首页 > 代码库 > Lua 语言

Lua 语言

快捷注释: 

- -[[

print(10) - ->10  - - 不起作用(因为这是注释)

- -]]

 

当重新启用这段代码时,只需在一次行行首添加一个连接字符即可:

- - -[[

print(10) - ->10  - - 10

- -]]

 

 

 

全局变量:

全局变量不需要声明,只需将一个值赋予一个全局变量就可以创建了, 在Lua中,访问一个未初始化的变量不会引发错误,访问结果是一个特殊的值 nil ,

 print(b)  - -> nil

 b=10

print(b) - ->10

通常没有必要删除一个全局变量,如果一个变量只有较短的生存周期,那么久应该使用局部变量。但是,诶果一定要删除某个全局变量的话,只需要将其赋值为nil

b=nil

print(b)=nil

 

 

字符串:

指字符的序列。lua是8位字节,所以字符串可以包含任何数值字符,包括嵌入的0。这意味着你可以存储任意的二进制数据在一个字符串里。Lua中字符串是不可以修改的,你可以创建一个新的变量存放你要的字符串,如下:

a = "one string"

b = string.gsub(a, "one", "another")   -- 修改字符串的一部分

print(a)          --> one string

print(b)          --> another string

 

string和其他对象一样,Lua自动进行内存分配和释放,一个string可以只包含一个字母也可以包含一本书,Lua可以高效的处理长字符串,1M的string在Lua中是很常见的。可以使用单引号或者双引号表示字符串

a = "a line"

b = ‘another line‘

 

为了风格统一,最好使用一种,除非两种引号嵌套情况。对于字符串中含有引号的情况还可以使用转义符\来表示。Lua中的转义序列有:

\a bell 响铃  

\b back space               -- 后退

\f form feed                -- 换页

\n newline                  -- 换行

\r carriage return          -- 回车

\t horizontal tab           -- 制表

\v vertical tab

\\ backslash                 -- "\"

\" double quote             -- 双引号

\‘ single quote             -- 单引号

\[ left square bracket      -- 左中括号

\] right square bracket     -- 右中括号

例子:

> print("one line\nnext line\n\"in quotes\", ‘in quotes‘")

one line

next line

"in quotes", ‘in quotes‘

> print(‘a backslash inside quotes: \‘\\\‘‘)

a backslash inside quotes: ‘\‘

> print("a simpler way: ‘\\‘")

a simpler way: ‘\‘

 

 

运行时,Lua会自动在string和numbers之间自动进行类型转换,当一个字符串使用算术操作符时,string就会被转成数字。

print("10" + 1)             --> 11

print("10 + 1")             --> 10 + 1

print("-5.3e - 10" * "2")   --> -1.06e-09

print("hello" + 1)          -- 错误(不能转换为”hello”)

 

反过来,当Lua期望一个string而碰到数字时,会将数字转成string。

print(10 .. 20)      --> 1020

 

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

 

尽管字符串和数字可以自动转换,但两者是不同的,像10 == "10"这样的比较永远都是错的。如果需要显式将string转成数字可以使用函数tonumber(),如果string不是正确的数字该函数将返回nil。

line = io.read()         -- 读取一行

n = tonumber(line)       -- 尝试将它转换为一个数字

if n == nil then

    error(line .. " is not a valid number")

else

    print(n*2)

end

反之,可以调用tostring()将数字转成字符串,这种转换一直有效:

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

print(10 .. "" == "10")         --> true   这样的转换是合法的

 

在Lua 5.1中,可以在字符串前放置操作符 ”#“ ,这样可以获得该字符串的长度

A = “hello”

print(#A)    - -> 5

print(#”good\0bye”)  - -> 8

 

 

 

Lua的逻辑操作符

逻辑操作符有 and、or 和 not 。与条件控制语句一样,所有的逻辑操作符将 false 和 nil 视为假,而将其他的任何东西视为真。对于操作符 and 来说,如果它的第一个操作数为假,就返回第一个操作数;不然就返回第二个操作数。对于操作符 or 来说,如果它的第一个操作数为真,就返回第一个操作数,不然就返回第二个操作数

a and b       -- 如果a为false,则返回a,否则返回b

a or  b        -- 如果a为true,则返回a,否则返回b

例如:

print(4 and 5)           --> 5

print(nil and 13)        --> nil

print(false and 13)      --> false

print(4 or 5)            --> 4

print(false or 5)        --> 5

 

连接运算符

 

..         --两个点

字符串连接,如果操作数为数字,Lua将数字转成字符串。

print("Hello " .. "World")      --> Hello World

print(0 .. 1)                   --> 01

 

 

 

table 构造试

构造器是创建和初始化表的表达式。表是Lua特有的功能强大的东西。最简单的构造函数是{},用来创建一个空表。可以直接初始化数组:

 例如:days = {"Sunday", "Monday", "Tuesday", "Wednesday",

              "Thursday", "Friday", "Saturday"}

Lua将"Sunday"初始化days[1](第一个元素索引为1),用"Monday"初始化days[2]...

print(days[4])       --> Wednesday

 

    Lua还提供了一种特殊的语法用于初始化记录风格的table

a = {X=10,y=20}   等价于  a={ }; a.x = 10; a.y = 20

 

不管用何种方式创建table,我们都可以向表中添加或者删除任何类型的域,构造函数仅仅影响表的初始化。

w = {x=0, y=0, label="console"}

x = {sin(0), sin(1), sin(2)}

w[1] = "another field"    - - 添加key 1 到 table w

x.f = w - - 添加key “f” 到 table x

print(w["x"])     --> 0

print(w[1])       --> another field

print(x.f[1])     --> another field

w.x = nil         -- 删除字段 "x"

 

每当Lua调用构造函数,Lua都会创建一个新的table,然后初始化它,这样,就能用table写出以下的链接代表码,可以使用table构造一个list:

list = nil

for line in io.lines() do

    list = {next=list, value=http://www.mamicode.com/line}

end

 

 

这段代码从标准输入读进每行的内容,然后将每行按相反的次序存储到一个链表中。链表的每一个节点都是一个table,table 中含有两个字段:value(没行的内容)和 nex(指向下一个节点的引用)。下面的代码打印链表的内容:

l = list

while l do

    print(l.value)

    l = l.next

end

 

 

在同一个构造函数中可以混合列表风格和record风格进行初始化,如:

polyline = {

color="blue", thickness=2, npoints=4,

              {x=0,   y=0},

              {x=-10, y=0},

              {x=-10, y=1},

              {x=0,   y=1}

  }

这个例子也表明我们可以嵌套构造函数来表示复杂的数据结构.

print(polyline[2].x)     --> -10

print(polyline[4].y)     --> -1

 

 

这两种风格的构造式各有其限制,例如 不能使用负数的索引,也不能用运算符作为记录的字段名,为了满足这些要求,Lua还提供了一种更通用的表达格式。这种格式允许在方括号之间,显式地用一个表达式来初始化索引值:

opnames = {["+"] = "add", ["-"] = "sub",

              ["*"] = "mul", ["/"] = "div"}

 

i = 20; s = "-"

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

 

print(opnames[s])    --> sub

print(a[22])         --> ---

 

如果真的想要数组下标从0开始:

days = {[0]="Sunday", "Monday", "Tuesday", "Wednesday",

              "Thursday", "Friday", "Saturday"}

注意:不推荐数组下标从0开始,否则很多标准库不能使用。

在构造函数的最后的","是可选的,可以方便以后的扩展。

a = {[1]="red", [2]="green", [3]="blue",}

在构造函数中域分隔符逗号(",")可以用分号(";")替代,通常我们使用分号用来分割不同类型的表元素。

{x=10, y=45; "one", "two", "three"}

 

 

 

 

赋值语句

 

赋值是改变一个变量的值和改变表域的最基本的方法。

  a = "hello" .. "world"

  t.n = t.n + 1

Lua可以对多个变量同时赋值,变量列表和值列表的各个元素用逗号分开,赋值语句右边的值会依次赋给左边的变量。

  a, b = 10, 2*x       <-->       a=10; b=2*x

遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作,所以我们可以这样进行交换变量的值:

  x, y = y, x                     -- 交换 ‘x‘ for ‘y‘

  a[i], a[j] = a[j], a[i]         -- 交换3 ‘a[i]‘ for ‘a[i]‘

当变量个数和值的个数不一致时,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。

 

Lua 语言