Lua常用

Lua的数据类型其实很少。

数据类型 描述

• nil 这个最简单，只有值nil属于该类，表示一个无效值（在条件表达式中相当于false）。
  boolean 包含两个值：false和true。 number 表示双精度类型的实浮点数 string 字符串由一对双引号或单引号来表示
  function 由 C 或 Lua 编写的函数 userdata 表示任意存储在变量中的C数据结构
  thread 表示执行的独立线路，用于执行协同程序 table Lua 中的表（table）其实是一个"关联数组"（associative
  arrays），数组的索引可以是数字或者是字符串。在 Lua 里，table
  的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。 我们可以使用type函数测试给定变量或者值的类型：
• print(type(“Hello world”)) --> string
• print(type(10.4*3)) --> number
• print(type(print)) --> function
• print(type(type)) --> function
• print(type(true)) --> boolean
• print(type(nil)) --> nil
• print(type(type(X))) --> string

变量

• Lua的变量让我们看起来也很奇怪

   a = 5 --全局变量   
   local b = 5 --局部变量   
   function joke()   
   　　c =5 --全局变量   
   　　local d = 6 --局部变量   
   end
   另外：
   site = {}   
   site["key"] = "www.w3cschool.cc"
   可以写作为如下：   
   site.key  
   也就是  site["key"]   等价于  site.key   

while循环

while(condition)
   do
     statements
   end

For循环

• exp1为起点，exp2为终点，exp3为步进值，若exp3没有写，则默认为1

  for var=exp1,exp2,exp3  
   do  
      <执行体>           
   end

Repeat循环

• 就是我们平时使用的do…while循环

- a = 10
   --[ 执行循环 --] 
   repeat    
      print("a的值为:", a)    
      a = a + 1 
   until( a > 15 )

迭代器循环

• C#里面的迭代器循环使用的最多的当然是foreach循环了，当然协程也是个迭代器循环

array = {"Lua",  "Tutorial"} --一个Table，也能想象成一个字典 
无状态迭代器： 
function square(iteratorMaxCount,currentNumber)    
	if currentNumber<iteratorMaxCount    
	then
         currentNumber = currentNumber+1   
    return currentNumber, currentNumber*currentNumber    
    end 
end

for i,n in square,3,0  --square是一个可以参与运行的函数，3和0为参数 
do    
	print(i,n)
end

多状态迭代器：

• 多状态迭代器可以遍历一个函数的结果集和pairs和ipairs两种特殊迭代方式

 array = {"Lua", "Tutorial"}

function elementIterator (collection)
   local index = 0
   local count = #collection --井号能取出collection参数的数量，若为[1] = ,[2] = ，则取出从第一个元素连续最多元素的数量，假如没有3，直接跳到了[4] = ，则#collection的值为2
   -- 闭包函数
   return function ()
      index = index + 1
      if index <= count
      then
         --  返回迭代器的当前元素
         return collection[index]
      end
   end
end

for element in elementIterator(array)
do
   print(element)
end

• pairs: 迭代 table，可以遍历表中所有的 key 可以返回 nil
  ipairs: 迭代数组，不能返回 nil,如果遇到 nil 则退出
  （ipairs的迭代，会像C#的foreach那样，挨个写入堆栈。）

local tab= { 
[1] = "a", 
[3] = "b", 
[4] = "c" 
} 
for i,v in pairs(tab) do        -- 输出 "a" ,"b", "c"  ,
    print( tab[i] ) 
end 

for i,v in ipairs(tab) do    -- 输出 "a" ,k=2时断开 
    print( tab[i] ) 
end

• **但重要点说明一下paris跌代，或取的数据顺序并不是一个让人很好理解的顺序，因为它并不会按照1234这种顺序排下来，paris迭代产生的结果列表的排列，是按照一定的希哈规律来排列的，所以并不是无规则的无序，而是按哈规则的有序。

  如果数据量非常庞大的话，paris的希哈排列，会造成性能上非常大的优势，倘若将列表值赋值给C#，然后以linq、lambda的方式来取，则也并不需要有序。

  所以不要纠结于paris中看似无序实则有序的排列。**

对象

local myClass = {}
 
function myClass:new()
    local self = {}
    setmetatable(self,{__index = myClass})
end
 
local a = 0
local b = 0
local c = 0
 
return myClass

• 以上类的对象实例化的调用：

  require “myClass”

  local _myClass = myClass:new()

  实例化后 _myClass.a、_myClass.b、_myClass.c的初始值均为nil

单例

lua的单例的本质其实就是一个全局的字段

myInstanceClass = {}
 
myInstanceClass_mt = {__index = myInstanceClass}
 
function myInstanceClass:new()
    local self = {}
    setmetatable(self,myInstanceClass_mt)
end
 
local a = 0
local b = 0
local c = 0
 
return myInstanceClass --在使用全局字段的单例中，这句返回值其实可有可无，因为是全局的，所以不需要返回值也能调用。

• 以上类的对象的调用：

  require “myInstanceClass”

  local _myInstanceClass1 = myInstanceClass:new()

  local _myInstanceClass2 = myInstanceClass:new()

  local _myInstanceClass3 = myInstanceClass:new()

  实例化后
  _myInstanceClass.a、_myInstanceClass.b、_myInstanceClass.c的初始值均为nil

  任何时时候以下三个对象之一的值变化的时候_myInstanceClass1 、_myInstanceClass2
  、_myInstanceClass3，另外两个对象的值也同时会变化。

导入lua工程资源路径：

LuaStack* stack = engine->getLuaStack();
stack->addSearchPath("src/");