Lua

直接上代码 简单易懂

-- 是lua中的注释 相当于 // 字符串：1. 单引号表示的字符串里可包含双引号 但内部不能包含单引号2. 双引号表示的字符串里可以包含单引号 但内部不能包含双引号

-- print("lua") -- a = 1-- b = 2-- print(a+b) -- 3 -- b = false-- n = 1-- s = 'lua'-- print(type(b)) -- type()类型 在代码后面注释的是这一句的输出结果 输出boolean-- print(type(n)) -- number-- print(type(s)) -- string-- gVar = 10 -- 全局变量 没有local关键字的变量都是全局变量 命名规范全局加g-- local var2 = 1 -- 局部变量-- print(gVar,var2)-- do   -- do...end 相当于{}代码块--  local name = 'fool'--  gAge = 5--  print(name,gAge) -- fool 5-- end-- print(name,gAge) -- nil 5-- x = 1-- y = 2-- z = x-- x = y -- y = z-- print(x,y) --交换值-- x,y = y,x -- print(x,y) --也可以这样写-- x = 1 -- y = x..1-- print(y) -- 11 数字拼接-- str = 'hello'-- str2 = 'lua'-- print(str..str2) --hellolua 字符串拼接-- print(#str2) -- 3 长度-- ^ 优先级最高 -- a^b计算的就是a的b次方 x^0.5将计算x的算术平方根, x^(-1/3)将计算x立方根的倒数-- not -- * /-- + - -- ..-- < > <= >= ~= ==     -- ~= 就是 !=-- and  -- 逻辑非操作符。与逻辑运算结果相反 如果条件为 true 逻辑非为 false。-- or 优先级最低-- x^y^z ==> (y^z)^z 特例  从右往左计算-- "%"(取模)：和有的语言的%不一样，a % b == a - floor(a/b)*b 。floor(x) 表示对x向下取整 可以看出来表达式的符号永远和b的符号相同。-- 如果a,b都是整数，%既是求余，这是好理解的。-- 如果a,b中存在实数呢？-- 其实，a,b都为实数计算a%b的大多数情况下都是没有实用价值的。-- 但是特别的，当x为实数的时候：x-x%1就是计算x的整数部分-- 类似的，x-x%0.01就是计算x精确到小数点后两位的结果-- 单分支-- if..-- if a == nil then--  print('条件成立')-- end-- 双分支-- if a ~= nil then--  print('条件成立')-- else--  print('条件不成立')-- end--[=[1111111222多行注释]=]---- x,y = 1,2-- if x>y then--  print('x>y')-- else--  print('x<y')-- end-- a = 0-- while a<10--  do--  print('hello lua')--  a = a + 1-- end-- sum,a = 0,1-- while a<=100--  do--  sum = sum + a--  a = a+1-- end-- print(sum)-- sum,a = 0,1-- while a<=100--  do--  if a % 2 == 0 then--      sum = sum + a--  end --  a = a+1-- end-- print(sum)-- sum,a = 0,1-- while a<=100--  do--  if a % 2 == 0 then--      sum = sum + a--      if sum >= 1500 then--          print(a-2)--          print(sum-a)--          break--      end--  end --  a = a+1-- end-- 默认步长为1-- var从exp1变化到exp2,每次变化都是以exp3作为步长(step)递增var,并执行一次循环体。-- 不过第三个表达式exp3是可选的 若不指定的话 lua就会将步长默认为1。-- 不过值得注意的是:在lua中 var 作为控制变量是被 lua 封装起来了 也就是说在循环体里面对 var 的修改都是无效的。-- for i=1,10 do--  print(i)-- end-- break return 跟其他语言差不多-- for i=1,math.huge do--  print(i)--  if i>=100 then--      break--  end-- end-- Lua的基础库提供了ipairs 这是一个用于遍历数组的迭代器函数-- 在每次循环中 i会被赋予一个索引值 同时v被赋予一个对应该索引值得数组元素值 -- 通过从外观上看泛型for比较简单 但其实它是非常强大的 -- 通过不同的迭代器，几乎可以遍历所有东西-- 而且写出来的代码是极具可读性 标准库提供了几种迭代器 包括用于迭代文件中的每行的( io.lines() )  -- 迭代table元素的( pairs() ) ... 迭代数组元素的( ipairs() ) ...迭代字符串中单词的( string.gmatch() )等等-- a = {5,7,3,8,1}-- for i,v in ipairs(a) do--  io.write(v,' ') -- 5 7 3 8 1-- end-- 函数-- function F(x)--  print(x)-- end-- F(10)-- print 'hello lua'-- function Compare(num1,num2)    -- if num1>num2 then    --  return num1    -- else    --  return num2    -- end--  return num1>num2 and num1 or num2--  -- ==> x > y ? x : y-- end-- max = Compare(12,11)-- print(max)-- function Calculate(num1,num2)--  return num1+num2,num1-num2,num1*num2,num1/num2  -- end-- v1,v2,v3,v4 = Calculate(10,10)-- print(v1,v2,v3,v4)-- f = function (  )--  print('这是一个函数变量声明的函数')-- end-- f()-- function MyFunc( f )--  f()-- end-- v = function (  )--  print('这是一个函数')-- end-- MyFunc(v)--  如果函数作为一条单独的语句 lua会丢弃所有的返回值 -- function Calculate(num1,num2)--  return num1+num2,num1-num2,num1*num2,num1/num2  -- end-- Calculate(10,10)-- 如果函数作为表达式的一部分来调用时-- lua只保留函数的第一个返回值-- 只有当一个函数调用是一系列表达式中的最后一个元素时-- 才能获得它所有的返回值-- 这里的一系列表达式在lua中表现4中情况-- 1> 多重赋值 2> 函数调用时传入参数列表-- 3> table表达式  4>return语句-- function F0(  ) end-- function F1( ) return 'a' end-- function F2( ) return 'a' ,'b' end-- 1. 若一个函数调用是最后一个表达式的时候 --    lua会保留尽可能多的返回值 用于匹配变量-- x,y = F2()-- print(x,y) -- a b-- x = F2()-- print(x) -- a-- x,y,z = 10,F2()-- print(x,y,z) -- 10 a b-- x,y,z = F2(),10-- print(x,y,z) -- a 10 nil-- 2.  如果一个函数没有返回值 或没有返回足够多的值--     那么lua会用nil来补位-- x,y = F0()-- print(x,y) -- nil nil-- x,y = F1()-- print(x,y) -- a nil-- 3. 如果一个函数调用不是一系列表达式的最后一个元素--    那么只产生一个值-- x,y = F2(),10-- print(x,y) -- a 10-- x,y = F0(),20,30-- print(x,y) -- nil 20 值列表大于变量列表 30被舍弃-- x,y = F0(),F1()-- print(x,y) -- nil a -- 4. 当一个函数调用作为另一个函数的最后一个（或仅有）的实参时--    第一个函数的所有返回值都将作为实参传入第二个函数-- print(F0()) -- 空 不是nil-- print(F1()) -- a -- print(F2()) -- a b-- print(F2(),1) -- a 1  符合<3>-- 变长参数 ... -- function Add( ...  )--  local arg = {...}  -- 表结构--  sum  = 0--  for i=1,#arg do--      sum = sum + arg[i]--  end--  return sum-- end-- print(Add(10,10,10))-- function Test( ... )--  length = select("#",...) -- 得到所有参数的长度--  print(length) --  for i=1,length do--  array = select(i,...) -- 得到第i个参数--  print(array) --  end-- end-- Test("测试",2) -- 运行结果 length = 2 array 输出了 aa111 2-- table表mytable = {}-- 通过mytable[key] 方法可以对表中的数据查找或修改mytable["name"] = "wp"mytable["age"] = 80print(mytable["name"],mytable["age"],mytable["money"]) -- wp 80 nilmytable["name"] = "pw"print(mytable["name"],mytable["age"],mytable["money"]) -- pw 80 nil-- 如果对于没有赋值的key其值为nilmytable.age = 79;print(mytable.age) -- 79-- repeat <循环体> until <判断>value = 1repeat    io.write(value," ")    value = value + 1until value == 10 --  1 2 3 4 5 6 7 8 9

– 字符串处理
– 1.字符转数字

-- myStr = "1234"-- myNum = tonumber(myStr) -- int.Parse-- print(myNum)

– 2.数字转换成字符串

-- myNum = 123-- myStr = tostring(myNum)-- print(myStr,type(myStr))

– 3.返回指定的字符串

-- myStr = "hellolua"-- newStr = string.sub(myStr,2,5) -- ello 参数1 要截取的字符串 参数2 从第几个  参数3 截取到几 无参数3 就从参数2开始截取剩下的全部-- print(newStr)

– 4.从字符串的尾部开始截取

-- myStr = "hellolua"-- newStr = string.sub(myStr,-3) -- lua倒着截-- print(newStr)

-- url = "www.kengni.com?"-- www = url.."username='admin'&&userpsd = '123'"-- params = string.sub(www,-(#www - #url))-- print(params)

– 5.格式化字符串 – %s: 与空白字符配对

-- str = string.format("%s%s%s",url,www,2)-- print(str)-- print("\\f")

– 6.string.gsub 函数有三个参数：目标串，模式串，替换串。
– 基本作用是用来查找匹配模式的串，并将使用替换串其替换掉– ：

-- s = string.gsub("Lua is good", "good", "bad?") -- print(s)   -- Lua is bad?

-- pai = 3.1415926-- print(string.format('%.2f',pai)) -- 3.14

– 一个中文字符在lua中占3个字节

-- myStr = "字符串"-- sIndex,endIndex = string.find(myStr,'串')-- print(sIndex,endIndex) -- 7 9 

- myStr = "字符串查找a11.00"-- pattern = "%a%d%d.%d%d"-- sIndex,endIndex = string.find(myStr,pattern)-- print(string.sub(myStr,sIndex,endIndex)) -- 找110

– “%”(取模)：和有的语言的%不一样，a % b == a - floor(a/b)*b 。floor(x) 表示对x向下取整 可以看出来表达式的符号永远和b的符号相同。
– 如果a,b都是整数，%既是求余，这是好理解的。
– 如果a,b中存在实数呢？
– 其实，a,b都为实数计算a%b的大多数情况下都是没有实用价值的。
– 但是特别的，当x为实数的时候：x-x%1就是计算x的整数部分
– 类似的，x-x%0.01就是计算x精确到小数点后两位的结果

– 模式串
– . 任意字符
– %a 字母
– %c 控制字符
– %d 数字
– %l 小写字母
– %p 标点字符
– %s 空白符
– %u 大写字母
– %w 字母和数字
– %x 十六进制数字
– %z 代表 0的字符

– 特殊字符如下：
– (). % + - * ? [ ^ $
– % 也作为以上特殊字符的转义字符。

– 字符加数字
– 查找特殊符号

-- str = "#哈哈#，@#￥12"-- pattern ="#"-- sIndex,endIndex = string.find(str,pattern)-- print(sIndex,endIndex)

-- count = 0-- for jinghao in string.gmatch(str,pattern) do--  print(jinghao)--  print("#出现了",(count + 1).."次")-- end

– [] 该方框作为匹配该范围的集合
– 如[0-9] 则匹配0到9的数字范围
– Lua 中的模式修饰符有四个：
– + 匹配前一字符 1 次或多次，最长匹配
– * 匹配前一字符 0 次或多次，最长匹配
– - 匹配前一字符 0 次或多次，最短匹配
– ? 匹配前一字符 0 次或 1次
– ‘+’，匹配一个或多个字符，总是进行最长的匹配。
– 模式 ‘%a+’ 匹配一个或多个字母或者一个单词
– 如：匹配c中的注释串
– 用 ‘/%.%/’ 和’/%.-%*/’

-- myStr = "#qwe11#wocao#"-- pattern = "#[^%s+]-#"-- for var in string.gmatch(myStr,pattern) do--  print(var)-- end

-- str = "int x; /*x*/  int y; /* y */" -- print("/%*.*%*/")-- print(string.gsub(str, "/%*.*%*/", "<注释串>"),"wea") 

-- str22 = "woshinibabanini"-- print(string.gsub(str22,"ni","nide"))-- str33 = string.gsub(str22,"ni","nide")-- print(str33)

–> int x; <注释串>
–采用 ‘.-’ 则为最短匹配，即匹配 “/” 开始到第一个 “/” 之前的部分：

-- str = "int x; /* x */  int y; /* y */" -- print(string.gsub(str, "/%*.-%*/", "<注释部分>")) 

–> int x; <注释串> int y; <注释串>

– 数组

-- array = {}-- for i=-2,10 do--  array[i] = i+1-- end-- print(array[-1])

– 迭代器

-- function Values( t )--  local i = 0i--  return function (  )--      i = i+1--  return t[i]-- end-- end

– – 定义一个测试数组

-- array = {10,20,30}-- -- 采用自定义迭代器的方式返回数组-- iter = Values(array)-- while true do --  local element = iter()--  if element == nil then break end--  print(element)-- end

– for循环 1.传统for循环 数值for循环
– 2.泛型for循环
– ipairs
– pairs

-- t  = {["name"]="lua",["age"] = 18,188}-- for _,v in ipairs(t) do--  print(v)-- end

– 不是按顺序的 按key的哈希值

-- for _,v in pairs(t) do--  print(v)-- end

– 情况1:表结构实现的是数组 此时2中迭代器没区别

-- t = {1,2,3,4}-- for i,v in ipairs(t) do--  print(i,v)-- end-- for k,v in pairs(t) do--  print(k,v)-- end

– 情况2:表结构为哈希表/字典 对应c#中HashTable Dictionary

-- t = {--  ["name"] = "lua",--  ["age"] = 18-- }-- for i,v in ipairs(t) do --  print(i,v) -- 无输出-- end-- for i,v in pairs(t) do--  print(i,v) -- age 18 name lua-- end-- t = {--  ["name"] = "lua",--  ["age"] = 18,--  [1] = "lua1",--  [2] = "lua2"-- }-- for i,v in ipairs(t) do--  print(i,v) -- 1 lua1    2 lua2-- end

– key为整数，但是不连续

t ={    [1] = "a",    [2] = "b",    [3] = "d"   }-- for i,v in ipairs(t) do --  print(i,v) -- 1 1 2 2-- endfor i,v in pairs(t) do    print(i,v) -- 2 2 1 1 4 4end

– 混合情况 混合的表结构

t = {    1,    2,    3,    [1] = 222,    ["name"] = "lua",    [2] = 333}-- -- for i,v in ipairs(t) do -- --   print(i,v) -- 部分输出 只能输出连续的索引-- -- end

-- for i,v in pairs(t) do--  print(i,v) -- --   1   1-- --   2   2-- --   3   3 -- --  name lua -- end

– concat 连接函数

-- t1 = {"laowang","and","laozhang",1,2,["key"] = "value"}-- print(table.concat(t1),type(table.concat(t1))) -- -- laowangandlaozhang12 string

– insert 插入函数(相当于按下标插入)

--  t2 = {"ello","lua"}--  var = table.insert(t2,1,"h") -- t1 = {"h","ello","lua"}--  print(var) -- nil 没有返回值--  print(t2[1]) -- h --  print(table.concat(t2)) -- hellolua

整理的比较乱 凑合看吧 0.0
有时间在整理整理
附lua学习网站：http://www.runoob.com/lua/lua-tutorial.html