-- ####注释方式
--单行注释
--[["多行注释"]]
-- ####类型
-- nil、number、string、boolean、table、function、userdata、thread
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
-- nil 作比较时应该加上双引号 "
type(X) --nil
type(X)==nil -- false
type(X)=="nil" -- true
-- boolean 类型只有两个可选值：true（真） 和 false（假），Lua 把 false 和 nil 看作是"假"，其他的都为"真":
print(type(true))
print(type(false))
print(type(nil))
if false or nil then
print("至少有一个是 true")
else
print("false 和 nil 都为 false!")
end
-- number 类型 -- double（双精度）类型（默认类型可以修改 luaconf.h 里的定义），以下几种写法都被看作是 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))
-- 字符串由一对双引号或单引号来表示
string1 = "this is string1"
html = [[
<html></html>
]]
print(html)
-- 数字字符串上进行算术操作时，会尝试将这个数字字符串转成一个数字:
print("2" + 6)
-- table 的创建是通过"构造表达式"来完成，最简单构造表达式是{}，用来创建一个空表。也可以在表里添加一些数据，直接初始化表:
-- 创建一个空的 table
local tbl1 = {}
-- 直接初始表
local tbl2 = {"apple", "pear", "orange", "grape"}
-- 不同于其他语言的数组把 0 作为数组的初始索引，在 Lua 里表的默认初始索引一般以 1 开始。
-- table 不会固定长度大小，有新数据添加时 table 长度会自动增长，没初始的 table 都是 nil。
-- 动态构建表
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
-- 执行结果：
-- key : value
-- 10 : 33
a3 = {}
for i = 1, 10 do
a3[i] = i
end
a3["key"] = "val"
print(a3["key"]) --执行结果：val
print(a3["none"]) --执行结果：nil
-- 函数是被看作是"第一类值（First-Class Value）"，函数可以存在变量里:
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))
-- Lua 变量有三种类型：全局变量、局部变量、表中的域。
-- 变量全是全局变量，那怕是语句块或是函数里，除非用 local 显式声明为局部变量。
-- 局部变量的作用域为从声明位置开始到所在语句块结束。
-- 变量的默认值均为 nil
a = 5 -- 全局变量
local b = 5 -- 局部变量
function joke()
c = 5 -- 全局变量
local d = 6 -- 局部变量
end
joke()
print(c,d) --> 5 nil
do
local a = 6 -- 局部变量
b = 6 -- 全局变量
print(a,b); --> 6 6
end
print(a,b) --> 5 6
-- 赋值是改变一个变量的值和改变表域的最基本的方法。
a = "hello" .. "world"
t.n = t.n + 1
-- 对多个变量同时赋值，变量列表和值列表的各个元素用逗号分开，赋值语句右边的值会依次赋给左边的变量。
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]'
-- 当变量个数和值的个数不一致时，Lua会一直以变量个数为基础采取以下策略：
-- a. 变量个数 > 值的个数 按变量个数补足nil
-- b. 变量个数 < 值的个数 多余的值会被忽略
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
-- 对 table 的索引使用方括号 []。Lua 也提供了 . 操作。
t[i]
t.i -- 当索引为字符串类型时的一种简化写法
gettable_event(t,i) -- 采用索引访问本质上是一个类似这样的函数调用
site = {}
site["key"] = "www"
print(site["key"]) -- www
print(site.key) -- www
-- while循环控制语句
while( true )
do
print("循环将永远执行下去")
end
-- 数值for循环控制语句
-- var从exp1变化到exp2，每次变化以step为步长递增var，并执行一次"执行体"。step是可选的，如果不指定，默认为1。
for var=exp1,exp2,step do
print(var)
end
-- 控制结构的条件表达式结果可以是任何值，Lua认为false和nil为假，true和非nil为真。
--[ 0 为 true ]
if(0)
then
print("0 为 true")
end
-- if...else 语句语法格式如下：
if(布尔表达式)
then
--[ 布尔表达式为 true 时执行该语句块 --]
else
--[ 布尔表达式为 false 时执行该语句块 --]
end
-- Lua函数中，在return后列出要返回的值得列表即可返回多值，如：
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}))
-- Lua函数可以接受可变数目的参数，和C语言类似在函数参数列表中使用三点（...) 表示函数有可变的参数。
-- Lua将函数的参数放在一个叫arg的表中，#arg 表示传入参数的个数。
-- 例如，我们计算几个数的平均值：
function average(...)
result = 0
local 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))
-- Lua提供了以下几种运算符类型：
-- 算术运算符
-- 关系运算符
-- 逻辑运算符
-- 其他运算符
-- 常用算术运算符，设定 A 的值为10，B 的值为 20：
-- + 加法 A + B 输出结果 30
-- - 减法 A - B 输出结果 -10
-- * 乘法 A * B 输出结果 200
-- / 除法 B / A w输出结果 2
-- % 取余 B % A 输出结果 0
-- ^ 乘幂 A^2 输出结果 100
-- - 负号 -A 输出结果v -10
a = 21
b = 10
c = a + b
print("Line 1 - c 的值为 ", c ) -- Line 1 - c 的值为 31
c = a - b
print("Line 2 - c 的值为 ", c ) -- Line 2 - c 的值为 11
c = a * b
print("Line 3 - c 的值为 ", c ) -- Line 3 - c 的值为 210
c = a / b
print("Line 4 - c 的值为 ", c ) -- Line 4 - c 的值为 2.1
c = a % b
print("Line 5 - c 的值为 ", c ) -- Line 5 - c 的值为 1
c = a^2
print("Line 6 - c 的值为 ", c ) -- Line 6 - c 的值为 441
c = -a
print("Line 7 - c 的值为 ", c ) -- Line 7 - c 的值为 -21
-- 常用关系运算符，设定 A 的值为10，B 的值为 20
-- == 等于，检测两个值是否相等，相等返回 true，否则返回 false (A == B) 为 false。
-- ~= 不等于，检测两个值是否相等，相等返回 false，否则返回 true (A ~= B) 为 true。
-- > 大于，如果左边的值大于右边的值，返回 true，否则返回 false (A > B) 为 false。
-- < 小于，如果左边的值大于右边的值，返回 false，否则返回 true (A < B) 为 true。
-- >= 大于等于，如果左边的值大于等于右边的值，返回 true，否则返回 false (A >= B) 返回 false。
-- <= 小于等于， 如果左边的值小于等于右边的值，返回 true，否则返回 false (A <= B) 返回 true。
a = true
b = true
if ( a and b )
then
print("a and b - 条件为 true" )
end
if ( a or b )
then
print("a or b - 条件为 true" )
end
print("---------分割线---------" )
-- 修改 a 和 b 的值
a = false
b = true
if ( a and b )
then
print("a and b - 条件为 true" )
else
print("a and b - 条件为 false" )
end
if ( not( a and b) )
then
print("not( a and b) - 条件为 true" )
else
print("not( a and b) - 条件为 false" )
end
-- 连接运算符与计算表或字符串长度的运算符：
-- .. 连接两个字符串 a..b ，其中 a 为 "Hello " ， b 为 "World", 输出结果为 "Hello World"。
-- # 一元运算符，返回字符串或表的长度。 #"Hello" 返回 5
a = "Hello "
b = "World"
print("连接字符串 a 和 b ", a..b ) -- Hello World
print("b 字符串长度 ",#b ) -- 5
-- 运算符优先级(从高到低的顺序):
-- ^
-- not - (unary)
-- * /
-- + -
-- ..
-- < > <= >= ~= ==
-- and
-- or
-- 除了^和..外所有的二元运算符都是左连接的。
-- a+i < b/2+1 <--> (a+i) < ((b/2)+1)
-- 5+x^2*8 <--> 5+((x^2)*8)
-- a < y and y <= z <--> (a < y) and (y <= z)
-- -x^2 <--> -(x^2)
-- x^y^z <--> x^(y^z)
-- 字符串可以使用以下三种方式来表示：
-- 单引号间的一串字符。
-- 双引号间的一串字符。
-- [[和]]间的一串字符。
string1 = "Lua"
print(""字符串1是"",string1)
string2 = 'runoob.com'
print("字符串 2 是",string2)
string3 = [["Lua 教程"]]
print("字符串 3 是",string3)
-- 字符串操作
string.upper(argument) -- 字符串全部转为大写字母。
string.lower(argument) -- 字符串全部转为小写字母。
string.gsub(mainString,findString,replaceString,num) -- 在字符串中替换,mainString为要替换的字符串， findString 为被替换的字符，replaceString 要替换的字符，num 替换次数（可以忽略，则全部替换）
string.find (str, substr, [init, [end]]) -- 在一个指定的目标字符串中搜索指定的内容(第三个参数为索引),返回其具体位置。不存在则返回 nil。
string.reverse(arg) -- 字符串反转
string.format(...) -- 返回一个类似printf的格式化字符串
string.char(arg) -- char 将整型数字转成字符并连接
string.byte(arg[,int]) -- byte 转换字符为整数值(可以指定某个字符，默认第一个字符)。
string.len(arg) -- 计算字符串长度
string.rep(string, n) -- 返回字符串string的n个拷贝
string.gmatch(str, pattern) -- 回一个迭代器函数，每一次调用这个函数， 返回一个在字符串 str 找到的下一个符合 pattern 描述的子串。如果参数 pattern 描述的字符串没有找到，迭代函数返回nil。
string.match(str, pattern, init) -- 只寻找源字串str中的第一个配对. 参数init可选, 指定搜寻过程的起点, 默认为1。在成功配对时, 函数将返回配对表达式中的所有捕获结果; 如果没有设置捕获标记, 则返回整个配对字符串. 当没有成功的配对时, 返回nil。
string.upper(str) -- 如何对字符串大小写进行转换
string.lower(str)
string.find(string, substr) -- 对字符串进行查找与反转操作
-- 示例
string.gsub("aaaa","a","z",3) -- zzza3
string.find("Hello Lua user", "Lua", 1) -- 7 9
string.reverse("Lua") -- auL
string.format("the value is:%d",4) -- the value is:4
string.char(97,98,99,100) -- abcd
string.byte("ABCD",4) -- 68
string.len("abc") -- 3
string.rep("abcd",2) -- abcdabcd
for word in string.gmatch("Hello Lua user", "%a+") do print(word) end -- 输出: Hello Lua user
string.match("I have 2 questions for you.", "%d+ %a+") -- 2 questions
string.format("%d, %q", string.match("I have 2 questions for you.", "(%d+) (%a+)")) -- 2, "questions"
print(string.upper("Lua")) -- LUA
string.lower("Lua") -- lua
string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- 基本字符串格式化
print(string.format("基本格式化 %s %s",string1,string2))
-- 日期格式化
date = 2; month = 1; year = 2014
print(string.format("日期格式化 %02d/%02d/%03d", date, month, year))
-- 十进制格式化
print(string.format("%.4f",1/3))
string.format("%c", 83) -- 输出S
string.format("%+d", 17.0) -- 输出+17
string.format("%05d", 17) -- 输出00017
string.format("%o", 17) -- 输出21
string.format("%u", 3.14) -- 输出3
string.format("%x", 13) -- 输出d
string.format("%X", 13) -- 输出D
string.format("%e", 1000) -- 输出1.000000e+03
string.format("%E", 1000) -- 输出1.000000E+03
string.format("%6.3f", 13) -- 输出13.000
string.format("%q", "One
Two") -- 输出"One
-- Two"
string.format("%s", "monkey") -- 输出monkey
string.format("%10s", "monkey") -- 输出 monkey
string.format("%5.3s", "monkey") -- 输出 mon
-- 所有字符类：
--[[
单个字符(除 ^$()%.[]*+-? 外): 与该字符自身配对
.(点): 与任何字符配对
%a: 与任何字母配对
%c: 与任何控制符配对(例如
)
%d: 与任何数字配对
%l: 与任何小写字母配对
%p: 与任何标点(punctuation)配对
%s: 与空白字符配对
%u: 与任何大写字母配对
%w: 与任何字母/数字配对
%x: 与任何十六进制数配对
%z: 与任何代表0的字符配对
%x(此处x是非字母非数字字符): 与字符x配对. 主要用来处理表达式中有功能的字符(^$()%.[]*+-?)的配对问题, 例如%%与%配对
[数个字符类]: 与任何[]中包含的字符类配对. 例如[%w_]与任何字母/数字, 或下划线符号(_)配对
[^数个字符类]: 与任何不包含在[]中的字符类配对. 例如[^%s]与任何非空白字符配对
上述的字符类用大写书写时, 表示与非此字符类的任何字符配对. 例如, %S表示与任何非空白字符配对.例如，'%A'非字母的字符
]]
print(string.gsub("hello, up-down!", "%A", ".")) -- hello..up.down. 4
-- Lua中的特殊字符如下：
--[[
( ) . % + - * ? [ ^ $
'%' 用作特殊字符的转义字符，因此 '%.' 匹配点；'%%' 匹配字符 '%'。
转义字符 '%'不仅可以用来转义特殊字符，还可以用于所有的非字母的字符。
模式条目可以是：
单个字符类匹配该类别中任意单个字符；
单个字符类跟一个 '*'， 将匹配零或多个该类的字符。 这个条目总是匹配尽可能长的串；
单个字符类跟一个 '+'， 将匹配一或更多个该类的字符。 这个条目总是匹配尽可能长的串；
单个字符类跟一个 '-'， 将匹配零或更多个该类的字符。 和 '*' 不同， 这个条目总是匹配尽可能短的串；
单个字符类跟一个 '?'， 将匹配零或一个该类的字符。 只要有可能，它会匹配一个；
%n， 这里的 n 可以从 1 到 9； 这个条目匹配一个等于 n 号捕获物（后面有描述）的子串。
%bxy， 这里的 x 和 y 是两个明确的字符； 这个条目匹配以 x 开始 y 结束， 且其中 x 和 y 保持 平衡 的字符串。
意思是，如果从左到右读这个字符串，对每次读到一个 x 就 +1 ，读到一个 y 就 -1， 最终结束处的那个 y 是第一个记数到 0 的 y。
举个例子，条目 %b() 可以匹配到括号平衡的表达式。
%f[set]， 指 边境模式； 这个条目会匹配到一个位于 set 内某个字符之前的一个空串， 且这个位置的前一个字符不属于 set 。
集合 set 的含义如前面所述。 匹配出的那个空串之开始和结束点的计算就看成该处有个字符 ' ' 一样。
模式：
模式 指一个模式条目的序列。 在模式最前面加上符号 '^' 将锚定从字符串的开始处做匹配。 在模式最后面加上符号 '$' 将使匹配过程锚定到字符串的结尾。 如果 '^' 和 '$' 出现在其它位置，它们均没有特殊含义，只表示自身。
捕获：
模式可以在内部用小括号括起一个子模式； 这些子模式被称为 捕获物。
当匹配成功时，由 捕获物 匹配到的字符串中的子串被保存起来用于未来的用途。
捕获物以它们左括号的次序来编号。
例如，对于模式 "(a*(.)%w(%s*))" ， 字符串中匹配到 "a*(.)%w(%s*)" 的部分保存在第一个捕获物中 （因此是编号 1 ）；
由 "." 匹配到的字符是 2 号捕获物， 匹配到 "%s*" 的那部分是 3 号。
作为一个特例，空的捕获 () 将捕获到当前字符串的位置（它是一个数字）。
例如，如果将模式 "()aa()" 作用到字符串 "flaaap" 上，将产生两个捕获物： 3 和 5 。
]]
-- 一维数组可以用for循环出数组中的元素，如下实例：
array = {"Lua", "Tutorial"}
for i= 0, 2 do
print(array[i]) -- 依次输出： nil Lua Tutorial
end
-- Lua 索引值是以 1 为起始，但你也可以指定 0 开始
for i= -2, 2 do
print(array[i]) -- 依次输出： nil nil nil Lua Tutorial
end
-- 多维数组即数组中包含数组或一维数组的索引键对应一个数组。
array = {}
for i=1,3 do
array[i] = {}
for j=1,3 do
array[i][j] = i*j
end
end
-- 访问数组
for i=1,3 do
for j=1,3 do
print(array[i][j])
end
end
-- 迭代器（iterator）是一种对象，它能够用来遍历标准模板库容器中的部分或全部元素
-- 泛型 for 在自己内部保存迭代函数，实际上它保存三个值：迭代函数、状态常量、控制变量
-- 泛型 for 迭代器提供了集合的 key/value 对，语法格式如下：
-- k, v为变量列表；pair(t)为表达式列表。
for k, v in pairs(t) do
print(k, v)
end
array = {"Lua", "Tutorial"}
for key,value in ipairs(array)
do
print(key, value)
end
-- pairs 和 ipairs异同
--[[
同：都是能遍历集合（表、数组）
异：
ipairs 仅仅遍历值，按照索引升序遍历，索引中断停止遍历。即不能返回 nil,只能返回数字 0，如果遇到 nil 则退出。它只能遍历到集合中出现的第一个不是整数的 key。
pairs 能遍历集合的所有元素。即 pairs 可以遍历集合中所有的 key，并且除了迭代器本身以及遍历表本身还可以返回 nil。
]]
local tabFiles = {"alpha", "beta", [3] = "no", ["two"] = "yes"} for i,v in ipairs(tabFiles ) do
--输出前三个 备注：因为第四个key不是整数
print( tabFiles [i] )
end
for i,v in pairs(tabFiles ) do --全部输出
print( tabFiles [i] )
end
-- table(表)的构造
-- 初始化表
mytable = {} -- 指定值
mytable[1]= "Lua" -- 移除引用
mytable = nil -- lua 垃圾回收会释放内存
-- Table 操作常用的方法：
table.concat (table [, sep [, start [, end]]]) -- 指定table的数组部分从start位置到end位置的所有元素, 元素间以指定的分隔符(sep)隔开
table.insert (table, [pos,] value) -- 指定位置(pos)插入值为value的一个元素. pos参数可选, 默认为数组部分末尾
table.maxn (table) -- 指定table中所有正数key值中最大的key值. 如果不存在key值为正数的元素, 则返回0(Lua5.2之后该方法已经不存在)
table.remove (table [, pos]) -- 返回table数组部分位于pos位置的元素. 其后的元素会被前移. pos参数可选, 默认为table长度, 即从最后一个元素删起.
table.sort (table [, comp]) -- 对给定的table进行升序排序。
-- @prams t table
-- @return 返回table中最大的值
function table_maxn(t)
local mn=nil;
for k, v in pairs(t) do
if(mn==nil) then
mn=v
end
if mn < v then
mn = v
end
end
return mn
end
tbl = {[1] = 2, [2] = 6, [3] = 34, [26] =5}
print("tbl 最大值：", table_maxn(tbl))
print("tbl 长度 ", #tbl)
fruits = {"banana","orange","apple"}
-- 返回 table 连接后的字符串
print("连接后的字符串 ",table.concat(fruits))
table.insert(fruits,"mango") -- 在末尾插入
print("索引为 4 的元素为 ",fruits[4])
table.remove(fruits)
print("移除后最后一个元素为 ",fruits[5])
table.sort(fruits)
for k,v in ipairs(fruits) do
print(k,v)
end
-- 日期时间函数
os.time ([table]) -- 返回当前的时间和日期（它表示从某一时刻到现在的秒数）。如果用 table 参数，它会返回一个数字，表示该 table 中 所描述的日期和时间（它表示从某一时刻到 table 中描述日期和时间的秒数）。
--[[
table 的字段如下：
year 四位数字
month 1--12
day 1--31
hour 0--23
min 0--59
sec 0--61
isdst boolean（true表示夏令时）
格式字符与含义：
%a 一星期中天数的简写（例如：Wed）
%A 一星期中天数的全称（例如：Wednesday）
%b 月份的简写（例如：Sep）
%B 月份的全称（例如：September）
%c 日期和时间（例如：07/30/15 16:57:24）
%d 一个月中的第几天[01 ~ 31]
%H 24小时制中的小时数[00 ~ 23]
%I 12小时制中的小时数[01 ~ 12]
%j 一年中的第几天[001 ~ 366]
%M 分钟数[00 ~ 59]
%m 月份数[01 ~ 12]
%p “上午（am）”或“下午（pm）”
%S 秒数[00 ~ 59]
%w 一星期中的第几天[1 ~ 7 = 星期天 ~ 星期六]
%x 日期（例如：07/30/15）
%X 时间（例如：16:57:24）
%y 两位数的年份[00 ~ 99]
%Y 完整的年份（例如：2015）
%% 字符'%'
]]
os.difftime (t2, t1) -- 返回 t1 到 t2 的时间差，单位为秒。
os.date ([format [, time]]) -- 把一个表示日期和时间的数值，转换成更高级的表现形式。
-- 其第一个参数 format 是一个格式化字符串，描述了要返回的时间形式。
-- 第二个参数 time 就是日期和时间的数字表示，缺省时默认为当前的时间。
-- 使用格式字符 "*t"，创建一个时间表。
print(os.time()) -->output 1438243393
local t1 = { year = 1970, month = 1, day = 1, hour = 8, min = 1 }
print(os.time(t1)) -->output 60
local day2 = { year = 2015, month = 7, day = 31 }
local t2 = os.time(day2)
print(os.difftime(t2, t1)) -->output 86400
local tab1 = os.date("*t") --返回一个描述当前日期和时间的表
local ans1 = "{"
for k, v in pairs(tab1) do --把tab1转换成一个字符串
ans1 = string.format("%s %s = %s,", ans1, k, tostring(v))
end
ans1 = ans1 .. "}"
print("tab1 = ", ans1)
-->output
tab1 = { hour = 17, min = 28, wday = 5, day = 30, month = 7, year = 2015, sec = 10, yday = 211, isdst = false,}
tab2 = { hour = 8, min = 6, wday = 5, day = 1, month = 1, year = 1970, sec = 0, yday = 1, isdst = false,}
print(os.date("today is %A, in %B")) -- today is Thursday, in July
print(os.date("now is %x %X")) -- now is 07/30/15 17:39:22
-- ### 数学库
math.rad(x) -- 角度x转换成弧度
math.deg(x) -- 弧度x转换成角度
math.max(x, ...) -- 返回参数中值最大的那个数，参数必须是number型
math.min(x, ...) -- 返回参数中值最小的那个数，参数必须是number型
math.random ([m [, n]]) -- 不传入参数时，返回 一个在区间[0,1)内均匀分布的伪随机实数；
-- 只使用一个整数参数m时，返回一个在区间[1, m]内均匀分布的伪随机整数；
-- 使用两个整数参数时，返回一个在区间[m, n]内均匀分布的伪随机整数
math.randomseed (x) -- 为伪随机数生成器设置一个种子x，相同的种子将会生成相同的数字序列
math.abs(x) -- 返回x的绝对值
math.fmod(x, y) -- 返回 x对y取余数
math.pow(x, y) -- 返回x的y次方
math.sqrt(x) -- 返回x的算术平方根
math.exp(x) -- 返回自然数e的x次方
math.log(x) -- 返回x的自然对数
math.log10(x) -- 返回以10为底，x的对数
math.floor(x) -- 返回最大且不大于x的整数
math.ceil(x) -- 返回最小且不小于x的整数
math.pi -- 圆周率
math.sin(x) -- 求弧度x的正弦值
math.cos(x) -- 求弧度x的余弦值
math.tan(x) -- 求弧度x的正切值
math.asin(x) -- 求x的反正弦值
math.acos(x) -- 求x的反余弦值
math.atan(x) -- 求x的反正切值
-- ### 文件操作
--[[
模式：
模式 含义 文件不存在时
"r" 读模式 (默认) 返回nil加错误信息
"w" 写模式 创建文件
"a" 添加模式 创建文件
"r+" 更新模式，保存之前的数据 返回nil加错误信息
"w+" 更新模式，清除之前的数据 创建文件
"a+" 添加更新模式，保存之前的数据,在文件尾进行添加 创建文件
]]
io.open (filename [, mode]) -- 按指定的模式 mode，打开一个文件名为 filename 的文件，成功则返回文件句柄，失败则返回 nil 加错误信息。
io.close ([file]) -- 关闭文件，和 file:close() 的作用相同。没有参数 file 时，关闭默认输出文件。
io.lines ([filename]) -- 打开指定的文件 filename 为读模式并返回一个迭代函数
io.output ([file]) -- 类似于 io.input，但操作在默认输出文件上。
io.read (...) -- 相当于 io.input():read
io.type (obj) -- 检测 obj 是否一个可用的文件句柄。
io.write (...) -- 相当于 io.output():write。
file:read (...) -- 按指定的格式读取一个文件。
file:close () -- 关闭文件。注意：当文件句柄被垃圾收集后，文件将自动关闭。句柄将变为一个不可预知的值。
file:write (...) -- 把每一个参数的值写入文件。
-- 参数必须为字符串或数字，若要输出其它值，则需通过 tostring 或 string.format 进行转换。
file:seek ([whence] [, offset]) -- 设置和获取当前文件位置，成功则返回最终的文件位置(按字节，相对于文件开头) 失败则返回 nil 加错误信息。
-- 缺省时，whence 默认为 "cur"，offset 默认为 0 。 参数 whence：
-- whence 含义
-- "set" 文件开始
-- "cur" 文件当前位置(默认)
-- "end" 文件结束
file:setvbuf (mode [, size]) -- 设置输出文件的缓冲模式
-- 模式 含义
-- "no" 没有缓冲，即直接输出
-- "full" 全缓冲，即当缓冲满后才进行输出操作(也可调用flush马上输出)
-- "line" 以行为单位，进行输出
-- 最后两种模式，size 可以指定缓冲的大小（按字节），忽略 size 将自动调整为最佳的大小。
-- Lua I/O 库提供两种不同的方式处理文件：隐式文件描述，显式文件描述。
-- 隐式文件描述:
-- 打开已经存在的 test1.txt 文件，并读取里面的内容
file = io.input("test1.txt") -- 使用 io.input() 函数打开文件
repeat
line = io.read() -- 逐行读取内容，文件结束时返回nil
if nil == line then
break
end
print(line)
until (false)
io.close(file) -- 关闭文件
-- 在 test1.txt 文件的最后添加一行 "hello world"
file = io.open("test1.txt", "a+") -- 使用 io.open() 函数，以添加模式打开文件
io.output(file) -- 使用 io.output() 函数，设置默认输出文件
io.write("
hello world") -- 使用 io.write() 函数，把内容写到文件
io.close(file)
-- 显式文件描述
-- 使用 file:XXX() 函数方式进行操作, 其中 file 为 io.open() 返回的文件句柄。
-- 打开已经存在的 test2.txt 文件，并读取里面的内容
file = io.open("test2.txt", "r") -- 使用 io.open() 函数，以只读模式打开文件
for line in file:lines() do -- 使用 file:lines() 函数逐行读取文件
print(line)
end
file:close()
-- 在 test2.txt 文件的最后添加一行 "hello world"
file = io.open("test2.txt", "a") -- 使用 io.open() 函数，以添加模式打开文件
file:write("
hello world") -- 使用 file:write() 函数，在文件末尾追加内容
file:close()