• lua安装 
* 官网：www.lua.org
* make 
* sudo make install
  * 如果敲完命令 make linux test 出错那就需要安装 libreadline
  * 命令：sudo sudo apt-get install libreadline-dev
  * 命令：make 之后 sudo make install

lua安装--如何在vscode中安装
* 安装插件 lua   （0.0.9这个)
* 安装插件 lrdb

  • lua语法
* 注释  --被注释的内容  或 --[[被注释的内容 ]]

* 变量  
      全局变量 无类型直接写变量名 = 参数
      局部变量 local 变量名 = 参数

* 字符串 
      ""  或   ''   或   [[ ]]
       --最后这种可换行输入

* io
      io.write("sdf",变量名,#变量名,type(变量名）"\n")   
      io.read()    从终端读字符串
       
       --打印字符串（一个或多个)
       --#变量名        字符串长度
       --type(变量名)   变量类型  
       --lua中数字或浮点数字都为 number类型
       --9223372036854775807为最大整数显示，超过将用科学计数法（1-9.13位e+共多少位）（注意：如果在加法计算中超过这个最大数则会错误显示成负数，如果加之前已经得用科学计数法显示，则正常执行计算）
       --浮点数值精确到小数点后13位
       --math.floor(2.345)    2
         math.ceil(2.345)     3
         math.max(2,3)        3
         math.min(2,3)        2
         math.pow(8,2)        64
         math.sqrt(64)        8
         math.pi         圆周率
         math.random(随机范围)   随机数
         math.randomseed(os.time())  --使我们相同时间段产生的随机数一样
         string.format(格式，变量)
         string.len(子服串)    和#作用一样   
         true   false   是boolean类型
         tostring(not true)   得到flase
         string.gsub(字符串，参数1中的需要被替换字符串，用用这里的字符串来替换参数2的字符串)
         string.find(字符串,想在参数1中查找的字符串)
         string.upper(字符串)  --把字符串全变成大写
         string.lower(字符串)  --把字符串全变成小写
         string.gmatch(字符串，正则表达式)
          --字符串求和用   ..
          --数字求和用     +
          --由于变量是动态的，所以纯数字的字符串遇到数字也会变为数字类型

* 函数与函数调用
      函数     
       function function_name( ... )
       -- 这里是函数体内部
       end

       function_name = function() 
       -- 这里是函数体内部
       end

      函数调用
       function_name( ... )

      --------------------------------------------
      函数传参
       --不指定传入的参数   ,无参调用
       --指定传入的参数     ,指定几个传入几个
       --括号位置填入 ...   ,可传入任意数量的参数（包括一个不传）
      函数返回值
       --可以没有返回值
       --可以返回一个或多个返回值
      闭包（工厂）
       --函数返回了一个函数内部的函数，这个内部函数引用了外部函数中的局部变量，内部函数不调用不释放，因此局部变量的值被内部函数保存了下来（即内层函数形成了闭包）
        --闭包调用（先创建）
         1--   变量 = 闭包函数       -- 先创建
         2--   变量()               -- 再调用

* 条件语句
      if 条件 then
            条件满足后执行的语句
      else 
            条件不满足执行的语句
      end

       -- > <  >=  <=  ==   ~=
       -- and   or   not

      -----------------------------------

      a > b and true or false

       -- a > b ? true : false

* 循环语句
      for 变量=初始值，最大值,递增值 do
            循环体内部执行的语句
      end

       --break    跳出循环

       -- 递增值可以不写，不写默认为1，只写两个参数即可

      -----------------------------------

      while (变量<数值) do
            循环体内部执行的语句
      end

       --break    跳出循环

      -----------------------------------

      repeat
            循环内部
      until tonumber(变量) == 数值

      ------------------------------------

* 表
      config = { }          --定义了一个空表
      config.变量名 = 参数    --定义了一个表中的变量
      config["变量名"] = 参数  --同上
      config['变量名'] = 参数  --同上

      使用方法同变量使用方法一致 config.变量名 或 config["变量名"] 或 config["变量名"]

      --定义表的时候对表做初始化  只能用者两种变量初始化方式
      config = {["变量名_1"] = 参数, ['变量名_2'] = 参数}   

      遍历                                       -- (迭代器)
            for 标志1:标志2 in pairs(遍历对象) do
                   print(标志1,标志2)      
            end

             --标志1 代表变量这一列
             --标志2 代表变量值这一列（赋予变量的参数这一列）
             --接收函数无数参数时pairs{...}

      数组
            arr = {}              --定义一个空数组
            arr = {1,2,"hello"}   --定义数组并初始化元素

      table
          table.insert(被插入数据的对象，每次插入数据的位置，插入的数据)
          table.concat(查看的表，用来隔开数据的字符串)
          table.remove(表变量，要删除哪个位置的数据)

            //table.maxn( 参数 )     --返回最大数字key（即元素总个数）

      元表
             __add    对应的运算符 '+'
             __sub    对应的运算符 '-'
             __mul    对应的运算符 '*'
             __div    对应的运算符 '/'
             __mod    对应的运算符 '%'
             __unm    对应的运算符 '-'
             __concat    对应的运算符 '..'
             __eq    对应的运算符 '=='
             __lt    对应的运算符 '<'
             __le    对应的运算符 '<='
            注意：__是两个下划线

            setmetatable(普通表名,元表名)    
             -- 设置 普通表 可以 使用元表 重载的运算符



* 协同程序
      coroutine.create()   --创建 coroutine，返回 coroutine， 参数是一个函数，当和 resume 配合使用的时候就唤醒函数调用
      coroutine.status()   --查看 coroutine 的状态。  注：coroutine 的状态有三种：dead，suspended，running
      coroutine.yield()    --挂起 coroutine，将 coroutine 设置为挂起状态，这个和 resume 配合使用能有很多有用的效果
      coroutine.resume()   --重启 coroutine，和 create 配合使用
* 文件
       --r    以只读方式打开文件，该文件必须存在。
         w    打开只写文件，若文件存在则文件长度清为0，即该文件内容会消失。若文件不存在则建立该文件。
         a    以附加的方式打开只写文件。若文件不存在，则会建立该文件，如果文件存在，写入的数据会被加到文件尾，即文件原先的内容会被保留。（EOF符保留）
         r+    以可读写方式打开文件，该文件必须存在。
         w+    打开可读写文件，若文件存在则文件长度清为零，即该文件内容会消失。若文件不存在则建立该文件。
         a+    与a类似，但此文件可读可写
         b    二进制模式，如果文件是二进制文件，可以加上b
         +    号表示对文件既可以读也可以写
      file = io.open("test.lua", "r")  --以只读方式打开文件
      file:read()  --读文件   
      file:write() --写文件
      file:seek("set",0)  --让光标回到文件初始位置
      file:close() --关闭文件

       --"*n"    读取一个数字并返回它。例：file.read("*n")
       --"*a"    从当前位置读取整个文件。例：file.read("*a")
       --"*l"（默认）    读取下一行，在文件尾 (EOF) 处返回 nil。例：file.read("*l")
       --number    返回一个指定字符个数的字符串，在 EOF 时返回 nil。例：file.read(5)
* 模块
      模块定义
        -- 文件名为 module.lua
        -- 定义一个名为 module 的模块
       module = {}   --模块头

        --模块内部APi格式
            -- 定义一个常量
            module.constant = "这是一个常量"
            
            -- 定义一个函数
            function module.func1()
             io.write("这是一个公有函数！\n")
            end
            
            local function func2()
             print("这是一个私有函数！")
            end
            
            function module.func3()
             func2()
            end
            
       return module      --模块尾部
      
      ------------------------------------

      模块加载和使用
       require("模块名")  或  require "模块名"
       使用时   module.func1()  模块名.方法名

      给加载的模块取别名
       a = require("模块名")  或  a = require "模块名"
       使用时   a.func1()       别名.方法名

  • 附录

  • lua正则表达式网址

  • lua教程网站