Sublime 編輯器

注意：在保存lua文件時，必須是<文件名.lua>的形式，必須加.lua后綴名

執行腳本：Ctrl + B

清空執行結果區：全選 + 刪除

Lua語句

Lua語言是區分大小寫的

Lua語句不需要使用分號結尾， 但是即使寫了分號也不保錯

Lua注釋

單行注釋：-- （sublime快捷鍵：ctrl+/）

多行注釋:--[[ 語句 ]] (sublime快捷鍵：ctrl+shift+/)、--[[ 語句 ]]--、--[[ 語句 --]]

--單行注釋
--print("11111111111")

--多行注釋
--[[
print("22222222222")

print("33333333333333")
]]

--[[
print("22222222222")

print("33333333333333")
]]--

--[[
print("22222222222")

print("33333333333333")
--]]
多行注釋推薦使用--[=[注釋內容]=]


print("44444444444444444")

Lua變量定義

變量名 = 初始值

無需指定數據類型， 會根據賦值的值自動改變變量的數據類型

-- C#  數據類型  變量名 = 初始值
c1 = [[abcdefg]]
print(c1, type(c1))

變量名（標識符）規范

1、以字母或下劃線開頭

2、后面可以有數字、字母、下劃線組成

3、盡量避免 下劃線+大寫字母 開頭的寫法，lua自身保留格式

查看變量類型

type（變量名）

num = 10.1
print(num, type(num))

Lua數據類型

number數字類型

lua不區分整數與小數， 數都是number類型

num = 10.1
print(num, type(num))
num2 = 10
print(num2, type(num2))

nil空數據

等同于null

nil可以使用在條件判斷中，表示false結果

boolean布爾類型

ture 或者 false

lua認為只有false和nil是假的（不滿足條件）， 其他都是真的（滿足條件）

string字符串類型

Lua沒有字符類型， 雙引號與單引號都表示字符串類型

"字符內容"：不可以換行編輯

'字符串內容'：不可以換行編輯

[[字符串內容]]：可以換行編輯，容易與多行注釋沖突

字符串的基本操作

數學運算符 +、-、*、/、%

當兩個字符串進行數學運算符運算時，會將兩個字符串轉換成數值進行計算，如果轉換失敗就報錯

str1 = "5"
str2 = "7"

print("--------------------------字符的數學運算------------------------------")
str3 = str1 + str2
str4 = str1 - str2
str5 = str1 * str2
str6 = str1 / str2
str7 = str1 % str2

print(str3)
print(str4)
print(str5)
print(str6)
print(str7)

字符串的連接

使用“..” 兩個點進行拼接

print("-----------------------------字符串的連接-----------------------------")
str8 = str1 .. str2
print(str8)

字符串的長度

#變量名

print("----------------------字符串的長度------------------------")

str9 = "12345asgfasfd"
length = #str9
print(length)

str10 = [[12345a
sgfasfd]]
length = #str10
print(length)

Lua運算符

算術運算符

+, -, *, /, %

print(1 + 2)
print(4 % 2)

^：冪次方

2 ^ 3表示2的3次方

print(2 ^ 3)

關系運算符

<，>，<=，>=，==，

print(1 > 2)

~=：不等判斷，與C#不一樣

print(1 ~= 2)

邏輯運算符

and：與

同時為真才為真，相當于C# &&

print(true and true)
print(false and true)

or：或

只要有一個為真就為真，相當于C# ||

print(false or true)

not：非

取反，相當于C# ！

print(not true)

流程控制語句

if 條件 then 語句 end

--num為nil， lua認為nil為false
if not num then
    print("num為nil")
end

year = 2004
--1 能被4整除，不能被100整除
--2 能被400整除
if (year % 4 == 0 and year % 100 ~= 0) or year % 400 == 0 then
    print("year: "..year.." 是閏年")
end

if 條件 then 語句1 else 語句2 end

-- if  else

age = 19
if age > 18 then
    print("你已經成年了")
else
    print("你未成年")
end

if 條件1 then 語句1 elseif 條件2 then 語句2 else 語句3 end

-- if  else if  else 
--判斷字符串是否是A或B ，如果是A打印 A1，如果是B打印B2， 如果都不是，打印C3
str = "9"
if str == "A" then
    print("A1")

--elseif是放在一起寫的，中間沒有空格, 只要是條件判斷，條件后要加then關鍵字
elseif str == "B" then
    print("B2")
else
    print("C3")
end

循環語句

while

--[[
C# : 
while(循環條件)
{
    循環體
}
]]

--[[
Lua：
while 循環條件 do
    循環體
end
]]
num = 37
--判斷num是否是質數,  只能被1和本身整除的數就是質數
print("判斷num是否是質數,  只能被1和本身整除的數就是質數")
isPrime = true
i = 2
while i < num do
    if num % i == 0 then
        isPrime = false
        --可以跳出
        break
    end
    i = i + 1
end
if isPrime then
    print("num: "..num .."是質數")
else
    print("num: "..num .. "不是質數")
end


--打印100到999之間的水仙花數
--153 = 1*1*1 + 5*5*5 + 3*3*3
print("打印100到999之間的水仙花數")
num = 100
while num < 1000 do
    --取個位，十位，百位
    one = num % 10;
    tow = (num - one) / 10 % 10
    -- (153 - 3 - 5 * 10) / 100
    three = (num - one - tow * 10) / 100
    if one^3 + tow^3 + three^3 == num then
        print(num)
    end
    num = num + 1
end

repeat

--[[
C#:
do
{
    循環體
}while(循環條件)
滿足條件循環
]]

--[[
lua:
repeat
    循環體
until 跳出循環條件
滿足條件退出循環
]]


num = 10
repeat
    print(num)
    num = num - 1
    --注意條件是跳出循環的條件
until num >= 1

for

--[[
C#
for(int 變量 = 初始值; 循環條件; 增量表達式)
{
    循環體
}
]]

--[[
Lua

for 變量 = 初始值, 閾值, 增量值 do

    循環體

end 
變量超過閾值，結束循環, 
每次循環變量都增加增量值
增量值可以省略，如果省略那么默認是1

]]

--打印2到100之間的質數，包含2和100
for num = 2,100 do

    isPrime = true
    for i = 2, num-1 do
        if num % i == 0 then
            isPrime = false
        end
    end
    if isPrime then
        print(num)
    end
end


--打印2000年到2050年之間的所有閏年
for year = 2000, 2050 do
    if (year % 4 == 0 and year % 100 ~= 0) or year % 400 == 0 then
        print(year)
    end
end

注意：lua的循環語言可以使用break跳出，但是沒有continue

Lua中的數組

lua 中沒有數組的，是使用表table結構來模擬數組, 長度不是固定的

lua數組的默認索引是從1開始的，不是從0，遇到非連續的索引后就停

--[[
C#
數據類型[] 數組名 = new 數據類型[數組的長度]
]]

--[[
lua  中沒有數組的，是使用表table結構來模擬數組, 長度不是固定的

數據名 = {}
]]

array1 = {}
--可以初始化賦值
array2 = {"123", "456"}

--打印第1個數組元素
print(array2[1])

--數組的長度
print(#array2)

--遍歷數組
for i = 1, #array2 do
    print(array2[i])
end

--對第5個索引賦值為“789”
array2[5] = "789"

--數組的長度
print("數組長度: "..#array2)

--這種寫法在語法上沒有錯誤，但是主管不認為是數組
array3 = {[-1] = "45678", [0] = "123", [1] = "456"}
print(array3[-1])
print(array3[0])

--數組的長度
print("數組長度: "..#array3)


--將10 - 1 依次存儲到一個數組中

arr = {}

index = 1
for num = 10, 1, -1 do
    arr[index] = num
    index = index + 1
end

for i = 1, #arr do
    print(arr[i])
end

函數

先定義，再執行

-- 函數的定義
--[[
function 函數名(參數列表)
    
end
]]

--[[
函數名 = function(參數列表)
    
end
]]


function Func1()
    print("執行Func1的方法")
    --該位置調用，只要保證Func1調用時在Func2定義之后就可以
    Func2()
end

--調用會報錯, 因為Func2在該行執行時未定義
--Func2()

Func2 = function()
    print("Func2")
end

Func1()

--帶有參數與返回值的，注意參數列表無需指定類型
function Func3(a, b)
    sum = a + b
    return sum
end

sum = Func3(10, 20)
print(sum)


--多個返回值
function Func4()
    return 1, "str", true, {"abc", "def"}
end

--接收多個返回值的函數，要使用多個變量接收
one, tow, three, four = Func4()
print(one)
print(tow)
print(three)
print(four[1])


--lua函數還支持可變參數  ...
function Func5(...)
    --通過數組獲取可變參數
    --[[
    args = {...}
    for i = 1, #args do
        print(args[i])
    end
    ]]

    --第二種獲取可變參數的方式， arg是lua方法中默認的可變參數組
    for i = 1, #arg do
        print(arg[i])
    end

    print("Func5")
end

Func5(1,"334", true, {"abc", "def"})

表（table）

lua中的table是一個關聯數組， 索引可以是數字也可以是字符串

--定義
tab1 = {}
tab2 = {[1] = "123", ["Key"] = 34, Name = "小明"}

--賦值訪問
print(tab2[1])
tab2["Name"] = "小李"
tab2.Name = "小紅"
--訪問字符串索引的元素
print(tab2["Name"])
print(tab2.Name)
print(tab2["Key"])
print(tab2.Key)

-- 釋放
tab2 = nil

print("----------------------------------------------------------")
--表中存儲方法
tab3 = 
    { 
         Func1 = function(a)
            print("Func1: " .. type(a))
            print(a)
         end 
    }

tab3.Func2 = function(a)
    print("Func2: " .. type(a))
end

--調用表中的方法
--當使用：調用表中初始化時方法或通過表.方法名定義的方法時， 會將表作為第一個參數傳遞到方法中
--當使用 . 調用表中初始化時方法或通過表.方法名定義的方法時， 不會將表傳入
tab3:Func1()
print(tab3)
tab3:Func2()

print("=======================================================")
function tab3:Func3(a)
    print("Func3: " .. type(a))
    print("self: " .. type(self))
end

--當調用使用 表:方法名 定義的方法時
-- 表.方法()調用， 表示不傳入當前表
-- 表:方法()調用， 表示傳入當前表, 不占參數位置，通過self可以獲取表
tab3:Func3()

模塊化開發

require 函數

require("<模塊名>")

TestModel引用其他文件

--執行Model.lua的文件
local m = require("Model")
print("-----------------------------------------------------------------")

print(m.Name)
print(m.Age)
m:Show()

print("-----------------------------------------------------------------")
--執行Model1.lua的文件, 注意Model1在當前文件文件夾的子文件夾Lesson下
require("Lesson/Model1") -- Lesson/Model1 表示相對路徑，相對于當前文件所在文件夾的路徑

--執行文件都有一個加載路徑， 加載路徑都存儲在table表 package.path中
--路徑與路徑間使用分號分隔，后綴是.lua，通過？來匹配文件名
print(type(package.path))

--執行Model3.lua的文件, 注意Model3在D盤的TestLua文件夾下
--需要將桌面路徑添加到 package.path 中,文件路徑以 ";" 號分隔，最后的 2 個 ";;" 表示新加的路徑后面加上原來的默認路徑。
package.path = package.path .. ";D:/TestLua/?.lua"

require("Model3")

print("========================================================================")
tab = {"123", "234", "456", "567"}

local Json = require("JsonUtility")
--將表解析成Json串
str = Json.encode(tab)
print(str)

Model

print("Start Model ......")

local Model = {}

Model.Name = "小明"

Model.Age = 18

function Model:Show()
    print("我叫：" .. self.Name .. ", 我的年齡: " .. self.Age .. "歲")
end

return Model

元表

算術類

+：__add

--元表, 針對table的, 元表是改變表與表間的運算或操作的規則的

t1 = {key = "123", age = 18}
t2 = {name = "456", [-1] = "abc", [1] = "ghj", [2] = "fhgdsh", [4] = "asdfasdf"}

add = 
{
    --合并兩個表為一個新的表
    __add = function (tab1, tab2)
        local tab = {}
        --遍歷tab1
        for k,v in pairs(tab1) do
            tab[k] = v
        end
        --遍歷tab2
        for k,v in pairs(tab2) do
            tab[k] = v
        end
        return tab
    end

}

--設置meta表為t1表的元表
--setmetatable(t1, meta)
setmetatable(t1, add)

--當兩個表向加運算時，先判斷兩個表是否有元表，如果都沒有元表，直接報錯
--如果其中一個有元表，再判斷元表中是否有 __add 的元方法，如果沒有，直接報錯
--如果有元表并且有__add元方法， 那么執行__add的元方法， 該方法的返回值就是兩個表相加的結果
--執行__add元方法時，將 + 號左邊的表作為第一個參數傳入， 將+號右邊的表作為第二個參數傳入
t3 = t1 + t2

--print("t1", t1)
--print("t2", t2)

print(t3)

for k,v in pairs(t3) do
    print(k,v)
end

-：__sub

*：__mul

/：__div

比較類

等于：__eq

設置元表

mytable = {}                          -- 普通表
mymetatable = {}                      -- 元表
setmetatable(mytable,mymetatable)     -- 把 mymetatable 設為 mytable 的元表

__index 元方法

這是 metatable 最常用的鍵。

當你通過鍵來訪問 table 的時候，如果這個鍵沒有值，那么Lua就會尋找該table的metatable（假定有metatable）中的__index 鍵。如果__index包含一個表格，Lua會在表格中查找相應的鍵。

> other = { foo = 3 }
> t = setmetatable({}, { __index = other })
> t.foo
3
> t.bar
nil

如果__index包含一個函數的話，Lua就會調用那個函數，table和鍵會作為參數傳遞給函數。

__index 元方法查看表中元素是否存在，如果不存在，返回結果為 nil；如果存在則由 __index 返回結果。

mytable = setmetatable({key1 = "value1"}, {
  __index = function(mytable, key)
    if key == "key2" then
      return "metatablevalue"
    else
      return nil
    end
  end
})

print(mytable.key1,mytable.key2)

實例輸出結果為：

value1    metatablevalue

__newindex 元方法

__newindex 元方法用來對表更新，__index則用來對表訪問 。

當你給表的一個缺少的索引賦值，解釋器就會查找__newindex 元方法：如果存在則調用這個函數而不進行賦值操作。

mymetatable = {}
mytable = setmetatable({key1 = "value1"}, { __newindex = mymetatable })

print(mytable.key1)

mytable.newkey = "新值2"
print(mytable.newkey,mymetatable.newkey)

mytable.key1 = "新值1"
print(mytable.key1,mymetatable.key1)

輸出結果為：

value1
nil    新值2
新值1    nil

以上實例中表設置了元方法 __newindex，在對新索引鍵（newkey）賦值時（mytable.newkey = "新值2"），會調用元方法，而不進行賦值。而如果對已存在的索引鍵（key1），則會進行賦值，而不調用元方法 __newindex。

總結

以上是生活随笔為你收集整理的第52天-lua语言基础语法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。