一.注释

--这是行注释

--[[
这是块注释
这是块注释
这是块注释
--]]

--如果想取消块注释,只需将 --[[ 改为 ---[[


二.类型与值

--lua有8种基础类型:nil/boolean/number/string/userdata/function/thread/table
--即空/布尔/数字/字符串/自定义类型/函数/线程/表
--函数type可根据一个值返回其类型名称

print(type("Hello World"))      --string
print(type(10))                 --number
print(type(print))              --function
print(type(type))               --function
print(type(true))               --boolean
print(type(nil))                --nil
print(type(type(X)))            --string 因为type函数总是返回一个字符串


--变量没有预定义的类型,任何变量都可以包含任何类型的值

print(type(a))                  --nil
a = 10
print(type(a))                  --number
a = "Hello"
print(type(a))                  --string
a = print                       --函数是一种类型
a(type(a))                      --function



nil:它只有一个值nil,作用类似于其他语言的null,可以将nil赋予一个变量表示删除这个变量

boolean:取值为true或者false。在lua中,false和nil表示假,除此之外的其他值为真

number:表示双精度浮点数(double)


string:字符串是不可变的值,不能直接修改字符串中的某个字符,若要修改,则要新建一个新的字符串。

字符串由一对单引号或者一对双引号来表示:a = "a line"        b = 'another line'

常用的转义字符:\n-----换行     \\-----反斜杠     \"-----双引号     \'-----单引号

另外,还可以用一对匹配的双方括号来表示一个字符串,这时将会忽视转义字符:

page = [[
<html>
<head>
<title>an html page</title>
</head>
<body>
<a href="http://www.lua.org">Lua</a>
</body>
</html>
]]
print(page)


lua还提供了运行时的数字与字符串的自动转换:

--字符串转数字
print("10" + 1)       --11
print("10" + "1")     --11

--数字转字符串
print(10)             --10
print(10 .. 20)       --1020 

--..是字符串连接操作符,当直接在一个数字后面输入它时,
--必须要用一个空格来分隔它们,不然lua会将第一个点理解为小数点


--比较10=="10"总为false,因为10是数字,"10"是字符串
--以上是隐式转换,使用tonumber/tostring可以显示转换

print(tostring(10) == "10")     --true
print(10 .. "" == "10")         --true


--#可以换取字符串的长度
a = "hello"
print(#a)                       --5




table:类似于哈希表。table中的key可以是任何类型的值(除了nil)。table的创建是通过构造表达式完成的。最简单的构造表达式就是{}

a = {}                --创建一个table,并将它的引用存储到a
k = "x"
a[k] = 10             --key="x",value=10
a[20] = "great"       --key=20,value="great"

print(a["x"])         --10
print(a[20])          --great
a["x"] = a["x"] + 1
print(a["x"])         --11



a = {}                --创建一个table,并将它的引用存储到a
a["x"] = 10
b = a                 --b与a引用了同一个table

print(b["x"])         --10
b["x"] = 20
print(a["x"])         --20
a = nil               --现在只有b还在引用table
b = nil               --再也没有对table的引用了



a = {}
x = "y"
a[x] = 10
print(a[x])    --10
print(a.x)     --nil
print(a.y)     --10

--a.x等同于a["x"]



--若要表示一个传统的数组或者线性表,只需以整数作为key来使用table即可
--不同于许多语言,lua习惯以1作为数组开始
a = {}
for i = 1,5 do
	a[i] = i
end

--#长度操作符,可获取table或者字符串的长度
for i = 1,#a do
	print(a[i]);             --1到5
end

--注意是以1作为数组开始
print(a[#a])                 --5
a[#a] = nil                  --删除a[5]
a[#a+1] = 10                 --a[5]=10
print(a[#a])                 --10



请记住对于所有未初始化的元素的索引结果都是nil。lua将nil作为界定数组结尾的标志。如果数组中含有nil,此时使用#就不安全了,可以使用table.maxn,它将返回一个table的最大正索引数。


a = {}
for i = 1,5 do
	a[i] = i
end

a[4] = nil
print(#a)               --3
print(table.maxn(a))    --5


function、userdata和thread暂略,后面再提。


三.表达式

lua的操作符跟c大致相同,除了以下的:

其他语言

lua

!=

~=

&&

and

||

or

!

not


注意:


and:如果第一个操作数为假,则返回第一个操作数;否则返回第二个操作数。

or:如果第一个操作数为真,则返回第一个操作数;否则返回第二个操作数。

table构造式:

table有三种方式进行初始化:

1.

days = {"Sunday","Monday","Tuseday"}

上面只指定了value,但没有指定key。这种情况下,lua会给没有key的value指定一个默认的key,从1开始,每次加1递增。

days = {"Sunday","Monday","Tuseday"}
print(days[0])    --nil
print(days[1])    --Sunday
print(days[2])    --Monday



2.

a = {x = 10,y = 20}     --等价于a={};a.x=10;a.y=20
print(a["x"])           --10
print(a["y"])           --20


混合使用:

polyline = {color="blue",thickness=2,npoints=4,
{x=10,y=20},
{x=30,y=40},
{x=50,y=60},
{x=70,y=80},
}
print(polyline[2].x)     --30
print(polyline[4].y)     --80



3.

opnames = {
["+"] = "add",
["-"] = "sub",
["*"] = "mul",
["/"] = "div",
}

i = 20;s = "+"
a = {
[i+0] = s,
[i+1] = s..s,
[i+2] = s..s..s,
}

print(opnames[s])     --add
print(a[22])          --+++



四,语句

多重赋值:将多个值赋予多个变量

a,b = 10,20
print(a)           --10
print(b)           --20

--在多重赋值中,lua先对等号右边的所有元素求值,然后才执行赋值
--利用这个特性,可以很好地实现变量的值交换

a,b = b,a
print(a)           --20
print(b)           --10

--若值的个数少于变量的个数,那么多余的变量会被赋值为nil
--若值的个数多于变量的个数,那么多余的值会被丢弃

a,b,c = 1,2
print(a,b,c)       --1 2 nil
a,b,c = 10,20,30,40
print(a,b,c)       --10 20 30


局部变量与块:

与全局变量不同的是,局部变量的作用域仅限于声明它们的那个块。一个块是一个控制结构的执行体、或者是一个函数的执行体再或者是一个程序块。

x = 10               --全局变量
local i = 1          --局部变量

while i <= x do
local x = i * 2
print(x)             --2,4,6。。。
i = i + 1
end

if(i > 20) then
local x = 20
print(x + 2)
else
print(x)              --10,全局变量
end

print(x)              --10,全局变量

请注意,如果是在交互模式中输入这段代码的话,该示例可能不会如预期的那样工作。因为在交互模式中每行输入内容自身就形成了一个程序块。一旦输入了本例的第二行local i = 1 ,lua会马上运行这句话,并为下一行的运行开启一个新的程序块。到那时local声明就已经超出其作用域。为了解决这个问题,可以显式地界定一个块,只需将这些内容放入一对do-end中即可。当输入了do,lua就不会单独地执行后面每行的内容,而是直至遇到一个相应的end时,才会执行整个块的内容。


如下所示,在函数中,a_str是局部变量,_G.a_str是全局变量。

local a_str = "aa_str"
A = {}
A.fun = function ()
	print(a_str) --aa_str
	print(_G.a_str) --nil
end
A.fun()




控制结构:

--------------------if----------------
a = 70

if (a < 100 and a >= 80) then
print("A")
elseif (a < 80 and a >= 60) then
print("B")
else
print("C")
end

--------------------while----------------
local i = 1
while (i <= 3) do
	print(i)
	i = i + 1
end

--------------------repeat----------------至少执行一次循环体
local i = 10
repeat
i = i + 1
print(i)
until (i > 13)

--------------------数字型for----------------
for i = 100,103,1 do    --100到103,步长为1,其中步长可以省略,默认步长为1
print(i)                --for的三个值是循环前一次性求值的
end                     --控制变量在循环结束后就不存在了


--------------------泛型for----------------
a = {"one","two","three"}
for i,v in ipairs(a) do            --i为索引值,v为对应元素值
print("第"..i.."个元素为"..v)
end


b = {x="xx",y="yy",z="zz"}
for k,v in pairs(b) do
print("键  "..k.."  值  "..v)
end


--标准库提供了几种迭代器,包含用于迭代文件中每行的io.lines
--迭代数组的ipairs,迭代table的pairs,迭代字符串中单词的string.gmatch

--lua中的break和return与其他语言类似,所以省略