献给Lua小白的Lua基础入门

lua的起源

lua是Roberto Ierusalimschy、Luiz Henrique de Figueiredo 和 Waldemar Celes在1993年创建的一门轻量的可嵌入的快速的脚本语言，其功能非常强大，是以C语言编写的开源语言。lua本身的目的是为嵌入应用程序为应用程序提供灵活的扩展和定制功能。

Lua特性

• 脚本语言------解释型语言
• 嵌入程序开发
• 易与其他语言相互调用
• 轻量
• 面向过程
• 函数式编程
• 热更新

安装Lua

下载地址：http://luabinaries.sourceforge.net/download.html
推荐的编写工具：sublime、VSCode、babelua等等
安装完成后不要忘记配置环境变量
在系统环境变量中的Path中加入
要把路径换成你自己lua所安装的路径。
执行lua脚本方法：打开CMD，进入lua脚本所在文件夹，使用命令：lua xxxxx.lua即可运行脚本。

lua语法

一、注释

单行注释：–注释内容
多行注释：–[[ 注释内容 ]]

二、变量声明

Lua 变量有三种类型：全局变量、局部变量、表中的域。
Lua 中的变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。
局部变量的作用域为从声明位置开始到所在语句块结束。
变量的默认值均为 nil（即相当于C#等语言中的null）。
例：全局变量声明

• 单变量：name = “xiaowang”
• 多变量：name,age = “xiaowang”,18
  局部变量声明
• 单变量：local age = 23
• 多变量：local name,age = “xiaowang”,20

注：声明变量时，不需要指定数据类型；语句结束也不需要分号；

三、运算符

1.算数运算符：加(+)、减(-)、乘(*)、除(/)、幂(^)、取余（%）（不多说）
2.比较运算符：⼩于(<)、⼤于(>)、⼩于等于(<=)、⼤于等于(>=)、等于等于(==)、不等于(~=)（不多说）
3.逻辑运算符：

• 与(and)、或(or)、⾮(not)
• 注意逻辑运算结果：
• a and b - - 如果a为false，则返回a，否则返回b
  a or b - - 如果a为true，则返回a，否则返回b
  not a - -如果a为true，则返回false，否则返回true

注：逻辑运算中只有nil和false视为假，其它都为真，0也为真

4.连接运算符：…两个点
例：print("hello " … “world”) ------》 hello world

四、数据类型

• nil：表示空值，所有没有使⽤过的变量都是nil；nil既是值，⼜是数据类型
• boolean：布尔类型，只有两个有效的值：true和false
• number：数值类型，在Lua⾥，相当于C语⾔⾥的double
• string：字符串，如果愿意的话，字符串是可以包含"\0"字符的
• table：关系类型，这个类型的功能⽐较强⼤
• function：函数类型，可以由函数类型来声明变量

五、关系类型详解

• table = {}------初始化表
• table[0] =4------指定值
• table[“name”] = “⽼王”
• table[“son”] = {name=“北京”,gender=“男”}
• table = nil------移除应用，lua垃圾回收释放内存

table 是 Lua 的一种数据结构用来帮助我们创建不同的数据类型，如：数组、字典等。Lua table 使用关联型数组，你可以用任意类型的值来作数组的索引，但这个值不能是 nil。Lua table 是不固定大小的，你可以根据自己需要进行扩容。Lua也是通过table来解决模块（module）、包（package）和对象（Object）的。 例如string.format表示使用"format"来索引table string。

• Table嵌套：table =
  {
  10,–相当于[1] = 10
  [100] = 110,
  person = {
  name = “Albert”,
  age = 80,
  },
  20–相当于[2] = 20
  }

六、赋值语句

• 变量个数>值的个数 —> 按变量个数补⾜nil
• 变量个数<值的个数 —> 多余的值会被忽略
  如下例：
  • a , b = 10 , 2x <—> a = 10 ; b = 2x ;
  • a , b , c = 0 , 1 —> 0 1 nil
  • a , b = a + 1 , b + 1 , b + 2 —> 1 2
  • a , b , c = 0 —> 0 nil nil
  • a , b = f() —> f()返回两个值，第⼀个赋给a，第⼆个赋给b

还有个特殊的赋值操作

• a , b = b , a <—> swap(x,y);
• a[i] , a[j] = a[j] , a[i] <—> swap(a[i],a[j]);

是的，Lua可以直接通过以上方式交换两个变量的值

七、if语句

• 语法：
  1.第⼀种形式：
  if conditions then
  then-part
  end

  2.第⼆种形式：
  if conditions then
  then-part
  else else -part
  end;

  3.第三种形式：
  if conditions then
  then-part
  elseif conditions then
  elseif-part
  …
  else
  else-part
  end;

例：

a = io.read()
if a==“m” then
print(“man”)
elseif a==“w” then
print(“women”)
else 
end

if语句常见练习：

•输⼊⼀个年份，判断该年份是否
是闰年？如果是闰年，则输出该年是
闰年，否则输出该年不是闰年。
•提示：
•闰年：能被400整除，或者能被
4整除但是不能被100整除。

实现：

year = io.read()
if tonumber(year)%400 == 0 or (tonumber(year)%4 == 0 and tonumber(year)%100 ~=0) then
print("yes")
else
	print("no")
end

八、for语句

• 语法：
  for var=exp1,exp2,exp3 do
  loop-part
  end
  exp1是起点（包含），exp2是终点（包含），exp3 增量（可省略，省略时表示每次自增1）
• 例：
  for i=1,10,2 do
  print(i)
  end

练习：

求1到100内的质数之和。

实现：

sum = 0

for	i=2,100,1 do
	flag = true
	for j=2,i/2,1 do
		if i%j ==0 then
			flag = false
	end
end
if flag then
	print(i)
	sum = sum + i
end
end

print(sum)

九、while循环语句

• 语法：
  while condition do
  statements
  end

例：

while i < 100 do
	print(i)
	i = i + 2
end

练习：

编写程序实现功能，计算100⾄10000之间有多少个数其各位数字之和是7.（例如241：2+4+1=7） 。

实现：

i = 100

count = 0

while i < 10000 do

quyu = 1000
sum = 0
temp = i

while temp > 9 do
	dange = (temp - temp%quyu)/quyu
	temp = temp%quyu
	if temp < 10 then
		sum = sum + temp
	end
	sum = sum + dange
	quyu = quyu/10
end

i = i + 1

if sum == 7 then
	count = count + 1
	print(i-1)
end
end
print(count

十、repeat语句

• 语法：
  repeat
  statements;
  until conditions;

例：

i = 0
repeat
print(i)
i = i +1
until i > 10

十一、范型for语句

• 语法：
• – print all values of array ‘a’
  for i,v in ipairs(a) do print(v) end
  – print all keys of table ‘t’
  for k in pairs(t) do print(k) end
  区别：ipairs遇到第⼀个nil跳出循环

十二、break语句

emmm…这个没什么好说的，就是用来跳出循环的嘛

例：

ocal i = 1
while a[i] do
if a[i] == v then break end
i=i+1
end

十三、函数

在Lua中，函数是对语句和表达式进行抽象的主要方法。既可以用来处理一些特殊的工作，也可以用来计算一些值。

Lua 提供了许多的内建函数，你可以很方便的在程序中调用它们，如print()函数可以将传入的参数打印在控制台上。

Lua 函数主要有两种用途：

1.完成指定的任务，这种情况下函数作为调用语句使用；
2.计算并返回值，这种情况下函数作为赋值语句的表达式使用。

• 语法：
  function func_name (argumentslist)
  statements-list;
  end;
• 调用：
  括号可省略
  print(“HelloWorld”) <—>print “HelloWorld”
• 形参实参匹配
  function f(a, b) return a or b end
  CALL PARAMETERS
  f(3) ------a=3, b=nil
  f(3, 4) – a=3, b=4
  f(3,4,5) -a=3,b=4 (5 is discarded)

注意：Lua不支持重载！

Lua支持多返回值：

function maximum (a)
	local mi = 1 -- maximum index 
	local m = a[mi] -- maximum value 
	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

十四、Lua模拟面向对象

模块

模块类似于一个封装库，从 Lua 5.1 开始，Lua 加入了标准的模块管理机制，可以把一些公用的代码放在一个文件里，以 API
接口的形式在其他地方调用，有利于代码的重用和降低代码耦合度。

Lua 的模块是由变量、函数等已知元素组成的 table，因此创建一个模块很简单，就是创建一个
table，然后把需要导出的常量、函数放入其中，最后返回这个 table 就行。

• 创建模块
  1.xxx.lua
  2.aaa={}
  2.1.aaa.name=“A”
  2.2.function aaa.show(){return “I am A”}
  3.bbb={}
  3.1.bbb.name=“b”
  3.2.function bbb.show(){return “I am B”}

• 使用模块

• Lua提供了一个名为require的函数用来加载模块。要加载一个模块，只需要简单地调用就可以了。
  require(“模块名”) ---------require(“xxx”)

元表(metatable)

在 Lua table 中我们可以访问对应的key来得到value值，但是却无法对两个 table 进行操作。

因此 Lua 提供了元表(Metatable)，允许我们改变table的行为，每个行为关联了对应的元方法。

例如，使用元表我们可以定义Lua如何计算两个table的相加操作a+b。

当Lua试图对两个表进行相加时，先检查两者之一是否有元表，之后检查是否有一个叫"__add"的字段，若找到，则调用对应的值。"__add"等即时字段，其对应的值（往往是一个函数或是table）就是"元方法"。
有两个很重要的函数来处理元表：

• 设置元表：setmetatable(table,metatable) 返回值为tabl，对table设置元表metatable
• 获取元表：getmetatable(table) 返回值为metatable,获取table的元表

元⽅法

__index (读)

• 如果__index是个表格:⼦表没有的字段，搜索元表；若搜不到，递归搜索元表的元表…
  这是 metatable 最常用的键。
  当你通过键来访问 table 的时候，如果这个键没有值，那么Lua就会寻找该table的metatable（假定有metatable）中的__index 键。如果__index包含一个表格，Lua会在表格中查找相应的键。

例：

son = {}
parent = {
 __index = {
 name = "laowang",
 func = function ()
 print("show")
 end
 }
}
setmetatable(son, parent)
print(son.name)
son.func()

-如果 __index是个⽅法：⼦表没有的字段，调⽤元表__index⽅法，并以表格和字段为参数
__index 元方法查看表中元素是否存在，如果不存在，返回结果为 nil；如果存在则由 __index 返回结果。

__index总结

Lua 查找一个表元素时的规则，其实就是如下 3 个步骤:

1.在表中查找，如果找到，返回该元素，找不到则继续
2.判断该表是否有元表，如果没有元表，返回 nil，有元表则继续。
3.判断元表有没有 __index 方法，如果 __index 方法为 nil，则返回 nil；如果 __index 方法是一个表，则重复 1、2、3；			如果 __index 方法是一个函数，则返回该函数的返回值。
该部分内容来自作者寰子：https://blog.csdn.net/xocoder/article/details/9028347

例：

son={}
parent={__index = function 
(tb,key)
 -- body
 if key == "name" then
 -- body
 return "laowang"
 else 
 return "null variable"
 end
end
}
setmetatable(son,parent)
print(son.name)

__newindex(写)

• 如果__newindex是⼀个表格：在设置值时，⼦表没有的新字段，会在元表的__newindex表格中添加该新字段

例：

 tb = {}
newtb = {}
setmetatable(tb,{__newindex = 
newtb})
tb.name = "xiaozhang"
print(tb.name)
print(newtb.name)

以上实例中表设置了元方法 __newindex，在对新索引键（tb.name）赋值时（tb.name = “xiaozhang”），会调用元方法，而不进行赋值。而如果对已存在的索引键，则会进行赋值，而不调用元方法 __newindex。

• 如果__newindex是⼀个⽅法：在设置值时，⼦表没有的新字段，会调⽤元表的__newindex⽅法，并会以表格、字段、值作为参数

例：

 son = {name = "xiaowang"}
parent = { __newindex = 
 function (tb,key,value)
 if key == "age" then
 print(key,value)
 end
 end
}
setmetatable(son,parent)
son.name = "xiaozhang"
son.age = "18"

还有两个方法__call、__tostring就不细说了，读者可以自行查阅API，大差不差。

十五、LUA面向对象编程

我们知道，对象由属性和方法组成。LUA中最基本的结构是table，所以需要用table来描述对象的属性。

lua 中的 function 可以用来表示方法。那么LUA中的类可以通过 table + function 模拟出来。

至于继承，可以通过 metetable 模拟出来（不推荐用，只模拟最基本的对象大部分时间够用了）。

Lua
中的表不仅在某种意义上是一种对象。像对象一样，表也有状态（成员变量）；也有与对象的值独立的本性，特别是拥有两个不同值的对象（table）代表两个不同的对象；一个对象在不同的时候也可以有不同的值，但他始终是一个对象；与对象类似，表的生命周期与其由什么创建、在哪创建没有关系。

创建⼀个类

Person = {name = "xiaoming",age = 19,sex = "M"}

设置类的构造函数

function 
Person:new(name,age,sex)
 o = {}
 setmetatable(o,self)
 self.__index = self
 self.name = name
 self.age = age
 self.sex = sex
 return o
end

设置类的成员函数

function Person:getsex()
return self.sex
end

对象的实例化

xiaoming = Person:new("xiaoming",10,"M")

设置对象的成员字段

xiaoming.age = 11

调⽤对象的成员⽅法

print(xiaoming:getsex())

静态

Person.maxPerson = 100000
print(Person.maxPerson)
function Person.getMax()
 return Person.maxPerson
end

码字不易，如果对你有一丝丝帮助，请点个赞，收个藏，能给个关注就更好了！有不懂得可以私我或者下方评论交流。