字串

字串資料類型是一個由字母、數字和符號組成的順序。它是儲存大多數文字資訊的資料類型。

宣告字串

要宣告變量串，請在角色之間放置引號。 使用雙引號（"）更常見，但單引號（'）也可以使用。 如果您想要在您的字串中包含單引號或雙引號，請將您的字串包在其他類型的引號中，或使用逃出的引號。

local string1 = "Hello world!"
print(string1)  --> 世界你好！

local string2 = 'Hello "world"!'
print(string2)  --> Hello "world"!

要在字串中包含單引和雙引，或建立多行字串，請使用雙撇：

local string1 = [[Hello
world!
Hello "world"!
Hello 'world'!]]

print(string1)
--> 你好
--> 世界！
--> 世界你好！
--> Hello 'world'!

如果需要，您可以在兩個開始和結束橋梁之間使用相同的符號來呈現多個螺柱：

local string1 = [=[Hello
[[world!]]
]=]

print(string1)
--> 你好
--> [[world!]]

結合字串

要結合字串，請使用 連接器 把它們結合在一起，以使之形成兩個點 ( .. )。結合字串不會在字串之間插入空格，因此您必須在上一個/下一個字串之間包含空間格(s)。或者結合在兩個字串之間的空格。

local hello = "Hello"
local helloWithSpace = "Hello "
local world = "world!"

local string1 = hello .. world
local string2 = helloWithSpace .. world
local string3 = hello .. " " .. world

print(string1)  --> Helloworld！
print(string2)  --> 世界你好！
print(string3)  --> Hello world!

注意，print()指令需要多個參數，並且以空格組合它們，因此您可以使用, 而不是,來輸出空格在2>print()2>輸出中。

local hello = "Hello"
local world = "world"
local exclamationMark = "!"

print(hello .. world .. exclamationMark)  --> Helloworld！
print(hello, world .. exclamationMark)  --> 世界你好！
print(hello, world, exclamationMark)  --> Hello world !

將字串轉換為列表

若要將字串轉換為數字，請使用 tonumber() 函數。如果字串沒有數字代表， tonumber() 將返回 nil。

local numericString = "123"
print(tonumber(numericString))  --> 123

local alphanumericString = "Hello123"
print(tonumber(alphanumericString))  --> nil

逃離字串

要逃脫雙引或單引號語法宣言，並在任何角色上方放置空格 ( \ ) ，請在角色前面放置一個返回頁 ( 返回頁 )。例如：

• 要在單一引言中包含單一引言字串，請使用 \'。
• 要在雙倍引用字串中嵌入雙引用，請使用 \"。

local string1 = 'Hello \'world\'!'
print(string1)  --> 世界你好！

local string2 = "Hello \"world\"!"
print(string2)  --> Hello "world"!

某些追蹤回擊的角色會產生特殊角色，而不是逃脫的角色：

• 要埋入新行，請使用 \n。
• 要埋入水平標籤，請使用 \t。

local string1 = "Hello\nworld!"
print(string1)
--> 你好
--> 世界！

local string2 = "Hello\tworld!"
print(string2)  --> Hello	world!

字串解析

Luau 支援 字串轉換 ，這是可以將錯誤表示為字串的功能。使用 backticks ( ` ) 來宣告一個已翻譯的字串，然後在弧狀括號內添加錯誤。

local world = "world"

local string1 = `Hello {world}!`
print(string1)  --> Hello world!

雖然變數是最常見的使用，但您可以使用任何表達式，包括數學：

local world = "world"
local number = 1
local letters = {"w", "o", "r", "l", "d"}

local string1 = `Hello {world}, {number} time!`
local string2 = `Hello {world}, {number + 1} times!`
local string3 = `Hello {table.concat(letters)} a third time!`

print(string1)  --> 世界你好，1次！
print(string2)  --> 世界你好，2次！
print(string3)  --> Hello world a third time!

回撥鍵、捲籠鉤和後撥鍵適用標準逃脫規則：

local string1 = `Hello \`\{world\}\`!`
print(string1)  --> Hello `{world}`!

數學轉換

如果您對串處理數學運算，Luau 會自動將字串轉換為數字。如果字串沒有數字代表，它就會發生錯誤。

print("55" + 10)  --> 65
print("55" - 10)  --> 45
print("55" * 10)  --> 550
print("55" / 10)  --> 5.5
print("55" % 10)  -->5
print("Hello" + 10)	 --> print("Hello" + 10):1: attempt to perform arithmetic (add) on string and number

比較

可以使用 < , <= , > 和 1> >=1> 操作來比較

print("Apple" < "apple") --> 是
print("Banana" < "apple") --> 是 (B 在 ASCII 之前)
print("number100" < "number20") --> true

字串模式參考

字串模式 是您可以使用 string.match() 、string.gmatch() 和其他功能來尋找一個更長字串的片語或子語。

直接比賽

您可以使用直接匹配在 Luau 函數中，例如 string.match() ，除了 魔法字符 之外。 例如，這些指令在字串中尋找 Roblox 字串中的字符。

local match1 = string.match("Welcome to Roblox!", "Roblox")
local match2 = string.match("Welcome to my awesome game!", "Roblox")
print(match1)  --> Roblox
print(match2)  --> nil

角色類別

角色類是進階搜尋串的必需元素。你可以使用它們來搜尋不是字符特定的內容，但適合已知類別（ 字母 、 數字 、 空格 、1>分號1>、4>點數4>和7>括號7>）。

下表顯示 Luau 字串模式的官方角色類別：

對於單一字母的角色，例如 %a 和 %s ，相應的大小寫字母代表相關的上下文字符。例個體、實例， %p 代表斷點角色，而 1> %P1> 代表所有角色，除斷點角色之外。

魔法字符

有 12 個 "魔法字符" 可以在模式中用於特殊目的：

您可以使用 % 符號逃脫並搜尋魔法角色。例如，要搜尋 roblox.com ，請先使用 . (期號) 符號將它前置於 1> %1> 中。

-- 「roblox.com」與「roblox#com」相符，因為期間被解釋為「任何角色」
local match1 = string.match("What is roblox#com?", "roblox.com")
print(match1)  --> roblox#com

-- 以 % 結束期間，因此它被解釋為字符串的字符期
local match2 = string.match("I love roblox.com!", "roblox%.com")
print(match2)  --> roblox.com

錨定

您可以使用 ^ 和 $ 符號在字串的開始或結束搜尋模式。

local start1 = string.match("first second third", "^first")  -- 因為「第一」位於開始
print(start1)  --> 第一

local start2 = string.match("third second first", "^first")  -- 不能匹配，因為 "第一" 不在開始
print(start2)  --> 零

local end1 = string.match("first second third", "third$")  -- 因為「第三」位於結束
print(end1)  --> 第三

local end2 = string.match("third second first", "third$")  -- 不匹配，因為 "第三" 不在結束
print(end2)  --> nil

您也可以使用 ^ 和 $ 以確保模式只匹配整個字串，而不是只有其中的一部分。

-- 使用 ^ 和 $ 匹配全部字串
local match1 = string.match("Roblox", "^Roblox$")  -- 因為「Roblox」是整個字串 (平等)
print(match1)  --> Roblox

local match2 = string.match("I play Roblox", "^Roblox$")  -- 不匹配，因為「Roblox」不是開始和結束
print(match2)  --> 零

local match3 = string.match("I play Roblox", "Roblox")  -- 因為 "Roblox" 位於 "I play Roblox" 內
print(match3)  --> Roblox

類別模組

一個角色類型只能對 一個 角色在字串中匹配。例個體、實例，以下模式 ( "%d" ) 從左到右閱讀字串，找到第一個 第 位數字 ( 1> 21> )，然後停止。

local match = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match)  --> 2

您可以使用 模組器 與任何角色類別來控制結果：

將一個修改器添加到同一個模式("%d+" 而不是 "%d" 則會輸出 25 而不是 1> 21>：

local match1 = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match1)  -->2

local match2 = string.match("The Cloud Kingdom has 25 power gems", "%d+")
print(match2)  --> 25

類別設定

應該使用 Set 當單個角色類無法完成整個工作。例個體、實例，您可能想要使用單個模式匹配兩個下帶 %l 的字母，並使用單個模式匹配 ** %p ** 和 0> %p0> 分號。

套件由括號 [] 圍著它們。在下一個例子中，注意使用套件 ( "[%l%p]+" ) 與不使用套件 ( "不" 使用套件 ( 1> "%l%p"1> ) 之間的差異。

local match1 = string.match("Hello!!! I am another string.", "[%l%p]+")  -- 設定
print(match1)  --> 你好！！！

local match2 = string.match("Hello!!! I am another string.", "%l%p+")  -- 非設定
print(match2)  --> o!!!

第一個指令 (se設定) 告訴 Luau 尋找兩個下帶大小寫字符和分號。 與整個 se設定 後添加的 + 量表後，它找到所有 ello!!! 的字符 ( ello!!!)，停止在空間格時到達。

在第二個指令(非設定)中，+量化器只適用於%p類別前的 o 字元，因此 Luau 只會抓取第一個下拉漢字(2>o2>)，而不是連接符號(5>!!!5>)。

Like 角色類別, 設可以是^ 自己的極[ 。這是通過在"[%p%s]+" 開始直接後的2> [%p%s]+2> 來表示彼此的分號和空格。 例個體、實例，5>"[%p%s

也支援 範圍 讓你可以在開始和結束角色之間找到整個範圍。這是一種先進功能，在 Lua 5.1 手冊 中詳細說明。

字串捕捉

String 捕捉 是在模式內的子樣式。這些樣式被包含在 () 內，用於獲得 (匹擷取) 的子樣式並將它們儲存到變量。例如，下列模式包含兩個捕捉， (%a+) 和 1> percentd+1>，以及�

local pattern = "(%a+)%s?=%s?(%d+)"

local key1, val1 = string.match("TwentyOne = 21", pattern)
print(key1, val1)  --> TwentyOne 21

local key2, val2 = string.match("TwoThousand= 2000", pattern)
print(key2, val2)  --> 2000 年兩千

local key3, val3 = string.match("OneMillion=1000000", pattern)
print(key3, val3)  --> OneMillion 1000000

在上一個模式中，跟隨兩個 ? 類別的量化器是安全的額外，因為它使 %s 標誌的空間在兩個方向都可選。這意味著在平等號標誌周圍有一個或兩個空格不足的情況下，匹配成功。

字串也可以作為下列示例 嵌入 ：

local places = "The Cloud Kingdom is heavenly, The Forest Kingdom is peaceful"
local pattern = "(The%s(%a+%sKingdom)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
	print(description)
	print(kingdom)
end
--> 雲王國是天堂
--> 雲朵王國
-->森林王國是平靜的
--> Forest Kingdom

此模式搜尋會以下方式運作：

Library.string.gmatch() 執行器在整個 "說明" 模式中尋找匹配，其中外部的兩個字符串由親和號定義。這在第一個命令中停止，並捕捉以追蹤中內容：

使用成功的第一次擷取，再次尋找 "kingdom" 模式由內部對子括號定義的匹配。這個階層結構只會捕捉以追蹤中內容：

執行器然後退出，並且繼續搜尋完整字串，捕捉以追蹤中內容：

除了上述所有內容外，還有一個特殊例子 空白捕捉 ( () )。如果捕捉是空的，則 string 的位置會被捕捉：

local match1 = "Where does the capture happen? Who knows!"
local match2 = "This string is longer than the first one. Where does the capture happen? Who knows?!"

local pattern = "()Where does the capture happen%? Who knows!()"

local start1, finish1 = string.match(match1, pattern)
print(start1, finish1)  --> 142

local start2, finish2 = string.match(match2, pattern)
print(start2, finish2)  --> 43 84

這些特殊捕捉可以像普通捕捉一樣重疊：

local places = "The Cloud Kingdom is heavenly, The Forest Kingdom is peaceful."
local pattern = "The (%a+()) Kingdom is %a+"

for kingdom, position in string.gmatch(places, pattern) do
	print(kingdom, position)
end
--> 雲朵 10
--> Forest 42

返回的值是不尋常的，因為它們是 數字 而不是字串：

local match = "This is an example"
local pattern = "This is an ()example"

local position = string.match(match, pattern)
print(typeof(position))  --> number