注释

					-- 单行注释
					
					--[[
					 多行注释
					 多行注释
					 --]]
					

数据类型

Lua是动态类型语言,变量不要类型定义,只需要为变量赋值。 值可以存储在变量中,作为参数传递或结果返回。

数据类型 描述 实例
nil 这个最简单,只有值nil属于该类,表示一个无效值(在条件表达式中相当于false)。 local a=nil
boolean 包含两个值:false和true。 local a=true
number 表示双精度类型的实浮点数 local a=3.14
string 字符串由一对双引号或单引号来表示 local a="hello,world!"
function 由 C 或 Lua 编写的函数
							function a()
								return a
							end
							
userdata 表示任意存储在变量中的C数据结构
thread 表示执行的独立线路,用于执行协同程序
table Lua 中的表(table)其实是一个"关联数组"(associative arrays),数组的索引可以是数字或者是字符串。在 Lua 里,table 的创建是通过"构造表达式"来完成,最简单构造表达式是{},用来创建一个空表。 local a={"apple", "pear", "orange", "grape"}

变量/运算符

					-- test.lua 文件脚本
					a = 5               -- 全局变量
					local b = 5         -- 局部变量
					
					function joke()
					    c = 5           -- 全局变量
					    local d = 6     -- 局部变量
					end
					
					joke()
					print(c,d)          --> 5 nil
					
					do 
					    local a = 6     -- 局部变量
					    b = 6           -- 全局变量
					    print(a,b);     --> 6 6
					end
					
					print(a,b)      --> 5 6	
					
操作符 描述 实例
+ 加法 A + B 输出结果 30
- 减法 A - B 输出结果 -10
* 乘法 A * B 输出结果 200
/ 除法 B / A 输出结果 2
% 取余 B % A 输出结果 0
^ 乘幂 A^2 输出结果 100
- 负号 -A 输出结果v -10
== 等于,检测两个值是否相等,相等返回 true,否则返回 false (A == B) 为 false。
~= 不等于,检测两个值是否相等,相等返回 false,否则返回 true (A ~= B) 为 true。
> 大于,如果左边的值大于右边的值,返回 true,否则返回 false (A > B) 为 false。
< 小于,如果左边的值大于右边的值,返回 false,否则返回 true (A < B) 为 true。
>= 大于等于,如果左边的值大于等于右边的值,返回 true,否则返回 false (A >= B) 返回 false。
<= 小于等于, 如果左边的值小于等于右边的值,返回 true,否则返回 false (A <=B ) 返回 true。
and 逻辑与操作符。 若 A 为 false,则返回 A,否则返回 B。 (A and B) 为 false
or 逻辑或操作符。 若 A 为 true,则返回 A,否则返回 B。 (A or B) 为 true。
not 逻辑非操作符。与逻辑运算结果相反,如果条件为 true,逻辑非为 false。 not(A and B) 为 true。

流程控制

条件判断
							if( 布尔表达式 1)
							then
							   --[ 在布尔表达式 1 为 true 时执行该语句块 --]
							
							elseif( 布尔表达式 2)
							then
							   --[ 在布尔表达式 2 为 true 时执行该语句块 --]
							
							elseif( 布尔表达式 3)
							then
							   --[ 在布尔表达式 3 为 true 时执行该语句块 --]
							else 
							   --[ 如果以上布尔表达式都不为 true 则执行该语句块 --]
							end
							
while循环
							while(condition)
							do
							   statements
							end
							
for循环
							for var=exp1,exp2,exp3 do  
							    statements  
							end  
							
repeat循环
							repeat
							   statements
							until( condition )
							

函数

					--[[ 函数返回两个值的最大值 --]]
					function max(num1, num2)
					
					   if (num1 > num2) then
					      result = num1;
					   else
					      result = num2;
					   end
					
					   return result; 
					end
					-- 调用函数
					print("两值比较最大值为 ",max(10,4))
					print("两值比较最大值为 ",max(5,6))
					

字符串

					local str1="this is string"
					local str2='this is string'
					local str3=[[
						this is string
					]]
					
  1. 转大写字母 --> string.upper(argument)
  2. 转小写字母 --> string.lower(argument)
  3. 替换字符串 --> string.gsub(mainString,findString,replaceString,num)
  4. 查找字符串 --> string.find(str, substr, [init, [end]])
  5. 反转字符串 --> string.reverse("Lua")
  6. 格式化字符串 --> string.format("the value is:%d",4)
  7. 计算长度 --> string.len(arg)
  8. 连接字符串 --> "www.runoob".."com"

数组/表

					local array = {"Lua", "Tutorial"}
					
					for i= 0, 2 do
					   print(array[i])
					end	
					
					for k, v in pairs(array) do
					    print(k, v)
					end
					

模块/包

					-- 引用模块
					local m = require("module")
					
					-- 文件名为 module.lua
					-- 定义一个名为 module 的模块
					module = {}
					 
					-- 定义一个常量
					module.constant = "这是一个常量"
					 
					-- 定义一个函数
					function module.func1()
					    io.write("这是一个公有函数!\n")
					end
					 
					local function func2()
					    print("这是一个私有函数!")
					end
					 
					function module.func3()
					    func2()
					end
					 
					return module	
					

元表

在 Lua table 中我们可以访问对应的key来得到value值,但是却无法对两个 table 进行操作。 因此 Lua 提供了元表(Metatable),允许我们改变table的行为,每个行为关联了对应的元方法。 例如,使用元表我们可以定义Lua如何计算两个table的相加操作a+b。 当Lua试图对两个表进行相加时,先检查两者之一是否有元表,之后检查是否有一个叫"__add"的字段,若找到,则调用对应的值。"__add"等即时字段,其对应的值(往往是一个函数或是table)就是"元方法"。 有两个很重要的函数来处理元表: setmetatable(table,metatable): 对指定table设置元表(metatable),如果元表(metatable)中存在__metatable键值,setmetatable会失败 。 getmetatable(table): 返回对象的元表(metatable)。

协同程序

					function foo (a)
					    print("foo 函数输出", a)
					    return coroutine.yield(2 * a) -- 返回  2*a 的值
					end
					 
					co = coroutine.create(function (a , b)
					    print("第一次协同程序执行输出", a, b) -- co-body 1 10
					    local r = foo(a + 1)
					     
					    print("第二次协同程序执行输出", r)
					    local r, s = coroutine.yield(a + b, a - b)  -- a,b的值为第一次调用协同程序时传入
					     
					    print("第三次协同程序执行输出", r, s)
					    return b, "结束协同程序"                   -- b的值为第二次调用协同程序时传入
					end)
					        
					print("main", coroutine.resume(co, 1, 10)) -- true, 4
					print("--分割线----")
					print("main", coroutine.resume(co, "r")) -- true 11 -9
					print("---分割线---")
					print("main", coroutine.resume(co, "x", "y")) -- true 10 end
					print("---分割线---")
					print("main", coroutine.resume(co, "x", "y")) -- cannot resume dead coroutine
					print("---分割线---")
					

文件I/O

					-- 以只读方式打开文件
					file = io.open("test.lua", "r")
					
					-- 输出文件第一行
					print(file:read())
					
					-- 关闭打开的文件
					file:close()
					
					-- 以附加的方式打开只写文件
					file = io.open("test.lua", "a")
					
					-- 在文件最后一行添加 Lua 注释
					file:write("--test")
					
					-- 关闭打开的文件
					file:close()
					

面向对象

					-- Meta class
					Shape = {area = 0}
					-- 基础类方法 new
					function Shape:new (o,side)
					  o = o or {}
					  setmetatable(o, self)
					  self.__index = self
					  side = side or 0
					  self.area = side*side;
					  return o
					end
					-- 基础类方法 printArea
					function Shape:printArea ()
					  print("面积为 ",self.area)
					end
					
					-- 创建对象
					myshape = Shape:new(nil,10)
					myshape:printArea()
					
					Square = Shape:new()
					-- 派生类方法 new
					function Square:new (o,side)
					  o = o or Shape:new(o,side)
					  setmetatable(o, self)
					  self.__index = self
					  return o
					end
					
					-- 派生类方法 printArea
					function Square:printArea ()
					  print("正方形面积为 ",self.area)
					end
					
					-- 创建对象
					mysquare = Square:new(nil,10)
					mysquare:printArea()
					
					Rectangle = Shape:new()
					-- 派生类方法 new
					function Rectangle:new (o,length,breadth)
					  o = o or Shape:new(o)
					  setmetatable(o, self)
					  self.__index = self
					  self.area = length * breadth
					  return o
					end
					
					-- 派生类方法 printArea
					function Rectangle:printArea ()
					  print("矩形面积为 ",self.area)
					end
					
					-- 创建对象
					myrectangle = Rectangle:new(nil,10,20)
					myrectangle:printArea()
					

{include file="footer_part"}