Lua的学习

Lua的基本语法

第一章 起点

1.1、全局变量：Lua中默认的变量为全局变量，只有加上 local 才是局部变量,全部变量不赋值，直接访问得到的结果是 nil，同时把一个变量直接赋值为 nil 就是把这个变量给删除

1.2、词法约定：字母数字下划线组成，字母开头。
Lua 大小写敏感。
单行注释： –
多行注释： –[[ –]]

1.3、Lua的关键字：if then elseif end while for in do false true nil and not or repeat until local function return break

    Lua中只有 false 和 nil 为假 ，其余的都为真。
     0在 Lua 中为真值，Lua 的table 列表索引值是从 1 开始的，而不是从 0 开始的。
     Lua中的变量不需要类型的声明，没有赋值之前变量的类型都是未定的。

第二章 类型和值

Lua中的数据类型：nil boolean number string userdata function thread table
变量没有预定义的类型，每个变量都可以包含任何一种类型的值。

2.1、Nil：
nil Lua中的特殊类型，一个全局变量没有赋值之前都是 nil ，给一个全局变量赋值 nil 可以删除该变量。

2.2、Booleans:
两个取值 false 和 true。但是 Lua 中只有 false 和 nil 为假值，其余的值都是真。包括 0 和 空字符串。

2.3、string：
“” ”括起来的都是字符串，
[[
]]括起来的字符串可以包含多行

    string可以和number进行转化 

        print("10" + 2)       --> 12
        print("22" * 2)       --> 44 
        print("number" + 2)   --> error

    .. 在Lua中是字符串连接符，当在一个数字的后面写 .. 时，必须加上空格以防止被解释错误。

        print(10 .. 20)  --> 1020
        print(10..20)    -->error

    tonumber()函数是将字符串转化为数字，tostring()函数是将数字转化为字符串。

2.4、Functions：
函数可以存储在变量中，也可以作为函数的参数，可以作为返回值。在Lua中函数就是一个类型。

第三章 表达式

3.1、算术运算符：
二元运算符：+ - * / ^ (加减乘除幂)
一元运算符：- (负值)

3.2、关系运算符：

= < <= == ~= (在Lua中 ~= 是不等于)
这些操作符返回是 false 和 true
== 和 ~= 比较的类型如果不一致 Lua就认为是 false
nil 只能和自己比较
table userdata function 在Lua中是通过引用比较的，也就是当且仅当两者表示同一对象时才是相等的。

3.3、逻辑运算：

                and or not

            a and b  --若果 a 为 false,则返回 a ,否则，返回 b  相当于 C 语言的 &
            a or b   --如果 a 为 true ,则返回 a ,否则，返回 b  相当于 C 语言的 |

            C 语言中的三元运算符
            a ? b : c
            在Lua中的实现
            (a and b) or c

            not 的结果一直返回 false 或者 true

3.4、链接运算符：
.. – 两个点
如果操作数是数字，第一个数字后必须有空格，而且被转化成字符串

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

3.5、表table：
初始化方法：
1、a = {} –空表
2、a = {1,3,4;”abc”;x=19} –直接初始化 用;表示不同类型的元素
3、a = {} –先创建一个空表
a.x = 1; a.y = 2
相当于：a = {x = 1,y = 2,} –尾部可以加 , 方便以后的扩展

        Lua中可以随意添加或删除元素，删除元素只需要把该元素赋值 nil

第四章 基本语法

4.1、赋值语句：
a = 1

         Lua中可以对多个变量同时赋值：a , b = 1 , 2  <==> a = 1 ; b = 2

         多个变量进行赋值时：
         a. 变量的个数 > 值的个数时： 多余的变量直接赋值为 nil
         b. 变量的个数 < 值的个数时： 多余的值直接被忽略

            a , b , c = 0, 1
            print(a,b,c)        --> 0 1 nil

            a,b = a+1,b+1,b+2  
            print(a,b)          -->1 2

            a,b,c = 0
            print(a,b,c)        --> 0 nil nil 

4.2、局部变量 local:
Lua中的变量默认是全局变量，只有加上 local 才是局部变量

        do end 相当于 C/C++中{}
        应尽量使用局部变量的好处：
                                a.避免命名冲突
                                b.局部变量的访问速度比全局变量要快很多

            do
                local a = 1
                print(a)        --1
            end
            print(a)            --nil

4.3、控制结构语句
if 语句，三种：

                            1.  if conditions then
                                    --body
                                end

                            2.  if conditions then
                                    --body
                                else
                                    --body
                                end

                            3.  if conditions then
                                    --body
                                elseif conditions then
                                    --body
                                    --可以有多个elseif
                                else 
                                    --body
                                end

            while 语句:

                            while conditions do
                                --body
                            end

            repeat-until 语句：

                            repeat
                                --body
                            until conditions

            for 语句有两大类：

                        a.数值 for 循环

                            for var = exp1,exp2,exp3 do
                                --body
                            end

                        其中exp3作为step 从exp1（初始值）到exp2（终止值）,执行 --body
                        exp3可以省略 默认step 是 1

                        需要注意的地方：
                        1.三个表达式只会被计算一次，并且在循环开始前
                        2.其中变量var是局部变量，在只在循环内有效
                        3.循环过程中不要改变控制变量的值

                        b.范型 for 循环

                            for i,v in ipairs(a) do
                                print(i,v)
                            end

                            for k in pairs(t) do
                                print(t[k])
                            end

                        ipairs 和 pairs 的区别：
                                                ipairs 是按照 key 索引值递增的顺序访问 table 中的键-值队的
                                                pairs  是访问所有的键-值队的

                        例子：
                        a = {1,2,3,x=5,5}

                        for i,v in pairs(a) do
                            print(i,v)             
                        end
                        --> 把顺序打乱了，先按照索引值递增的顺序输出
                        1 1
                        2 2
                        3 3
                        4 5
                        x 5

                            for i,v in ipairs(a) do
                                print(i,v)
                            end

                        --> 只按照索引值输出
                        1 1
                        2 2
                        3 4
                        4 5

4.4、break 和 return 语句：
break 语句用来退出当前循环
return 语句用来从函数返回结果

第五章 函数

语法：

    function function_name( arguments-list )
        -- body
    end

    function_name = function( arguments-list )
        -- body
    end

函数调用时需要注意的：
1.如果参数列表为空，必须加上 ()
2.如果是单个参数，且这个参数是字符串或表构造时， () 是可选的
3.Lua函数实参和形参的匹配和赋值语句类似，多余忽略，缺少补上 nil

            1.Lua中的函数可以返回多个结果值
            2.Lua中的函数跟 C 语言一样可以是可变参数
            3.Lua中的函数跟 C++ 一样可以命名参数

Lua中的函数词法定界的第一类值。
第一类值：Lua 中的函数像其他值一样可以放在变量中，表中，函数的参数，函数的返回值
词法定界：Lua 中的被嵌套的函数可以访问他外部函数的变量。

函数闭包：

        function newCounter()     --定义一个函数闭包
            local i = 0           --局部变量 i
            return function ()    --匿名函数
                i = i + 1
                return i
            end
        end
        c1 = newCounter()         --创建一个闭包
        c2 = newCounter()         --创建一个闭包

        print(c1())               -- 1
        print(c2())               -- 1
        print(c1())               -- 2

第六章 表

lua中的数据结构只有一个：表table
原理：键值对 key-value

6.1 table 表示一个数组
数组的下标为正整数，且索引值是从 1 开始的。
（1） 数组的定义：
t = {值1 ， 值2 ，值3 ，… , 值n}
（2）获取数组元素的个数：#t
例子：
t = {1,2,3,4,5,6}

6.2 table表
例子：
t = {x = 1 ,y = 2 ,z = 3}

完全的键值对，也可以是键值对和数组的混合

6.3 table表的使用
t[1],t[2] 这种按照下标来取值的
t.x t.y 这种按照键来取值的
t[“x”] t[“y”] 这种也可以的

注意：t[“x”] 是无效的

最有Lua中导入文件：
搜索目录加载文件，并判断文件是否已经加载，避免重复加载统一文件。

require”hello”
require(“hello”)