Lua基础语法

topic
6.4k 词

注释

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

    数据类型

  • 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