godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/zh_Hant/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**\ s are immutable strings designed for general-purpose representation of unique names (also called "string interning"). Two **StringName**\ s with the same value are the same object. Comparing them is extremely fast compared to regular :ref:`String<class_String>`\ s.
You will usually pass a :ref:`String<class_String>` to methods expecting a **StringName** and it will be automatically converted (often at compile time), but in rare cases you can construct a **StringName** ahead of time with the **StringName** constructor or, in GDScript, the literal syntax ``&"example"``. Manually constructing a **StringName** allows you to control when the conversion from :ref:`String<class_String>` occurs or to use the literal and prevent conversions entirely.
See also :ref:`NodePath<class_NodePath>`, which is a similar concept specifically designed to store pre-parsed scene tree paths.
All of :ref:`String<class_String>`'s methods are available in this class too. They convert the **StringName** into a string, and they also return a string. This is highly inefficient and should only be used if the string is desired.
\ **Note:** In C#, an explicit conversion to ``System.String`` is required to use the methods listed on this page. Use the ``ToString()`` method to cast a **StringName** to a string, and then use the equivalent methods in ``System.String`` or ``StringExtensions``.
\ **Note:** In a boolean context, a **StringName** will evaluate to ``false`` if it is empty (``StringName("")``). Otherwise, a **StringName** will always evaluate to ``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() # Returns "Move Local X"
"sceneFile_path".capitalize() # Returns "Scene File Path"
"2D, FPS, PNG".capitalize() # Returns "2d, Fps, Png"
.. code-tab:: csharp
"move_local_x".Capitalize(); // Returns "Move Local X"
"sceneFile_path".Capitalize(); // Returns "Scene File Path"
"2D, FPS, PNG".Capitalize(); // Returns "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>`
Performs a case-sensitive comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" and "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order.
With different string lengths, returns ``1`` if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is *always* ``0``.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, and :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>`
Returns ``true`` if the string contains ``what``. In GDScript, this corresponds to the ``in`` operator.
.. tabs::
.. code-tab:: gdscript
print("Node".contains("de")) # Prints true
print("team".contains("I")) # Prints false
print("I" in "team") # Prints false
.. code-tab:: csharp
GD.Print("Node".Contains("de")); // Prints True
GD.Print("team".Contains("I")); // Prints False
If you need to know where ``what`` is within the string, use :ref:`find()<class_StringName_method_find>`. See also :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>`
Returns ``true`` if the string contains ``what``, **ignoring case**.
If you need to know where ``what`` is within the string, use :ref:`findn()<class_StringName_method_findn>`. See also :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>`
Like :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>` but prioritizes strings that begin with periods (``.``) and underscores (``_``) before any other character. Useful when sorting folders or file names.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, and :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>`
Like :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>` but prioritizes strings that begin with periods (``.``) and underscores (``_``) before any other character. Useful when sorting folders or file names.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, and :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>`
Formats the string by replacing all occurrences of ``placeholder`` with the elements of ``values``.
\ ``values`` can be a :ref:`Dictionary<class_Dictionary>`, an :ref:`Array<class_Array>`, or an :ref:`Object<class_Object>`. Any underscores in ``placeholder`` will be replaced with the corresponding keys in advance. Array elements use their index as keys.
::
# Prints "Waiting for Godot is a play by Samuel Beckett, and Godot Engine is named after it."
var use_array_values = "Waiting for {0} is a play by {1}, and {0} Engine is named after it."
print(use_array_values.format(["Godot", "Samuel Beckett"]))
# Prints "User 42 is Godot."
print("User {id} is {name}.".format({"id": 42, "name": "Godot"}))
Some additional handling is performed when ``values`` is an :ref:`Array<class_Array>`. If ``placeholder`` does not contain an underscore, the elements of the ``values`` array will be used to replace one occurrence of the placeholder in order; If an element of ``values`` is another 2-element array, it'll be interpreted as a key-value pair.
::
# Prints "User 42 is Godot."
print("User {} is {}.".format([42, "Godot"], "{}"))
print("User {id} is {name}.".format([["id", 42], ["name", "Godot"]]))
When passing an :ref:`Object<class_Object>`, the property names from :ref:`Object.get_property_list()<class_Object_method_get_property_list>` are used as keys.
::
# Prints "Visible true, position (0, 0)"
var node = Node2D.new()
print("Visible {visible}, position {position}".format(node))
See also the :doc:`GDScript format string <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.
\ **Note:** Each replacement is done sequentially for each element of ``values``, **not** all at once. This means that if any element is inserted and it contains another placeholder, it may be changed by the next replacement. While this can be very useful, it often causes unexpected results. If not necessary, make sure ``values``'s elements do not contain placeholders.
::
print("{0} {1}".format(["{1}", "x"])) # Prints "x x"
print("{0} {1}".format(["x", "{0}"])) # Prints "x {0}"
print("{a} {b}".format({"a": "{b}", "b": "c"})) # Prints "c c"
print("{a} {b}".format({"b": "c", "a": "{b}"})) # Prints "{b} c"
\ **Note:** In C#, it's recommended to `interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__, instead.
.. 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>`
Splits the string using a ``delimiter`` and returns the substring at index ``slice``. Returns the original string if ``delimiter`` does not occur in the string. Returns an empty string if the ``slice`` does not exist.
This is faster than :ref:`split()<class_StringName_method_split>`, if you only need one substring.
::
print("i/am/example/hi".get_slice("/", 2)) # Prints "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>`
Returns the 32-bit hash value representing the string's contents.
\ **Note:** Strings with equal hash values are *not* guaranteed to be the same, as a result of hash collisions. On the contrary, strings with different hash values are guaranteed to be different.
.. 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>`
Decodes a hexadecimal string as a :ref:`PackedByteArray<class_PackedByteArray>`.
.. tabs::
.. code-tab:: gdscript
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # outputs "68656c6c6f20776f726c64"
print(encoded.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // outputs "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>`
Returns ``true`` if all characters of this string can be found in ``text`` in their original order. This is not the same as :ref:`contains()<class_StringName_method_contains>`.
::
var text = "Wow, incredible!"
print("inedible".is_subsequence_of(text)) # Prints true
print("Word!".is_subsequence_of(text)) # Prints true
print("Window".is_subsequence_of(text)) # Prints false
print("".is_subsequence_of(text)) # Prints 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>`
Returns ``true`` if all characters of this string can be found in ``text`` in their original order, **ignoring case**. This is not the same as :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>`
Returns ``true`` if this string is a valid ASCII identifier. A valid ASCII identifier may contain only letters, digits, and underscores (``_``), and the first character may not be a digit.
::
print("node_2d".is_valid_ascii_identifier()) # Prints true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Prints true
print("1st_method".is_valid_ascii_identifier()) # Prints false
print("MyMethod#2".is_valid_ascii_identifier()) # Prints false
See also :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>`
Returns ``true`` if this string is a valid file name. A valid file name cannot be empty, begin or end with space characters, or contain characters that are not allowed (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
.. 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>`
Returns ``true`` if this string is a valid Unicode identifier.
A valid Unicode identifier must begin with a Unicode character of class ``XID_Start`` or ``"_"``, and may contain Unicode characters of class ``XID_Continue`` in the other positions.
::
print("node_2d".is_valid_unicode_identifier()) # Prints true
print("1st_method".is_valid_unicode_identifier()) # Prints false
print("MyMethod#2".is_valid_unicode_identifier()) # Prints false
print("állóképesség".is_valid_unicode_identifier()) # Prints true
print("выносливость".is_valid_unicode_identifier()) # Prints true
print("体力".is_valid_unicode_identifier()) # Prints true
See also :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>`.
\ **Note:** This method checks identifiers the same way as GDScript. See :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` for more advanced checks.
.. 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>`
Returns the concatenation of ``parts``' elements, with each element separated by the string calling this method. This method is the opposite of :ref:`split()<class_StringName_method_split>`.
.. tabs::
.. code-tab:: gdscript
var fruits = ["Apple", "Orange", "Pear", "Kiwi"]
print(", ".join(fruits)) # Prints "Apple, Orange, Pear, Kiwi"
print("---".join(fruits)) # Prints "Apple---Orange---Pear---Kiwi"
.. code-tab:: csharp
string[] fruits = ["Apple", "Orange", "Pear", "Kiwi"];
// In C#, this method is static.
GD.Print(string.Join(", ", fruits)); // Prints "Apple, Orange, Pear, Kiwi"
GD.Print(string.Join("---", fruits)); // Prints "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>`
Performs a **case-sensitive**, *natural order* comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order.
When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected, instead of the single digit's value. A sorted sequence of numbered strings will be ``["1", "2", "3", ...]``, not ``["1", "10", "2", "3", ...]``.
With different string lengths, returns ``1`` if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is *always* ``0``.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, and :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>`
Performs a **case-insensitive**, *natural order* comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order. Internally, lowercase characters are converted to uppercase for the comparison.
When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected, instead of the single digit's value. A sorted sequence of numbered strings will be ``["1", "2", "3", ...]``, not ``["1", "10", "2", "3", ...]``.
With different string lengths, returns ``1`` if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is *always* ``0``.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, and :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>`
Performs a **case-insensitive** comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order. Internally, lowercase characters are converted to uppercase for the comparison.
With different string lengths, returns ``1`` if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is *always* ``0``.
To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`casecmp_to()<class_StringName_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, and :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>`
Concatenates ``path`` at the end of the string as a subpath, adding ``/`` if necessary.
\ **Example:** ``"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>`
Removes all occurrences of the Unicode character with code ``what``. Faster version of :ref:`replace()<class_StringName_method_replace>` when the key is only one character long and the replacement is ``""``.
.. 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>`
Replaces all occurrences of the Unicode character with code ``key`` with the Unicode character with code ``with``. Faster version of :ref:`replace()<class_StringName_method_replace>` when the key is only one character long. To get a single character use ``"X".unicode_at(0)`` (note that some strings, like compound letters and emoji, can be composed of multiple unicode codepoints, and will not work with this method, use :ref:`length()<class_StringName_method_length>` to make sure).
.. 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>`
Replaces any occurrence of the characters in ``keys`` with the Unicode character with code ``with``. See also :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>`
Returns the copy of this string in reverse order. This operation works on unicode codepoints, rather than sequences of codepoints, and may break things like compound letters or emojis.
.. 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>`
Splits the string using a ``delimiter`` and returns an array of the substrings, starting from the end of the string. The splits in the returned array appear in the same order as the original string. If ``delimiter`` is an empty string, each substring will be a single character.
If ``allow_empty`` is ``false``, empty strings between adjacent delimiters are excluded from the array.
If ``maxsplit`` is greater than ``0``, the number of splits may not exceed ``maxsplit``. By default, the entire string is split, which is mostly identical to :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()) # Prints 2
print(some_array[0]) # Prints "One,Two,Three"
print(some_array[1]) # Prints "Four"
.. code-tab:: csharp
// In C#, there is no String.RSplit() method.
.. 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>`
Returns the similarity index (`Sørensen-Dice coefficient <https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient>`__) of this string compared to another. A result of ``1.0`` means totally similar, while ``0.0`` means totally dissimilar.
::
print("ABC123".similarity("ABC123")) # Prints 1.0
print("ABC123".similarity("XYZ456")) # Prints 0.0
print("ABC123".similarity("123ABC")) # Prints 0.8
print("ABC123".similarity("abc123")) # Prints 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>`
Splits the string using a ``delimiter`` and returns an array of the substrings. If ``delimiter`` is an empty string, each substring will be a single character. This method is the opposite of :ref:`join()<class_StringName_method_join>`.
If ``allow_empty`` is ``false``, empty strings between adjacent delimiters are excluded from the array.
If ``maxsplit`` is greater than ``0``, the number of splits may not exceed ``maxsplit``. By default, the entire string is split.
.. tabs::
.. code-tab:: gdscript
var some_array = "One,Two,Three,Four".split(",", true, 2)
print(some_array.size()) # Prints 3
print(some_array[0]) # Prints "One"
print(some_array[1]) # Prints "Two"
print(some_array[2]) # Prints "Three,Four"
.. code-tab:: csharp
// C#'s `Split()` does not support the `maxsplit` parameter.
var someArray = "One,Two,Three".Split(",");
GD.Print(someArray[0]); // Prints "One"
GD.Print(someArray[1]); // Prints "Two"
GD.Print(someArray[2]); // Prints "Three"
\ **Note:** If you only need one substring from the array, consider using :ref:`get_slice()<class_StringName_method_get_slice>` which is faster. If you need to split strings with more complex rules, use the :ref:`RegEx<class_RegEx>` class instead.
.. 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>` 稍快，但會把不支援的字元都替換為空格。
.. 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>`
Returns the string converted to ``kebab-case``.
\ **Note:** Numbers followed by a *single* letter are not separated in the conversion to keep some words (such as "2D") together.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_kebab_case() # Returns "node-2d"
"2nd place".to_kebab_case() # Returns "2-nd-place"
"Texture3DAssetFolder".to_kebab_case() # Returns "texture-3d-asset-folder"
.. code-tab:: csharp
"Node2D".ToKebabCase(); // Returns "node-2d"
"2nd place".ToKebabCase(); // Returns "2-nd-place"
"Texture3DAssetFolder".ToKebabCase(); // Returns "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>`
Returns the string converted to ``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>`
Converts the string to system multibyte code page encoded :ref:`PackedByteArray<class_PackedByteArray>`. If conversion fails, empty array is returned.
The values permitted for ``encoding`` are system dependent. If ``encoding`` is empty string, system default encoding is used.
- For Windows, see `Code Page Identifiers <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ .NET names.
- For macOS and Linux/BSD, see ``libiconv`` library documentation and ``iconv --list`` for a list of supported encodings.
.. 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>`
Returns the string converted to ``snake_case``.
\ **Note:** Numbers followed by a *single* letter are not separated in the conversion to keep some words (such as "2D") together.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_snake_case() # Returns "node_2d"
"2nd place".to_snake_case() # Returns "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # Returns "texture_3d_asset_folder"
.. code-tab:: csharp
"Node2D".ToSnakeCase(); // Returns "node_2d"
"2nd place".ToSnakeCase(); // Returns "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // Returns "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>`
Returns the string converted to ``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 字元。大多數情況下請優先使用這個方法。
.. 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>`\ 。
.. 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>`\ 。
.. 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>`\ 。
.. 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>`
Returns the character code at position ``at``.
See also :ref:`String.chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>`, and :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>`
Decodes the string from its URL-encoded format. This method is meant to properly decode the parameters in a URL when receiving an HTTP request. See also :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()) # Prints "$DOCS_URL/?highlight=Godot Engine:docs"
.. code-tab:: csharp
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // Prints "$DOCS_URL/?highlight=Godot Engine:docs"
\ **Note:** This method decodes ``+`` as space.
.. 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>`
Decodes the file path from its URL-encoded format. Unlike :ref:`uri_decode()<class_StringName_method_uri_decode>` this method leaves ``+`` as is.
.. 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