LUA入门以及ipairs pairs的区别

-- 注释行
print("hello world!")

-- 局部变量
local i = 1

--全局变量
name = "iPanda"

print(type("Hello world"))      --> string
print(type(10.4*3))             --> number
print(type(print))              --> function
print(type(type))               --> function
print(type(true))               --> boolean
print(type(nil))                --> nil
print(type(type(X)))            --> string

print(type(a))

-- nil的删除作用
tab1 = { key1 = "val1", key2 = "val2", "val3" }
for k, v in pairs(tab1) do
    print(k .." - " .. v)
end

tab1.key1 = nil
for k, v in pairs(tab1) do
    print(k .. " - " .. v)
end

--nil 作比较时应该加上双引号 "：
print(type(X))
print(nil)
print(type(nil))
print(type("nil"))
print(type(X) == nil)--type(X)==nil 结果为 false 的原因是 type(X) 实质是返回的 "nil" 字符串，是一个 string 类型：
print(type(X) == "nil")
print(type(type(x)))

--boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是 false，其他的都为 true，数字 0 也是 true:
print(type(true))
print(type(false))
print(type(nil))

if false or nil then
    print("至少有一个是 true")
else
    print("false 和 nil 都为 false")
end

if 0 then
    print("数字 0 是 true")
else
    print("数字 0 为 false")
end

--number
print(type(2))
print(type(2.2))
print(type(0.2))
print(type(2e+1))
print(type(0.2e-1))
print(type(7.8263692594256e-06))

--在对一个数字字符串上进行算术操作时，Lua 会尝试将这个数字字符串转成一个数字:
print("2" + 6)

print("2" + "6")
print("2 + 6")
print("-2e2" * "6")
--print("error" + 1)

-- 字符创..连接
print("a" .. 'b')
print(157 .. 428)

--#长度
len = "www.baidu.com"
print(#len)
print(#"www.baidu.com")

--table  Lua 中的表（table）其实是一个"关联数组"（associative arrays），数组的索引可以是数字或者是字符串。
local table = {}

local tbl2 = {"apple", "pear", "orange", "grape"}

a = {}
a["key"] = "value"
key = 10
a[key] = 22
a[key] = a[key] + 11
for k, v in pairs(a) do
    print(k .. " : " .. v)
end

--不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
local tbl = {"apple", "pear", "orange", "grape"}
for key, val in pairs(tbl) do
    print("Key", key)
end

a3 = {}
for i = 1, 10 do
    a3[i] = i
end
print(a[1])
a3["key"] = "val"
print(a3["key"])
print(a3["none"])

function factorial1(n)
    if n == 0 then
        return 1
    else
        return n * factorial1(n - 1)
    end
end
print(factorial1(5))
factorial2 = factorial1
print(factorial2(5))

function testFun(tab,fun)
    for k ,v in pairs(tab) do
        print(fun(k,v));
    end
end
tab={key1="val1",key2="val2"};
testFun(tab,
        function(key,val)--匿名函数
            return key.."="..val;
        end
)

a = 5               -- 全局变量
local b = 5         -- 局部变量

function joke()
    c = 5           -- 全局变量
    local d = 6     -- 局部变量
end

joke()
print(c,d)


do
    local a = 6     -- 局部变量
    b = 6           -- 对局部变量重新赋值
    print(a,b);     --> 6 6
end

print(a,b)      --> 5 6

--a, b = 10, 2*x       -->       a=10; b=2*x

--遇到赋值语句Lua会先计算右边所有的值然后再执行赋值操作，所以我们可以这样进行交换变量的值：
--x, y = y, x                     -- swap 'x' for 'y'
--a[i], a[j] = a[j], a[i]         -- swap 'a[i]' for 'a[j]'

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

a, b = a+1, b+1, b+2     -- value of b+2 is ignored
print(a,b)               --> 1   2

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

--a, b = f() -- f()返回两个值，第一个赋给a，第二个赋给b。

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

--while( true )
--do
--    print("循环将永远执行下去")
--end

--[ 0 为 true ]
if(0)
then
    print("0 为 true")
else
    print("0 为 false")
end

--[[ 函数返回两个值的最大值 --]]
function max(num1, num2)

    if (num1 > num2) then
        result = num1;
    else
        result = num2;
    end

    return result;
end
-- 调用函数
print("两值比较最大值为 ",max(10,4))
print("两值比较最大值为 ",max(5,6))

myprint = function(param)
    print("这是打印函数 -   ##",param,"##")
end

function add(num1,num2,functionPrint)
    result = num1 + num2
    -- 调用传递的函数参数
    functionPrint(result)
end
myprint(10)
-- myprint 函数作为参数传递
add(2,5,myprint)

function maximum (a)
    local mi = 1             -- 最大值索引
    local m = a[mi]          -- 最大值
    for i,val in ipairs(a) do
        if val > m then
            mi = i
            m = val
        end
    end
    return m, mi
end

print(maximum({8,10,23,12,5}))

function add(...)
    local s = 0
    for i, v in ipairs{...} do   --> {...} 表示一个由所有变长参数构成的数组
        s = s + v
    end
    return s
end
print(add(3,4,5,6,7))  --->25

function average(...)
    result = 0
    local arg={...}    --> arg 为一个表，局部变量
    for i,v in ipairs(arg) do
        result = result + v
    end
    print("总共传入 " .. #arg .. " 个数")
    return result/#arg
end

print("平均值为",average(10,5,3,4,5,6))

function f(...)
    a = select(3,...)  -->从第三个位置开始，变量 a 对应右边变量列表的第一个参数
    print (a)
    print (select(3,...)) -->打印所有列表参数
end

f(0,1,2,3,4,5)

do
    function foo(...)
        for i = 1, select('#', ...) do  -->获取参数总数
            local arg = select(i, ...); -->读取参数，arg 对应的是右边变量列表的第一个参数
            print("arg", arg);
        end
    end

    foo(1, 2, 3, 4);
end

array = {"Google", "Runoob"}

for key,value in ipairs(array)
do
    print(key, value)
end

--Lua中ipairs和pairs的区别详解
--区别一：ipairs遇到nil会停止，pairs会输出nil值然后继续下去
--区别二：ipairs并不会输出table中存储的键值对，会跳过键值对，然后顺序输出table中的值，遇到nil则会停止。
--而pairs会输出table中的键和键值对，先顺序输出值，再乱序（键的哈希值）输出键值对。
--这是因为，table在存储值的时候是按照顺序的，但是在存储键值对的时候是按照键的哈希值存储的，并不会按照键的字母顺序或是数字顺序存储。
--=》对于a来说，如果执行print(a[3]),输出的结果也会是Good。也就是说table并不会给键值对一个索引值。
--也就是说，ipairs知识按照索引值顺序，打印出了table中有索引的数据，没有索引值的不管。
--而pairs是先按照索引值打印，打印完成后再按照键值对的键的哈希值打印它的值。
local a = {"Hello", "World", a = 1, b = 2, x = 10, y = 20, "Good", nil, "Bye"}
 for i,v in ipairs(a) do
     print(v)
 end

print("------------")
for k,v in pairs(a) do
    print(k,v)
end

--所以，怎么顺序输出一个table里面的键值对？
local tab = {
    key1 = 1,
    key2 = 2,
    key3 = 3,
    key4 = 4,
    key5 = 5,
    key6 = 6,
    key7 = 7,
}

function getLen(tab)
    local len = 0
    for _,v in pairs(tab) do
        len = len + 1
    end
    return len
end

local key
for i=1,getLen(tab) do
    key = "key"..i
    print(key, tab[key])
end