lua基础(一)

来源：互联网发布：淘宝数据真实数据编辑：程序博客网时间：2024/04/28 20:11

最近在学习unity的热更,看了下 lua 基础,看了这位博主转载的文章觉得还不错,保存下来,方便以后回顾

原文地址:http://blog.csdn.net/lyh916/article/details/49719697

一.注释

[plain] view plain copy
--这是行注释  
  
--[[  
这是块注释  
这是块注释  
这是块注释  
--]]  
  
--如果想取消块注释，只需将 --[[ 改为 ---[[  

二.类型与值

[plain] view plain copy
--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-----换行 \\-----反斜杠 \"-----双引号 \'-----单引号

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

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

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

[plain] view plain copy
--字符串转数字  
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的创建是通过构造表达式完成的。最简单的构造表达式就是{}

[plain] view plain copy
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  

[plain] view plain copy
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的引用了  

[plain] view plain copy
a = {}  
x = "y"  
a[x] = 10  
print(a[x])    --10  
print(a.x)     --nil  
print(a.y)     --10  
  
--a.x等同于a["x"]  

[plain] view plain copy
--若要表示一个传统的数组或者线性表，只需以整数作为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的最大正索引数。

[plain] view plain copy
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有三种方式进行初始化：

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

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

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

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

混合使用：

[plain] view plain copy
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  

[plain] view plain copy
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])          --+++  

四,语句

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

[plain] view plain copy
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  

局部变量与块：

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

[plain] view plain copy
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时，才会执行整个块的内容。

控制结构：

[plain] view plain copy
--------------------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与其他语言类似，所以省略  

1 0