godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-04 10:09:56 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
c3f2364c10f397e3718d45ebd79eda715f38f8e0
godot-docs-l10n/classes/ru/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
154 KiB
ReStructuredText
Raw Blame History

This file contains ambiguous Unicode characters

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

:github_url: hide
.. _class_StringName:
StringName
==========
Встроенный тип для уникальных строк.
.. rst-class:: classref-introduction-group
Описание
----------------
**StringName** — это неизменяемые строки, предназначенные для универсального представления уникальных имен (также называемого «интернированием строк»). Два **StringName** с одинаковым значением являются одним и тем же объектом. Их сравнение выполняется чрезвычайно быстро по сравнению с обычными :ref:`String<class_String>`.
Обычно вы передаете :ref:`String<class_String>` методам, ожидающим **StringName**, и он будет автоматически преобразован (часто во время компиляции), но в редких случаях вы можете заранее создать **StringName** с помощью конструктора **StringName** или, в GDScript, литерального синтаксиса ``&"example"``. Ручное создание **StringName** позволяет вам контролировать, когда происходит преобразование из :ref:`String<class_String>`, или использовать литерал и полностью предотвратить преобразования.
См. также :ref:`NodePath<class_NodePath>`, который является похожей концепцией, специально разработанной для хранения предварительно проанализированных путей дерева сцены.
Все методы :ref:`String<class_String>` также доступны в этом классе. Они преобразуют **StringName** в строку, а также возвращают строку. Это крайне неэффективно и должно использоваться только в том случае, если строка желательна.
\ **Примечание:** В C# для использования методов, перечисленных на этой странице, требуется явное преобразование в ``System.String``. Используйте метод ``ToString()``, чтобы преобразовать **StringName** в строку, а затем используйте эквивалентные методы в ``System.String`` или ``StringExtensions``.
\ **Примечание:** В логическом контексте **StringName** будет оцениваться как ``false``, если он пуст (``StringName("")``). В противном случае **StringName** всегда будет оцениваться как ``true``.
.. note::
Существуют заметные различия при использовании данного API с C#. Подробнее см. :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** как копию заданного **StringName**.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`String<class_String>`\ )
Создает новый **StringName** из заданного :ref:`String<class_String>`. В 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>`
Возвращает ``true``, если строка начинается с указанного ``text``. См. также :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()) # Prints ["Ge", "et", "t ", " u", "up", "p!"]
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_bin_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_bin_to_int>`
Преобразует строку, представляющую двоичное число, в :ref:`int<class_int>`. Строка может иметь необязательный префикс ``"0b"`` и дополнительный префикс ``-`` для отрицательных чисел.
.. tabs::
.. code-tab:: gdscript
print("101".bin_to_int()) # Выводит 5
print("0b101".bin_to_int()) # Выводит 5
print("-0b10".bin_to_int()) # Выводит -2
.. code-tab:: csharp
GD.Print("101".BinToInt()); // Выводит 5
GD.Print("0b101".BinToInt()); // Выводит 5
GD.Print("-0b10".BinToInt()); // Выводит -2
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_c_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта языка C.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_c_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_unescape>`
Возвращает копию строки с экранированными символами, замененными их значениями. Поддерживаемые экранированные последовательности: ``\'``, ``\"``, ``\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.
\ **Примечание:** В отличие от парсера GDScript, этот метод не поддерживает экранированную последовательность ``\uXXXX``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_capitalize:
.. rst-class:: classref-method
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_StringName_method_capitalize>`
Изменяет внешний вид строки: заменяет подчеркивания (``_``) пробелами, добавляет пробелы перед заглавными буквами в середине слова, преобразует все буквы в строчные, затем преобразует первую букву и каждую букву после пробела в заглавные.
.. tabs::
.. code-tab:: gdscript
"move_local_x".capitalize() # Возвращает "Move Local X"
"sceneFile_path".capitalize() # Возвращает "Scene File Path"
"2D, FPS, PNG".capitalize() # Возвращает "2d, Fps, Png"
.. code-tab:: csharp
"move_local_x".Capitalize(); // Возвращает "Move Local X"
"sceneFile_path".Capitalize(); // Возвращает "Scene File Path"
"2D, FPS, PNG".Capitalize(); // Возвращает "2d, Fps, Png"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_casecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_casecmp_to>`
Выполняет сравнение с другой строкой с учетом регистра. Возвращает ``-1`` если меньше, ``1`` если больше, или ``0`` если равно. «Меньше» и «больше» определяются `кодовыми точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ каждой строки, что примерно соответствует алфавитному порядку.
При разной длине строк возвращает ``1`` если эта строка длиннее строки ``to``, или ``-1`` если короче. Обратите внимание, что длина пустых строк *всегда * ровна ``0``.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` и :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_contains:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_contains>`
Возвращает ``true``, если строка содержит ``what``. В GDScript это соответствует оператору ``in``.
.. tabs::
.. code-tab:: gdscript
print("Node".contains("de")) # Выводит true
print("team".contains("I")) # Выводит false
print("I" in "team") # Выводит false
.. code-tab:: csharp
GD.Print("Node".Contains("de")); // Выводит True
GD.Print("team".Contains("I")); // Выводит False
Если вам нужно узнать, где в строке находится ``what``, используйте :ref:`find()<class_StringName_method_find>`. См. также :ref:`containsn()<class_StringName_method_containsn>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_containsn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_containsn>`
Возвращает ``true``, если строка содержит ``what``, **игнорируя регистр**.
Если вам нужно узнать, где находится ``what`` в строке, используйте :ref:`findn()<class_StringName_method_findn>`. См. также :ref:`contains()<class_StringName_method_contains>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **count**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_count>`
Возвращает количество вхождений подстроки ``what`` между позициями ``from`` и ``to``. Если ``to`` равен 0, поиск продолжается до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_countn:
.. rst-class:: classref-method
:ref:`int<class_int>` **countn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_countn>`
Возвращает количество вхождений подстроки ``what`` между позициями ``from`` и ``to``, **без учета регистра**. Если ``to`` равен 0, поиск продолжается до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_StringName_method_dedent>`
Возвращает копию строки с удаленным отступом (начальные табуляции и пробелы). См. также :ref:`indent()<class_StringName_method_indent>` для добавления отступа.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_ends_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_ends_with>`
Возвращает ``true``, если строка заканчивается указанным ``text``. См. также :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>`
Возвращает строку с стертыми ``chars`` символами, начиная с ``position``. Если ``chars`` превышает длину строки, заданную ``position``, из возвращаемой строки будет стерто меньше символов. Возвращает пустую строку, если ``position`` или ``chars`` отрицательны. Возвращает исходную строку без изменений, если ``chars`` равен ``0``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_filecasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filecasecmp_to>`
Как :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, но отдает приоритет строкам, начинающимся с точек (``.``) и подчеркиваний (``_``) перед любым другим символом. Полезно при сортировке папок или имен файлов.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>` и :ref:`casecmp_to()<class_StringName_method_casecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_filenocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filenocasecmp_to>`
Как :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, но отдает приоритет строкам, начинающимся с точек (``.``) и подчеркиваний (``_``) перед любым другим символом. Полезно при сортировке папок или имен файлов.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>` и :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_find:
.. rst-class:: classref-method
:ref:`int<class_int>` **find**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_find>`
Returns the index of the **first** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the string.
.. tabs::
.. code-tab:: gdscript
print("Team".find("I")) # Prints -1
print("Potato".find("t")) # Prints 2
print("Potato".find("t", 3)) # Prints 4
print("Potato".find("t", 5)) # Prints -1
.. code-tab:: csharp
GD.Print("Team".Find("I")); // Prints -1
GD.Print("Potato".Find("t")); // Prints 2
GD.Print("Potato".Find("t", 3)); // Prints 4
GD.Print("Potato".Find("t", 5)); // Prints -1
\ **Note:** If you just want to know whether the string contains ``what``, use :ref:`contains()<class_StringName_method_contains>`. In GDScript, you may also use the ``in`` operator.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_findn:
.. rst-class:: classref-method
:ref:`int<class_int>` **findn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_findn>`
Возвращает индекс **первого** **регистронезависимого** вхождения ``what`` в этой строке или ``-1``, если их нет. Начальный индекс поиска можно указать с помощью ``from``, продолжая до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_format:
.. rst-class:: classref-method
:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_StringName_method_format>`
Форматирует строку, заменяя все вхождения ``placeholder`` элементами ``values``.
\ ``values`` может быть :ref:`Dictionary<class_Dictionary>`, :ref:`Array<class_Array>` или :ref:`Object<class_Object>`. Любые подчеркивания в ``placeholder`` будут заранее заменены соответствующими ключами. Элементы массива используют свои индексы в качестве ключей.
::
# Выводит "Waiting for Godot 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"]))
# Выводит "User 42 is Godot."
print("User {id} is {name}.".format({"id": 42, "name": "Godot"}))
Некоторая дополнительная обработка выполняется, когда ``values`` является :ref:`Array<class_Array>`. Если ``placeholder`` не содержит подчеркивания, элементы массива ``values`` будут использоваться для замены одного вхождения placeholder по порядку; Если элемент ``values`` является другим массивом из 2 элементов, он будет интерпретироваться как пара ключ-значение.
::
# Выводит "User 42 is Godot."
print("User {} is {}.".format([42, "Godot"], "{}"))
print("User {id} is {name}.".format([["id", 42], ["name", "Godot"]]))
При передаче :ref:`Object<class_Object>` в качестве ключей используются имена свойств из :ref:`Object.get_property_list()<class_Object_method_get_property_list>`.
::
# Выводит "Visible true, position (0, 0)"
var node = Node2D.new()
print("Visible {visible}, position {position}".format(node))
См. также :doc:`Строка формата GDScript <../tutorials/scripting/gdscript/gdscript_format_string>` учебник.
\ **Примечание:** Каждая замена выполняется последовательно для каждого элемента ``values``, **не** всех сразу. Это означает, что если какой-либо элемент вставлен и содержит другой placeholder, он может быть изменен следующей заменой. Хотя это может быть очень полезно, часто это приводит к неожиданным результатам. Если это не обязательно, убедитесь, что элементы ``values`` не содержат placeholder.
::
print("{0} {1}".format(["{1}", "x"])) # Выводит "x x"
print("{0} {1}".format(["x", "{0}"])) # Выводит "x {0}"
print("{a} {b}".format({"a": "{b}", "b": "c"})) # Выводит "c c"
print("{a} {b}".format({"b": "c", "a": "{b}"})) # Выводит "{b} c"
\ **Примечание:** В C# рекомендуется вместо этого `интерполировать строки с помощью «$» <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_base_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_base_dir>`
Если строка является допустимым путем к файлу, возвращает имя базового каталога.
::
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path равен "/path/to"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_basename>`
Если строка является допустимым путем к файлу, возвращает полный путь к файлу без расширения.
::
var base = "/path/to/file.txt".get_basename() # base равен "/path/to/file"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_extension:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_extension>`
Если строка является допустимым именем файла или путем, возвращает расширение файла без начальной точки (``.``). В противном случае возвращает пустую строку.
::
var a = "/path/to/file.txt".get_extension() # a равен "txt"
var b = "cool.txt".get_extension() # b равен "txt"
var c = "cool.font.tres".get_extension() # c равен "tres"
var d = ".pack1".get_extension() # d равен "pack1"
var e = "file.txt.".get_extension() # e равен ""
var f = "file.txt..".get_extension() # f равен ""
var g = "txt".get_extension() # g равен ""
var h = "".get_extension() # h равен ""
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_file:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_file>`
Если строка является допустимым путем к файлу, возвращает имя файла, включая расширение.
::
var file = "/path/to/icon.png".get_file() # file равен "icon.png"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slice:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slice**\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice>`
Разделяет строку с помощью ``delimiter`` и возвращает подстроку с индексом ``slice``. Возвращает исходную строку, если ``delimiter`` не встречается в строке. Возвращает пустую строку, если ``slice`` не существует.
Это быстрее, чем :ref:`split()<class_StringName_method_split>`, если вам нужна только одна подстрока.
::
print("i/am/example/hi".get_slice("/", 2)) # Выводит "example"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slice_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice_count>`
Возвращает общее количество фрагментов при разделении строки с заданным ``delimiter`` (см. :ref:`split()<class_StringName_method_split>`).
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slicec:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slicec**\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slicec>`
Разделяет строку, используя символ Unicode с кодом ``delimiter`` и возвращает подстроку с индексом ``slice``. Возвращает пустую строку, если ``slice`` не существует.
Это быстрее, чем :ref:`split()<class_StringName_method_split>`, если вам нужна только одна подстрока.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_StringName_method_hash>`
Возвращает 32-битное хэш-значение, представляющее содержимое строки.
\ **Примечание:** Строки с одинаковыми хэш-значениями *не* гарантированно будут одинаковыми из-за коллизий хэшей. Напротив, строки с разными хэш-значениями гарантированно будут разными.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hex_decode:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_decode>`
Декодирует шестнадцатеричную строку как :ref:`PackedByteArray<class_PackedByteArray>`.
.. tabs::
.. code-tab:: gdscript
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # выводит "68656c6c6f20776f726c64"
print(encoded.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // выводит "68656c6c6f20776f726c64"
GD.Print(encoded.HexDecode().GetStringFromUtf8());
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hex_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_to_int>`
Преобразует строку, представляющую шестнадцатеричное число, в :ref:`int<class_int>`. Строка может иметь необязательный префикс ``"0x"`` и дополнительный префикс ``-`` для отрицательных чисел.
.. tabs::
.. code-tab:: gdscript
print("0xff".hex_to_int()) # Выводит 255
print("ab".hex_to_int()) # Выводит 171
.. code-tab:: csharp
GD.Print("0xff".HexToInt()); // Выводит 255
GD.Print("ab".HexToInt()); // Выводит 171
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_indent:
.. rst-class:: classref-method
:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_indent>`
Делает отступ каждой строки с заданным ``prefix``. Пустые строки не имеют отступа. См. также :ref:`dedent()<class_StringName_method_dedent>` для удаления отступа.
Например, отступ строки можно сделать двумя табуляциями с помощью ``"\t\t"`` или четырьмя пробелами с помощью ``" "``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_insert:
.. rst-class:: classref-method
:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_insert>`
Вставляет ``what`` в указанную ``position`` в строке.
.. 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>`
Возвращает ``true``, если длина строки равна ``0`` (``""``), то есть пуста. См. также :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>`
Возвращает ``true``, если все символы этой строки можно найти в ``text`` в их исходном порядке. Это не то же самое, что :ref:`contains()<class_StringName_method_contains>`.
::
var text = "Wow, incredible!"
print("inedible".is_subsequence_of(text)) # Выводит true
print("Word!".is_subsequence_of(text)) # Выводит true
print("Window".is_subsequence_of(text)) # Выводит false
print("".is_subsequence_of(text)) # Выводит true
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_subsequence_ofn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_is_subsequence_ofn>`
Возвращает ``true``, если все символы этой строки можно найти в ``text`` в их исходном порядке, **игнорируя регистр**. Это не то же самое, что и :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>`
Возвращает ``true``, если эта строка является допустимым идентификатором ASCII. Допустимый идентификатор ASCII может содержать только буквы, цифры и подчеркивания (``_``), а первый символ не может быть цифрой.
::
print("node_2d".is_valid_ascii_identifier()) # Выводит true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Выводит true
print("1st_method".is_valid_ascii_identifier()) # Выводит false
print("MyMethod#2".is_valid_ascii_identifier()) # Выводит false
См. также :ref:`is_valid_unicode_identifier()<class_StringName_method_is_valid_unicode_identifier>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_filename:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_filename>`
Возвращает ``true``, если эта строка является допустимым именем файла. Допустимое имя файла не может быть пустым, начинаться или заканчиваться пробелами или содержать недопустимые символы (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_float:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_float>`
Возвращает ``true``, если эта строка представляет допустимое число с плавающей точкой. Допустимое число с плавающей точкой может содержать только цифры, одну десятичную точку (``.``) и букву экспоненты (``e``). Оно также может иметь префикс в виде положительного (``+``) или отрицательного (``-``) знака. Любое допустимое целое число также является допустимым числом с плавающей точкой (см. :ref:`is_valid_int()<class_StringName_method_is_valid_int>`). См. также :ref:`to_float()<class_StringName_method_to_float>`.
::
print("1.7".is_valid_float()) # Выводит true
print("24".is_valid_float()) # Выводит true
print("7e3".is_valid_float()) # Выводит true
print("Hello".is_valid_float()) # Выводит false
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_hex_number:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_hex_number**\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_is_valid_hex_number>`
Возвращает ``true``, если эта строка является допустимым шестнадцатеричным числом. Допустимое шестнадцатеричное число содержит только цифры или буквы от ``A`` до ``F`` (как заглавные, так и строчные) и может иметь префикс в виде положительного (``+``) или отрицательного (``-``) знака.
Если ``with_prefix`` равен ``true``, шестнадцатеричное число должно иметь префикс ``"0x"``, чтобы считаться допустимым.
::
print("A08E".is_valid_hex_number()) # Выводит true
print("-AbCdEf".is_valid_hex_number()) # Выводит true
print("2.5".is_valid_hex_number()) # Выводит false
print("0xDEADC0DE".is_valid_hex_number(true)) # Выводит true
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_html_color:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_html_color>`
Возвращает ``true``, если эта строка является допустимым цветом в шестнадцатеричной нотации HTML. Строка должна быть шестнадцатеричным значением (см. :ref:`is_valid_hex_number()<class_StringName_method_is_valid_hex_number>`) из 3, 4, 6 или 8 цифр и может иметь префикс в виде знака решетки (``#``). Другие нотации HTML для цветов, такие как имена или ``hsl()``, не считаются допустимыми. См. также :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>`
Возвращает ``true``, если эта строка представляет собой правильно отформатированный адрес IPv4 или IPv6. Этот метод рассматривает `зарезервированные IP-адреса <https://en.wikipedia.org/wiki/Reserved_IP_addresses>`__, такие как ``"0.0.0.0"`` и ``"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"`` как допустимые.
.. 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>`
Возвращает ``true``, если эта строка является допустимым идентификатором Unicode.
Допустимый идентификатор Unicode должен начинаться с символа Unicode класса ``XID_Start`` или ``"_"`` и может содержать символы Unicode класса ``XID_Continue`` в других позициях.
::
print("node_2d".is_valid_unicode_identifier()) # Выводит true
print("1st_method".is_valid_unicode_identifier()) # Выводит false
print("MyMethod#2".is_valid_unicode_identifier()) # Выводит false
print("állóképesség".is_valid_unicode_identifier()) # Выводит true
print("выносливость".is_valid_unicode_identifier()) # Выводит true
print("体力".is_valid_unicode_identifier()) # Выводит true
См. также :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>`.
\ **Примечание:** Этот метод проверяет идентификаторы так же, как GDScript. См. :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` для более сложных проверок.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_StringName_method_join>`
Возвращает цепочку элементов ``parts``', где каждый элемент разделен строкой, вызывающей этот метод. Этот метод противоположен :ref:`split()<class_StringName_method_split>`.
.. tabs::
.. code-tab:: gdscript
var fruits = ["Apple", "Orange", "Pear", "Kiwi"]
print(", ".join(fruits)) # Выводит "Apple, Orange, Pear, Kiwi"
print("---".join(fruits)) # Выводит "Apple---Orange---Pear---Kiwi"
.. code-tab:: csharp
string[] fruits = ["Apple", "Orange", "Pear", "Kiwi"];
// В C# этот метод является статическим.
GD.Print(string.Join(", ", fruits)); // Выводит "Apple, Orange, Pear, Kiwi"
GD.Print(string.Join("---", fruits)); // Выводит "Apple---Orange---Pear---Kiwi"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_json_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_json_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта JSON. Поскольку он близко соответствует стандарту C, можно использовать :ref:`c_unescape()<class_StringName_method_c_unescape>` для деэкранирования строки, если это необходимо.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_left:
.. rst-class:: classref-method
:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_left>`
Возвращает первые ``length`` символы из начала строки. Если ``length`` отрицательный, удаляет последние ``length`` символы из конца строки.
::
print("Hello World!".left(3)) # Выводит "Hel"
print("Hello World!".left(-4)) # Выводит "Hello Wo"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_StringName_method_length>`
Возвращает количество символов в строке. Пустые строки (``""``) всегда возвращают ``0``. См. также :ref:`is_empty()<class_StringName_method_is_empty>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_lpad:
.. rst-class:: classref-method
:ref:`String<class_String>` **lpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_lpad>`
Форматирует строку так, чтобы она была длиной не менее ``min_length``, добавляя ``character`` слева от строки, если необходимо. См. также :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://en.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://en.wikipedia.org/wiki/MD5>`__ строки как другую :ref:`String<class_String>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalcasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalcasecmp_to>`
Выполняет **чувствительное к регистру**, *естественное* сравнение с другой строкой. Возвращает ``-1`` если меньше, ``1`` если больше, или ``0`` если равно. "Меньше" или "больше" определяются `кодовыми точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ каждой строки, что примерно соответствует алфавитному порядку.
При использовании для сортировки сравнение в естественном порядке упорядочивает последовательности чисел по объединенному значению каждой цифры, как часто ожидается, а не по значению одной цифры. Отсортированная последовательность пронумерованных строк будет ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``.
При разной длине строки возвращает ``1``, если эта строка длиннее строки ``to``, или ``-1`` если короче. Обратите внимание, что длина пустых строк *всегда* равна ``0``.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` и :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalnocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalnocasecmp_to>`
Выполняет **нечувствительное к регистру**, *естественное* сравнение с другой строкой. Возвращает ``-1`` если меньше, ``1`` если больше, или ``0`` если равно. "Меньше" или "больше" определяются `кодовыми точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ каждой строки, что примерно соответствует алфавитному порядку. Внутренне строчные символы преобразуются в прописные для сравнения.
При использовании для сортировки сравнение в естественном порядке упорядочивает последовательности чисел по объединенному значению каждой цифры, как часто ожидается, вместо значения одной цифры. Отсортированная последовательность пронумерованных строк будет ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``.
При разной длине строки возвращает ``1``, если эта строка длиннее строки ``to``, или ``-1`` если короче. Обратите внимание, что длина пустых строк *]всегда* равна ``0``.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` и :ref:`casecmp_to()<class_StringName_method_casecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_nocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_nocasecmp_to>`
Выполняет **нечувствительное к регистру** сравнение с другой строкой. Возвращает ``-1`` если меньше, ``1`` если больше, или ``0`` если равно. «Меньше» или «больше» определяются `кодовыми точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ каждой строки, что примерно соответствует алфавитному порядку. Внутренне строчные символы преобразуются в заглавные для сравнения.
При разной длине строк возвращает ``1``, если эта строка длиннее строки ``to``, или ``-1`` если короче. Обратите внимание, что длина пустых строк *всегда* равна ``0``.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте оператор ``==``. См. также :ref:`casecmp_to()<class_StringName_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` и :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_pad_decimals:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_decimals>`
Форматирует строку, представляющую число, так, чтобы она содержала точное количество цифр ``digits`` *после* десятичной точки.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_pad_zeros:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_zeros>`
Форматирует строку, представляющую число, так, чтобы она содержала точное количество цифр ``digits`` *перед* десятичной точкой.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_path_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_path_join>`
Объединяет ``path`` в конце строки как подпуть, добавляя ``/`` при необходимости.
\ **Пример:** ``"this/is".path_join("path") == "this/is/path"``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_remove_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_remove_char>`
Удаляет все вхождения символа Unicode с кодом ``what``. Более быстрая версия :ref:`replace()<class_StringName_method_replace>`, когда ключ состоит только из одного символа, а замена — ``""``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_StringName_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_repeat>`
Повторяет эту строку несколько раз. ``count`` должно быть больше, чем ``0``. В противном случае возвращает пустую строку.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replace>`
Заменяет все вхождения ``what`` внутри строки на указанный ``forwhat``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace_char**\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_char>`
Заменяет все вхождения символа Unicode с кодом ``key`` на символ Unicode с кодом ``with``. Более быстрая версия метода :ref:`replace()<class_StringName_method_replace>`, когда ключ состоит всего из одного символа. Чтобы получить один символ, используйте ``"X".unicode_at(0)`` (обратите внимание, что некоторые строки, например, составные буквы и эмодзи, могут состоять из нескольких кодовых точек Unicode и не будут работать с этим методом, используйте :ref:`length()<class_StringName_method_length>` для уверенности).
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replace_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace_chars**\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_chars>`
Заменяет все вхождения символов в ``keys`` на символ Unicode с кодом ``with``. См. также :ref:`replace_char()<class_StringName_method_replace_char>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replacen:
.. rst-class:: classref-method
:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replacen>`
Заменяет все **независимые от регистра** вхождения ``what`` внутри строки на заданный ``forwhat``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_StringName_method_reverse>`
Возвращает копию этой строки в обратном порядке. Эта операция работает с кодовыми точками Unicode, а не с последовательностями кодовых точек, и может сломать такие вещи, как составные буквы или эмодзи.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rfind:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfind>`
Returns the index of the **last** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`find()<class_StringName_method_find>`.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
\ **Note:** A value of ``from`` that is greater than the last possible index with enough space to find ``what`` is considered out-of-bounds, and returns ``-1``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rfindn:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfindn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfindn>`
Возвращает индекс **последнего** **регистронезависимого** вхождения ``what`` в этой строке или ``-1``, если их нет. Начальный индекс поиска можно указать с помощью ``from``, продолжая до начала строки. Этот метод является обратным :ref:`findn()<class_StringName_method_findn>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_right:
.. rst-class:: classref-method
:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_right>`
Возвращает последние ``length`` символы с конца строки. Если ``length`` отрицательный, удаляет первые ``length`` символы с начала строки.
::
print("Hello World!".right(3)) # Выводит "ld!"
print("Hello World!".right(-4)) # Вывдит "o World!"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rpad:
.. rst-class:: classref-method
:ref:`String<class_String>` **rpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_rpad>`
Форматирует строку так, чтобы она была длиной не менее ``min_length``, добавляя ``character`` справа от строки, если необходимо. См. также :ref:`lpad()<class_StringName_method_lpad>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rsplit:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **rsplit**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_rsplit>`
Разделяет строку с помощью ``delimiter`` и возвращает массив подстрок, начиная с конца строки. Разделения в возвращаемом массиве отображаются в том же порядке, что и исходная строка. Если ``delimiter`` — пустая строка, каждая подстрока будет представлять собой один символ.
Если ``allow_empty`` — ``false``, пустые строки между соседними разделителями исключаются из массива.
Если ``maxsplit`` больше ``0``, количество разделений не может превышать ``maxsplit``. По умолчанию разделяется вся строка, что в основном идентично :ref:`split()<class_StringName_method_split>`.
.. tabs::
.. code-tab:: gdscript
var some_string = "One,Two,Three,Four"
var some_array = some_string.rsplit(",", true, 1)
print(some_array.size()) # Выводит 2
print(some_array[0]) # Выводит "One,Two,Three"
print(some_array[1]) # Выводит "Four"
.. code-tab:: csharp
// В C# нет метода String.RSplit().
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_rstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_rstrip>`
Удаляет набор символов, определенных в ``chars``, из конца строки. См. также :ref:`lstrip()<class_StringName_method_lstrip>`.
\ **Примечание:** ``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://en.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://en.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://en.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://en.wikipedia.org/wiki/SHA-2>`__ хэш строки как еще один :ref:`String<class_String>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_similarity:
.. rst-class:: classref-method
:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_similarity>`
Возвращает индекс схожести (`коэффициент Сёренсена-Дайса <https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient>`__) этой строки по сравнению с другой. Результат ``1.0`` означает полное сходство, а ``0.0`` означает полное несходство.
::
print("ABC123".similarity("ABC123")) # Выводит 1.0
print("ABC123".similarity("XYZ456")) # Выводит 0.0
print("ABC123".similarity("123ABC")) # Выводит 0.8
print("ABC123".similarity("abc123")) # Выводит 0.4
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_simplify_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_simplify_path>`
Если строка является допустимым путем к файлу, преобразует строку в канонический путь. Это кратчайший возможный путь, без ``"./"`` и всех ненужных ``".."`` и ``"/"``.
::
var simple_path = "./path/to///../file".simplify_path()
print(simple_path) # Выводит "path/file"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_split:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **split**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_split>`
Разделяет строку с помощью ``delimiter`` и возвращает массив подстрок. Если ``delimiter`` — пустая строка, каждая подстрока будет одним символом. Этот метод противоположен :ref:`join()<class_StringName_method_join>`.
Если ``allow_empty`` — ``false``, пустые строки между соседними разделителями исключаются из массива.
Если ``maxsplit`` больше ``0``, количество разделений не может превышать ``maxsplit``. По умолчанию разделяется вся строка.
.. tabs::
.. code-tab:: gdscript
var some_array = "One,Two,Three,Four".split(",", true, 2)
print(some_array.size()) # Выводит 3
print(some_array[0]) # Выводит "One"
print(some_array[1]) # Выводит "Two"
print(some_array[2]) # Выводит "Three,Four"
.. code-tab:: csharp
// `Split()` в C# не поддерживает параметр `maxsplit`.
var someArray = "One,Two,Three".Split(",");
GD.Print(someArray[0]); // Выводит "One"
GD.Print(someArray[1]); // Выводит "Two"
GD.Print(someArray[2]); // Выводит "Three"
\ **Примечание:** Если вам нужна только одна подстрока из массива, рассмотрите возможность использования :ref:`get_slice()<class_StringName_method_get_slice>`, который быстрее. Если вам нужно разделить строки с более сложными правилами, используйте вместо этого класс :ref:`RegEx<class_RegEx>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_split_floats:
.. rst-class:: classref-method
:ref:`PackedFloat64Array<class_PackedFloat64Array>` **split_floats**\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_split_floats>`
Разделяет строку на числа с плавающей точкой с помощью ``delimiter`` и возвращает :ref:`PackedFloat64Array<class_PackedFloat64Array>`.
Если ``allow_empty`` равен ``false``, пустые или недействительные преобразования :ref:`float<class_float>` между соседними разделителями исключаются.
::
var a = "1,2,4.5".split_floats(",") # a равен [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c равен [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b равен [1.0, 4.5]
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_strip_edges:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_edges**\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_strip_edges>`
Удаляет все непечатаемые символы из начала и конца строки. К ним относятся пробелы, табуляции (``\t``) и переводы строк (``\n`` ``\r``).
Если ``left`` равен ``false``, игнорирует начало строки. Аналогично, если ``right`` равен ``false``, игнорирует конец строки.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_strip_escapes:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_StringName_method_strip_escapes>`
Удаляет все экранированные символы из строки. К ним относятся все непечатаемые управляющие символы первой страницы таблицы ASCII (значения от 0 до 31), такие как символы табуляции (``\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://en.wikipedia.org/wiki/ASCII>`__/Latin-1 закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Этот метод немного быстрее, чем :ref:`to_utf8_buffer()<class_StringName_method_to_utf8_buffer>`, но заменяет все неподдерживаемые символы пробелами. Это обратный метод :ref:`PackedByteArray.get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_camel_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_camel_case>`
Возвращает строку, преобразованную в ``camelCase``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_float>`
Преобразует строку, представляющую десятичное число, в :ref:`float<class_float>`. Этот метод останавливается на первом нечисловом символе, за исключением первой десятичной точки (``.``) и буквы экспоненты (``e``). См. также :ref:`is_valid_float()<class_StringName_method_is_valid_float>`.
::
var a = "12.35".to_float() # a равен 12.35
var b = "1.2.3".to_float() # b равен 1.2
var c = "12xy3".to_float() # c равен 12.0
var d = "1e3".to_float() # d равен 1000.0
var e = "Hello!".to_float() # e равен 0.0
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_int>`
Преобразует строку, представляющую целое число, в :ref:`int<class_int>`. Этот метод удаляет все нечисловые символы и останавливается на первой десятичной точке (``.``). См. также :ref:`is_valid_int()<class_StringName_method_is_valid_int>`.
::
var a = "123".to_int() # a равен 123
var b = "x1y2z3".to_int() # b равен 123
var c = "-1.2.3".to_int() # c равен -1
var d = "Hello!".to_int() # d равен 0
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_kebab_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_kebab_case>`
Возвращает строку, преобразованную в ``kebab-case``.
\ **Примечание:** Цифры, за которыми следует *одна* буква, не разделяются при преобразовании, чтобы сохранить некоторые слова (например, «2D») вместе.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_kebab_case() # Возвращает "node-2d"
"2nd place".to_kebab_case() # Возвращает "2-nd-place"
"Texture3DAssetFolder".to_kebab_case() # Возвращает "texture-3d-asset-folder"
.. code-tab:: csharp
"Node2D".ToKebabCase(); // Возвращает "node-2d"
"2nd place".ToKebabCase(); // Возвращает "2-nd-place"
"Texture3DAssetFolder".ToKebabCase(); // Возвращает "texture-3d-asset-folder"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_lower:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_lower>`
Возвращает строку, преобразованную в ``строчную``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_multibyte_char_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_StringName_method_to_multibyte_char_buffer>`
Преобразует строку в системную многобайтовую кодовую страницу, закодированную в :ref:`PackedByteArray<class_PackedByteArray>`. Если преобразование не удалось, возвращается пустой массив.
Допустимые значения для ``encoding`` зависят от системы. Если ``encoding`` — пустая строка, используется системная кодировка по умолчанию.
- Для Windows см. `Идентификаторы кодовых страниц <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ .NET-имена.
- Для macOS и Linux/BSD см. документацию библиотеки ``libiconv`` и ``iconv --list`` для списка поддерживаемых кодировок.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_pascal_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_pascal_case>`
Возвращает строку, преобразованную в ``PascalCase``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_snake_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_snake_case>`
Возвращает строку, преобразованную в ``snake_case``.
\ **Примечание:** Цифры, за которыми следует *одна* буква, не разделяются при преобразовании, чтобы сохранить некоторые слова (например, «2D») вместе.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_snake_case() # Выводит "node_2d"
"2nd place".to_snake_case() # Выводит "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # Выводит "texture_3d_asset_folder"
.. code-tab:: csharp
"Node2D".ToSnakeCase(); // Выводит "node_2d"
"2nd place".ToSnakeCase(); // Выводит "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // Выводит "texture_3d_asset_folder"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_upper:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_upper>`
Возвращает строку, преобразованную в ``ВЕРХНИЙ РЕГИСТР``.
.. 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://en.wikipedia.org/wiki/UTF-8>`__ закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Этот метод немного медленнее, чем :ref:`to_ascii_buffer()<class_StringName_method_to_ascii_buffer>`, но поддерживает все символы UTF-8. В большинстве случаев предпочтительнее использовать этот метод. Это обратный метод :ref:`PackedByteArray.get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf16_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf16_buffer>`
Преобразует строку в `UTF-16 <https://en.wikipedia.org/wiki/UTF-16>`__ закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Это обратный метод :ref:`PackedByteArray.get_string_from_utf16()<class_PackedByteArray_method_get_string_from_utf16>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf32_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf32_buffer>`
Преобразует строку в `UTF-32 <https://en.wikipedia.org/wiki/UTF-32>`__ закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Это обратный метод :ref:`PackedByteArray.get_string_from_utf32()<class_PackedByteArray_method_get_string_from_utf32>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_wchar_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_wchar_buffer>`
Преобразует строку в `широкий символ <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 в Windows, UTF-32 на других платформах), закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Это обратный метод :ref:`PackedByteArray.get_string_from_wchar()<class_PackedByteArray_method_get_string_from_wchar>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_trim_prefix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_prefix>`
Удаляет указанный ``prefix`` из начала строки или возвращает строку без изменений.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_trim_suffix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_suffix>`
Удаляет указанный ``suffix`` из конца строки или возвращает строку без изменений.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_unicode_at:
.. rst-class:: classref-method
:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_unicode_at>`
Возвращает код символа в позиции ``at``.
См. также :ref:`String.chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` и :ref:`@GDScript.ord()<class_@GDScript_method_ord>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_decode>`
Декодирует строку из ее URL-кодированного формата. Этот метод предназначен для правильного декодирования параметров в URL при получении HTTP-запроса. См. также :ref:`uri_encode()<class_StringName_method_uri_encode>`.
.. tabs::
.. code-tab:: gdscript
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
print(url.uri_decode()) # Выводит "$DOCS_URL/?highlight=Godot Engine:docs"
.. code-tab:: csharp
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // Выводит "$DOCS_URL/?highlight=Godot Engine:docs"
\ **Примечание:** Этот метод декодирует ``+`` как пробел.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_encode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_encode>`
Кодирует строку в формат, удобный для URL. Этот метод предназначен для правильного кодирования параметров в URL при отправке HTTP-запроса. См. также :ref:`uri_decode()<class_StringName_method_uri_decode>`.
.. tabs::
.. code-tab:: gdscript
var prefix = "$DOCS_URL/?highlight="
var url = prefix + "Godot Engine:docs".uri_encode()
print(url) # Выводит "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
.. code-tab:: csharp
var prefix = "$DOCS_URL/?highlight=";
var url = prefix + "Godot Engine:docs".URIEncode();
GD.Print(url); // Выводит "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_uri_file_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_file_decode>`
Декодирует путь к файлу из его URL-кодированного формата. В отличие от :ref:`uri_decode()<class_StringName_method_uri_decode>` этот метод оставляет ``+`` как есть.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_filename:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_filename>`
Возвращает копию строки, в которой все символы, недопустимые в :ref:`is_valid_filename()<class_StringName_method_is_valid_filename>`, заменены на подчеркивания.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_node_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_node_name>`
Возвращает копию строки, в которой все символы, недопустимые в :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``), заменены на подчеркивания.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_xml_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_xml_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта XML. Если ``escape_quotes`` равен ``true``, символы одинарной кавычки (``'``) и двойной кавычки (``"``) также экранируются.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_xml_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_xml_unescape>`
Возвращает копию строки, в которой экранированные символы заменены их значениями в соответствии со стандартом XML.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания оператора
------------------------------------
.. _class_StringName_operator_neq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_neq_String>`
Возвращает ``true``, если **StringName** не эквивалентно заданной :ref:`String<class_String>`.
.. 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>`
Возвращает ``true``, если **StringName** и ``right`` не ссылаются на одно и то же имя. Сравнения между **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**, заменяя заполнители (placeholders) одним или несколькими параметрами, возвращая :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>`
Возвращает ``true``, если указатель left **StringName** находится перед ``right``. Обратите внимание, что это не будет соответствовать их `порядку Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
.. 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>`
Возвращает ``true``, если указатель left **StringName** предшествует ``right`` или если они одинаковы. Обратите внимание, что это не будет соответствовать их `порядку Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
.. 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>`
Возвращает ``true``, если **StringName** эквивалентно заданной :ref:`String<class_String>`.
.. 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>`
Возвращает ``true``, если **StringName** и ``right`` ссылаются на одно и то же имя. Сравнения между **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>`
Возвращает ``true``, если указатель left **StringName** находится после ``right``. Обратите внимание, что это не будет соответствовать их `порядку Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
.. 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>`
Возвращает ``true``, если указатель left **StringName** следует за ``right`` или они одинаковы. Обратите внимание, что это не будет соответствовать их `порядку Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
.. |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