godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2025-12-31 09:49:22 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/ru/class_string.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

2504 lines
163 KiB
ReStructuredText
Raw Permalink Blame History

This file contains ambiguous Unicode characters

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

:github_url: hide
.. _class_String:
String
======
Встроенный тип для строк.
.. rst-class:: classref-introduction-group
Описание
----------------
Это встроенный тип строки Variant (используемый GDScript). Строки могут содержать любое количество символов Unicode и предоставлять методы, полезные для манипулирования и генерации строк. Строки подсчитываются по ссылкам и используют подход копирования при записи (каждая модификация строки возвращает новую **String**), поэтому их передача обходится дешево с точки зрения ресурсов.
Некоторые строковые методы имеют соответствующие вариации. Вариации с суффиксом ``n`` (:ref:`countn()<class_String_method_countn>`, :ref:`findn()<class_String_method_findn>`, :ref:`replacen()<class_String_method_replacen>` и т. д.) **нечувствительны к регистру** (они не различают заглавные и строчные буквы). Вариации методов с префиксом ``r`` (:ref:`rfind()<class_String_method_rfind>`, :ref:`rsplit()<class_String_method_rsplit>` и т. д.) меняются местами и начинаются с конца строки, а не с начала.
Чтобы преобразовать любой :ref:`Variant<class_Variant>` в строку или из нее, см. :ref:`@GlobalScope.str()<class_@GlobalScope_method_str>`, :ref:`@GlobalScope.str_to_var()<class_@GlobalScope_method_str_to_var>` и :ref:`@GlobalScope.var_to_str()<class_@GlobalScope_method_var_to_str>`.
\ **Примечание:** В булевом контексте строка будет оцениваться как ``false``, если она пустая (``""``). В противном случае строка всегда будет оцениваться как ``true``.
.. note::
Существуют заметные различия при использовании данного API с C#. Подробнее см. :ref:`doc_c_sharp_differences`.
.. rst-class:: classref-introduction-group
Обучающие материалы
--------------------------------------
- :doc:`Форматирование строки GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`
.. rst-class:: classref-reftable-group
Конструкторы
------------------------
.. table::
:widths: auto
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`String<class_String>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`NodePath<class_NodePath>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Методы
------------
.. table::
:widths: auto
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`begins_with<class_String_method_begins_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`bigrams<class_String_method_bigrams>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bin_to_int<class_String_method_bin_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_escape<class_String_method_c_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_unescape<class_String_method_c_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`capitalize<class_String_method_capitalize>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`casecmp_to<class_String_method_casecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`chr<class_String_method_chr>`\ (\ code\: :ref:`int<class_int>`\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`contains<class_String_method_contains>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`containsn<class_String_method_containsn>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_String_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_String_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_String_method_dedent>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`ends_with<class_String_method_ends_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`erase<class_String_method_erase>`\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filecasecmp_to<class_String_method_filecasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filenocasecmp_to<class_String_method_filenocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_String_method_find>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`findn<class_String_method_findn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`format<class_String_method_format>`\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_base_dir<class_String_method_get_base_dir>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_basename<class_String_method_get_basename>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_extension<class_String_method_get_extension>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_file<class_String_method_get_file>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slice<class_String_method_get_slice>`\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_slice_count<class_String_method_get_slice_count>`\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slicec<class_String_method_get_slicec>`\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hash<class_String_method_hash>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`hex_decode<class_String_method_hex_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hex_to_int<class_String_method_hex_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`humanize_size<class_String_method_humanize_size>`\ (\ size\: :ref:`int<class_int>`\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`indent<class_String_method_indent>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`insert<class_String_method_insert>`\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_absolute_path<class_String_method_is_absolute_path>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_String_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_relative_path<class_String_method_is_relative_path>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_of<class_String_method_is_subsequence_of>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_ofn<class_String_method_is_subsequence_ofn>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ascii_identifier<class_String_method_is_valid_ascii_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_filename<class_String_method_is_valid_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_float<class_String_method_is_valid_float>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_hex_number<class_String_method_is_valid_hex_number>`\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_html_color<class_String_method_is_valid_html_color>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_identifier<class_String_method_is_valid_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_int<class_String_method_is_valid_int>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ip_address<class_String_method_is_valid_ip_address>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_unicode_identifier<class_String_method_is_valid_unicode_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`join<class_String_method_join>`\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`json_escape<class_String_method_json_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`left<class_String_method_left>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`length<class_String_method_length>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lpad<class_String_method_lpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lstrip<class_String_method_lstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`match<class_String_method_match>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`matchn<class_String_method_matchn>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`md5_buffer<class_String_method_md5_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`md5_text<class_String_method_md5_text>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalcasecmp_to<class_String_method_naturalcasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalnocasecmp_to<class_String_method_naturalnocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`nocasecmp_to<class_String_method_nocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`num<class_String_method_num>`\ (\ number\: :ref:`float<class_float>`, decimals\: :ref:`int<class_int>` = -1\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`num_int64<class_String_method_num_int64>`\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`num_scientific<class_String_method_num_scientific>`\ (\ number\: :ref:`float<class_float>`\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`num_uint64<class_String_method_num_uint64>`\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_decimals<class_String_method_pad_decimals>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_zeros<class_String_method_pad_zeros>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`path_join<class_String_method_path_join>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_char<class_String_method_remove_char>`\ (\ what\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_chars<class_String_method_remove_chars>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`repeat<class_String_method_repeat>`\ (\ count\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace<class_String_method_replace>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_char<class_String_method_replace_char>`\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_chars<class_String_method_replace_chars>`\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replacen<class_String_method_replacen>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`reverse<class_String_method_reverse>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_String_method_rfind>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfindn<class_String_method_rfindn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`right<class_String_method_right>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`rpad<class_String_method_rpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`rsplit<class_String_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_String_method_rstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha1_buffer<class_String_method_sha1_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha1_text<class_String_method_sha1_text>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha256_buffer<class_String_method_sha256_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha256_text<class_String_method_sha256_text>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`similarity<class_String_method_similarity>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`simplify_path<class_String_method_simplify_path>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`split<class_String_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_String_method_split_floats>`\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_edges<class_String_method_strip_edges>`\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_escapes<class_String_method_strip_escapes>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`substr<class_String_method_substr>`\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_ascii_buffer<class_String_method_to_ascii_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_camel_case<class_String_method_to_camel_case>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`to_float<class_String_method_to_float>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_int<class_String_method_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_kebab_case<class_String_method_to_kebab_case>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_lower<class_String_method_to_lower>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_multibyte_char_buffer<class_String_method_to_multibyte_char_buffer>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_pascal_case<class_String_method_to_pascal_case>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_snake_case<class_String_method_to_snake_case>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_upper<class_String_method_to_upper>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf8_buffer<class_String_method_to_utf8_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf16_buffer<class_String_method_to_utf16_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf32_buffer<class_String_method_to_utf32_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_wchar_buffer<class_String_method_to_wchar_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_prefix<class_String_method_trim_prefix>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_suffix<class_String_method_trim_suffix>`\ (\ suffix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`unicode_at<class_String_method_unicode_at>`\ (\ at\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_decode<class_String_method_uri_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_encode<class_String_method_uri_encode>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_file_decode<class_String_method_uri_file_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_filename<class_String_method_validate_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_node_name<class_String_method_validate_node_name>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_escape<class_String_method_xml_escape>`\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_unescape<class_String_method_xml_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Операторы
------------------
.. table::
:widths: auto
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_String_operator_neq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_String_operator_neq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator %<class_String_operator_mod_Variant>`\ (\ right\: :ref:`Variant<class_Variant>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_String_operator_sum_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_String_operator_sum_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_String_operator_lt_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_String_operator_lte_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_String_operator_eq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_String_operator_eq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_String_operator_gt_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_String_operator_gte_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator []<class_String_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ ) |
+-----------------------------+-------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания конструктора
------------------------------------------
.. _class_String_constructor_String:
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ ) :ref:`🔗<class_String_constructor_String>`
Создает пустой **String** (``""``).
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`String<class_String>`\ )
Создает **String** как копию заданной **String**.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`NodePath<class_NodePath>`\ )
Создает новый **String** из заданного :ref:`NodePath<class_NodePath>`.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`StringName<class_StringName>`\ )
Создает новый **String** из заданной :ref:`StringName<class_StringName>`.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания метода
------------------------------
.. _class_String_method_begins_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **begins_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_begins_with>`
Возвращает ``true``, если строка начинается с указанного ``text``. См. также :ref:`ends_with()<class_String_method_ends_with>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_bigrams:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **bigrams**\ (\ ) |const| :ref:`🔗<class_String_method_bigrams>`
Возвращает массив, содержащий биграммы (пары последовательных символов) данной строки.
::
print("Get up!".bigrams()) # Prints ["Ge", "et", "t ", " u", "up", "p!"]
.. rst-class:: classref-item-separator
----
.. _class_String_method_bin_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_c_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_String_method_c_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта языка C.
.. rst-class:: classref-item-separator
----
.. _class_String_method_c_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_String_method_c_unescape>`
Возвращает копию строки с экранированными символами, замененными их значениями. Поддерживаемые экранированные последовательности: ``\'``, ``\"``, ``\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.
\ **Примечание:** В отличие от парсера GDScript, этот метод не поддерживает экранированную последовательность ``\uXXXX``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_capitalize:
.. rst-class:: classref-method
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_casecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>` и :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_chr:
.. rst-class:: classref-method
:ref:`String<class_String>` **chr**\ (\ code\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_String_method_chr>`
Возвращает один символ Unicode из целого числа ``code``. В качестве отправной точки можно использовать `unicodelookup.com <https://unicodelookup.com/>`__ или `unicode.org <https://www.unicode.org/charts/>`__.
::
print(String.chr(65)) # Выводит "A"
print(String.chr(129302)) # Выводит "🤖" (эмодзи с лицом робота)
См. также :ref:`unicode_at()<class_String_method_unicode_at>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` и :ref:`@GDScript.ord()<class_@GDScript_method_ord>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_contains:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_find>`. См. также :ref:`containsn()<class_String_method_containsn>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_containsn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_containsn>`
Возвращает ``true``, если строка содержит ``what``, **игнорируя регистр**.
Если вам нужно узнать, где находится ``what`` в строке, используйте :ref:`findn()<class_String_method_findn>`. См. также :ref:`contains()<class_String_method_contains>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_count>`
Возвращает количество вхождений подстроки ``what`` между позициями ``from`` и ``to``. Если ``to`` равен 0, поиск продолжается до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_countn>`
Возвращает количество вхождений подстроки ``what`` между позициями ``from`` и ``to``, **без учета регистра**. Если ``to`` равен 0, поиск продолжается до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_String_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_String_method_dedent>`
Возвращает копию строки с удаленным отступом (начальные табуляции и пробелы). См. также :ref:`indent()<class_String_method_indent>` для добавления отступа.
.. rst-class:: classref-item-separator
----
.. _class_String_method_ends_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_ends_with>`
Возвращает ``true``, если строка заканчивается указанным ``text``. См. также :ref:`begins_with()<class_String_method_begins_with>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_erase>`
Возвращает строку с стертыми ``chars`` символами, начиная с ``position``. Если ``chars`` превышает длину строки, заданную ``position``, из возвращаемой строки будет стерто меньше символов. Возвращает пустую строку, если ``position`` или ``chars`` отрицательны. Возвращает исходную строку без изменений, если ``chars`` равен ``0``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_filecasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_filecasecmp_to>`
Как :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, но отдает приоритет строкам, начинающимся с точек (``.``) и подчеркиваний (``_``) перед любым другим символом. Полезно при сортировке папок или имен файлов.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` и :ref:`casecmp_to()<class_String_method_casecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_filenocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_filenocasecmp_to>`
Как :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, но отдает приоритет строкам, начинающимся с точек (``.``) и подчеркиваний (``_``) перед любым другим символом. Полезно при сортировке папок или имен файлов.
Чтобы получить результат :ref:`bool<class_bool>` из сравнения строк, используйте вместо этого оператор ``==``. См. также :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` и :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_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_String_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_String_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_String_method_findn>`
Возвращает индекс **первого** **регистронезависимого** вхождения ``what`` в этой строке или ``-1``, если их нет. Начальный индекс поиска можно указать с помощью ``from``, продолжая до конца строки.
.. rst-class:: classref-item-separator
----
.. _class_String_method_format:
.. rst-class:: classref-method
:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_String_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_String_method_get_base_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_String_method_get_base_dir>`
Если строка является допустимым путем к файлу, возвращает имя базового каталога.
::
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path равен "/path/to"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_String_method_get_basename>`
Если строка является допустимым путем к файлу, возвращает полный путь к файлу без расширения.
::
var base = "/path/to/file.txt".get_basename() # base равен "/path/to/file"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_extension:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_get_file:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_String_method_get_file>`
Если строка является допустимым путем к файлу, возвращает имя файла, включая расширение.
::
var file = "/path/to/icon.png".get_file() # file равен "icon.png"
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_get_slice>`
Splits the string using a ``delimiter`` and returns the substring at index ``slice``. Returns the original string if ``delimiter`` does not occur in the string. Returns an empty string if the ``slice`` does not exist.
This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.
::
print("i/am/example/hi".get_slice("/", 2)) # Prints "example"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_slice_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_get_slice_count>`
Returns the total number of slices when the string is split with the given ``delimiter`` (see :ref:`split()<class_String_method_split>`).
Use :ref:`get_slice()<class_String_method_get_slice>` to extract a specific slice.
::
print("i/am/example/string".get_slice_count("/")) # Prints '4'.
print("i am example string".get_slice_count("/")) # Prints '1'.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_get_slicec>`
Splits the string using a Unicode character with code ``delimiter`` and returns the substring at index ``slice``. Returns an empty string if the ``slice`` does not exist.
This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.
This is a Unicode version of :ref:`get_slice()<class_String_method_get_slice>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_String_method_hash>`
Возвращает 32-битное хэш-значение, представляющее содержимое строки.
\ **Примечание:** Строки с одинаковыми хэш-значениями *не* гарантированно будут одинаковыми из-за коллизий хэшей. Напротив, строки с разными хэш-значениями гарантированно будут разными.
.. rst-class:: classref-item-separator
----
.. _class_String_method_hex_decode:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_hex_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_humanize_size:
.. rst-class:: classref-method
:ref:`String<class_String>` **humanize_size**\ (\ size\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_String_method_humanize_size>`
Преобразует ``size``, представляющий количество байтов, в удобочитаемую форму.
Результат находится в `формате префикса IEC <https://en.wikipedia.org/wiki/Binary_prefix#IEC_prefixes>`__, который может заканчиваться на ``"B"``, ``"KiB"``, ``"MiB"``, ``"GiB"``, ``"TiB"``, ``"PiB"`` или ``"EiB"``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_indent:
.. rst-class:: classref-method
:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_indent>`
Делает отступ каждой строки с заданным ``prefix``. Пустые строки не имеют отступа. См. также :ref:`dedent()<class_String_method_dedent>` для удаления отступа.
Например, отступ строки можно сделать двумя табуляциями с помощью ``"\t\t"`` или четырьмя пробелами с помощью ``" "``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_insert:
.. rst-class:: classref-method
:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_insert>`
Вставляет ``what`` в указанную ``position`` в строке.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_absolute_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_absolute_path**\ (\ ) |const| :ref:`🔗<class_String_method_is_absolute_path>`
Возвращает ``true``, если строка является путем к файлу или каталогу, и его начальная точка явно определена. Этот метод противоположен :ref:`is_relative_path()<class_String_method_is_relative_path>`.
Это включает все пути, начинающиеся с ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"`` и т. д.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_String_method_is_empty>`
Возвращает ``true``, если длина строки равна ``0`` (``""``), то есть пуста. См. также :ref:`length()<class_String_method_length>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_relative_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_relative_path**\ (\ ) |const| :ref:`🔗<class_String_method_is_relative_path>`
Возвращает ``true``, если строка является путем, и ее начальная точка зависит от контекста. Путь может начинаться с текущего каталога или текущего :ref:`Node<class_Node>` (если строка получена из :ref:`NodePath<class_NodePath>`), и иногда может иметь префикс ``"./"``. Этот метод противоположен :ref:`is_absolute_path()<class_String_method_is_absolute_path>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_subsequence_of:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_of**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_is_subsequence_of>`
Возвращает ``true``, если все символы этой строки можно найти в ``text`` в их исходном порядке. Это не то же самое, что :ref:`contains()<class_String_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_String_method_is_subsequence_ofn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_is_subsequence_ofn>`
Возвращает ``true``, если все символы этой строки можно найти в ``text`` в их исходном порядке, **игнорируя регистр**. Это не то же самое, что и :ref:`containsn()<class_String_method_containsn>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_valid_ascii_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_is_valid_unicode_identifier>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_valid_filename:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_filename>`
Возвращает ``true``, если эта строка является допустимым именем файла. Допустимое имя файла не может быть пустым, начинаться или заканчиваться пробелами или содержать недопустимые символы (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_valid_float:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_float>`
Возвращает ``true``, если эта строка представляет допустимое число с плавающей точкой. Допустимое число с плавающей точкой может содержать только цифры, одну десятичную точку (``.``) и букву экспоненты (``e``). Оно также может иметь префикс в виде положительного (``+``) или отрицательного (``-``) знака. Любое допустимое целое число также является допустимым числом с плавающей точкой (см. :ref:`is_valid_int()<class_String_method_is_valid_int>`). См. также :ref:`to_float()<class_String_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_String_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_String_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_String_method_is_valid_html_color:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_html_color>`
Возвращает ``true``, если эта строка является допустимым цветом в шестнадцатеричной нотации HTML. Строка должна быть шестнадцатеричным значением (см. :ref:`is_valid_hex_number()<class_String_method_is_valid_hex_number>`) из 3, 4, 6 или 8 цифр и может иметь префикс в виде знака решетки (``#``). Другие нотации HTML для цветов, такие как имена или ``hsl()``, не считаются допустимыми. См. также :ref:`Color.html()<class_Color_method_html>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_valid_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_identifier**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_identifier>`
**Устарело:** Use :ref:`is_valid_ascii_identifier()<class_String_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_String_method_is_valid_int:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_int**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_int>`
Возвращает ``true``, если эта строка представляет допустимое целое число. Допустимое целое число содержит только цифры и может иметь префикс в виде положительного (``+``) или отрицательного (``-``) знака. См. также :ref:`to_int()<class_String_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_String_method_is_valid_ip_address:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_is_valid_unicode_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_is_valid_ascii_identifier>`.
\ **Примечание:** Этот метод проверяет идентификаторы так же, как GDScript. См. :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` для более сложных проверок.
.. rst-class:: classref-item-separator
----
.. _class_String_method_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_String_method_join>`
Возвращает цепочку элементов ``parts``', где каждый элемент разделен строкой, вызывающей этот метод. Этот метод противоположен :ref:`split()<class_String_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_String_method_json_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_String_method_json_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта JSON. Поскольку он близко соответствует стандарту C, можно использовать :ref:`c_unescape()<class_String_method_c_unescape>` для деэкранирования строки, если это необходимо.
.. rst-class:: classref-item-separator
----
.. _class_String_method_left:
.. rst-class:: classref-method
:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_left>`
Возвращает первые ``length`` символы из начала строки. Если ``length`` отрицательный, удаляет последние ``length`` символы из конца строки.
::
print("Hello World!".left(3)) # Выводит "Hel"
print("Hello World!".left(-4)) # Выводит "Hello Wo"
.. rst-class:: classref-item-separator
----
.. _class_String_method_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_String_method_length>`
Возвращает количество символов в строке. Пустые строки (``""``) всегда возвращают ``0``. См. также :ref:`is_empty()<class_String_method_is_empty>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_lpad>`
Форматирует строку так, чтобы она была длиной не менее ``min_length``, добавляя ``character`` слева от строки, если необходимо. См. также :ref:`rpad()<class_String_method_rpad>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_lstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **lstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_lstrip>`
Удаляет набор символов, определенных в ``chars``, из начала строки. См. также :ref:`rstrip()<class_String_method_rstrip>`.
\ **Примечание:** ``chars`` не является префиксом. Используйте :ref:`trim_prefix()<class_String_method_trim_prefix>`, чтобы удалить один префикс, а не набор символов.
.. rst-class:: classref-item-separator
----
.. _class_String_method_match:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **match**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_match>`
Соответствует ли простое выражение (также называемое «глоб» или «глоббинг»), где ``*`` соответствует нулю или более произвольным символам, а ``?`` соответствует любому одиночному символу, кроме точки (``.``). Пустая строка или пустое выражение всегда оценивается как ``false``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_matchn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **matchn**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_matchn>`
Соответствует ли простое **выражение без учета регистра**, где ``*`` соответствует нулю или более произвольным символам, а ``?`` соответствует любому одиночному символу, кроме точки (``.``). Пустая строка или пустое выражение всегда оцениваются как ``false``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_md5_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_md5_buffer>`
Возвращает `MD5-хэш <https://en.wikipedia.org/wiki/MD5>`__ строки в виде :ref:`PackedByteArray<class_PackedByteArray>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_md5_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **md5_text**\ (\ ) |const| :ref:`🔗<class_String_method_md5_text>`
Возвращает `MD5-хэш <https://en.wikipedia.org/wiki/MD5>`__ строки как другую **String**.
.. rst-class:: classref-item-separator
----
.. _class_String_method_naturalcasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>` и :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_naturalnocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>` и :ref:`casecmp_to()<class_String_method_casecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_nocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>` и :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_num:
.. rst-class:: classref-method
:ref:`String<class_String>` **num**\ (\ number\: :ref:`float<class_float>`, decimals\: :ref:`int<class_int>` = -1\ ) |static| :ref:`🔗<class_String_method_num>`
Преобразует :ref:`float<class_float>` в строковое представление десятичного числа с количеством десятичных знаков, указанным в ``decimals``.
Если ``decimals`` равен ``-1`` по умолчанию, строковое представление может иметь только до 14 значащих цифр, причем цифры до десятичной точки имеют приоритет над цифрами после нее.
Завершающие нули не включаются в строку. Последняя цифра округляется, а не усекается.
::
String.num(3.141593) # Выводит "3.141593"
String.num(3.141593, 3) # Выводит "3.142"
String.num(3.14159300) # Выводит "3.141593"
# Здесь последняя цифра будет округлена в большую сторону,
# что уменьшает общее количество цифр, поскольку конечные нули удаляются:
String.num(42.129999, 5) # Выводит "42.13"
# Если `decimals` не указано, максимальное количество значащих цифр равно 14:
String.num(-0.0000012345432123454321) # Выводит "-0.00000123454321"
String.num(-10000.0000012345432123454321) # Выводит "-10000.0000012345"
.. rst-class:: classref-item-separator
----
.. _class_String_method_num_int64:
.. rst-class:: classref-method
:ref:`String<class_String>` **num_int64**\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| :ref:`🔗<class_String_method_num_int64>`
Преобразует заданный ``number`` в строковое представление с заданным ``base``.
По умолчанию ``base`` установлен на десятичное (``10``). Другие распространенные основания в программировании включают двоичное (``2``), `восьмеричное <https://en.wikipedia.org/wiki/Octal>`__ (``8``), шестнадцатеричное (``16``).
Если ``capitalize_hex`` равен ``true``, цифры выше 9 представлены в верхнем регистре.
.. rst-class:: classref-item-separator
----
.. _class_String_method_num_scientific:
.. rst-class:: classref-method
:ref:`String<class_String>` **num_scientific**\ (\ number\: :ref:`float<class_float>`\ ) |static| :ref:`🔗<class_String_method_num_scientific>`
Преобразует заданный ``number`` в строковое представление в научной нотации.
.. tabs::
.. code-tab:: gdscript
var n = -5.2e8
print(n) # Выводит -520000000
print(String.num_scientific(n)) # Выводит -5.2e+08
.. code-tab:: csharp
// Этот метод не реализован в C#.
// Используйте `string.ToString()` с "e" для достижения аналогичных результатов.
var n = -5.2e8f;
GD.Print(n); // Выводит -520000000
GD.Print(n.ToString("e1")); // Выводит -5.2e+008
\ **Примечание:** В C# этот метод не реализован. Чтобы добиться похожих результатов, см. `Стандартные числовые форматы строк C# <https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings>`__.
.. rst-class:: classref-item-separator
----
.. _class_String_method_num_uint64:
.. rst-class:: classref-method
:ref:`String<class_String>` **num_uint64**\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| :ref:`🔗<class_String_method_num_uint64>`
Преобразует заданное беззнаковое (unsigned) :ref:`int<class_int>` в строковое представление с заданным ``base``.
По умолчанию ``base`` установлено в десятичное (``10``). Другие распространенные основания в программировании включают двоичное (``2``), `восьмеричное <https://en.wikipedia.org/wiki/Octal>`__ (``8``), шестнадцатеричное (``16``).
Если ``capitalize_hex`` равно ``true``, цифры выше 9 представлены в верхнем регистре.
.. rst-class:: classref-item-separator
----
.. _class_String_method_pad_decimals:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_pad_decimals>`
Форматирует строку, представляющую число, так, чтобы она содержала точное количество цифр ``digits`` *после* десятичной точки.
.. rst-class:: classref-item-separator
----
.. _class_String_method_pad_zeros:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_pad_zeros>`
Форматирует строку, представляющую число, так, чтобы она содержала точное количество цифр ``digits`` *перед* десятичной точкой.
.. rst-class:: classref-item-separator
----
.. _class_String_method_path_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_path_join>`
Объединяет ``path`` в конце строки как подпуть, добавляя ``/`` при необходимости.
\ **Пример:** ``"this/is".path_join("path") == "this/is/path"``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_remove_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_remove_char>`
Удаляет все вхождения символа Unicode с кодом ``what``. Более быстрая версия :ref:`replace()<class_String_method_replace>`, когда ключ состоит только из одного символа, а замена — ``""``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_String_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_repeat>`
Повторяет эту строку несколько раз. ``count`` должно быть больше, чем ``0``. В противном случае возвращает пустую строку.
.. rst-class:: classref-item-separator
----
.. _class_String_method_replace:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_replace>`
Заменяет все вхождения ``what`` внутри строки на указанный ``forwhat``.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_replace_char>`
Заменяет все вхождения символа Unicode с кодом ``key`` на символ Unicode с кодом ``with``. Более быстрая версия метода :ref:`replace()<class_String_method_replace>`, когда ключ состоит всего из одного символа. Чтобы получить один символ, используйте ``"X".unicode_at(0)`` (обратите внимание, что некоторые строки, например, составные буквы и эмодзи, могут состоять из нескольких кодовых точек Unicode и не будут работать с этим методом, используйте :ref:`length()<class_String_method_length>` для уверенности).
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_replace_chars>`
Заменяет все вхождения символов в ``keys`` на символ Unicode с кодом ``with``. См. также :ref:`replace_char()<class_String_method_replace_char>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_replacen:
.. rst-class:: classref-method
:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_replacen>`
Заменяет все **независимые от регистра** вхождения ``what`` внутри строки на заданный ``forwhat``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_String_method_reverse>`
Возвращает копию этой строки в обратном порядке. Эта операция работает с кодовыми точками Unicode, а не с последовательностями кодовых точек, и может сломать такие вещи, как составные буквы или эмодзи.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_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_String_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_String_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_String_method_rfindn>`
Возвращает индекс **последнего** **регистронезависимого** вхождения ``what`` в этой строке или ``-1``, если их нет. Начальный индекс поиска можно указать с помощью ``from``, продолжая до начала строки. Этот метод является обратным :ref:`findn()<class_String_method_findn>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_right:
.. rst-class:: classref-method
:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_right>`
Возвращает последние ``length`` символы с конца строки. Если ``length`` отрицательный, удаляет первые ``length`` символы с начала строки.
::
print("Hello World!".right(3)) # Выводит "ld!"
print("Hello World!".right(-4)) # Вывдит "o World!"
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_rpad>`
Форматирует строку так, чтобы она была длиной не менее ``min_length``, добавляя ``character`` справа от строки, если необходимо. См. также :ref:`lpad()<class_String_method_lpad>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_rsplit>`
Разделяет строку с помощью ``delimiter`` и возвращает массив подстрок, начиная с конца строки. Разделения в возвращаемом массиве отображаются в том же порядке, что и исходная строка. Если ``delimiter`` — пустая строка, каждая подстрока будет представлять собой один символ.
Если ``allow_empty`` — ``false``, пустые строки между соседними разделителями исключаются из массива.
Если ``maxsplit`` больше ``0``, количество разделений не может превышать ``maxsplit``. По умолчанию разделяется вся строка, что в основном идентично :ref:`split()<class_String_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_String_method_rstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_rstrip>`
Удаляет набор символов, определенных в ``chars``, из конца строки. См. также :ref:`lstrip()<class_String_method_lstrip>`.
\ **Примечание:** ``chars`` не является суффиксом. Используйте :ref:`trim_suffix()<class_String_method_trim_suffix>`, чтобы удалить один суффикс, а не набор символов.
.. rst-class:: classref-item-separator
----
.. _class_String_method_sha1_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_sha1_buffer>`
Возвращает `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ хэш строки в виде :ref:`PackedByteArray<class_PackedByteArray>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_sha1_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha1_text**\ (\ ) |const| :ref:`🔗<class_String_method_sha1_text>`
Возвращает `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ хэш строки как еще один **String**.
.. rst-class:: classref-item-separator
----
.. _class_String_method_sha256_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_sha256_buffer>`
Возвращает `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ хэш строки в виде :ref:`PackedByteArray<class_PackedByteArray>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_sha256_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_String_method_sha256_text>`
Возвращает `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ хэш строки как еще один **String**.
.. rst-class:: classref-item-separator
----
.. _class_String_method_similarity:
.. rst-class:: classref-method
:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_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_String_method_simplify_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_String_method_simplify_path>`
Если строка является допустимым путем к файлу, преобразует строку в канонический путь. Это кратчайший возможный путь, без ``"./"`` и всех ненужных ``".."`` и ``"/"``.
::
var simple_path = "./path/to///../file".simplify_path()
print(simple_path) # Выводит "path/file"
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_split>`
Разделяет строку с помощью ``delimiter`` и возвращает массив подстрок. Если ``delimiter`` — пустая строка, каждая подстрока будет одним символом. Этот метод противоположен :ref:`join()<class_String_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_String_method_get_slice>`, который быстрее. Если вам нужно разделить строки с более сложными правилами, используйте вместо этого класс :ref:`RegEx<class_RegEx>`.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_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_String_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_String_method_strip_edges>`
Удаляет все непечатаемые символы из начала и конца строки. К ним относятся пробелы, табуляции (``\t``) и переводы строк (``\n`` ``\r``).
Если ``left`` равен ``false``, игнорирует начало строки. Аналогично, если ``right`` равен ``false``, игнорирует конец строки.
.. rst-class:: classref-item-separator
----
.. _class_String_method_strip_escapes:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_String_method_strip_escapes>`
Удаляет все экранированные символы из строки. К ним относятся все непечатаемые управляющие символы первой страницы таблицы ASCII (значения от 0 до 31), такие как символы табуляции (``\t``) и новой строки (``\n``, ``\r``), но *не* пробелы.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_method_substr>`
Возвращает часть строки из позиции ``from`` с длиной ``len``. Если ``len`` равен ``-1`` (по умолчанию), возвращает остаток строки, начиная с указанной позиции.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_ascii_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_ascii_buffer>`
Преобразует строку в `ASCII <https://en.wikipedia.org/wiki/ASCII>`__/Latin-1 закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Этот метод немного быстрее, чем :ref:`to_utf8_buffer()<class_String_method_to_utf8_buffer>`, но заменяет все неподдерживаемые символы пробелами. Это обратный метод :ref:`PackedByteArray.get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_camel_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_camel_case>`
Возвращает строку, преобразованную в ``camelCase``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_String_method_to_float>`
Преобразует строку, представляющую десятичное число, в :ref:`float<class_float>`. Этот метод останавливается на первом нечисловом символе, за исключением первой десятичной точки (``.``) и буквы экспоненты (``e``). См. также :ref:`is_valid_float()<class_String_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_String_method_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_String_method_to_int>`
Преобразует строку, представляющую целое число, в :ref:`int<class_int>`. Этот метод удаляет все нечисловые символы и останавливается на первой десятичной точке (``.``). См. также :ref:`is_valid_int()<class_String_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_String_method_to_kebab_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_to_lower:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_String_method_to_lower>`
Возвращает строку, преобразованную в ``строчную``.
.. rst-class:: classref-item-separator
----
.. _class_String_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_String_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_String_method_to_pascal_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_pascal_case>`
Возвращает строку, преобразованную в ``PascalCase``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_snake_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_to_upper:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_String_method_to_upper>`
Возвращает строку, преобразованную в ``ВЕРХНИЙ РЕГИСТР``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_utf8_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf8_buffer>`
Преобразует строку в `UTF-8 <https://en.wikipedia.org/wiki/UTF-8>`__ закодированный :ref:`PackedByteArray<class_PackedByteArray>`. Этот метод немного медленнее, чем :ref:`to_ascii_buffer()<class_String_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_String_method_to_utf16_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_to_utf32_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_to_wchar_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_String_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_String_method_trim_prefix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_trim_prefix>`
Удаляет указанный ``prefix`` из начала строки или возвращает строку без изменений.
.. rst-class:: classref-item-separator
----
.. _class_String_method_trim_suffix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_trim_suffix>`
Удаляет указанный ``suffix`` из конца строки или возвращает строку без изменений.
.. rst-class:: classref-item-separator
----
.. _class_String_method_unicode_at:
.. rst-class:: classref-method
:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_unicode_at>`
Возвращает код символа в позиции ``at``.
См. также :ref:`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_String_method_uri_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_decode>`
Декодирует строку из ее URL-кодированного формата. Этот метод предназначен для правильного декодирования параметров в URL при получении HTTP-запроса. См. также :ref:`uri_encode()<class_String_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_String_method_uri_encode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_encode>`
Кодирует строку в формат, удобный для URL. Этот метод предназначен для правильного кодирования параметров в URL при отправке HTTP-запроса. См. также :ref:`uri_decode()<class_String_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_String_method_uri_file_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_file_decode>`
Декодирует путь к файлу из его URL-кодированного формата. В отличие от :ref:`uri_decode()<class_String_method_uri_decode>` этот метод оставляет ``+`` как есть.
.. rst-class:: classref-item-separator
----
.. _class_String_method_validate_filename:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_String_method_validate_filename>`
Возвращает копию строки, в которой все символы, недопустимые в :ref:`is_valid_filename()<class_String_method_is_valid_filename>`, заменены на подчеркивания.
.. rst-class:: classref-item-separator
----
.. _class_String_method_validate_node_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_String_method_validate_node_name>`
Возвращает копию строки, в которой все символы, недопустимые в :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``), заменены на подчеркивания.
.. rst-class:: classref-item-separator
----
.. _class_String_method_xml_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_String_method_xml_escape>`
Возвращает копию строки со специальными символами, экранированными с использованием стандарта XML. Если ``escape_quotes`` равен ``true``, символы одинарной кавычки (``'``) и двойной кавычки (``"``) также экранируются.
.. rst-class:: classref-item-separator
----
.. _class_String_method_xml_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_String_method_xml_unescape>`
Возвращает копию строки, в которой экранированные символы заменены их значениями в соответствии со стандартом XML.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Описания оператора
------------------------------------
.. _class_String_operator_neq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_neq_String>`
Возвращает ``true``, если обе строки не содержат одинаковую последовательность символов.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_neq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_neq_StringName>`
Возвращает ``true``, если эта **String** не эквивалентна заданной :ref:`StringName<class_StringName>`.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_mod_Variant:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator %**\ (\ right\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_String_operator_mod_Variant>`
Форматирует **String**, заменяя заполнители одним или несколькими параметрами. Чтобы передать несколько параметров, ``right`` должен быть :ref:`Array<class_Array>`.
::
print("I caught %d fishes!" % 2) # Выводит "I caught 2 fishes!"
var my_message = "Travelling to %s, at %2.2f km/h."
var location = "Deep Valley"
var speed = 40.3485
print(my_message % [location, speed]) # Выводит "Travelling to Deep Valley, at 40.35 km/h."
Для получения дополнительной информации см. :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_String_operator_sum_String:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_sum_String>`
Добавляет ``right`` в конец этой **String**, что также называется конкатенацией строк.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_sum_StringName:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_sum_StringName>`
Добавляет ``right`` в конец этой **String**, возвращая **String**. Это также известно как конкатенация строк.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_lt_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_lt_String>`
Возвращает ``true``, если левая **String** предшествует ``right`` в `порядке Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, что примерно соответствует алфавитному порядку. Полезно для сортировки.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_lte_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_lte_String>`
Возвращает ``true``, если левая **String** предшествует ``right`` в `порядке Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, что примерно соответствует алфавитному порядку, или если оба они равны.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_eq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_eq_String>`
Возвращает ``true``, если обе строки содержат одинаковую последовательность символов.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_eq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_eq_StringName>`
Возвращает ``true``, если эта **String** эквивалентна заданной :ref:`StringName<class_StringName>`.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_gt_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_gt_String>`
Возвращает ``true``, если левая **String** следует после ``right`` в `порядке Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, что примерно соответствует алфавитному порядку. Полезно для сортировки.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_gte_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_gte_String>`
Возвращает ``true``, если левая **String** следует после ``right`` в `порядке Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, что примерно соответствует алфавитному порядку, или если оба они равны.
.. rst-class:: classref-item-separator
----
.. _class_String_operator_idx_int:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_String_operator_idx_int>`
Возвращает новую **String**, содержащую только символ в ``index``. Индексы начинаются с ``0``. Если ``index`` больше или равен ``0``, символ извлекается, начиная с начала строки. Если ``index`` — отрицательное значение, он извлекается, начиная с конца. Доступ к строке за пределами границ вызовет ошибку времени выполнения, приостанавливая выполнение проекта, если он запущен из редактора.
.. |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