godot-docs/classes/class_string.rst

:github_url: hide

.. DO NOT EDIT THIS FILE!!!
.. Generated automatically from Godot engine sources.
.. Generator: https://github.com/godotengine/godot/tree/master/doc/tools/make_rst.py.
.. XML source: https://github.com/godotengine/godot/tree/master/doc/classes/String.xml.

.. _class_String:

String
======

A built-in type for strings.

.. rst-class:: classref-introduction-group

Description
-----------

This is the built-in string Variant type (and the one used by GDScript). Strings may contain any number of Unicode characters, and expose methods useful for manipulating and generating strings. Strings are reference-counted and use a copy-on-write approach (every modification to a string returns a new **String**), so passing them around is cheap in resources.

Some string methods have corresponding variations. Variations suffixed with ``n`` (:ref:`countn()<class_String_method_countn>`, :ref:`findn()<class_String_method_findn>`, :ref:`replacen()<class_String_method_replacen>`, etc.) are **case-insensitive** (they make no distinction between uppercase and lowercase letters). Method variations prefixed with ``r`` (:ref:`rfind()<class_String_method_rfind>`, :ref:`rsplit()<class_String_method_rsplit>`, etc.) are reversed, and start from the end of the string, instead of the beginning.

To convert any :ref:`Variant<class_Variant>` to or from a string, see :ref:`@GlobalScope.str()<class_@GlobalScope_method_str>`, :ref:`@GlobalScope.str_to_var()<class_@GlobalScope_method_str_to_var>`, and :ref:`@GlobalScope.var_to_str()<class_@GlobalScope_method_var_to_str>`.

\ **Note:** In a boolean context, a string will evaluate to ``false`` if it is empty (``""``). Otherwise, a string will always evaluate to ``true``.

.. note::

	There are notable differences when using this API with C#. See :ref:`doc_c_sharp_differences` for more information.

.. rst-class:: classref-introduction-group

Tutorials
---------

- :doc:`GDScript format strings <../tutorials/scripting/gdscript/gdscript_format_string>`

.. rst-class:: classref-reftable-group

Constructors
------------

.. table::
   :widths: auto

   +-----------------------------+--------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ )                                             |
   +-----------------------------+--------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`String<class_String>`\ )         |
   +-----------------------------+--------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`NodePath<class_NodePath>`\ )     |
   +-----------------------------+--------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
   +-----------------------------+--------------------------------------------------------------------------------------------------+

.. rst-class:: classref-reftable-group

Methods
-------

.. table::
   :widths: auto

   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`begins_with<class_String_method_begins_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const|                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedStringArray<class_PackedStringArray>`   | :ref:`bigrams<class_String_method_bigrams>`\ (\ ) |const|                                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`bin_to_int<class_String_method_bin_to_int>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`c_escape<class_String_method_c_escape>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`c_unescape<class_String_method_c_unescape>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`capitalize<class_String_method_capitalize>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`casecmp_to<class_String_method_casecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`chr<class_String_method_chr>`\ (\ code\: :ref:`int<class_int>`\ ) |static|                                                                                                          |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`contains<class_String_method_contains>`\ (\ what\: :ref:`String<class_String>`\ ) |const|                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`containsn<class_String_method_containsn>`\ (\ what\: :ref:`String<class_String>`\ ) |const|                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`count<class_String_method_count>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const|                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`countn<class_String_method_countn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const|                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`dedent<class_String_method_dedent>`\ (\ ) |const|                                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`ends_with<class_String_method_ends_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const|                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`erase<class_String_method_erase>`\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const|                                                                |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`filecasecmp_to<class_String_method_filecasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`filenocasecmp_to<class_String_method_filenocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`find<class_String_method_find>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const|                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`findn<class_String_method_findn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const|                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`format<class_String_method_format>`\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const|                                        |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_base_dir<class_String_method_get_base_dir>`\ (\ ) |const|                                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_basename<class_String_method_get_basename>`\ (\ ) |const|                                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_extension<class_String_method_get_extension>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_file<class_String_method_get_file>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_slice<class_String_method_get_slice>`\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const|                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`get_slice_count<class_String_method_get_slice_count>`\ (\ delimiter\: :ref:`String<class_String>`\ ) |const|                                                                        |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`get_slicec<class_String_method_get_slicec>`\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const|                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`hash<class_String_method_hash>`\ (\ ) |const|                                                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`hex_decode<class_String_method_hex_decode>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`hex_to_int<class_String_method_hex_to_int>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`humanize_size<class_String_method_humanize_size>`\ (\ size\: :ref:`int<class_int>`\ ) |static|                                                                                      |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`indent<class_String_method_indent>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const|                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`insert<class_String_method_insert>`\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const|                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_absolute_path<class_String_method_is_absolute_path>`\ (\ ) |const|                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_empty<class_String_method_is_empty>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_relative_path<class_String_method_is_relative_path>`\ (\ ) |const|                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_subsequence_of<class_String_method_is_subsequence_of>`\ (\ text\: :ref:`String<class_String>`\ ) |const|                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_subsequence_ofn<class_String_method_is_subsequence_ofn>`\ (\ text\: :ref:`String<class_String>`\ ) |const|                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_ascii_identifier<class_String_method_is_valid_ascii_identifier>`\ (\ ) |const|                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_filename<class_String_method_is_valid_filename>`\ (\ ) |const|                                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_float<class_String_method_is_valid_float>`\ (\ ) |const|                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_hex_number<class_String_method_is_valid_hex_number>`\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const|                                                          |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_html_color<class_String_method_is_valid_html_color>`\ (\ ) |const|                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_identifier<class_String_method_is_valid_identifier>`\ (\ ) |const|                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_int<class_String_method_is_valid_int>`\ (\ ) |const|                                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_ip_address<class_String_method_is_valid_ip_address>`\ (\ ) |const|                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`is_valid_unicode_identifier<class_String_method_is_valid_unicode_identifier>`\ (\ ) |const|                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`join<class_String_method_join>`\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const|                                                                            |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`json_escape<class_String_method_json_escape>`\ (\ ) |const|                                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`left<class_String_method_left>`\ (\ length\: :ref:`int<class_int>`\ ) |const|                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`length<class_String_method_length>`\ (\ ) |const|                                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`lpad<class_String_method_lpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const|                                                    |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`lstrip<class_String_method_lstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const|                                                                                              |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`match<class_String_method_match>`\ (\ expr\: :ref:`String<class_String>`\ ) |const|                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`                             | :ref:`matchn<class_String_method_matchn>`\ (\ expr\: :ref:`String<class_String>`\ ) |const|                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`md5_buffer<class_String_method_md5_buffer>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`md5_text<class_String_method_md5_text>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`naturalcasecmp_to<class_String_method_naturalcasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`naturalnocasecmp_to<class_String_method_naturalnocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`nocasecmp_to<class_String_method_nocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const|                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`num<class_String_method_num>`\ (\ number\: :ref:`float<class_float>`, decimals\: :ref:`int<class_int>` = -1\ ) |static|                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`num_int64<class_String_method_num_int64>`\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static|       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`num_scientific<class_String_method_num_scientific>`\ (\ number\: :ref:`float<class_float>`\ ) |static|                                                                              |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`num_uint64<class_String_method_num_uint64>`\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static|     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`pad_decimals<class_String_method_pad_decimals>`\ (\ digits\: :ref:`int<class_int>`\ ) |const|                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`pad_zeros<class_String_method_pad_zeros>`\ (\ digits\: :ref:`int<class_int>`\ ) |const|                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`path_join<class_String_method_path_join>`\ (\ path\: :ref:`String<class_String>`\ ) |const|                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`remove_char<class_String_method_remove_char>`\ (\ what\: :ref:`int<class_int>`\ ) |const|                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`remove_chars<class_String_method_remove_chars>`\ (\ chars\: :ref:`String<class_String>`\ ) |const|                                                                                  |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`repeat<class_String_method_repeat>`\ (\ count\: :ref:`int<class_int>`\ ) |const|                                                                                                    |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`replace<class_String_method_replace>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const|                                                      |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`replace_char<class_String_method_replace_char>`\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const|                                                            |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`replace_chars<class_String_method_replace_chars>`\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const|                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`replacen<class_String_method_replacen>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const|                                                    |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`reverse<class_String_method_reverse>`\ (\ ) |const|                                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`rfind<class_String_method_rfind>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const|                                                              |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`rfindn<class_String_method_rfindn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const|                                                            |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`right<class_String_method_right>`\ (\ length\: :ref:`int<class_int>`\ ) |const|                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`rpad<class_String_method_rpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const|                                                    |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedStringArray<class_PackedStringArray>`   | :ref:`rsplit<class_String_method_rsplit>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`rstrip<class_String_method_rstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const|                                                                                              |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`sha1_buffer<class_String_method_sha1_buffer>`\ (\ ) |const|                                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`sha1_text<class_String_method_sha1_text>`\ (\ ) |const|                                                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`sha256_buffer<class_String_method_sha256_buffer>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`sha256_text<class_String_method_sha256_text>`\ (\ ) |const|                                                                                                                         |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                           | :ref:`similarity<class_String_method_similarity>`\ (\ text\: :ref:`String<class_String>`\ ) |const|                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`simplify_path<class_String_method_simplify_path>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedStringArray<class_PackedStringArray>`   | :ref:`split<class_String_method_split>`\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const|   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedFloat64Array<class_PackedFloat64Array>` | :ref:`split_floats<class_String_method_split_floats>`\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const|                                |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`strip_edges<class_String_method_strip_edges>`\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const|                                          |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`strip_escapes<class_String_method_strip_escapes>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`substr<class_String_method_substr>`\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const|                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_ascii_buffer<class_String_method_to_ascii_buffer>`\ (\ ) |const|                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_camel_case<class_String_method_to_camel_case>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`float<class_float>`                           | :ref:`to_float<class_String_method_to_float>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`to_int<class_String_method_to_int>`\ (\ ) |const|                                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_kebab_case<class_String_method_to_kebab_case>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_lower<class_String_method_to_lower>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_multibyte_char_buffer<class_String_method_to_multibyte_char_buffer>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const|                                                  |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_pascal_case<class_String_method_to_pascal_case>`\ (\ ) |const|                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_snake_case<class_String_method_to_snake_case>`\ (\ ) |const|                                                                                                                     |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`to_upper<class_String_method_to_upper>`\ (\ ) |const|                                                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_utf8_buffer<class_String_method_to_utf8_buffer>`\ (\ ) |const|                                                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_utf16_buffer<class_String_method_to_utf16_buffer>`\ (\ ) |const|                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_utf32_buffer<class_String_method_to_utf32_buffer>`\ (\ ) |const|                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_wchar_buffer<class_String_method_to_wchar_buffer>`\ (\ ) |const|                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`trim_prefix<class_String_method_trim_prefix>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const|                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`trim_suffix<class_String_method_trim_suffix>`\ (\ suffix\: :ref:`String<class_String>`\ ) |const|                                                                                   |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`int<class_int>`                               | :ref:`unicode_at<class_String_method_unicode_at>`\ (\ at\: :ref:`int<class_int>`\ ) |const|                                                                                               |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`uri_decode<class_String_method_uri_decode>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`uri_encode<class_String_method_uri_encode>`\ (\ ) |const|                                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`uri_file_decode<class_String_method_uri_file_decode>`\ (\ ) |const|                                                                                                                 |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`validate_filename<class_String_method_validate_filename>`\ (\ ) |const|                                                                                                             |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`validate_node_name<class_String_method_validate_node_name>`\ (\ ) |const|                                                                                                           |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`xml_escape<class_String_method_xml_escape>`\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const|                                                                          |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>`                         | :ref:`xml_unescape<class_String_method_xml_unescape>`\ (\ ) |const|                                                                                                                       |
   +-----------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-reftable-group

Operators
---------

.. table::
   :widths: auto

   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator !=<class_String_operator_neq_String>`\ (\ right\: :ref:`String<class_String>`\ )             |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator !=<class_String_operator_neq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`operator %<class_String_operator_mod_Variant>`\ (\ right\: :ref:`Variant<class_Variant>`\ )           |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`operator +<class_String_operator_sum_String>`\ (\ right\: :ref:`String<class_String>`\ )              |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`operator +<class_String_operator_sum_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ )  |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator \<<class_String_operator_lt_String>`\ (\ right\: :ref:`String<class_String>`\ )              |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator \<=<class_String_operator_lte_String>`\ (\ right\: :ref:`String<class_String>`\ )            |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator ==<class_String_operator_eq_String>`\ (\ right\: :ref:`String<class_String>`\ )              |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator ==<class_String_operator_eq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ )  |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator ><class_String_operator_gt_String>`\ (\ right\: :ref:`String<class_String>`\ )               |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`bool<class_bool>`     | :ref:`operator >=<class_String_operator_gte_String>`\ (\ right\: :ref:`String<class_String>`\ )             |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+
   | :ref:`String<class_String>` | :ref:`operator []<class_String_operator_idx_int>`\ (\ index\: :ref:`int<class_int>`\ )                      |
   +-----------------------------+-------------------------------------------------------------------------------------------------------------+

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Constructor Descriptions
------------------------

.. _class_String_constructor_String:

.. rst-class:: classref-constructor

:ref:`String<class_String>` **String**\ (\ ) :ref:`🔗<class_String_constructor_String>`

Constructs an empty **String** (``""``).

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`String<class_String>` **String**\ (\ from\: :ref:`String<class_String>`\ )

Constructs a **String** as a copy of the given **String**.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`String<class_String>` **String**\ (\ from\: :ref:`NodePath<class_NodePath>`\ )

Constructs a new **String** from the given :ref:`NodePath<class_NodePath>`.

.. rst-class:: classref-item-separator

----

.. rst-class:: classref-constructor

:ref:`String<class_String>` **String**\ (\ from\: :ref:`StringName<class_StringName>`\ )

Constructs a new **String** from the given :ref:`StringName<class_StringName>`.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Method Descriptions
-------------------

.. _class_String_method_begins_with:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **begins_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_begins_with>`

Returns ``true`` if the string begins with the given ``text``. See also :ref:`ends_with()<class_String_method_ends_with>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_bigrams:

.. rst-class:: classref-method

:ref:`PackedStringArray<class_PackedStringArray>` **bigrams**\ (\ ) |const| :ref:`🔗<class_String_method_bigrams>`

Returns an array containing the bigrams (pairs of consecutive characters) of this string.

::

    print("Get up!".bigrams()) # Prints ["Ge", "et", "t ", " u", "up", "p!"]

.. rst-class:: classref-item-separator

----

.. _class_String_method_bin_to_int:

.. rst-class:: classref-method

:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_String_method_bin_to_int>`

Converts the string representing a binary number into an :ref:`int<class_int>`. The string may optionally be prefixed with ``"0b"``, and an additional ``-`` prefix for negative numbers.


.. tabs::

 .. code-tab:: gdscript

    print("101".bin_to_int())   # Prints 5
    print("0b101".bin_to_int()) # Prints 5
    print("-0b10".bin_to_int()) # Prints -2

 .. code-tab:: csharp

    GD.Print("101".BinToInt());   // Prints 5
    GD.Print("0b101".BinToInt()); // Prints 5
    GD.Print("-0b10".BinToInt()); // Prints -2



.. rst-class:: classref-item-separator

----

.. _class_String_method_c_escape:

.. rst-class:: classref-method

:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_String_method_c_escape>`

Returns a copy of the string with special characters escaped using the C language standard.

.. rst-class:: classref-item-separator

----

.. _class_String_method_c_unescape:

.. rst-class:: classref-method

:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_String_method_c_unescape>`

Returns a copy of the string with escaped characters replaced by their meanings. Supported escape sequences are ``\'``, ``\"``, ``\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.

\ **Note:** Unlike the GDScript parser, this method doesn't support the ``\uXXXX`` escape sequence.

.. rst-class:: classref-item-separator

----

.. _class_String_method_capitalize:

.. rst-class:: classref-method

:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_String_method_capitalize>`

Changes the appearance of the string: replaces underscores (``_``) with spaces, adds spaces before uppercase letters in the middle of a word, converts all letters to lowercase, then converts the first one and each one following a space to uppercase.


.. tabs::

 .. code-tab:: gdscript

    "move_local_x".capitalize()   # Returns "Move Local X"
    "sceneFile_path".capitalize() # Returns "Scene File Path"
    "2D, FPS, PNG".capitalize()   # Returns "2d, Fps, Png"

 .. code-tab:: csharp

    "move_local_x".Capitalize();   // Returns "Move Local X"
    "sceneFile_path".Capitalize(); // Returns "Scene File Path"
    "2D, FPS, PNG".Capitalize();   // Returns "2d, Fps, Png"



.. rst-class:: classref-item-separator

----

.. _class_String_method_casecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_casecmp_to>`

Performs a case-sensitive comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" and "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order.

If the character comparison reaches the end of one string, but the other string contains more characters, then it will use length as the deciding factor: ``1`` will be returned if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is always ``0``.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, and :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_chr:

.. rst-class:: classref-method

:ref:`String<class_String>` **chr**\ (\ code\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_String_method_chr>`

Returns a single Unicode character from the integer ``code``. You may use `unicodelookup.com <https://unicodelookup.com/>`__ or `unicode.org <https://www.unicode.org/charts/>`__ as points of reference.

::

    print(String.chr(65))     # Prints "A"
    print(String.chr(129302)) # Prints "🤖" (robot face emoji)

See also :ref:`unicode_at()<class_String_method_unicode_at>`, :ref:`@GDScript.char()<class_@GDScript_method_char>`, and :ref:`@GDScript.ord()<class_@GDScript_method_ord>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_contains:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_contains>`

Returns ``true`` if the string contains ``what``. In GDScript, this corresponds to the ``in`` operator.


.. tabs::

 .. code-tab:: gdscript

    print("Node".contains("de")) # Prints true
    print("team".contains("I"))  # Prints false
    print("I" in "team")         # Prints false

 .. code-tab:: csharp

    GD.Print("Node".Contains("de")); // Prints True
    GD.Print("team".Contains("I"));  // Prints False



If you need to know where ``what`` is within the string, use :ref:`find()<class_String_method_find>`. See also :ref:`containsn()<class_String_method_containsn>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_containsn:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_containsn>`

Returns ``true`` if the string contains ``what``, **ignoring case**.

If you need to know where ``what`` is within the string, use :ref:`findn()<class_String_method_findn>`. See also :ref:`contains()<class_String_method_contains>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_count:

.. rst-class:: classref-method

:ref:`int<class_int>` **count**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_count>`

Returns the number of occurrences of the substring ``what`` between ``from`` and ``to`` positions. If ``to`` is 0, the search continues until the end of the string.

.. rst-class:: classref-item-separator

----

.. _class_String_method_countn:

.. rst-class:: classref-method

:ref:`int<class_int>` **countn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0, to\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_countn>`

Returns the number of occurrences of the substring ``what`` between ``from`` and ``to`` positions, **ignoring case**. If ``to`` is 0, the search continues until the end of the string.

.. rst-class:: classref-item-separator

----

.. _class_String_method_dedent:

.. rst-class:: classref-method

:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_String_method_dedent>`

Returns a copy of the string with indentation (leading tabs and spaces) removed. See also :ref:`indent()<class_String_method_indent>` to add indentation.

.. rst-class:: classref-item-separator

----

.. _class_String_method_ends_with:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_ends_with>`

Returns ``true`` if the string ends with the given ``text``. See also :ref:`begins_with()<class_String_method_begins_with>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_erase:

.. rst-class:: classref-method

:ref:`String<class_String>` **erase**\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| :ref:`🔗<class_String_method_erase>`

Returns a string with ``chars`` characters erased starting from ``position``. If ``chars`` goes beyond the string's length given the specified ``position``, fewer characters will be erased from the returned string. Returns an empty string if either ``position`` or ``chars`` is negative. Returns the original string unmodified if ``chars`` is ``0``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_filecasecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_filecasecmp_to>`

Like :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` but prioritizes strings that begin with periods (``.``) and underscores (``_``) before any other character. Useful when sorting folders or file names.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, and :ref:`casecmp_to()<class_String_method_casecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_filenocasecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_filenocasecmp_to>`

Like :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` but prioritizes strings that begin with periods (``.``) and underscores (``_``) before any other character. Useful when sorting folders or file names.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, and :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_find:

.. rst-class:: classref-method

:ref:`int<class_int>` **find**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_find>`

Returns the index of the **first** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the string.


.. tabs::

 .. code-tab:: gdscript

    print("Team".find("I")) # Prints -1

    print("Potato".find("t"))    # Prints 2
    print("Potato".find("t", 3)) # Prints 4
    print("Potato".find("t", 5)) # Prints -1

 .. code-tab:: csharp

    GD.Print("Team".Find("I")); // Prints -1

    GD.Print("Potato".Find("t"));    // Prints 2
    GD.Print("Potato".Find("t", 3)); // Prints 4
    GD.Print("Potato".Find("t", 5)); // Prints -1



\ **Note:** If you just want to know whether the string contains ``what``, use :ref:`contains()<class_String_method_contains>`. In GDScript, you may also use the ``in`` operator.

\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_findn:

.. rst-class:: classref-method

:ref:`int<class_int>` **findn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_findn>`

Returns the index of the **first** **case-insensitive** occurrence of ``what`` in this string, or ``-1`` if there are none. The starting search index can be specified with ``from``, continuing to the end of the string.

.. rst-class:: classref-item-separator

----

.. _class_String_method_format:

.. rst-class:: classref-method

:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_String_method_format>`

Formats the string by replacing all occurrences of ``placeholder`` with the elements of ``values``.

\ ``values`` can be a :ref:`Dictionary<class_Dictionary>`, an :ref:`Array<class_Array>`, or an :ref:`Object<class_Object>`. Any underscores in ``placeholder`` will be replaced with the corresponding keys in advance. Array elements use their index as keys.

::

    # Prints "Waiting for Godot is a play by Samuel Beckett, and Godot Engine is named after it."
    var use_array_values = "Waiting for {0} is a play by {1}, and {0} Engine is named after it."
    print(use_array_values.format(["Godot", "Samuel Beckett"]))

    # Prints "User 42 is Godot."
    print("User {id} is {name}.".format({"id": 42, "name": "Godot"}))

Some additional handling is performed when ``values`` is an :ref:`Array<class_Array>`. If ``placeholder`` does not contain an underscore, the elements of the ``values`` array will be used to replace one occurrence of the placeholder in order; If an element of ``values`` is another 2-element array, it'll be interpreted as a key-value pair.

::

    # Prints "User 42 is Godot."
    print("User {} is {}.".format([42, "Godot"], "{}"))
    print("User {id} is {name}.".format([["id", 42], ["name", "Godot"]]))

When passing an :ref:`Object<class_Object>`, the property names from :ref:`Object.get_property_list()<class_Object_method_get_property_list>` are used as keys.

::

    # Prints "Visible true, position (0, 0)"
    var node = Node2D.new()
    print("Visible {visible}, position {position}".format(node))

See also the :doc:`GDScript format string <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.

\ **Note:** Each replacement is done sequentially for each element of ``values``, **not** all at once. This means that if any element is inserted and it contains another placeholder, it may be changed by the next replacement. While this can be very useful, it often causes unexpected results. If not necessary, make sure ``values``'s elements do not contain placeholders.

::

    print("{0} {1}".format(["{1}", "x"]))           # Prints "x x"
    print("{0} {1}".format(["x", "{0}"]))           # Prints "x {0}"
    print("{a} {b}".format({"a": "{b}", "b": "c"})) # Prints "c c"
    print("{a} {b}".format({"b": "c", "a": "{b}"})) # Prints "{b} c"

\ **Note:** In C#, it's recommended to `interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__, instead.

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_base_dir:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_String_method_get_base_dir>`

If the string is a valid file path, returns the base directory name.

::

    var dir_path = "/path/to/file.txt".get_base_dir() # dir_path is "/path/to"

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_basename:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_String_method_get_basename>`

If the string is a valid file path, returns the full file path, without the extension.

::

    var base = "/path/to/file.txt".get_basename() # base is "/path/to/file"

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_extension:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_String_method_get_extension>`

If the string is a valid file name or path, returns the file extension without the leading period (``.``). Otherwise, returns an empty string.

::

    var a = "/path/to/file.txt".get_extension() # a is "txt"
    var b = "cool.txt".get_extension()          # b is "txt"
    var c = "cool.font.tres".get_extension()    # c is "tres"
    var d = ".pack1".get_extension()            # d is "pack1"

    var e = "file.txt.".get_extension()  # e is ""
    var f = "file.txt..".get_extension() # f is ""
    var g = "txt".get_extension()        # g is ""
    var h = "".get_extension()           # h is ""

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_file:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_String_method_get_file>`

If the string is a valid file path, returns the file name, including the extension.

::

    var file = "/path/to/icon.png".get_file() # file is "icon.png"

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_slice:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_slice**\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_get_slice>`

Splits the string using a ``delimiter`` and returns the substring at index ``slice``. Returns the original string if ``delimiter`` does not occur in the string. Returns an empty string if the ``slice`` does not exist.

This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.

::

    print("i/am/example/hi".get_slice("/", 2)) # Prints "example"

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_slice_count:

.. rst-class:: classref-method

:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_get_slice_count>`

Returns the total number of slices when the string is split with the given ``delimiter`` (see :ref:`split()<class_String_method_split>`).

Use :ref:`get_slice()<class_String_method_get_slice>` to extract a specific slice.

::

    print("i/am/example/string".get_slice_count("/")) # Prints '4'.
    print("i am example string".get_slice_count("/")) # Prints '1'.

.. rst-class:: classref-item-separator

----

.. _class_String_method_get_slicec:

.. rst-class:: classref-method

:ref:`String<class_String>` **get_slicec**\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_get_slicec>`

Splits the string using a Unicode character with code ``delimiter`` and returns the substring at index ``slice``. Returns an empty string if the ``slice`` does not exist.

This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.

This is a Unicode version of :ref:`get_slice()<class_String_method_get_slice>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_hash:

.. rst-class:: classref-method

:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_String_method_hash>`

Returns the 32-bit hash value representing the string's contents.

\ **Note:** Strings with equal hash values are *not* guaranteed to be the same, as a result of hash collisions. On the contrary, strings with different hash values are guaranteed to be different.

.. rst-class:: classref-item-separator

----

.. _class_String_method_hex_decode:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_String_method_hex_decode>`

Decodes a hexadecimal string as a :ref:`PackedByteArray<class_PackedByteArray>`.


.. tabs::

 .. code-tab:: gdscript

    var text = "hello world"
    var encoded = text.to_utf8_buffer().hex_encode() # outputs "68656c6c6f20776f726c64"
    print(encoded.hex_decode().get_string_from_utf8())

 .. code-tab:: csharp

    var text = "hello world";
    var encoded = text.ToUtf8Buffer().HexEncode(); // outputs "68656c6c6f20776f726c64"
    GD.Print(encoded.HexDecode().GetStringFromUtf8());



.. rst-class:: classref-item-separator

----

.. _class_String_method_hex_to_int:

.. rst-class:: classref-method

:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_String_method_hex_to_int>`

Converts the string representing a hexadecimal number into an :ref:`int<class_int>`. The string may be optionally prefixed with ``"0x"``, and an additional ``-`` prefix for negative numbers.


.. tabs::

 .. code-tab:: gdscript

    print("0xff".hex_to_int()) # Prints 255
    print("ab".hex_to_int())   # Prints 171

 .. code-tab:: csharp

    GD.Print("0xff".HexToInt()); // Prints 255
    GD.Print("ab".HexToInt());   // Prints 171



.. rst-class:: classref-item-separator

----

.. _class_String_method_humanize_size:

.. rst-class:: classref-method

:ref:`String<class_String>` **humanize_size**\ (\ size\: :ref:`int<class_int>`\ ) |static| :ref:`🔗<class_String_method_humanize_size>`

Converts ``size`` which represents a number of bytes into a human-readable form.

The result is in `IEC prefix format <https://en.wikipedia.org/wiki/Binary_prefix#IEC_prefixes>`__, which may end in either ``"B"``, ``"KiB"``, ``"MiB"``, ``"GiB"``, ``"TiB"``, ``"PiB"``, or ``"EiB"``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_indent:

.. rst-class:: classref-method

:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_indent>`

Indents every line of the string with the given ``prefix``. Empty lines are not indented. See also :ref:`dedent()<class_String_method_dedent>` to remove indentation.

For example, the string can be indented with two tabulations using ``"\t\t"``, or four spaces using ``"    "``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_insert:

.. rst-class:: classref-method

:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_insert>`

Inserts ``what`` at the given ``position`` in the string.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_absolute_path:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_absolute_path**\ (\ ) |const| :ref:`🔗<class_String_method_is_absolute_path>`

Returns ``true`` if the string is a path to a file or directory, and its starting point is explicitly defined. This method is the opposite of :ref:`is_relative_path()<class_String_method_is_relative_path>`.

This includes all paths starting with ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"``, etc.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_empty:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_String_method_is_empty>`

Returns ``true`` if the string's length is ``0`` (``""``). See also :ref:`length()<class_String_method_length>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_relative_path:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_relative_path**\ (\ ) |const| :ref:`🔗<class_String_method_is_relative_path>`

Returns ``true`` if the string is a path, and its starting point is dependent on context. The path could begin from the current directory, or the current :ref:`Node<class_Node>` (if the string is derived from a :ref:`NodePath<class_NodePath>`), and may sometimes be prefixed with ``"./"``. This method is the opposite of :ref:`is_absolute_path()<class_String_method_is_absolute_path>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_subsequence_of:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_subsequence_of**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_is_subsequence_of>`

Returns ``true`` if all characters of this string can be found in ``text`` in their original order. This is not the same as :ref:`contains()<class_String_method_contains>`.

::

    var text = "Wow, incredible!"

    print("inedible".is_subsequence_of(text)) # Prints true
    print("Word!".is_subsequence_of(text))    # Prints true
    print("Window".is_subsequence_of(text))   # Prints false
    print("".is_subsequence_of(text))         # Prints true

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_subsequence_ofn:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_is_subsequence_ofn>`

Returns ``true`` if all characters of this string can be found in ``text`` in their original order, **ignoring case**. This is not the same as :ref:`containsn()<class_String_method_containsn>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_ascii_identifier:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_ascii_identifier>`

Returns ``true`` if this string is a valid ASCII identifier. A valid ASCII identifier may contain only letters, digits, and underscores (``_``), and the first character may not be a digit.

::

    print("node_2d".is_valid_ascii_identifier())    # Prints true
    print("TYPE_FLOAT".is_valid_ascii_identifier()) # Prints true
    print("1st_method".is_valid_ascii_identifier()) # Prints false
    print("MyMethod#2".is_valid_ascii_identifier()) # Prints false

See also :ref:`is_valid_unicode_identifier()<class_String_method_is_valid_unicode_identifier>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_filename:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_filename>`

Returns ``true`` if this string is a valid file name. A valid file name cannot be empty, begin or end with space characters, or contain characters that are not allowed (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_float:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_float>`

Returns ``true`` if this string represents a valid floating-point number. A valid float may contain only digits, one decimal point (``.``), and the exponent letter (``e``). It may also be prefixed with a positive (``+``) or negative (``-``) sign. Any valid integer is also a valid float (see :ref:`is_valid_int()<class_String_method_is_valid_int>`). See also :ref:`to_float()<class_String_method_to_float>`.

::

    print("1.7".is_valid_float())   # Prints true
    print("24".is_valid_float())    # Prints true
    print("7e3".is_valid_float())   # Prints true
    print("Hello".is_valid_float()) # Prints false

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_hex_number:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_hex_number**\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_String_method_is_valid_hex_number>`

Returns ``true`` if this string is a valid hexadecimal number. A valid hexadecimal number only contains digits or letters ``A`` to ``F`` (either uppercase or lowercase), and may be prefixed with a positive (``+``) or negative (``-``) sign.

If ``with_prefix`` is ``true``, the hexadecimal number needs to prefixed by ``"0x"`` to be considered valid.

::

    print("A08E".is_valid_hex_number())    # Prints true
    print("-AbCdEf".is_valid_hex_number()) # Prints true
    print("2.5".is_valid_hex_number())     # Prints false

    print("0xDEADC0DE".is_valid_hex_number(true)) # Prints true

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_html_color:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_html_color>`

Returns ``true`` if this string is a valid color in hexadecimal HTML notation. The string must be a hexadecimal value (see :ref:`is_valid_hex_number()<class_String_method_is_valid_hex_number>`) of either 3, 4, 6 or 8 digits, and may be prefixed by a hash sign (``#``). Other HTML notations for colors, such as names or ``hsl()``, are not considered valid. See also :ref:`Color.html()<class_Color_method_html>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_identifier:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_identifier**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_identifier>`

**Deprecated:** Use :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>` instead.

Returns ``true`` if this string is a valid identifier. A valid identifier may contain only letters, digits and underscores (``_``), and the first character may not be a digit.

::

    print("node_2d".is_valid_identifier())    # Prints true
    print("TYPE_FLOAT".is_valid_identifier()) # Prints true
    print("1st_method".is_valid_identifier()) # Prints false
    print("MyMethod#2".is_valid_identifier()) # Prints false

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_int:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_int**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_int>`

Returns ``true`` if this string represents a valid integer. A valid integer only contains digits, and may be prefixed with a positive (``+``) or negative (``-``) sign. See also :ref:`to_int()<class_String_method_to_int>`.

::

    print("7".is_valid_int())    # Prints true
    print("1.65".is_valid_int()) # Prints false
    print("Hi".is_valid_int())   # Prints false
    print("+3".is_valid_int())   # Prints true
    print("-12".is_valid_int())  # Prints true

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_ip_address:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_ip_address>`

Returns ``true`` if this string represents a well-formatted IPv4 or IPv6 address. This method considers `reserved IP addresses <https://en.wikipedia.org/wiki/Reserved_IP_addresses>`__ such as ``"0.0.0.0"`` and ``"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"`` as valid.

.. rst-class:: classref-item-separator

----

.. _class_String_method_is_valid_unicode_identifier:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗<class_String_method_is_valid_unicode_identifier>`

Returns ``true`` if this string is a valid Unicode identifier.

A valid Unicode identifier must begin with a Unicode character of class ``XID_Start`` or ``"_"``, and may contain Unicode characters of class ``XID_Continue`` in the other positions.

::

    print("node_2d".is_valid_unicode_identifier())      # Prints true
    print("1st_method".is_valid_unicode_identifier())   # Prints false
    print("MyMethod#2".is_valid_unicode_identifier())   # Prints false
    print("állóképesség".is_valid_unicode_identifier()) # Prints true
    print("выносливость".is_valid_unicode_identifier()) # Prints true
    print("体力".is_valid_unicode_identifier())         # Prints true

See also :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>`.

\ **Note:** This method checks identifiers the same way as GDScript. See :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` for more advanced checks.

.. rst-class:: classref-item-separator

----

.. _class_String_method_join:

.. rst-class:: classref-method

:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_String_method_join>`

Returns the concatenation of ``parts``' elements, with each element separated by the string calling this method. This method is the opposite of :ref:`split()<class_String_method_split>`.


.. tabs::

 .. code-tab:: gdscript

    var fruits = ["Apple", "Orange", "Pear", "Kiwi"]

    print(", ".join(fruits))  # Prints "Apple, Orange, Pear, Kiwi"
    print("---".join(fruits)) # Prints "Apple---Orange---Pear---Kiwi"

 .. code-tab:: csharp

    string[] fruits = ["Apple", "Orange", "Pear", "Kiwi"];

    // In C#, this method is static.
    GD.Print(string.Join(", ", fruits));  // Prints "Apple, Orange, Pear, Kiwi"
    GD.Print(string.Join("---", fruits)); // Prints "Apple---Orange---Pear---Kiwi"



.. rst-class:: classref-item-separator

----

.. _class_String_method_json_escape:

.. rst-class:: classref-method

:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_String_method_json_escape>`

Returns a copy of the string with special characters escaped using the JSON standard. Because it closely matches the C standard, it is possible to use :ref:`c_unescape()<class_String_method_c_unescape>` to unescape the string, if necessary.

.. rst-class:: classref-item-separator

----

.. _class_String_method_left:

.. rst-class:: classref-method

:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_left>`

Returns the first ``length`` characters from the beginning of the string. If ``length`` is negative, strips the last ``length`` characters from the string's end.

::

    print("Hello World!".left(3))  # Prints "Hel"
    print("Hello World!".left(-4)) # Prints "Hello Wo"

.. rst-class:: classref-item-separator

----

.. _class_String_method_length:

.. rst-class:: classref-method

:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_String_method_length>`

Returns the number of characters in the string. Empty strings (``""``) always return ``0``. See also :ref:`is_empty()<class_String_method_is_empty>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_lpad:

.. rst-class:: classref-method

:ref:`String<class_String>` **lpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_String_method_lpad>`

Formats the string to be at least ``min_length`` long by adding ``character``\ s to the left of the string, if necessary. See also :ref:`rpad()<class_String_method_rpad>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_lstrip:

.. rst-class:: classref-method

:ref:`String<class_String>` **lstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_lstrip>`

Removes a set of characters defined in ``chars`` from the string's beginning. See also :ref:`rstrip()<class_String_method_rstrip>`.

\ **Note:** ``chars`` is not a prefix. Use :ref:`trim_prefix()<class_String_method_trim_prefix>` to remove a single prefix, rather than a set of characters.

.. rst-class:: classref-item-separator

----

.. _class_String_method_match:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **match**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_match>`

Does a simple expression match (also called "glob" or "globbing"), where ``*`` matches zero or more arbitrary characters and ``?`` matches any single character except a period (``.``). An empty string or empty expression always evaluates to ``false``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_matchn:

.. rst-class:: classref-method

:ref:`bool<class_bool>` **matchn**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_matchn>`

Does a simple **case-insensitive** expression match, where ``*`` matches zero or more arbitrary characters and ``?`` matches any single character except a period (``.``). An empty string or empty expression always evaluates to ``false``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_md5_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_md5_buffer>`

Returns the `MD5 hash <https://en.wikipedia.org/wiki/MD5>`__ of the string as a :ref:`PackedByteArray<class_PackedByteArray>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_md5_text:

.. rst-class:: classref-method

:ref:`String<class_String>` **md5_text**\ (\ ) |const| :ref:`🔗<class_String_method_md5_text>`

Returns the `MD5 hash <https://en.wikipedia.org/wiki/MD5>`__ of the string as another **String**.

.. rst-class:: classref-item-separator

----

.. _class_String_method_naturalcasecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_naturalcasecmp_to>`

Performs a **case-sensitive**, *natural order* comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order.

When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected, instead of the single digit's value. A sorted sequence of numbered strings will be ``["1", "2", "3", ...]``, not ``["1", "10", "2", "3", ...]``.

If the character comparison reaches the end of one string, but the other string contains more characters, then it will use length as the deciding factor: ``1`` will be returned if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is always ``0``.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, and :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_naturalnocasecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_naturalnocasecmp_to>`

Performs a **case-insensitive**, *natural order* comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order. Internally, lowercase characters are converted to uppercase for the comparison.

When used for sorting, natural order comparison orders sequences of numbers by the combined value of each digit as is often expected, instead of the single digit's value. A sorted sequence of numbered strings will be ``["1", "2", "3", ...]``, not ``["1", "10", "2", "3", ...]``.

If the character comparison reaches the end of one string, but the other string contains more characters, then it will use length as the deciding factor: ``1`` will be returned if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is always ``0``.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, and :ref:`casecmp_to()<class_String_method_casecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_nocasecmp_to:

.. rst-class:: classref-method

:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_nocasecmp_to>`

Performs a **case-insensitive** comparison to another string. Returns ``-1`` if less than, ``1`` if greater than, or ``0`` if equal. "Less than" or "greater than" are determined by the `Unicode code points <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ of each string, which roughly matches the alphabetical order. Internally, lowercase characters are converted to uppercase for the comparison.

If the character comparison reaches the end of one string, but the other string contains more characters, then it will use length as the deciding factor: ``1`` will be returned if this string is longer than the ``to`` string, or ``-1`` if shorter. Note that the length of empty strings is always ``0``.

To get a :ref:`bool<class_bool>` result from a string comparison, use the ``==`` operator instead. See also :ref:`casecmp_to()<class_String_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, and :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_num:

.. rst-class:: classref-method

:ref:`String<class_String>` **num**\ (\ number\: :ref:`float<class_float>`, decimals\: :ref:`int<class_int>` = -1\ ) |static| :ref:`🔗<class_String_method_num>`

Converts a :ref:`float<class_float>` to a string representation of a decimal number, with the number of decimal places specified in ``decimals``.

If ``decimals`` is ``-1`` as by default, the string representation may only have up to 14 significant digits, with digits before the decimal point having priority over digits after.

Trailing zeros are not included in the string. The last digit is rounded, not truncated.

::

    String.num(3.141593)     # Returns "3.141593"
    String.num(3.141593, 3)  # Returns "3.142"
    String.num(3.14159300)   # Returns "3.141593"

    # Here, the last digit will be rounded up,
    # which reduces the total digit count, since trailing zeros are removed:
    String.num(42.129999, 5) # Returns "42.13"

    # If `decimals` is not specified, the maximum number of significant digits is 14:
    String.num(-0.0000012345432123454321)     # Returns "-0.00000123454321"
    String.num(-10000.0000012345432123454321) # Returns "-10000.0000012345"

.. rst-class:: classref-item-separator

----

.. _class_String_method_num_int64:

.. rst-class:: classref-method

:ref:`String<class_String>` **num_int64**\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| :ref:`🔗<class_String_method_num_int64>`

Converts the given ``number`` to a string representation, with the given ``base``.

By default, ``base`` is set to decimal (``10``). Other common bases in programming include binary (``2``), `octal <https://en.wikipedia.org/wiki/Octal>`__ (``8``), hexadecimal (``16``).

If ``capitalize_hex`` is ``true``, digits higher than 9 are represented in uppercase.

.. rst-class:: classref-item-separator

----

.. _class_String_method_num_scientific:

.. rst-class:: classref-method

:ref:`String<class_String>` **num_scientific**\ (\ number\: :ref:`float<class_float>`\ ) |static| :ref:`🔗<class_String_method_num_scientific>`

Converts the given ``number`` to a string representation, in scientific notation.


.. tabs::

 .. code-tab:: gdscript

    var n = -5.2e8
    print(n)                        # Prints -520000000
    print(String.num_scientific(n)) # Prints -5.2e+08

 .. code-tab:: csharp

    // This method is not implemented in C#.
    // Use `string.ToString()` with "e" to achieve similar results.
    var n = -5.2e8f;
    GD.Print(n);                // Prints -520000000
    GD.Print(n.ToString("e1")); // Prints -5.2e+008



\ **Note:** In C#, this method is not implemented. To achieve similar results, see C#'s `Standard numeric format strings <https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings>`__.

.. rst-class:: classref-item-separator

----

.. _class_String_method_num_uint64:

.. rst-class:: classref-method

:ref:`String<class_String>` **num_uint64**\ (\ number\: :ref:`int<class_int>`, base\: :ref:`int<class_int>` = 10, capitalize_hex\: :ref:`bool<class_bool>` = false\ ) |static| :ref:`🔗<class_String_method_num_uint64>`

Converts the given unsigned :ref:`int<class_int>` to a string representation, with the given ``base``.

By default, ``base`` is set to decimal (``10``). Other common bases in programming include binary (``2``), `octal <https://en.wikipedia.org/wiki/Octal>`__ (``8``), hexadecimal (``16``).

If ``capitalize_hex`` is ``true``, digits higher than 9 are represented in uppercase.

.. rst-class:: classref-item-separator

----

.. _class_String_method_pad_decimals:

.. rst-class:: classref-method

:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_pad_decimals>`

Formats the string representing a number to have an exact number of ``digits`` *after* the decimal point.

.. rst-class:: classref-item-separator

----

.. _class_String_method_pad_zeros:

.. rst-class:: classref-method

:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_pad_zeros>`

Formats the string representing a number to have an exact number of ``digits`` *before* the decimal point.

.. rst-class:: classref-item-separator

----

.. _class_String_method_path_join:

.. rst-class:: classref-method

:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_path_join>`

Concatenates ``path`` at the end of the string as a subpath, adding ``/`` if necessary.

\ **Example:** ``"this/is".path_join("path") == "this/is/path"``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_remove_char:

.. rst-class:: classref-method

:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_remove_char>`

Removes all occurrences of the Unicode character with code ``what``. Faster version of :ref:`replace()<class_String_method_replace>` when the key is only one character long and the replacement is ``""``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_remove_chars:

.. rst-class:: classref-method

:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_remove_chars>`

Removes any occurrence of the characters in ``chars``. See also :ref:`remove_char()<class_String_method_remove_char>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_repeat:

.. rst-class:: classref-method

:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_repeat>`

Repeats this string a number of times. ``count`` needs to be greater than ``0``. Otherwise, returns an empty string.

.. rst-class:: classref-item-separator

----

.. _class_String_method_replace:

.. rst-class:: classref-method

:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_replace>`

Replaces all occurrences of ``what`` inside the string with the given ``forwhat``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_replace_char:

.. rst-class:: classref-method

:ref:`String<class_String>` **replace_char**\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_replace_char>`

Replaces all occurrences of the Unicode character with code ``key`` with the Unicode character with code ``with``. Faster version of :ref:`replace()<class_String_method_replace>` when the key is only one character long. To get a single character use ``"X".unicode_at(0)`` (note that some strings, like compound letters and emoji, can be composed of multiple unicode codepoints, and will not work with this method, use :ref:`length()<class_String_method_length>` to make sure).

.. rst-class:: classref-item-separator

----

.. _class_String_method_replace_chars:

.. rst-class:: classref-method

:ref:`String<class_String>` **replace_chars**\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_replace_chars>`

Replaces any occurrence of the characters in ``keys`` with the Unicode character with code ``with``. See also :ref:`replace_char()<class_String_method_replace_char>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_replacen:

.. rst-class:: classref-method

:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_replacen>`

Replaces all **case-insensitive** occurrences of ``what`` inside the string with the given ``forwhat``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_reverse:

.. rst-class:: classref-method

:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_String_method_reverse>`

Returns the copy of this string in reverse order. This operation works on unicode codepoints, rather than sequences of codepoints, and may break things like compound letters or emojis.

.. rst-class:: classref-item-separator

----

.. _class_String_method_rfind:

.. rst-class:: classref-method

:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_String_method_rfind>`

Returns the index of the **last** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`find()<class_String_method_find>`.

\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.

\ **Note:** A value of ``from`` that is greater than the last possible index with enough space to find ``what`` is considered out-of-bounds, and returns ``-1``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_rfindn:

.. rst-class:: classref-method

:ref:`int<class_int>` **rfindn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_String_method_rfindn>`

Returns the index of the **last** **case-insensitive** occurrence of ``what`` in this string, or ``-1`` if there are none. The starting search index can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`findn()<class_String_method_findn>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_right:

.. rst-class:: classref-method

:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_right>`

Returns the last ``length`` characters from the end of the string. If ``length`` is negative, strips the first ``length`` characters from the string's beginning.

::

    print("Hello World!".right(3))  # Prints "ld!"
    print("Hello World!".right(-4)) # Prints "o World!"

.. rst-class:: classref-item-separator

----

.. _class_String_method_rpad:

.. rst-class:: classref-method

:ref:`String<class_String>` **rpad**\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| :ref:`🔗<class_String_method_rpad>`

Formats the string to be at least ``min_length`` long, by adding ``character``\ s to the right of the string, if necessary. See also :ref:`lpad()<class_String_method_lpad>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_rsplit:

.. rst-class:: classref-method

:ref:`PackedStringArray<class_PackedStringArray>` **rsplit**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_rsplit>`

Splits the string using a ``delimiter`` and returns an array of the substrings, starting from the end of the string. The splits in the returned array appear in the same order as the original string. If ``delimiter`` is an empty string, each substring will be a single character.

If ``allow_empty`` is ``false``, empty strings between adjacent delimiters are excluded from the array.

If ``maxsplit`` is greater than ``0``, the number of splits may not exceed ``maxsplit``. By default, the entire string is split, which is mostly identical to :ref:`split()<class_String_method_split>`.


.. tabs::

 .. code-tab:: gdscript

    var some_string = "One,Two,Three,Four"
    var some_array = some_string.rsplit(",", true, 1)

    print(some_array.size()) # Prints 2
    print(some_array[0])     # Prints "One,Two,Three"
    print(some_array[1])     # Prints "Four"

 .. code-tab:: csharp

    // In C#, there is no String.RSplit() method.



.. rst-class:: classref-item-separator

----

.. _class_String_method_rstrip:

.. rst-class:: classref-method

:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_rstrip>`

Removes a set of characters defined in ``chars`` from the string's end. See also :ref:`lstrip()<class_String_method_lstrip>`.

\ **Note:** ``chars`` is not a suffix. Use :ref:`trim_suffix()<class_String_method_trim_suffix>` to remove a single suffix, rather than a set of characters.

.. rst-class:: classref-item-separator

----

.. _class_String_method_sha1_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_sha1_buffer>`

Returns the `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ hash of the string as a :ref:`PackedByteArray<class_PackedByteArray>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_sha1_text:

.. rst-class:: classref-method

:ref:`String<class_String>` **sha1_text**\ (\ ) |const| :ref:`🔗<class_String_method_sha1_text>`

Returns the `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ hash of the string as another **String**.

.. rst-class:: classref-item-separator

----

.. _class_String_method_sha256_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_sha256_buffer>`

Returns the `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ hash of the string as a :ref:`PackedByteArray<class_PackedByteArray>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_sha256_text:

.. rst-class:: classref-method

:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_String_method_sha256_text>`

Returns the `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ hash of the string as another **String**.

.. rst-class:: classref-item-separator

----

.. _class_String_method_similarity:

.. rst-class:: classref-method

:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_similarity>`

Returns the similarity index (`Sørensen-Dice coefficient <https://en.wikipedia.org/wiki/S%C3%B8rensen%E2%80%93Dice_coefficient>`__) of this string compared to another. A result of ``1.0`` means totally similar, while ``0.0`` means totally dissimilar.

::

    print("ABC123".similarity("ABC123")) # Prints 1.0
    print("ABC123".similarity("XYZ456")) # Prints 0.0
    print("ABC123".similarity("123ABC")) # Prints 0.8
    print("ABC123".similarity("abc123")) # Prints 0.4

.. rst-class:: classref-item-separator

----

.. _class_String_method_simplify_path:

.. rst-class:: classref-method

:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_String_method_simplify_path>`

If the string is a valid file path, converts the string into a canonical path. This is the shortest possible path, without ``"./"``, and all the unnecessary ``".."`` and ``"/"``.

::

    var simple_path = "./path/to///../file".simplify_path()
    print(simple_path) # Prints "path/file"

.. rst-class:: classref-item-separator

----

.. _class_String_method_split:

.. rst-class:: classref-method

:ref:`PackedStringArray<class_PackedStringArray>` **split**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_split>`

Splits the string using a ``delimiter`` and returns an array of the substrings. If ``delimiter`` is an empty string, each substring will be a single character. This method is the opposite of :ref:`join()<class_String_method_join>`.

If ``allow_empty`` is ``false``, empty strings between adjacent delimiters are excluded from the array.

If ``maxsplit`` is greater than ``0``, the number of splits may not exceed ``maxsplit``. By default, the entire string is split.


.. tabs::

 .. code-tab:: gdscript

    var some_array = "One,Two,Three,Four".split(",", true, 2)

    print(some_array.size()) # Prints 3
    print(some_array[0])     # Prints "One"
    print(some_array[1])     # Prints "Two"
    print(some_array[2])     # Prints "Three,Four"

 .. code-tab:: csharp

    // C#'s `Split()` does not support the `maxsplit` parameter.
    var someArray = "One,Two,Three".Split(",");

    GD.Print(someArray[0]); // Prints "One"
    GD.Print(someArray[1]); // Prints "Two"
    GD.Print(someArray[2]); // Prints "Three"



\ **Note:** If you only need one substring from the array, consider using :ref:`get_slice()<class_String_method_get_slice>` which is faster. If you need to split strings with more complex rules, use the :ref:`RegEx<class_RegEx>` class instead.

.. rst-class:: classref-item-separator

----

.. _class_String_method_split_floats:

.. rst-class:: classref-method

:ref:`PackedFloat64Array<class_PackedFloat64Array>` **split_floats**\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_String_method_split_floats>`

Splits the string into floats by using a ``delimiter`` and returns a :ref:`PackedFloat64Array<class_PackedFloat64Array>`.

If ``allow_empty`` is ``false``, empty or invalid :ref:`float<class_float>` conversions between adjacent delimiters are excluded.

::

    var a = "1,2,4.5".split_floats(",")         # a is [1.0, 2.0, 4.5]
    var c = "1| ||4.5".split_floats("|")        # c is [1.0, 0.0, 0.0, 4.5]
    var b = "1| ||4.5".split_floats("|", false) # b is [1.0, 4.5]

.. rst-class:: classref-item-separator

----

.. _class_String_method_strip_edges:

.. rst-class:: classref-method

:ref:`String<class_String>` **strip_edges**\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| :ref:`🔗<class_String_method_strip_edges>`

Strips all non-printable characters from the beginning and the end of the string. These include spaces, tabulations (``\t``), and newlines (``\n`` ``\r``).

If ``left`` is ``false``, ignores the string's beginning. Likewise, if ``right`` is ``false``, ignores the string's end.

.. rst-class:: classref-item-separator

----

.. _class_String_method_strip_escapes:

.. rst-class:: classref-method

:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_String_method_strip_escapes>`

Strips all escape characters from the string. These include all non-printable control characters of the first page of the ASCII table (values from 0 to 31), such as tabulation (``\t``) and newline (``\n``, ``\r``) characters, but *not* spaces.

.. rst-class:: classref-item-separator

----

.. _class_String_method_substr:

.. rst-class:: classref-method

:ref:`String<class_String>` **substr**\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_String_method_substr>`

Returns part of the string from the position ``from`` with length ``len``. If ``len`` is ``-1`` (as by default), returns the rest of the string starting from the given position.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_ascii_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_ascii_buffer>`

Converts the string to an `ASCII <https://en.wikipedia.org/wiki/ASCII>`__/Latin-1 encoded :ref:`PackedByteArray<class_PackedByteArray>`. This method is slightly faster than :ref:`to_utf8_buffer()<class_String_method_to_utf8_buffer>`, but replaces all unsupported characters with spaces. This is the inverse of :ref:`PackedByteArray.get_string_from_ascii()<class_PackedByteArray_method_get_string_from_ascii>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_camel_case:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_camel_case>`

Returns the string converted to ``camelCase``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_float:

.. rst-class:: classref-method

:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_String_method_to_float>`

Converts the string representing a decimal number into a :ref:`float<class_float>`. This method stops on the first non-number character, except the first decimal point (``.``) and the exponent letter (``e``). See also :ref:`is_valid_float()<class_String_method_is_valid_float>`.

::

    var a = "12.35".to_float()  # a is 12.35
    var b = "1.2.3".to_float()  # b is 1.2
    var c = "12xy3".to_float()  # c is 12.0
    var d = "1e3".to_float()    # d is 1000.0
    var e = "Hello!".to_float() # e is 0.0

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_int:

.. rst-class:: classref-method

:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_String_method_to_int>`

Converts the string representing an integer number into an :ref:`int<class_int>`. This method removes any non-number character and stops at the first decimal point (``.``). See also :ref:`is_valid_int()<class_String_method_is_valid_int>`.

::

    var a = "123".to_int()    # a is 123
    var b = "x1y2z3".to_int() # b is 123
    var c = "-1.2.3".to_int() # c is -1
    var d = "Hello!".to_int() # d is 0

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_kebab_case:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_kebab_case>`

Returns the string converted to ``kebab-case``.

\ **Note:** Numbers followed by a *single* letter are not separated in the conversion to keep some words (such as "2D") together.


.. tabs::

 .. code-tab:: gdscript

    "Node2D".to_kebab_case()               # Returns "node-2d"
    "2nd place".to_kebab_case()            # Returns "2-nd-place"
    "Texture3DAssetFolder".to_kebab_case() # Returns "texture-3d-asset-folder"

 .. code-tab:: csharp

    "Node2D".ToKebabCase();               // Returns "node-2d"
    "2nd place".ToKebabCase();            // Returns "2-nd-place"
    "Texture3DAssetFolder".ToKebabCase(); // Returns "texture-3d-asset-folder"



.. rst-class:: classref-item-separator

----

.. _class_String_method_to_lower:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_String_method_to_lower>`

Returns the string converted to ``lowercase``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_multibyte_char_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_String_method_to_multibyte_char_buffer>`

Converts the string to system multibyte code page encoded :ref:`PackedByteArray<class_PackedByteArray>`. If conversion fails, empty array is returned.

The values permitted for ``encoding`` are system dependent. If ``encoding`` is empty string, system default encoding is used.

- For Windows, see `Code Page Identifiers <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ .NET names.

- For macOS and Linux/BSD, see ``libiconv`` library documentation and ``iconv --list`` for a list of supported encodings.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_pascal_case:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_pascal_case>`

Returns the string converted to ``PascalCase``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_snake_case:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_snake_case>`

Returns the string converted to ``snake_case``.

\ **Note:** Numbers followed by a *single* letter are not separated in the conversion to keep some words (such as "2D") together.


.. tabs::

 .. code-tab:: gdscript

    "Node2D".to_snake_case()               # Returns "node_2d"
    "2nd place".to_snake_case()            # Returns "2_nd_place"
    "Texture3DAssetFolder".to_snake_case() # Returns "texture_3d_asset_folder"

 .. code-tab:: csharp

    "Node2D".ToSnakeCase();               // Returns "node_2d"
    "2nd place".ToSnakeCase();            // Returns "2_nd_place"
    "Texture3DAssetFolder".ToSnakeCase(); // Returns "texture_3d_asset_folder"



.. rst-class:: classref-item-separator

----

.. _class_String_method_to_upper:

.. rst-class:: classref-method

:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_String_method_to_upper>`

Returns the string converted to ``UPPERCASE``.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_utf8_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf8_buffer>`

Converts the string to a `UTF-8 <https://en.wikipedia.org/wiki/UTF-8>`__ encoded :ref:`PackedByteArray<class_PackedByteArray>`. This method is slightly slower than :ref:`to_ascii_buffer()<class_String_method_to_ascii_buffer>`, but supports all UTF-8 characters. For most cases, prefer using this method. This is the inverse of :ref:`PackedByteArray.get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_utf16_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf16_buffer>`

Converts the string to a `UTF-16 <https://en.wikipedia.org/wiki/UTF-16>`__ encoded :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf16()<class_PackedByteArray_method_get_string_from_utf16>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_utf32_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf32_buffer>`

Converts the string to a `UTF-32 <https://en.wikipedia.org/wiki/UTF-32>`__ encoded :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_utf32()<class_PackedByteArray_method_get_string_from_utf32>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_to_wchar_buffer:

.. rst-class:: classref-method

:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_wchar_buffer>`

Converts the string to a `wide character <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 on Windows, UTF-32 on other platforms) encoded :ref:`PackedByteArray<class_PackedByteArray>`. This is the inverse of :ref:`PackedByteArray.get_string_from_wchar()<class_PackedByteArray_method_get_string_from_wchar>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_trim_prefix:

.. rst-class:: classref-method

:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_trim_prefix>`

Removes the given ``prefix`` from the start of the string, or returns the string unchanged.

.. rst-class:: classref-item-separator

----

.. _class_String_method_trim_suffix:

.. rst-class:: classref-method

:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_trim_suffix>`

Removes the given ``suffix`` from the end of the string, or returns the string unchanged.

.. rst-class:: classref-item-separator

----

.. _class_String_method_unicode_at:

.. rst-class:: classref-method

:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_unicode_at>`

Returns the character code at position ``at``.

See also :ref:`chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>`, and :ref:`@GDScript.ord()<class_@GDScript_method_ord>`.

.. rst-class:: classref-item-separator

----

.. _class_String_method_uri_decode:

.. rst-class:: classref-method

:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_decode>`

Decodes the string from its URL-encoded format. This method is meant to properly decode the parameters in a URL when receiving an HTTP request. See also :ref:`uri_encode()<class_String_method_uri_encode>`.


.. tabs::

 .. code-tab:: gdscript

    var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
    print(url.uri_decode()) # Prints "$DOCS_URL/?highlight=Godot Engine:docs"

 .. code-tab:: csharp

    var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
    GD.Print(url.URIDecode()) // Prints "$DOCS_URL/?highlight=Godot Engine:docs"



\ **Note:** This method decodes ``+`` as space.

.. rst-class:: classref-item-separator

----

.. _class_String_method_uri_encode:

.. rst-class:: classref-method

:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_encode>`

Encodes the string to URL-friendly format. This method is meant to properly encode the parameters in a URL when sending an HTTP request. See also :ref:`uri_decode()<class_String_method_uri_decode>`.


.. tabs::

 .. code-tab:: gdscript

    var prefix = "$DOCS_URL/?highlight="
    var url = prefix + "Godot Engine:docs".uri_encode()

    print(url) # Prints "$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); // Prints "$DOCS_URL/?highlight=Godot%20Engine%3%docs"



.. rst-class:: classref-item-separator

----

.. _class_String_method_uri_file_decode:

.. rst-class:: classref-method

:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_String_method_uri_file_decode>`

Decodes the file path from its URL-encoded format. Unlike :ref:`uri_decode()<class_String_method_uri_decode>` this method leaves ``+`` as is.

.. rst-class:: classref-item-separator

----

.. _class_String_method_validate_filename:

.. rst-class:: classref-method

:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_String_method_validate_filename>`

Returns a copy of the string with all characters that are not allowed in :ref:`is_valid_filename()<class_String_method_is_valid_filename>` replaced with underscores.

.. rst-class:: classref-item-separator

----

.. _class_String_method_validate_node_name:

.. rst-class:: classref-method

:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_String_method_validate_node_name>`

Returns a copy of the string with all characters that are not allowed in :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) replaced with underscores.

.. rst-class:: classref-item-separator

----

.. _class_String_method_xml_escape:

.. rst-class:: classref-method

:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_String_method_xml_escape>`

Returns a copy of the string with special characters escaped using the XML standard. If ``escape_quotes`` is ``true``, the single quote (``'``) and double quote (``"``) characters are also escaped.

.. rst-class:: classref-item-separator

----

.. _class_String_method_xml_unescape:

.. rst-class:: classref-method

:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_String_method_xml_unescape>`

Returns a copy of the string with escaped characters replaced by their meanings according to the XML standard.

.. rst-class:: classref-section-separator

----

.. rst-class:: classref-descriptions-group

Operator Descriptions
---------------------

.. _class_String_operator_neq_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_neq_String>`

Returns ``true`` if both strings do not contain the same sequence of characters.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_neq_StringName:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_neq_StringName>`

Returns ``true`` if this **String** is not equivalent to the given :ref:`StringName<class_StringName>`.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_mod_Variant:

.. rst-class:: classref-operator

:ref:`String<class_String>` **operator %**\ (\ right\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_String_operator_mod_Variant>`

Formats the **String**, replacing the placeholders with one or more parameters. To pass multiple parameters, ``right`` needs to be an :ref:`Array<class_Array>`.

::

    print("I caught %d fishes!" % 2) # Prints "I caught 2 fishes!"

    var my_message = "Travelling to %s, at %2.2f km/h."
    var location = "Deep Valley"
    var speed = 40.3485
    print(my_message % [location, speed]) # Prints "Travelling to Deep Valley, at 40.35 km/h."

For more information, see the :doc:`GDScript format strings <../tutorials/scripting/gdscript/gdscript_format_string>` tutorial.

\ **Note:** In C#, this operator is not available. Instead, see `how to interpolate strings with "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_sum_String:

.. rst-class:: classref-operator

:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_sum_String>`

Appends ``right`` at the end of this **String**, also known as a string concatenation.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_sum_StringName:

.. rst-class:: classref-operator

:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_sum_StringName>`

Appends ``right`` at the end of this **String**, returning a **String**. This is also known as a string concatenation.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_lt_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_lt_String>`

Returns ``true`` if the left **String** comes before ``right`` in `Unicode order <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, which roughly matches the alphabetical order. Useful for sorting.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_lte_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_lte_String>`

Returns ``true`` if the left **String** comes before ``right`` in `Unicode order <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, which roughly matches the alphabetical order, or if both are equal.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_eq_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_eq_String>`

Returns ``true`` if both strings contain the same sequence of characters.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_eq_StringName:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_String_operator_eq_StringName>`

Returns ``true`` if this **String** is equivalent to the given :ref:`StringName<class_StringName>`.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_gt_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_gt_String>`

Returns ``true`` if the left **String** comes after ``right`` in `Unicode order <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, which roughly matches the alphabetical order. Useful for sorting.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_gte_String:

.. rst-class:: classref-operator

:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_String_operator_gte_String>`

Returns ``true`` if the left **String** comes after ``right`` in `Unicode order <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, which roughly matches the alphabetical order, or if both are equal.

.. rst-class:: classref-item-separator

----

.. _class_String_operator_idx_int:

.. rst-class:: classref-operator

:ref:`String<class_String>` **operator []**\ (\ index\: :ref:`int<class_int>`\ ) :ref:`🔗<class_String_operator_idx_int>`

Returns a new **String** that only contains the character at ``index``. Indices start from ``0``. If ``index`` is greater or equal to ``0``, the character is fetched starting from the beginning of the string. If ``index`` is a negative value, it is fetched starting from the end. Accessing a string out-of-bounds will cause a run-time error, pausing the project execution if run from the editor.

.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (This method has no side effects. It doesn't modify any of the instance's member variables.)`
.. |vararg| replace:: :abbr:`vararg (This method accepts any number of arguments after the ones described here.)`
.. |constructor| replace:: :abbr:`constructor (This method is used to construct a type.)`
.. |static| replace:: :abbr:`static (This method doesn't need an instance to be called, so it can be called directly using the class name.)`
.. |operator| replace:: :abbr:`operator (This method describes a valid operator to use with this type as left-hand operand.)`
.. |bitfield| replace:: :abbr:`BitField (This value is an integer composed as a bitmask of the following flags.)`
.. |void| replace:: :abbr:`void (No return value.)`