线程

*此内容使用人工智能(Beta)翻译,可能包含错误。若要查看英文页面,请点按 此处

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

宣言字符串

要宣言一个字符串变量,请将引号放在字符周围。更常用双引号("),但单引号(')也可以使用。如果您想在字符串中包含单个或双个引号,将您的字符串包围在另一种引号类型上,或使用 逃生引号


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) --> 你好世界!
print(string2) --> 你好,世界!
print(string3) --> Hello world!

请注意,print() 命令接受多个参数并将它们组合为 **** 空格,因此您可以使用 , 而不是 .. 来产生空间在 print()输出。


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支持 字符串插入 功能,这是一项允许您将表达式插入到字符串的功能。使用撇号 ( ` ) 来宣言插入的字符串,然后添加括号内的表达式:


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

比较

字符串可以使用 < , <= , >>= 运营商进行比较,其中每个字符串中的 ASCII 代码基于字符的字典顺序进行比较。这将导致在字符串中的数字无法正确比较,例如, "100" 小于 "20" ,因为 bytes "0" 和 bytes "1" 的 ASCII 代码比 byte "2" 低。


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

角色类类别

角色类是更高级的字符搜索必不可少的。您可以使用它们来搜索不一定与角色特定的东西,但适合于已知类别(类),包括 字母数字空格句号 等。

下表显示 Luau 字符模式的官方角色类别:

代表示例匹配
.任何字符32kasGJ1%fTlk?@94
%a大写或小写的字母aBcDeFgHiJkLmNoPqRsTuVwXyZ
%l小写字母abcdefghijklmnopqrstuvwxyz
%u大写字母ABCDEFGHIJKLMNOPQRSTUVWXYZ
%d任何数字(数字)0123456789
%p任何撇号字符!@#;,.
%w一个字母数字字符(是字母 一个数字)abcdefghijklmnopqrsztuvwxyz0123456789
%s空格或空白字符 , \n , 和 \r
%c特殊的控制字符
%x十六进制字符0123456789ABCDEF
%zNULL 字符 (\0 )

对于单个字母字类如 %a%s ,相应的大写字母代表了类的“反面”。例实例,%p 代表一个标点符号,而 %P 代表所有字符,除了标点符号。

魔法字符

有 12 个“魔法字符”,用于模式的特殊用途:

$%^*()
.[]+-?

您可以使用 % 符号逃离并搜索魔法字符。例如,要搜索 roblox.com , 通过在前面加入 . (时间符号) 来逃离 % (时间符号) 符号,如在 %. 中。


-- “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

您还可以使用 both ^$ 一起来确保模式匹配仅全部字符串,而不是某些部分。


-- 使用 ^ 和 $ 匹配整个字符串
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")从左到右开始阅读字符串,找到第 数字(2),然后停止。


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

您可以使用 修改器 与任何角色类型来控制结果:

数量计意义
+匹配前一个字符类别中的 1 或更多字符
-尽可能匹配少量以前的角色类别
*匹配前一个字符类的 0 或更多字符
?匹配前一个字符类别的 1 或更少
%n对于 n 之间的 19,匹配与第 n 捕获的字符串相等的子串。
%bxy平衡捕获匹配 x , y , 以及之间的所有内容(例如, %b() 匹配一对括号,以及之间的所有内容)

将相同模式添加修改器("%d+" 而不是 "%d"),输出 25 而不是 2


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

类集

集合 应在单个字符类无法完成整个工作时使用。例实例,你可能想要使用单个模式匹配小写字母(%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!!!

第一个命令(设置)告诉 Luau 找到小写字母和句点符号。通过在整个集合之后添加 + 量化器,它找到了 所有 这些字符 ( ello!!! ),当它到达空间时停止。

在第二个命令(非设置)中,+量化器仅适用于前面的%p类,因此 Luau 只抓取前面的首个小写字母(o),而不是系列的分号(!!!)。

像角类别类似,集合可以是自己的“反对者”。这可以通过在设置合的开头添加 ^ 字符来实现,直接在打开 [ 之后。例实例, 代表句点和空格,而 代表所有字符,除了句点和空格外。

集合也支持 范围 ,这可以让你找到从开始和结束字符之间的整个匹配范围。这是一项高级功能,在 Lua 5.1 手册 中更详细地列出。

字符串捕获

字符串 捕获 是模式内的子模式。这些被括号 () 包围,用于获取 (文本捕捉) 匹配的子串并将其保存到变量中。例如,以下模式包含两个捕获,(%a+)(%d+) , 它们在匹配成功后返回两个子串。


local pattern = "(%a+)%s?=%s?(%d+)"
local key1, val1 = string.match("TwentyOne = 21", pattern)
print(key1, val1) --> 二十一 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

该模式搜索的工作方式如下:

迭代器 string.gmatch() 查找外部括号组定义的整个"描述"模式的匹配。这在第一个逗号处停止,并捕获以关注中/正在关注内容:

#模式捕获
1(The%s/%a+%s王国)[%w%s]+)云端王国是天堂

使用其成功的第一次文本捕捉,迭代器然后寻找由内部括号定义的"王国"模式的匹配。这个嵌套模式仅捕获以关注中/正在关注内容:

#模式捕获
2(%a+%s王国)云之王国

迭代器然后退出并继续搜索全部字符串,捕获以关注中/正在关注内容:

#模式捕获
3(The%s/%a+%s王国)[%w%s]+)森林王国是和平的
4(%a+%s王国)森林王国

除了上述所有内容外,还有一个特殊情况与一个 空捕获 ( () )。如果捕获是空的,那么在字符串中的位置将被捕获:


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