路漫漫其修远兮
吾将上下而求索

nginx学习:lua基础语法学习

参考教程:http://www.runoob.com/lua/lua-tutorial.html

安装=====================================
Linux 系统上安装
Linux & Mac上安装 Lua 安装非常简单,只需要下载源码包并在终端解压编译即可,本文使用了5.3.0版本进行安装:
curl -R -O http://www.lua.org/ftp/lua-5.3.0.tar.gz
tar zxf lua-5.3.0.tar.gz
cd lua-5.3.0
make linux test
make install

执行程序,交互式编程
[root@master-10 ~]#lua
Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio
> print("hello world")
hello world

执行程序,脚本编程
[root@master-10 ~]#cat a.lua 
print("hello world")
[root@master-10 ~]#lua a.lua 
hello world

基本语法=====================
单行注释
两个减号是单行注释:
--

多行注释
--[[
 多行注释
 多行注释
 --]]


变量名
最好不要使用下划线加大写字母的标示符,因为Lua的保留字也是这样的,Lua 是一个区分大小写的编程语言


全局变量
在默认情况下,变量总是认为是全局的。
全局变量不需要声明,给一个变量赋值后即创建了这个全局变量,访问一个没有初始化的全局变量也不会出错,只不过得到的结果是:nil。
> print(b)
nil
> b=10
> print(b)
10
> 
如果你想删除一个全局变量,只需要将变量赋值为nil。
b = nil
print(b)      --> nil
这样变量b就好像从没被使用过一样。换句话说, 当且仅当一个变量不等于nil时,这个变量即存在。


数据类型================================
我们可以使用type函数测试给定变量或者值的类型:
print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string


nil(空)
[root@master-10 ~]#cat a.lua 
tab1 = {key1="val1", key2="val2"}

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end

tab1.key1 = nil

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end
[root@master-10 ~]#lua a.lua 
key1 - val1
key2 - val2
key2 - val2


当table中是数组的形式的时候,如果只取一个值,取出来的是数组的坐标
[root@master-10 ~]#cat a.lua 
tab1 = {"val1", "val2"}

for k in pairs(tab1) do
    print(k)
end

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end
[root@master-10 ~]#lua a.lua 
1
2
1 - val1
2 - val2


nil 作比较时应该加上双引号 ":
> type(X)
nil
> type(X)==nil
false
> type(X)=="nil"
true
> 


boolean 类型只有两个可选值:true(真) 和 false(假),Lua 把 false 和 nil 看作是"假",其他的都为"真":
[root@master-10 ~]#cat a.lua 
print(type(true))
print(type(false))
print(type(nil))

if false or nil then
    print("at least one is true")
else
    print("false and nil is false")
end

[root@master-10 ~]#lua a.lua 
boolean
boolean
nil
false and nil is false


字符串由一对双引号或单引号来表示。
string1 = "this is string1"
string2 = 'this is string2'
也可以用 2 个方括号 "[[]]" 来表示"一块"字符串。
[root@master-10 ~]#cat a.lua 
html = [[
<html>
<head><head>
<body>
    <a href="http://baidu.com">hello</a>
</body>
</html>
]]

print(html)

[root@master-10 ~]#lua a.lua 
<html>
<head><head>
<body>
    <a href="http://baidu.com">hello</a>
</body>
</html>

字符串连接使用的是 .. ,如:
> print("a" .. 'b')
ab
> print(157 .. 428)
157428
> 


在对一个数字字符串上进行算术操作时,Lua 会尝试将这个数字字符串转成一个数字:
> print("2" + 6)
8.0
> print("2" + "6")
8.0
> print("2 + 6")
2 + 6
> print("-2e2" * "6")
-1200.0


使用 # 来计算字符串的长度,放在字符串前面,如下实例:
> len = "www.runoob.com"
> print(#len)
14
> print(#"www.runoob.com")
14
> 



table的示例
[root@master-10 ~]#cat a.lua 
a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k,v in pairs(a) do
    print(k .. " - " .. v)
end

[root@master-10 ~]#lua a.lua 
key - value
10 - 33


[root@master-10 ~]#cat a.lua 
tab1 = {key1="val1", key2="val2"}

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end

tab1.key1 = nil

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end
[root@master-10 ~]#lua a.lua 
key1 - val1
key2 - val2
key2 - val2


当table中是数组的形式的时候,如果只取一个值,取出来的是数组的坐标
不同于其他语言的数组把 0 作为数组的初始索引,在 Lua 里表的默认初始索引一般以 1 开始。
[root@master-10 ~]#cat a.lua 
tab1 = {"val1", "val2"}

for k in pairs(tab1) do
    print(k)
end

for k,v in pairs(tab1) do
    print(k .. " - " .. v)
end
[root@master-10 ~]#lua a.lua 
1
2
1 - val1
2 - val2



在 Lua 中,函数是被看作是"第一类值(First-Class Value)",函数可以存在变量里:
[root@master-10 ~]#cat a.lua 
function f(n)
    if n==0 then
        return 1
    else
        return n *f(n-1)
    end
end

print(f(4))
f2=f
print(f2(4))

[root@master-10 ~]#lua a.lua 
24
24



变量========================
变量在使用前,必须在代码中进行声明,即创建该变量。
Lua 变量有三种类型:全局变量、局部变量、表中的域。
Lua 中的变量全是全局变量,那怕是语句块或是函数里,除非用 local 显式声明为局部变量。
局部变量的作用域为从声明位置开始到所在语句块结束。
变量的默认值均为 nil。

[root@master-10 ~]#cat a.lua 
a = 5
local b = 5

function joke()
    c = 5
    local d = 6
end

joke()
print(c,d)

do 
    local a = 6
    b = 6
    print(a,b)
end

print(a,b)
[root@master-10 ~]#lua a.lua 
5	nil
6	6
5	6


赋值语句
赋值是改变一个变量的值和改变表域的最基本的方法。
a = "hello" .. "world"
t.n = t.n + 1 

Lua可以对多个变量同时赋值,变量列表和值列表的各个元素用逗号分开,赋值语句右边的值会依次赋给左边的变量。
a, b = 10, 2*x       <-->       a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作,所以我们可以这样进行交换变量的值:
x, y = y, x                     -- swap 'x' for 'y'
a[i], a[j] = a[j], a[i]         -- swap 'a[i]' for 'a[j]'

当变量个数和值的个数不一致时,Lua会一直以变量个数为基础采取以下策略:
a. 变量个数 > 值的个数             按变量个数补足nil
b. 变量个数 < 值的个数             多余的值会被忽略
例如:
a, b, c = 0, 1
print(a,b,c)             --> 0   1   nil
a, b = a+1, b+1, b+2     -- value of b+2 is ignored
print(a,b)               --> 1   2
a, b, c = 0
print(a,b,c)             --> 0   nil   nil

上面最后一个例子是一个常见的错误情况,注意:如果要对多个变量赋值必须依次对每个变量赋值。
a, b, c = 0, 0, 0
print(a,b,c)             --> 0   0   0

多值赋值经常用来交换变量,或将函数调用返回给变量:
a, b = f()
f()返回两个值,第一个赋给a,第二个赋给b。

应该尽可能的使用局部变量,有两个好处:
1. 避免命名冲突。
2. 访问局部变量的速度比全局变量更快。


索引,下面两种方式调用字典都是一样的结果,两张方式都可以
对 table 的索引使用方括号 []。Lua 也提供了 . 操作。
t[i]
t.i                 -- 当索引为字符串类型时的一种简化写法
gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用

例如:
> site = {}
> site["key"] = "www.w3cschool.cc"
> print(site["key"])
www.w3cschool.cc
> print(site.key)
www.w3cschool.cc



流程控制=============================
Lua 编程语言流程控制语句通过程序设定一个或多个条件语句来设定。在条件为 true 时执行指定程序代码,在条件为 false 时执行其他指定代码。

Lua认为false和nil为假,true和非nil为真。
要注意的是Lua中 0 为 true:

[root@master-10 ~]#cat a.lua 
--[ 定义变量 --]
a = 100;
b = 200;

--[ 检查条件 --]
if( a == 100 )
then
   --[ if 条件为 true 时执行以下 if 条件判断 --]
   if( b == 200 )
   then
      --[ if 条件为 true 时执行该语句块 --]
      print("a 的值为 100 b 的值为 200" );
   end
end
print("a 的值为 :", a );
print("b 的值为 :", b );
[root@master-10 ~]#lua a.lua 
a 的值为 100 b 的值为 200
a 的值为 :	100
b 的值为 :	200


--[ 定义变量 --]
a = 100

--[ 检查布尔条件 --]
if( a == 10 )
then
   --[ 如果条件为 true 打印以下信息 --]
   print("a 的值为 10" )
elseif( a == 20 )
then   
   --[ if else if 条件为 true 时打印以下信息 --]
   print("a 的值为 20" )
elseif( a == 30 )
then
   --[ if else if condition 条件为 true 时打印以下信息 --]
   print("a 的值为 30" )
else
   --[ 以上条件语句没有一个为 true 时打印以下信息 --]
   print("没有匹配 a 的值" )
end
print("a 的真实值为: ", a )



函数====================
需要设置函数为局部函数需要使用关键字 local。
Lua函数可以返回多个结果值,比如string.find,其返回匹配串"开始和结束的下标"(如果不存在匹配串返回nil)。
> s, e = string.find("www.runoob.com", "runoob") 
> print(s, e)
5    10


Lua 函数可以接受可变数目的参数,和 C 语言类似,在函数参数列表中使用三点 ... 表示函数有可变的参数
function add(...)  
local s = 0  
  for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组  
    s = s + v  
  end  
  return s  
end  
print(add(3,4,5,6,7))  --->25

我们可以将可变参数赋值给一个变量。
例如,我们计算几个数的平均值:
function average(...)
   result = 0
   local arg={...}    --> arg 为一个表,局部变量
   for i,v in ipairs(arg) do
      result = result + v
   end
   print("总共传入 " .. #arg .. " 个数")
   return result/#arg
end

print("平均值为",average(10,5,3,4,5,6))
以上代码执行结果为:

总共传入 6 个数
平均值为    5.5


运算符=======================
http://www.runoob.com/lua/lua-miscellaneous-operator.html


字符串=======================
里面的常用函数和正则匹配需要注意


数组=======================
在 Lua 索引值是以 1 为起始
多维数组即数组中包含数组或一维数组的索引键对应一个数组。
以下是一个三行三列的阵列多维数组:
[root@master-10 ~]#cat a.lua 
array = {}
for i=1,3 do
    array[i]={}
    for j=1,3 do
        array[i][j] = i*j
    end
end

for i=1,3 do
    for j=1,3 do
        print(array[i][j])
    end
end


[root@master-10 ~]#lua a.lua 
1
2
3
2
4
6
3
6
9


迭代器==================
好像用不到



table================
table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型,如:数组、字典等。
Lua table 使用关联型数组,你可以用任意类型的值来作数组的索引,但这个值不能是 nil。
Lua table 是不固定大小的,你可以根据自己需要进行扩容。
Lua也是通过table来解决模块(module)、包(package)和对象(Object)的。 例如string.format表示使用"format"来索引table string。

当我们为 table a 并设置元素,然后将 a 赋值给 b,则 a 与 b 都指向同一个内存。如果 a 设置为 nil ,则将a指针指向删除,但是 b 同
样能访问 table 的元素。如果没有指定的变量指向a,Lua的垃圾回收机制会清理相对应的内存。

[root@master-10 ~]#cat a.lua 
mytable = {}
print("mytable type ", type(mytable))

mytable[1] = "lua"
mytable["wow"] = "before change"
print("mytable index 1 is ", mytable[1])
print("mytable index wow is ", mytable["wow"])

alter = mytable

print("alter index 1 is ", alter[1])
print("alter index wow is ", alter["wow"])

alter["wow"] = "after change"
print("mytable index wow is ", mytable["wow"])

alter = nil
print("alter is ", alter)

print("mytable index wow is ", mytable["wow"])

mytable = nil
print("mytable is", mytable)

[root@master-10 ~]#lua a.lua 
mytable type 	table
mytable index 1 is 	lua
mytable index wow is 	before change
alter index 1 is 	lua
alter index wow is 	before change
mytable index wow is 	after change
alter is 	nil
mytable index wow is 	after change
mytable is	nil


table的一些常用的操作
Table 排序
以下实例演示了 sort() 方法的使用,用于对 Table 进行排序:
[root@master-10 ~]#cat a.lua 
fruits = {"banana", "orange", "apple", "haha"}

for k,v in ipairs(fruits) do
    print(k,v)
end

table.sort(fruits)

for k,v in ipairs(fruits) do
    print(k,v)
end

[root@master-10 ~]#lua a.lua 
1	banana
2	orange
3	apple
4	haha
1	apple
2	banana
3	haha
4	orange


模块和包
Lua 的模块是由变量、函数等已知元素组成的 table,因此创建一个模块很简单,就是创建一个 table,然后把需要导出的常量、函数放入其中,最后返回这个 table 就行。
[root@master-10 ~/abc]#cat module.lua 
module = {}

module.constant = "this is a text"

function module.func1()
    io.write("this is a public function")
end

local function func2()
    print('this is a private function')
end

function module.func3()
    func2()
end

return module

[root@master-10 ~/abc]#cat test_module.lua 
require("module")

print(module.constant)

module.func3()

[root@master-10 ~/abc]#lua test_module.lua 
this is a text
this is a private function

未经允许不得转载:江哥架构师笔记 » nginx学习:lua基础语法学习

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址