:github_url: hide .. _class_StringName: StringName ========== Вбудований тип для унікальних рядків. .. rst-class:: classref-introduction-group Опис -------- **StringName** — це незмінні рядки, призначені для представлення унікальних імен загального призначення (також називається "інтернування рядків"). Два **StringName** з однаковим значенням є одним і тим же об’єктом. Їх порівняння відбувається надзвичайно швидко порівняно зі звичайними :ref:`String`. Зазвичай ви передаєте :ref:`String` методам, які очікують **StringName**, і він буде автоматично перетворений (часто під час компіляції), але в рідкісних випадках ви можете створити **StringName** завчасно за допомогою конструктора **StringName** або, у GDScript, літерального синтаксису ``&"example"``. Ручне створення **StringName** дозволяє контролювати, коли відбувається перетворення з :ref:`String`, або використовувати літерал і повністю запобігати перетворенням. Дивіться також :ref:`NodePath`, який є подібною концепцією, спеціально розробленою для зберігання попередньо проаналізованих шляхів дерева сцен. Усі методи :ref:`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` | :ref:`StringName`\ (\ ) | +-------------------------------------+--------------------------------------------------------------------------------------------------------------+ | :ref:`StringName` | :ref:`StringName`\ (\ from\: :ref:`StringName`\ ) | +-------------------------------------+--------------------------------------------------------------------------------------------------------------+ | :ref:`StringName` | :ref:`StringName`\ (\ from\: :ref:`String`\ ) | +-------------------------------------+--------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Методи ------------ .. table:: :widths: auto +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`begins_with`\ (\ text\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`bigrams`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`bin_to_int`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`c_escape`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`c_unescape`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`capitalize`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`casecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`contains`\ (\ what\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`containsn`\ (\ what\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`count`\ (\ what\: :ref:`String`, from\: :ref:`int` = 0, to\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`countn`\ (\ what\: :ref:`String`, from\: :ref:`int` = 0, to\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`dedent`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`ends_with`\ (\ text\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`erase`\ (\ position\: :ref:`int`, chars\: :ref:`int` = 1\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`filecasecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`filenocasecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`find`\ (\ what\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`findn`\ (\ what\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`format`\ (\ values\: :ref:`Variant`, placeholder\: :ref:`String` = "{_}"\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_base_dir`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_basename`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_extension`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_file`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_slice`\ (\ delimiter\: :ref:`String`, slice\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`get_slice_count`\ (\ delimiter\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`get_slicec`\ (\ delimiter\: :ref:`int`, slice\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`hash`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`hex_decode`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`hex_to_int`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`indent`\ (\ prefix\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`insert`\ (\ position\: :ref:`int`, what\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_absolute_path`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_empty`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_relative_path`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_subsequence_of`\ (\ text\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_subsequence_ofn`\ (\ text\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_ascii_identifier`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_filename`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_float`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_hex_number`\ (\ with_prefix\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_html_color`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_identifier`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_int`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_ip_address`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`is_valid_unicode_identifier`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`join`\ (\ parts\: :ref:`PackedStringArray`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`json_escape`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`left`\ (\ length\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`length`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`lpad`\ (\ min_length\: :ref:`int`, character\: :ref:`String` = " "\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`lstrip`\ (\ chars\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`match`\ (\ expr\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`matchn`\ (\ expr\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`md5_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`md5_text`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`naturalcasecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`naturalnocasecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`nocasecmp_to`\ (\ to\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`pad_decimals`\ (\ digits\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`pad_zeros`\ (\ digits\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`path_join`\ (\ path\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`remove_char`\ (\ what\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`remove_chars`\ (\ chars\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`repeat`\ (\ count\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`replace`\ (\ what\: :ref:`String`, forwhat\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`replace_char`\ (\ key\: :ref:`int`, with\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`replace_chars`\ (\ keys\: :ref:`String`, with\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`replacen`\ (\ what\: :ref:`String`, forwhat\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`reverse`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfind`\ (\ what\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`rfindn`\ (\ what\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`right`\ (\ length\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`rpad`\ (\ min_length\: :ref:`int`, character\: :ref:`String` = " "\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`rsplit`\ (\ delimiter\: :ref:`String` = "", allow_empty\: :ref:`bool` = true, maxsplit\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`rstrip`\ (\ chars\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`sha1_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`sha1_text`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`sha256_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`sha256_text`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`similarity`\ (\ text\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`simplify_path`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedStringArray` | :ref:`split`\ (\ delimiter\: :ref:`String` = "", allow_empty\: :ref:`bool` = true, maxsplit\: :ref:`int` = 0\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedFloat64Array` | :ref:`split_floats`\ (\ delimiter\: :ref:`String`, allow_empty\: :ref:`bool` = true\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`strip_edges`\ (\ left\: :ref:`bool` = true, right\: :ref:`bool` = true\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`strip_escapes`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`substr`\ (\ from\: :ref:`int`, len\: :ref:`int` = -1\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_ascii_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_camel_case`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`float` | :ref:`to_float`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`to_int`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_kebab_case`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_lower`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_multibyte_char_buffer`\ (\ encoding\: :ref:`String` = ""\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_pascal_case`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_snake_case`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`to_upper`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_utf8_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_utf16_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_utf32_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`PackedByteArray` | :ref:`to_wchar_buffer`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`trim_prefix`\ (\ prefix\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`trim_suffix`\ (\ suffix\: :ref:`String`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`int` | :ref:`unicode_at`\ (\ at\: :ref:`int`\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`uri_decode`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`uri_encode`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`uri_file_decode`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`validate_filename`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`validate_node_name`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`xml_escape`\ (\ escape_quotes\: :ref:`bool` = false\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`xml_unescape`\ (\ ) |const| | +-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-reftable-group Оператори ------------------ .. table:: :widths: auto +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`String`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator !=`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`operator %`\ (\ right\: :ref:`Variant`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`operator +`\ (\ right\: :ref:`String`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`String` | :ref:`operator +`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator \<=`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`String`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator ==`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ | :ref:`bool` | :ref:`operator >=`\ (\ right\: :ref:`StringName`\ ) | +-----------------------------+------------------------------------------------------------------------------------------------------------------+ .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи конструкторів -------------------------------------- .. _class_StringName_constructor_StringName: .. rst-class:: classref-constructor :ref:`StringName` **StringName**\ (\ ) :ref:`🔗` Будуємо порожній **StringName**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`StringName` **StringName**\ (\ from\: :ref:`StringName`\ ) Constructs a **StringName** як копія даної **StringName**. .. rst-class:: classref-item-separator ---- .. rst-class:: classref-constructor :ref:`StringName` **StringName**\ (\ from\: :ref:`String`\ ) Створює новий **StringName** з даної :ref:`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` **begins_with**\ (\ text\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``true``, якщо рядок починається з даної ``text``. Дивіться також :ref:`ends_with()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_bigrams: .. rst-class:: classref-method :ref:`PackedStringArray` **bigrams**\ (\ ) |const| :ref:`🔗` Повертає масив, що містить біграми (пари послідовних символів) цього рядка. :: 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` **bin_to_int**\ (\ ) |const| :ref:`🔗` Перетворює рядок, що представляє двійкове число, на :ref:`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` **c_escape**\ (\ ) |const| :ref:`🔗` Повертає копію рядка з особливими героями, які втекли за допомогою стандарту C. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_c_unescape: .. rst-class:: classref-method :ref:`String` **c_unescape**\ (\ ) |const| :ref:`🔗` Повертає копію рядка з втечу символи, заміщеними їх значеннями. Підтримані послідовності втечу ``\'``, ``\"``, ``\\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``. \ **Примітка:** На відміну від парсера GDScript, цей метод не підтримує ``\uXXXX`` послідовність втечу. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_capitalize: .. rst-class:: classref-method :ref:`String` **capitalize**\ (\ ) |const| :ref:`🔗` Змінює зовнішній вигляд рядка: замінює підкреслення (``_``) пробілами, додає пробіли перед великими літерами в середині слова, перетворює всі літери на малі, потім перетворює першу та кожну наступну за пробілом у верхній регістр. .. 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` **casecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Виконує порівняння з іншим рядком з урахуванням регістру. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" та "більше ніж" визначаються за допомогою `кодових точок Unicode `__ кожного рядка, що приблизно відповідає алфавітному порядку. Для рядків різної довжини повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`nocasecmp_to()`, :ref:`filecasecmp_to()` та :ref:`naturalcasecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_contains: .. rst-class:: classref-method :ref:`bool` **contains**\ (\ what\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``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()`. Дивіться також :ref:`міститьn()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_containsn: .. rst-class:: classref-method :ref:`bool` **containsn**\ (\ what\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``true``, якщо рядок містить ``what``, **ігноруючи регістр**. Якщо вам потрібно знати, де знаходиться ``what`` у рядку, використовуйте :ref:`findn()`. Див. також :ref:`contains()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_count: .. rst-class:: classref-method :ref:`int` **count**\ (\ what\: :ref:`String`, from\: :ref:`int` = 0, to\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає кількість входжень підрядка ``what`` між позиціями ``from`` та ``to``. Якщо ``to`` дорівнює 0, пошук продовжується до кінця рядка. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_countn: .. rst-class:: classref-method :ref:`int` **countn**\ (\ what\: :ref:`String`, from\: :ref:`int` = 0, to\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає кількість входжень підрядка ``what`` між позиціями ``from`` і ``to``, **ігноруючи регістр**. Якщо ``to`` дорівнює 0, пошук продовжується до кінця рядка. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_dedent: .. rst-class:: classref-method :ref:`String` **dedent**\ (\ ) |const| :ref:`🔗` Повертає копію рядка без відступів (початкових табуляцій та пробілів). Див. також :ref:`indent()` для додавання відступів. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_ends_with: .. rst-class:: classref-method :ref:`bool` **ends_with**\ (\ text\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``true``, якщо рядок закінчується заданим ``text``. Див. також :ref:`begins_with()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_erase: .. rst-class:: classref-method :ref:`String` **erase**\ (\ position\: :ref:`int`, chars\: :ref:`int` = 1\ ) |const| :ref:`🔗` Повертає рядок, у якому стерто ``chars`` символів, починаючи з ``position``. Якщо ``chars`` перевищує довжину рядка, задану ``position``, з повернутого рядка буде стерто менше символів. Повертає порожній рядок, якщо ``position`` або ``chars`` від'ємні. Повертає вихідний рядок без змін, якщо ``chars`` дорівнює ``0``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_filecasecmp_to: .. rst-class:: classref-method :ref:`int` **filecasecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Подібно до :ref:`naturalcasecmp_to()`, але надає пріоритет рядкам, що починаються з крапок (``.``) та символів підкреслення (``_``) перед будь-яким іншим символом. Корисно під час сортування папок або імен файлів. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`filenocasecmp_to()`, :ref:`naturalcasecmp_to()` та :ref:`casecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_filenocasecmp_to: .. rst-class:: classref-method :ref:`int` **filenocasecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Подібно до :ref:`naturalnocasecmp_to()`, але надає пріоритет рядкам, що починаються з крапок (``.``) та символів підкреслення (``_``) перед будь-яким іншим символом. Корисно під час сортування папок або імен файлів. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`filecasecmp_to()`, :ref:`naturalnocasecmp_to()` та :ref:`nocasecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_find: .. rst-class:: classref-method :ref:`int` **find**\ (\ what\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` 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()`. 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` **findn**\ (\ what\: :ref:`String`, from\: :ref:`int` = 0\ ) |const| :ref:`🔗` Повертає індекс **першого** **без урахування регістру** входження ``what`` у цей рядок, або ``-1``, якщо таких немає. Початковий індекс пошуку можна вказати за допомогою ``from``, продовжуючи до кінця рядка. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_format: .. rst-class:: classref-method :ref:`String` **format**\ (\ values\: :ref:`Variant`, placeholder\: :ref:`String` = "{_}"\ ) |const| :ref:`🔗` Форматує рядок, замінюючи всі входження ``placeholder`` на елементи ``values``. \ ``values`` може бути :ref:`Dictionary`, :ref:`Array` або :ref:`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`. Якщо ``placeholder`` не містить підкреслення, елементи масиву ``values`` будуть використані для заміни одного входження заповнювача в порядку; Якщо елемент ``values`` є іншим 2-елементним масивом, він інтерпретуватиметься як пара ключ-значення. :: # Виводить «Користувач 42 — Godot». print("User {} - {}.".format([42, "Godot"], "{}")) print("User {id} — {name}.".format([["id", 42], ["name", "Godot"]])) Під час передачі :ref:`Object` імена властивостей із :ref:`Object.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# натомість рекомендується `інтерполювати рядки за допомогою "$" `__. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_get_base_dir: .. rst-class:: classref-method :ref:`String` **get_base_dir**\ (\ ) |const| :ref:`🔗` Якщо рядок є дійсним шляхом до файлу, повертає назву основного каталогу. :: 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` **get_basename**\ (\ ) |const| :ref:`🔗` Якщо рядок є дійсним шляхом до файлу, повертає повний шлях до файлу без розширення. :: 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` **get_extension**\ (\ ) |const| :ref:`🔗` Якщо рядок є дійсним ім’ям файлу або шляхом, повертає розширення файлу без початкової крапки (``.``). В іншому випадку повертає порожній рядок. :: 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` **get_file**\ (\ ) |const| :ref:`🔗` Якщо рядок є дійсним шляхом до файлу, повертає ім’я файлу, включаючи розширення. :: 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` **get_slice**\ (\ delimiter\: :ref:`String`, slice\: :ref:`int`\ ) |const| :ref:`🔗` Розділяє рядок за допомогою ``delimiter`` і повертає підрядок за індексом ``slice``. Повертає вихідний рядок, якщо ``delimiter`` не зустрічається в рядку. Повертає порожній рядок, якщо ``slice`` не існує. Це швидше, ніж :ref:`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` **get_slice_count**\ (\ delimiter\: :ref:`String`\ ) |const| :ref:`🔗` Повертає загальну кількість розрізів, коли рядок розділено за допомогою поданого ``delimiter`` (див. :ref:`split()`). .. rst-class:: classref-item-separator ---- .. _class_StringName_method_get_slicec: .. rst-class:: classref-method :ref:`String` **get_slicec**\ (\ delimiter\: :ref:`int`, slice\: :ref:`int`\ ) |const| :ref:`🔗` Розділяє рядок за допомогою символу з Юнікод з кодом ``delimiter`` і повертає підрядок в індексі ``slice``. Повертає порожній рядок, якщо ``slice`` не існує. Це швидше, ніж :ref:`split()`, якщо вам потрібен тільки певний підрядок. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_hash: .. rst-class:: classref-method :ref:`int` **hash**\ (\ ) |const| :ref:`🔗` Повертає значення 32-бітного хешу, що представляє вміст рядків. \ **Примітка:** Рядки з однаковими значеннями хеш *not* гарантовано бути таким же, в результаті зіткнень. Навпаки з різними значеннями хешу гарантовано відрізняються. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_hex_decode: .. rst-class:: classref-method :ref:`PackedByteArray` **hex_decode**\ (\ ) |const| :ref:`🔗` Декодує шістнадцятковий рядок як :ref:`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` **hex_to_int**\ (\ ) |const| :ref:`🔗` Перетворює рядок, що представляє шістнадцяткове число, на :ref:`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` **indent**\ (\ prefix\: :ref:`String`\ ) |const| :ref:`🔗` Змінює відступ кожного рядка за допомогою заданого префікса ``prefix``. Порожні рядки не мають відступів. Див. також :ref:`dedent()` для видалення відступів. Наприклад, рядок може бути відступлений двома табуляціями за допомогою ``"\t\t"`` або чотирма пробілами за допомогою ``" "``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_insert: .. rst-class:: classref-method :ref:`String` **insert**\ (\ position\: :ref:`int`, what\: :ref:`String`\ ) |const| :ref:`🔗` Вставки ``what`` в наданій ``position`` в рядку. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_absolute_path: .. rst-class:: classref-method :ref:`bool` **is_absolute_path**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо рядок є шлях до файлу або каталогу, а початкова точка явно визначена. Цей метод є протилежним :ref:`is_relative_path()`. Це включає в себе всі шляхи, починаючи з ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"`` і т.д. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_empty: .. rst-class:: classref-method :ref:`bool` **is_empty**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо довжина рядка ``0`` (``"""``). Дивись також :ref:`length()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_relative_path: .. rst-class:: classref-method :ref:`bool` **is_relative_path**\ (\ ) |const| :ref:`🔗` Повертаємо ``true``, якщо рядок є шляхом, а початкова точка залежить від контексту. Шлях може початися з поточного каталогу, або поточного :ref:`Node` (якщо рядок виходить з :ref:`NodePath`), а іноді може бути попередньофіксований ``./"``. Цей метод є протилежним :ref:`is_absolute_path()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_subsequence_of: .. rst-class:: classref-method :ref:`bool` **is_subsequence_of**\ (\ text\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``true``, якщо всі символи цього рядка можна знайти в ``text`` у їхньому початковому порядку. Це не те саме, що :ref:`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` **is_subsequence_ofn**\ (\ text\: :ref:`String`\ ) |const| :ref:`🔗` Повертає ``true``, якщо всі символи цього рядка можна знайти в ``text`` у їхньому початковому порядку, **ігноруючи регістр**. Це не те саме, що :ref:`containsn()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_valid_ascii_identifier: .. rst-class:: classref-method :ref:`bool` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗` Повертає ``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()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_valid_filename: .. rst-class:: classref-method :ref:`bool` **is_valid_filename**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо цей рядок є коректним іменем файлу. Коректне ім'я файлу не може бути порожнім, починатися або закінчуватися пробілами або містити заборонені символи (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``). .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_valid_float: .. rst-class:: classref-method :ref:`bool` **is_valid_float**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо цей рядок представляє дійсне число з плаваючою комою. Правильний float може містити лише цифри, одну десяткову крапку (``.``) і літеру експоненти (``e``). Перед ним також може бути позитивний (``+``) або негативний (``-``) знак. Будь-яке дійсне ціле число також є дійсним float (див. :ref:`is_valid_int()`). Дивіться також :ref:`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` **is_valid_hex_number**\ (\ with_prefix\: :ref:`bool` = false\ ) |const| :ref:`🔗` Повертає ``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` **is_valid_html_color**\ (\ ) |const| :ref:`🔗` Повертаємо ``true``, якщо цей рядок є дійсним кольором в шестигранному HTML позначення. Рядок повинен бути шестигранним значенням (див. :ref:`is_valid_hex_number()`) або 3, 4, 6 або 8 цифр, і може бути попередньофіксований знаком хеш (``#``. Інші HTML позначення для кольорів, таких як імена або ``hsl()``, не вважаються дійсними. Дивитися також :ref:`Color.html()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_is_valid_identifier: .. rst-class:: classref-method :ref:`bool` **is_valid_identifier**\ (\ ) |const| :ref:`🔗` **Застаріло:** Use :ref:`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` **is_valid_int**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо цей рядок представляє дійсне ціле число. Дійсне ціле число містить лише цифри та може мати перед собою позитивний (``+``) або негативний (``-``) знак. Дивіться також :ref:`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` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗` Повертає ``true``, якщо цей рядок представляє добре відформатовану адресу IPv4 або IPv6. Цей метод розглядає `зарезервовані IP-адреси `__, наприклад ``"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` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗` Повертає ``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()`. \ **Примітка.** Цей метод перевіряє ідентифікатори так само, як і GDScript. Перегляньте :ref:`TextServer.is_valid_identifier()` для більш розширених перевірок. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_join: .. rst-class:: classref-method :ref:`String` **join**\ (\ parts\: :ref:`PackedStringArray`\ ) |const| :ref:`🔗` Повертає конкатенацію елементів ``parts``, кожен елемент розділений рядком, що викликає цей метод. Цей метод протилежний методу :ref:`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` **json_escape**\ (\ ) |const| :ref:`🔗` Повертає копію рядка з особливими героями, які втекли за допомогою стандарта JSON. Тому що він тісно відповідає стандарту C, можна використовувати :ref:`c_unescape()`, щоб вийти на рядок, якщо це необхідно. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_left: .. rst-class:: classref-method :ref:`String` **left**\ (\ length\: :ref:`int`\ ) |const| :ref:`🔗` Повертає перші ``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` **length**\ (\ ) |const| :ref:`🔗` Повертає кількість символів у рядку. Порожні рядки (``""``) завжди повертають ``0``. Дивіться також :ref:`is_empty()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_lpad: .. rst-class:: classref-method :ref:`String` **lpad**\ (\ min_length\: :ref:`int`, character\: :ref:`String` = " "\ ) |const| :ref:`🔗` Форматує рядок довжиною щонайменше ``min_length``, додаючи ``character`` ліворуч від рядка, якщо необхідно. Див. також :ref:`rpad()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_lstrip: .. rst-class:: classref-method :ref:`String` **lstrip**\ (\ chars\: :ref:`String`\ ) |const| :ref:`🔗` Видаляє набір символів, визначених у ``chars``, з початку рядка. Див. також :ref:`rstrip()`. \ **Примітка:** ``chars`` не є префіксом. Використовуйте :ref:`trim_prefix()` для видалення одного префікса, а не набору символів. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_match: .. rst-class:: classref-method :ref:`bool` **match**\ (\ expr\: :ref:`String`\ ) |const| :ref:`🔗` Чи є простий виразний матч (також називається "glob" або "globbing"), де ``*`` відповідає нульовим або більш довільним символам і ``? `` відповідає будь-якому символу, крім періоду (`` ``. Порожня рядок або порожня експресія завжди оцінюється до ``false``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_matchn: .. rst-class:: classref-method :ref:`bool` **matchn**\ (\ expr\: :ref:`String`\ ) |const| :ref:`🔗` Чи є простий **case-insensitive** вираз матч, де `` *`` відповідає нульовим або більш довільним символам і ``? `` відповідає будь-якому символу, крім періоду (`` ``. Порожня рядок або порожня експресія завжди оцінюється до ``false``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_md5_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **md5_buffer**\ (\ ) |const| :ref:`🔗` Повернення `MD5 хеш `__ рядка як :ref:`PackedByteArray`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_md5_text: .. rst-class:: classref-method :ref:`String` **md5_text**\ (\ ) |const| :ref:`🔗` Повернення `MD5 хеш `__ рядка як ще :ref:`String`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_naturalcasecmp_to: .. rst-class:: classref-method :ref:`int` **naturalcasecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Виконує порівняння з іншим рядком у **регістрово-чутливому**, *природному порядку*. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за `кодовими точками Unicode `__ кожного рядка, що приблизно відповідає алфавітному порядку. Під час використання для сортування порівняння в природному порядку впорядковує послідовності чисел за сумарним значенням кожної цифри, як часто очікується, а не за значенням однієї цифри. Відсортована послідовність нумерованих рядків буде ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``. Якщо довжина рядків різна, повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`naturalnocasecmp_to()`, :ref:`filecasecmp_to()` та :ref:`nocasecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_naturalnocasecmp_to: .. rst-class:: classref-method :ref:`int` **naturalnocasecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Виконує порівняння з іншим рядком у **регістрово-незалежному**, *природному порядку*. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за `кодовими точками Unicode `__ кожного рядка, що приблизно відповідає алфавітному порядку. Внутрішньо малі символи перетворюються на великі для порівняння. Під час використання для сортування порівняння в природному порядку впорядковує послідовності чисел за сумарним значенням кожної цифри, як часто очікується, а не за значенням однієї цифри. Відсортована послідовність нумерованих рядків буде ``["1", "2", "3", ...]``, а не ``["1", "10", "2", "3", ...]``. Якщо довжина рядків різна, повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`naturalcasecmp_to()`, :ref:`filenocasecmp_to()` та :ref:`casecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_nocasecmp_to: .. rst-class:: classref-method :ref:`int` **nocasecmp_to**\ (\ to\: :ref:`String`\ ) |const| :ref:`🔗` Виконує порівняння з іншим рядком **без урахування** регістру. Повертає ``-1``, якщо менше, ``1``, якщо більше, або ``0``, якщо дорівнює. "Менше ніж" або "більше ніж" визначаються за допомогою `кодових точок Unicode `__ кожного рядка, що приблизно відповідає алфавітному порядку. Внутрішньо малі символи перетворюються на великі для порівняння. Для рядків різної довжини повертає ``1``, якщо цей рядок довший за рядок ``to``, або ``-1``, якщо коротший. Зверніть увагу, що довжина порожніх рядків *завжди* ``0``. Щоб отримати результат :ref:`bool` з порівняння рядків, використовуйте оператор ``==``. Див. також :ref:`casecmp_to()`, :ref:`filenocasecmp_to()` та :ref:`naturalnocasecmp_to()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_pad_decimals: .. rst-class:: classref-method :ref:`String` **pad_decimals**\ (\ digits\: :ref:`int`\ ) |const| :ref:`🔗` Формати рядка, що представляє номер, щоб мати точну кількість ``digits`` * після * десятковий пункт. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_pad_zeros: .. rst-class:: classref-method :ref:`String` **pad_zeros**\ (\ digits\: :ref:`int`\ ) |const| :ref:`🔗` Формати рядка, що представляє номер, щоб мати точну кількість ``digits`` *before* десятковий пункт. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_path_join: .. rst-class:: classref-method :ref:`String` **path_join**\ (\ path\: :ref:`String`\ ) |const| :ref:`🔗` Об'єднує ``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` **remove_char**\ (\ what\: :ref:`int`\ ) |const| :ref:`🔗` Видаляє всі входження символу Unicode за допомогою коду ``what``. Швидша версія методу :ref:`replace()`, коли ключ містить лише один символ, а заміна — ``""``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_remove_chars: .. rst-class:: classref-method :ref:`String` **remove_chars**\ (\ chars\: :ref:`String`\ ) |const| :ref:`🔗` Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_repeat: .. rst-class:: classref-method :ref:`String` **repeat**\ (\ count\: :ref:`int`\ ) |const| :ref:`🔗` Повторює цей ряд разів. ``count`` повинен бути більшим, ніж ``0``. В іншому випадку повертає порожній рядок. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_replace: .. rst-class:: classref-method :ref:`String` **replace**\ (\ what\: :ref:`String`, forwhat\: :ref:`String`\ ) |const| :ref:`🔗` Замінює всі входження ``what`` всередині рядка на заданий ``forwhat``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_replace_char: .. rst-class:: classref-method :ref:`String` **replace_char**\ (\ key\: :ref:`int`, with\: :ref:`int`\ ) |const| :ref:`🔗` Замінює всі входження символу Unicode з кодом ``key`` на символ Unicode з кодом ``with``. Швидша версія методу :ref:`replace()`, коли ключ містить лише один символ. Щоб отримати один символ, використовуйте ``"X".unicode_at(0)`` (зверніть увагу, що деякі рядки, такі як складені літери та емодзі, можуть складатися з кількох кодових точок Unicode і не працюватимуть із цим методом, використовуйте :ref:`length()`, щоб переконатися). .. rst-class:: classref-item-separator ---- .. _class_StringName_method_replace_chars: .. rst-class:: classref-method :ref:`String` **replace_chars**\ (\ keys\: :ref:`String`, with\: :ref:`int`\ ) |const| :ref:`🔗` Замінює будь-які символи, що входять до складу ``keys``, символом Unicode з кодом ``with``. Див. також :ref:`replace_char()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_replacen: .. rst-class:: classref-method :ref:`String` **replacen**\ (\ what\: :ref:`String`, forwhat\: :ref:`String`\ ) |const| :ref:`🔗` Замінює всі **case-insensitive** появи ``парам, що`` всередині рядка з наданою ``forwhat``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_reverse: .. rst-class:: classref-method :ref:`String` **reverse**\ (\ ) |const| :ref:`🔗` Повернення копії цього рядка в зворотному порядку. Ця операція працює на пунктах коду унікоду, а не послідовностей точок коду, і може розбити речі, такі як складні листи або смайлики. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_rfind: .. rst-class:: classref-method :ref:`int` **rfind**\ (\ what\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` 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()`. \ **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` **rfindn**\ (\ what\: :ref:`String`, from\: :ref:`int` = -1\ ) |const| :ref:`🔗` Повертає індекс **останнього** **без урахування регістру** входження ``what`` у цей рядок, або ``-1``, якщо таких немає. Початковий індекс пошуку можна вказати за допомогою ``from``, продовжуючи до початку рядка. Цей метод є зворотним до :ref:`findn()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_right: .. rst-class:: classref-method :ref:`String` **right**\ (\ length\: :ref:`int`\ ) |const| :ref:`🔗` Повертає останні символи ``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` **rpad**\ (\ min_length\: :ref:`int`, character\: :ref:`String` = " "\ ) |const| :ref:`🔗` Форматує рядок так, щоб він мав довжину щонайменше ``min_length``, додаючи ``character`` праворуч від рядка, якщо необхідно. Див. також :ref:`lpad()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_rsplit: .. rst-class:: classref-method :ref:`PackedStringArray` **rsplit**\ (\ delimiter\: :ref:`String` = "", allow_empty\: :ref:`bool` = true, maxsplit\: :ref:`int` = 0\ ) |const| :ref:`🔗` Розділяє рядок за допомогою ``delimiter`` і повертає масив підрядків, починаючи з кінця рядка. Розбиття у повернутому масиві з’являється в тому самому порядку, що й вихідний рядок. Якщо ``delimiter`` є порожнім рядком, кожен підрядок буде одним символом. Якщо ``allow_empty`` має значення ``false``, порожні рядки між суміжними роздільниками виключаються з масиву. Якщо ``maxsplit`` більший за ``0``, кількість розділень не може перевищувати ``maxsplit``. За замовчуванням весь рядок розділено, що здебільшого ідентично :ref:`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` **rstrip**\ (\ chars\: :ref:`String`\ ) |const| :ref:`🔗` Видаляє набір символів, визначених у ``chars``, з кінця рядка. Див. також :ref:`lstrip()`. \ **Примітка:** ``chars`` не є суфіксом. Використовуйте :ref:`trim_suffix()` для видалення одного суфікса, а не набору символів. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_sha1_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **sha1_buffer**\ (\ ) |const| :ref:`🔗` Повертаємо `SHA-1 `__ хеш рядка як :ref:`PackedByteArray`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_sha1_text: .. rst-class:: classref-method :ref:`String` **sha1_text**\ (\ ) |const| :ref:`🔗` Повертаємо `SHA-1 `__ хеш рядка в іншому :ref:`String`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_sha256_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **sha256_buffer**\ (\ ) |const| :ref:`🔗` Повертаємо `SHA-256 `__ хеш рядка як :ref:`PackedByteArray`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_sha256_text: .. rst-class:: classref-method :ref:`String` **sha256_text**\ (\ ) |const| :ref:`🔗` Повертаємо `SHA-256 `__ хеш рядка в іншому :ref:`String`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_similarity: .. rst-class:: classref-method :ref:`float` **similarity**\ (\ text\: :ref:`String`\ ) |const| :ref:`🔗` Повертає індекс подібності (`коефіцієнт Соренсена-Діса `__) цього рядка порівняно з іншим. Результат ``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` **simplify_path**\ (\ ) |const| :ref:`🔗` Якщо рядок є дійсним шляхом до файлу, перетворює рядок на канонічний шлях. Це найкоротший можливий шлях, без ``"./"`` і всього непотрібного ``".."`` і ``"/"``. :: 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` **split**\ (\ delimiter\: :ref:`String` = "", allow_empty\: :ref:`bool` = true, maxsplit\: :ref:`int` = 0\ ) |const| :ref:`🔗` Розділяє рядок за допомогою ``delimiter`` і повертає масив підрядків. Якщо ``delimiter`` є порожнім рядком, кожен підрядок буде одним символом. Цей метод протилежний методу :ref:`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()`, який є швидшим. Якщо вам потрібно розділити рядки за більш складними правилами, замість цього використовуйте клас :ref:`RegEx`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_split_floats: .. rst-class:: classref-method :ref:`PackedFloat64Array` **split_floats**\ (\ delimiter\: :ref:`String`, allow_empty\: :ref:`bool` = true\ ) |const| :ref:`🔗` Розділяє рядок на плаваючі числа за допомогою ``delimiter`` і повертає :ref:`PackedFloat64Array`. Якщо ``allow_empty`` має значення ``false``, порожні або недійсні перетворення :ref:`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` **strip_edges**\ (\ left\: :ref:`bool` = true, right\: :ref:`bool` = true\ ) |const| :ref:`🔗` Роздягання всіх немаркованих символів з початку і кінця рядка. До них відносяться пробіли, вкладки (``\t``), а також нові лінії (``\n`` ``\r``). Якщо ``зліва`` ``false``, ігнорує початок рядка. Так само, якщо ``right`` ``false``, ігнорує кінець рядка. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_strip_escapes: .. rst-class:: classref-method :ref:`String` **strip_escapes**\ (\ ) |const| :ref:`🔗` Смуги всі символи втечу з рядка. До них відносяться всі немарковані символи керування першої сторінки таблиці ASCII (значення від 0 до 31), такі як таблифікація (``\t``) та нова лінія (``\n``, ``\r``) символи, але *not*. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_substr: .. rst-class:: classref-method :ref:`String` **substr**\ (\ from\: :ref:`int`, len\: :ref:`int` = -1\ ) |const| :ref:`🔗` Повертає частину рядка з позиції ``from`` довжиною ``len``. Якщо ``len`` дорівнює ``-1`` (як за замовчуванням), повертає решту рядка, починаючи з заданої позиції. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_ascii_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗` Конвертує рядок на ` ASCII `__/Latin-1 кодовано :ref:`PackedByteArray`. Цей метод трохи швидше :ref:`to_utf8_buffer()`, але замінює всі непідтримані символи з пробілами. This is the inverse of :ref:`PackedByteArray.get_string_from_ascii()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_camel_case: .. rst-class:: classref-method :ref:`String` **to_camel_case**\ (\ ) |const| :ref:`🔗` Повертає рядок, перетворена на ``camelCase``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_float: .. rst-class:: classref-method :ref:`float` **to_float**\ (\ ) |const| :ref:`🔗` Перетворює рядок, що представляє десяткове число, у :ref:`float`. Цей метод зупиняється на першому нечисловому символі, за винятком першої десяткової коми (``.``) і літери експоненти (``e``). Дивіться також :ref:`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` **to_int**\ (\ ) |const| :ref:`🔗` Перетворює рядок, що представляє ціле число, на :ref:`int`. Цей метод видаляє будь-який нечисловий символ і зупиняється на першій десятковій комі (``.``). Дивіться також :ref:`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` **to_kebab_case**\ (\ ) |const| :ref:`🔗` Повертає рядок, перетворений на ``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` **to_lower**\ (\ ) |const| :ref:`🔗` Повертає рядок, що перетворюється на ``низ ``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_multibyte_char_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String` = ""\ ) |const| :ref:`🔗` Перетворює рядок на системну багатобайтову кодову сторінку, закодовану як :ref:`PackedByteArray`. Якщо перетворення не вдається, повертається порожній масив. Дозволені значення для ``encoding`` залежать від системи. Якщо ``encoding`` – це порожній рядок, використовується системне кодування за замовчуванням. - Для Windows див. `Ідентифікатори кодових сторінок `__ імена .NET. - Для macOS та Linux/BSD див. документацію до бібліотеки ``libiconv`` та ``iconv --list`` для списку підтримуваних кодувань. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_pascal_case: .. rst-class:: classref-method :ref:`String` **to_pascal_case**\ (\ ) |const| :ref:`🔗` Повертає рядок, перетворена на ``ПаскалаКаза``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_snake_case: .. rst-class:: classref-method :ref:`String` **to_snake_case**\ (\ ) |const| :ref:`🔗` Повертає рядок, перетворений на ``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` **to_upper**\ (\ ) |const| :ref:`🔗` Повертає рядок, що перетворюється на ``UPPERCASE``. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_utf8_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗` Конвертує рядок на `UTF-8 `__\ кодовано :ref:`PackedByteArray`. Цей метод дещо повільний, ніж ``метод_ascii_buffer``, але підтримує всі символи UTF-8. Для більшості випадків, віддають перевагу цим методом. This is the inverse of :ref:`PackedByteArray.get_string_from_utf8()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_utf16_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗` Конвертує рядок на `UTF-16 `__\ кодовано :ref:`PackedByteArray`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf16()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_utf32_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗` Конвертує рядок на `UTF-32 `__\ кодовано :ref:`PackedByteArray`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf32()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_to_wchar_buffer: .. rst-class:: classref-method :ref:`PackedByteArray` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗` Перетворює рядок на `широкий характер `__ (``wchar_t``, UTF-16 на Windows, UTF-32 на інших платформах) закодовано :ref:`PackedByteArray`. This is the inverse of :ref:`PackedByteArray.get_string_from_wchar()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_trim_prefix: .. rst-class:: classref-method :ref:`String` **trim_prefix**\ (\ prefix\: :ref:`String`\ ) |const| :ref:`🔗` Видаляє заданий префікс ``prefix`` з початку рядка або повертає рядок без змін. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_trim_suffix: .. rst-class:: classref-method :ref:`String` **trim_suffix**\ (\ suffix\: :ref:`String`\ ) |const| :ref:`🔗` Видаліть задану ``prefix`` з кінця рядка, або повертає рядок незмінним. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_unicode_at: .. rst-class:: classref-method :ref:`int` **unicode_at**\ (\ at\: :ref:`int`\ ) |const| :ref:`🔗` Повертає код символу в позиції ``at``. Див. також :ref:`String.chr()`, :ref:`@GDScript.char()` та :ref:`@GDScript.ord()`. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_uri_decode: .. rst-class:: classref-method :ref:`String` **uri_decode**\ (\ ) |const| :ref:`🔗` Декодує рядок з його формату, закодованого за URL-адресою. Цей метод призначений для правильного декодування параметрів в URL-адресі під час отримання HTTP-запиту. Див. також :ref:`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` **uri_encode**\ (\ ) |const| :ref:`🔗` Кодує рядок до URL-дружнього формату. Цей метод призначений для правильного кодування параметрів в URL-адресі під час надсилання запиту HTTP. Дивіться також :ref:`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` **uri_file_decode**\ (\ ) |const| :ref:`🔗` Декодує шлях до файлу з його URL-кодованого формату. На відміну від методу :ref:`uri_decode()`, цей метод залишає ``+`` як є. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_validate_filename: .. rst-class:: classref-method :ref:`String` **validate_filename**\ (\ ) |const| :ref:`🔗` Повертає копію рядка, в якому всі символи, недозволені в :ref:`is_valid_filename()`, замінені на символи підкреслення. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_validate_node_name: .. rst-class:: classref-method :ref:`String` **validate_node_name**\ (\ ) |const| :ref:`🔗` Повертає копію рядка з усіма символами, які не дозволені в :ref:`Node.name` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) замінено підкресленням. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_xml_escape: .. rst-class:: classref-method :ref:`String` **xml_escape**\ (\ escape_quotes\: :ref:`bool` = false\ ) |const| :ref:`🔗` Повертає копію рядка зі спеціальними символами, екранованими за допомогою стандарту XML. Якщо ``escape_quotes`` має значення ``true``, символи одинарних лапок (``'``) і подвійних лапок (``"``) також екрануються. .. rst-class:: classref-item-separator ---- .. _class_StringName_method_xml_unescape: .. rst-class:: classref-method :ref:`String` **xml_unescape**\ (\ ) |const| :ref:`🔗` Повертає копію рядка з вбитими символами, заміненими на їх значення відповідно до стандарту XML. .. rst-class:: classref-section-separator ---- .. rst-class:: classref-descriptions-group Описи операторів -------------------------------- .. _class_StringName_operator_neq_String: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`String`\ ) :ref:`🔗` Повертає ``true``, якщо це **StringName** не еквівалентно даній :ref:`String`. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_neq_StringName: .. rst-class:: classref-operator :ref:`bool` **operator !=**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертає ``true``, якщо **StringName** і ``right`` не відноситься до тієї ж назви. Порівняння між **StringName** набагато швидше, ніж регулярні :ref:`String` порівняння. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_mod_Variant: .. rst-class:: classref-operator :ref:`String` **operator %**\ (\ right\: :ref:`Variant`\ ) :ref:`🔗` Форматує **StringName**, замінюючи заповнювачі одним або кількома параметрами, повертаючи :ref:`String`. Щоб передати кілька параметрів, ``right`` має бути масивом :ref:`Array`. Для отримання додаткової інформації див. навчальний посібник :doc:`Рядки формату GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`. \ **Примітка:** У C# цей оператор недоступний. Натомість див. `як інтерполювати рядки за допомогою "$" `__. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_sum_String: .. rst-class:: classref-operator :ref:`String` **operator +**\ (\ right\: :ref:`String`\ ) :ref:`🔗` Додатки ``right`` в кінці цього **StringName**, повернення :ref:`String`. Це також відомий як рядок конкатенації. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_sum_StringName: .. rst-class:: classref-operator :ref:`String` **operator +**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Додатки ``right`` в кінці цього **StringName**, повернення :ref:`String`. Це також відомий як рядок конкатенації. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_lt_StringName: .. rst-class:: classref-operator :ref:`bool` **operator <**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертаємо ``true``, якщо зліва **StringName** надходить до ``right``. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення `__. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_lte_StringName: .. rst-class:: classref-operator :ref:`bool` **operator <=**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертаємо ``true``, якщо зліва **StringName** надходить до ``right`` або якщо вони однакові. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення `__. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_eq_String: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`String`\ ) :ref:`🔗` Повертає ``true``, якщо це **StringName** еквівалентно даній :ref:`String`. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_eq_StringName: .. rst-class:: classref-operator :ref:`bool` **operator ==**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертає ``true``, якщо **StringName** і ``right`` відносяться до тієї ж назви. Порівняння між **StringName** набагато швидше, ніж регулярні :ref:`String` порівняння. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_gt_StringName: .. rst-class:: classref-operator :ref:`bool` **operator >**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертає ``true``, якщо лівий **StringName** тостер приходить після ``right``. Зверніть увагу, що це не буде відповідати їхньому `Юнікод замовлення `__. .. rst-class:: classref-item-separator ---- .. _class_StringName_operator_gte_StringName: .. rst-class:: classref-operator :ref:`bool` **operator >=**\ (\ right\: :ref:`StringName`\ ) :ref:`🔗` Повертає ``true``, якщо зліва **StringName** надходить після ``right`` або якщо вони однакові. Зверніть увагу, що це не буде відповідати їхньому `Унікод замовлення `__. .. |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 (Значення не повертається.)`