lua学习之复习汇总篇

时间  2020-02-19
标签 lua 学习 复习 汇总 栏目 Lua 繁體版
原文   原文链接

第六日笔记

1. 基础概念

程序块

定义

  1. 在 lua 中任何一个源代码文件或在交互模式中输入的一行代码
  2. 程序块能够是任意大小的
  3. 程序块能够是一连串语句或一条命令
  4. 也可由函数定义构成，通常将函数定义写在文件中，而后用解释器执行这个文件
  5. 换行在代码中不起任何做用，只是为了提高可读性
  6. 分隔符 ; 起分隔做用
a = a * 2 
b = a * b

a = a * 2;
b = a * b

a = a * b; b = a * b
a = a * b b = a * b

交互模式

在交互模式中输入的一行内容会被解释器看成一个完整的程序块，若是这一行的内容不足以构成一个完整的程序块，就会等待输入html

退出交互模式
  1. Ctrl + Z 是 end-of-file 控制字符，在 dos 中是这个快捷键
  2. os.exit() 标准库中的退出函数

区域设置

  1. lua 中识别什么是字母是经过区域设置来判别的
  2. 如设置希腊，就能够识别希腊字母做为变量
  3. 但在不支持该区域的系统上没法执行

执行函数文件

  1. lua 函数文件路径
  2. dofile("文件路径 / 须要转义") 加载函数库
-- 阶乘函数
function fact(n) 
    if n == 0    then
        return 1 --0 的阶乘是 1
    else
        return n * fact(n - 1) -- 3 的阶乘， 3 * 2 * 1
    end
end
print("Enter a number:")
a = io.read("*number")  -- 读取用户输入且需为数字类型的
print(fact(a)) --调用阶乘函数，并传入实参 a 

-- lib1 函数库
function norm(x, y)
    return (x ^ 2 + y ^ 2) ^ 0.5  -- 两个数的平方和再开平方根
end
function twice(x)
    return 2 * x -- 一个数的两倍
end

标识符

定义

  1. 由任意数字、字母、下划线构成的字符串叫作标识符
  2. 标识符不能由数字开头
  3. 标识符不能如下划线开头后跟多个大写字母
  4. 如: _PROMPT, _VERSION
  5. lua 将它们保留用做特殊用途，被称为哑变量
_PROMPT = ">lua"  -- 修改交互模式中的提示符，默认为 >

保留字

流程控制
  1. if
  2. then
  3. elseif
  4. end
  5. for
  6. do
  7. in
  8. while
  9. repeat
  10. until
if 条件表达式 then
    elseif 条件表达式 then
end
for 控制变量, 终止变量, 步长 do
     <循环体>
end
a = {}
for i,v in ipairs(a) do
    <循环体>
end
while i < 10 do
    i = i + 1
    print(i)
end
repeat
    i = 0
    i = i + 1
until i > 10
条件控制
  1. true
  2. false
逻辑控制
  1. and
  2. or
  3. not
类型
  1. function
  2. local
  3. nil
须要注意的点
  1. nil == nil 是相等的
  2. and 和 And 不一样，lua 区分大小写
  3. lua 中条件值不只仅只有 true 和 false
  4. 在 lua 中任何值除了 false 和 nil 均可以用做表示「真」
  5. 包括空字符串 "" 和数字 0

注释

  1. 单行注释 --
  2. 多行注释 --[[]]
  3. 使多行注释中的代码生效 ---[[ <代码块> --]]
  4. 多行注释中包含多行注释 --[==[ <多行注释> ]==]

全局变量

  1. 全局变量不须要声明，只须要将一个值赋给它便可
  2. lua 中能够访问一个未初始化的变量且不会发生错误
  3. 但这个未初始化的变量的值为 nil
  4. 删除全局变量赋值 nil 便可
  5. lua 将全局变量存储在一个普通的 table 中

解释器

参数

  1. -i 先执行程序块，后进入交互模式
  2. -e 直接执行代码块
  3. -l 加载库文件

解释器执行参数前

  1. 会先寻找一个叫作 LUA_INIT 的环境变量
  2. 找到了，且内容为 @文件名 的话，就执行这个文件
  3. 没找到，就假设内容为 lua 代码， 并执行

解释器运行脚本前

  1. lua 将脚本前的参数存储到 arg 这个 table 中，用做启动参数
  2. 脚本名在这个 table 中的索引为 0，其后参数依此类推
  3. 脚本名前的参数为负数索引 
lua -i -e "hello" script a b 
arg[0] = "script"
arg[1] = "a"
arg[-1] = "hello"
arg[-2] = "-e"
arg[-3] = "-i"
  1. 在 lua 中也能够经过变长参数语法来检索脚本参数
  2. 变长参数为 ... 三个点，做为函数参数传递时表示传递全部参数

2. 类型与值

  1. lua 是动态类型语言
  2. 每一个值都携带有它的类型信息

获取值的类型

  1. type() 能够返回一个值的类型名称
  2. type()的返回结果永远是 string 类型的
print(type(3)) -- number
print(type("a")) -- string
print(type({"a", "b", "c"})) -- table
print(type(io.read)) -- function
print(type(true)) -- boolean

number

  1. 实数，即双精度浮点数
  2. 可以使用科学计数法，如 2e2 表示 200
  3. 可从新编译 lua，使用其余类型的值来表示数字类型，如 long
  4. tonumber() 用于将一个字符串显式的转换为数字类型

boolean

  1. 在 lua 中，有两个布尔值一个是 true 表示为「真」，一个是 false 表示为「假」
  2. 但，这两个值不是用来表示条件的惟一值，在 lua 中 除 nil 和 false 外的任何值，均可以用来表示

    「真」， 包括空字符串 "" 和数字 0数组

nil

  1. 只有一个值，nil
  2. 仅用来表示为空，表示未初始化的变量或 table 元素
  3. 也可用来删除变量或 table 元素

string

  1. 是对象，由自动内存回收器进行分配和释放
  2. 是字符序列，是8位编码
  3. 能够包含数值编码，如二进制
  4. lua 中的字符串是惟一不可变的值
  5. .. 字符串链接符，用于链接两个字符串，但数字类型使用时须要用空格隔开
  6. # 长度操做符，后跟字符串，能够获取字符串长度
  7. [[]] 在期内的特殊字符不须要转义
  8. [==[ <多行注释> ]==] 能够正确打印多行注释的内容
  9. "3" + 4 这样的值会是 number 类型，发生了运行时隐式转换
print("\97" == "a") -- 在 ASCII 编码表中，\97 表示为 a
print(type(3 .. "")) -- string
print(3..4) --报错
print(3 .. 4) -- 34
print(#"hello") -- 5

-- 获取子串，证实字符串是不可变的值
a = "hello"
b = a .. " ,world"
print(a) -- hello
print(b) -- hello, world
a = [[
    <html>
        <head><title>芜湖</title></head>
        <body></body>
    </html>
]]
a = [==[
    --[[
        print("多行注释")
        print("多行注释")
    ]]
]==]
print(type("3" + 4)) -- number

显式转换为字符串

  1. tostring()
  2. .. "" 任意数字链接一个空字符串便可转换为字符串

table

  1. 是对象，由自动内存回收器进行分配和释放
  2. table 没有固定大小，能够动态添加元素
  3. {} 是 table 构造式，用来建立一个 table
  4. # 长度操做符能够获取 table 的大小
  5. table 中的元素在未被初始化前都是 nil
  6. 能够将 table 中的元素赋值 nil 来进行删除
  7. 若是 table 中间部分的元素值为 nil 就说明这是一个有「空隙」的 table
  8. 有「空隙」的 table 要使用 table.maxn() 来返回这个函数的最大正索引数
  9. table 能够用来表示模块、包、对象
  10. table 中的索引能够是任何值，除了 nil
  11. table 是匿名的
  12. 程序仅保留了对 table 的一个引用
  13. 一个仅有 table 的变量和 table 自身并无关系
  14. a.x 等价于 a["x"] 是以字符串为索引的
  15. a[x] 是以变量 x 为索引的 
a = {}
for i = 1, 10 do
    a[i] = i
    print(a[i])
end
for i = 1, #a do
    print(a[i])
end
print(a[10]) -- 10
print(#a) -- 10
a[10] = nil
print(#a) -- 9
a[10000] = 666
print(#a) -- 9
print(table.maxn(a)) -- 10000
a = {}
b = {}
c = a 
print(type(a == b)) -- false
print(type(a == c)) -- true
x = "y"
a["x"] = 666
a["y"] = 777
print(a.x) --666
print(a[x]) -- 777

function

  1. 第一类值
  2. 能够存储在变量中
  3. 能够做为函数的返回值或参数
  4. lua 能够调用自身编写的函数也能够调用 C 语言编写的函数
  5. lua 标准库中的函数都是用 C 语言编写的

userdata

  1. 由应用程序或 C 语言编写建立的新类型
  2. 没有太多的预约义操做
  3. 仅用来作赋值和条件测试

3. 表达式

定义

  1. 表达式用于表示值
  2. 在 lua 中，函数调用，函数定义，数字常量、字面字符串，变量，一元和二元操做符，table 构造式都是表达式

算数操做符

一元操做符

  1. - 负号

二元操做符

  1. +
  2. - 减号
  3. *
  4. /
  5. %
  6. ^
-- % 的技巧
-- x % 1
print(3.13 % 1) -- 获得小数部分
-- x - x % 1
print(3.14 - 3.14 % 1) -- 获得整数部分
-- x - x % 0.1
print(3.14 - 3.14 % 0.1) -- 获得整数部分 + 一位小数部分
-- x - x % 0.01 以此类推，是整数部分 + 两位小数部分

关系操做符

  1. >
  2. <
  3. >=
  4. <=
  5. == 相等性判断
  6. ~= 不等性判断

逻辑操做符

  1. and 第一个操做数为假，返回第一个，不然返回第二个
  2. or 第一个操做数为真，返回第一个，不然返回第二个
  3. not 只会返回 true 或 false 
-- 短路操做的使用技巧
print(x = x or v) -- 初始化一个值，若是 x 为 nil 没有被初始化过，就赋值 v 
-- 等价于
if not x then 
    x = v
end
-- 实现 C 语言中的三元操做符, a ? b : c
print((a and b) or c) -- b 必须为真，才能够这样操做
-- 等价于
if a == true then
    return b
elseif a == false then
    return c
end
-- 实现返回两个数中的较大值
max = (x > y) and x or y -- 由于 lua 将数字视为「真」
-- 等价于
if x > y then
    return x
else
    return y
end

字符串链接

  1. .. 字符串链接

优先级

1级优先

  1. ^

2级优先

  1. - 负号
  2. not
  3. #

3级优先

  1. *
  2. /
  3. %

4级优先

  1. +
  2. - 减号

5级优先

  1. .. 字符串链接

6级优先

  1. >
  2. <
  3. >=
  4. <=
  5. ==
  6. ~=

7级优先

  1. and

8级优先

  1. or

table 构造式

  1. lua 标准库中的函数对 table 的索引都是从 1 开始处理的

记录风格的 table

a = {x = 10, y = 20} -- 等价于 a.x = 10, a.y = 20

混合使用的 table

  1. 这种方式的 table 不能以负数和操做符做为索引 
a = {
    color = {"red", "green", "blue"}
    width = 200,
    height = 300
}

链表

  1. 由一系列节点组成，节点就是元素
  2. 节点能够再运行时动态生成

  3. 每一个节点包括两部分函数

    1. 存储数据的数据域
    2. 存储下一个地址节点的指针域 
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

指定索引的 table

options = {["+"] = "add", ["-"] = "sub", 
    ["*"] = "mul", ["/"] = "div"}
print(options["+"]) -- "add"

4. 语句

  1. 在 lua 中包括赋值，程序结构和过程调用
  2. 还有多重赋值和局部变量声明

赋值

  1. lua 支持多重赋值，即 a, b = 1, 2
  2. 会先计算等号右边全部元素的值，而后再赋值
  3. 若是右边的值少于左边变量，未被初始化的变量就置为 nil
  4. 若是左边变量少于右边的值，多余的值会被「抛弃」
  5. 可用来收集函数的多个返回值
  6. 初始化变量就是为每个变量赋一个初始值
a, b = 1, 2
x, y  = y, x -- 交换变量
a, b = 1 -- a = 1, b = nil
a, b = 1, 2, 3 -- a = 1, b = 2, 3 被抛弃
a, b = f() -- a 接收函数 f 的第一个返回值，b 接收第二个
a, b, c = 0, 0, 0 -- 初始化赋值

局部变量与块

块

  1. 一个块就是程序结构的执行体，或函数的执行体
  2. 在块内声明的变量仅在块内生效，即做用域为声明它们的块
  3. 可显式声明一个块使用 do <要执行的内容> end 将要执行的内容包裹在一个块内

局部变量

  1. local 用来声明一个局部变量
  2. 局部变量仅在声明它的块内生效，在块的外部无效
  3. 如：在循环内部声明在的变量在循环外部则没法使用
a = 3
b = 0
if a then
    local a = 5
    b = a -- 将 then 块内的局部变量 a ，保存到全局变量 b 中
    print(a)
end
print(a) -- 3
print(b) -- 5
do
    -- code block
end

尽可能使用局部变量

  1. 使用局部变量要比全局变量要快
  2. 避免污染全局环境
  3. 局部变量仅在声明它的块中有效，即在块外这个变量就被释放掉了
  4. lua 将局部变量声明看成语句处理，便可以在任何支持书写语句的地方书写局部变量声明
  5. 声明能够包含初始化赋值

程序结构

  1. 程序结构中的条件表达式能够是任何值

条件结构

  1. if
  2. elseif
  3. else
if 条件表达式 then 
     <执行体> -- 符合条件表达式执行
end
if 条件表达式1 then
    <执行体 1> -- 符合条件表达式 1 执行
    elseif 条件表达式2 then
    <执行体 2> -- 符合条件表达式 2 执行
end
if 条件表达式 then
    <执行体 1>  -- 条件表达式为真时执行
else
    <执行体 2>  -- 条件表达式为假是执行
end

循环结构

  1. for
  2. while 条件表达式为假时退出
  3. repeat ... until 条件表达式为真时推出，条件测试是在循环体以后作的，所以循环体至少会执行一次
  4. 在循环体内声明的局部变量的做用域包含了条件测试
  5. 循环的三个表达式是在循环开始前一次性求值的
  6. 控制变量会被自动声明为 for 块中的局部变量，即做用域为 for 块，在循环结束后不可见
  7. 不要在循环过程当中修改控制变量的值
  8. 可使用 break 或 return 在循环正常结束前提早结束它
for exp1, exp2, exp3 do
   <循环体> 
end
while 条件表达式 do
    <循环体>
end
repeat 
    <循环体>
until 条件表达式
a = 20
repeat
    local a = 0
    print(a)
until a == 0 -- 可访问在 repeat 块内声明的 a, 而不是全局变量 a
数值型 for
for i = 10, 0, -1 do
    print(i)
end
泛型 for
  1. ipairs() 用来遍历数组
  2. i 每次循环时都会赋予一个新的索引值，v 则是索引值所对应的元素
a = {1, 2, 3, 4, 5, 6}
for i,v in ipairs(a) do 
    print(i)
    print(v)
end
for i,v in pairs(a) do
    print(i)
    print(v)
end
两种 for 的共同点
  1. 循环变量都是循环体的局部变量
  2. 不该该对循环遍历进行赋值
days = {"第一天", "次日", "第三天"}
revdays = {}
for i, v in ipairs(days) do
    revdays[v] = i -- 逆向数组，将数组索引和数组元素调换，可获取数组元素的位置
end
print(revdays["次日"]) -- 获取次日所在位置

break 和 return

  1. break 用于结束一个循环，跳出内层循环后在外层循环中继续执行
  2. return 用于返回函数结果或简单的结束函数的执行
  3. 任何函数的结尾处实际都有一句隐式的 return
  4. 若是函数无返回值，就无需在结尾处加 return

二者的共同点

  1. 都是用做跳出当前块
  2. 都须要放在一个块的结尾处，即一个块的最后一条语句
  3. 由于 return 或 break 后的语句将没法执行到
  4. 能够用 do ... end 块包裹 return，用与调试，即调用函数但不执行函数内容的状况
a = 1
if a then
   print("hello")
   break
   print("world") -- 会报错
end
for i = 1, 10 do
    print(i)
    if i > 3 then
        break -- 只会打印 1 2 3 4 而后就跳出循环了
    end
end
-- 调试
function foo(...)
    do
           return 
    end
    print("执行 foo 函数") -- 不会打印
end
foo(1, 2 ,3)

5. 函数

  1. 函数是对语句和表达式进行抽象的主要机制

函数的两种用法

  1. 一是能够完成特定的任务，一句函数调用被视为一条语句
  2. 二是只用来计算并返回特定结果，视为一句表达式
print("hello") -- 用来完成打印任务，视为一条语句
a = os.date() -- os.date() 用来返回日期，视为一句表达式

两种用法的共同点

  1. 都须要将全部参数放到一对圆括号中 ()
  2. 但当参数为字面字符串或 table 构造式的时候 ()能够省略
  3. 即便调用函数没有参数，也必需要有一对空的圆括号 () 
print "hello" -- hello
print {1, 2, 3} -- 1 2 3
print(os.date) -- 当前日期

定义

  1. function 是建立函数的关键字
  2. function add add 是函数的名称
  3. function add(n) n 是函数的形式参数，简称为形参
  4. add(4) 4 是调用 add()函数时的实际参 ，简称为实参
  5. 实参多余形参，多余的实参被「抛弃」
  6. 形参多余实参，多余的形参被置为nil 
function foo(a, b)
    return a or b
end
foo(1) -- a = 1, b = nil
foo(1, 2) -- a = 1, b = 2
foo(1, 2, 31) -- a = 1, b = 2, 多余的 31 被抛弃
-- 面向对象式调用
o.foo(o, x)
o:foo(x) -- 与上面的效果同样，: 冒号操做符，隐式的将 o 做为第一个参数

多重返回值

  1. lua 中的函数容许返回多个结果
  2. 用逗号分隔所须要返回的全部参数
string.find("you are cool", "are") -- 5 7 返回找到的字符串的开头位置和结尾位置
-- 查找数组中的最大元素，并返回这个元素的所在位置
function maximum(a)
    local val = 1
    local max = a[val]
    for i,v in ipairs(a) do
        if max < a[i] then
            max = a[i]
            val = i
        end
    end
    return max, val
end
a = {1, 2, 55, 22, 29, 4}
maximum(a)

不一样状况下的返回值

  1. 若是将函数做为单独的语句执行，lua 会丢弃全部的返回值
  2. 若是将函数做为表达式的一部分调用，只保留函数的第一个返回值
  3. 只有当函数是一系列表达式中的最后一个元素（或只有一个元素的时候），才会获取全部的返回值

一系列表达式的4种状况

多重赋值
  1. 若是一个函数调用是最后（或仅有）的一个表达式，lua 会保留尽量多的返回值，用来匹配赋值的变量
  2. 若是一个函数没有返回值或没有返回足够多的返回值，那么 lua 会用 nil 来补充缺失的值
  3. 若是一个函数调用不是一系列表达式中的最后一个元素，就只能返回一个值
function foo() end
function foo1() return "a" end
function foo2() return "a", "b" end

-- 第一种状况，最后（或仅有）的一个表达式
x, y = foo1() -- x = a, y = b
-- 第二种状况，没有返回值
x = foo() -- nil
-- 第二种状况，没有返回足够多的返回值
x, y, z = foo1() -- x = a, y = b, z = nil
-- 第三种状况，不是表达式中的最后一个元素
x, y = foo2(), 10 -- x = a, y = 10
函数调用时传入的实参列表
  1. 若是一个函数调用做为另外一个函数调用的最后一个（或仅有的）实参的时候，第一个函数的全部返回值都会做为实参传递给另外一个函数
function foo() end
function foo1() return "a" end
function foo2() return "a", "b" end
-- 第四种状况，做为 print 函数中的最后一个（或仅有的）实参
print(foo()) -- nil
print(foo1()) -- "a"
print(foo2()) -- "a" "b"
print(foo1() .. "test") -- "atest"
print(foo2() .. "test") -- "atest"
table 构造式
  1. table 构造式会完整接收一个函数调用的全部结果，即不会由任何数量方面的调整
  2. 但这种行为，只有当一个函数调用做为最后一个元素时才发生
  3. 其余位置上的函数调用老是只产生一个结果值
function foo() end
function foo1() return "a" end
function foo2() return "a", "b" end
-- 函数调用是 table 中的最后一个元素
a = {foo2()} -- a = {"a", "b"}
a = {foo2(), 10} -- a = {"a", 10}
return 语句
  1. 将函数调用放入一对圆括号 () 中，使其只返回一个结果
  2. return 语句后面的内容不须要 () 圆括号
  3. 若是强行加上则会使一个多返回值的函数，强制其只返回一个 return(f())
function foo0() end
function foo1() return "a" end
function foo2() return "a", "b" end
function foo(i)
    if i == 0 then return foo0() 
        elseif i == 1 then return foo1() 
        elseif i == 2 then return foo2() 
    end
end
print(foo(1)) -- a
print(foo(2)) -- a, b
print(foo(0)) -- 无返回值，在交互模式中会是一个空行

-- () 包裹
print((foo(1)) -- a
print((foo(2)) -- a
print((foo(0)) -- nil ，应该是强制返回了一个未初始化的值，由于 foo0() 没有返回值

unpack 函数

  1. 接收一个数组做为参数
  2. 并从下标 1 开始返回该数组的全部元素
  3. 这个预约义函数由 C 语言编写
print(unpack{10, 20, 30}) -- 10 20 30
a, b = unpack{10, 20, 30}  -- a = 10, b = 20
  1. 用于泛型调用
  2. 泛型调用就是能够以任何实参来调用任何函数 
-- 调用任意函数 f, 而全部的参数都在数组 a 中
-- unpack 将返回 a 中的全部值，这些值做为 f 的实参
f(unpack(a)) 
f = string.find
a = {"hello", "ll"}
f(unpack(a)) -- 3 4 等效于 string.find("hello", "ll")

用 lua 递归实现 unpack

function unpack(t, i)
    i = i or 1
    if t[i] then
        return t[i], unpack(t, i + 1)
    end
end

变长参数

  1. lua 中的函数能够接收不一样数量的实参
  2. 当这个函数被调用时，它的全部参数都会被收集到一块儿
  3. 这部分收集起来的实参称为这个函数的「变长参数」
  4. ... 三个点表示该函数接收不一样数量的实参
  5. 一个函数要访问它的变长参数时，须要用 ... 三个点，此时 ... 三个点是做为一个表达式使用的
  6. 表达式 ... 三个点的行为相似一个具备多重返回值的函数，它返回的是当前函数的全部变长参数
  7. 具备变长参数的函数也能够拥有任意数量的固定参数
  8. 但固定参数必定要在变长参数以前
  9. 当变长参数中包含 nil ，则须要用 select 访问变长参数
  10. 调用 select 时，必须传入一个固定参数 selector (选择开关) 和一系列变长参数
  11. 若是 selector 为数字 n ，那么 select 返回它的第 n 个可变实参
  12. 不然，select 只能为字符串 "#" ，这样 select 会返回变长参数的总数，包括 nil 
-- 返回全部参数的和
function add(...)
    local s = 0
    for i, v in ipairs{...} do -- 表达式{...}表示一个由变长参数构成的数组
           s = s + v
    end
    return s
end
print(add(3, 4, 5, 100)) -- 115

-- 调试技巧 ,相似与直接调用函数 foo ，但在调用 foo 前先调用 print 打印其全部的实参
function foo1(...)
    print("calling foo:", ...)
    return foo(...)
end


-- 获取函数的实参列表
function foo(a, b, c) end
function foo(...)
        local a, b, c = ...
end
-- 格式化文本 string.format ，输出文本 io.write
-- 固定参数必定要在变长参数以前
function fwrite(fmt, ...)
    return io.write(string.format(fmt, ...))
end
fwrite() -- fmt = nil
fwrite("a") -- fmt = a 
fwrite("%d%d", 4, 5) -- fmt = "%d%d" , 变长参数  = 4, 5

for i = 1, select('#', ...) do
    local arg = select('#', ...)
    <循环体>
end

具名参数

  1. lua 中的参数传递机制是具备 「位置性」的
  2. 就是说在调用一个函数时，实参是经过它在参数表中的位置与形参匹配起来的
  3. 第一个实参的值与第一个形参相匹配，依此类推
  4. 定义：经过名称来指定实参
  5. 可将全部的实参组织到一个 table 中，并将这个 table 做为惟一的实参传给函数
  6. lua 中特殊的函数调用语法，当实参只有一个 table 构造式时，函数调用中的圆括号 () 是无关紧要的
os.rename  -- 文件更名,但愿达到的效果 os.rename(old = "temp.lua", new = "temp1.lua")
-- lua 不支持注释的写法
rename = {old = "temp.lua", new = "temp1.lua"}
function rename (arg)
    return os.rename(arg.old, arg.new)
end

x = Window{x = 0, y = 0, width = 300, height = 200, title = "Lua", background = "blue", border = "true"}

-- Window 函数根据要求检查必填参数，或为某些函数添加默认值
-- 假设 _Window 是真正用于建立新窗口的函数，要求全部参数以正确次序传入
function Window(options)
    if type(options.title) ~= "string" then
        error("no title")
    elseif type(options.width) ~= "number" then
        error("no width")
    elseif type(options.height) ~= "height" then
        error("no height")
    end
    _Window(options.title,
        options.x or 0 -- 默认值
        options.y or 0 -- 默认值
        options.width, options.height,
        options.background or "white" -- 默认值
        options.border -- 默认值为 false(nil)
    )
end

由于，目前只学到第五章函数篇，因此只有前五章的复习汇总，很基础，也很重要，也祝愿你们能够踏踏实实地打好地基。测试

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程