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

--[=[
1111111
222
多行注释
]=]--

-- 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"] = 80
print(mytable["name"],mytable["age"],mytable["money"]) -- wp 80 nil
mytable["name"] = "pw"
print(mytable["name"],mytable["age"],mytable["money"]) -- pw 80 nil
-- 如果对于没有赋值的key其值为nil

mytable.age = 79;
print(mytable.age) -- 79

-- repeat <循环体> until <判断>
value = 1
repeat
    io.write(value," ")
    value = value + 1
until 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
-- end
for i,v in pairs(t) do
    print(i,v) -- 2 2 1 1 4 4
end

– 混合情况 混合的表结构

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