--------------------------第一個測試程序-----------------------------------------------------------
--[[
--書本第一個程序
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
--]]
一個Lua小白的筆記
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章