【Lua】详解Lua基础，类型，范围，函数，操作符

变量

变量是标签，即给程序能读取或修改的数据一个名字。你可以就把它当做标签。

比如说有一些有不同颜色果酱的罐子，但是不知道它们的味道。可以贴一个标签在罐子上，并写明它们的味道。

这个标签能随时改变。

例如刚开始装的草莓酱，标签上就写“草莓酱”，等草莓酱吃完了，再装桃子酱，标签上就写“桃子酱”。标签还是同一个，但是标签上的内容是可以改的。

这是只有一个罐子，贴一个标签的情况。如果有多个罐子多个标签呢？

那要想说清楚罐子里有什么，就要说第一个罐子上的标签写的是醋，第二个罐子上的标签写的是酱油等。“第一个罐子上的标签”这一串其实就是第一个标签的名字，我们很自然的通过顺序给标签起名字区分不同的标签。但是这样很不方便，会出现如下场景：

对比可以看出，第一个和第二个标签换了位置，这个时候我们说的第一个标签上写的是酱油。但是此时第一个标签和上一次说的第一个标签却不是同一个了。

而且如果此时第二个标签的“醋”被改成“酱油”，那就完全区分不出第一个和第二个标签了。

如果我们要保存这种标签信息。我们可以给标签起一个名字，这样无论标签上的字改成什么，罐子的位置怎么改变都能区分出来。如下可以区分不同标签：

创建变量

创建变量需要做两件事：

• 声明一个变量
• 给变量赋予一个值

例如创建一个变量label1，赋予值“草莓酱”，就像这样：

label1 = "strawberry jam"

这行代码可以这样解释：

打印变量

怎么把变量的值显示到屏幕上呢？可以输入print，然后把变量名放在圆括号里（），语法如下：

print(<variable>)

上面的<variable>是一个可替代的字符串，用你自己定义的变量名替换掉它。如下：

foo = "bar"
print(foo)

上面的代码第一行创建了一个变量，名为foo，赋予了一个字符串“bar”给它。第二行打印（在屏幕上显示字）了变量的值在控制台（运行代码后显示的一个程序页面，通常是黑色的，类似Windows的cmd页面）上。

变量赋值

变量是描述数据（值）的，数据可能会改变。比如你想要一个叫“当前时间”的变量，你能猜到这个变量的值每秒都会改变。你可以用赋值符号（=，就是数学里的等于号，但是意义不是数学上的等于）把新的值赋予变量“当前时间”。

如下有一个叫“color”的变量，它的值就改变了3次：

color = "red"
color = "blue"
color = "green"

注释

–是两个横线-（或者说两个减号-），代表注释（两个横线及本行横线后的其它内容），注释的内容不会被识别为代码。注释，英文是comment，可以说就是评论，对代码的评论，可以解释代码是干什么的，或者随便聊聊天也行。

-- 把“bar”字符串赋予foo变量
foo = "bar" -- 这里也是注解的内容，两个横线前的是会被执行的代码
-- 也可以另起一行做注解
-- 这段代码看起来没什么用，而且注释比代码多得多

基础类型

每个值都有一个数据类型。

Lua支持8种基础数据类型：

• nil：缺失数据。这个类型表示字面上的没有任何东西。
• Boolean：布尔值，或者说真假值。
• number：实数，如-1，0，5, 3.14。
• string：字符串，一组字符。声明一串字面量，必须用引号围住。如’‘hello’'，‘world’。
• function：函数，能通过一个名字引用并执行的代码。
• table：表，包含使用键值对的信息。
• userdata：用C语言定义的复杂数据结构。
• thread：线程，能并发执行代码。

Lua是弱类型语言，这就是说变量可以有任意的类型。如果赋予了变量类型，还能被赋予其它类型。

nil

nil代表数据缺失，如果访问一个没有被创建的变量，它的值就是nil。

print(foo) -- nil

Boolean

仅有两个可选，为true或false。

foo = true
print(foo) -- true
print(5 > 6) -- false

number

Lua没有整数和小数之分，只有实数。

pi = 3.14
print(math.floor(pi)) -- 3，math.floor()向下取整
print(math.ceil(pi + 1)) -- 5，math.ceil()向上取整

查询类型

string type()，内置函数，返回变量的类型的字符串。

var1 = true
print(type(var1)) -- boolean
print(type(type(var1))) -- string

字符串类型

字面量（strkng literals）

必须用引号引起来，可以是单引号或双引号，前后必须匹配，如：

"hello"
'teacher'

字符长度

两种方式，string.len()，或在字符串前放一个#。

print(string.len("good")) -- 4
print(#"a word") -- 6

连接字符串

连接两个字符串需要放 … 符号在两个字符串中间，…符号的左右都要有一个空格。

print("nice" .. "people")
name = "Mike"
message = "red " .. name --red Mike

字符串强制转换

Lua会自动转换字符串代表的数据的类型。

pi = 3.14
message = "the pi is: " .. pi -- the pi is: 3.14

加一个只包含数字的字符串是有效的加法。

ten = "9" + 1 -- 10
six = 2 + "4" -- 6

字符逃逸

字符串需要在引号内，但如果需要字符串内有引号怎么办呢？

message = 'I said "good" '
message = "You said 'good'"

但是如果字符串里有双引号又有单引号怎么办呢？在字符串内的引号前加一个反斜线\。

message = "I said \"good\""
message = 'You said \'good\' '

还有其它逃逸字符，它们必须在字符串内才有用。常用的逃逸字符有：

• \n：新的一行
• \t：tab
• \：反斜线本身
• ‘’：双引号

控制台输入

string io.read()，不需要参数。在按下回车键后，这个函数会读取输入的一行文本作为字符串返回。

name = io.read() -- 此时可以输入，假设输入Jay，然后按下回车键
print(name) -- Jay

范围

范围定义了变量在程序中的可用位置。范围被限制在出现的块（块就是一段代码）中。
所有被执行的Lua文件都是一个块，块能包含其它的，更小的块。
你可以用do关键字创建一个本地块，这个块以end关键字结束。

do
    -- code here...
end
do
    -- other chunk...
end

一个块能访问任何它的父类块的变量，但不能访问子块的变量。
Local chunk可以访问dog，cat，fish变量；File chunk可以访问dog，cat变量，不能访问fish变量；Global chunk只能访问dog变量，不能访问cat，fish变量。

范围访问

块的意义就在范围。

foo = 7 -- foo是全局范围变量
do
    print(foo) -- 7
end
do
    local bar = 8 -- 本地范围
end
print(bar) -- 报错

对多级嵌套块也是一样的：

foo = 5
do
    local bar = 7
    do
        local x = 9 -- 可以访问foo, bar
    end
    -- 可以访问foo，bar，不能访问x
end

全局范围

注意到上面使用了local关键字，使用的local关键字声明的变量的范围是它所在块的范围。如果省略local，变量会被当做是全局范围的变量，无论是在哪个块声明的。

foo = 7 -- foo是全局范围
do
    bar = 8 -- bar是全局范围
end
print(foo) -- 7
print(bar) -- 8

全局变量和文件无关。local关键字可以使变量只能在被加载的文件中使用。

foo = 7 -- 所有.lua文件都能访问foo
local x = 9 -- 只有当前.lua文件可以访问x
do
    local bar = 8 -- 当前do/end块可以访问bar
end

覆盖

可以在子块内声明一个父块内已经声明的变量，之后子块内访问的是自己声明的变量。这叫变量覆盖。如果在不同范围声明了相同的变量名，那会使用最接近当前块的变量。

message = "global"
do
    local message = "do"
    print(message) 
    do
        print(message) -- do
    end
end
print(message) -- global

函数

函数本质上就是一个命名的代码块。和其它块不同，函数的内容不会在文件加载时被自动执行。文件加载时，函数只是被定义了，你可以调用它执行。函数的范围规则和do/end块相同。

函数定义

函数声明（定义）用function开始，后面跟函数名，然后是一列圆括号（）包围起来的参数列表，参数可以为空。

function printHello()
	text = "hello"
	print(text)
end

函数调用

当函数被声明后，就可以调用它来执行函数块内的代码。调用函数就是输入函数名，后加圆括号（）。例如输入io.read()调用内置函数读取控制台输入。

function pirntHelloW()
	print("hello world!")
end
printHelloW() -- 这里会在控制台输出字符串"hello world!

函数参数

函数可以携带参数。参数是可以给函数传递的数据（值，变量）。就像之前传递给函数print的string参数，就像这样：print(“a word”)。

在声明函数的时候可以放任意个变量名在圆括号（）内，它们可以在函数内使用，它们有函数的本地范围。

function AddAndPrint(a, b)
	print(a + b)
end
AddAndPrint(2, 11) -- 控制台输出13

任意数量的参数

在Lua中不必提供在声明函数时相同数量的参数。如果提供了超过声明时数量的参数，额外的参数会被直接忽略：

function addP(a, b)
	print(a + b)
end
addP(1, 2, 3, 4) -- 控制台输出3，忽略参数3, 4

如果少给参数，变量的默认值是nil：

function printValue(x, y)
	print("x: " .. tostring(x))
end
printValue() -- 控制台输出x: nil

x被传递给tostring函数，这是一个Lua内置函数，可以避免在将nil连接到字符串的时候产生错误。

返回一个值

函数不只有输入，还可以有输出，通过return关键字完成。当函数返回时，它可以作为表达式的一部分或者独立语句。函数执行完就是相当于是一个和函数同名的变量，值是返回值。

function add1(x)
	result = x + 1
	print(result)
	return result
end
a = add1(10) -- 控制台输出11。此时add1函数相当于add1变量，值为11，a为11
b = add1(a) + 2 -- 控制台输出12，add1函数相当于add1变量，值为12，b为14 

当函数执行到return语句，它会直接返回return后面的值并停止执行。如果return语句后面还有代码，它们永远不会执行。

function square(number)
		print("I am good")
		do
			return number * number
		end
		print("I am bad") -- 永远不会执行
end
print(square(2)) -- 控制台先输出I am good, 下一行输出4

为什么上面的return语句在do/end块中呢？因为return语句必须紧跟着end关键字，否则会编译失败。而do/end块只会改变变量的作用范围，不会改变语句执行顺序。

返回多个值

为了返回多个返回值，需要将函数结果赋予一列用逗号,分隔的变量。

function squareAndCube(x)
	square = x * x
	cube = x * x * x
	return square, cube
end
s, c = squareAndCube(2) -- s是4，c是8

和函数传参时一样，如果函数返回值数和变量数不一样，多出的变量值是nil。如果变量数少，则多出的返回值会被丢弃。

s, c, q = squareAndCube(2) -- 调用上面的squareAndCube函数，s是4，c是8，q是nil
s2 = squareAndCube(2) -- s是4

操作符

操作符（运算符）就是加号+，字符串连接符…，赋值符=。操作符可以分成以下几个种类：

• 算术运算符
• 关系运算符
• 逻辑运算符
• 其它运算符

运算符可以是一元的(unary)或二元的(binary)。一元运算符只有一个运算对象。例如负号-是一元运算符。它返回值的负数：

x = -7 -- x值为-7
y = -x -- y值为7

二元运算符对两个数运算。减号-也可以用来做减法，但它和与它对应的负号是完全不同的运算符。

x = 7 - 3 -- x值为4
y = x - 1 -- y值为3

算术运算符

这些符号和数字一起起作用。

x = 1 + 12 -- 加号为+，x为13
y = 10 - 4 -- 减号为-，y为6
t = 2 * 4 -- 乘号为*，t为8
s = 24 / 4 -- 除号为/，s为6
z = 5 % 3 -- 取余（或者说取模）为%，z为2（因为5除以3，余数为2）
n = -5 -- 取负为-，n为-5
e = 10 ^ 2 -- 幂为^，e为100（10的2次幂），第一个操作数为基，第二个操作数为指数

关系运算符

关系运算符比较两个事（通常是数字），然后判断真假（返回一个Boolean值）。

相等运算符（==）

x = 2 == 2 -- x为true
y = x == 3 -- y为false，x不等于3

不等运算符（~=）

x = 2 ~= 3 -- x为true,2不等于3
y = x ~= “nice” -- y为true，x不等于“nice”

大于 大于等于 小于 小于等于运算符

x = 4 > 5 -- x为false
y = 4 >= 4 -- y为true
l = 3 < 5 -- l为true
q = 4 <= 3 -- q为false

逻辑运算符

逻辑运算符用来测试两个语句的关系。在Lua中，任何非假的都是真的，只有两个是假的，即false和nil。

and运算符。如果第一个操作数是假，返回第一个操作数；如果第一个操作数是真，返回第二个操作数。

x = true and false -- x为false，第一个操作数是true，返回第二个操作数false
x = 3 and 1 -- x为1，同上

or运算符。如果第一个操作数是真，返回第一个操作数；如果第一个操作数是假，返回第二个操作数。

x = true or false -- x为true，第一个操作数为true，返回第一个操作数
x = 7 or 1 -- x为7，第一个操作数为7，为真，返回第一个操作数
x = false or true -- x为true

and/or操作符都是短路判断，这意味着第二个操作数只在必要的时候会被判断。特别是对于函数来说：

function trueF()
	print("trueF")
	return true
end

function falseF()
	print("falseF")
	return false
end

x = falseF() and trueF() -- x为false

上面的代码执行，控制台会输出"falseF", 不会输出"trueF"，因为第一个操作数为假（操作数为函数时，执行这个函数，操作数的值为返回值，falseF函数返回值为false），直接返回第一个操作数，不判断第二个操作数，也就不会执行trueF函数。

x = trueF() and falseF() -- x为false

对调一下位置，此时控制台会输出"trueF"，然后输出"falseF"，因为第一个操作数的返回值为真，判断第二个操作数，执行第二个函数并返回第二个操作数。

not运算符。是一个一元运算符，它会反转操作数的逻辑状态。

x = not true -- x为false
x = not (3 + 1) -- x为false
x = not not true -- x为true

其它运算符

赋值符（=）。可以一次赋多个变量值。

x = 2
y, t = 3, "hello" -- y为3，t为"hello"

字符串连接符（…）

x = "hello" .. "world" -- x为"helloworld"

长度运算符（#）

x = #"hello" -- x为5

运算符优先级

运算符是有优先级的，如5 + 2 * 10 结果是25，因为乘法比加法先运算。使用括号使一组式子先运算，如((5 + 2) * 10)结果是70。Lua遵循下表的优先级，从高（第一行）到低（最后一行）：

相同优先级的符号遵循从左到右的顺序执行。