Lua 入门

Lua 是一个不错的嵌入式脚本，在游戏，Redis，Nginx 等诸多模块都有应用
解释效率高，可以说是精巧，灵活。

Lua 官网

Lua 官方安装方式

Lua 非常容易构建和安装。 这个包中有 详细的说明，但这里是一个简单的终端会话，下载当前版本的 Lua 并在 Linux 中构建它：

curl -R -O http://www.lua.org/ftp/lua-5.3.4.tar.gz 
tar zxf lua-5.3.4.tar.gz cd lua-5.3.4 
做linux测试

对于 Mac OS X，请使用 make macosx test。

个人安装方式

1. 到官网安装了 lua 包，我安装的是 lua-5.3.4
2. 解压之后，命令行 cd 进入到 src 目录下，输入 make macosx

• 完成后 cd .. 到上一层目录， 输入 sudo make install

安装成功后，可以使用如下命令测试。
lua -v 查看当前 lua 的版本
which lua 查看 lua 的安装目录

（Mac 用的还不是很熟练，会小伙伴可以留言讲一下
1make macosx 的作用
2make macosx 与 make macosx test 有区别吗）

选择一款编辑器

Sublime（个人使用 Brackets）

            菜单 Tools -> Build System -> New Build System

            // Mac 配置
            {  
             "cmd": ["/usr/local/bin/lua", "$file"],  
             "file_regex": "^(...*?):([0-9]*):?([0-9]*)",  
             "selector": "source.lua"  
            }  

            // Windows 配置
            { 
                "cmd": ["C:/Program Files (x86)/Lua5.3/luac.exe", "$file"], 
                 "file_regex": "^(?:lua:)?[\t ](...*?):([0-9]*):?([0-9]*)", 
                 "selector": "source.lua" 
            }

基础语法

单行注释 --
块注释 --[[...]]
全局变量 b=10
删除变量 b=nil

类型与值

    • nil（空）
    • boolean（布尔）
    • number（数字）
    • string（字符串）
    • table
    • function（函数）
    • userdata（自定义类型）和 thread（线程）

函数 type 可根据一个值返回其类型名称

Lua将值false和nil视为“假”，而除此之外的其他值视为“真”。

table 类型实现了“关联数组”。“关联数组”是一种具有特殊索引方式的数组。不仅可以通过整数来索引它，还可以使用字符串或其他类型的值（除了 nil）来索引它

a = { }             -- 创建一个table，并将它的引用存储到a
                k = "x"
                a[k] = 10           -- 新条目，key = "x", value = 10
                a[20] = "great"     -- 新条目，key = 20, value = "great"
                print(a["x"])       -- 10

a = { }
                x = "y"
                a[x] = 10           -- 将10放入字段“y”
                print(a[x])         -- 10 字段“y”的值
                print(a.x)          -- nil 字段“x”（未定义）的值
                print(a.y)          -- 10 字段“y”的值

function（函数）

  Lua 既可以调用以自身 Lua 语言编写的函数，又可以调用以 C 语言编写的函数。Lua 所有的标准库都是用 C 语言写的，标准库中包括对字符串的操作、table 的操作、I／O、操作系统的功能调用、数学函数和调试函数。同样，应用程序也可以用 C 语言来定义其他函数。

    function function_name( )
        -- body
    end

算术操作符

    例如：
        x^0.5 将计算x的平方根
        x^(-1/3) 将计算x立方根的倒数

    取模操作符是根据以下规则定义的：
        a%b == a - floor(a/b)*b

    例如：
        x%1 的结果就是x的小数部分
        x - x%1 的结果就是其整数部分
        x - x%0.01 则是x精确到小数点后两位的结果

        x = math.pi
        print(x - x%0.01)   --> 3.14

关系操作符

    <、>、<=、>=、==、~=
    所有这些操作符的运算结果都是true或false。

    操作符==用于相等性测试，操作符～=用于不等性测试。
    这两个操作符可以应用于任意两个值。

    如果两个值具有不同的类型，Lua就认为它们是不相等的。
    否则，Lua会根据它们的类型来比较。

    nil只与其自身相等。

    对于table、userdata和函数，Lua是作引用比较的。
    也就是说，只有当它们引用同一个对象时，才认为它们相等。

    a = {}; a.x = 1; a.y = 0
    b = {}; b.x = 1; b.y = 0
    c = a
    其结果是a==c，但a~=b。

Lua 会在遇到字符串和数字的大小比较时引发一个错误，例如 2<"15" 就会导致这种错误。

逻辑操作符

    and、or、not
    与条件控制语句一样，所有的逻辑操作符将false和nil视为假，而将其他的任何东西视为真。

    对于操作符and来说，如果它的第一个操作数为假，就返回第一个操作数；不然返回第二个操作数。

    对于操作符or来说，如果它的第一个操作数为真，就返回第一个操作数；不然返回第二个操作数。

    print(4 and 5)        --> 5
    print(nil and 13)     --> nil
    print(false and 13)   --> false
    print(4 or 5)         --> 4
    print(false or 5)     --> 5

    and和or都是用“短路求值”，也就是说，它们只会在需要时才去评估第二个操作数。
    短路求值可以确保像（type(v)=="table" and v.tag == "h1"）这样的表达式不会导致运行时错误。

    有一种常用的Lua习惯写法“x = x or v”，它等价于：
    if not x then x = v end

    另外，还有一种习惯写法是“（a and b）or c”，这类似于C语言中的表达式a?b:c，但前提是b不为假。
    例如，为了选出数字x和y中的较大者，可以使用以下语句：
    max = (x > y) and x or y

    操作符not永远只返回true或false：
        print(not nil)        --> true
        print(not false)      --> true
        print(not 0)          --> false
        print(not not nil)    --> false

字符串连接

  要在 Lua 中连接两个字符串，可以使用操作符“..”（两个点）。如果其任意一个操作数是数字的话，Lua 会将这个数字转换成一个字符串：

    print("Hello" .. "World")    --> Hello World
    print(0 .. 1)                --> 01

Lua 模拟链表

每当 Lua 评估一个构造式时，都会先创建一个新 table，然后初始化它。

    -- 用table实现链表：

    list = nil
    for line in io.lines() do            -- 从标准输入读取每行的内容
        list = {next=list, value=line}   -- 按相反的次序存储到一个链表中
    end

    -- 遍历该链表

    local l = list
    while l do
        print(l.value)
        l = l.next
    end

对于某些情况如果真的需要以 0 作为一个数组的起始索引的话，通过这种语法也可以轻松做到：

days = {[0]="Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"}

  现在第一个值“Sunday”的索引就为 0 了。这个索引 0 并不影响其他元素，“Monday”照常索引为 1，因为它是构造式中列表风格中的第一个值，后续其他值的索引依次递增。但无论是否使用这种初始化语法，都不推荐在 Lua 中以 0 作为数组的起始索引。大多数内建函数都假设数组起始于索引 1，若遇到以索引 0 开始的数组，它们就无法进行正确地处理了**。

赋值

    a = "hello" .. "world"
    t = { n = 0 }
    t.n = t.n + 1

  Lua 允许“多重赋值”，也就是一下子将多个值赋予多个变量。每个值或每个变量之间以逗号分隔。

    a, b = 10, 2*x    -- a为10，b为2*x

  在多重赋值中，Lua 先对等号右边的所有元素求值，然后才执行赋值。这样便可以用一句多重赋值来交互两个变量了。

    x, y = y, x                    -- 交换x与x
    a[i], a[j] = a[j], a[i]        -- 交换a[i]与a[j]

  Lua 总是会将等号右边值的个数调整到与左边变量的个数相一致。规则是：若值的个数少于变量的个数，那么多余的变量会被赋予 nil；若值的个数更多的话，那么多余的值会被“静悄悄”丢弃掉：

    a, b, c = 0, 1
    print(a, b, c)            --> 0 1 nil
    a, b = a+1, b+1, b+2      -- 其中b+2会被忽略
    print(a, b)               --> 1 2
    a, b, c = 0
    print(a, b, c)            --> 0 nil nil

就先看到这里，感觉写点什么出来，实践出真知嘛

Lua 实现冒泡排序

function sort(a)
    for i=1,#a-1 do
        for j=1,#a-i do
    if a[j]>a[j+1]
    then a[j],a[j+1]=a[j+1],a[j];
    end
        end
    end
end

array={}
flag=true
i=1
while flag do
print('添加数字,输入非数字结束')
num=io.read("*number")
if num 
then array[i]=num
else
break
end
i=i+1
flag=io.read("*number")

print('length-in:'..#array)
end

print('length:'..#array)
sort(array)
for i=1,#array do print(array[i]) end

Lua IO 库

保存该段代码为 sort.lua
命令行 输入 lua /path/to/sort.lua
就可以看到效果了