--------------------------第一个测试程序-----------------------------------------------------------
--[[
--书本第一个程序
function fact(n)
if n == 0 then
return 1;
else
return n * fact(n - 1);
end
end
print("enter a number");
a = io.read("*number");
print(fact(a));
--]]
-----------------------字符串简单操作和print函数的使用-----------------------------------------------------
--对字符串的一些常识
--print(1 + "10"); --> 11
--print("10 + 1"); --> 10 + 1
--print("10" * "2"); -->20
--print("hello" + 1); -->错误
--print(10 .. 20); -->1020
--print("hello" .. 1); -->hello1
--[[
--[=[
--输出转意标识符使用
--可以用不同的引号来界定字面字符串本身带的引号
--也可以用转意符“\”来界定
--转义符“\”后跟数字输出的是数字后代表的字符串
--]=]
print("one ilne \nnext line\n\"in quotes\" , 'in qutotes'");
--[==[
one ilne
next line
"in quotes" , 'in qutotes'
--]==]
print('a backslash inside quotes: \'\\\'');
--[===[
a backslash inside quotes: '\'
--]===]
print("a simpler way: '\\'");
--[====[
a simpler way: '\'
--]====]
print("alo\n123\"" .. "\n=\n" .. '\97lo\10\04923"')；
--[=====[
alo
123"
=
alo
123"
--]=====]
--]]
--[=[
--可以是用使用以下的操作符对成页的字符串赋值，这样对写如源程序代码的字符串很方便
page = [[
<html>
<head>
<title>An HTML Page</title>
</head>
<body>
<a href="http://www.lua.org">lua</a>
</body>
</html>
]]
--对字符串取长度用# 5.1新加
print(#page);
--]=]
--[[
--对tonumber函数测试
line = io.read(); --读取一行
n = tonumber(line) --尝试将它转换为一个数字
if n == nil then
error(line .. "is not a valid number");
else
print(n * 2);
end
--]]
--------------------------table的操作--------------------------------------------
--[[
--一般操作
a = {}; --创建一个table，并将它的引用存储到a
k = 'x'; --简单赋值
a[k] = 10; --新条目，key=“x”，value=10
a[20] = "great"; --新条目，key=20，value=“great”
print(a[k]); -->10
k = 20; --赋值
print(a[k]); --“greate”
a["x"] = a["x"] + 1; --新增条目“x”
print(a["x"]); -->11
--]]
--[[
--语糖法
a.x = 10; --等同于a["x"] = 10
print(a.x); --等同于print(a["x"]);
print(a.y); --等同于print(a["y"]);
--]]
--[[
--语糖法注意事项
tableb = {};
x = "y";
tableb[x] = 10; --将10放入以字段“y”为key的条目中
print(tableb[x]); -->10 --打印字段“y”的值
print(tableb.x); -->nil --字段“x”（未定义）的值
print(tableb.y); -->10 --等同于tableb[x]，打印字段“y”的值
--]]
--[[
--如果用整数做索引的话，lua习惯索引是从1开始
tablec = {};
--读取10行数据，并存储到tablec中
--for i=1,10 do --第一种方式
-- tablec[i] = io.read();
--end
for i=1, 10 do
tablec[#tablec+1] = io.read();
end
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
--对table几种长度操作符在Lua中的习惯写法：
print(tablec[#tablec]);
tablec[#tablec] = nil;
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
tablec[#tablec+1] = "v";
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
--]]
--[[
--利用table.maxn()来处理有nil的table最大正索引
tabled = {};
tabled[1000] = 1;
print(table.maxn(tabled));
--]]
--[[
--此例子说明，以索引为10和索引为“10”去条目的value不同
i = 10;
j = "10";
k = "+10";
tableE = {};
tableE[i] = "one value";
tableE[j] = "another value";
tableE[k] = "yet another value";
print("tableE[j] = " .. tableE[j]);
print("tableE[k] = " .. tableE[k]);
print("tableE[tonumber(j)] = " .. tableE[tonumber(j)]);
print("tableE[tonumber(k)] = " .. tableE[tonumber(k)]);
--]]
--------------------------------------------表达式操作-----------------------------------------------------------------------------------
--[[
--算数操作符操作。指数操符"^"的操作
x = 5.697050
print("x = " .. x)
print("x的整数部分:" .. x - x % 1);
print("x的小数部分:" .. x % 1);
print("x精确到小数点后n位，此处是第二位：" .. x - x % 0.01);
--]]
--[[
--关系操作符: “<”、“>”、 “<=”、 “>=”、 “==”、 “~=”、
--在Lua中table、userdata和函数，是做引用比较的，也就是说只有当它们引用同一个对象时，才认为它们相等
tableA = {};
tableA.x = 1;
tableA.y = 0;
tableB = {};
tableB.x = 1;
tableB.y = 0;
tableC = tableA;
a = 3
--print();
print(tableA);
print(tableB);
print(tableC);
--]]
--[[
--逻辑操作符：“and”、“or”、“not”、
--“and”和“or”操作符都使用“短路求值（short-cut evaluation）”，也就说，它们只在需要时才会评估第二个操作数。
--在Lua中是把false和nil看为假，其他都为真
--尽量用括号来指定所期望的运算次序，不能优先级
--对于“and”操作符来说，如果第一个操作数为假，则返回第一个操作数，不然返回第二个操作数
print(4 and 5); -->5
print(nil and 13); -->nil
print(false and 13); -->false
--对于“or”操作符来说，如果的哥操作数为真，就返回第一个操作数，不然返回第二个操作数
print(4 or 5); -->4
print(false or 5); -->5
print(nil or 5); -->5
--对于操作符“not”来说，只返回true或false
print(not nil) -->ture
--"and"和“or”操作符的特殊用法，表达和C中a?b:c相同的表达式
--(表达式(a) and 真时返回值(b) or 假时返回值(c))其中前提条件是b为真
number_x = 3;
number_y = 4;
--(number_x > number_y) ? number_x : number_y
number_max = (number_x > number_y) and number_x or number_y;
print("The max number:" .. number_max);
--]]
----------------------table构造式-------------------------------------------------------
--在table构造式中最后一个元素后可以跟“,”或“;”，这种灵活性，
--使得Lua无须将最后一个元素做特殊处理，可以方便以后的扩展。a = {1,2,3,};
--[[
--table构造式,在table式的数组中，索引是从“1”开始的。
week = {"Sunday","Monday","Tuesday","Wednesday","Thursday",
"Friday","Saturday"};
print("The KEY is 1: " .. week[1]); -->Sunday
tableD = {x = 10,y = 20}; --tableD = {}; tableD.x = 10,tableD.y = 20;
print(tableD.x); --print(tableD["x"]);
print(tableD.y);
tableW = {x = 0,y = 0, lable = "console"};
tableX = {math.sin(0), math.sin(1), math.sin(2)};
tableW[1] = "another field"; --添加KEY为“1”到tableW中
tableX.f = tableW; --添加KEY为“"f"”到tableX中
print('tableW["x"] = ' .. tableW["x"]);
print("tableW[1] = " .. tableW[1]);
print("tableX.f[1] = " .. tableX.f[1]);
tableW.x = nil;
if tableX.f == tableW then
print(tableX.f);
print(tableW);
end
--]]
--[[ ---留作以后看
--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
--]]
--[[
--将记录的风格初始化与列表风格的初始化混合在一个构造式中
--通过嵌套构造式来表示复杂的数据结构每个polyline[i]元素都是一个table
polyline = {color = "blue", thickness = 2, npoints = 4,
{x = 0, y = 0},
{x = -10, y = 0},
{x = -10, y = 1},
{x = 0, y = 1}
};
--表示一条记录：
print(polyline[2].x);
print(polyline[1].y);
--]]
--[[
--通用同时通用的table构造式，在方括号中间，显示地用一个表达式来初始化索引值
opname = {["+"] = "add", ["-"] = "sub",
["*"] = "mul", ["/"] = "div"};
i = 20; s = "-";
tableZ = {[i+0] = s, [i+1] = s .. s, [i+2] = s .. s .. s};
print(opname[s]);
print(tableZ[22]);
--以下构造式是全等的
--{x = 100, y = 200}
tablePoint = {["x"] = 100, ["y"] = 200};
--{"r", "g", "b"}
tableColor ={[1] = "r", [2] = "g", [3] = "b"};
--在table构造式中，还可以用分号(“;”)代替逗号(“,”)，通常用于分隔构造式中不同的成分。
--例如，将列表部分记录与记录部分明显的区分开：
polyline1 = {color = "blue", thickness = 2, npoints = 4;
{x = 0, y = 0};
{x = -10, y = 0};
{x = -10, y = 1};
{x = 0, y = 1};
};
--表示一条记录：
print(polyline1[2].x);
print(polyline1[1].y);
--]]
------------------------语句----------------------------------
--1赋值
--[[
--多重赋值中，Lua先对等号右边的所有元素求值，然后才进行赋值。
numberT = 20;
numberA,numberB = 10,2 * numberT;
print("numberA = " .. numberA);
print("numberB = " .. numberB);
--多重赋值这种特性，方便数据交换。
numberA,numberB = numberB,numberA;
print("After change.");
print("numberA = " .. numberA);
print("numberB = " .. numberB);
--注：Lua对于多重赋值规定，如果等号左边变量多余等号右边变量，会将多余的左边变量赋值为“nil”
-- 如果等号右边变量多余左边变量，则将多余的右边变量给丢弃掉。
--如果想赋值一组变量，应为每一个变量赋值。
a1,b1,c1 = 0; --错误
a2,b2,c2 = 0,0,0; --正确
--]]
--局部变量与块(block)
--“尽可能的使用局部变量”，局部变量可以避免将一些无用的名称引入全局环境（global environment）
--[[
--全局变量和局部变量的区别
xnumber = 10; --定义全局变量“xnumber”
local i = 1; --定义程序块中的局部变量“i”
while i <= xnumber do --while循环开始
local xnumber = i * 2; --while循环体中的局部变量“xnumber”
print(xnumber); -->2,4,6,8...
i = i + 1; -->块中局部变量+1
end --while循环结束
if i > 20 then
local xnumber; --定义then中局部变量“xnumber”
xnumber = 20;
print(xnumber + 2); --如果测试成功会打印22，打印的是then中局部变量“xnumber”
else
print(xnumber); --10 (全局变量“xnumber”)
end
print(xnumber); --10 (全局变量“xnumber”)
--]]
--[[
--如果需要显示的界定一个块，可以用“do-end”关键字。
do
local a = 2;
local c = 4;
local b = 8;
local a2 = 2 * a;
local d = (b ^ 2 - 4 * a * c) ^ (1 / 2);
x1 = (-b + d) / a2;
x2 = (-b - d) / a2;
end --a,c,a2,d的作用域到此结束
print("a = ", a);
print("x1 = " .. x1);
print("x2 = " .. x2);
do
local a,b = 1,10;
if a < b then
print(a); -->1
local a; --具有隐式的“nil”
print(a); -->nil
end --then块至此结束
print("a = " .. a .. ", b = " .. b);
end
--]]
--控制结构
--[[
--嵌套if,由于Lua不支持switch，所以，这种连串的if-elseif很有用。
do
local op = "+";
local a = 3;
local b = 4;
local r;
if op == "+" then
r = a + b;
elseif op == "-" then
r = a - b;
elseif op == "*" then
r = a * b;
elseif op == "/" then
r = a / b;
else
error("invalid operation");
end
end
--]]
--[[
--while ... do ... end
do
local i = 1;
local a = {1,2,3,4,5,6,7,8,};
while a[i] do
print(a[i]);
i = i + 1;
end
end
--]]
--[[
--repeat ... until ...
--在Lua中，一个声明在循环体中的局部变量的作用域包括了条件测试
do
repeat
local line = io.read();
until line ~= " "
print(line); --在此仍可以访问error
end
--]]
--“for”:两中for相同点：1.循环变量是循环体可见。2.决不应该对循环变量作任何赋值。
--[[
--数字型for(numeric for)
--for var = exp1, exp2, exp3 do
-- <执行体>
--end
--原理：var从exp1变化到exp2，每次变化都以exp3为步长(step)递增var，
--并且执行一次“<执行体>”。第三个表达式是可选的，若不指定默认为1.
--注：在for中控制变量为局部变量，仅有循环体内可见。
do
for i = 1, 3, 1 do
print("wo ai yue mengmeng");
end
print(i) --这里访问的是一个全局的“i”
end
--]]
--[[
--泛型for(generic for)，通过一个迭代器(iterator)函数来遍历所有值。
--Lua提供了专门用于遍历数组的迭代器函数“ipairs”，在每次循环
--中，“k”会被赋予一个索引值，同时“v”被赋予一个对应该索引的
--数组元素值。
--打印数组“a”中所有值
do
local a = {1,2,3,4,5,6,7,8,9,"end"};
print("遍历数组a开始：");
for k, v in ipairs(a) do
print("k(key) = " .. k .. ",v(value) = " .. v);
end
end
--打印table t中的所有KEY
do
local t = {["D"] = "fother",["N"] = "mother", ["E"] = "son",3, 4, 5,};
for k in pairs(t) do
print("k(KEY of t) = " .. k);
end
end
--]]
--[[
--生成反向table
do
local days = {[1] = "Sunday", [2] = "Monday", [3] = "Tuesday",
[4] = "Wednesday", [5] = "Thuresday",
[6] = "Friday", [7] = "Saturday"};
local revDays = {};
print("正序数组为：");
for k, v in ipairs(days) do
print("k(key) = " .. k .. ", v(value) = " .. v);
end
for k, v in ipairs(days) do
revDays[v] = k;
end
print("逆序数组，因该是table：")
for k, v in pairs(revDays) do
print("k(key) = " .. k .. ", v(value) = " .. v);
end
end
--]]
----------------------------函数-----------------------------------
--[[
--简单的函数,体现语法和用法
do
function add (a)
local sum = 0;
for i , v in ipairs(a) do
sum = sum + v;
end
return sum;
end
local a = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,};
local sum = nil;
sum = add(a);
print(sum);
end
--]]
--[[
--验证多重赋值在函数参数上的例子
do
local count = 0;
--[===[此函数是在累加一个全局变量，当n为一个数时，全局变量会累加n，
当n为nil或false时，全局变量默认加一--]===]
function incCount(n)
n = n or 1; --如果的哥操作数为真，就返回第一个操作数，不然返回第二个操作数
count = count + n; --如果n为真，则“count” + n，相反，默认加1
end
incCount(3)
print(count);
--如果参数缺省的话，函数参数n会别赋值nil
incCount()
print(count);
end
--]]
--[[
--多重返回值
do
--找到数组中最大的元素和该元素所在的位置
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
maxnum, maxPos = maximum({8, 10, 23, 12, 5});
print(maxnum .. " " .. maxPos);
end
--]]
--[[
--[=[多重函数的注意事项：多重返回函数只有在表达式最后，或是表达是仅有
的返回值，如果在表达式中，则只保留第一个返回值。或者将多重返回值函数
放到一对“()”中，迫使它返回一个参数--]=]
do
function foo0() end
function foo1() return "a"; end
function foo2() return "a", "b"; end
local x, y = foo2();
print("x = " .. x .. " ,y = " .. y);
local x = foo2();
print("x = " .. x .. " ,y = " .. y);
--local z = nil;
local x,y,z = 10,foo2();
print("x = " .. x .. " ,y = " .. y .. " ,z = " .. z);
--特殊返回展示：
print(foo2(),1); -->a1
print(1,foo2()); -->1ab
print((foo2())); -->a
end
--]]
--[[
--书本第一个程序
function fact(n)
if n == 0 then
return 1;
else
return n * fact(n - 1);
end
end
print("enter a number");
a = io.read("*number");
print(fact(a));
--]]
-----------------------字符串简单操作和print函数的使用-----------------------------------------------------
--对字符串的一些常识
--print(1 + "10"); --> 11
--print("10 + 1"); --> 10 + 1
--print("10" * "2"); -->20
--print("hello" + 1); -->错误
--print(10 .. 20); -->1020
--print("hello" .. 1); -->hello1
--[[
--[=[
--输出转意标识符使用
--可以用不同的引号来界定字面字符串本身带的引号
--也可以用转意符“\”来界定
--转义符“\”后跟数字输出的是数字后代表的字符串
--]=]
print("one ilne \nnext line\n\"in quotes\" , 'in qutotes'");
--[==[
one ilne
next line
"in quotes" , 'in qutotes'
--]==]
print('a backslash inside quotes: \'\\\'');
--[===[
a backslash inside quotes: '\'
--]===]
print("a simpler way: '\\'");
--[====[
a simpler way: '\'
--]====]
print("alo\n123\"" .. "\n=\n" .. '\97lo\10\04923"')；
--[=====[
alo
123"
=
alo
123"
--]=====]
--]]
--[=[
--可以是用使用以下的操作符对成页的字符串赋值，这样对写如源程序代码的字符串很方便
page = [[
<html>
<head>
<title>An HTML Page</title>
</head>
<body>
<a href="http://www.lua.org">lua</a>
</body>
</html>
]]
--对字符串取长度用# 5.1新加
print(#page);
--]=]
--[[
--对tonumber函数测试
line = io.read(); --读取一行
n = tonumber(line) --尝试将它转换为一个数字
if n == nil then
error(line .. "is not a valid number");
else
print(n * 2);
end
--]]
--------------------------table的操作--------------------------------------------
--[[
--一般操作
a = {}; --创建一个table，并将它的引用存储到a
k = 'x'; --简单赋值
a[k] = 10; --新条目，key=“x”，value=10
a[20] = "great"; --新条目，key=20，value=“great”
print(a[k]); -->10
k = 20; --赋值
print(a[k]); --“greate”
a["x"] = a["x"] + 1; --新增条目“x”
print(a["x"]); -->11
--]]
--[[
--语糖法
a.x = 10; --等同于a["x"] = 10
print(a.x); --等同于print(a["x"]);
print(a.y); --等同于print(a["y"]);
--]]
--[[
--语糖法注意事项
tableb = {};
x = "y";
tableb[x] = 10; --将10放入以字段“y”为key的条目中
print(tableb[x]); -->10 --打印字段“y”的值
print(tableb.x); -->nil --字段“x”（未定义）的值
print(tableb.y); -->10 --等同于tableb[x]，打印字段“y”的值
--]]
--[[
--如果用整数做索引的话，lua习惯索引是从1开始
tablec = {};
--读取10行数据，并存储到tablec中
--for i=1,10 do --第一种方式
-- tablec[i] = io.read();
--end
for i=1, 10 do
tablec[#tablec+1] = io.read();
end
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
--对table几种长度操作符在Lua中的习惯写法：
print(tablec[#tablec]);
tablec[#tablec] = nil;
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
tablec[#tablec+1] = "v";
--打印所有条目
for i=1,#tablec do
print(tablec[i]);
end
--]]
--[[
--利用table.maxn()来处理有nil的table最大正索引
tabled = {};
tabled[1000] = 1;
print(table.maxn(tabled));
--]]
--[[
--此例子说明，以索引为10和索引为“10”去条目的value不同
i = 10;
j = "10";
k = "+10";
tableE = {};
tableE[i] = "one value";
tableE[j] = "another value";
tableE[k] = "yet another value";
print("tableE[j] = " .. tableE[j]);
print("tableE[k] = " .. tableE[k]);
print("tableE[tonumber(j)] = " .. tableE[tonumber(j)]);
print("tableE[tonumber(k)] = " .. tableE[tonumber(k)]);
--]]
--------------------------------------------表达式操作-----------------------------------------------------------------------------------
--[[
--算数操作符操作。指数操符"^"的操作
x = 5.697050
print("x = " .. x)
print("x的整数部分:" .. x - x % 1);
print("x的小数部分:" .. x % 1);
print("x精确到小数点后n位，此处是第二位：" .. x - x % 0.01);
--]]
--[[
--关系操作符: “<”、“>”、 “<=”、 “>=”、 “==”、 “~=”、
--在Lua中table、userdata和函数，是做引用比较的，也就是说只有当它们引用同一个对象时，才认为它们相等
tableA = {};
tableA.x = 1;
tableA.y = 0;
tableB = {};
tableB.x = 1;
tableB.y = 0;
tableC = tableA;
a = 3
--print();
print(tableA);
print(tableB);
print(tableC);
--]]
--[[
--逻辑操作符：“and”、“or”、“not”、
--“and”和“or”操作符都使用“短路求值（short-cut evaluation）”，也就说，它们只在需要时才会评估第二个操作数。
--在Lua中是把false和nil看为假，其他都为真
--尽量用括号来指定所期望的运算次序，不能优先级
--对于“and”操作符来说，如果第一个操作数为假，则返回第一个操作数，不然返回第二个操作数
print(4 and 5); -->5
print(nil and 13); -->nil
print(false and 13); -->false
--对于“or”操作符来说，如果的哥操作数为真，就返回第一个操作数，不然返回第二个操作数
print(4 or 5); -->4
print(false or 5); -->5
print(nil or 5); -->5
--对于操作符“not”来说，只返回true或false
print(not nil) -->ture
--"and"和“or”操作符的特殊用法，表达和C中a?b:c相同的表达式
--(表达式(a) and 真时返回值(b) or 假时返回值(c))其中前提条件是b为真
number_x = 3;
number_y = 4;
--(number_x > number_y) ? number_x : number_y
number_max = (number_x > number_y) and number_x or number_y;
print("The max number:" .. number_max);
--]]
----------------------table构造式-------------------------------------------------------
--在table构造式中最后一个元素后可以跟“,”或“;”，这种灵活性，
--使得Lua无须将最后一个元素做特殊处理，可以方便以后的扩展。a = {1,2,3,};
--[[
--table构造式,在table式的数组中，索引是从“1”开始的。
week = {"Sunday","Monday","Tuesday","Wednesday","Thursday",
"Friday","Saturday"};
print("The KEY is 1: " .. week[1]); -->Sunday
tableD = {x = 10,y = 20}; --tableD = {}; tableD.x = 10,tableD.y = 20;
print(tableD.x); --print(tableD["x"]);
print(tableD.y);
tableW = {x = 0,y = 0, lable = "console"};
tableX = {math.sin(0), math.sin(1), math.sin(2)};
tableW[1] = "another field"; --添加KEY为“1”到tableW中
tableX.f = tableW; --添加KEY为“"f"”到tableX中
print('tableW["x"] = ' .. tableW["x"]);
print("tableW[1] = " .. tableW[1]);
print("tableX.f[1] = " .. tableX.f[1]);
tableW.x = nil;
if tableX.f == tableW then
print(tableX.f);
print(tableW);
end
--]]
--[[ ---留作以后看
--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
--]]
--[[
--将记录的风格初始化与列表风格的初始化混合在一个构造式中
--通过嵌套构造式来表示复杂的数据结构每个polyline[i]元素都是一个table
polyline = {color = "blue", thickness = 2, npoints = 4,
{x = 0, y = 0},
{x = -10, y = 0},
{x = -10, y = 1},
{x = 0, y = 1}
};
--表示一条记录：
print(polyline[2].x);
print(polyline[1].y);
--]]
--[[
--通用同时通用的table构造式，在方括号中间，显示地用一个表达式来初始化索引值
opname = {["+"] = "add", ["-"] = "sub",
["*"] = "mul", ["/"] = "div"};
i = 20; s = "-";
tableZ = {[i+0] = s, [i+1] = s .. s, [i+2] = s .. s .. s};
print(opname[s]);
print(tableZ[22]);
--以下构造式是全等的
--{x = 100, y = 200}
tablePoint = {["x"] = 100, ["y"] = 200};
--{"r", "g", "b"}
tableColor ={[1] = "r", [2] = "g", [3] = "b"};
--在table构造式中，还可以用分号(“;”)代替逗号(“,”)，通常用于分隔构造式中不同的成分。
--例如，将列表部分记录与记录部分明显的区分开：
polyline1 = {color = "blue", thickness = 2, npoints = 4;
{x = 0, y = 0};
{x = -10, y = 0};
{x = -10, y = 1};
{x = 0, y = 1};
};
--表示一条记录：
print(polyline1[2].x);
print(polyline1[1].y);
--]]
------------------------语句----------------------------------
--1赋值
--[[
--多重赋值中，Lua先对等号右边的所有元素求值，然后才进行赋值。
numberT = 20;
numberA,numberB = 10,2 * numberT;
print("numberA = " .. numberA);
print("numberB = " .. numberB);
--多重赋值这种特性，方便数据交换。
numberA,numberB = numberB,numberA;
print("After change.");
print("numberA = " .. numberA);
print("numberB = " .. numberB);
--注：Lua对于多重赋值规定，如果等号左边变量多余等号右边变量，会将多余的左边变量赋值为“nil”
-- 如果等号右边变量多余左边变量，则将多余的右边变量给丢弃掉。
--如果想赋值一组变量，应为每一个变量赋值。
a1,b1,c1 = 0; --错误
a2,b2,c2 = 0,0,0; --正确
--]]
--局部变量与块(block)
--“尽可能的使用局部变量”，局部变量可以避免将一些无用的名称引入全局环境（global environment）
--[[
--全局变量和局部变量的区别
xnumber = 10; --定义全局变量“xnumber”
local i = 1; --定义程序块中的局部变量“i”
while i <= xnumber do --while循环开始
local xnumber = i * 2; --while循环体中的局部变量“xnumber”
print(xnumber); -->2,4,6,8...
i = i + 1; -->块中局部变量+1
end --while循环结束
if i > 20 then
local xnumber; --定义then中局部变量“xnumber”
xnumber = 20;
print(xnumber + 2); --如果测试成功会打印22，打印的是then中局部变量“xnumber”
else
print(xnumber); --10 (全局变量“xnumber”)
end
print(xnumber); --10 (全局变量“xnumber”)
--]]
--[[
--如果需要显示的界定一个块，可以用“do-end”关键字。
do
local a = 2;
local c = 4;
local b = 8;
local a2 = 2 * a;
local d = (b ^ 2 - 4 * a * c) ^ (1 / 2);
x1 = (-b + d) / a2;
x2 = (-b - d) / a2;
end --a,c,a2,d的作用域到此结束
print("a = ", a);
print("x1 = " .. x1);
print("x2 = " .. x2);
do
local a,b = 1,10;
if a < b then
print(a); -->1
local a; --具有隐式的“nil”
print(a); -->nil
end --then块至此结束
print("a = " .. a .. ", b = " .. b);
end
--]]
--控制结构
--[[
--嵌套if,由于Lua不支持switch，所以，这种连串的if-elseif很有用。
do
local op = "+";
local a = 3;
local b = 4;
local r;
if op == "+" then
r = a + b;
elseif op == "-" then
r = a - b;
elseif op == "*" then
r = a * b;
elseif op == "/" then
r = a / b;
else
error("invalid operation");
end
end
--]]
--[[
--while ... do ... end
do
local i = 1;
local a = {1,2,3,4,5,6,7,8,};
while a[i] do
print(a[i]);
i = i + 1;
end
end
--]]
--[[
--repeat ... until ...
--在Lua中，一个声明在循环体中的局部变量的作用域包括了条件测试
do
repeat
local line = io.read();
until line ~= " "
print(line); --在此仍可以访问error
end
--]]
--“for”:两中for相同点：1.循环变量是循环体可见。2.决不应该对循环变量作任何赋值。
--[[
--数字型for(numeric for)
--for var = exp1, exp2, exp3 do
-- <执行体>
--end
--原理：var从exp1变化到exp2，每次变化都以exp3为步长(step)递增var，
--并且执行一次“<执行体>”。第三个表达式是可选的，若不指定默认为1.
--注：在for中控制变量为局部变量，仅有循环体内可见。
do
for i = 1, 3, 1 do
print("wo ai yue mengmeng");
end
print(i) --这里访问的是一个全局的“i”
end
--]]
--[[
--泛型for(generic for)，通过一个迭代器(iterator)函数来遍历所有值。
--Lua提供了专门用于遍历数组的迭代器函数“ipairs”，在每次循环
--中，“k”会被赋予一个索引值，同时“v”被赋予一个对应该索引的
--数组元素值。
--打印数组“a”中所有值
do
local a = {1,2,3,4,5,6,7,8,9,"end"};
print("遍历数组a开始：");
for k, v in ipairs(a) do
print("k(key) = " .. k .. ",v(value) = " .. v);
end
end
--打印table t中的所有KEY
do
local t = {["D"] = "fother",["N"] = "mother", ["E"] = "son",3, 4, 5,};
for k in pairs(t) do
print("k(KEY of t) = " .. k);
end
end
--]]
--[[
--生成反向table
do
local days = {[1] = "Sunday", [2] = "Monday", [3] = "Tuesday",
[4] = "Wednesday", [5] = "Thuresday",
[6] = "Friday", [7] = "Saturday"};
local revDays = {};
print("正序数组为：");
for k, v in ipairs(days) do
print("k(key) = " .. k .. ", v(value) = " .. v);
end
for k, v in ipairs(days) do
revDays[v] = k;
end
print("逆序数组，因该是table：")
for k, v in pairs(revDays) do
print("k(key) = " .. k .. ", v(value) = " .. v);
end
end
--]]
----------------------------函数-----------------------------------
--[[
--简单的函数,体现语法和用法
do
function add (a)
local sum = 0;
for i , v in ipairs(a) do
sum = sum + v;
end
return sum;
end
local a = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,};
local sum = nil;
sum = add(a);
print(sum);
end
--]]
--[[
--验证多重赋值在函数参数上的例子
do
local count = 0;
--[===[此函数是在累加一个全局变量，当n为一个数时，全局变量会累加n，
当n为nil或false时，全局变量默认加一--]===]
function incCount(n)
n = n or 1; --如果的哥操作数为真，就返回第一个操作数，不然返回第二个操作数
count = count + n; --如果n为真，则“count” + n，相反，默认加1
end
incCount(3)
print(count);
--如果参数缺省的话，函数参数n会别赋值nil
incCount()
print(count);
end
--]]
--[[
--多重返回值
do
--找到数组中最大的元素和该元素所在的位置
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
maxnum, maxPos = maximum({8, 10, 23, 12, 5});
print(maxnum .. " " .. maxPos);
end
--]]
--[[
--[=[多重函数的注意事项：多重返回函数只有在表达式最后，或是表达是仅有
的返回值，如果在表达式中，则只保留第一个返回值。或者将多重返回值函数
放到一对“()”中，迫使它返回一个参数--]=]
do
function foo0() end
function foo1() return "a"; end
function foo2() return "a", "b"; end
local x, y = foo2();
print("x = " .. x .. " ,y = " .. y);
local x = foo2();
print("x = " .. x .. " ,y = " .. y);
--local z = nil;
local x,y,z = 10,foo2();
print("x = " .. x .. " ,y = " .. y .. " ,z = " .. z);
--特殊返回展示：
print(foo2(),1); -->a1
print(1,foo2()); -->1ab
print((foo2())); -->a
end
--]]
1396
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
