godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-05 14:10:19 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/es/class_string.rst
Rémi Verschelde c3f2364c10 Sync classref with 4.6 branch 
Lots of translations invalidated (fuzzied) as we just synced Weblate.
2025-12-19 16:39:51 +01:00

2504 lines
143 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_String:
String
======
Un tipo integrado para strings.
.. rst-class:: classref-introduction-group
Descripción
----------------------
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::
Hay diferencias notables cuando usa esta API con C#. Véase :ref:`doc_c_sharp_differences` para más información.
.. rst-class:: classref-introduction-group
Tutoriales
--------------------
- :doc:`Strings de formato de GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`
.. rst-class:: classref-reftable-group
Constructores
--------------------------
.. 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
Métodos
--------------
.. 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
Operadores
--------------------
.. 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
Descripciones de Constructores
------------------------------------------------------------
.. _class_String_constructor_String:
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ ) :ref:`🔗<class_String_constructor_String>`
Construye una **String** vacía (``""``).
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`String<class_String>`\ )
Construye una **String** como copia de la **String** dada.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`NodePath<class_NodePath>`\ )
Construye una nueva **String** desde el :ref:`NodePath<class_NodePath>` dado.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`StringName<class_StringName>`\ )
Construye una nueva **String** desde el :ref:`StringName<class_StringName>` dado.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Métodos
------------------------------------------------
.. _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>`
Devuelve ``true`` si la string comienza con el ``text`` dado. Véase también :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>`
Devuelve un array que contiene los bigramas (pares de caracteres consecutivos) de esta string.
::
print("Levántate!".bigrams()) # Imprime ["Le", "ev", "vá", "nt", "ta", "at", "te", "e!"]
.. 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>`
Devuelve una copia de la string con caracteres especiales escapados usando el estándar del lenguaje C.
.. rst-class:: classref-item-separator
----
.. _class_String_method_c_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_String_method_c_unescape>`
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>`
Devuelve ``true`` si la string contiene ``what``, **ignorando mayúsculas y minúsculas**.
Si necesitas saber dónde está ``what`` dentro de la string, usa :ref:`findn()<class_String_method_findn>`. Véase también :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>`
Devuelve el número de ocurrencias de la substring ``what`` entre las posiciones ``from`` y ``to``. Si ``to`` es 0, la búsqueda continúa hasta el final de la 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>`
Devuelve el número de ocurrencias de la substring ``what`` entre las posiciones ``from`` y ``to``, **ignorando mayúsculas y minúsculas**. Si ``to`` es 0, la búsqueda continúa hasta el final de la 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>`
Devuelve una string con ``chars`` caracteres borrados, comenzando desde ``position``. Si ``chars`` excede la longitud de la string dada la ``position`` especificada, se borrarán menos caracteres de la string devuelta. Devuelve una string vacía si ``position`` o ``chars`` son negativos. Devuelve la string original sin modificar si ``chars`` es ``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>`
Como :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` pero prioriza las strings que comienzan con puntos (``.``) y guiones bajos (``_``) antes que cualquier otro carácter. Útil al ordenar carpetas o nombres de archivos.
Para obtener un resultado :ref:`bool<class_bool>` de una comparación de strings, usa el operador ``==`` en su lugar. Véase también :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` y :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>`
Como :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` pero prioriza las strings que comienzan con puntos (``.``) y guiones bajos (``_``) antes que cualquier otro carácter. Útil al ordenar carpetas o nombres de archivos.
Para obtener un resultado :ref:`bool<class_bool>` de una comparación de strings, usa el operador ``==`` en su lugar. Véase también :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` y :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>`
Devuelve el índice de la **primera** ocurrencia **insensible a mayúsculas y minúsculas** de ``what`` en esta string, o ``-1`` si no hay ninguna. El índice de búsqueda inicial se puede especificar con ``from``, continuando hasta el final de la 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>`
Si la string es una ruta de archivo válida, devuelve el nombre del directorio base.
::
var dir_path = "/ruta/al/archivo.txt".get_base_dir() # dir_path es "/ruta/al"
.. 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>`
Si la string es una ruta de archivo válida, devuelve la ruta de acceso de archivo completa, sin la extensión.
::
var base = "/ruta/a/archivo.txt".get_basename() # la base es "/ruta/a/archivo"
.. 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>`
Devuelve el valor hash de 32 bits que representa el contenido de la string.
\ **Nota:** *No* se garantiza que las strings con valores hash iguales sean las mismas, como resultado de colisiones hash. Por el contrario, se garantiza que las strings con diferentes valores hash sean diferentes.
.. 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>`
Indenta cada línea de la string con el ``prefix`` dado. Las líneas vacías no se indentan. Véase también :ref:`dedent()<class_String_method_dedent>` para eliminar la indentación.
Por ejemplo, la string se puede indentar con dos tabulaciones usando ``"\t\t"``, o cuatro espacios usando ``" "``.
.. 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>`
Inserta ``what`` en la ``position`` dada en la 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>`
Devuelve ``true`` si la string es una ruta a un archivo o directorio, y su punto de inicio está definido explícitamente. Este método es lo opuesto a :ref:`is_relative_path()<class_String_method_is_relative_path>`.
Esto incluye todas las rutas que comienzan con ``"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>`
Devuelve ``true`` si la string es una ruta, y su punto de inicio depende del contexto. La ruta podría comenzar desde el directorio actual, o el :ref:`Node<class_Node>` actual (si la string deriva de un :ref:`NodePath<class_NodePath>`), y a veces puede tener el prefijo ``"./"``. Este método es lo opuesto a :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>`
**Obsoleto:** 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>`
Devuelve una copia de la string con los caracteres especiales escapados usando el estándar JSON. Debido a que coincide estrechamente con el estándar C, es posible usar :ref:`c_unescape()<class_String_method_c_unescape>` para desencapsular la string, si es necesario.
.. 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>`
Devuelve el número de caracteres en la string. Las strings vacías (``""``) siempre devuelven ``0``. Véase también :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>`
Formatea la string para que tenga al menos ``min_length`` de longitud añadiendo ``character``\ s a la izquierda de la string, si es necesario. Véase también :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>`
Elimina un conjunto de caracteres definidos en ``chars`` del comienzo de la string. Véase también :ref:`rstrip()<class_String_method_rstrip>`.
\ **Nota:** ``chars`` no es un prefijo. Usa :ref:`trim_prefix()<class_String_method_trim_prefix>` para eliminar un solo prefijo, en lugar de un conjunto de caracteres.
.. 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>`
Realiza una comparación simple de expresiones (también llamado "glob" o "globbing"), donde ``*`` coincide con cero o más caracteres arbitrarios y ``?`` coincide con cualquier carácter individual excepto un punto (``.``). Una string vacía o una expresión vacía siempre se evalúa como ``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>`
Realiza una comparación simple de expresiones **insensible a mayúsculas/minúsculas**, donde ``*`` coincide con cero o más caracteres arbitrarios y ``?`` coincide con cualquier carácter individual excepto un punto (``.``). Una string vacía o una expresión vacía siempre se evalúa como ``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>`
Elimina todas las ocurrencias del carácter Unicode con el código ``what``. Versión más rápida de :ref:`replace()<class_String_method_replace>` cuando la clave tiene solo un carácter de longitud y el reemplazo es ``""``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_String_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_repeat>`
Repite esta string un número de veces. ``count`` debe ser mayor que ``0``. De lo contrario, devuelve una string vacía.
.. 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>`
Reemplaza todas las instancias de ``what`` dentro de la string con el ``forwhat`` dado.
.. 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>`
Reemplaza cualquier ocurrencia de los caracteres en ``keys`` con el carácter Unicode con el código ``with``. Véase también :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>`
Reemplaza todas las ocurrencias **insensibles a mayúsculas y minúsculas** de ``what`` dentro de la string con el ``forwhat`` dado.
.. rst-class:: classref-item-separator
----
.. _class_String_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_String_method_reverse>`
Devuelve la copia de esta string en orden inverso. Esta operación funciona en puntos de código Unicode, en lugar de secuencias de puntos de código, y puede romper cosas como letras compuestas o 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>`
Devuelve el índice de la **última** ocurrencia **insensible a mayúsculas y minúsculas** de ``what`` en esta string, o ``-1`` si no hay ninguna. El índice de búsqueda inicial se puede especificar con ``from``, continuando hasta el principio de la string. Este método es el inverso de :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>`
Formatea la string para que tenga al menos ``min_length`` de longitud, añadiendo ``character``\ s a la derecha de la string, si es necesario. Véase también :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>`
Elimina un conjunto de caracteres definidos en ``chars`` del final de la string. Véase también :ref:`lstrip()<class_String_method_lstrip>`.
\ **Nota:** ``chars`` no es un sufijo. Usa :ref:`trim_suffix()<class_String_method_trim_suffix>` para eliminar un solo sufijo, en lugar de un conjunto de caracteres.
.. 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>`
Devuelve el hash `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ de la string como un :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>`
Devuelve el hash `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ de la string como otra **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>`
Devuelve el `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ hash de la string como un :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>`
Devuelve el hash `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ de la string como otra **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>`
Si la string es una ruta de archivo válida, convierte la string en una ruta canónica. Esta es la ruta más corta posible, sin ``"./"``, y todo el ``".."`` y ``"/"`` innecesarios.
::
var ruta_simple = "./ruta/a///../archivo".simplify_path()
print(ruta_simple) # Imprime "ruta/archivo"
.. 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>`
Devuelve la string convertida a ``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>`
Devuelve la string convertida a ``minúsculas``.
.. 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>`
Devuelve la string convertida a ``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>`
Devuelve la string convertida a ``MAYÚSCULAS``.
.. 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>`
Convierte la string a un :ref:`PackedByteArray<class_PackedByteArray>` codificado en `UTF-8 <https://en.wikipedia.org/wiki/UTF-8>`__. Este método es un poco más lento que :ref:`to_ascii_buffer()<class_String_method_to_ascii_buffer>`, pero soporta todos los caracteres UTF-8. En la mayoría de los casos, es preferible usar este método. Este es el inverso de :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>`
Convierte la string a un :ref:`PackedByteArray<class_PackedByteArray>` codificado en `UTF-16 <https://en.wikipedia.org/wiki/UTF-16>`__. Este es el inverso de :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>`
Convierte la string a un :ref:`PackedByteArray<class_PackedByteArray>` codificado en `UTF-32 <https://en.wikipedia.org/wiki/UTF-32>`__. Este es el inverso de :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>`
Convierte la string en un :ref:`PackedByteArray<class_PackedByteArray>` codificado `carácter ancho <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 en Windows, UTF-32 en otras plataformas). Esto es el inverso de :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>`
Elimina el ``prefix`` dado del inicio de la string, o devuelve la string sin cambios.
.. 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>`
Elimina el ``suffix`` dado del final de la string, o string la string sin cambios.
.. 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>`
Devuelve el código de carácter en la posición ``at``.
Véase también :ref:`chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` y :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>`
Decodifica la ruta del archivo desde su formato codificado en URL. A diferencia de :ref:`uri_decode()<class_String_method_uri_decode>` este método deja ``+`` como está.
.. 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>`
Devuelve una copia de la string con todos los caracteres que no están permitidos en :ref:`is_valid_filename()<class_String_method_is_valid_filename>` reemplazados con guiones bajos.
.. 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>`
Devuelve una copia de la string con todos los caracteres que no están permitidos en :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) reemplazados con guiones bajos.
.. 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>`
Devuelve una copia de la string con los caracteres especiales escapados usando el estándar XML. Si ``escape_quotes`` es ``true``, la comilla simple (``'``) y la comilla doble (``"``) también se escapan.
.. 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>`
Devuelve una copia de la string con los caracteres escapados reemplazados por sus significados según el estándar XML.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descripciones de Operadores
------------------------------------------------------
.. _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>`
Devuelve ``true`` si ambas strings no contienen la misma secuencia de caracteres.
.. 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>`
Devuelve ``true`` si esta **String** no es equivalente al :ref:`StringName<class_StringName>` dado.
.. 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>`
Añade ``right`` al final de esta **String**, también conocido como concatenación de strings.
.. 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>`
Añade ``right`` al final de esta **String**, devolviendo un **String**. Esto también se conoce como concatenación de strings.
.. 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>`
Devuelve ``true`` si la **String** de la izquierda es anterior a ``right`` en el `orden Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, que coincide aproximadamente con el orden alfabético. Útil para ordenar.
.. 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>`
Devuelve ``true`` si la **String** de la izquierda es anterior a ``right`` en el `orden Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, que coincide aproximadamente con el orden alfabético, o si ambos son iguales.
.. 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>`
Devuelve ``true`` si ambas strings contienen la misma secuencia de caracteres.
.. 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>`
Devuelve ``true`` si esta **String** es equivalente al :ref:`StringName<class_StringName>` dado.
.. 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>`
Devuelve ``true`` si la **String** de la izquierda es posterior a ``right`` en el `orden Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, que coincide aproximadamente con el orden alfabético. Útil para ordenar.
.. 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>`
Devuelve ``true`` si la **String** de la izquierda es posterior a ``right`` en el `orden Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, que coincide aproximadamente con el orden alfabético, o si ambos son iguales.
.. 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>`
Devuelve una nueva **String** que solo contiene el carácter en ``index``. Los índices comienzan desde ``0``. Si ``index`` es mayor o igual que ``0``, el carácter se obtiene desde el principio de la string. Si ``index`` es un valor negativo, se obtiene desde el final. Acceder a una string fuera de los límites provocará un error en tiempo de ejecución, pausando la ejecución del proyecto si se ejecuta desde el editor.
.. |virtual| replace:: :abbr:`virtual (Normalmente, este método debería ser sobreescrito por el usuario para que tenga algún efecto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Este método no tiene efectos secundarios. No modifica ninguna de las variables miembro de la instancia.)`
.. |vararg| replace:: :abbr:`vararg (Este método permite agregar cualquier número de argumentos después de los descritos aquí.)`
.. |constructor| replace:: :abbr:`constructor (Este método se utiliza para construir un tipo.)`
.. |static| replace:: :abbr:`static (Este método no necesita una instancia para ser llamado, por lo que puede llamarse directamente utilizando el nombre de la clase.)`
.. |operator| replace:: :abbr:`operator (Este método describe un operador válido para usar con este tipo como operando izquierdo.)`
.. |bitfield| replace:: :abbr:`BitField (Este valor es un entero compuesto como una máscara de bits de las siguientes banderas.)`
.. |void| replace:: :abbr:`void (Sin valor de retorno.)`
Reference in New Issue View Git Blame Copy Permalink