发布于 

Lua基础语法

注释

  • 单行注释
    两个减号,--
  • 多行注释
    --[[ 内容 --]]

    数据类型

  • Lua是动态类型语言,变量不需要类型定义,只需为变量赋值
数据类型 描述
nil 只有值”nil”属于该类,表示一个无效值(在条件表达式里相当于false)
boolean false 和 true
number 双精度类型的实浮点数
string 由一对双引号" "或单引号' '表示
function 由C或Lua编写的函数
userdata 表示任意存储在变量中的C数据结构
thread 表示执行的独立线路
table Lua 中的表(table)其实是一个”关联数组”(associative arrays),数组的索引可以是数字或者是字符串。在 Lua 里,table 的创建是通过”构造表达式”来完成,最简单构造表达式是{},用来创建一个空表。

nil

  • nil类型表示一种没有任何有效值,它只有一个值”nil”
  • 对于全局变量和table,nil的另外一个作用为删除,给全局变量或table表里的变量赋值nil,等于把它们删掉

    boolean

  • Lua把false和nil看作“假”,其余为“真”

    number

  • Lua默认只有一种number类型,即double(双精度)类型,默认类型可以修改luaconf.h里的定义。以下几种写法都是number类型
    >print(type(2))
    >print(type(2.2))
    >print(type(0.2))
    >print(type(2e+1))
    >print(type(0.2e-1))
    >print(type(7.8263692594256e-06))

    number
    number
    number
    number
    number
    number

string

  • 由一对双引号" "或单引号' '表示
  • 两个方括号[[ ]]表示一块字符串

    >html = [[
    <html>
    <head></head>
    <body>
    <a href="http://www.w3cschool.cc/">w3cschool菜鸟教程</a>
    </body>
    </html>
    ]]
    print(html)

    <html>
    <head></head>
    <body>
    <a href="http://www.w3cschool.cc/">w3cschool菜鸟教程</a>
    </body>
    </html>
  • 在对一个数字字符串上进行算术操作时,Lua会将数字字符串转成一个数字

    > print("2" + 6)
    8.0
    > print("2" + "6")
    8.0
    > print("2 + 6")
    2 + 6
    > print("-2e2" * "6")
    -1200.0
    > print("error" + 1)
    stdin:1: attempt to perform arithmetic on a string value
    stack traceback:
    stdin:1: in main chunk
    [C]: in ?
    >
  • 字符串连接需要用..,需加上空格

    >print('a' .. 'b')
    ab

    >print(157 .. 333)
    157333
  • 使用#计算字符串的长度,放在字符串前面

    >len='www.w3cshool.cc'
    >print(#len)
    16
    >print(#'www.w3cschool.cc')
    16

table


local table1={}

--初始表
local table2={'apple','pear','orange','grape'}
  • Lua中的table是一个”关联数组”,数组的索引可以数字或字符串
    【注】Lua中table 默认初始索引从1开始
    a={}
    a['key']='value'
    key=10
    a[key]=22
    a[key]=a[key]+11

    for k,v in ipairs(a) do
    print(k .. ':' .. v)
    end

    结果
    key:value
    10:33

function

  • 在Lua中,function被看作是”第一类值(First-Class Value)”,函数可以存在变量里
function (n)
if n==0 then
return 1
else
return n*factorial1(n-1)
end
end

print(factorial1(5))

factorial2=factorial1
print(fatorial2(5))

结果
120
120

userdata

userdata 是一种用户自定义数据,用于表示一种由应用程序或 C/C++ 语言库所创建的类型,可以将任意 C/C++ 的任意数据类型的数据(通常是 struct 和 指针)存储到 Lua 变量中调用。

变量

  • 变量在使用前,必须在代码中进行声明,即创建该变量。
  • Lua 变量有三种类型:全局变量、局部变量、表中的域
  • 变量的默认值均为 nil。

标识符

  • 一般用下划线加大写字母的标识符,为Lua的保留字。如:_VERSION 为保留用于Lua内部全局变量
  • 区分大小写

    全局变量

  • 默认是全局变量
  • 全局变量无需声明,给一个变量赋值后即创建了这个全局变量,访问一个没有初始化的全局变量也不会出错,得到的结果为:nil

    print(b)
    >nil
    b=10
    print(b)
    >10
  • 删除一个全局变量,将变量赋值为nil即可

    b=nil
    print(b)
    >nil

局部变量

使用local声明
应该尽可能的使用局部变量,有两个好处:

  1. 避免命名冲突。
  2. 访问局部变量的速度比全局变量更快。

    赋值语句

  • 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会一直以变量个数为基础采取以下策略:

  1. 变量个数 > 值的个数 按变量个数补足nil
  2. 变量个数 < 值的个数 多余的值会被忽略
>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=fun()

f()返回两个值,第一个赋给a,第二个赋给b。

循环

while

while(condition)
do
statements
end

for

Lua中for语句有两大类:

  • 数值for循环
  • 泛型for循环

数值for循环

for var=exp1,exp2,exp3 do
statements
end
  • var从exp1变化到exp2,每次变化以exp3为步长递增var,并执行一次”执行体”。exp3是可选的,如果不指定,默认为1
  • for的三个表达式在循环开始前一次性求值,以后不再进行求值。

    泛型for循环

    用过一个迭代器遍历所有值
    --打印数组a 的所有值
    for i,v in ipairs(a)
    do print(v)
    end

i是数组索引值,v是对应索引的数组元素值。ipairs是Lua提供的一个迭代器函数,用来迭代数组。

days={"Suanday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}

for i,v in ipairs(days) do
print(v)
end


结果
Suanday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

repeat…until

Lua 编程语言中 repeat…until 循环语句不同于 for 和 while循环,for 和 while 循环的条件语句在当前循环执行开始时判断,而 repeat…until 循环的条件语句在当前循环结束后判断。

repeat
statements
until(contidion)

我们注意到循环条件判断语句(condition)在循环体末尾部分,所以在条件进行判断前循环体都会执行一次。

函数

函数作为参数

Lua 中我们可以将函数作为参数传递给函数

myprint = function(param)
print("这是打印函数 - ##",param,"##")
end

function add(num1,num2,functionPrint)
result = num1 + num2
-- 调用传递的函数参数
functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

结果
这是打印函数 - ## 10 ##
这是打印函数 - ## 7 ##

多返回值

  • Lua可以返回多个结果值,如string.find,返回匹配串“开始和结束的下标”(如果不存在匹配串返回nil)

    >s,e=string.find('www.runoob.com','runoob')
    >print(s,e)

    5 10
  • Lua函数中,在return后列出要返回的值得列表即可返回多值

function maximum(a)
local mi=1 --最大值索引
local m=a[mi] --最大值

for i,val in ipairs(a) do
if val > m then
mi=i
m=val
end
end
return m,mi
end

print(maximum({8,10,23,12,5}))


结果
23 3
  • return f()这种形式,则返回“f()的返回值”:

    function foo0() end
    function foo1() return 'a' end
    function foo2() return 'a','b' end

    function foo(i)
    if i==0 then return foo0()
    elseif i==1 then return foo1()
    elseif i==2 then return foo2()
    end
    end

    >print(foo(1))
    a
    >print(foo(2))
    a b
    >print(foo(0))
    --(no result)
    >print(foo(3))
    --(no result)
  • 可以使用圆括号( )强制使调用返回一个值

    >print((foo0()))
    nil
    >print((foo1()))
    a
    >print((foo2()))
    a
  • 函数多值返回的特殊函数unpack,接受一个数组作为输入参数,返回数组的所有元素。unpack被用来实现范型调用机制,在C语言中可以使用函数指针调用可变的函数,可以声明参数可变的函数,但不能两者同时可变。在Lua中如果你想调用可变参数的可变函数只需要这样:
    f(unpack(a))
    unpack返回a所有的元素作为f()的参数

    f=string.find
    a={'hello','ll'}
    print(f(unpack(a)))

    -->3 4

预定义的unpack函数是用C语言实现的,也可以用Lua实现

function unpack(t,i)
i= i or 1
if t[i] then
return t[i],unpack(t,i+1)
end
end

可变参数

  • Lua函数可以接受可变数目的参数,和C语言类似在函数参数列表中使用三点(…) 表示函数有可变的参数。
  • Lua将函数的参数放在一个叫arg的表中,#arg 表示传入参数的个数。
    function average(...)
    result = 0
    local 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

再论函数

Lua中的函数是带有词法定界(lexical scoping)的第一类值(first-class value)

第一类值

在Lua中函数和其他值(数值、字符串)一样,函数可以被存放在变量中,也可以存放在table中,可以作为函数的参数,还可以作为函数的返回值

词法定界

嵌套的函数可以访问它外部函数中的变量

  • Lua中关于函数难以理解的地方时函数也可以是匿名的。
    函数名(如print)实际上是一个指向函数的变量,像具有其他类型值的变量一样
    a={p=print}
    a.p('hello world') -->hello world

    print=math.sin -- print now refers to the sin function

    a.p(print(1)) -->0.841470

    sin=a.p --sin now refers to the print function
    sin(10,20) -->10 20

闭包

当一个函数内部嵌套另一个函数定义时,内部的函数体可以访问外部的函数的局部变量,这种特征我们称作词法定界。虽然这看起来很清楚,事实并非如此,词法定界加上第一类函数在编程语言里是一个功能强大的概念,很少语言提供这种支持。
下面看一个简单的例子,假定有一个学生姓名的列表和一个学生名和成绩对应的表;现在想根据学生的成绩从高到低对学生进行排序,可以这样做:

names={'Peter','Paul','Mary'}
grades={Mary=10,Paul=7,Peter=8}
table.sort(names,function (n1,n2)
return grades[n1]>grades[n2]
end)

假定创建一个函数实现此功能

function sortByGrade(names,grades)
table.sort(names,function(n1,n2)
return grades[n1]>grades[n2]
end)
end

例子中包含在sortbygrade函数内部的sort中的匿名函数可以访问sortbygrade的参数grades,在匿名函数内部grades不是全局变量也不是局部变量,我们称作外部的局部变量(external local variable)或者upvalue。(upvalue意思有些误导,然而在Lua中他的存在有历史的根源,还有他比起external local variable简短)。

function newCounter()
local i = 0
return function() -- anonymous function
i = i + 1
return i
end
end