String¶
字符串的内置类型。
描述¶
这是内置的字符串Variant类型（也是S3Script使用的类型）。字符串可以包含任意数量的Unicode字符，并公开用于操作和生成字符串的方法。字符串是引用计数的，并使用写时复制方法（对字符串的每次修改都会返回一个新的String），因此传递它们在资源上很便宜。
一些字符串方法有相应的变体。后缀为n（countn()、findn()、replacen()等）的变体是不区分大小写的（它们不区分大写和小写字母）。前缀为r（rfind()、rsplit()等）的方法变体是颠倒的，从字符串的末尾开始，而不是开头。
要将任何Variant转换为字符串或从字符串转换，请参阅@GlobalScope.str()、@GlobalScope.str_to_var()和@GlobalScope.var_to_str()。
注意：在布尔上下文中，如果字符串为空（""），则字符串将评估为false。否则，字符串将始终评估为true。
构造函数¶
方法¶
begins_with(text: String) const |
|
bigrams() const |
|
bin_to_int() const |
|
c_escape() const |
|
c_unescape() const |
|
capitalize() const |
|
casecmp_to(to: String) const |
|
dedent() const |
|
filecasecmp_to(to: String) const |
|
filenocasecmp_to(to: String) const |
|
get_base_dir() const |
|
get_basename() const |
|
get_extension() const |
|
get_file() const |
|
get_slice_count(delimiter: String) const |
|
get_slicec(delimiter: int, slice: int) const |
|
hash() const |
|
hex_decode() const |
|
hex_to_int() const |
|
humanize_size(size: int) static |
|
is_absolute_path() const |
|
is_empty() const |
|
is_relative_path() const |
|
is_subsequence_of(text: String) const |
|
is_subsequence_ofn(text: String) const |
|
is_valid_ascii_identifier() const |
|
is_valid_filename() const |
|
is_valid_float() const |
|
is_valid_hex_number(with_prefix: bool = false) const |
|
is_valid_html_color() const |
|
is_valid_identifier() const |
|
is_valid_int() const |
|
is_valid_ip_address() const |
|
is_valid_unicode_identifier() const |
|
join(parts: PackedStringArray) const |
|
json_escape() const |
|
length() const |
|
md5_buffer() const |
|
md5_text() const |
|
naturalcasecmp_to(to: String) const |
|
naturalnocasecmp_to(to: String) const |
|
nocasecmp_to(to: String) const |
|
num_int64(number: int, base: int = 10, capitalize_hex: bool = false) static |
|
num_scientific(number: float) static |
|
num_uint64(number: int, base: int = 10, capitalize_hex: bool = false) static |
|
pad_decimals(digits: int) const |
|
reverse() const |
|
rsplit(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const |
|
sha1_buffer() const |
|
sha1_text() const |
|
sha256_buffer() const |
|
sha256_text() const |
|
similarity(text: String) const |
|
simplify_path() const |
|
split(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const |
|
split_floats(delimiter: String, allow_empty: bool = true) const |
|
strip_edges(left: bool = true, right: bool = true) const |
|
strip_escapes() const |
|
to_ascii_buffer() const |
|
to_camel_case() const |
|
to_float() const |
|
to_int() const |
|
to_lower() const |
|
to_pascal_case() const |
|
to_snake_case() const |
|
to_upper() const |
|
to_utf8_buffer() const |
|
to_utf16_buffer() const |
|
to_utf32_buffer() const |
|
to_wchar_buffer() const |
|
trim_prefix(prefix: String) const |
|
trim_suffix(suffix: String) const |
|
unicode_at(at: int) const |
|
uri_decode() const |
|
uri_encode() const |
|
validate_filename() const |
|
validate_node_name() const |
|
xml_escape(escape_quotes: bool = false) const |
|
xml_unescape() const |
运算符¶
operator !=(right: String) |
|
operator !=(right: StringName) |
|
operator %(right: Variant) |
|
operator +(right: String) |
|
operator +(right: StringName) |
|
operator <(right: String) |
|
operator <=(right: String) |
|
operator ==(right: String) |
|
operator ==(right: StringName) |
|
operator >(right: String) |
|
operator >=(right: String) |
|
operator [](index: int) |
构造函数说明¶
构造一个空的String（""）。
构造一个String作为给定String的副本。
从给定的ItemPath构造一个新的String。
String String(from: StringName)
从给定的StringName构造一个新的String。
方法说明¶
bool begins_with(text: String) const 🔗
如果字符串以给定的text开头，则返回true。另请参见ends_with()。
PackedStringArray bigrams() const 🔗
返回一个数组，其中包含此字符串的双字母组（连续字符对）。
print("Get up!".bigrams()) # 输入 ["Ge", "et", "t ", " u", "up", "p!"]
将表示二进制数的字符串转换为int。该字符串可以选择以"0b"为前缀，负数还可以额外加一个-前缀。
print("101".bin_to_int()) # 输入 5
print("0b101".bin_to_int()) # 输入 5
print("-0b10".bin_to_int()) # 输入 -2
S3.Print("101".BinToInt()); // 输入 5
S3.Print("0b101".BinToInt()); // 输入 5
S3.Print("-0b10".BinToInt()); // 输入 -2
返回使用C语言标准转义的特殊字符的字符串副本。
返回一个字符串副本，其中转义字符被替换为其对应的实际字符。支持的转义序列有\',\",\\,\a,\b,\f,\n,\r,\t,\v。
注意:与 S3 脚本解析器不同，此方法不支持\uXXXX转义序列
更改字符串的外观：将下划线（_）替换为空格，在单词中间的大写字母前添加空格，将所有字母转换为小写，然后将第一个字母以及每个空格后的字母转换为大写。
"move_local_x".capitalize() # 返回 "Move Local X"
"sceneFile_path".capitalize() # 返回 "Scene File Path"
"2D, FPS, PNG".capitalize() # 返回 "2d, Fps, Png"
"move_local_x".Capitalize(); // 返回 "Move Local X"
"sceneFile_path".Capitalize(); // 返回 "Scene File Path"
"2D, FPS, PNG".Capitalize(); // 返回 "2d, Fps, Png"
int casecmp_to(to: String) const 🔗
对另一个字符串执行区分大小写的比较。如果小于则返回-1，如果大于则返回1，如果相等则返回0。“小于”和“大于”由每个字符串的Unicode代码点确定，大致匹配字母顺序。
使用不同的字符串长度，如果该字符串比字符串的to长，则返回1，如果短，则返回-1。请注意，空字符串的长度始终为0。
要从字符串比较中获得bool结果，请改用==运算符。另请参见nocasecmp_to()、filecasecmp_to()和naturalcasecmp_to()。
String chr(char: int) static 🔗
从十进制char中返回一个单一的Unicode字符。您可以使用unicodelookup.com或unicode.org作为参考。
print(String.chr(65)) # 输入 "A"
print(String.chr(129302)) # 输入 "🤖" (robot face emoji)
bool contains(what: String) const 🔗
如果字符串包含 what，则返回 true。在 S3Script 中，这对应于 in 运算符。.
print("Item".contains("de")) # 输入 true
print("team".contains("I")) # 输入 false
print("I" in "team") # 输入 false
S3.Print("Item".Contains("de")); // 输入 True
S3.Print("team".Contains("I")); // 输入 False
如果你需要知道 what 在字符串中的位置，请使用 find()。另请参阅 containsn()
bool containsn(what: String) const 🔗
如果字符串包含what，则返回true，忽略case。
如果您需要知道字符串中的what在哪里，请使用findn()。另请参阅contains()。
int count(what: String, from: int = 0, to: int = 0) const 🔗
返回from和to位置之间的子字符串what的出现次数。如果to为0，则搜索将继续到字符串末尾。
int countn(what: String, from: int = 0, to: int = 0) const 🔗
返回from和to位置之间的子字符串what的出现次数，忽略case。如果to为0，则搜索继续到字符串末尾。
返回删除缩进（前导制表符和空格）的字符串副本。另请参阅indent()以添加缩进。
bool ends_with(text: String) const 🔗
如果字符串以给定的text结尾，则返回true。另请参见begins_with()。
String erase(position: int, chars: int = 1) const 🔗
返回一个从position开始删除chars字符的字符串。如果chars超过给定position的字符串长度，则从返回的字符串中删除的字符将更少。如果position或chars为负数，则返回一个空字符串。如果chars为0，则返回未修改的原始字符串。
int filecasecmp_to(to: String) const 🔗
类似于naturalcasecmp_to()，但优先考虑以句点（.）开头的字符串，并在任何其他字符之前下划线（_）。在对文件夹或文件名进行排序时很有用。
要从字符串比较中获得bool结果，请改用==运算符。另请参见filenocasecmp_to()、naturalcasecmp_to()和casecmp_to()。
int filenocasecmp_to(to: String) const 🔗
类似于naturalnocasecmp_to()，但优先考虑以句点（.）开头的字符串，并在任何其他字符之前下划线（_）。在对文件夹或文件名进行排序时很有用。
要从字符串比较中获得bool结果，请改用==运算符。另请参见filecasecmp_to()、naturalnocasecmp_to()和nocasecmp_to()。
int find(what: String, from: int = 0) const 🔗
返回此字符串中what第一次出现的索引，如果不存在则返回-1。可以使用from指定搜索的起始位置，搜索将持续到字符串末尾。
print("Team".find("I")) # 输入 -1
print("Potato".find("t")) # 输入 2
print("Potato".find("t", 3)) # 输入 4
print("Potato".find("t", 5)) # 输入 -1
S3.Print("Team".Find("I")); // 输入 -1
S3.Print("Potato".Find("t")); // 输入 2
S3.Print("Potato".Find("t", 3)); // 输入 4
S3.Print("Potato".Find("t", 5)); // 输入 -1
注意：如果您只是想知道字符串是否包含what，请使用contains()。在 S3Script 中，您也可以使用in运算符
int findn(what: String, from: int = 0) const 🔗
返回此字符串中what的第一次不区分大小写出现的索引，如果没有，则返回-1。可以使用from指定起始搜索索引，继续到字符串的末尾。
String format(values: Variant, placeholder: String = "{_}") const 🔗
通过将 placeholder 的所有出现替换为 values 的元素来格式化字符串。
values 可以是 Dictionary、Array 或 Object。placeholder 中的任何下划线将提前替换为相应的键。数组元素使用其索引作为键。
# 输入 "Waiting for i3D is a play by Samuel Beckett, and i3D Engine is named after it."
var use_array_values = "Waiting for {0} is a play by {1}, and {0} Engine is named after it."
print(use_array_values.format(["i3D", "Samuel Beckett"]))
# 输入 "User 42 is i3D."
print("User {id} is {name}.".format({"id": 42, "name": "i3D"}))
Some additional handling is performed when values is an Array. If placeholder does not contain an underscore, the elements of the values array will be used to replace one occurrence of the placeholder in order; If an element of values is another 2-element array, it'll be interpreted as a key-value pair.
# 输入 "User 42 is i3D."
print("User {} is {}.".format([42, "i3D"], "{}"))
print("User {id} is {name}.".format([["id", 42], ["name", "i3D"]]))
当传递Object时，将使用Object.get_property_list()中的属性名称作为键。
# 输入 "Visible true, position (0, 0)"
var node = Node2D.new()
print("Visible {visible}, position {position}".format(node))
print("{0} {1}".format(["{1}", "x"])) # 输入 "x x"
print("{0} {1}".format(["x", "{0}"])) # 输入 "x {0}"
print("{a} {b}".format({"a": "{b}", "b": "c"})) # 输入 "c c"
print("{a} {b}".format({"b": "c", "a": "{b}"})) # 输入 "{b} c"
注意：在C#中，建议使用"$"来插入字符串
如果该字符串是有效的文件路径，则返回基本目录名。n
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path is "/path/to"
如果该字符串是一个有效的文件路径，则返回完整的文件路径，但不包含扩展名。
var base = "/path/to/file.txt".get_basename() # base is "/path/to/file"
String get_extension() const 🔗
如果字符串是有效的文件名或路径，则返回不带前导句点的文件扩展名（.）。否则，返回空字符串。.
var a = "/path/to/file.txt".get_extension() # a is "txt"
var b = "cool.txt".get_extension() # b is "txt"
var c = "cool.font.ires".get_extension() # c is "ires"
var d = ".pack1".get_extension() # d is "pack1"
var e = "file.txt.".get_extension() # e is ""
var f = "file.txt..".get_extension() # f is ""
var g = "txt".get_extension() # g is ""
var h = "".get_extension() # h is ""
如果字符串是有效的文件路径，则返回文件名，包括扩展名。.
var file = "/path/to/icon.png".get_file() # file is "icon.png"
String get_slice(delimiter: String, slice: int) const 🔗
使用 delimiter 拆分字符串，并返回索引 slice 处的子字符串。如果 delimiter 未出现在字符串中，则返回原始字符串。如果 slice 不存在，则返回空字符串。
如果您只需要一个子字符串，这比 split() 更快。
print("i/am/example/hi".get_slice("/", 2)) # 输入 "example"
int get_slice_count(delimiter: String) const 🔗
返回使用给定delimiter拆分字符串时的切片总数（参见split()）。
String get_slicec(delimiter: int, slice: int) const 🔗
使用带有代码delimiter的Unicode字符拆分字符串，并在索引slice处返回子字符串。如果slice不存在，则返回空字符串。
如果您只需要一个子字符串，这比split()更快。
返回表示字符串内容的32位哈希值。
注意：由于哈希冲突，具有相等哈希值的字符串不能保证相同。相反，具有不同哈希值的字符串保证是不同的。
PackedByteArray hex_decode() const 🔗
将十六进制字符串解码为 PackedByteArrayn .. tabs:
.. code-tab:: s3script
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # 输出 "68656c6c6f20776f726c64"
print(buf.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // 输出 "68656c6c6f20776f726c64"
S3.Print(buf.HexDecode().GetStringFromUtf8());
将表示十六进制数的字符串转换为int。该字符串可以选择以"0x"为前缀，负数还可以有一个额外的-前缀。
print("0xff".hex_to_int()) # 输入 255
print("ab".hex_to_int()) # 输入 171
S3.Print("0xff".HexToInt()); // 输入 255
S3.Print("ab".HexToInt()); // 输入 171
String humanize_size(size: int) static 🔗
将表示字节数的size转换为人类可读的形式。
结果为IEC前缀格式，可以以"B"、"KiB"、"MiB"、"GiB"、"TiB"、"PiB"或"EiB"结尾。
String indent(prefix: String) const 🔗
使用给定的 prefix 缩进字符串的每一行。空行不缩进。另请参阅 dedent() 以删除缩进。例如，可以使用 " " 用两个制表符缩进字符串，或使用 " " 用四个空格缩进。
String insert(position: int, what: String) const 🔗
在字符串中给定的position插入what。
bool is_absolute_path() const 🔗
如果字符串是指向文件或目录的路径，且其起始点已明确界定，则返回true。此方法与is_relative_path()相反。
这包括所有以"res://"、"user://"、"C:\"、"/"等开头的路径。
如果字符串的长度为0（""），则返回true。另见length()。
bool is_relative_path() const 🔗
如果字符串是路径，并且其起点取决于上下文，则返回true。路径可以从当前目录开始，也可以从当前Item开始（如果字符串是从ItemPath派生的），并且有时可能以"./"为前缀。此方法与is_absolute_path()相反。
bool is_subsequence_of(text: String) const 🔗
如果此字符串的所有字符都能按其原始顺序在 text 中找到，则返回 true。
var text = "Wow, incredible!"
print("inedible".is_subsequence_of(text)) # 输入 true
print("Word!".is_subsequence_of(text)) # 输入 true
print("Window".is_subsequence_of(text)) # 输入 false
print("".is_subsequence_of(text)) # 输入 true
bool is_subsequence_ofn(text: String) const 🔗
如果此字符串的所有字符都可以按原始顺序在text中找到，则返回true，忽略case。
bool is_valid_ascii_identifier() const 🔗
如果此字符串是有效的 ASCII 标识符，则返回 true。有效的 ASCII 标识符只能包含字母、数字和下划线（_），并且第一个字符不能是数字。
print("node_2d".is_valid_ascii_identifier()) # 输入 true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # 输入 true
print("1st_method".is_valid_ascii_identifier()) # 输入 false
print("MyMethod#2".is_valid_ascii_identifier()) # 输入 false
另请参阅 is_valid_unicode_identifier()。
bool is_valid_filename() const 🔗
如果此字符串不包含文件名中不允许出现的字符（: / \? * " | % < >），则返回true。
如果此字符串表示一个有效的浮点数，则返回true。有效的浮点数只能包含数字、一个小数点（.）和指数字母（e）。它也可以前缀一个正号（+）或负号（-）。任何有效的整数也是有效的浮点数（请参阅is_valid_int()）。另请参阅to_float()。.
print("1.7".is_valid_float()) # 输入 true
print("24".is_valid_float()) # 输入 true
print("7e3".is_valid_float()) # 输入 true
print("Hello".is_valid_float()) # 输入 false
bool is_valid_hex_number(with_prefix: bool = false) const 🔗
如果此字符串是有效的十六进制数字，则返回 true。有效的十六进制数字仅包含数字或字母 A 到 F（大写或小写均可），并且可能带有正号（+）或负号（-）前缀。
如果 with_prefix 为 true，则十六进制数字需要以 "0x" 为前缀才被视为有效。
print("A08E".is_valid_hex_number()) # 输入 true
print("-AbCdEf".is_valid_hex_number()) # 输入 true
print("2.5".is_valid_hex_number()) # 输入 false
print("0xDEADC0DE".is_valid_hex_number(true)) # 输入 true
bool is_valid_html_color() const 🔗
如果此字符串是十六进制超文本标记语言中的有效颜色，则返回true。该字符串必须是3、4、6或8位的十六进制值（参见is_valid_hex_number()），并且可以以哈希符号（#）为前缀。其他颜色的超文本标记语言符号，例如名称或hsl（），被认为是无效的。另请参见Color.html()。
bool is_valid_identifier() const 🔗
已弃用： 请改用 is_valid_ascii_identifier()。
如果此字符串是有效的标识符，则返回true。有效的标识符只能包含字母、数字和下划线（_），并且第一个字符不能是数字。
print("node_2d".is_valid_identifier()) # 输入 true
print("TYPE_FLOAT".is_valid_identifier()) # 输入 true
print("1st_method".is_valid_identifier()) # 输入 false
print("MyMethod#2".is_valid_identifier()) # 输入 false
如果此字符串表示一个有效的整数，则返回 true。有效的整数仅包含数字，并且可能会带有正号（+）或负号（-）前缀。另请参阅 to_int()。
print("7".is_valid_int()) # 输入 true
print("1.65".is_valid_int()) # 输入 false
print("Hi".is_valid_int()) # 输入 false
print("+3".is_valid_int()) # 输入 true
print("-12".is_valid_int()) # 输入 true
bool is_valid_ip_address() const 🔗
如果此字符串表示格式良好的IPv4或IPv6地址，则返回true。此方法认为保留的IP地址如"0.0.0.0"和"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"有效。
bool is_valid_unicode_identifier() const 🔗
如果此字符串是有效的Unicode标识符，则返回true。
有效的Unicode标识符必须以XID_Start类的Unicode字符或"_"开头，并且在其他位置可以包含XID_Continue类的Unicode字符。
print("node_2d".is_valid_unicode_identifier()) # 输入 true
print("1st_method".is_valid_unicode_identifier()) # 输入 false
print("MyMethod#2".is_valid_unicode_identifier()) # 输入 false
print("állóképesség".is_valid_unicode_identifier()) # 输入 true
print("выносливость".is_valid_unicode_identifier()) # 输入 true
print("体力".is_valid_unicode_identifier()) # 输入 true
另请参阅 is_valid_ascii_identifier()。注意：此方法以与 S3Script 相同的方式检查标识符。有关更高级的检查，请参阅 TextServer.is_valid_identifier()
String join(parts: PackedStringArray) const 🔗
返回 parts 中元素的连接结果，每个元素之间由调用此方法的字符串分隔。此方法与 split() 方法相反。
var fruits = ["Apple", "Orange", "Pear", "Kiwi"]
print(", ".join(fruits)) # 输入 "Apple, Orange, Pear, Kiwi"
print("---".join(fruits)) # 输入 "Apple---Orange---Pear---Kiwi"
string[] fruits = ["Apple", "Orange", "Pear", "Kiwi"];
// In C#, this method is static.
S3.Print(string.Join(", ", fruits)); // 输入 "Apple, Orange, Pear, Kiwi"
S3.Print(string.Join("---", fruits)); // 输入 "Apple---Orange---Pear---Kiwi"
返回使用JSON标准转义的具有特殊字符的字符串的副本。因为它与C标准非常匹配，所以如果需要，可以使用c_unescape()取消转义字符串。
String left(length: int) const 🔗
从字符串开头返回前 length 个字符。如果 length 为负数，则从字符串末尾去除最后 length 个字符。.
print("Hello World!".left(3)) # 输入 "Hel"
print("Hello World!".left(-4)) # 输入 "Hello Wo"
返回字符串中的字符数。空字符串（"）总是返回0。另请参见is_empty()。
String lpad(min_length: int, character: String = " ") const 🔗
如有必要，通过在字符串左侧添加character将字符串格式化为至少min_length长。另请参阅rpad()。
String lstrip(chars: String) const 🔗
从字符串的开头删除chars中定义的一组字符。另请参阅rstrip()。
注意：chars不是前缀。使用trim_prefix()删除单个前缀，而不是一组字符。
bool match(expr: String) const 🔗
*匹配零个或多个任意字符并且？[ /code]匹配除句点（[code].）之外的任何单个字符。空字符串或空表达式的计算结果总是false。
bool matchn(expr: String) const 🔗
一个简单的不区分大小写的**表达式是否匹配，其中*匹配零个或多个任意字符，并且？[ /code]匹配除句点（[code].）之外的任何单个字符。空字符串或空表达式的计算结果总是false。
PackedByteArray md5_buffer() const 🔗
将字符串的MD5哈希作为PackedByteArray返回。
将字符串的MD5哈希作为另一个String返回。
int naturalcasecmp_to(to: String) const 🔗
与另一个字符串执行区分大小写的，自然顺序比较。如果小于，则返回-1，如果大于，则返回1，如果相等，则返回0。“小于”或“大于”由每个字符串的Unicode代码点确定，大致符合字母顺序。
当用于排序时，自然顺序比较按通常预期的每个数字的组合值对数字序列进行排序，而不是单个数字的值。排序后的字符串序列将是["1","2","3",…]，而不是["1","10","2","3",…]。
使用不同的字符串长度，如果该字符串比字符串的to长，则返回1，如果短，则返回-1。请注意，空字符串的长度始终为0。
要从字符串比较中获得bool结果，请改用==运算符。另请参见naturalnocasecmp_to()、filecasecmp_to()和nocasecmp_to()。
int naturalnocasecmp_to(to: String) const 🔗
与另一个字符串执行不区分大小写的，自然顺序比较。如果小于，则返回-1，如果大于，则返回1，如果相等，则返回0。“小于”或“大于”由每个字符串的Unicode代码点确定，大致匹配字母顺序。内部，小写字符转换为大写进行比较。
当用于排序时，自然顺序比较按通常预期的每个数字的组合值对数字序列进行排序，而不是单个数字的值。排序后的字符串序列将是["1","2","3",…]，而不是["1","10","2","3",…]。
使用不同的字符串长度，如果该字符串比字符串的to长，则返回1，如果短，则返回-1。请注意，空字符串的长度始终为0。
要从字符串比较中获得bool结果，请改用==运算符。另请参见naturalcasecmp_to()、filenocasecmp_to()和casecmp_to()。
int nocasecmp_to(to: String) const 🔗
对另一个字符串执行不区分大小写的比较。如果小于则返回-1，如果大于则返回1，如果等于则返回0。“小于”或“大于”由每个字符串的Unicode代码点确定，大致匹配字母顺序。内部，小写字符转换为大写进行比较。
使用不同的字符串长度，如果该字符串比字符串的to长，则返回1，如果短，则返回-1。请注意，空字符串的长度始终为0。
要从字符串比较中获得bool结果，请改用==运算符。另请参见casecmp_to()、filenocasecmp_to()和naturalnocasecmp_to()。
String num(number: float, decimals: int = -1) static 🔗
将一个float转换为十进制数的字符串表示形式，小数位数由decimals指定。
如果decimals默认设置为-1，则字符串表示形式最多可有14位有效数字，小数点前的数字优先于小数点后的数字。
字符串中不包含尾随零。最后一位数字是四舍五入，而非截断。
String.num(3.141593) # 返回 "3.141593"
String.num(3.141593, 3) # 返回 "3.142"
String.num(3.14159300) # 返回 "3.141593"
# 此处，最后一位数字会向上取整，
# 由于末尾的零会被移除，因此总位数会减少：
String.num(42.129999, 5) # 返回 "42.13"
# 若未指定 decimals 参数，则有效数字的最大位数为 14 位:
String.num(-0.0000012345432123454321) # 返回 "-0.00000123454321"
String.num(-10000.0000012345432123454321) # 返回 "-10000.0000012345"
String num_int64(number: int, base: int = 10, capitalize_hex: bool = false) static 🔗
使用给定的base将给定的number转换为字符串表示形式。
默认情况下，base设置为十进制（10）。编程中的其他常见基础包括二进制（2）、八进制（8）、十六进制（16）。
如果capitalize_hex为true，则大于9的数字以大写表示。
String num_scientific(number: float) static 🔗
将给定的 number 转换为科学记数法的字符串表示形式。
var n = -5.2e8
print(n) # 输入 -520000000
print(String.num_scientific(n)) # 输入 -5.2e+08
// This method is not implemented in C#.
// Use `string.ToString()` with "e" to achieve similar results.
var n = -5.2e8f;
S3.Print(n); // 输入 -520000000
S3.Print(n.ToString("e1")); // 输入 -5.2e+008
]
注意：在C#中，这一方法没有实现。若要获得类似的结果，请参阅C#的标准数字格式字符串
String num_uint64(number: int, base: int = 10, capitalize_hex: bool = false) static 🔗
使用给定的base将给定的unsignint转换为字符串表示形式。
默认情况下，base设置为十进制（10）。编程中的其他常见基础包括二进制（2）、八进制（8）、十六进制（16）。
如果capitalize_hex为true，则大于9的数字以大写表示。
String pad_decimals(digits: int) const 🔗
将表示数字的字符串格式化为在小数点之后具有digits的精确数量。
String pad_zeros(digits: int) const 🔗
将表示数字的字符串格式化为在小数点之前具有digits的精确数量。
String path_join(file: String) const 🔗
将字符串末尾的file连接为子路径，必要时添加/。
示例： "this/is".path_join("path") == "this/is/path"。
String repeat(count: int) const 🔗
多次重复此字符串。count需要大于0。否则，返回一个空字符串。
String replace(what: String, forwhat: String) const 🔗
用给定的forwhat替换字符串中所有出现的what。
String replacen(what: String, forwhat: String) const 🔗
用给定的forwhat替换字符串中所有不区分大小写的**出现的what。
以相反的顺序返回此字符串的副本。此操作适用于unicode代码点，而不是代码点序列，并且可能会破坏复合字母或表情符号等内容。
int rfind(what: String, from: int = -1) const 🔗
返回此字符串中what的最后出现的索引，如果没有，则返回-1。可以使用from指定搜索的开始，继续到字符串的开头。此方法与find()相反。
int rfindn(what: String, from: int = -1) const 🔗
返回此字符串中what的最后不区分大小写出现的索引，如果没有，则返回-1。可以使用from指定起始搜索索引，继续到字符串的开头。此方法与findn()相反。
String right(length: int) const 🔗
从字符串末尾返回最后 length 个字符。如果 length 为负数，则从字符串开头删除前 length 个字符。
print("Hello World!".right(3)) # 输入 "ld!"
print("Hello World!".right(-4)) # 输入 "o World!"
String rpad(min_length: int, character: String = " ") const 🔗
如有必要，通过在字符串右侧添加character将字符串格式化为至少min_length长。另请参阅lpad()。
PackedStringArray rsplit(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const 🔗
使用 delimiter 拆分字符串，并从字符串末尾开始返回子字符串数组。返回数组中的拆分顺序与原始字符串中的顺序相同。如果 delimiter 为空字符串，则每个子字符串将是单个字符。
如果 allow_empty 为 false，则相邻分隔符之间的空字符串将从数组中排除。
如果 maxsplit 大于 0，拆分的数量不得超过 maxsplit。默认情况下，整个字符串都会被拆分，这与 split() 基本相同。
var some_string = "One,Two,Three,Four"
var some_array = some_string.rsplit(",", true, 1)
print(some_array.size()) # 输入 2
print(some_array[0]) # 输入 "One,Two,Three"
print(some_array[1]) # 输入 "Four"
// 在 C# 中，不存在 String.RSplit() 方法.
String rstrip(chars: String) const 🔗
从字符串末尾删除chars中定义的一组字符。另请参见lstrip()。
注意：chars不是后缀。使用trim_suffix()删除单个后缀，而不是一组字符。
PackedByteArray sha1_buffer() const 🔗
将字符串的SHA-1哈希作为PackedByteArray返回。
将字符串的SHA-1哈希作为另一个String返回。
PackedByteArray sha256_buffer() const 🔗
将字符串的SHA-256哈希作为PackedByteArray返回。
将字符串的SHA-256哈希作为另一个String返回。
float similarity(text: String) const 🔗
返回此字符串与另一个字符串的相似度指数（索伦森 - 戴斯系数）。结果为1.0表示完全相似，而0.0表示完全不相似。
print("ABC123".similarity("ABC123")) # 输入 1.0
print("ABC123".similarity("XYZ456")) # 输入 0.0
print("ABC123".similarity("123ABC")) # 输入 0.8
print("ABC123".similarity("abc123")) # 输入 0.4
String simplify_path() const 🔗
如果该字符串是一个有效的文件路径，就将该字符串转换为规范路径。规范路径是尽可能最短的路径，不包含 "./" ，并且去除所有不必要的 ".." 和 "/" 。
var simple_path = "./path/to///../file".simplify_path()
print(simple_path) # 输入 "path/file"
PackedStringArray split(delimiter: String = "", allow_empty: bool = true, maxsplit: int = 0) const 🔗
使用 delimiter 拆分字符串，并返回子字符串数组。如果 delimiter 为空字符串，则每个子字符串将是单个字符。此方法与 join() 相反。
如果 allow_empty 为 false，则相邻分隔符之间的空字符串将从数组中排除。
如果 maxsplit 大于 0，则拆分的数量不得超过 maxsplit。默认情况下，将拆分整个字符串。
var some_array = "One,Two,Three,Four".split(",", true, 2)
print(some_array.size()) # 输入 3
print(some_array[0]) # 输入 "One"
print(some_array[1]) # 输入 "Two"
print(some_array[2]) # 输入 "Three,Four"
// C#'s `Split()` does not support the `maxsplit` parameter.
var someArray = "One,Two,Three".Split(",");
S3.Print(someArray[0]); // 输入 "One"
S3.Print(someArray[1]); // 输入 "Two"
S3.Print(someArray[2]); // 输入 "Three"
注意：如果你只需要数组中的一个子字符串，可以考虑使用get_slice()，它的速度更快。如果你需要使用更复杂的规则拆分字符串，请改用RegEx类
PackedFloat64Array split_floats(delimiter: String, allow_empty: bool = true) const 🔗
通过使用 delimiter 将字符串拆分为浮点数，并返回一个 PackedFloat64Array。
如果 allow_empty 为 false，则相邻分隔符之间的空或无效 float 转换将被排除。
var a = "1,2,4.5".split_floats(",") # a is [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c is [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b is [1.0, 4.5]
String strip_edges(left: bool = true, right: bool = true) const 🔗
从字符串的开头和结尾去除所有不可打印的字符。这些字符包括空格、制表符（\t）和换行符（\n \r）。
如果left为false，则忽略字符串的开头。同样，如果right为false，则忽略字符串的结尾
String strip_escapes() const 🔗
从字符串中去除所有转义字符。这些转义字符包括ASCII表第一页中的所有不可打印控制字符（值从0到31），例如制表符（\t）和换行符（\n、\r），但不包括空格。
String substr(from: int, len: int = -1) const 🔗
从带有长度len的位置from返回部分字符串。如果len是-1（默认情况下），则返回从给定位置开始的字符串的其余部分。
PackedByteArray to_ascii_buffer() const 🔗
将字符串转换为ASCII/Latin-1编码的PackedByteArray。此方法比to_utf8_buffer()稍快，但将所有不支持的字符替换为空格。这与PackedByteArray.get_string_from_ascii()相反。
String to_camel_case() const 🔗
返回转换为camelCase的字符串。
将表示十进制数的字符串转换为float。此方法在遇到第一个非数字字符时停止，第一个小数点（.）和指数字母（e）除外。另请参阅is_valid_float()。
var a = "12.35".to_float() # a is 12.35
var b = "1.2.3".to_float() # b is 1.2
var c = "12xy3".to_float() # c is 12.0
var d = "1e3".to_float() # d is 1000.0
var e = "Hello!".to_float() # e is 0.0
将表示整数的字符串转换为int。此方法会移除任何非数字字符，并在遇到第一个小数点（.）时停止。另请参阅is_valid_int()。
var a = "123".to_int() # a is 123
var b = "x1y2z3".to_int() # b is 123
var c = "-1.2.3".to_int() # c is -1
var d = "Hello!".to_int() # d is 0
返回转换为小写的字符串。
String to_pascal_case() const 🔗
返回转换为PascalCase的字符串。
String to_snake_case() const 🔗
返回转换为蛇形命名法的字符串。
注意： 为了使某些单词（如“2D”）保持不变，单个字母紧跟数字的情况在转换时不进行分隔。
"Node2D".to_snake_case() # 返回 "node_2d"
"2nd place".to_snake_case() # 返回 "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # 返回 "texture_3d_asset_folder"
"Node2D".ToSnakeCase(); // 返回 "node_2d"
"2nd place".ToSnakeCase(); // 返回 "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // 返回 "texture_3d_asset_folder"
返回转换为大写的字符串。
PackedByteArray to_utf8_buffer() const 🔗
将字符串转换为UTF-8编码的PackedByteArray。此方法比to_ascii_buffer()稍慢，但支持所有UTF-8字符。在大多数情况下，更喜欢使用此方法。这与PackedByteArray.get_string_from_utf8()相反。
PackedByteArray to_utf16_buffer() const 🔗
将字符串转换为UTF-16编码的PackedByteArray。这与PackedByteArray.get_string_from_utf16()相反。
PackedByteArray to_utf32_buffer() const 🔗
将字符串转换为UTF-32编码的PackedByteArray。这与PackedByteArray.get_string_from_utf32()相反。
PackedByteArray to_wchar_buffer() const 🔗
将字符串转换为宽字符（wchar_t， Windows上的UTF-16，其他平台上的UTF-32）编码的PackedByteArray。这是PackedByteArray.get_string_from_wchar()的逆。
String trim_prefix(prefix: String) const 🔗
从字符串的开头删除给定的prefix，或返回未更改的字符串。
String trim_suffix(suffix: String) const 🔗
从字符串末尾删除给定的suffix，或返回未更改的字符串。
int unicode_at(at: int) const 🔗
返回位置at处的字符代码。
将字符串从其URL编码格式中解码。此方法旨在在接收HTTP请求时正确解码URL中的参数。另请参阅uri_encode()。
var url = "$DOCS_URL/?highlight=i3D%20Engine%3%docs"
print(url.uri_decode()) # 输入 "$DOCS_URL/?highlight=i3D Engine:docs"
var url = "$DOCS_URL/?highlight=i3D%20Engine%3%docs"
S3.Print(url.URIDecode()) // 输入 "$DOCS_URL/?highlight=i3D Engine:docs"
将字符串编码为适合URL的格式。此方法旨在在发送HTTP请求时正确编码URL中的参数。另请参阅uri_decode()。
var prefix = "$DOCS_URL/?highlight="
var url = prefix + "i3D Engine:docs".uri_encode()
print(url) # 输入 "$DOCS_URL/?highlight=i3D%20Engine%3%docs"
var prefix = "$DOCS_URL/?highlight=";
var url = prefix + "i3D Engine:docs".URIEncode();
S3.Print(url); // 输入 "$DOCS_URL/?highlight=i3D%20Engine%3%docs"
String validate_filename() const 🔗
返回字符串的副本，其中is_valid_filename()中不允许的所有字符都替换为下划线。
String validate_node_name() const 🔗
返回字符串的副本，其中Item.name（.：@/"%）中不允许的所有字符都被下划线替换。
String xml_escape(escape_quotes: bool = false) const 🔗
返回带有使用XML标准转义的特殊字符的字符串副本。如果escape_quotes为true，则单引号（'）和双引号（"）字符也会被转义。
返回字符串的副本，其中转义字符根据XML标准替换为其含义。
运算符说明¶
bool operator !=(right: String) 🔗
如果两个字符串不包含相同的字符序列，则返回true。
bool operator !=(right: StringName) 🔗
如果此String不等效于给定的StringName，则返回true。
String operator %(right: Variant) 🔗
格式化 String，用一个或多个参数替换占位符。要传递多个参数，right 必须是一个 Array。
print("I caught %d fishes!" % 2) # 输入 "I caught 2 fishes!"
var my_message = "Travelling to %s, at %2.2f km/h."
var location = "Deep Valley"
var speed = 40.3485
print(my_message % [location, speed]) # 输入 "Travelling to Deep Valley, at 40.35 km/h."
注意：在 C# 中，此运算符不可用。
String operator +(right: String) 🔗
将right附加在此String的末尾，也称为字符串连接。
String operator +(right: StringName) 🔗
在此String的末尾附加right，返回String。这也称为字符串连接。
bool operator <(right: String) 🔗
如果Unicode order中的左String位于right之前，则返回true，大致匹配字母顺序。用于排序。
bool operator <=(right: String) 🔗
如果Unicode order中的左String在right之前，大致匹配字母顺序，或者两者相等，则返回true。
bool operator ==(right: String) 🔗
如果两个字符串包含相同的字符序列，则返回true。
bool operator ==(right: StringName) 🔗
如果此String等效于给定的StringName，则返回true。
bool operator >(right: String) 🔗
返回true，如果Unicode order中的right后面的String与字母顺序大致匹配。用于排序。
bool operator >=(right: String) 🔗
返回true，如果Unicode order中的right之后的左String与字母顺序大致匹配，或者两者相等。
String operator [](index: int) 🔗
返回仅包含index处的字符的新String。索引从0开始。如果index大于或等于0，则从字符串的开头开始获取字符。如果index是负值，则从结尾开始获取。越界访问字符串将导致运行时错误，如果从编辑器运行，则暂停项目执行。