mirror of
https://github.com/godotengine/godot-docs-l10n.git
synced 2026-01-04 10:09:56 +03:00
2317 lines
152 KiB
ReStructuredText
2317 lines
152 KiB
ReStructuredText
:github_url: hide
|
||
|
||
.. _class_StringName:
|
||
|
||
StringName
|
||
==========
|
||
|
||
Вбудований тип для унікальних рядків.
|
||
|
||
.. rst-class:: classref-introduction-group
|
||
|
||
Опис
|
||
--------
|
||
|
||
**StringName** — це незмінні рядки, призначені для представлення унікальних імен загального призначення (також називається "інтернування рядків"). Два **StringName** з однаковим значенням є одним і тим же об’єктом. Їх порівняння відбувається надзвичайно швидко порівняно зі звичайними :ref:`String<class_String>`.
|
||
|
||
Зазвичай ви передаєте :ref:`String<class_String>` методам, які очікують **StringName**, і він буде автоматично перетворений (часто під час компіляції), але в рідкісних випадках ви можете створити **StringName** завчасно за допомогою конструктора **StringName** або, у GDScript, літерального синтаксису ``&"example"``. Ручне створення **StringName** дозволяє контролювати, коли відбувається перетворення з :ref:`String<class_String>`, або використовувати літерал і повністю запобігати перетворенням.
|
||
|
||
Дивіться також :ref:`NodePath<class_NodePath>`, який є подібною концепцією, спеціально розробленою для зберігання попередньо проаналізованих шляхів дерева сцен.
|
||
|
||
Усі методи :ref:`String<class_String>` також доступні в цьому класі. Вони перетворюють **StringName** на рядок і також повертають рядок. Це дуже неефективно, і його слід використовувати, лише якщо рядок потрібен.
|
||
|
||
\ **Примітка.** У C# для використання методів, перелічених на цій сторінці, потрібне явне перетворення в ``System.String``. Використовуйте метод ``ToString()``, щоб привести **StringName** до рядка, а потім використовуйте еквівалентні методи в ``System.String`` або ``StringExtensions``.
|
||
|
||
\ **Примітка.** У логічному контексті **StringName** матиме значення ``false``, якщо він порожній (``StringName("")``). В іншому випадку **StringName** завжди матиме значення ``true``.
|
||
|
||
.. note::
|
||
|
||
Існують значні відмінності при використанні цього API із С#. Більше інформації: ref:`doc_c_sharp_differences`.
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Конструктори
|
||
------------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ ) |
|
||
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`String<class_String>`\ ) |
|
||
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Методи
|
||
------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`begins_with<class_StringName_method_begins_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`bigrams<class_StringName_method_bigrams>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`bin_to_int<class_StringName_method_bin_to_int>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`c_escape<class_StringName_method_c_escape>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`c_unescape<class_StringName_method_c_unescape>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`capitalize<class_StringName_method_capitalize>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`casecmp_to<class_StringName_method_casecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`contains<class_StringName_method_contains>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`containsn<class_StringName_method_containsn>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`count<class_StringName_method_count>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`countn<class_StringName_method_countn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`dedent<class_StringName_method_dedent>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`ends_with<class_StringName_method_ends_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`erase<class_StringName_method_erase>`\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`filecasecmp_to<class_StringName_method_filecasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`filenocasecmp_to<class_StringName_method_filenocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`find<class_StringName_method_find>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`findn<class_StringName_method_findn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`format<class_StringName_method_format>`\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_base_dir<class_StringName_method_get_base_dir>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_basename<class_StringName_method_get_basename>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_extension<class_StringName_method_get_extension>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_file<class_StringName_method_get_file>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_slice<class_StringName_method_get_slice>`\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`get_slice_count<class_StringName_method_get_slice_count>`\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`get_slicec<class_StringName_method_get_slicec>`\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`hash<class_StringName_method_hash>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`hex_decode<class_StringName_method_hex_decode>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`hex_to_int<class_StringName_method_hex_to_int>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`indent<class_StringName_method_indent>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`insert<class_StringName_method_insert>`\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_absolute_path<class_StringName_method_is_absolute_path>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_empty<class_StringName_method_is_empty>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_relative_path<class_StringName_method_is_relative_path>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_subsequence_of<class_StringName_method_is_subsequence_of>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_subsequence_ofn<class_StringName_method_is_subsequence_ofn>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_ascii_identifier<class_StringName_method_is_valid_ascii_identifier>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_filename<class_StringName_method_is_valid_filename>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_float<class_StringName_method_is_valid_float>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_hex_number<class_StringName_method_is_valid_hex_number>`\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_html_color<class_StringName_method_is_valid_html_color>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_identifier<class_StringName_method_is_valid_identifier>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_int<class_StringName_method_is_valid_int>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_ip_address<class_StringName_method_is_valid_ip_address>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`is_valid_unicode_identifier<class_StringName_method_is_valid_unicode_identifier>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`join<class_StringName_method_join>`\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`json_escape<class_StringName_method_json_escape>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`left<class_StringName_method_left>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`length<class_StringName_method_length>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`lpad<class_StringName_method_lpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`lstrip<class_StringName_method_lstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`match<class_StringName_method_match>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`matchn<class_StringName_method_matchn>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`md5_buffer<class_StringName_method_md5_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`md5_text<class_StringName_method_md5_text>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`naturalcasecmp_to<class_StringName_method_naturalcasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`naturalnocasecmp_to<class_StringName_method_naturalnocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`nocasecmp_to<class_StringName_method_nocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`pad_decimals<class_StringName_method_pad_decimals>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`pad_zeros<class_StringName_method_pad_zeros>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`path_join<class_StringName_method_path_join>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`remove_char<class_StringName_method_remove_char>`\ (\ what\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`remove_chars<class_StringName_method_remove_chars>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`repeat<class_StringName_method_repeat>`\ (\ count\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`replace<class_StringName_method_replace>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`replace_char<class_StringName_method_replace_char>`\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`replace_chars<class_StringName_method_replace_chars>`\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`replacen<class_StringName_method_replacen>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`reverse<class_StringName_method_reverse>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`rfind<class_StringName_method_rfind>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`rfindn<class_StringName_method_rfindn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`right<class_StringName_method_right>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`rpad<class_StringName_method_rpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`rsplit<class_StringName_method_rsplit>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`rstrip<class_StringName_method_rstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha1_buffer<class_StringName_method_sha1_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`sha1_text<class_StringName_method_sha1_text>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha256_buffer<class_StringName_method_sha256_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`sha256_text<class_StringName_method_sha256_text>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`similarity<class_StringName_method_similarity>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`simplify_path<class_StringName_method_simplify_path>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`split<class_StringName_method_split>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedFloat64Array<class_PackedFloat64Array>` | :ref:`split_floats<class_StringName_method_split_floats>`\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`strip_edges<class_StringName_method_strip_edges>`\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`strip_escapes<class_StringName_method_strip_escapes>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`substr<class_StringName_method_substr>`\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_ascii_buffer<class_StringName_method_to_ascii_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_camel_case<class_StringName_method_to_camel_case>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`float<class_float>` | :ref:`to_float<class_StringName_method_to_float>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`to_int<class_StringName_method_to_int>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_kebab_case<class_StringName_method_to_kebab_case>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_lower<class_StringName_method_to_lower>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_multibyte_char_buffer<class_StringName_method_to_multibyte_char_buffer>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_pascal_case<class_StringName_method_to_pascal_case>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_snake_case<class_StringName_method_to_snake_case>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`to_upper<class_StringName_method_to_upper>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf8_buffer<class_StringName_method_to_utf8_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf16_buffer<class_StringName_method_to_utf16_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf32_buffer<class_StringName_method_to_utf32_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_wchar_buffer<class_StringName_method_to_wchar_buffer>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`trim_prefix<class_StringName_method_trim_prefix>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`trim_suffix<class_StringName_method_trim_suffix>`\ (\ suffix\: :ref:`String<class_String>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`int<class_int>` | :ref:`unicode_at<class_StringName_method_unicode_at>`\ (\ at\: :ref:`int<class_int>`\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`uri_decode<class_StringName_method_uri_decode>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`uri_encode<class_StringName_method_uri_encode>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`uri_file_decode<class_StringName_method_uri_file_decode>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`validate_filename<class_StringName_method_validate_filename>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`validate_node_name<class_StringName_method_validate_node_name>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`xml_escape<class_StringName_method_xml_escape>`\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`xml_unescape<class_StringName_method_xml_unescape>`\ (\ ) |const| |
|
||
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-reftable-group
|
||
|
||
Оператори
|
||
------------------
|
||
|
||
.. table::
|
||
:widths: auto
|
||
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`operator %<class_StringName_operator_mod_Variant>`\ (\ right\: :ref:`Variant<class_Variant>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<<class_StringName_operator_lt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_StringName_operator_lte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator ><class_StringName_operator_gt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
| :ref:`bool<class_bool>` | :ref:`operator >=<class_StringName_operator_gte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
|
||
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи конструкторів
|
||
--------------------------------------
|
||
|
||
.. _class_StringName_constructor_StringName:
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`StringName<class_StringName>` **StringName**\ (\ ) :ref:`🔗<class_StringName_constructor_StringName>`
|
||
|
||
Будуємо порожній **StringName**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`StringName<class_StringName>`\ )
|
||
|
||
Constructs a **StringName** як копія даної **StringName**.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-constructor
|
||
|
||
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`String<class_String>`\ )
|
||
|
||
Створює новий **StringName** з даної :ref:`String<class_String>`. У GDScript ``StringName("example")`` еквівалент ``&"example"``.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи методів
|
||
--------------------------
|
||
|
||
.. _class_StringName_method_begins_with:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **begins_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_begins_with>`
|
||
|
||
Повертає ``true``, якщо рядок починається з даної ``text``. Дивіться також :ref:`ends_with()<class_StringName_method_ends_with>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_bigrams:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedStringArray<class_PackedStringArray>` **bigrams**\ (\ ) |const| :ref:`🔗<class_StringName_method_bigrams>`
|
||
|
||
Повертає масив, що містить біграми (пари послідовних символів) цього рядка.
|
||
|
||
::
|
||
|
||
print("Get up!".bigrams()) # Prints ["Ge", "et", "t ", " u", "up", "p!"]
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_bin_to_int:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_bin_to_int>`
|
||
|
||
Перетворює рядок, що представляє двійкове число, на :ref:`int<class_int>`. Рядок може додатково мати префікс ``"0b"`` і додатковий префікс ``-`` для від’ємних чисел.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
print("101".bin_to_int()) # Виводить 5
|
||
print("0b101".bin_to_int()) # Виводить 5
|
||
print("-0b10".bin_to_int()) # Виводить -2
|
||
|
||
.. code-tab:: csharp
|
||
|
||
GD.Print("101".BinToInt()); // Виводить 5
|
||
GD.Print("0b101".BinToInt()); // Виводить 5
|
||
GD.Print("-0b10".BinToInt()); // Виводить -2
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_c_escape:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_escape>`
|
||
|
||
Повертає копію рядка з особливими героями, які втекли за допомогою стандарту C.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_c_unescape:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_c_unescape>`
|
||
|
||
Повертає копію рядка з втечу символи, заміщеними їх значеннями. Підтримані послідовності втечу ``\'``, ``\"``, ``\\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.
|
||
|
||
\ **Примітка:** На відміну від парсера GDScript, цей метод не підтримує ``\uXXXX`` послідовність втечу.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_capitalize:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_StringName_method_capitalize>`
|
||
|
||
Змінює зовнішній вигляд рядка: замінює підкреслення (``_``) пробілами, додає пробіли перед великими літерами в середині слова, перетворює всі літери на малі, потім перетворює першу та кожну наступну за пробілом у верхній регістр.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
"move_local_x".capitalize() # Повертає "Move Local X"
|
||
"sceneFile_path".capitalize() # Повертає "Шлях до файлу сцени"
|
||
"2D, FPS, PNG".capitalize() # Повертає "2D, FPS, PNG"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
"move_local_x".Capitalize(); // Повертає "Move Local X"
|
||
"sceneFile_path".Capitalize(); // Повертає "Шлях до файлу сцени"
|
||
"2D, FPS, PNG". Capitalize(); // Повертає "2d, Fps, Png"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_casecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_casecmp_to>`
|
||
|
||
Виконує порівняння з іншим рядком з урахуванням регістру. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" та "більше ніж" визначаються за допомогою `кодових точок Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ кожного рядка, що приблизно відповідає алфавітному порядку.
|
||
|
||
Для рядків різної довжини повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` та :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_contains:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_contains>`
|
||
|
||
Повертає ``true``, якщо рядок містить ``what``. У GDScript це відповідає оператору ``in``.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
print("Node".contains("de")) # Виводить true
|
||
print("team".contains("I")) # Виводить false
|
||
print("I" in "team") # Виводить false
|
||
|
||
.. code-tab:: csharp
|
||
|
||
GD.Print("Вузол".Містить("de")); // Виводить True
|
||
GD.Print("команда".Містить("Я")); // Виводить False
|
||
|
||
|
||
|
||
Якщо вам потрібно дізнатися, де знаходиться ``what`` у рядку, використовуйте :ref:`find()<class_StringName_method_find>`. Дивіться також :ref:`міститьn()<class_StringName_method_міститьn>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_containsn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_containsn>`
|
||
|
||
Повертає ``true``, якщо рядок містить ``what``, **ігноруючи регістр**.
|
||
|
||
Якщо вам потрібно знати, де знаходиться ``what`` у рядку, використовуйте :ref:`findn()<class_StringName_method_findn>`. Див. також :ref:`contains()<class_StringName_method_contains>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_count:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **count**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_count>`
|
||
|
||
Повертає кількість входжень підрядка ``what`` між позиціями ``from`` та ``to``. Якщо ``to`` дорівнює 0, пошук продовжується до кінця рядка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_countn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **countn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_countn>`
|
||
|
||
Повертає кількість входжень підрядка ``what`` між позиціями ``from`` і ``to``, **ігноруючи регістр**. Якщо ``to`` дорівнює 0, пошук продовжується до кінця рядка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_dedent:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_StringName_method_dedent>`
|
||
|
||
Повертає копію рядка без відступів (початкових табуляцій та пробілів). Див. також :ref:`indent()<class_StringName_method_indent>` для додавання відступів.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_ends_with:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_ends_with>`
|
||
|
||
Повертає ``true``, якщо рядок закінчується заданим ``text``. Див. також :ref:`begins_with()<class_StringName_method_begins_with>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_erase:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **erase**\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| :ref:`🔗<class_StringName_method_erase>`
|
||
|
||
Повертає рядок, у якому стерто ``chars`` символів, починаючи з ``position``. Якщо ``chars`` перевищує довжину рядка, задану ``position``, з повернутого рядка буде стерто менше символів. Повертає порожній рядок, якщо ``position`` або ``chars`` від'ємні. Повертає вихідний рядок без змін, якщо ``chars`` дорівнює ``0``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_filecasecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filecasecmp_to>`
|
||
|
||
Подібно до :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, але надає пріоритет рядкам, що починаються з крапок (``.``) та символів підкреслення (``_``) перед будь-яким іншим символом. Корисно під час сортування папок або імен файлів.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>` та :ref:`casecmp_to()<class_StringName_method_casecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_filenocasecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filenocasecmp_to>`
|
||
|
||
Подібно до :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, але надає пріоритет рядкам, що починаються з крапок (``.``) та символів підкреслення (``_``) перед будь-яким іншим символом. Корисно під час сортування папок або імен файлів.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>` та :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_find:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **find**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_find>`
|
||
|
||
Returns the index of the **first** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the string.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
print("Team".find("I")) # Prints -1
|
||
|
||
print("Potato".find("t")) # Prints 2
|
||
print("Potato".find("t", 3)) # Prints 4
|
||
print("Potato".find("t", 5)) # Prints -1
|
||
|
||
.. code-tab:: csharp
|
||
|
||
GD.Print("Team".Find("I")); // Prints -1
|
||
|
||
GD.Print("Potato".Find("t")); // Prints 2
|
||
GD.Print("Potato".Find("t", 3)); // Prints 4
|
||
GD.Print("Potato".Find("t", 5)); // Prints -1
|
||
|
||
|
||
|
||
\ **Note:** If you just want to know whether the string contains ``what``, use :ref:`contains()<class_StringName_method_contains>`. In GDScript, you may also use the ``in`` operator.
|
||
|
||
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_findn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **findn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_findn>`
|
||
|
||
Повертає індекс **першого** **без урахування регістру** входження ``what`` у цей рядок, або ``-1``, якщо таких немає. Початковий індекс пошуку можна вказати за допомогою ``from``, продовжуючи до кінця рядка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_format:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_StringName_method_format>`
|
||
|
||
Форматує рядок, замінюючи всі входження ``placeholder`` на елементи ``values``.
|
||
|
||
\ ``values`` може бути :ref:`Dictionary<class_Dictionary>`, :ref:`Array<class_Array>` або :ref:`Object<class_Object>`. Будь-які підкреслення в ``placeholder`` будуть заздалегідь замінені відповідними ключами. Елементи масиву використовують свій індекс як ключі.
|
||
|
||
::
|
||
|
||
# Друкує «Чекаючи на Godot» — це п’єса Семюеля Беккета, на честь якої названо двигун Godot».
|
||
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"]))
|
||
|
||
# Виводить «Користувач 42 — Godot».
|
||
print("User {id} — {name}.".format({"id": 42, "name": "Godot"}))
|
||
|
||
Деяка додаткова обробка виконується, коли ``values`` є :ref:`Array<class_Array>`. Якщо ``placeholder`` не містить підкреслення, елементи масиву ``values`` будуть використані для заміни одного входження заповнювача в порядку; Якщо елемент ``values`` є іншим 2-елементним масивом, він інтерпретуватиметься як пара ключ-значення.
|
||
|
||
::
|
||
|
||
# Виводить «Користувач 42 — Godot».
|
||
print("User {} - {}.".format([42, "Godot"], "{}"))
|
||
print("User {id} — {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``, **не** відразу. Це означає, що якщо будь-який елемент вставлено і він містить інший заповнювач, він може бути змінений наступною заміною. Хоча це може бути дуже корисним, воно часто призводить до неочікуваних результатів. Якщо це не потрібно, переконайтеся, що елементи ``values`` не містять заповнювачів.
|
||
|
||
::
|
||
|
||
print("{0} {1}".format(["{1}", "x"])) # Виводить "x x"
|
||
print("{0} {1}".format(["x", "{0}"])) # Виводить "x {0}"
|
||
print("{a} {b}".format({"a": "{b}", "b": "c"})) # Виводить "c c"
|
||
print("{a} {b}".format({"b": "c", "a": "{b}"})) # Виводить "{b} c"
|
||
|
||
\ **Примітка.** У C# натомість рекомендується `інтерполювати рядки за допомогою "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_base_dir:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_base_dir>`
|
||
|
||
Якщо рядок є дійсним шляхом до файлу, повертає назву основного каталогу.
|
||
|
||
::
|
||
|
||
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path is "/path/to"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_basename:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_basename>`
|
||
|
||
Якщо рядок є дійсним шляхом до файлу, повертає повний шлях до файлу без розширення.
|
||
|
||
::
|
||
|
||
var base = "/path/to/file.txt".get_basename() # base is "/path/to/file"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_extension:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_extension>`
|
||
|
||
Якщо рядок є дійсним ім’ям файлу або шляхом, повертає розширення файлу без початкової крапки (``.``). В іншому випадку повертає порожній рядок.
|
||
|
||
::
|
||
|
||
var a = "/path/to/file.txt".get_extension() # a це "txt"
|
||
var b = "cool.txt".get_extension() # b це "txt"
|
||
var c = "cool.font.tres".get_extension() # c це "tres"
|
||
var d = ".pack1".get_extension() # d це "pack1"
|
||
|
||
var e = "file.txt.".get_extension() # e це ""
|
||
var f = "file.txt..".get_extension() # f це ""
|
||
var g = "txt".get_extension() # g це ""
|
||
var h = "".get_extension() # h це ""
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_file:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_StringName_method_get_file>`
|
||
|
||
Якщо рядок є дійсним шляхом до файлу, повертає ім’я файлу, включаючи розширення.
|
||
|
||
::
|
||
|
||
var file = "/path/to/icon.png".get_file() # файл "icon.png"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_slice:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_slice**\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice>`
|
||
|
||
Розділяє рядок за допомогою ``delimiter`` і повертає підрядок за індексом ``slice``. Повертає вихідний рядок, якщо ``delimiter`` не зустрічається в рядку. Повертає порожній рядок, якщо ``slice`` не існує.
|
||
|
||
Це швидше, ніж :ref:`split()<class_StringName_method_split>`, якщо вам потрібен лише один підрядок.
|
||
|
||
::
|
||
|
||
print("i/am/example/hi".get_slice("/", 2)) # Виводить "example"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_slice_count:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice_count>`
|
||
|
||
Повертає загальну кількість розрізів, коли рядок розділено за допомогою поданого ``delimiter`` (див. :ref:`split()<class_StringName_method_split>`).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_get_slicec:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **get_slicec**\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_get_slicec>`
|
||
|
||
Розділяє рядок за допомогою символу з Юнікод з кодом ``delimiter`` і повертає підрядок в індексі ``slice``. Повертає порожній рядок, якщо ``slice`` не існує.
|
||
|
||
Це швидше, ніж :ref:`split()<class_StringName_method_split>`, якщо вам потрібен тільки певний підрядок.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_hash:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_StringName_method_hash>`
|
||
|
||
Повертає значення 32-бітного хешу, що представляє вміст рядків.
|
||
|
||
\ **Примітка:** Рядки з однаковими значеннями хеш *not* гарантовано бути таким же, в результаті зіткнень. Навпаки з різними значеннями хешу гарантовано відрізняються.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_hex_decode:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_decode>`
|
||
|
||
Декодує шістнадцятковий рядок як :ref:`PackedByteArray<class_PackedByteArray>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var text = "привіт, світ"
|
||
var encoded = text.to_utf8_buffer().hex_encode() # виходи "68656c6c6f20776f726c64"
|
||
print(encoded.hex_decode().get_string_from_utf8())
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var text = "привіт, світ";
|
||
var encoded = text.ToUtf8Buffer().HexEncode(); // виходи "68656c6c6f20776f726c64"
|
||
GD.Print(encoded.HexDecode().GetStringFromUtf8());
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_hex_to_int:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_hex_to_int>`
|
||
|
||
Перетворює рядок, що представляє шістнадцяткове число, на :ref:`int<class_int>`. Рядок може мати префікс ``"0x"`` і додатковий префікс ``-`` для від’ємних чисел.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
print("0xff".hex_to_int()) # Виводить 255
|
||
print("ab".hex_to_int()) # Виводить 171
|
||
|
||
.. code-tab:: csharp
|
||
|
||
GD.Print("0xff".HexToInt()); // Виводить 255
|
||
GD.Print("ab".HexToInt()); // Друкує 171
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_indent:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_indent>`
|
||
|
||
Змінює відступ кожного рядка за допомогою заданого префікса ``prefix``. Порожні рядки не мають відступів. Див. також :ref:`dedent()<class_StringName_method_dedent>` для видалення відступів.
|
||
|
||
Наприклад, рядок може бути відступлений двома табуляціями за допомогою ``"\t\t"`` або чотирма пробілами за допомогою ``" "``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_insert:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_insert>`
|
||
|
||
Вставки ``what`` в наданій ``position`` в рядку.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_absolute_path:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_absolute_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_absolute_path>`
|
||
|
||
Повертає ``true``, якщо рядок є шлях до файлу або каталогу, а початкова точка явно визначена. Цей метод є протилежним :ref:`is_relative_path()<class_StringName_method_is_relative_path>`.
|
||
|
||
Це включає в себе всі шляхи, починаючи з ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"`` і т.д.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_empty:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_empty>`
|
||
|
||
Повертає ``true``, якщо довжина рядка ``0`` (``"""``). Дивись також :ref:`length()<class_StringName_method_length>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_relative_path:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_relative_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_relative_path>`
|
||
|
||
Повертаємо ``true``, якщо рядок є шляхом, а початкова точка залежить від контексту. Шлях може початися з поточного каталогу, або поточного :ref:`Node<class_Node>` (якщо рядок виходить з :ref:`NodePath<class_NodePath>`), а іноді може бути попередньофіксований ``./"``. Цей метод є протилежним :ref:`is_absolute_path()<class_StringName_method_is_absolute_path>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_subsequence_of:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_subsequence_of**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_is_subsequence_of>`
|
||
|
||
Повертає ``true``, якщо всі символи цього рядка можна знайти в ``text`` у їхньому початковому порядку. Це не те саме, що :ref:`contains()<class_StringName_method_contains>`.
|
||
|
||
::
|
||
|
||
var text = "Вау, неймовірно!"
|
||
|
||
print("неїстівний".is_subsequence_of(text)) # Друк true
|
||
print("Слово!".is_subsequence_of(text)) # Друк true
|
||
print("Вікно".is_subsequence_of(text)) # Друк false
|
||
print("".is_subsequence_of(text)) # Друк true
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_subsequence_ofn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_is_subsequence_ofn>`
|
||
|
||
Повертає ``true``, якщо всі символи цього рядка можна знайти в ``text`` у їхньому початковому порядку, **ігноруючи регістр**. Це не те саме, що :ref:`containsn()<class_StringName_method_containsn>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_ascii_identifier:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_ascii_identifier>`
|
||
|
||
Повертає ``true``, якщо цей рядок є дійсним ідентифікатором ASCII. Дійсний ідентифікатор ASCII може містити лише літери, цифри та підкреслення (``_``), а перший символ не може бути цифрою.
|
||
|
||
::
|
||
|
||
print("node_2d".is_valid_ascii_identifier()) # Виводить true
|
||
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Виводить true
|
||
print("1st_method".is_valid_ascii_identifier()) # Виводить false
|
||
print("MyMethod#2".is_valid_ascii_identifier()) # Виводить false
|
||
|
||
Дивіться також :ref:`is_valid_unicode_identifier()<class_StringName_method_is_valid_unicode_identifier>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_filename:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_filename>`
|
||
|
||
Повертає ``true``, якщо цей рядок є коректним іменем файлу. Коректне ім'я файлу не може бути порожнім, починатися або закінчуватися пробілами або містити заборонені символи (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_float:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_float>`
|
||
|
||
Повертає ``true``, якщо цей рядок представляє дійсне число з плаваючою комою. Правильний float може містити лише цифри, одну десяткову крапку (``.``) і літеру експоненти (``e``). Перед ним також може бути позитивний (``+``) або негативний (``-``) знак. Будь-яке дійсне ціле число також є дійсним float (див. :ref:`is_valid_int()<class_StringName_method_is_valid_int>`). Дивіться також :ref:`to_float()<class_StringName_method_to_float>`.
|
||
|
||
::
|
||
|
||
print("1.7".is_valid_float()) # Виводить true
|
||
print("24".is_valid_float()) # Виводить true
|
||
print("7e3".is_valid_float()) # Виводить true
|
||
print("Привіт".is_valid_float()) # Виводить false
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_hex_number:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_hex_number**\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_is_valid_hex_number>`
|
||
|
||
Повертає ``true``, якщо цей рядок є дійсним шістнадцятковим числом. Дійсне шістнадцяткове число містить лише цифри або літери ``A`` до ``F`` (великі або малі) і може мати перед собою позитивний (``+``) або негативний (``-``) знак.
|
||
|
||
Якщо ``with_prefix`` має значення ``true``, шістнадцяткове число має мати префікс ``"0x"``, щоб вважатися дійсним.
|
||
|
||
::
|
||
|
||
print("A08E".is_valid_hex_number()) # Виводить true
|
||
print("-AbCdEf".is_valid_hex_number()) # Виводить true
|
||
print("2.5".is_valid_hex_number()) # Виводить false
|
||
|
||
print("0xDEADC0DE".is_valid_hex_number(true)) # Виводить true
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_html_color:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_html_color>`
|
||
|
||
Повертаємо ``true``, якщо цей рядок є дійсним кольором в шестигранному HTML позначення. Рядок повинен бути шестигранним значенням (див. :ref:`is_valid_hex_number()<class_StringName_method_is_valid_hex_number>`) або 3, 4, 6 або 8 цифр, і може бути попередньофіксований знаком хеш (``#``. Інші HTML позначення для кольорів, таких як імена або ``hsl()``, не вважаються дійсними. Дивитися також :ref:`Color.html()<class_Color_method_html>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_identifier:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_identifier>`
|
||
|
||
**Застаріло:** Use :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>` instead.
|
||
|
||
Повертає ``true``, якщо цей рядок є дійсним ідентифікатором. Правильний ідентифікатор може містити лише літери, цифри та підкреслення (``_``), а перший символ не може бути цифрою.
|
||
|
||
::
|
||
|
||
print("node_2d".is_valid_identifier()) # Виводить true
|
||
print("TYPE_FLOAT".is_valid_identifier()) # Виводить true
|
||
print("1st_method".is_valid_identifier()) # Виводить false
|
||
print("MyMethod#2".is_valid_identifier()) # Виводить false
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_int:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_int>`
|
||
|
||
Повертає ``true``, якщо цей рядок представляє дійсне ціле число. Дійсне ціле число містить лише цифри та може мати перед собою позитивний (``+``) або негативний (``-``) знак. Дивіться також :ref:`to_int()<class_StringName_method_to_int>`.
|
||
|
||
::
|
||
|
||
print("7".is_valid_int()) # Виводить true
|
||
print("1.65".is_valid_int()) # Виводить false
|
||
print("Hi".is_valid_int()) # Виводить false
|
||
print("+3".is_valid_int()) # Виводить true
|
||
print("-12".is_valid_int()) # Виводить true
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_ip_address:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_ip_address>`
|
||
|
||
Повертає ``true``, якщо цей рядок представляє добре відформатовану адресу IPv4 або IPv6. Цей метод розглядає `зарезервовані IP-адреси <https://en.wikipedia.org/wiki/Reserved_IP_addresses>`__, наприклад ``"0.0.0.0"`` і ``"ffff:ffff: ffff:ffff:ffff:ffff:ffff:ffff"`` як дійсний.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_is_valid_unicode_identifier:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_unicode_identifier>`
|
||
|
||
Повертає ``true``, якщо цей рядок є дійсним ідентифікатором Unicode.
|
||
|
||
Дійсний ідентифікатор Unicode має починатися з символу Unicode класу ``XID_Start`` або ``"_"`` і може містити символи Unicode класу ``XID_Continue`` в інших позиціях.
|
||
|
||
::
|
||
|
||
print("node_2d".is_valid_unicode_identifier()) # Виводить true
|
||
print("1st_method".is_valid_unicode_identifier()) # Виводить false
|
||
print("MyMethod#2".is_valid_unicode_identifier()) # Виводить false
|
||
print("endurance".is_valid_unicode_identifier()) # Виводить true
|
||
print("витривалість".is_valid_unicode_identifier()) # Prints true
|
||
print("体力".is_valid_unicode_identifier()) # Виводить true
|
||
|
||
Дивіться також :ref:`is_valid_ascii_identifier()<class_StringName_method_is_valid_ascii_identifier>`.
|
||
|
||
\ **Примітка.** Цей метод перевіряє ідентифікатори так само, як і GDScript. Перегляньте :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` для більш розширених перевірок.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_join:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_StringName_method_join>`
|
||
|
||
Повертає конкатенацію елементів ``parts``, кожен елемент розділений рядком, що викликає цей метод. Цей метод протилежний методу :ref:`split()<class_StringName_method_split>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var fruits = ["Яблуко", "Апельсин", "Груша", "Ківі"]
|
||
|
||
print(", ".join(fruits)) # Виводить "Яблуко, Апельсин, Груша, Ківі"
|
||
print("---".join(fruits)) # Виводить "Яблуко---Апельсин---Груша---Ківі"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
string[] fruits = ["Яблуко", "Апельсин", "Груша", "Ківі"];
|
||
|
||
// У C# цей метод є статичним.
|
||
GD.Print(string.Join(", ", фрукти)); // Друкує "Яблуко, Апельсин, Груша, Ківі"
|
||
GD.Print(string.Join("---", фрукти)); // Друкує "Яблуко---Апельсин---Груша---Ківі"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_json_escape:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_StringName_method_json_escape>`
|
||
|
||
Повертає копію рядка з особливими героями, які втекли за допомогою стандарта JSON. Тому що він тісно відповідає стандарту C, можна використовувати :ref:`c_unescape()<class_StringName_method_c_unescape>`, щоб вийти на рядок, якщо це необхідно.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_left:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_left>`
|
||
|
||
Повертає перші ``length`` символи з початку рядка. Якщо ``length`` від'ємне, видаляє останні символи ``length`` із кінця рядка.
|
||
|
||
::
|
||
|
||
print("Hello World!".left(3)) # Виводить "Hel"
|
||
print("Hello World!".left(-4)) # Виводить "Hello Wo"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_length:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_StringName_method_length>`
|
||
|
||
Повертає кількість символів у рядку. Порожні рядки (``""``) завжди повертають ``0``. Дивіться також :ref:`is_empty()<class_StringName_method_is_empty>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_lpad:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **lpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_lpad>`
|
||
|
||
Форматує рядок довжиною щонайменше ``min_length``, додаючи ``character`` ліворуч від рядка, якщо необхідно. Див. також :ref:`rpad()<class_StringName_method_rpad>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_lstrip:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **lstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_lstrip>`
|
||
|
||
Видаляє набір символів, визначених у ``chars``, з початку рядка. Див. також :ref:`rstrip()<class_StringName_method_rstrip>`.
|
||
|
||
\ **Примітка:** ``chars`` не є префіксом. Використовуйте :ref:`trim_prefix()<class_StringName_method_trim_prefix>` для видалення одного префікса, а не набору символів.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_match:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **match**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_match>`
|
||
|
||
Чи є простий виразний матч (також називається "glob" або "globbing"), де ``*`` відповідає нульовим або більш довільним символам і ``? `` відповідає будь-якому символу, крім періоду (`` ``. Порожня рядок або порожня експресія завжди оцінюється до ``false``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_matchn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`bool<class_bool>` **matchn**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_matchn>`
|
||
|
||
Чи є простий **case-insensitive** вираз матч, де `` *`` відповідає нульовим або більш довільним символам і ``? `` відповідає будь-якому символу, крім періоду (`` ``. Порожня рядок або порожня експресія завжди оцінюється до ``false``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_md5_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_md5_buffer>`
|
||
|
||
Повернення `MD5 хеш <https://en.wikipedia.org/wiki/MD5>`__ рядка як :ref:`PackedByteArray<class_PackedByteArray>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_md5_text:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **md5_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_md5_text>`
|
||
|
||
Повернення `MD5 хеш <https://en.wikipedia.org/wiki/MD5>`__ рядка як ще :ref:`String<class_String>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_naturalcasecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalcasecmp_to>`
|
||
|
||
Виконує порівняння з іншим рядком у **регістрово-чутливому**, *природному порядку*. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за `кодовими точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ кожного рядка, що приблизно відповідає алфавітному порядку.
|
||
|
||
Під час використання для сортування порівняння в природному порядку впорядковує послідовності чисел за сумарним значенням кожної цифри, як часто очікується, а не за значенням однієї цифри. Відсортована послідовність нумерованих рядків буде ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``.
|
||
|
||
Якщо довжина рядків різна, повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>` та :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_naturalnocasecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalnocasecmp_to>`
|
||
|
||
Виконує порівняння з іншим рядком у **регістрово-незалежному**, *природному порядку*. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за `кодовими точками Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ кожного рядка, що приблизно відповідає алфавітному порядку. Внутрішньо малі символи перетворюються на великі для порівняння.
|
||
|
||
Під час використання для сортування порівняння в природному порядку впорядковує послідовності чисел за сумарним значенням кожної цифри, як часто очікується, а не за значенням однієї цифри. Відсортована послідовність нумерованих рядків буде ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``.
|
||
|
||
Якщо довжина рядків різна, повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` та :ref:`casecmp_to()<class_StringName_method_casecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_nocasecmp_to:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_nocasecmp_to>`
|
||
|
||
Виконує порівняння з іншим рядком **без урахування** регістру. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за допомогою `кодових точок Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ кожного рядка, що приблизно відповідає алфавітному порядку. Внутрішньо малі символи перетворюються на великі для порівняння.
|
||
|
||
Для рядків різної довжини повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``.
|
||
|
||
Щоб отримати результат :ref:`bool<class_bool>` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`casecmp_to()<class_StringName_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>` та :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_pad_decimals:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_decimals>`
|
||
|
||
Формати рядка, що представляє номер, щоб мати точну кількість ``digits`` * після * десятковий пункт.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_pad_zeros:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_pad_zeros>`
|
||
|
||
Формати рядка, що представляє номер, щоб мати точну кількість ``digits`` *before* десятковий пункт.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_path_join:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_path_join>`
|
||
|
||
Об'єднує ``path`` в кінці рядка як підшлях, додаючи ``/`` за потреби.
|
||
|
||
\ **Приклад:** ``"this/is".path_join("path") == "this/is/path"``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_remove_char:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_remove_char>`
|
||
|
||
Видаляє всі входження символу Unicode за допомогою коду ``what``. Швидша версія методу :ref:`replace()<class_StringName_method_replace>`, коли ключ містить лише один символ, а заміна — ``""``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_remove_chars:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_remove_chars>`
|
||
|
||
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_StringName_method_remove_char>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_repeat:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_repeat>`
|
||
|
||
Повторює цей ряд разів. ``count`` повинен бути більшим, ніж ``0``. В іншому випадку повертає порожній рядок.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_replace:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replace>`
|
||
|
||
Замінює всі входження ``what`` всередині рядка на заданий ``forwhat``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_replace_char:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **replace_char**\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_char>`
|
||
|
||
Замінює всі входження символу Unicode з кодом ``key`` на символ Unicode з кодом ``with``. Швидша версія методу :ref:`replace()<class_StringName_method_replace>`, коли ключ містить лише один символ. Щоб отримати один символ, використовуйте ``"X".unicode_at(0)`` (зверніть увагу, що деякі рядки, такі як складені літери та емодзі, можуть складатися з кількох кодових точок Unicode і не працюватимуть із цим методом, використовуйте :ref:`length()<class_StringName_method_length>`, щоб переконатися).
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_replace_chars:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **replace_chars**\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_replace_chars>`
|
||
|
||
Замінює будь-які символи, що входять до складу ``keys``, символом Unicode з кодом ``with``. Див. також :ref:`replace_char()<class_StringName_method_replace_char>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_replacen:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_replacen>`
|
||
|
||
Замінює всі **case-insensitive** появи ``парам, що`` всередині рядка з наданою ``forwhat``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_reverse:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_StringName_method_reverse>`
|
||
|
||
Повернення копії цього рядка в зворотному порядку. Ця операція працює на пунктах коду унікоду, а не послідовностей точок коду, і може розбити речі, такі як складні листи або смайлики.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_rfind:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfind>`
|
||
|
||
Returns the index of the **last** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`find()<class_StringName_method_find>`.
|
||
|
||
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
|
||
|
||
\ **Note:** A value of ``from`` that is greater than the last possible index with enough space to find ``what`` is considered out-of-bounds, and returns ``-1``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_rfindn:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **rfindn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_rfindn>`
|
||
|
||
Повертає індекс **останнього** **без урахування регістру** входження ``what`` у цей рядок, або ``-1``, якщо таких немає. Початковий індекс пошуку можна вказати за допомогою ``from``, продовжуючи до початку рядка. Цей метод є зворотним до :ref:`findn()<class_StringName_method_findn>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_right:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_right>`
|
||
|
||
Повертає останні символи ``length`` з кінця рядка. Якщо ``length`` від'ємне, видаляє перші символи ``length`` з початку рядка.
|
||
|
||
::
|
||
|
||
print("Hello World!".right(3)) # Виводить "ld!"
|
||
print("Hello World!".right(-4)) # Друкує "о Світе!"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_rpad:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **rpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_StringName_method_rpad>`
|
||
|
||
Форматує рядок так, щоб він мав довжину щонайменше ``min_length``, додаючи ``character`` праворуч від рядка, якщо необхідно. Див. також :ref:`lpad()<class_StringName_method_lpad>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_rsplit:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedStringArray<class_PackedStringArray>` **rsplit**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_rsplit>`
|
||
|
||
Розділяє рядок за допомогою ``delimiter`` і повертає масив підрядків, починаючи з кінця рядка. Розбиття у повернутому масиві з’являється в тому самому порядку, що й вихідний рядок. Якщо ``delimiter`` є порожнім рядком, кожен підрядок буде одним символом.
|
||
|
||
Якщо ``allow_empty`` має значення ``false``, порожні рядки між суміжними роздільниками виключаються з масиву.
|
||
|
||
Якщо ``maxsplit`` більший за ``0``, кількість розділень не може перевищувати ``maxsplit``. За замовчуванням весь рядок розділено, що здебільшого ідентично :ref:`split()<class_StringName_method_split>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var some_string = "Один, два, три, чотири"
|
||
var some_array = some_string.rsplit(",", true, 1)
|
||
|
||
print(some_array.size()) # Виводить 2
|
||
print(some_array[0]) # Виводить "Один, два, три"
|
||
print(some_array[1]) # Виводить "Чотири"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
// У C# немає методу String.RSplit().
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_rstrip:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_rstrip>`
|
||
|
||
Видаляє набір символів, визначених у ``chars``, з кінця рядка. Див. також :ref:`lstrip()<class_StringName_method_lstrip>`.
|
||
|
||
\ **Примітка:** ``chars`` не є суфіксом. Використовуйте :ref:`trim_suffix()<class_StringName_method_trim_suffix>` для видалення одного суфікса, а не набору символів.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_sha1_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha1_buffer>`
|
||
|
||
Повертаємо `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ хеш рядка як :ref:`PackedByteArray<class_PackedByteArray>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_sha1_text:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **sha1_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha1_text>`
|
||
|
||
Повертаємо `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ хеш рядка в іншому :ref:`String<class_String>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_sha256_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha256_buffer>`
|
||
|
||
Повертаємо `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ хеш рядка як :ref:`PackedByteArray<class_PackedByteArray>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_sha256_text:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha256_text>`
|
||
|
||
Повертаємо `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ хеш рядка в іншому :ref:`String<class_String>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_similarity:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_similarity>`
|
||
|
||
Повертає індекс подібності (`коефіцієнт Соренсена-Діса <https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient>`__) цього рядка порівняно з іншим. Результат ``1.0`` означає абсолютно подібний, тоді як ``0.0`` означає абсолютно несхожий.
|
||
|
||
::
|
||
|
||
print("ABC123".similarity("ABC123")) # Друкує 1.0
|
||
print("ABC123".similarity("XYZ456")) # Виводить 0.0
|
||
print("ABC123".similarity("123ABC")) # Виводить 0,8
|
||
print("ABC123".similarity("abc123")) # Виводить 0,4
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_simplify_path:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_StringName_method_simplify_path>`
|
||
|
||
Якщо рядок є дійсним шляхом до файлу, перетворює рядок на канонічний шлях. Це найкоротший можливий шлях, без ``"./"`` і всього непотрібного ``".."`` і ``"/"``.
|
||
|
||
::
|
||
|
||
var simple_path = "./path/to///../file".simplify_path()
|
||
print(simple_path) # Виводить "шлях/файл"
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_split:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedStringArray<class_PackedStringArray>` **split**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_StringName_method_split>`
|
||
|
||
Розділяє рядок за допомогою ``delimiter`` і повертає масив підрядків. Якщо ``delimiter`` є порожнім рядком, кожен підрядок буде одним символом. Цей метод протилежний методу :ref:`join()<class_StringName_method_join>`.
|
||
|
||
Якщо ``allow_empty`` має значення ``false``, порожні рядки між суміжними роздільниками виключаються з масиву.
|
||
|
||
Якщо ``maxsplit`` більший за ``0``, кількість розділень не може перевищувати ``maxsplit``. За замовчуванням весь рядок розділено.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var some_array = "One,Two,Three,Four".split(",", true, 2)
|
||
|
||
print(some_array.size()) # Виводить 3
|
||
print(some_array[0]) # Виводить "One"
|
||
print(some_array[1]) # Виводить "Два"
|
||
print(some_array[2]) # Виводить "Три, Чотири"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
// `Split()` C# не підтримує параметр `maxsplit`.
|
||
var someArray = "One,Two,Three".Split(",");
|
||
|
||
GD.Print(someArray[0]); // Виводить "One"
|
||
GD.Print(someArray[1]); // Друкує "Два"
|
||
GD.Print(someArray[2]); // Виводить "Три"
|
||
|
||
|
||
|
||
\ **Примітка.** Якщо вам потрібен лише один підрядок із масиву, спробуйте використати :ref:`get_slice()<class_StringName_method_get_slice>`, який є швидшим. Якщо вам потрібно розділити рядки за більш складними правилами, замість цього використовуйте клас :ref:`RegEx<class_RegEx>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_split_floats:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedFloat64Array<class_PackedFloat64Array>` **split_floats**\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_split_floats>`
|
||
|
||
Розділяє рядок на плаваючі числа за допомогою ``delimiter`` і повертає :ref:`PackedFloat64Array<class_PackedFloat64Array>`.
|
||
|
||
Якщо ``allow_empty`` має значення ``false``, порожні або недійсні перетворення :ref:`float<class_float>` між суміжними роздільниками виключаються.
|
||
|
||
::
|
||
|
||
var a = "1,2,4.5".split_floats(",") # a is [1.0, 2.0, 4.5]
|
||
var c = "1| ||4.5".split_floats("|") # c дорівнює [1.0, 0.0, 0.0, 4.5]
|
||
var b = "1| ||4.5".split_floats("|", false) # b дорівнює [1.0, 4.5]
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_strip_edges:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **strip_edges**\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_StringName_method_strip_edges>`
|
||
|
||
Роздягання всіх немаркованих символів з початку і кінця рядка. До них відносяться пробіли, вкладки (``\t``), а також нові лінії (``\n`` ``\r``).
|
||
|
||
Якщо ``зліва`` ``false``, ігнорує початок рядка. Так само, якщо ``right`` ``false``, ігнорує кінець рядка.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_strip_escapes:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_StringName_method_strip_escapes>`
|
||
|
||
Смуги всі символи втечу з рядка. До них відносяться всі немарковані символи керування першої сторінки таблиці ASCII (значення від 0 до 31), такі як таблифікація (``\t``) та нова лінія (``\n``, ``\r``) символи, але *not*.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_substr:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **substr**\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_StringName_method_substr>`
|
||
|
||
Повертає частину рядка з позиції ``from`` довжиною ``len``. Якщо ``len`` дорівнює ``-1`` (як за замовчуванням), повертає решту рядка, починаючи з заданої позиції.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_ascii_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_ascii_buffer>`
|
||
|
||
Конвертує рядок на ` ASCII <https://en.wikipedia.org/wiki/ASCII>`__/Latin-1 кодовано :ref:`PackedByteArray<class_PackedByteArray>`. Цей метод трохи швидше :ref:`to_utf8_buffer()<class_StringName_method_to_utf8_buffer>`, але замінює всі непідтримані символи з пробілами. This is the inverse of :ref:`PackedByteArray.get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_camel_case:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_camel_case>`
|
||
|
||
Повертає рядок, перетворена на ``camelCase``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_float:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_float>`
|
||
|
||
Перетворює рядок, що представляє десяткове число, у :ref:`float<class_float>`. Цей метод зупиняється на першому нечисловому символі, за винятком першої десяткової коми (``.``) і літери експоненти (``e``). Дивіться також :ref:`is_valid_float()<class_StringName_method_is_valid_float>`.
|
||
|
||
::
|
||
|
||
var a = "12.35".to_float() # a дорівнює 12.35
|
||
var b = "1.2.3".to_float() # b це 1.2
|
||
var c = "12xy3".to_float() # c дорівнює 12,0
|
||
var d = "1e3".to_float() # d дорівнює 1000,0
|
||
var e = "Привіт!".to_float() # e дорівнює 0,0
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_int:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_int>`
|
||
|
||
Перетворює рядок, що представляє ціле число, на :ref:`int<class_int>`. Цей метод видаляє будь-який нечисловий символ і зупиняється на першій десятковій комі (``.``). Дивіться також :ref:`is_valid_int()<class_StringName_method_is_valid_int>`.
|
||
|
||
::
|
||
|
||
var a = "123".to_int() # a дорівнює 123
|
||
var b = "x1y2z3".to_int() # b дорівнює 123
|
||
var c = "-1.2.3".to_int() # c дорівнює -1
|
||
var d = "Привіт!".to_int() # d дорівнює 0
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_kebab_case:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_kebab_case>`
|
||
|
||
Повертає рядок, перетворений на ``kebab-case``.
|
||
|
||
\ **Примітка:** Числа, за якими йде *одна* літера, не розділяються під час перетворення, щоб деякі слова (наприклад, "2D") залишалися разом.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
"Node2D".to_kebab_case() # Повертає "node-2d"
|
||
"2nd place".to_kebab_case() # Повертає "2-nd-place"
|
||
"Texture3DAssetFolder".to_kebab_case() # Повертає "texture-3d-asset-folder"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
"Node2D".ToKebabCase(); // Повертає "node-2d"
|
||
"2nd place".ToKebabCase(); // Повертає "2-nd-place"
|
||
"Texture3DAssetFolder".ToKebabCase(); // Повертає "texture-3d-asset-folder"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_lower:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_lower>`
|
||
|
||
Повертає рядок, що перетворюється на ``низ ``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_multibyte_char_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_StringName_method_to_multibyte_char_buffer>`
|
||
|
||
Перетворює рядок на системну багатобайтову кодову сторінку, закодовану як :ref:`PackedByteArray<class_PackedByteArray>`. Якщо перетворення не вдається, повертається порожній масив.
|
||
|
||
Дозволені значення для ``encoding`` залежать від системи. Якщо ``encoding`` – це порожній рядок, використовується системне кодування за замовчуванням.
|
||
|
||
- Для Windows див. `Ідентифікатори кодових сторінок <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ імена .NET.
|
||
|
||
- Для macOS та Linux/BSD див. документацію до бібліотеки ``libiconv`` та ``iconv --list`` для списку підтримуваних кодувань.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_pascal_case:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_pascal_case>`
|
||
|
||
Повертає рядок, перетворена на ``ПаскалаКаза``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_snake_case:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_snake_case>`
|
||
|
||
Повертає рядок, перетворений на ``snake_case``.
|
||
|
||
\ **Примітка: ** Числа, за якими йде *одна * літера, не розділяються під час перетворення, щоб зберегти деякі слова (наприклад, "2D") разом.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
"Node2D".to_snake_case() # Повертає "node_2d"
|
||
"2nd place".to_snake_case() # Повертає "2_nd_place"
|
||
"Texture3DAssetFolder".to_snake_case() # Повертає "texture_3d_asset_folder"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
"Node2D".ToSnakeCase(); // Повертає "node_2d"
|
||
"2 місце".ToSnakeCase(); // Повертає "2_nd_place"
|
||
"Texture3DAssetFolder".ToSnakeCase(); // Повертає "texture_3d_asset_folder"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_upper:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_upper>`
|
||
|
||
Повертає рядок, що перетворюється на ``UPPERCASE``.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_utf8_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf8_buffer>`
|
||
|
||
Конвертує рядок на `UTF-8 <https://en.wikipedia.org/wiki/UTF-8>`__\ кодовано :ref:`PackedByteArray<class_PackedByteArray>`. Цей метод дещо повільний, ніж ``метод_ascii_buffer``, але підтримує всі символи UTF-8. Для більшості випадків, віддають перевагу цим методом. This is the inverse of :ref:`PackedByteArray.get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_utf16_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf16_buffer>`
|
||
|
||
Конвертує рядок на `UTF-16 <https://en.wikipedia.org/wiki/UTF-16>`__\ кодовано :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf16()<class_PackedByteArray_method_get_string_from_utf16>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_utf32_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_utf32_buffer>`
|
||
|
||
Конвертує рядок на `UTF-32 <https://en.wikipedia.org/wiki/UTF-32>`__\ кодовано :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf32()<class_PackedByteArray_method_get_string_from_utf32>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_to_wchar_buffer:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_wchar_buffer>`
|
||
|
||
Перетворює рядок на `широкий характер <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 на Windows, UTF-32 на інших платформах) закодовано :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_wchar()<class_PackedByteArray_method_get_string_from_wchar>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_trim_prefix:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_prefix>`
|
||
|
||
Видаляє заданий префікс ``prefix`` з початку рядка або повертає рядок без змін.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_trim_suffix:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_trim_suffix>`
|
||
|
||
Видаліть задану ``prefix`` з кінця рядка, або повертає рядок незмінним.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_unicode_at:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_unicode_at>`
|
||
|
||
Повертає код символу в позиції ``at``.
|
||
|
||
Див. також :ref:`String.chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` та :ref:`@GDScript.ord()<class_@GDScript_method_ord>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_uri_decode:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_decode>`
|
||
|
||
Декодує рядок з його формату, закодованого за URL-адресою. Цей метод призначений для правильного декодування параметрів в URL-адресі під час отримання HTTP-запиту. Див. також :ref:`uri_encode()<class_StringName_method_uri_encode>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
|
||
print(url.uri_decode()) # Виводить "$DOCS_URL/?highlight=Godot Engine:docs"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
|
||
GD.Print(url.URIDecode()) // Виводить "$DOCS_URL/?highlight=Godot Engine:docs"
|
||
|
||
|
||
|
||
\ **Примітка:** Цей метод декодує ``+`` як пробіл.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_uri_encode:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_encode>`
|
||
|
||
Кодує рядок до URL-дружнього формату. Цей метод призначений для правильного кодування параметрів в URL-адресі під час надсилання запиту HTTP. Дивіться також :ref:`uri_decode()<class_StringName_method_uri_decode>`.
|
||
|
||
|
||
.. tabs::
|
||
|
||
.. code-tab:: gdscript
|
||
|
||
var prefix = "$DOCS_URL/?highlight="
|
||
var url = prefix + "Godot Engine:docs".uri_encode()
|
||
|
||
print(url) # Виводить "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
|
||
|
||
.. code-tab:: csharp
|
||
|
||
var prefix = "$DOCS_URL/?highlight=";
|
||
var url = prefix + "Godot Engine:docs".URIEncode();
|
||
|
||
GD.Print(url); // Друкує "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
|
||
|
||
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_uri_file_decode:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_file_decode>`
|
||
|
||
Декодує шлях до файлу з його URL-кодованого формату. На відміну від методу :ref:`uri_decode()<class_StringName_method_uri_decode>`, цей метод залишає ``+`` як є.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_validate_filename:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_filename>`
|
||
|
||
Повертає копію рядка, в якому всі символи, недозволені в :ref:`is_valid_filename()<class_StringName_method_is_valid_filename>`, замінені на символи підкреслення.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_validate_node_name:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_StringName_method_validate_node_name>`
|
||
|
||
Повертає копію рядка з усіма символами, які не дозволені в :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) замінено підкресленням.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_xml_escape:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_method_xml_escape>`
|
||
|
||
Повертає копію рядка зі спеціальними символами, екранованими за допомогою стандарту XML. Якщо ``escape_quotes`` має значення ``true``, символи одинарних лапок (``'``) і подвійних лапок (``"``) також екрануються.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_method_xml_unescape:
|
||
|
||
.. rst-class:: classref-method
|
||
|
||
:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_method_xml_unescape>`
|
||
|
||
Повертає копію рядка з вбитими символами, заміненими на їх значення відповідно до стандарту XML.
|
||
|
||
.. rst-class:: classref-section-separator
|
||
|
||
----
|
||
|
||
.. rst-class:: classref-descriptions-group
|
||
|
||
Описи операторів
|
||
--------------------------------
|
||
|
||
.. _class_StringName_operator_neq_String:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_neq_String>`
|
||
|
||
Повертає ``true``, якщо це **StringName** не еквівалентно даній :ref:`String<class_String>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_neq_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_neq_StringName>`
|
||
|
||
Повертає ``true``, якщо **StringName** і ``right`` не відноситься до тієї ж назви. Порівняння між **StringName** набагато швидше, ніж регулярні :ref:`String<class_String>` порівняння.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_mod_Variant:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`String<class_String>` **operator %**\ (\ right\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_StringName_operator_mod_Variant>`
|
||
|
||
Форматує **StringName**, замінюючи заповнювачі одним або кількома параметрами, повертаючи :ref:`String<class_String>`. Щоб передати кілька параметрів, ``right`` має бути масивом :ref:`Array<class_Array>`.
|
||
|
||
Для отримання додаткової інформації див. навчальний посібник :doc:`Рядки формату GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`.
|
||
|
||
\ **Примітка:** У C# цей оператор недоступний. Натомість див. `як інтерполювати рядки за допомогою "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_sum_String:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_sum_String>`
|
||
|
||
Додатки ``right`` в кінці цього **StringName**, повернення :ref:`String<class_String>`. Це також відомий як рядок конкатенації.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_sum_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_sum_StringName>`
|
||
|
||
Додатки ``right`` в кінці цього **StringName**, повернення :ref:`String<class_String>`. Це також відомий як рядок конкатенації.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_lt_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lt_StringName>`
|
||
|
||
Повертаємо ``true``, якщо зліва **StringName** надходить до ``right``. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_lte_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lte_StringName>`
|
||
|
||
Повертаємо ``true``, якщо зліва **StringName** надходить до ``right`` або якщо вони однакові. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_eq_String:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_eq_String>`
|
||
|
||
Повертає ``true``, якщо це **StringName** еквівалентно даній :ref:`String<class_String>`.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_eq_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_eq_StringName>`
|
||
|
||
Повертає ``true``, якщо **StringName** і ``right`` відносяться до тієї ж назви. Порівняння між **StringName** набагато швидше, ніж регулярні :ref:`String<class_String>` порівняння.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_gt_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gt_StringName>`
|
||
|
||
Повертає ``true``, якщо лівий **StringName** тостер приходить після ``right``. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
|
||
|
||
.. rst-class:: classref-item-separator
|
||
|
||
----
|
||
|
||
.. _class_StringName_operator_gte_StringName:
|
||
|
||
.. rst-class:: classref-operator
|
||
|
||
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gte_StringName>`
|
||
|
||
Повертає ``true``, якщо зліва **StringName** надходить після ``right`` або якщо вони однакові. Зверніть увагу, що це не буде відповідати їхньому `Унікод замовлення <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__.
|
||
|
||
.. |virtual| replace:: :abbr:`virtual (Зазвичай, цей метод перевизначається користувачем, щоб він мав вплив.)`
|
||
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
|
||
.. |const| replace:: :abbr:`const (Цей метод не має побічних ефектів. Не змінює ніяку змінну екземпляра об'єкта.)`
|
||
.. |vararg| replace:: :abbr:`vararg (Цей метод приймає будь-яке число аргументів після описаних тут.)`
|
||
.. |constructor| replace:: :abbr:`constructor (Цей метод використовується для побудови типів.)`
|
||
.. |static| replace:: :abbr:`static (Цей метод не потребує екземпляра для виклику, його можна викликати безпосередньо за допомогою назви класу.)`
|
||
.. |operator| replace:: :abbr:`operator (Цей метод описує дійсний оператор для взаємодії з цим типом як з лівим операндом.)`
|
||
.. |bitfield| replace:: :abbr:`BitField (Це значення є цілим числом, складеним у вигляді бітової маски з наступних прапорів.)`
|
||
.. |void| replace:: :abbr:`void (Значення не повертається.)`
|