字符串

字符串数据类型是一个字符串，例如字母、数字和符号。它是存储大多数文本信息的数据类型。

声明字符串

要宣布一个字符变量，请将引号包围角色。 使用双引号（"）更常见，但单引号（'）也可以使用。 如果您想要在您的字符串中包含单引号或双引号，请将您的字符串包围其他类型的引号，或使用逃出引号。

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!]]

结合字符串

要将字符串合并，请使用两个点（..）将它们连接起来。 不会在字符串之间插入空格，因此您需要在上下文字符串之间包含空间格。 或者在两个字符串之间连接空格。

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

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

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

注意，print()命令需要多个参数，并将它们组合成with 空格，因此您可以使用,而不是2>..2>来生成空格在5>print()5>输出中。

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

print(hello .. world .. exclamationMark)  --> 黄色世界！
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 支持 字符串 interpolation ，这是一个可以将表达插入字符串的功能。 使用 backticks ( ` ) 来声明一个 interpolated 字符串，然后在圆号内添加表达。

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

角色类

角色类是为更高级的字符搜索提供基础。你可以使用它们来搜索不是必须是角色特定的内容，但与已知的类别（角色）、字符串、空格、2>分号2>、5>问号5>等内容相关的内容。

下表显示 Luau 字符串模式的官方角色类：

对于单个字符角色，例如 %a 和 %s ，相应的大写字母代表该类的“反对”。例实例， %p 代表打号角色，而 1> %P1> 代表所有除打号角色之外的角色。

魔法角色

有 12 个“魔法字符” 用于在模式中的特殊用途：

您可以使用 % 符号逃离并搜索魔法角色。例如，要搜索 roblox.com ，请先使用 . (期间) 符号，然后使用 1> %1> 作为在 4> %4> 中的前置符号。

-- “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” 被包含在 “我玩 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

类别设置

设置 应该用于单个角色类无法完成整个工作时。例实例，您可能想要使用单个模式匹配 both lowercase letters ( %l ) 和 打破符号角 ( 0> %p0> ) 使用一个单个模式。

集合由括号 [] 周围的字符定义。在下面的例子中，注意使用集合 ( "[%l%p]+" ) 和不使用集合 ( "%l%p") 之间的区别。

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 找到 both 下划字符和打号。 使用整个 se设置 后添加的 + 量表，它找到 所有 这些字符 ( ello!!! )，停止在空间到达时。

在第二个命令(非设置)中，+ 量化器仅适用于前后 %p 类，因此 Luau 只会抓取第一个下划角角色(o )，然后是2> !!!2> 系列的分号(5> o5>).

像角类别类似，可以将设置的“对称”字符作为自己的“反对”。这是通过在设置开始时添加一个 ^ 角色来实现的，直接在打开 [ 后。例实例， "[%p%s]+" 代表所有角色，除了打开 2>("

还支持 范围 允许您找到启动和结束角色之间的整个范围。这是 Lua 5.1 手册中的高级功能，具体描述在更多资料 在线电子书 上。

字符串捕捉

字符串 捕捉 在模式内是子模式。这些被包含在父亲标签 () 内，用于获取匹配子串并将其保存到变量。例如，下列模式包含两个捕捉， (%a+) 和 1> percent ，4> 在成功匹配后返回两个子串。

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 类的量化器是一个安全的添加，因为它使空间在两个 = 侧面都可选。这意味着在没有两个 1>%s1> 空间的情况下匹配成功。

字符串捕捉也可以作为 串子 示例：

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() 继承器在整个“描述”模式定义的父子组中寻找匹配。这在第一个命令行中停止，并捕获以关注中/正在关注内容：

使用它成功的第一次文本捕捉，后来的遍历器在“王国”模式定义的父子对子之间寻找匹配。这个递归模式只会简单地捕捉以关注中/正在关注内容：

itteriter 然后退出，继续搜索完整字符串，捕获以关注中/正在关注内容：

除了上述所有内容外，还有一个特殊例子，其中 空白捕捉 ( () ) 。如果捕捉是空的，那么在字符串中的位置将被捕捉：

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)  --> 1 42

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