godot-docs/classes/class_string.rst

:github_url: hide

.. Generated automatically by doc/tools/make_rst.py in Godot's source tree.
.. DO NOT EDIT THIS FILE, but the String.xml source instead.
.. The source is found in doc/classes or modules/<name>/doc_classes.

.. _class_String:

String
======

Built-in string class.

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

This is the built-in string class (and the one used by GDScript). It supports Unicode and provides all necessary means for string handling. Strings are reference-counted and use a copy-on-write approach, so passing them around is cheap in resources.

Tutorials
---------

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

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

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

Methods
-------

+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                             | :ref:`begins_with<class_String_method_begins_with>` **(** :ref:`String<class_String>` text **)** |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>` **(** :ref:`String<class_String>` to **)** |const|                                                                            |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`chr<class_String_method_chr>` **(** :ref:`int<class_int>` char **)** |static|                                                                                             |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                             | :ref:`contains<class_String_method_contains>` **(** :ref:`String<class_String>` what **)** |const|                                                                              |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`count<class_String_method_count>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=0, :ref:`int<class_int>` to=0 **)** |const|                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`countn<class_String_method_countn>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=0, :ref:`int<class_int>` to=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>` **(** :ref:`String<class_String>` text **)** |const|                                                                            |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`find<class_String_method_find>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=0 **)** |const|                                                        |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`findn<class_String_method_findn>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=0 **)** |const|                                                      |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`format<class_String_method_format>` **(** :ref:`Variant<class_Variant>` values, :ref:`String<class_String>` placeholder="{_}" **)** |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>` **(** :ref:`String<class_String>` delimiter, :ref:`int<class_int>` slice **)** |const|                                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`get_slice_count<class_String_method_get_slice_count>` **(** :ref:`String<class_String>` delimiter **)** |const|                                                           |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`get_slicec<class_String_method_get_slicec>` **(** :ref:`int<class_int>` delimiter, :ref:`int<class_int>` slice **)** |const|                                              |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`hash<class_String_method_hash>` **(** **)** |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>` **(** :ref:`int<class_int>` size **)** |static|                                                                         |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`indent<class_String_method_indent>` **(** :ref:`String<class_String>` prefix **)** |const|                                                                                |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`insert<class_String_method_insert>` **(** :ref:`int<class_int>` position, :ref:`String<class_String>` what **)** |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>` **(** :ref:`String<class_String>` text **)** |const|                                                            |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                             | :ref:`is_subsequence_ofn<class_String_method_is_subsequence_ofn>` **(** :ref:`String<class_String>` text **)** |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>` **(** :ref:`bool<class_bool>` with_prefix=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:`String<class_String>`                         | :ref:`join<class_String_method_join>` **(** :ref:`PackedStringArray<class_PackedStringArray>` parts **)** |const|                                                               |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`json_escape<class_String_method_json_escape>` **(** **)** |const|                                                                                                         |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`left<class_String_method_left>` **(** :ref:`int<class_int>` position **)** |const|                                                                                        |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`length<class_String_method_length>` **(** **)** |const|                                                                                                                   |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`lpad<class_String_method_lpad>` **(** :ref:`int<class_int>` min_length, :ref:`String<class_String>` character=" " **)** |const|                                           |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`lstrip<class_String_method_lstrip>` **(** :ref:`String<class_String>` chars **)** |const|                                                                                 |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                             | :ref:`match<class_String_method_match>` **(** :ref:`String<class_String>` expr **)** |const|                                                                                    |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`                             | :ref:`matchn<class_String_method_matchn>` **(** :ref:`String<class_String>` expr **)** |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:`naturalnocasecmp_to<class_String_method_naturalnocasecmp_to>` **(** :ref:`String<class_String>` to **)** |const|                                                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`nocasecmp_to<class_String_method_nocasecmp_to>` **(** :ref:`String<class_String>` to **)** |const|                                                                        |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`num<class_String_method_num>` **(** :ref:`float<class_float>` number, :ref:`int<class_int>` decimals=-1 **)** |static|                                                    |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`num_scientific<class_String_method_num_scientific>` **(** :ref:`float<class_float>` number **)** |static|                                                                 |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`pad_decimals<class_String_method_pad_decimals>` **(** :ref:`int<class_int>` digits **)** |const|                                                                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`pad_zeros<class_String_method_pad_zeros>` **(** :ref:`int<class_int>` digits **)** |const|                                                                                |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`plus_file<class_String_method_plus_file>` **(** :ref:`String<class_String>` file **)** |const|                                                                            |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`repeat<class_String_method_repeat>` **(** :ref:`int<class_int>` count **)** |const|                                                                                       |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`replace<class_String_method_replace>` **(** :ref:`String<class_String>` what, :ref:`String<class_String>` forwhat **)** |const|                                           |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`replacen<class_String_method_replacen>` **(** :ref:`String<class_String>` what, :ref:`String<class_String>` forwhat **)** |const|                                         |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`rfind<class_String_method_rfind>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=-1 **)** |const|                                                     |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`rfindn<class_String_method_rfindn>` **(** :ref:`String<class_String>` what, :ref:`int<class_int>` from=-1 **)** |const|                                                   |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`right<class_String_method_right>` **(** :ref:`int<class_int>` position **)** |const|                                                                                      |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`rpad<class_String_method_rpad>` **(** :ref:`int<class_int>` min_length, :ref:`String<class_String>` character=" " **)** |const|                                           |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>`   | :ref:`rsplit<class_String_method_rsplit>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)** |const| |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`rstrip<class_String_method_rstrip>` **(** :ref:`String<class_String>` chars **)** |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>` **(** :ref:`String<class_String>` text **)** |const|                                                                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`simplify_path<class_String_method_simplify_path>` **(** **)** |const|                                                                                                     |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>`   | :ref:`split<class_String_method_split>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true, :ref:`int<class_int>` maxsplit=0 **)** |const|   |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedFloat32Array<class_PackedFloat32Array>` | :ref:`split_floats<class_String_method_split_floats>` **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true **)** |const|                       |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`strip_edges<class_String_method_strip_edges>` **(** :ref:`bool<class_bool>` left=true, :ref:`bool<class_bool>` right=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>` **(** :ref:`int<class_int>` from, :ref:`int<class_int>` len=-1 **)** |const|                                                          |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>`       | :ref:`to_ascii_buffer<class_String_method_to_ascii_buffer>` **(** **)** |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_lower<class_String_method_to_lower>` **(** **)** |const|                                                                                                               |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`to_upper<class_String_method_to_upper>` **(** **)** |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_utf8_buffer<class_String_method_to_utf8_buffer>` **(** **)** |const|                                                                                                   |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`trim_prefix<class_String_method_trim_prefix>` **(** :ref:`String<class_String>` prefix **)** |const|                                                                      |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`trim_suffix<class_String_method_trim_suffix>` **(** :ref:`String<class_String>` suffix **)** |const|                                                                      |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>`                               | :ref:`unicode_at<class_String_method_unicode_at>` **(** :ref:`int<class_int>` at **)** |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:`validate_node_name<class_String_method_validate_node_name>` **(** **)** |const|                                                                                           |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`xml_escape<class_String_method_xml_escape>` **(** :ref:`bool<class_bool>` escape_quotes=false **)** |const|                                                               |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>`                         | :ref:`xml_unescape<class_String_method_xml_unescape>` **(** **)** |const|                                                                                                       |
+-----------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+

Operators
---------

+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator !=<class_String_operator_neq_bool>` **(** **)**                                           |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator !=<class_String_operator_neq_bool>` **(** :ref:`String<class_String>` right **)**         |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator !=<class_String_operator_neq_bool>` **(** :ref:`StringName<class_StringName>` right **)** |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator %<class_String_operator_mod_String>` **(** :ref:`Variant<class_Variant>` right **)**      |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_String_operator_sum_String>` **(** :ref:`String<class_String>` right **)**        |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator <<class_String_operator_lt_bool>` **(** :ref:`String<class_String>` right **)**           |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator <=<class_String_operator_lte_bool>` **(** :ref:`String<class_String>` right **)**         |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator ==<class_String_operator_eq_bool>` **(** **)**                                            |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator ==<class_String_operator_eq_bool>` **(** :ref:`String<class_String>` right **)**          |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator ==<class_String_operator_eq_bool>` **(** :ref:`StringName<class_StringName>` right **)**  |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator ><class_String_operator_gt_bool>` **(** :ref:`String<class_String>` right **)**           |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>`     | :ref:`operator >=<class_String_operator_gte_bool>` **(** :ref:`String<class_String>` right **)**         |
+-----------------------------+----------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator []<class_String_operator_idx_String>` **(** :ref:`int<class_int>` index **)**             |
+-----------------------------+----------------------------------------------------------------------------------------------------------+

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

.. _class_String_constructor_String:

- :ref:`String<class_String>` **String** **(** **)**

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

----

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

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

----

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

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

----

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

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

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

.. _class_String_method_begins_with:

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

Returns ``true`` if the string begins with the given string.

----

.. _class_String_method_bigrams:

- :ref:`PackedStringArray<class_PackedStringArray>` **bigrams** **(** **)** |const|

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

::

    print("Bigrams".bigrams()) # Prints "[Bi, ig, gr, ra, am, ms]"

----

.. _class_String_method_bin_to_int:

- :ref:`int<class_int>` **bin_to_int** **(** **)** |const|

Converts a string containing a binary number into an integer. Binary strings can either be prefixed with ``0b`` or not, and they can also start with a ``-`` before the optional prefix.


.. tabs::

 .. code-tab:: gdscript

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

 .. code-tab:: csharp

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



----

.. _class_String_method_c_escape:

- :ref:`String<class_String>` **c_escape** **(** **)** |const|

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

----

.. _class_String_method_c_unescape:

- :ref:`String<class_String>` **c_unescape** **(** **)** |const|

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.

----

.. _class_String_method_capitalize:

- :ref:`String<class_String>` **capitalize** **(** **)** |const|

Changes the case of some letters. Replaces underscores with spaces, adds spaces before in-word uppercase characters, converts all letters to lowercase, then capitalizes the first letter and every letter following a space character. For ``capitalize camelCase mixed_with_underscores``, it will return ``Capitalize Camel Case Mixed With Underscores``.

----

.. _class_String_method_casecmp_to:

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

Performs a case-sensitive 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.

\ **Behavior with different string lengths:** Returns ``1`` if the "base" string is longer than the ``to`` string or ``-1`` if the "base" string is shorter than the ``to`` string. Keep in mind this length is determined by the number of Unicode codepoints, *not* the actual visible characters.

\ **Behavior with empty strings:** Returns ``-1`` if the "base" string is empty, ``1`` if the ``to`` string is empty or ``0`` if both strings are empty.

To get a boolean result from a string comparison, use the ``==`` operator instead. See also :ref:`nocasecmp_to<class_String_method_nocasecmp_to>` and :ref:`naturalnocasecmp_to<class_String_method_naturalnocasecmp_to>`.

----

.. _class_String_method_chr:

- :ref:`String<class_String>` **chr** **(** :ref:`int<class_int>` char **)** |static|

Directly converts an decimal integer to a unicode character. Tables of these characters can be found in various locations, for example `here. <https://unicodelookup.com/>`__\ 

::

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

----

.. _class_String_method_contains:

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

Returns ``true`` if the string contains the given string.

----

.. _class_String_method_count:

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

Returns the number of occurrences of substring ``what`` between ``from`` and ``to`` positions. If ``from`` and ``to`` equals 0 the whole string will be used. If only ``to`` equals 0 the remained substring will be used.

----

.. _class_String_method_countn:

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

Returns the number of occurrences of substring ``what`` (ignoring case) between ``from`` and ``to`` positions. If ``from`` and ``to`` equals 0 the whole string will be used. If only ``to`` equals 0 the remained substring will be used.

----

.. _class_String_method_dedent:

- :ref:`String<class_String>` **dedent** **(** **)** |const|

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

----

.. _class_String_method_ends_with:

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

Returns ``true`` if the string ends with the given string.

----

.. _class_String_method_find:

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

Returns the index of the **first** case-sensitive occurrence of the specified string in this instance, or ``-1``. Optionally, the starting search index can be specified, continuing to the end of the string.

\ **Note:** If you just want to know whether a string contains a substring, use the ``in`` operator as follows:


.. tabs::

 .. code-tab:: gdscript

    print("i" in "team") # Will print `false`.

 .. code-tab:: csharp

    // C# has no in operator, but we can use `Contains()`.
    GD.Print("team".Contains("i")); // Will print `false`.



----

.. _class_String_method_findn:

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

Returns the index of the **first** case-insensitive occurrence of the specified string in this instance, or ``-1``. Optionally, the starting search index can be specified, continuing to the end of the string.

----

.. _class_String_method_format:

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

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

----

.. _class_String_method_get_base_dir:

- :ref:`String<class_String>` **get_base_dir** **(** **)** |const|

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

----

.. _class_String_method_get_basename:

- :ref:`String<class_String>` **get_basename** **(** **)** |const|

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

----

.. _class_String_method_get_extension:

- :ref:`String<class_String>` **get_extension** **(** **)** |const|

Returns the extension without the leading period character (``.``) if the string is a valid file name or path. If the string does not contain an extension, returns an empty string instead.

::

    print("/path/to/file.txt".get_extension())  # "txt"
    print("file.txt".get_extension())  # "txt"
    print("file.sample.txt".get_extension())  # "txt"
    print(".txt".get_extension())  # "txt"
    print("file.txt.".get_extension())  # "" (empty string)
    print("file.txt..".get_extension())  # "" (empty string)
    print("txt".get_extension())  # "" (empty string)
    print("".get_extension())  # "" (empty string)

----

.. _class_String_method_get_file:

- :ref:`String<class_String>` **get_file** **(** **)** |const|

If the string is a valid file path, returns the filename.

----

.. _class_String_method_get_slice:

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

Splits a string using a ``delimiter`` and returns a substring at index ``slice``. Returns an empty string if the index doesn't exist.

This is a more performant alternative to :ref:`split<class_String_method_split>` for cases when you need only one element from the array at a fixed index.

Example:

::

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

----

.. _class_String_method_get_slice_count:

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

Splits a string using a ``delimiter`` and returns a number of slices.

----

.. _class_String_method_get_slicec:

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

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

This is a more performant alternative to :ref:`split<class_String_method_split>` for cases when you need only one element from the array at a fixed index.

----

.. _class_String_method_hash:

- :ref:`int<class_int>` **hash** **(** **)** |const|

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

\ **Note:** ``String``\ s with equal content will always produce identical hash values. However, the reverse is not true. Returning identical hash values does *not* imply the strings are equal, because different strings can have identical hash values due to hash collisions.

----

.. _class_String_method_hex_to_int:

- :ref:`int<class_int>` **hex_to_int** **(** **)** |const|

Converts a string containing a hexadecimal number into an integer. Hexadecimal strings can either be prefixed with ``0x`` or not, and they can also start with a ``-`` before the optional prefix.


.. 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".



----

.. _class_String_method_humanize_size:

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

Converts an integer representing a number of bytes into a human-readable form.

Note that this output is in `IEC prefix format <https://en.wikipedia.org/wiki/Binary_prefix#IEC_prefixes>`__, and includes ``B``, ``KiB``, ``MiB``, ``GiB``, ``TiB``, ``PiB``, and ``EiB``.

----

.. _class_String_method_indent:

- :ref:`String<class_String>` **indent** **(** :ref:`String<class_String>` prefix **)** |const|

Returns a copy of the string with lines indented with ``prefix``.

For example, the string can be indented with two tabs using ``"\t\t"``, or four spaces using ``"    "``. The prefix can be any string so it can also be used to comment out strings with e.g. ``"# "``. See also :ref:`dedent<class_String_method_dedent>` to remove indentation.

\ **Note:** Empty lines are kept empty.

----

.. _class_String_method_insert:

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

Returns a copy of the string with the substring ``what`` inserted at the given position.

----

.. _class_String_method_is_absolute_path:

- :ref:`bool<class_bool>` **is_absolute_path** **(** **)** |const|

Returns ``true`` if the string is a path to a file or directory and its starting point is explicitly defined. This includes ``res://``, ``user://``, ``C:\``, ``/``, etc.

----

.. _class_String_method_is_empty:

- :ref:`bool<class_bool>` **is_empty** **(** **)** |const|

Returns ``true`` if the length of the string equals ``0``.

----

.. _class_String_method_is_relative_path:

- :ref:`bool<class_bool>` **is_relative_path** **(** **)** |const|

Returns ``true`` if the string is a path to a file or directory and its starting point is implicitly defined within the context it is being used. The starting point may refer to the current directory (``./``), or the current :ref:`Node<class_Node>`.

----

.. _class_String_method_is_subsequence_of:

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

Returns ``true`` if this string is a subsequence of the given string.

----

.. _class_String_method_is_subsequence_ofn:

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

Returns ``true`` if this string is a subsequence of the given string, without considering case.

----

.. _class_String_method_is_valid_filename:

- :ref:`bool<class_bool>` **is_valid_filename** **(** **)** |const|

Returns ``true`` if this string is free from characters that aren't allowed in file names, those being:

\ ``: / \ ? * " | % < >``

----

.. _class_String_method_is_valid_float:

- :ref:`bool<class_bool>` **is_valid_float** **(** **)** |const|

Returns ``true`` if this string contains a valid float. This is inclusive of integers, and also supports exponents:

::

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

----

.. _class_String_method_is_valid_hex_number:

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

Returns ``true`` if this string contains a valid hexadecimal number. If ``with_prefix`` is ``true``, then a validity of the hexadecimal number is determined by ``0x`` prefix, for instance: ``0xDEADC0DE``.

----

.. _class_String_method_is_valid_html_color:

- :ref:`bool<class_bool>` **is_valid_html_color** **(** **)** |const|

Returns ``true`` if this string contains a valid color in hexadecimal HTML notation. Other HTML notations such as named colors or ``hsl()`` colors aren't considered valid by this method and will return ``false``.

----

.. _class_String_method_is_valid_identifier:

- :ref:`bool<class_bool>` **is_valid_identifier** **(** **)** |const|

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("good_ident_1".is_valid_identifier()) # Prints "true"
    print("1st_bad_ident".is_valid_identifier()) # Prints "false"
    print("bad_ident_#2".is_valid_identifier()) # Prints "false"

----

.. _class_String_method_is_valid_int:

- :ref:`bool<class_bool>` **is_valid_int** **(** **)** |const|

Returns ``true`` if this string contains a valid integer.

::

    print("7".is_valid_int()) # Prints "true"
    print("14.6".is_valid_int()) # Prints "false"
    print("L".is_valid_int()) # Prints "false"
    print("+3".is_valid_int()) # Prints "true"
    print("-12".is_valid_int()) # Prints "true"

----

.. _class_String_method_is_valid_ip_address:

- :ref:`bool<class_bool>` **is_valid_ip_address** **(** **)** |const|

Returns ``true`` if this string contains only 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`` as valid.

----

.. _class_String_method_join:

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

Returns a ``String`` which is the concatenation of the ``parts``. The separator between elements is the string providing this method.

Example:


.. tabs::

 .. code-tab:: gdscript

    print(", ".join(["One", "Two", "Three", "Four"]))

 .. code-tab:: csharp

    GD.Print(String.Join(",", new string[] {"One", "Two", "Three", "Four"}));



----

.. _class_String_method_json_escape:

- :ref:`String<class_String>` **json_escape** **(** **)** |const|

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

----

.. _class_String_method_left:

- :ref:`String<class_String>` **left** **(** :ref:`int<class_int>` position **)** |const|

Returns a number of characters from the left of the string. If negative ``position`` is used, the characters are counted downwards from ``String``'s length.

Examples:

::

    print("sample text".left(3)) #prints "sam"
    print("sample text".left(-3)) #prints "sample t"

----

.. _class_String_method_length:

- :ref:`int<class_int>` **length** **(** **)** |const|

Returns the string's amount of characters.

----

.. _class_String_method_lpad:

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

Formats a string to be at least ``min_length`` long by adding ``character``\ s to the left of the string.

----

.. _class_String_method_lstrip:

- :ref:`String<class_String>` **lstrip** **(** :ref:`String<class_String>` chars **)** |const|

Returns a copy of the string with characters removed from the left. The ``chars`` argument is a string specifying the set of characters to be removed.

\ **Note:** The ``chars`` is not a prefix. See :ref:`trim_prefix<class_String_method_trim_prefix>` method that will remove a single prefix string rather than a set of characters.

----

.. _class_String_method_match:

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

Does a simple case-sensitive 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``.

----

.. _class_String_method_matchn:

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

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``.

----

.. _class_String_method_md5_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer** **(** **)** |const|

Returns the MD5 hash of the string as an array of bytes.

----

.. _class_String_method_md5_text:

- :ref:`String<class_String>` **md5_text** **(** **)** |const|

Returns the MD5 hash of the string as a string.

----

.. _class_String_method_naturalnocasecmp_to:

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

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 will be converted to uppercase during the comparison.

When used for sorting, natural order comparison will order suites of numbers as expected by most people. If you sort the numbers from 1 to 10 using natural order, you will get ``[1, 2, 3, ...]`` instead of ``[1, 10, 2, 3, ...]``.

\ **Behavior with different string lengths:** Returns ``1`` if the "base" string is longer than the ``to`` string or ``-1`` if the "base" string is shorter than the ``to`` string. Keep in mind this length is determined by the number of Unicode codepoints, *not* the actual visible characters.

\ **Behavior with empty strings:** Returns ``-1`` if the "base" string is empty, ``1`` if the ``to`` string is empty or ``0`` if both strings are empty.

To get a boolean result from a string comparison, use the ``==`` operator instead. See also :ref:`nocasecmp_to<class_String_method_nocasecmp_to>` and :ref:`casecmp_to<class_String_method_casecmp_to>`.

----

.. _class_String_method_nocasecmp_to:

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

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 will be converted to uppercase during the comparison.

\ **Behavior with different string lengths:** Returns ``1`` if the "base" string is longer than the ``to`` string or ``-1`` if the "base" string is shorter than the ``to`` string. Keep in mind this length is determined by the number of Unicode codepoints, *not* the actual visible characters.

\ **Behavior with empty strings:** Returns ``-1`` if the "base" string is empty, ``1`` if the ``to`` string is empty or ``0`` if both strings are empty.

To get a boolean result from a string comparison, use the ``==`` operator instead. See also :ref:`casecmp_to<class_String_method_casecmp_to>` and :ref:`naturalnocasecmp_to<class_String_method_naturalnocasecmp_to>`.

----

.. _class_String_method_num:

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

Converts a :ref:`float<class_float>` to a string representation of a decimal number.

The number of decimal places can be specified with ``decimals``. If ``decimals`` is ``-1`` (default), decimal places will be automatically adjusted so that the string representation has 14 significant digits (counting both digits to the left and the right of the decimal point).

Trailing zeros are not included in the string. The last digit will be rounded and not truncated.

Some examples:

::

    String.num(3.141593)     # "3.141593"
    String.num(3.141593, 3)  # "3.142"
    String.num(3.14159300)   # "3.141593", no trailing zeros.
    # Last digit will be rounded up here, which reduces total digit count since
    # trailing zeros are removed:
    String.num(42.129999, 5) # "42.13"
    # If `decimals` is not specified, the total amount of significant digits is 14:
    String.num(-0.0000012345432123454321)     # "-0.00000123454321"
    String.num(-10000.0000012345432123454321) # "-10000.0000012345"

----

.. _class_String_method_num_scientific:

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

----

.. _class_String_method_pad_decimals:

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

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

----

.. _class_String_method_pad_zeros:

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

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

----

.. _class_String_method_plus_file:

- :ref:`String<class_String>` **plus_file** **(** :ref:`String<class_String>` file **)** |const|

If the string is a path, this concatenates ``file`` at the end of the string as a subpath. E.g. ``"this/is".plus_file("path") == "this/is/path"``.

----

.. _class_String_method_repeat:

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

Returns original string repeated a number of times. The number of repetitions is given by the argument.

----

.. _class_String_method_replace:

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

Replaces occurrences of a case-sensitive substring with the given one inside the string.

----

.. _class_String_method_replacen:

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

Replaces occurrences of a case-insensitive substring with the given one inside the string.

----

.. _class_String_method_rfind:

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

Returns the index of the **last** case-sensitive occurrence of the specified string in this instance, or ``-1``. Optionally, the starting search index can be specified, continuing to the beginning of the string.

----

.. _class_String_method_rfindn:

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

Returns the index of the **last** case-insensitive occurrence of the specified string in this instance, or ``-1``. Optionally, the starting search index can be specified, continuing to the beginning of the string.

----

.. _class_String_method_right:

- :ref:`String<class_String>` **right** **(** :ref:`int<class_int>` position **)** |const|

Returns a number of characters from the right of the string. If negative ``position`` is used, the characters are counted downwards from ``String``'s length.

Examples:

::

    print("sample text".right(3)) #prints "ext"
    print("sample text".right(-3)) #prints "ple text"

----

.. _class_String_method_rpad:

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

Formats a string to be at least ``min_length`` long by adding ``character``\ s to the right of the string.

----

.. _class_String_method_rsplit:

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

Splits the string by a ``delimiter`` string and returns an array of the substrings, starting from right.

The splits in the returned array are sorted in the same order as the original string, from left to right.

If ``maxsplit`` is specified, it defines the number of splits to do from the right up to ``maxsplit``. The default value of 0 means that all items are split, thus giving the same result as :ref:`split<class_String_method_split>`.

Example:


.. 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 "Four"
    print(some_array[1]) # Prints "Three,Two,One"

 .. code-tab:: csharp

    // There is no Rsplit.



----

.. _class_String_method_rstrip:

- :ref:`String<class_String>` **rstrip** **(** :ref:`String<class_String>` chars **)** |const|

Returns a copy of the string with characters removed from the right. The ``chars`` argument is a string specifying the set of characters to be removed.

\ **Note:** The ``chars`` is not a suffix. See :ref:`trim_suffix<class_String_method_trim_suffix>` method that will remove a single suffix string rather than a set of characters.

----

.. _class_String_method_sha1_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer** **(** **)** |const|

Returns the SHA-1 hash of the string as an array of bytes.

----

.. _class_String_method_sha1_text:

- :ref:`String<class_String>` **sha1_text** **(** **)** |const|

Returns the SHA-1 hash of the string as a string.

----

.. _class_String_method_sha256_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer** **(** **)** |const|

Returns the SHA-256 hash of the string as an array of bytes.

----

.. _class_String_method_sha256_text:

- :ref:`String<class_String>` **sha256_text** **(** **)** |const|

Returns the SHA-256 hash of the string as a string.

----

.. _class_String_method_similarity:

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

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

::

    print("ABC123".similarity("ABC123")) # Prints "1"
    print("ABC123".similarity("XYZ456")) # Prints "0"
    print("ABC123".similarity("123ABC")) # Prints "0.8"
    print("ABC123".similarity("abc123")) # Prints "0.4"

----

.. _class_String_method_simplify_path:

- :ref:`String<class_String>` **simplify_path** **(** **)** |const|

Returns a simplified canonical path.

----

.. _class_String_method_split:

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

Splits the string by a ``delimiter`` string and returns an array of the substrings. The ``delimiter`` can be of any length.

If ``maxsplit`` is specified, it defines the number of splits to do from the left up to ``maxsplit``. The default value of ``0`` means that all items are split.

If you need only one element from the array at a specific index, :ref:`get_slice<class_String_method_get_slice>` is a more performant option.

Example:


.. tabs::

 .. code-tab:: gdscript

    var some_string = "One,Two,Three,Four"
    var some_array = some_string.split(",", true, 1)
    print(some_array.size()) # Prints 2
    print(some_array[0]) # Prints "Four"
    print(some_array[1]) # Prints "Three,Two,One"

 .. code-tab:: csharp

    var someString = "One,Two,Three,Four";
    var someArray = someString.Split(",", true); // This is as close as it gets to Godots API.
    GD.Print(someArray[0]); // Prints "Four"
    GD.Print(someArray[1]); // Prints "Three,Two,One"



If you need to split strings with more complex rules, use the :ref:`RegEx<class_RegEx>` class instead.

----

.. _class_String_method_split_floats:

- :ref:`PackedFloat32Array<class_PackedFloat32Array>` **split_floats** **(** :ref:`String<class_String>` delimiter, :ref:`bool<class_bool>` allow_empty=true **)** |const|

Splits the string in floats by using a delimiter string and returns an array of the substrings.

For example, ``"1,2.5,3"`` will return ``[1,2.5,3]`` if split by ``","``.

----

.. _class_String_method_strip_edges:

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

Returns a copy of the string stripped of any non-printable character (including tabulations, spaces and line breaks) at the beginning and the end. The optional arguments are used to toggle stripping on the left and right edges respectively.

----

.. _class_String_method_strip_escapes:

- :ref:`String<class_String>` **strip_escapes** **(** **)** |const|

Returns a copy of the string stripped of any escape character. These include all non-printable control characters of the first page of the ASCII table (< 32), such as tabulation (``\t`` in C) and newline (``\n`` and ``\r``) characters, but not spaces.

----

.. _class_String_method_substr:

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

Returns part of the string from the position ``from`` with length ``len``. Argument ``len`` is optional and using ``-1`` will return remaining characters from given position.

----

.. _class_String_method_to_ascii_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer** **(** **)** |const|

Converts the String (which is a character array) to ASCII/Latin-1 encoded :ref:`PackedByteArray<class_PackedByteArray>` (which is an array of bytes). The conversion is faster compared to :ref:`to_utf8_buffer<class_String_method_to_utf8_buffer>`, as this method assumes that all the characters in the String are ASCII/Latin-1 characters, unsupported characters are replaced with spaces.

----

.. _class_String_method_to_float:

- :ref:`float<class_float>` **to_float** **(** **)** |const|

Converts a string containing a decimal number into a ``float``. The method will stop on the first non-number character except the first ``.`` (decimal point), and ``e`` which is used for exponential.

::

    print("12.3".to_float()) # 12.3
    print("1.2.3".to_float()) # 1.2
    print("12ab3".to_float()) # 12
    print("1e3".to_float()) # 1000

----

.. _class_String_method_to_int:

- :ref:`int<class_int>` **to_int** **(** **)** |const|

Converts a string containing an integer number into an ``int``. The method will remove any non-number character and stop if it encounters a ``.``.

::

    print("123".to_int()) # 123
    print("a1b2c3".to_int()) # 123
    print("1.2.3".to_int()) # 1

----

.. _class_String_method_to_lower:

- :ref:`String<class_String>` **to_lower** **(** **)** |const|

Returns the string converted to lowercase.

----

.. _class_String_method_to_upper:

- :ref:`String<class_String>` **to_upper** **(** **)** |const|

Returns the string converted to uppercase.

----

.. _class_String_method_to_utf16_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer** **(** **)** |const|

Converts the String (which is an array of characters) to UTF-16 encoded :ref:`PackedByteArray<class_PackedByteArray>` (which is an array of bytes).

----

.. _class_String_method_to_utf32_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer** **(** **)** |const|

Converts the String (which is an array of characters) to UTF-32 encoded :ref:`PackedByteArray<class_PackedByteArray>` (which is an array of bytes).

----

.. _class_String_method_to_utf8_buffer:

- :ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer** **(** **)** |const|

Converts the String (which is an array of characters) to UTF-8 encode :ref:`PackedByteArray<class_PackedByteArray>` (which is an array of bytes). The conversion is a bit slower than :ref:`to_ascii_buffer<class_String_method_to_ascii_buffer>`, but supports all UTF-8 characters. Therefore, you should prefer this function over :ref:`to_ascii_buffer<class_String_method_to_ascii_buffer>`.

----

.. _class_String_method_trim_prefix:

- :ref:`String<class_String>` **trim_prefix** **(** :ref:`String<class_String>` prefix **)** |const|

Removes a given string from the start if it starts with it or leaves the string unchanged.

----

.. _class_String_method_trim_suffix:

- :ref:`String<class_String>` **trim_suffix** **(** :ref:`String<class_String>` suffix **)** |const|

Removes a given string from the end if it ends with it or leaves the string unchanged.

----

.. _class_String_method_unicode_at:

- :ref:`int<class_int>` **unicode_at** **(** :ref:`int<class_int>` at **)** |const|

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

----

.. _class_String_method_uri_decode:

- :ref:`String<class_String>` **uri_decode** **(** **)** |const|

Decodes a string in URL encoded format. This is meant to decode parameters in a URL when receiving an HTTP request.


.. tabs::

 .. code-tab:: gdscript

    print("https://example.org/?escaped=" + "Godot%20Engine%3A%27docs%27".uri_decode())

 .. code-tab:: csharp

    GD.Print("https://example.org/?escaped=" + "Godot%20Engine%3a%27Docs%27".URIDecode());



----

.. _class_String_method_uri_encode:

- :ref:`String<class_String>` **uri_encode** **(** **)** |const|

Encodes a string to URL friendly format. This is meant to encode parameters in a URL when sending an HTTP request.


.. tabs::

 .. code-tab:: gdscript

    print("https://example.org/?escaped=" + "Godot Engine:'docs'".uri_encode())

 .. code-tab:: csharp

    GD.Print("https://example.org/?escaped=" + "Godot Engine:'docs'".URIEncode());



----

.. _class_String_method_validate_node_name:

- :ref:`String<class_String>` **validate_node_name** **(** **)** |const|

Removes any characters from the string that are prohibited in :ref:`Node<class_Node>` names (``.`` ``:`` ``@`` ``/`` ``"``).

----

.. _class_String_method_xml_escape:

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

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.

----

.. _class_String_method_xml_unescape:

- :ref:`String<class_String>` **xml_unescape** **(** **)** |const|

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

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

.. _class_String_operator_neq_bool:

- :ref:`bool<class_bool>` **operator !=** **(** **)**

----

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

----

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

----

.. _class_String_operator_mod_String:

- :ref:`String<class_String>` **operator %** **(** :ref:`Variant<class_Variant>` right **)**

----

.. _class_String_operator_sum_String:

- :ref:`String<class_String>` **operator +** **(** :ref:`String<class_String>` right **)**

----

.. _class_String_operator_lt_bool:

- :ref:`bool<class_bool>` **operator <** **(** :ref:`String<class_String>` right **)**

----

.. _class_String_operator_lte_bool:

- :ref:`bool<class_bool>` **operator <=** **(** :ref:`String<class_String>` right **)**

----

.. _class_String_operator_eq_bool:

- :ref:`bool<class_bool>` **operator ==** **(** **)**

----

- :ref:`bool<class_bool>` **operator ==** **(** :ref:`String<class_String>` right **)**

----

- :ref:`bool<class_bool>` **operator ==** **(** :ref:`StringName<class_StringName>` right **)**

----

.. _class_String_operator_gt_bool:

- :ref:`bool<class_bool>` **operator >** **(** :ref:`String<class_String>` right **)**

----

.. _class_String_operator_gte_bool:

- :ref:`bool<class_bool>` **operator >=** **(** :ref:`String<class_String>` right **)**

----

.. _class_String_operator_idx_String:

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

.. |virtual| replace:: :abbr:`virtual (This method should typically be overridden by the user to have any effect.)`
.. |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.)`