godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/zh_Hans/class_stringname.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

2317 lines
133 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_StringName:
StringName
==========
唯一字符串内置类型。
.. rst-class:: classref-introduction-group
描述
----
**StringName** 是不可变的字符串，用于唯一名称的通用表示（也叫“字符串内嵌”）。值相同的两个 **StringName** 是同一个对象。进行比较时比普通 :ref:`String<class_String>` 要快很多。
需要 **StringName** 的方法通常可以传 :ref:`String<class_String>`\ ，会自动进行转换（经常发生在编译时），不过有时候你可能会想要提前使用 **StringName** 构造函数来构造 **StringName**\ ，在 GDScript 中也可以用字面量语法 ``&"example"``\ 。你可以通过手动构造 **StringName** 来控制 :ref:`String<class_String>` 的转换时机，使用字面量则可以完全消除掉转换过程。
另见 :ref:`NodePath<class_NodePath>`\ ，这是与此类似的概念，针对存储预解析的场景树路径设计。
\ :ref:`String<class_String>` 的所有方法都在这个类中可用。它们会将 **StringName** 转换为字符串，返回的也是字符串。这样做效率非常低，应该只在需要字符串时使用。
\ **注意：**\ 在 C# 中，需要显式转换为 ``System.String`` 才能使用本页列出的方法。使用 ``ToString()`` 方法将 **StringName** 转换为字符串，然后使用 ``System.String`` 或 ``StringExtensions`` 中的等效方法。
\ **注意：**\ 转换为布尔值时，空的 **StringName**\ （\ ``StringName("")``\ ）为 ``false``\ ，其他 **StringName** 均为 ``true``\ 。
.. note::
通过 C# 使用该 API 时会有显著不同，详见 :ref:`doc_c_sharp_differences`\ 。
.. rst-class:: classref-reftable-group
构造函数
--------
.. table::
:widths: auto
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`String<class_String>`\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
方法
----
.. table::
:widths: auto
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`begins_with<class_StringName_method_begins_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`bigrams<class_StringName_method_bigrams>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bin_to_int<class_StringName_method_bin_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_escape<class_StringName_method_c_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_unescape<class_StringName_method_c_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`capitalize<class_StringName_method_capitalize>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`casecmp_to<class_StringName_method_casecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`contains<class_StringName_method_contains>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`containsn<class_StringName_method_containsn>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_StringName_method_count>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`countn<class_StringName_method_countn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`dedent<class_StringName_method_dedent>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`ends_with<class_StringName_method_ends_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`erase<class_StringName_method_erase>`\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filecasecmp_to<class_StringName_method_filecasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filenocasecmp_to<class_StringName_method_filenocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_StringName_method_find>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`findn<class_StringName_method_findn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`format<class_StringName_method_format>`\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_base_dir<class_StringName_method_get_base_dir>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_basename<class_StringName_method_get_basename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_extension<class_StringName_method_get_extension>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_file<class_StringName_method_get_file>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slice<class_StringName_method_get_slice>`\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_slice_count<class_StringName_method_get_slice_count>`\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slicec<class_StringName_method_get_slicec>`\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hash<class_StringName_method_hash>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`hex_decode<class_StringName_method_hex_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hex_to_int<class_StringName_method_hex_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`indent<class_StringName_method_indent>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`insert<class_StringName_method_insert>`\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_absolute_path<class_StringName_method_is_absolute_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_StringName_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_relative_path<class_StringName_method_is_relative_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_of<class_StringName_method_is_subsequence_of>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_ofn<class_StringName_method_is_subsequence_ofn>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ascii_identifier<class_StringName_method_is_valid_ascii_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_filename<class_StringName_method_is_valid_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_float<class_StringName_method_is_valid_float>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_hex_number<class_StringName_method_is_valid_hex_number>`\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_html_color<class_StringName_method_is_valid_html_color>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_identifier<class_StringName_method_is_valid_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_int<class_StringName_method_is_valid_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ip_address<class_StringName_method_is_valid_ip_address>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_unicode_identifier<class_StringName_method_is_valid_unicode_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`join<class_StringName_method_join>`\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`json_escape<class_StringName_method_json_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`left<class_StringName_method_left>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`length<class_StringName_method_length>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lpad<class_StringName_method_lpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lstrip<class_StringName_method_lstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`match<class_StringName_method_match>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`matchn<class_StringName_method_matchn>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`md5_buffer<class_StringName_method_md5_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`md5_text<class_StringName_method_md5_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalcasecmp_to<class_StringName_method_naturalcasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalnocasecmp_to<class_StringName_method_naturalnocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`nocasecmp_to<class_StringName_method_nocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_decimals<class_StringName_method_pad_decimals>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_zeros<class_StringName_method_pad_zeros>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`path_join<class_StringName_method_path_join>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_char<class_StringName_method_remove_char>`\ (\ what\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_chars<class_StringName_method_remove_chars>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`repeat<class_StringName_method_repeat>`\ (\ count\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace<class_StringName_method_replace>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_char<class_StringName_method_replace_char>`\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_chars<class_StringName_method_replace_chars>`\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replacen<class_StringName_method_replacen>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`reverse<class_StringName_method_reverse>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_StringName_method_rfind>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfindn<class_StringName_method_rfindn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`right<class_StringName_method_right>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`rpad<class_StringName_method_rpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`rsplit<class_StringName_method_rsplit>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`rstrip<class_StringName_method_rstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha1_buffer<class_StringName_method_sha1_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha1_text<class_StringName_method_sha1_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha256_buffer<class_StringName_method_sha256_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha256_text<class_StringName_method_sha256_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`similarity<class_StringName_method_similarity>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`simplify_path<class_StringName_method_simplify_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`split<class_StringName_method_split>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedFloat64Array<class_PackedFloat64Array>` | :ref:`split_floats<class_StringName_method_split_floats>`\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_edges<class_StringName_method_strip_edges>`\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_escapes<class_StringName_method_strip_escapes>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`substr<class_StringName_method_substr>`\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_ascii_buffer<class_StringName_method_to_ascii_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_camel_case<class_StringName_method_to_camel_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`to_float<class_StringName_method_to_float>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_int<class_StringName_method_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_kebab_case<class_StringName_method_to_kebab_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_lower<class_StringName_method_to_lower>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_multibyte_char_buffer<class_StringName_method_to_multibyte_char_buffer>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_pascal_case<class_StringName_method_to_pascal_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_snake_case<class_StringName_method_to_snake_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_upper<class_StringName_method_to_upper>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf8_buffer<class_StringName_method_to_utf8_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf16_buffer<class_StringName_method_to_utf16_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf32_buffer<class_StringName_method_to_utf32_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_wchar_buffer<class_StringName_method_to_wchar_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_prefix<class_StringName_method_trim_prefix>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_suffix<class_StringName_method_trim_suffix>`\ (\ suffix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`unicode_at<class_StringName_method_unicode_at>`\ (\ at\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_decode<class_StringName_method_uri_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_encode<class_StringName_method_uri_encode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_file_decode<class_StringName_method_uri_file_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_filename<class_StringName_method_validate_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_node_name<class_StringName_method_validate_node_name>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_escape<class_StringName_method_xml_escape>`\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_unescape<class_StringName_method_xml_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
运算符
------
.. table::
:widths: auto
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator %<class_StringName_operator_mod_Variant>`\ (\ right\: :ref:`Variant<class_Variant>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_StringName_operator_lt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_StringName_operator_lte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_StringName_operator_gt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_StringName_operator_gte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
构造函数说明
------------
.. _class_StringName_constructor_StringName:
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ ) :ref:`🔗<class_StringName_constructor_StringName>`
构造空的 **StringName**\ 。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`StringName<class_StringName>`\ )
构造给定 **StringName** 的副本。
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`String<class_String>`\ )
从给定的 :ref:`String<class_String>` 创建 **StringName**\ 。在 GDScript 中，\ ``StringName("example")`` 与 ``&"example"`` 等价。
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
方法说明
--------
.. _class_StringName_method_begins_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **begins_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_begins_with>`
如果该字符串以给定的 ``text`` 开始，则返回 ``true``\ 。另见 :ref:`ends_with()<class_StringName_method_ends_with>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_bigrams:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **bigrams**\ (\ ) |const| :ref:`🔗<class_StringName_method_bigrams>`
返回包含该字符串的双字母组（连续字母的组合）的数组。
::
print("Get up!".bigrams()) # 输出 ["Ge", "et", "t ", " u", "up", "p!"]
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_bin_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_bin_to_int>`
将表示二进制数的字符串转换为 :ref:`int<class_int>`\ 。该字符串可以前缀 ``"0b"``\ ，负数可以前缀 ``-``\ 。
.. tabs::
.. code-tab:: gdscript
print("101".bin_to_int()) # 输出 5
print("0b101".bin_to_int()) # 输出 5
print("-0b10".bin_to_int()) # 输出 -2
.. code-tab:: csharp
GD.Print("101".BinToInt()); // 输出 5
GD.Print("0b101".BinToInt()); // 输出 5
GD.Print("-0b10".BinToInt()); // 输出 -2
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_c_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_escape>`
返回该字符串的副本，按照 C 语言标准对特殊字符进行转义。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_c_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_unescape>`
返回该字符串的副本，转义字符均使用本义代替。支持的转义序列有 ``\'``\ 、\ ``\"``\ 、\ ``\\``\ 、\ ``\a``\ 、\ ``\b``\ 、\ ``\f``\ 、\ ``\n``\ 、\ ``\r``\ 、\ ``\t``\ 、\ ``\v``\ 。
\ **注意：**\ 与 GDScript 解析器不同，这个方法不支持 ``\uXXXX`` 转义序列。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_capitalize:
.. rst-class:: classref-method
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_StringName_method_capitalize>`
改变字符串的外观：用空格代替下划线（\ ``_``\ ），在单词中间的大写字母前添加空格，将所有字母转换为小写，然后将第一个字母和空格后的每个字母转换为大写。
.. tabs::
.. code-tab:: gdscript
"move_local_x".capitalize() # 返回 "Move Local X"
"sceneFile_path".capitalize() # 返回 "Scene File Path"
"2D, FPS, PNG".capitalize() # 返回 "2d, Fps, Png"
.. code-tab:: csharp
"move_local_x".Capitalize(); // 返回 "Move Local X"
"sceneFile_path".Capitalize(); // 返回 "Scene File Path"
"2D, FPS, PNG".Capitalize(); // 返回 "2d, Fps, Png"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_casecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_casecmp_to>`
与另一个字符串进行比较，区分大小写。小于时返回 ``-1``\ 、大于时返回 ``1``\ 、等于时返回 ``0``\ 。“小于”和“大于”比较的是字符串中的 `Unicode 码位 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ ，大致与字母表顺序一致。
如果字符串长度不同，这个字符串比 ``to`` 字符串长时返回 ``1``\ ，短时返回 ``-1``\ 。请注意空字符串的长度\ *始终*\ 为 ``0``\ 。
要从字符串比较中获得 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`\ 、\ :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` 和 :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_contains:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_contains>`
如果该字符串包含 ``what``\ ，则返回 ``true``\ 。在 GDScript 中对应 ``in`` 运算符。
.. tabs::
.. code-tab:: gdscript
print("Node".contains("de")) # 输出 true
print("team".contains("I")) # 输出 false
print("I" in "team") # 输出 false
.. code-tab:: csharp
GD.Print("Node".Contains("de")); // 输出 True
GD.Print("team".Contains("I")); // 输出 False
如果想要知道 ``what`` 在该字符串中的位置，请使用 :ref:`find()<class_StringName_method_find>`\ 。另见 :ref:`containsn()<class_StringName_method_containsn>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_containsn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_containsn>`
如果\ **忽略大小写**\ ，字符串包含 ``what``\ ，则返回 ``true``\ 。
如果你需要知道 ``what`` 在字符串中的位置，请使用 :ref:`findn()<class_StringName_method_findn>`\ 。另见 :ref:`contains()<class_StringName_method_contains>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **count**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_count>`
返回子串 ``what`` 在 ``from`` 和 ``to`` 位置之间出现的次数。如果 ``to`` 为 0，会在剩余字符串中继续搜索。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_countn:
.. rst-class:: classref-method
:ref:`int<class_int>` **countn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_countn>`
返回子串 ``what`` 在 ``from`` 和 ``to`` 位置之间出现的次数，\ **忽略大小写**\ 。如果 ``to`` 为 0，会在剩余字符串中继续搜索。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_StringName_method_dedent>`
返回删除了缩进（前导制表符和空格）的字符串副本。添加缩进请参阅 :ref:`indent()<class_StringName_method_indent>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_ends_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_ends_with>`
如果该字符串以给定的 ``text`` 结束，则返回 ``true``\ 。另见 :ref:`begins_with()<class_StringName_method_begins_with>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_erase:
.. rst-class:: classref-method
:ref:`String<class_String>` **erase**\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| :ref:`🔗<class_StringName_method_erase>`
返回从 ``position`` 开始擦除 ``chars`` 个字符后的字符串。如果在指定 ``position`` 的基础上 ``chars`` 超过字符串的长度，返回的字符串中擦除的字符数会少于请求的数量。如果 ``position`` 或 ``chars`` 为负数，则返回空字符串。如果 ``chars`` 为 ``0`` 则返回原字符串，不进行修改。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_filecasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filecasecmp_to>`
与 :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>` 类似，但优先考虑以句点（\ ``.``\ ）和下划线（\ ``_``\ ）开头的字符串，然后再考虑其他字符。在对文件夹或文件名进行排序时很有用。
要从字符串比较中获取 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`\ 、\ :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>` 和 :ref:`casecmp_to()<class_StringName_method_casecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_filenocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filenocasecmp_to>`
与 :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>` 类似，但优先考虑以句点（\ ``.``\ ）和下划线（\ ``_``\ ）开头的字符串，然后再考虑其他字符。在对文件夹或文件名进行排序时很有用。
要从字符串比较中获取 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`\ 、\ :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>` 和 :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_find:
.. rst-class:: classref-method
:ref:`int<class_int>` **find**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_find>`
Returns the index of the **first** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the string.
.. tabs::
.. code-tab:: gdscript
print("Team".find("I")) # Prints -1
print("Potato".find("t")) # Prints 2
print("Potato".find("t", 3)) # Prints 4
print("Potato".find("t", 5)) # Prints -1
.. code-tab:: csharp
GD.Print("Team".Find("I")); // Prints -1
GD.Print("Potato".Find("t")); // Prints 2
GD.Print("Potato".Find("t", 3)); // Prints 4
GD.Print("Potato".Find("t", 5)); // Prints -1
\ **Note:** If you just want to know whether the string contains ``what``, use :ref:`contains()<class_StringName_method_contains>`. In GDScript, you may also use the ``in`` operator.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_findn:
.. rst-class:: classref-method
:ref:`int<class_int>` **findn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_findn>`
返回这个字符串中 ``what`` **首次**\ 出现的索引，\ **不区分大小写**\ ，不存在时则为 ``-1``\ 。搜索的起点可以用 ``from`` 指定，终点为该字符串的末尾。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_format:
.. rst-class:: classref-method
:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_StringName_method_format>`
对字符串进行格式化，会将其中出现的所有 ``placeholder`` 都替换为 ``values`` 中的元素。
\ ``values`` 可以是 :ref:`Dictionary<class_Dictionary>`\ 、\ :ref:`Array<class_Array>` 或 :ref:`Object<class_Object>`\ 。\ ``placeholder`` 中的下划线都会事先替换为对应的键。数组元素使用对应的索引作为键。
::
# 输出“Waiting for Godot 是 Samuel Beckett 的戏剧，Godot 引擎由此得名。”
var use_array_values = "Waiting for {0} 是 {1} 的戏剧，{0} 引擎由此得名。"
print(use_array_values.format(["Godot", "Samuel Beckett"]))
# 输出“第 42 号用户是 Godot。”
print("第 {id} 号用户是 {name}。".format({"id": 42, "name": "Godot"}))
当 ``values`` 为 :ref:`Array<class_Array>` 时还会执行一些额外的处理。如果 ``placeholder`` 不包含下划线，则 ``values`` 数组的元素将用于按顺序替换出现的占位符；如果 ``values`` 的元素也是包含两个元素的数组，则会被解释为键值对。
::
# 输出“第 42 号用户是 Godot。”
print("第 {} 号用户是 {}。".format([42, "Godot"], "{}"))
print("第 {id} 号用户是 {name}。".format([["id", 42], ["name", "Godot"]]))
传入 :ref:`Object<class_Object>` 时，会将 :ref:`Object.get_property_list()<class_Object_method_get_property_list>` 中的属性名称用作键。
::
# 输出“可见 true，位置 (0, 0)”
var node = Node2D.new()
print("可见 {visible}，位置 {position}".format(node))
另见 :doc:`GDScript 格式化字符串 <../tutorials/scripting/gdscript/gdscript_format_string>`\ 教程。
\ **注意：**\ 占位符的替换是依次进行的，\ **并非**\ 同时完成。因此插入的元素中如果包含其他占位符，就可能在下一次替换时发生改变。这是一把双刃剑，常会导致预料之外的结果。除非必要，请确保 ``values`` 的元素中不包含占位符。
::
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# 中推荐改为\ `使用“$”插入字符串 <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_base_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_base_dir>`
如果该字符串是有效的文件路径，则返回基础目录名称。
::
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path 为 "/path/to"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_basename>`
如果该字符串是有效的文件路径，则返回完整文件路径，不包括扩展名。
::
var base = "/path/to/file.txt".get_basename() # base 为 "/path/to/file"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_extension:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_extension>`
如果该字符串是有效的文件名或路径，则返回该文件的扩展名，不含开头的点号（\ ``.``\ ）。否则返回空字符串。
::
var a = "/path/to/file.txt".get_extension() # a 为 "txt"
var b = "cool.txt".get_extension() # b 为 "txt"
var c = "cool.font.tres".get_extension() # c 为 "tres"
var d = ".pack1".get_extension() # d 为 "pack1"
var e = "file.txt.".get_extension() # e 为 ""
var f = "file.txt..".get_extension() # f 为 ""
var g = "txt".get_extension() # g 为 ""
var h = "".get_extension() # h 为 ""
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_file:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_file>`
如果该字符串是有效的文件路径，则返回文件名，包括扩展名。
::
var file = "/path/to/icon.png".get_file() # file 为 "icon.png"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slice:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slice**\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice>`
使用分隔符 ``delimiter`` 拆分该字符串，返回索引为 ``slice`` 的子串。如果字符串中不存在 ``delimiter`` 则返回原字符串。如果 ``slice`` 不存在则返回空字符串。
只需要一个子串时这个方法比 :ref:`split()<class_StringName_method_split>` 快。
::
print("i/am/example/hi".get_slice("/", 2)) # 输出“example”
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slice_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice_count>`
返回使用给定的分隔符 ``delimiter`` 拆分该字符串后切片的总数（见 :ref:`split()<class_StringName_method_split>`\ ）。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slicec:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slicec**\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slicec>`
使用 Unicode 字符码分隔符 ``delimiter`` 拆分该字符串，返回索引为 ``slice`` 的子串。如果 ``slice`` 不存在则返回空字符串。
只需要一个子串时这个方法比 :ref:`split()<class_StringName_method_split>` 快。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_StringName_method_hash>`
返回代表该字符串内容的 32 位哈希值。
\ **注意：**\ 由于哈希碰撞的缘故，哈希相同的字符串\ *不一定*\ 相同。而相对的是，哈希不同的字符串一定不同。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hex_decode:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_decode>`
将十六进制字符串解码为 :ref:`PackedByteArray<class_PackedByteArray>`\ 。
.. tabs::
.. code-tab:: gdscript
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # 输出 "68656c6c6f20776f726c64"
print(encoded.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // 输出 "68656c6c6f20776f726c64"
GD.Print(encoded.HexDecode().GetStringFromUtf8());
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hex_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_to_int>`
将表示十六进制数的字符串转换为 :ref:`int<class_int>`\ 。该字符串可以前缀 ``"0x"``\ ，负数可以前缀 ``-``\ 。
.. tabs::
.. code-tab:: gdscript
print("0xff".hex_to_int()) # 输出 255
print("ab".hex_to_int()) # 输出 171
.. code-tab:: csharp
GD.Print("0xff".HexToInt()); // 输出 255
GD.Print("ab".HexToInt()); // 输出 171
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_indent:
.. rst-class:: classref-method
:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_indent>`
使用前缀 ``prefix`` 将该字符串中的每一行进行缩进。空行不缩进。移除缩进请参阅 :ref:`dedent()<class_StringName_method_dedent>`\ 。
例如，该字符串可以用 ``"\t\t"`` 缩进两个制表位，用 ``" "`` 缩进四个空格。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_insert:
.. rst-class:: classref-method
:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_insert>`
在该字符串中的 ``position`` 位置插入 ``what``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_absolute_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_absolute_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_absolute_path>`
如果该字符串为文件或目录的路径，并且显式指定了起点，则返回 ``true``\ 。这个方法与 :ref:`is_relative_path()<class_StringName_method_is_relative_path>` 相反。
包括以 ``"res://"``\ 、\ ``"user://"``\ 、\ ``"C:\"``\ 、\ ``"/"`` 等开头的路径。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_empty>`
如果该字符串的长度为 ``0``\ （\ ``""``\ ），则返回 ``true``\ 。另见 :ref:`length()<class_StringName_method_length>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_relative_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_relative_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_relative_path>`
如果该字符串为文件或目录的路径，并且起点依赖于上下文，则返回 ``true``\ 。路径可以是从当前目录开始，也可以是从当前 :ref:`Node<class_Node>` 开始（如果该字符串是从 :ref:`NodePath<class_NodePath>` 得到的），有时候也可以是使用了 ``"./"`` 前缀。这个方法与 :ref:`is_absolute_path()<class_StringName_method_is_absolute_path>` 相反。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_subsequence_of:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_of**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_is_subsequence_of>`
如果这个字符串中的所有字符都能在 ``text`` 中按照原始顺序找到，则返回 ``true``\ 。与 :ref:`contains()<class_StringName_method_contains>` 不同。
::
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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_subsequence_ofn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_is_subsequence_ofn>`
如果这个字符串中的所有字符都能在 ``text`` 中按照原始顺序找到，\ **忽略大小写**\ ，则返回 ``true``\ 。与 :ref:`containsn()<class_StringName_method_containsn>` 不同。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_ascii_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_ascii_identifier>`
如果该字符串为有效的 ASCII 标识符，则返回 ``true``\ 。有效的 ASCII 标识符仅可以包含字母、数字和下划线（\ ``_``\ ），第一个字符不能为数字。
::
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
另见 :ref:`is_valid_unicode_identifier()<class_StringName_method_is_valid_unicode_identifier>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_filename:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_filename>`
如果该字符串为有效的文件名，则返回 ``true``\ 。有效的文件名不能为空、头尾不能是空白字符、不包含不允许的字符（\ ``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``\ ）。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_float:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_float>`
如果该字符串代表有效的浮点数，则返回 ``true``\ 。浮点数只能包含数字、一个小数点（\ ``.``\ ）以及指数字符（\ ``e``\ ）。还可以前缀正号（\ ``+``\ ）或负号（\ ``-``\ ）。有效的整数同时也是有效的浮点数（见 :ref:`is_valid_int()<class_StringName_method_is_valid_int>`\ ）。另见 :ref:`to_float()<class_StringName_method_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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_hex_number:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_hex_number**\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_is_valid_hex_number>`
如果该字符串代表有效的十六进制数，则返回 ``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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_html_color:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_html_color>`
如果该字符串是有效的十六进制 HTML 颜色标记，则返回 ``true``\ 。该字符串必须为 3 位、4 位、6 位或 8 位字符的十六进制值（见 :ref:`is_valid_hex_number()<class_StringName_method_is_valid_hex_number>`\ ），也可以带有井号前缀（\ ``#``\ ）。名称、\ ``hsl()`` 等其他 HTML 颜色标记法无效。另见 :ref:`Color.html()<class_Color_method_html>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_identifier>`
**已弃用：** Use :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>` instead.
如果该字符串为有效的标识符，则返回 ``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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_int:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_int>`
如果该字符串代表有效的整数，则返回 ``true``\ 。有效的整数仅可以包含数字，还可以前缀正号（\ ``+``\ ）或负号（\ ``-``\ ）。另见 :ref:`to_int()<class_StringName_method_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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_ip_address:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_ip_address>`
如果该字符串表示格式正确的 IPv4 或 IPv6 地址，则返回 ``true``\ 。这个方法认为 ``0.0.0.0``\ 、\ ``"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"`` 等\ `保留 IP 地址 <https://zh.wikipedia.org/wiki/%E4%BF%9D%E7%95%99IP%E5%9C%B0%E5%9D%80>`__\ 是有效的。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_unicode_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_unicode_identifier>`
如果该字符串是有效的 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
另见 :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>`\ 。
\ **注意：**\ 该方法检查标识符的规则与 GDScript 相同。使用更多高级规则见 :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_StringName_method_join>`
返回将 ``parts`` 中的元素连接组成的字符串，元素间使用调用该方法的字符串进行分隔。该方法和 :ref:`split()<class_StringName_method_split>` 相反。
.. tabs::
.. code-tab:: gdscript
var fruits = ["Apple", "Orange", "Pear", "Kiwi"]
print(", ".join(fruits)) # 输出 "Apple, Orange, Pear, Kiwi"
print("---".join(fruits)) # 输出 "Apple---Orange---Pear---Kiwi"
.. code-tab:: csharp
string[] fruits = ["Apple", "Orange", "Pear", "Kiwi"];
// 这个方法在 C# 中是静态的。
GD.Print(string.Join(", ", fruits)); // 输出 "Apple, Orange, Pear, Kiwi"
GD.Print(string.Join("---", fruits)); // 输出 "Apple---Orange---Pear---Kiwi"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_json_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_json_escape>`
返回该字符串的副本，使用 JSON 标准对特殊字符进行转义。因为与 C 标准非常类似，所以需要时可以用 :ref:`c_unescape()<class_StringName_method_c_unescape>` 取消转义。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_left:
.. rst-class:: classref-method
:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_left>`
返回该字符串开头的前 ``length`` 个字符。如果 ``length`` 为负，则会从该字符串的末尾剥离最后 ``length`` 个字符。
::
print("Hello World!".left(3)) # 输出 "Hel"
print("Hello World!".left(-4)) # 输出 "Hello Wo"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_StringName_method_length>`
返回该字符串中的字符数。空字符串（\ ``""``\ ）始终返回 ``0``\ 。另见 :ref:`is_empty()<class_StringName_method_is_empty>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_lpad:
.. rst-class:: classref-method
:ref:`String<class_String>` **lpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_lpad>`
必要时在该字符串的左侧添加若干 ``character`` 字符，使其长度至少为 ``min_length``\ 。另见 :ref:`rpad()<class_StringName_method_rpad>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_lstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **lstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_lstrip>`
从该字符串的开头移除 ``chars`` 中定义的字符。另见 :ref:`rstrip()<class_StringName_method_rstrip>`\ 。
\ **注意：**\ ``chars`` 不是前缀。如果要移除前缀而不是一组字符，请使用 :ref:`trim_prefix()<class_StringName_method_trim_prefix>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_match:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **match**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_match>`
进行简单的表达式匹配（也叫“通配”），\ ``*`` 匹配零个或多个任意字符，\ ``?`` 匹配除英文句号外的任意字符（\ ``.``\ ）。使用空字符串或空表达式时始终为 ``false``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_matchn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **matchn**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_matchn>`
进行简单的\ **大小写不敏感**\ 表达式匹配（也叫“通配”），\ ``*`` 匹配零个或多个任意字符，\ ``?`` 匹配除英文句号外的任意字符（\ ``.``\ ）。使用空字符串或空表达式时始终为 ``false``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_md5_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_md5_buffer>`
返回该字符串的 `MD5 哈希 <https://zh.wikipedia.org/wiki/MD5>`__\ ，类型为 :ref:`PackedByteArray<class_PackedByteArray>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_md5_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **md5_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_md5_text>`
返回该字符串的 `MD5 哈希 <https://zh.wikipedia.org/wiki/MD5>`__\ ，类型 :ref:`String<class_String>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalcasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalcasecmp_to>`
与另一个字符串进行\ **不区分大小写**\ 的\ *自然顺序*\ 比较。小于时返回 ``-1``\ 、大于时返回 ``1``\ 、等于时返回 ``0``\ 。“小于”和“大于”比较的是字符串中的 `Unicode 码位 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ ，大致与字母表顺序一致。内部实现时，会将小写字符转换为大写后进行比较。
使用自然顺序进行排序时，会和常见预期一样将连续的数字进行组合，而不是一个个数字进行比较。排序后的数列为 ``["1", "2", "3", ...]`` 而不是 ``["1", "10", "2", "3", ...]``\ 。
如果字符串长度不同，这个字符串比 ``to`` 字符串长时返回 ``1``\ ，短时返回 ``-1``\ 。请注意空字符串的长度\ *始终*\ 为 ``0``\ 。
要从字符串比较中获得 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`\ 、\ :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` 和 :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalnocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalnocasecmp_to>`
与另一个字符串进行\ **不区分大小写**\ 的\ *自然顺序*\ 比较。小于时返回 ``-1``\ 、大于时返回 ``1``\ 、等于时返回 ``0``\ 。“小于”和“大于”比较的是字符串中的 `Unicode 码位 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ ，大致与字母表顺序一致。内部实现时，会将小写字符转换为大写后进行比较。
使用自然顺序进行排序时，会和常见预期一样将连续的数字进行组合，而不是一个个数字进行比较。排序后的数列为 ``["1", "2", "3", ...]`` 而不是 ``["1", "10", "2", "3", ...]``\ 。
如果字符串长度不同，这个字符串比 ``to`` 字符串长时返回 ``1``\ ，短时返回 ``-1``\ 。请注意空字符串的长度\ *始终*\ 为 ``0``\ 。
要从字符串比较中获得 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`\ 、\ :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` 和 :ref:`casecmp_to()<class_StringName_method_casecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_nocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_nocasecmp_to>`
与另一个字符串进行\ **不区分大小写**\ 的比较。小于时返回 ``-1``\ 、大于时返回 ``1``\ 、等于时返回 ``0``\ 。“小于”和“大于”比较的是字符串中的 `Unicode 码位 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ ，大致与字母表顺序一致。内部实现时，会将小写字符转换为大写后进行比较。
如果字符串长度不同，这个字符串比 ``to`` 字符串长时返回 ``1``\ ，短时返回 ``-1``\ 。请注意空字符串的长度\ *始终*\ 为 ``0``\ 。
要从字符串比较中获得 :ref:`bool<class_bool>` 结果，请改用 ``==`` 运算符。另见 :ref:`casecmp_to()<class_StringName_method_casecmp_to>`\ 、\ :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` 和 :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_pad_decimals:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_decimals>`
格式化表示数字的字符串，使其小数点\ *后*\ 的位数为 ``digits``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_pad_zeros:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_zeros>`
格式化表示数字的字符串，使其小数点\ *前*\ 的位数为 ``digits``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_path_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_path_join>`
将 ``path`` 作为子路径连接到该字符串的末尾，必要时会添加 ``/``\ 。
\ **示例：**\ ``"this/is".path_join("path") == "this/is/path"``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_remove_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_remove_char>`
移除字符串中出现的所有码位为 ``what`` 的 Unicode 字符。相较于调用 :ref:`replace()<class_StringName_method_replace>` 时键为单字符串且替换为 ``""`` 要快。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_StringName_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_repeat>`
将该字符串重复若干次。次数 ``count`` 需要大于\ ``0`` 。否则返回空字符串。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replace>`
将该字符串中出现的所有 ``what`` 都替换为给定的 ``forwhat``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace_char**\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_char>`
将所有代码为 ``key`` 的 Unicode 字符都替换为代码为 ``with`` 的 Unicode 字符。这是 :ref:`replace()<class_StringName_method_replace>` 针对替换目标为单个字符的特化版本，速度更快。获取单个字符请使用 ``"X".unicode_at(0)``\ （请注意，合成字符、Emoji 等字符串是由多个 Unicode 码位构成的，无法使用该方法，请使用 :ref:`length()<class_StringName_method_length>` 判断）。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace_chars**\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_chars>`
将该字符串中出现的所有 ``keys`` 中的字符都替换为码位为 ``with`` 的 Unicode 字符。另见 :ref:`replace_char()<class_StringName_method_replace_char>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replacen:
.. rst-class:: classref-method
:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replacen>`
将该字符串中出现的所有 ``what`` 都替换为给定的 ``forwhat``\ ，\ **大小写不敏感**\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_StringName_method_reverse>`
返回该字符串的逆序的副本。该操作适用于 Unicode 代码点，而不是代码点序列，并且可能会破坏复合字母或表情符号等内容。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rfind:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfind>`
Returns the index of the **last** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`find()<class_StringName_method_find>`.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
\ **Note:** A value of ``from`` that is greater than the last possible index with enough space to find ``what`` is considered out-of-bounds, and returns ``-1``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rfindn:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfindn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfindn>`
返回这个字符串中 ``what`` **最后一次**\ 出现时的索引，\ **不区分大小写**\ ，不存在时则为 ``-1``\ 。搜索的起点可以用 ``from`` 指定，终点为该字符串的末尾。这个方法与 :ref:`findn()<class_StringName_method_findn>` 相对。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_right:
.. rst-class:: classref-method
:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_right>`
返回该字符串末尾的最后 ``length`` 个字符。如果 ``length`` 为负，则会从该字符串的开头剥离前 ``length`` 个字符。
::
print("Hello World!".right(3)) # 输出 "ld!"
print("Hello World!".right(-4)) # 输出 "o World!"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rpad:
.. rst-class:: classref-method
:ref:`String<class_String>` **rpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_rpad>`
必要时在该字符串的右侧添加若干 ``character`` 字符，使其长度至少为 ``min_length``\ 。另见 :ref:`lpad()<class_StringName_method_lpad>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rsplit:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **rsplit**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_rsplit>`
使用分隔符 ``delimiter`` 将该字符串从末尾开始进行拆分，返回子字符串数组。返回的数组中，每部分的出现顺序与它们在原字符串中的出现顺序一致。如果 ``delimiter`` 为空，则子串为单个字符。
如果 ``allow_empty`` 为 ``false``\ ，数组中会排除相邻分隔符之间的空字符串。
如果 ``maxsplit`` 大于 ``0``\ ，则拆分次数不能超过 ``maxsplit``\ 。默认拆分整个字符串，基本与 :ref:`split()<class_StringName_method_split>` 一致。
.. tabs::
.. code-tab:: gdscript
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”
.. code-tab:: csharp
// C# 中没有 String.RSplit() 方法。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_rstrip>`
从该字符串的结尾移除 ``chars`` 中定义的字符。另见 :ref:`rstrip()<class_StringName_method_rstrip>`\ 。
\ **注意：**\ ``chars`` 不是后缀。如果要移除后缀而不是一组字符，请使用 :ref:`trim_suffix()<class_StringName_method_trim_suffix>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha1_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha1_buffer>`
返回该字符串的 `SHA-1 <https://zh.wikipedia.org/wiki/SHA-1>`__ 哈希，类型为 :ref:`PackedByteArray<class_PackedByteArray>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha1_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha1_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha1_text>`
返回该字符串的 `SHA-1 <https://zh.wikipedia.org/wiki/SHA-1>`__ 哈希，类型为 :ref:`String<class_String>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha256_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha256_buffer>`
返回该字符串的 `SHA-256 <https://zh.wikipedia.org/wiki/SHA-2>`__ 哈希，类型为 :ref:`PackedByteArray<class_PackedByteArray>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha256_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha256_text>`
返回该字符串的 `SHA-256 <https://zh.wikipedia.org/wiki/SHA-2>`__ 哈希，类型为 :ref:`String<class_String>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_similarity:
.. rst-class:: classref-method
:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_similarity>`
返回该字符串与另一个字符串的相似指数（\ `索伦森-戴斯系数 <https://zh.wikipedia.org/wiki/Dice%E7%B3%BB%E6%95%B0>`__\ ）。结果为 ``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
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_simplify_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_simplify_path>`
如果该字符串为有效的文件路径，则将其转换为规范路径。规范路径是最短路径，不带 ``"./"`` 和所有不必要的 ``".."`` 和 ``"/"``\ 。
::
var simple_path = "./path/to///../file".simplify_path()
print(simple_path) # 输出 "path/file"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_split:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **split**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_split>`
使用分隔符 ``delimiter`` 将该字符串进行拆分，返回子字符串数组。如果 ``delimiter`` 为空，则子串为单个字符。这个方法与 :ref:`join()<class_StringName_method_join>` 相对。
如果 ``allow_empty`` 为 ``false``\ ，数组中会排除相邻分隔符之间的空字符串。
如果 ``maxsplit`` 大于 ``0``\ ，则拆分次数不能超过 ``maxsplit``\ 。默认拆分整个字符串。
.. tabs::
.. code-tab:: gdscript
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”
.. code-tab:: csharp
// C# 的 `Split()` 不支持 `maxsplit` 参数。
var someArray = "One,Two,Three".Split(",");
GD.Print(someArray[0]); // 输出“One”
GD.Print(someArray[1]); // 输出“Two”
GD.Print(someArray[2]); // 输出“Three,Four”
\ **注意：**\ 如果你只需要数组中的某一个子串，请考虑使用更快的 :ref:`get_slice()<class_StringName_method_get_slice>`\ 。如果你需要用更复杂的规则来拆分字符串，请改用 :ref:`RegEx<class_RegEx>` 类。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_split_floats:
.. rst-class:: classref-method
:ref:`PackedFloat64Array<class_PackedFloat64Array>` **split_floats**\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_split_floats>`
使用分隔符 ``delimiter`` 将该字符串拆分为浮点数，返回 :ref:`PackedFloat64Array<class_PackedFloat64Array>`\ 。
如果 ``allow_empty`` 为 ``false``\ ，则会排除相邻分隔符之间为空或无法转换为 :ref:`float<class_float>` 的内容。
::
var a = "1,2,4.5".split_floats(",") # a 为 [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c 为 [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b 为 [1.0, 4.5]
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_strip_edges:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_edges**\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_strip_edges>`
从该字符串的开头和结尾剥离所有不可打印的字符。其中包括空格、制表符（\ ``\t``\ ）以及换行符（\ ``\n`` ``\r``\ ）。
如果 ``left`` 为 ``false``\ ，会忽略该字符串的开头。与此类似，如果 ``right`` 为 ``false``\ ，则会忽略该字符串的结尾。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_strip_escapes:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_StringName_method_strip_escapes>`
从该字符串中剥离所有转义字符。其中包括 ASCII 表第一页的所有不可打印控制字符（值为 0 到 32），例如制表符（C 中的 ``\t``\ ）和换行符（\ ``\n`` 和 ``]\r``) 字符，但\ *不包括*\ 空格。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_substr:
.. rst-class:: classref-method
:ref:`String<class_String>` **substr**\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_substr>`
返回该字符串中的某一部分，位置从 ``from`` 开始，长度为 ``len``\ 。如果 ``len`` 为 ``-1``\ （默认值），将返回开给定位置开始的剩余字符。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_ascii_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_ascii_buffer>`
将该字符串转换为 `ASCII <https://zh.wikipedia.org/wiki/ASCII>`__/Latin-1 编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。这个方法比 :ref:`to_utf8_buffer()<class_StringName_method_to_utf8_buffer>` 稍快，但会把不支持的字符都替换为空格。这是 :ref:`PackedByteArray.get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>` 的逆运算。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_camel_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_camel_case>`
返回将该字符串转换为小驼峰命名法 ``camelCase`` 的结果。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_float>`
将代表十进制数的字符串转换为 :ref:`float<class_float>`\ 。该方法会在首个非数字字符处停止，除非是首次遇到 ``.``\ （小数点）以及表示指数的 ``e``\ 。另见 :ref:`is_valid_float()<class_StringName_method_is_valid_float>`\ 。
::
var a = "12.35".to_float() # a 为 12.35
var b = "1.2.3".to_float() # b 为 1.2
var c = "12xy3".to_float() # c 为 12.0
var d = "1e3".to_float() # d 为 1000.0
var e = "Hello!".to_float() # e 为 0.0
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_int>`
将代表整数的字符串转换为 :ref:`int<class_int>`\ 。该方法会删除所有非数字字符，并在遇到 ``.`` 后停止。另见 :ref:`is_valid_int()<class_StringName_method_is_valid_int>`\ 。
::
var a = "123".to_int() # a 为 123
var b = "x1y2z3".to_int() # b 为 123
var c = "-1.2.3".to_int() # c 为 -1
var d = "Hello!".to_int() # d 为 0
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_kebab_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_kebab_case>`
返回将该字符串转换为烤串命名法 ``kebab-case`` 的结果。
\ **注意：**\ 如果数字后跟着的是\ *单个*\ 字母，则不会进行拆分，这是为了保证某些单词的连贯（例如“2D”）。
.. tabs::
.. code-tab:: gdscript
"Node2D".to_kebab_case() # 返回 "node-2d"
"2nd place".to_kebab_case() # 返回 "2-nd-place"
"Texture3DAssetFolder".to_kebab_case() # 返回 "texture-3d-asset-folder"
.. code-tab:: csharp
"Node2D".ToKebabCase(); // 返回 "node-2d"
"2nd place".ToKebabCase(); // 返回 "2-nd-place"
"Texture3DAssetFolder".ToKebabCase(); // 返回 "texture-3d-asset-folder"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_lower:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_lower>`
返回将该字符串转换为小写 ``lowercase`` 的结果。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_multibyte_char_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_StringName_method_to_multibyte_char_buffer>`
将字符串转换为使用系统多字节代码页编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。如果转换失败，则会返回空数组。
\ ``encoding`` 的有效值由系统决定。如果 ``encoding`` 为空字符串，则会使用系统默认的编码。
- 对于 Windows，见\ `代码页标识符 <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ .NET 名称。
- 对于 macOS 和 Linux/BSD，支持的编码列表见 ``libiconv`` 库文档及 ``iconv --list``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_pascal_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_pascal_case>`
返回将该字符串转换为大驼峰命名法 ``PascalCase`` 的结果。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_snake_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_snake_case>`
返回将该字符串转换为蛇形命名法 ``snake_case`` 的结果。
\ **注意：**\ 如果数字后跟着的是\ *单个*\ 字母，则不会进行拆分，这是为了保证某些单词的连贯（例如“2D”）。
.. tabs::
.. code-tab:: gdscript
"Node2D".to_snake_case() # 返回 "node_2d"
"2nd place".to_snake_case() # 返回 "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # 返回 "texture_3d_asset_folder"
.. code-tab:: csharp
"Node2D".ToSnakeCase(); // 返回 "node_2d"
"2nd place".ToSnakeCase(); // 返回 "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // 返回 "texture_3d_asset_folder"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_upper:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_upper>`
返回将该字符串转换为大写 ``UPPERCASE`` 的结果。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf8_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf8_buffer>`
将该字符串转换为 `UTF-8 <https://zh.wikipedia.org/wiki/UTF-8>`__ 编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。这个方法比 :ref:`to_ascii_buffer()<class_StringName_method_to_ascii_buffer>` 稍慢，但支持所有 UTF-8 字符。大多数情况下请优先使用这个方法。这是 :ref:`PackedByteArray.get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>` 的逆运算。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf16_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf16_buffer>`
将该字符串转换为 `UTF-16 <https://zh.wikipedia.org/wiki/UTF-16>`__ 编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。这是 :ref:`PackedByteArray.get_string_from_utf16()<class_PackedByteArray_method_get_string_from_utf16>` 的逆运算。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf32_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf32_buffer>`
将该字符串转换为 `UTF-32 <https://zh.wikipedia.org/wiki/UTF-32>`__ 编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。这是 :ref:`PackedByteArray.get_string_from_utf32()<class_PackedByteArray_method_get_string_from_utf32>` 的逆运算。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_wchar_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_wchar_buffer>`
将该字符串转换为 `宽字符 <https://zh.wikipedia.org/zh-cn/%E5%AF%AC%E5%AD%97%E5%85%83>`__\ （\ ``wchat_t``\ ，Windows 上为 UTF-16，其他平台上为 UTF-32）编码的 :ref:`PackedByteArray<class_PackedByteArray>`\ 。这是 :ref:`PackedByteArray.get_string_from_wchar()<class_PackedByteArray_method_get_string_from_wchar>` 的逆运算。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_trim_prefix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_prefix>`
移除该字符串开头的 ``prefix`` 前缀，否则原样返回该字符串。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_trim_suffix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_suffix>`
移除该字符串末尾的 ``suffix`` 后缀，否则原样返回该字符串。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_unicode_at:
.. rst-class:: classref-method
:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_unicode_at>`
返回位于 ``at`` 的字符代码。
另见 :ref:`String.chr()<class_String_method_chr>`\ 、\ :ref:`@GDScript.char()<class_@GDScript_method_char>`\ 、\ :ref:`@GDScript.ord()<class_@GDScript_method_ord>`\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_decode>`
将该字符串按照 URL 编码格式进行解码。该方法可以在收到 HTTP 请求时正确解码 URL 中的参数。另见 :ref:`uri_encode()<class_StringName_method_uri_encode>`\ 。
.. tabs::
.. code-tab:: gdscript
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
print(url.uri_decode()) # 输出 "$DOCS_URL/?highlight=Godot Engine:docs"
.. code-tab:: csharp
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // 输出 "$DOCS_URL/?highlight=Godot Engine:docs"
\ **注意：**\ 这个方法会将 ``+`` 解码为空格。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_encode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_encode>`
将该字符串按照对 URL 友好的格式进行编码。该方法的目的是在发送 HTTP 请求时，正确编码 URL 中的参数。另见 :ref:`uri_decode()<class_StringName_method_uri_decode>`\ 。
.. tabs::
.. code-tab:: gdscript
var prefix = "$DOCS_URL/?highlight="
var url = prefix + "Godot Engine:docs".uri_encode()
print(url) # 输出 "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
.. code-tab:: csharp
var prefix = "$DOCS_URL/?highlight=";
var url = prefix + "Godot Engine:docs".URIEncode();
GD.Print(url); // 输出 "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_file_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_file_decode>`
按照 URL 编码格式解析文件路径。与 :ref:`uri_decode()<class_StringName_method_uri_decode>` 不同，该方法会保留 ``+``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_filename:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_filename>`
返回该字符串的副本，所有 :ref:`is_valid_filename()<class_StringName_method_is_valid_filename>` 中不允许的字符都会被替换为下划线。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_node_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_node_name>`
返回该字符串的副本，所有 :ref:`Node.name<class_Node_property_name>` 中不允许的字符都会被替换为下划线（\ ``.`` ``:`` ``@`` ``/`` ``"`` ``%``)）。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_xml_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_xml_escape>`
返回该字符串的副本，使用 XML 标准对特殊字符进行转义。如果 ``escape_quotes`` 为 ``true``\ ，则单引号（\ ``'``\ ）和双引号（\ ``"``\ ）字符也会被转义。
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_xml_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_xml_unescape>`
返回该字符串的副本，转义字符均按照 XML 标准使用本义代替。
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
运算符说明
----------
.. _class_StringName_operator_neq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_neq_String>`
如果该 **StringName** 与给定的 :ref:`String<class_String>` 不等价，则返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_neq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_neq_StringName>`
如果该 **StringName** 与 ``right`` 不指向同一个名称，则返回 ``true``\ 。\ **StringName** 间的比较比常规 :ref:`String<class_String>` 间的比较要快很多。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_mod_Variant:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator %**\ (\ right\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_StringName_operator_mod_Variant>`
格式化该 **StringName**\ ，使用若干参数替换占位符，返回的是 :ref:`String<class_String>`\ 。要传递多个参数时，\ ``right`` 应为 :ref:`Array<class_Array>`\ 。
更多信息见\ :doc:`《GDScript 格式字符串》 <../tutorials/scripting/gdscript/gdscript_format_string>`\ 教程。
\ **注意：**\ C# 中没有等价的运算符。见\ `如何使用“$”插入字符串 <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_sum_String:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_sum_String>`
将 ``right`` 追加到该 **StringName** 的末尾，返回的是 :ref:`String<class_String>`\ 。也称作字符串连接。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_sum_StringName:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_sum_StringName>`
将 ``right`` 追加到该 **StringName** 的末尾，返回的是 :ref:`String<class_String>`\ 。也称作字符串连接。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_lt_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lt_StringName>`
如果左侧的 **StringName** 的指针比 ``right`` 靠前，则返回 ``true``\ 。注意，这与 `Unicode 顺序 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ 是不同的。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_lte_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lte_StringName>`
如果左侧的 **StringName** 的指针比 ``right`` 靠前或者相同，则返回 ``true``\ 。注意，这与 `Unicode 顺序 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ 是不同的。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_eq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_eq_String>`
如果该 **StringName** 与给定的 :ref:`String<class_String>` 等价，则返回 ``true``\ 。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_eq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_eq_StringName>`
如果该 **StringName** 与 ``right`` 指向同一个名称，则返回 ``true``\ 。\ **StringName** 间的比较比常规 :ref:`String<class_String>` 间的比较要快很多。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_gt_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gt_StringName>`
如果左侧的 **StringName** 的指针比 ``right`` 靠后，则返回 ``true``\ 。注意，这与 `Unicode 顺序 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ 是不同的。
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_gte_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gte_StringName>`
如果左侧的 **StringName** 的指针比 ``right`` 靠后或相同，则返回 ``true``\ 。注意，这与 `Unicode 顺序 <https://zh.wikipedia.org/wiki/Unicode%E5%AD%97%E7%AC%A6%E5%88%97%E8%A1%A8>`__\ 是不同的。
.. |virtual| replace:: :abbr:`virtual (本方法通常需要用户覆盖才能生效。)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (本方法无副作用，不会修改该实例的任何成员变量。)`
.. |vararg| replace:: :abbr:`vararg (本方法除了能接受在此处描述的参数外，还能够继续接受任意数量的参数。)`
.. |constructor| replace:: :abbr:`constructor (本方法用于构造某个类型。)`
.. |static| replace:: :abbr:`static (调用本方法无需实例，可直接使用类名进行调用。)`
.. |operator| replace:: :abbr:`operator (本方法描述的是使用本类型作为左操作数的有效运算符。)`
.. |bitfield| replace:: :abbr:`BitField (这个值是由下列位标志构成位掩码的整数。)`
.. |void| replace:: :abbr:`void (无返回值。)`
Reference in New Issue View Git Blame Copy Permalink