godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-02 21:48:52 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.5
godot-docs-l10n/classes/it/class_string.rst
Rémi Verschelde b20bcbb88b Sync classref with 4.5 branch
2025-09-30 13:31:55 +02:00

2489 lines
144 KiB
ReStructuredText
Raw Permalink Blame History

:github_url: hide
.. _class_String:
String
======
Un tipo integrato per le stringhe.
.. rst-class:: classref-introduction-group
Descrizione
----------------------
Questo è il tipo di Variant stringa integrato (e quello utilizzato da GDScript). Le stringhe possono contenere un numero qualsiasi di caratteri Unicode, ed espongono metodi utili per manipolare e generare stringhe. Le stringhe sono conteggiate per riferimento e utilizzano un approccio copy-on-write (ogni modifica a una stringa restituisce una nuova **String**), quindi passarle in giro è economico in termini di risorse.
Alcuni metodi di stringa hanno variazioni corrispondenti. Le variazioni con suffisso ``n`` (:ref:`countn()<class_String_method_countn>`, :ref:`findn()<class_String_method_findn>`, :ref:`replacen()<class_String_method_replacen>`, ecc.) **non fanno distinzione** tra lettere maiuscole e minuscole. Le variazioni dei metodi con prefisso ``r`` (:ref:`rfind()<class_String_method_rfind>`, :ref:`rsplit()<class_String_method_rsplit>`, ecc.) sono invertite e iniziano dalla fine della stringa, anziché dall'inizio.
Per convertire qualsiasi :ref:`Variant<class_Variant>` in o da una stringa, vedi :ref:`@GlobalScope.str()<class_@GlobalScope_method_str>`, :ref:`@GlobalScope.str_to_var()<class_@GlobalScope_method_str_to_var>` e :ref:`@GlobalScope.var_to_str()<class_@GlobalScope_method_var_to_str>`.
\ **Nota:** In un contesto booleano, una stringa sarà valutata come ``false`` se è vuota (``""``). Altrimenti, una stringa sarà sempre valutata come ``true``.
.. note::
Ci sono differenze sostanziali quando si usa questa API con C#. Vedi :ref:`doc_c_sharp_differences` per maggiori informazioni.
.. rst-class:: classref-introduction-group
Tutorial
----------------
- :doc:`Formattazione di stringhe in GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`
.. rst-class:: classref-reftable-group
Costruttori
----------------------
.. 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
Metodi
------------
.. 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
Operatori
------------------
.. 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
Descrizioni dei costruttori
------------------------------------------------------
.. _class_String_constructor_String:
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ ) :ref:`🔗<class_String_constructor_String>`
Costruisce un **String** vuoto (``""``).
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`String<class_String>`\ )
Costruisce un **String** come copia del **String** specificato.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`NodePath<class_NodePath>`\ )
Costruisce una nuova **String** dal :ref:`NodePath<class_NodePath>` specificato.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`StringName<class_StringName>`\ )
Costruisce una nuova **String** dal :ref:`StringName<class_StringName>` specificato.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni dei metodi
--------------------------------------------
.. _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>`
Restituisce ``true`` se la stringa inizia con il testo ``text``. Vedi anche :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>`
Restituisce un array contenente i bigrammi (coppie di caratteri consecutivi) di questa stringa.
::
print("Vai su!".bigrams()) # Prints ["Va", "ai", "i ", " s", "su", "u!"]
.. 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>`
Converte la stringa che rappresenta un numero binario in un :ref:`int<class_int>`. La stringa può essere facoltativamente preceduta da ``"0b"`` e da un prefisso aggiuntivo ``-`` per i numeri negativi.
.. tabs::
.. code-tab:: gdscript
print("101".bin_to_int()) # Stampa 5
print("0b101".bin_to_int()) # Stampa 5
print("-0b10".bin_to_int()) # Stampa -2
.. code-tab:: csharp
GD.Print("101".BinToInt()); // Stampa 5
GD.Print("0b101".BinToInt()); // Stampa 5
GD.Print("-0b10".BinToInt()); // Stampa -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>`
Restituisce una copia della stringa con i caratteri speciali sottoposti a escape attraverso lo standard del linguaggio 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>`
Restituisce una copia della stringa con i caratteri di escape sostituiti dai loro significati. Le sequenze di escape supportate sono ``\'``, ``\"``, ``\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.
\ **Nota:** A differenza del parser di GDScript, questo metodo non supporta la sequenza di escape ``\uXXXX``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_capitalize:
.. rst-class:: classref-method
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_String_method_capitalize>`
Cambia l'aspetto della stringa: sostituisce i trattini bassi (``_``) con spazi, aggiunge spazi prima delle lettere maiuscole nel mezzo di una parola, converte tutte le lettere in minuscole, e infine converte la prima e ciascuna successiva a uno spazio in maiuscolo.
.. tabs::
.. code-tab:: gdscript
"move_local_x".capitalize() # Restituisce "Move Local X"
"sceneFile_path".capitalize() # Restituisce "Scene File Path"
"2D, FPS, PNG".capitalize() # Restituisce "2d, Fps, Png"
.. code-tab:: csharp
"move_local_x".Capitalize(); // Restituisce "Move Local X"
"sceneFile_path".Capitalize(); // Restituisce "Scene File Path"
"2D, FPS, PNG".Capitalize(); // Restituisce "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>`
Esegue un confronto con distinzione tra maiuscole e minuscole con un'altra stringa. Restituisce ``-1`` se minore di, ``1`` se maggiore di, o ``0`` se uguale. "Minore di" e "maggiore di" sono determinati dai `codici Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ di ogni stringa, che corrispondono approssimativamente all'ordine alfabetico.
Se il confronto tra caratteri raggiunge la fine di una stringa, ma l'altra stringa contiene più caratteri, utilizzerà la lunghezza come fattore decisivo: sarà restituito ``1`` se questa stringa è più lunga della stringa ``to``, oppure ``-1`` se è più corta. Si noti che la lunghezza delle stringhe vuote è sempre ``0``.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, utilizzare invece l'operatore ``==``. Vedi anche :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>` e :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>`
Restituisce un singolo carattere Unicode dall'intero ``code``. Puoi usare `unicodelookup.com <https://unicodelookup.com/>`__ o `unicode.org <https://www.unicode.org/charts/>`__ come punti di riferimento.
::
print(String.chr(65)) # Stampa "A"
print(String.chr(129302)) # Stampa "🤖" (emoji faccia di robot)
Vedi anche :ref:`unicode_at()<class_String_method_unicode_at>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` e :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>`
Restituisce ``true`` se la stringa contiene ``what``. In GDScript, questo corrisponde all'operatore ``in``.
.. tabs::
.. code-tab:: gdscript
print("Node".contains("de")) # Stampa true
print("team".contains("I")) # Stampa false
print("I" in "team") # Stampa false
.. code-tab:: csharp
GD.Print("Node".Contains("de")); // Stampa True
GD.Print("team".Contains("I")); // Stampa False
Se hai bisogno di sapere dove si trova ``what`` all'interno della stringa, usa :ref:`find()<class_String_method_find>`. Vedi anche :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>`
Restituisce ``true`` se la stringa contiene ``what``, **ignorando le maiuscole e le minuscole**.
Se hai bisogno di sapere dove si trova ``what`` all'interno della stringa, usa :ref:`findn()<class_String_method_findn>`. Vedi anche :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>`
Restituisce il numero di occorrenze della sottostringa ``what`` tra le posizioni ``from`` e ``to``. Se ``to`` è 0, la ricerca continua fino alla fine della stringa.
.. 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>`
Restituisce il numero di occorrenze della sottostringa ``what`` tra le posizioni ``from`` e ``to``, **ignorando le maiuscole e le minuscole**. Se ``to`` è 0, la ricerca continua fino alla fine della stringa.
.. rst-class:: classref-item-separator
----
.. _class_String_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_String_method_dedent>`
Restituisce una copia della stringa con l'indentazione (le tabulazioni iniziali e gli spazi) rimossa. Vedi anche :ref:`indent()<class_String_method_indent>` per aggiungere un'indentazione.
.. 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>`
Restituisce ``true`` se la stringa finisce con il testo ``text``. Vedi anche :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>`
Restituisce una stringa con ``chars`` caratteri cancellati a partire dalla posizione ``position``. Se ``chars`` supera la lunghezza della stringa con la posizione ``position``, verranno cancellati meno caratteri dalla stringa restituita. Restituisce una stringa vuota se ``position`` o ``chars`` è negativo. Restituisce la stringa originale non modificata se ``chars`` è ``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>`
Come :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` ma dà priorità alle stringhe che iniziano con punti (``.``) e caratteri di sottolineatura (``_``) prima di qualsiasi altro carattere. Utile quando si ordinano le cartelle o i nomi di file.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, usa invece l'operatore ``==``. Vedi anche :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` e :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>`
Come :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` ma dà priorità alle stringhe che iniziano con punti (``.``) e caratteri di sottolineatura (``_``) prima di qualsiasi altro carattere. Utile quando si ordinano le cartelle o i nomi di file.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, usa invece l'operatore ``==``. Vedi anche :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` e :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>`
Restituisce l'indice della **prima** occorrenza di ``what`` in questa stringa, o ``-1`` se non ce ne sono. L'inizio della ricerca può essere specificato con ``from``, continuando fino alla fine della stringa.
.. tabs::
.. code-tab:: gdscript
print("Team".find("I")) # Stampa -1
print("Potato".find("t")) # Stampa 2
print("Potato".find("t", 3)) # Stampa 4
print("Potato".find("t", 5)) # Stampa -1
.. code-tab:: csharp
GD.Print("Team".Find("I")); // Stampa -1
GD.Print("Potato".Find("t")); // Stampa 2
GD.Print("Potato".Find("t", 3)); // Stampa 4
GD.Print("Patata".Find("t", 5)); // Stampa -1
\ **Nota:** Se vuoi solo sapere se la stringa contiene ``what``, usa :ref:`contains()<class_String_method_contains>`. In GDScript, puoi anche usare l'operatore ``in``.
.. 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>`
Restituisce l'indice della **prima** occorrenza di ``what`` in questa stringa o ``-1`` se non ce ne sono, **senza distinzione tra maiuscole e minuscole**. L'indice di ricerca di partenza può essere specificato con ``from``, continuando fino alla fine della stringa.
.. 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>`
Formatta la stringa sostituendo tutte le occorrenze di ``placeholder`` con gli elementi di ``values``.
\ ``values`` può essere un :ref:`Dictionary<class_Dictionary>` o un :ref:`Array<class_Array>`. Qualsiasi trattino basso in ``placeholder`` verrà sostituito in anticipo con le chiavi corrispondenti. Gli elementi di array utilizzano il loro indice come chiavi.
::
# Stampa "Aspettando Godot è un'opera di Samuel Beckett, e il Godot Engine prende il nome da essa."
var use_array_values = "Aspettando {0} è un'opera di {1}, e {0} Engine prende il nome da essa."
print(use_array_values.format(["Godot", "Samuel Beckett"]))
# Stampa "Utente 42 è Godot."
print("Utente {id} è {nome}.".format({"id": 42, "nome": "Godot"}))
Vengono eseguite alcune operazioni aggiuntive quando ``values`` è un :ref:`Array<class_Array>`. Se ``placeholder`` non contiene un trattino basso, gli elementi dell'array ``values`` verranno utilizzati per sostituire un'occorrenza del segnaposto in ordine; se un elemento di ``values`` è un altro array di 2 elementi, verrà interpretato come una coppia chiave-valore.
::
# Stampa "Utente 42 is Godot."
print("Utente {} è {}.".format([42, "Godot"], "{}"))
print("Utente {id} è {nome}.".format([["id", 42], ["nome", "Godot"]]))
Quando si passa un :ref:`Object<class_Object>`, i nomi delle proprietà da :ref:`Object.get_property_list()<class_Object_method_get_property_list>` vengono utilizzati come chiavi.
::
# Stampa "Visibile true, posizione (0, 0)"
var nodo = Node2D.new()
print("Visibile {visible}, posizione {position}".format(nodo))
Consulta anche il tutorial :doc:`Stringa di formato GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`.
\ **Nota:** Ogni sostituzione viene eseguita in sequenza per ogni elemento di ``values``, **non** tutto in una volta. Ciò significa che se un elemento viene inserito e contiene un altro segnaposto, potrebbe essere modificato dalla sostituzione successiva. Sebbene ciò possa essere molto utile, spesso causa risultati inaspettati. Se non necessario, assicurati che gli elementi di ``values`` non contengano alcun segnaposto.
::
print("{0} {1}".format(["{1}", "x"])) # Stampa "x x"
print("{0} {1}".format(["x", "{0}"])) # Stampa "x {0}"
print("{foo} {bar}".format({"a": "{b}", "b": "c"})) # Stampa "c c"
print("{foo} {bar}".format({"b": "c", "a": "{b}"})) # Stampa "{b} c"
\ **Nota:** in C#, si consiglia di `interpolare le stringhe con "$" <https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/tokens/interpolated>`__.
.. 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>`
Se la stringa è un percorso di file valido, restituisce il nome della cartella di base.
::
var dir_path = "/path/to/file.txt".get_base_dir() # dir_path è "/path/to"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_String_method_get_basename>`
Se la stringa è un percorso di file valido, restituisce il percorso completo del file, senza l'estensione.
::
var base = "/path/to/file.txt".get_basename() # base is "/path/to/file"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_extension:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_String_method_get_extension>`
Se la stringa è un nome o un percorso di file valido, restituisce l'estensione del file senza il punto iniziale (``.``). Altrimenti, restituisce una stringa vuota.
::
var a = "/path/to/file.txt".get_extension() # a è "txt"
var b = "cool.txt".get_extension() # b è "txt"
var c = "cool.font.tres".get_extension() # c è "tres"
var d = ".pack1".get_extension() # d è "pack1"
var e = "file.txt.".get_extension() # e è ""
var f = "file.txt..".get_extension() # f è ""
var g = "txt".get_extension() # g è ""
var h = "".get_extension() # h è ""
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_file:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_String_method_get_file>`
Se la stringa è un percorso di file valido, restituisce il nome del file, inclusa l'estensione.
::
var file = "/path/to/icon.png".get_file() # file è "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>`
Divide la stringa tramite un ``delimiter`` e restituisce la sottostringa all'indice ``slice``. Restituisce la stringa originale se ``delimiter`` non esiste nella stringa. Restituisce una stringa vuota se la sezione all'indice ``slice`` non esiste.
Questo è più veloce di :ref:`split()<class_String_method_split>`, se hai bisogno di una sola sottostringa.
::
print("sono/un/esempio/ciao".get_slice("/", 2)) # Stampa "esempio"
.. 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>`
Restituisce il numero totale di sezioni quando la stringa viene divisa con il ``delimiter`` specificato (vedi :ref:`split()<class_String_method_split>`).
.. 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>`
Divide la stringa tramite un carattere Unicode con codice ``delimiter`` e restituisce la sottostringa all'indice ``slice``. Restituisce una stringa vuota se la sezione all'indice ``slice`` non esiste.
Questo è più veloce di :ref:`split()<class_String_method_split>`, se hai bisogno di una sola sottostringa.
.. rst-class:: classref-item-separator
----
.. _class_String_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_String_method_hash>`
Restituisce il valore di hash a 32 bit che rappresenta il contenuto della stringa.
\ **Nota:** Le stringhe con valori uguali di hash *non* sono garantite che siano identiche, a causa delle collisioni di hash. Al contrario, le stringhe con valori diversi di hash sono sicuramente diverse.
.. 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>`
Decodifica una stringa esadecimale come :ref:`PackedByteArray<class_PackedByteArray>`.
.. tabs::
.. code-tab:: gdscript
var text = "hello world"
var encoded = text.to_utf8_buffer().hex_encode() # produce "68656c6c6f20776f726c64"
print(encoded.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var text = "hello world";
var encoded = text.ToUtf8Buffer().HexEncode(); // produce "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>`
Converte la stringa che rappresenta un numero esadecimale in un :ref:`int<class_int>`. La stringa può essere facoltativamente preceduta dal prefisso ``"0x"`` e da un prefisso aggiuntivo ``-`` per i numeri negativi.
.. tabs::
.. code-tab:: gdscript
print("0xff".hex_to_int()) # Stampa 255
print("ab".hex_to_int()) # Stampa 171
.. code-tab:: csharp
GD.Print("0xff".HexToInt()); // Stampa 255
GD.Print("ab".HexToInt()); // Stampa 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>`
Converte ``size`` che rappresenta un numero di byte in un formato leggibile in chiaro.
Il risultato è in `formato per prefissi binari <https://it.wikipedia.org/wiki/Prefissi_per_multipli_binari>`__, che può terminare in ``"B"``, ``"KiB"``, ``"MiB"``, ``"GiB"``, ``"TiB"``, ``"PiB"`` o ``"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>`
Rientra ogni riga della stringa con il prefisso ``prefix`` specificato. Le righe vuote non sono rientrate. Vedi anche :ref:`dedent()<class_String_method_dedent>` per rimuovere l'indentazione.
Ad esempio, la stringa può essere rientrata con due tabulazioni usando ``"\t\t"``, o quattro spazi 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>`
Inserisce ``what`` nella posizione ``position`` nella stringa.
.. 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>`
Restituisce ``true`` se la stringa è un percorso verso un file o una cartella e il suo punto di partenza è definito esplicitamente. Questo metodo è l'opposto di :ref:`is_relative_path()<class_String_method_is_relative_path>`.
Ciò include tutti i percorsi che iniziano con ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"``, ecc.
.. 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>`
Restituisce ``true`` se la lunghezza della stringa è ``0`` (``""``). Vedi anche :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>`
Restituisce ``true`` se la stringa è un percorso e il suo punto di partenza dipende dal contesto. Il percorso potrebbe iniziare dalla cartella attuale o dal :ref:`Node<class_Node>` attuale (se la stringa è derivata da un :ref:`NodePath<class_NodePath>`) e può talvolta essere preceduto da ``"./"``. Questo metodo è l'opposto di :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>`
Restituisce ``true`` se è possibile trovare tutti i caratteri di questa stringa in ``text`` nel loro ordine originale. Questo non è lo stesso di :ref:`contains()<class_String_method_contains>`.
::
var text = "Wow, incredible!"
print("inedible".is_subsequence_of(text)) # Stampa true
print("Word!".is_subsequence_of(text)) # Stampa true
print("Window".is_subsequence_of(text)) # Stampa false
print("".is_subsequence_of(text)) # Stampa 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>`
Restituisce ``true`` se è possibile trovare tutti i caratteri di questa stringa in ``text`` nel loro ordine originale, **ignorando la distinzione tra le maiuscole e le minuscole**. Questo non è lo stesso di :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>`
Restituisce ``true`` se questa stringa è un identificatore ASCII valido. Un identificatore ASCII valido può contenere solo lettere, cifre e trattini bassi (``_``) e il primo carattere non può essere una cifra.
::
print("node_2d".is_valid_ascii_identifier()) # Stampa true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Stampa true
print("1st_method".is_valid_ascii_identifier()) # Stampa false
print("MyMethod#2".is_valid_ascii_identifier()) # Stampa false
Vedi anche :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>`
Restituisce ``true`` se questa stringa è un nome di file valido. Un nome di file valido non può essere vuoto, iniziare o finire con caratteri di spazio, o contenere caratteri non consentiti (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
.. 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>`
Restituisce ``true`` se questa stringa rappresenta un numero in virgola mobile valido. Un float valido può contenere solo cifre, un punto decimale (``.``) e la lettera esponente (``e``). Può anche essere preceduto da un segno positivo (``+``) o negativo (``-``). Qualsiasi intero valido è anche un float valido (vedi :ref:`is_valid_int()<class_String_method_is_valid_int>`). Vedi anche :ref:`to_float()<class_String_method_to_float>`.
::
print("1.7".is_valid_float()) # Stampa true
print("24".is_valid_float()) # Stampa true
print("7e3".is_valid_float()) # Stampa true
print("Hello".is_valid_float()) # Stampa 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>`
Restituisce ``true`` se questa stringa è un numero esadecimale valido. Un numero esadecimale valido contiene solo cifre o lettere da ``A`` a ``F`` (sia maiuscole sia minuscole) e può essere preceduto da un segno positivo (``+``) o negativo (``-``).
Se ``with_prefix`` è ``true``, il numero esadecimale deve essere preceduto da ``"0x"`` per essere considerato valido.
::
print("A08E".is_valid_hex_number()) # Stampa true
print("-AbCdEf".is_valid_hex_number()) # Stampa true
print("2.5".is_valid_hex_number()) # Stampa false
print("0xDEADC0DE".is_valid_hex_number(true)) # Stampa 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>`
Restituisce ``true`` se questa stringa è un colore valido in notazione HTML esadecimale. La stringa deve essere un valore esadecimale (vedi :ref:`is_valid_hex_number()<class_String_method_is_valid_hex_number>`) di 3, 4, 6 o 8 cifre e può essere preceduta da un cancelletto (``#``). Altre notazioni HTML per i colori, come nomi o ``hsl()``, non sono considerate valide. Vedi anche :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>`
**Deprecato:** Use :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>` instead.
Restituisce ``true`` se questa stringa è un identificatore valido. Un identificatore valido può contenere solo lettere, cifre e trattini bassi (``_``) e il primo carattere non può essere una cifra.
::
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>`
Restituisce ``true`` se questa stringa rappresenta un numero intero valido. Un numero intero valido contiene solo cifre e può essere preceduto da un segno positivo (``+``) o negativo (``-``). Vedi anche :ref:`to_int()<class_String_method_to_int>`.
::
print("7".is_valid_int()) # Stampa true
print("1.65".is_valid_int()) # Stampa false
print("Hi".is_valid_int()) # Stampa false
print("+3".is_valid_int()) # Stampa true
print("-12".is_valid_int()) # Stampa 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>`
Restituisce ``true`` se questa stringa rappresenta un indirizzo IPv4 o IPv6 ben formattato. Questo metodo considera validi gli `indirizzi IP riservati <https://en.wikipedia.org/wiki/Reserved_IP_addresses>`__ come ``"0.0.0.0"`` e ``"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"``.
.. 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>`
Restituisce ``true`` se questa stringa è un identificatore Unicode valido.
Un identificatore Unicode valido deve iniziare con un carattere Unicode di classe ``XID_Start`` o ``"_"`` e può contenere caratteri Unicode di classe ``XID_Continue`` nelle altre posizioni.
::
print("node_2d".is_valid_unicode_identifier()) # Stampa true
print("1st_method".is_valid_unicode_identifier()) # Stampa false
print("MyMethod#2".is_valid_unicode_identifier()) # Stampa false
print("állóképesség".is_valid_unicode_identifier()) # Stampa true
print("выносливость".is_valid_unicode_identifier()) # Stampa true
print("体力".is_valid_unicode_identifier()) # Stampa true
Vedi anche :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>`.
\ **Nota:** Questo metodo verifica gli identificatori allo stesso modo di GDScript. Vedi :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` per verifiche più avanzate.
.. 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>`
Restituisce la concatenazione degli elementi di ``parts``, con ogni elemento separato dalla stringa che chiama questo metodo. Questo metodo è l'opposto di :ref:`split()<class_String_method_split>`.
.. tabs::
.. code-tab:: gdscript
var frutta = ["Mela", "Arancia", "Pera", "Kiwi"]
print(", ".join(frutta)) # Stampa "Mela, Arancia, Pera, Kiwi"
print("---".join(frutta)) # Stampa "Mela---Arancia---Pera---Kiwi"
.. code-tab:: csharp
string[] frutta = ["Mela", "Orange", "Pear", "Kiwi"];
// In C#, questo metodo è statico.
GD.Print(string.Join(", ", frutta)); // Stampa "Mela, Arancia, Pera, Kiwi"
GD.Print(string.Join("---", frutta)); // Stampa "Mela---Arancia---Pera---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>`
Restituisce una copia della stringa con caratteri speciali sottoposti a escape attraverso lo standard JSON. Poiché corrisponde strettamente allo standard C, è possibile utilizzare :ref:`c_unescape()<class_String_method_c_unescape>` per annullare l'escape della stringa, se necessario.
.. 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>`
Restituisce i primi ``length`` caratteri dall'inizio della stringa. Se ``length`` è negativo, rimuove gli ultimi ``length`` caratteri dalla fine della stringa.
::
print("Hello World!".left(3)) # Stampa "Hel"
print("Hello World!".left(-4)) # Stampa "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>`
Restituisce il numero di caratteri nella stringa. Le stringhe vuote (``""``) restituiscono sempre ``0``. Vedi anche :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>`
Formatta la stringa in modo che sia lunga almeno ``min_length`` caratteri, aggiungendo più caratteri (``character``) a sinistra della stringa, se necessario. Vedi anche :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>`
Rimuove un insieme di caratteri definiti in ``chars`` dall'inizio della stringa. Vedi anche :ref:`rstrip()<class_String_method_rstrip>`.
\ **Nota:** ``chars`` non è un prefisso. Usa :ref:`trim_prefix()<class_String_method_trim_prefix>` per rimuovere un singolo prefisso, invece di insieme di caratteri.
.. 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>`
Esegue una corrispondenza di espressione semplice (chiamata anche "glob" o "globbing"), dove ``*`` corrisponde a zero o più caratteri arbitrari e ``?`` corrisponde a qualsiasi singolo carattere tranne un punto (``.``). Una stringa vuota o un'espressione vuota viene sempre valutata come ``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>`
Esegue una corrispondenza di espressione semplice (chiamata anche "glob" o "globbing") **senza distinzione tra le maiuscole e le minuscole**, dove ``*`` corrisponde a zero o più caratteri arbitrari e ``?`` corrisponde a qualsiasi singolo carattere tranne un punto (``.``). Una stringa vuota o un'espressione vuota viene sempre valutata come ``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>`
Restituisce l'`hash MD5 <https://it.wikipedia.org/wiki/MD5>`__ della stringa sotto forma di :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>`
Restituisce l'`hash MD5 <https://it.wikipedia.org/wiki/MD5>`__ della stringa sotto forma di un altra **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>`
Esegue un confronto **con distinzione** tra maiuscole e minuscole e in *ordine naturale* con un'altra stringa. Restituisce ``-1`` se minore di, ``1`` se maggiore di, o ``0`` se uguale. "Minore di" e "maggiore di" sono determinati dai `punti di codice Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ di ogni stringa, che corrispondono approssimativamente all'ordine alfabetico.
Quando viene utilizzato per l'ordinamento, il confronto con l'ordine naturale ordina sequenze di numeri in base al valore combinato di ciascuna cifra, come spesso previsto, anziché al valore della singola cifra. Una sequenza ordinata di stringhe numerate sarà ``["1", "2", "3", ...]``, non ``["1", "10", "2", "3", ...]``.
Se il confronto tra caratteri raggiunge la fine di una stringa, ma l'altra stringa contiene più caratteri, utilizzerà la lunghezza come fattore decisivo: sarà restituito ``1`` se questa stringa è più lunga della stringa ``to``, oppure ``-1`` se è più corta. Si noti che la lunghezza delle stringhe vuote è sempre ``0``.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, utilizzare invece l'operatore ``==``. Vedi anche :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>` e :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>`
Esegue un confronto **senza distinzione** tra maiuscole e minuscole e in *ordine naturale* con un'altra stringa. Restituisce ``-1`` se minore di, ``1`` se maggiore di, o ``0`` se uguale. "Minore di" e "maggiore di" sono determinati dai `punti di codice Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ di ogni stringa, che corrispondono approssimativamente all'ordine alfabetico.
Quando viene utilizzato per l'ordinamento, il confronto con l'ordine naturale ordina sequenze di numeri in base al valore combinato di ciascuna cifra, come spesso previsto, anziché al valore della singola cifra. Una sequenza ordinata di stringhe numerate sarà ``["1", "2", "3", ...]``, non ``["1", "10", "2", "3", ...]``.
Se il confronto tra caratteri raggiunge la fine di una stringa, ma l'altra stringa contiene più caratteri, utilizzerà la lunghezza come fattore decisivo: sarà restituito ``1`` se questa stringa è più lunga della stringa ``to``, oppure ``-1`` se è più corta. Si noti che la lunghezza delle stringhe vuote è sempre ``0``.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, utilizzare invece l'operatore ``==``. Vedi anche :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>` e :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>`
Esegue un confronto **senza distinzione tra maiuscole e minuscole** con un'altra stringa. Restituisce ``-1`` se minore di, ``1`` se maggiore di, o ``0`` se uguale. "Minore di" e "maggiore di" sono determinati dai `punti di codice Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__ di ogni stringa, che corrispondono approssimativamente all'ordine alfabetico.
Se il confronto tra caratteri raggiunge la fine di una stringa, ma l'altra stringa contiene più caratteri, utilizzerà la lunghezza come fattore decisivo: sarà restituito ``1`` se questa stringa è più lunga della stringa ``to``, oppure ``-1`` se è più corta. Si noti che la lunghezza delle stringhe vuote è sempre ``0``.
Per ottenere un risultato :ref:`bool<class_bool>` da un confronto di stringhe, utilizzare invece l'operatore ``==``. Vedi anche :ref:`casecmp_to()<class_String_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>` e :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>`
Converte un :ref:`float<class_float>` in una rappresentazione stringa di un numero decimale, con il numero di cifre decimali specificato in ``decimals``.
Se ``decimals`` è ``-1`` come predefinito, la rappresentazione di stringa può avere solo fino a 14 cifre significative, con le cifre prima del punto decimale che hanno la priorità sulle cifre dopo.
Gli zeri finali non sono inclusi nella stringa. L'ultima cifra viene arrotondata, non troncata.
::
String.num(3.141593) # Restituisce "3.141593"
String.num(3.141593, 3) # Restituisce "3.142"
String.num(3.14159300) # Restituisce "3.141593"
# Qui, l'ultima cifra verrà arrotondata per eccesso,
# il che riduce il conteggio totale delle cifre, poiché gli zeri finali vengono rimossi:
String.num(42.129999, 5) # Returns "42.13"
# Se `decimals` non è specificato, il numero massimo di cifre significative è 14:
String.num(-0.0000012345432123454321) # Restituisce "-0.00000123454321"
String.num(-10000.0000012345432123454321) # Restituisce "-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>`
Converte il numero ``number`` in una rappresentazione di stringa, con la ``base`` specificata.
Per impostazione predefinita, ``base`` è impostato su decimale (``10``). Altre basi comuni nella programmazione includono binario (``2``), `ottale <https://it.wikipedia.org/wiki/Sistema_numerico_ottale>`__ (``8``), esadecimale (``16``).
Se ``capitalize_hex`` è ``true``, le cifre superiori a 9 sono rappresentate in maiuscolo.
.. 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>`
Converte il numero ``number`` in una rappresentazione di stringa, in notazione scientifica.
.. tabs::
.. code-tab:: gdscript
var n = -5.2e8
print(n) # Stampa -520000000
print(String.num_scientific(n)) # Stampa -5.2e+08
.. code-tab:: csharp
// Questo metodo non è implementato in C#.
// Usa `string.ToString()` con "e" per ottenere risultati simili.
var n = -5.2e8f;
GD.Print(n); // Stampa -520000000
GD.Print(n.ToString("e1")); // Stampa -5.2e+008
\ **Nota:** In C#, questo metodo non è implementato. Per ottenere risultati simili, consulta le `Stringhe di formato numerico standard <https://learn.microsoft.com/en-us/dotnet/standard/base-types/standard-numeric-format-strings>`__ di C#.
.. 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>`
Converte il numero senza segno ``number`` in una rappresentazione di stringa, con la ``base`` specificata.
Per impostazione predefinita, ``base`` è impostato su decimale (``10``). Altre basi comuni nella programmazione includono binario (``2``), `ottale <https://it.wikipedia.org/wiki/Sistema_numerico_ottale>`__ (``8``), esadecimale (``16``).
Se ``capitalize_hex`` è ``true``, le cifre superiori a 9 sono rappresentate in maiuscolo.
.. 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>`
Formatta la stringa che rappresenta un numero in modo che abbia un numero esatto di cifre (``digits``) *dopo* il punto decimale.
.. 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>`
Formatta la stringa che rappresenta un numero in modo che abbia un numero esatto di cifre (``digits``) *prima* del punto decimale.
.. 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>`
Concatena ``path`` alla fine della stringa come sotto-percorso, aggiungendo ``/`` se necessario.
\ **Esempio:** ``"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>`
Rimuove tutte le occorrenze del carattere Unicode con il codice ``what``. Versione più veloce di :ref:`replace()<class_String_method_replace>` quando la chiave è lunga un solo carattere e la sostituzione è ``""``.
.. 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>`
Rimuove qualsiasi occorrenza dei caratteri in ``chars``. Vedi anche :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>`
Ripete questa stringa un certo numero di volte. ``count`` deve essere maggiore di ``0``. Altrimenti, restituisce una stringa vuota.
.. 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>`
Sostituisce tutte le occorrenze di ``what`` all'interno della stringa con il ``forwhat`` specificato.
.. 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>`
Sostituisce tutte le occorrenze del carattere Unicode con codice ``key`` con il carattere Unicode con codice ``with``. Versione più veloce di :ref:`replace()<class_String_method_replace>` quando la chiave è lunga un solo carattere. Per ottenere un singolo carattere, utilizzare ``"X".unicode_at(0)`` (si noti che alcune stringhe, come lettere composte ed emoji, possono essere composte da più codici Unicode e non funzioneranno con questo metodo; utilizzare :ref:`length()<class_String_method_length>` per esserne sicuri).
.. 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>`
Sostituisce qualsiasi occorrenza dei caratteri in ``keys`` con il carattere Unicode con codice ``with``. Vedi anche :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>`
Sostituisce tutte le occorrenze **senza distinzione tra maiuscole e minuscole** di ``what`` all'interno della stringa con il ``forwhat`` specificato.
.. rst-class:: classref-item-separator
----
.. _class_String_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_String_method_reverse>`
Restituisce la copia di questa stringa in ordine inverso. Questa operazione funziona su codici Unicode, piuttosto che su sequenze di codici, e potrebbe spezzare elementi come lettere composte o emoji.
.. 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>`
Restituisce l'indice dell'**ultima** occorrenza di ``what`` in questa stringa, o ``-1`` se non ce ne sono. L'inizio della ricerca può essere specificato con ``from``, continuando fino all'inizio della stringa. Questo metodo è l'inverso di :ref:`find()<class_String_method_find>`.
.. 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>`
Restituisce l'indice dell'**ultima** occorrenza di ``what`` in questa stringa o ``-1`` se non ce ne sono, **senza distinzione tra maiuscole e minuscole**. L'indice di ricerca di partenza può essere specificato con ``from``, continuando fino all'inizio della stringa. Questo metodo è l'inverso di :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>`
Restituisce gli ultimi ``length`` caratteri dalla fine della stringa. Se ``length`` è negativo, rimuove i primi ``length`` caratteri dall'inizio della stringa.
::
print("Hello World!".right(3)) # Stampa "ld!"
print("Hello World!".right(-4)) # Stampa "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>`
Formatta la stringa in modo che sia lunga almeno ``min_length`` caratteri, aggiungendo più caratteri (``character``) a destra della stringa, se necessario. Vedi anche :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>`
Divide la stringa tramite un ``delimiter`` e restituisce un array delle sottostringhe, a partire dalla fine della stringa. Le suddivisioni nell'array restituito appaiono nello stesso ordine della stringa originale. Se ``delimiter`` è una stringa vuota, ogni sottostringa sarà un singolo carattere.
Se ``allow_empty`` è ``false``, le stringhe vuote tra delimitatori adiacenti vengono escluse dall'array.
Se ``maxsplit`` è maggiore di ``0``, il numero di suddivisioni non può superare ``maxsplit``. Come predefinito, l'intera stringa viene suddivisa, il che è maggiormente identico a :ref:`split()<class_String_method_split>`.
.. tabs::
.. code-tab:: gdscript
var some_string = "Uno,Due,Tre,Quattro"
var some_array = some_string.rsplit(",", true, 1)
print(some_array.size()) # Stampa 2
print(some_array[0]) # Stampa "Uno,Due,Tre"
print(some_array[1]) # Stampa "Quattro"
.. code-tab:: csharp
// In C#, non esiste il metodo String.RSplit().
.. 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>`
Rimuove un insieme di caratteri definiti in ``chars`` dalla fine della stringa. Vedi anche :ref:`lstrip()<class_String_method_lstrip>`.
\ **Nota:** ``chars`` non è un suffisso. Usa :ref:`trim_suffix()<class_String_method_trim_suffix>` per rimuovere un singolo suffisso, invece di insieme di caratteri.
.. 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>`
Restituisce l'hash `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ della stringa sotto forma di :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>`
Restituisce l'hash `SHA-1 <https://en.wikipedia.org/wiki/SHA-1>`__ della stringa sotto forma di un altra **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>`
Restituisce l'hash `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ della stringa sotto forma di **String**.
.. 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>`
Restituisce l'hash `SHA-256 <https://en.wikipedia.org/wiki/SHA-2>`__ della stringa sotto forma di un altra **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>`
Restituisce l'indice di similarità (`indice di Sørensen-Dice <https://it.wikipedia.org/wiki/Indice_di_S%C3%B8rensen-Dice>`__) di questa stringa rispetto a un'altra. Un risultato di ``1.0`` significa totalmente simile, mentre ``0.0`` significa totalmente dissimile.
::
print("ABC123".similarity("ABC123")) # Stampa 1.0
print("ABC123".similarity("XYZ456")) # Stampa 0.0
print("ABC123".similarity("123ABC")) # Stampa 0.8
print("ABC123".similarity("abc123")) # Stampa 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>`
Se la stringa è un percorso di file valido, converte la stringa in un percorso canonico. Questo è il percorso più breve possibile, senza ``"./"`` e tutti gli ``"."`` e ``"/"`` non necessari.
::
var percorso_semplice = "./path/to///../file".simplify_path()
print(percorso_semplice ) # Stampa "path/file"
.. rst-class:: classref-item-separator
----
.. _class_String_method_split:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **split**\ (\ delimiter\: :ref:`String<class_String>` = "", allow_empty\: :ref:`bool<class_bool>` = true, maxsplit\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_split>`
Divide la stringa tramite un ``delimiter`` e restituisce un array delle sottostringhe. Se ``delimiter`` è una stringa vuota, ogni sottostringa sarà un singolo carattere. Questo metodo è l'opposto di :ref:`join()<class_String_method_join>`.
Se ``allow_empty`` è ``false``, le stringhe vuote tra delimitatori adiacenti vengono escluse dall'array.
Se ``maxsplit`` è maggiore di ``0``, il numero di suddivisioni non può superare ``maxsplit``. Come predefinito, l'intera stringa viene suddivisa.
.. tabs::
.. code-tab:: gdscript
var some_array = "Uno,Due,Tre,Quattro".split(",", true, 2)
print(some_array.size()) # Stampa 3
print(some_array[0]) # Stampa "Uno"
print(some_array[1]) # Stampa "Due"
print(some_array[2]) # Stampa "Tre,Quattro"
.. code-tab:: csharp
// La funzione `Split()` di C# non supporta il parametro `maxsplit`.
var someArray = "Uno,Due,Tre".Split(",");
GD.Print(someArray[0]); // Stampa "Uno"
GD.Print(someArray[1]); // Stampa "Due"
GD.Print(someArray[2]); // Stampa "Tre"
\ **Nota:** Se hai bisogno solo di una sottostringa dall'array, considera di usare :ref:`get_slice()<class_String_method_get_slice>` che è più veloce. Se hai bisogno di dividere stringhe con regole più complesse, usa invece la classe :ref:`RegEx<class_RegEx>`.
.. 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>`
Divide la stringa in più float tramite un ``delimiter`` e restituisce un :ref:`PackedFloat64Array<class_PackedFloat64Array>`.
Se ``allow_empty`` è ``false``, le conversioni :ref:`float<class_float>` vuote o non valide tra delimitatori adiacenti vengono escluse.
::
var a = "1,2,4.5".split_floats(",") # a è [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c è [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b è [1.0, 4.5]
.. rst-class:: classref-item-separator
----
.. _class_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>`
Rimuove tutti i caratteri non stampabili dall'inizio e alla fine della stringa. Questi includono spazi, tabulazioni (``\t``) e nuove righe (``\n`` ``\r``).
Se ``left`` è ``false``, ignora l'inizio della stringa. Allo stesso modo, se ``right`` è ``false``, ignora la fine della stringa.
.. 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>`
Rimuove tutti i caratteri di escape dalla stringa. Questi includono tutti i caratteri di controllo non stampabili della prima pagina della tabella ASCII (valori da 0 a 31), come i caratteri di tabulazione (``\t``) e di nuova riga (``\n``, ``\r``), ma *non* gli spazi.
.. 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>`
Restituisce parte della stringa dalla posizione ``from`` con lunghezza ``len``. Se ``len`` è ``-1`` (come per impostazione predefinita), restituisce il resto della stringa a partire dalla posizione specificata.
.. 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>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato in `ASCII <https://it.wikipedia.org/wiki/ASCII>`__/Latin-1. Questo metodo è leggermente più veloce di :ref:`to_utf8_buffer()<class_String_method_to_utf8_buffer>`, ma sostituisce tutti i caratteri non supportati con spazi. Questo è l'inverso di :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>`
Restituisce la stringa convertita in ``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>`
Converte la stringa che rappresenta un numero decimale in un :ref:`float<class_float>`. Questo metodo si ferma sul primo carattere non numerico, eccetto il primo punto decimale (``.``) e la lettera di esponente (``e``). Vedi anche :ref:`is_valid_float()<class_String_method_is_valid_float>`.
::
var a = "12.35".to_float() # a è 12.35
var b = "1.2.3".to_float() # b è 1.2
var c = "12xy3".to_float() # c è 12.0
var d = "1e3".to_float() # d è 1000.0
var e = "Hello!".to_float() # e è 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>`
Converte la stringa che rappresenta un numero intero in un :ref:`int<class_int>`. Questo metodo rimuove qualsiasi carattere non numerico e si ferma al primo punto decimale (``.``). Vedi anche :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>`
Restituisce la stringa convertita in ``kebab-case``.
\ **Nota:** I numeri seguiti da una *singola* lettera non vengono separati nella conversione per mantenere insieme alcune parole (come "2D").
.. tabs::
.. code-tab:: gdscript
"Node2D".to_kebab_case() # Restituisce "node-2d"
"2nd place".to_kebab_case() # Restituisce "2-nd-place"
"Texture3DAssetFolder".to_kebab_case() # Restituisce "texture-3d-asset-folder"
.. code-tab:: csharp
"Node2D".ToKebabCase(); // Restituisce "node-2d"
"2nd place".ToKebabCase(); // Restituisce "2-nd-place"
"Texture3DAssetFolder".ToKebabCase(); // Restituisce "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>`
Restituisce la stringa convertita in ``lowercase``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_multibyte_char_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_String_method_to_multibyte_char_buffer>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato con code page multibyte di sistema. Se la conversione fallisce, viene restituito un array vuoto.
I valori consentiti per ``encoding`` dipendono dal sistema. Se ``encoding`` è una stringa vuota, viene utilizzata la codifica predefinita del sistema.
- Per Windows, consultare i nomi .NET per i `Code Page Identifiers <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__.
- Per macOS e Linux/BSD, consultare la documentazione della libreria ``libiconv`` e ``iconv --list`` per un elenco delle codifiche supportate.
.. 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>`
Restituisce la stringa convertita in ``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>`
Restituisce la stringa convertita in ``snake_case``.
\ **Nota:** I numeri seguiti da una *singola* lettera non vengono separati nella conversione per mantenere insieme alcune parole (come "2D").
.. tabs::
.. code-tab:: gdscript
"Node2D".to_snake_case() # Restituisce "node_2d"
"2nd place".to_snake_case() # Restituisce "2_nd_place"
"Texture3DAssetFolder".to_snake_case() # Restituisce "texture_3d_asset_folder"
.. code-tab:: csharp
"Node2D".ToSnakeCase(); // Restituisce "node_2d"
"2nd place".ToSnakeCase(); // Restituisce "2_nd_place"
"Texture3DAssetFolder".ToSnakeCase(); // Restituisce "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>`
Restituisce la stringa convertita in ``UPPERCASE``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_utf8_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf8_buffer>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato in `UTF-8 <https://it.wikipedia.org/wiki/UTF-8>`__. Questo metodo è leggermente più lento di :ref:`to_ascii_buffer()<class_String_method_to_ascii_buffer>`, ma supporta tutti i caratteri UTF-8. Nella maggior parte dei casi, è preferibile usare questo metodo. Questo è l'inverso di :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>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato in `UTF-16 <https://it.wikipedia.org/wiki/UTF-16>`__. Questo è l'inverso di :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>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato in `UTF-32 <https://it.wikipedia.org/wiki/UTF-32>`__. Questo è l'inverso di :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>`
Converte la stringa in un :ref:`PackedByteArray<class_PackedByteArray>` codificato in `carattere largo <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 su Windows, UTF-32 su altre piattaforme). Questo è l'inverso di :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>`
Rimuove il prefisso ``prefix`` dall'inizio della stringa o restituisce la stringa invariata.
.. 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>`
Rimuove il suffisso ``suffix`` dalla fine della stringa o restituisce la stringa invariata.
.. 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>`
Restituisce il codice carattere alla posizione ``at``.
Vedi anche :ref:`chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>` e :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>`
Decodifica la stringa dal suo formato codificato in URL. Questo metodo è pensato per decodificare correttamente i parametri in un URL quando si riceve una richiesta HTTP. Vedi anche :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()) # Stampa "$DOCS_URL/?highlight=Godot Engine:docs"
.. code-tab:: csharp
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // Stampa "$DOCS_URL/?highlight=Godot Engine:docs"
\ **Nota:** Questo metodo decodifica ``+`` come spazio.
.. 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>`
Codifica la stringa in un formato compatibile con URL. Questo metodo è pensato per codificare correttamente i parametri in un URL quando si invia una richiesta HTTP. Vedi anche :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) # Stampa "$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); // Stampa "$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 il percorso di file dal suo formato codificato URL. A differenza di :ref:`uri_decode()<class_String_method_uri_decode>`, questo metodo lascia ``+`` invariati.
.. 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>`
Restituisce una copia della stringa in cui tutti i caratteri non consentiti in :ref:`is_valid_filename()<class_String_method_is_valid_filename>` vengono sostituiti con trattini bassi.
.. 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>`
Restituisce una copia della stringa con tutti i caratteri non consentiti in :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) sostituiti con trattini bassi.
.. 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>`
Restituisce una copia della stringa con caratteri speciali sottoposti a escape attraverso lo standard XML. Se ``escape_quotes`` è ``true``, anche i caratteri di virgolette singole (``'``) e virgolette doppie (``"``) vengono sottoposti a escape.
.. 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>`
Restituisce una copia della stringa con i caratteri di escape sostituiti dai rispettivi significati, seguendo lo standard XML.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descrizioni degli operatori
------------------------------------------------------
.. _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>`
Restituisce ``true`` se entrambe le stringhe non contengono la stessa sequenza di caratteri.
.. 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>`
Restituisce ``true`` se questa **String** non è equivalente allo :ref:`StringName<class_StringName>` fornito.
.. 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>`
Formatta la **String**, sostituendo i segnaposto con uno o più parametri. Per passare più parametri, ``right`` deve essere un :ref:`Array<class_Array>`.
::
print("Ho pescato %d pesci!" % 2) # Stampa "Ho pescato 2 pesci!"
var my_message = "In viaggio verso %s, a %2.2f km/h."
var location = "Deep Valley"
var speed = 40.3485
print(my_message % [location, speed]) # Stampa "In viaggio verso Deep Valley, a 40.35 km/h."
Per ulteriori informazioni, consulta il tutorial :doc:`Formattazione di stringhe in GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`.
\ **Nota:** in C#, questo operatore non è disponibile. Invece, consulta `come interpolare le stringhe con "$" <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>`
Accoda ``right`` alla fine di questa **String**, noto anche come concatenazione di stringhe.
.. 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>`
Accoda ``right`` alla fine di questa **String**, restituendo una **String**. Questo è noto anche come concatenazione di stringhe.
.. 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>`
Restituisce ``true`` se la **String** di sinistra precede ``right`` nell'`ordine Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, che corrisponde approssimativamente all'ordine alfabetico. Utile per l'ordinamento.
.. 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>`
Restituisce ``true`` se la **String** di sinistra precede ``right`` nell'`ordine Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, che corrisponde approssimativamente all'ordine alfabetico, oppure se entrambi sono uguali.
.. 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>`
Restituisce ``true`` se entrambe le stringhe contengono la stessa sequenza di caratteri.
.. 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>`
Restituisce ``true`` se questa **String** è equivalente allo :ref:`StringName<class_StringName>` fornito.
.. 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>`
Restituisce ``true`` se la **String** di sinistra viene dopo ``right`` nell'`ordine Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, che corrisponde approssimativamente all'ordine alfabetico. Utile per l'ordinamento.
.. 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>`
Restituisce ``true`` se la **String** di sinistra viene dopo ``right`` nell'`ordine Unicode <https://en.wikipedia.org/wiki/List_of_Unicode_characters>`__, che corrisponde approssimativamente all'ordine alfabetico, oppure se entrambi sono uguali.
.. 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>`
Restituisce una nuova **String** che contiene solo il carattere all'indice ``index``. Gli indici iniziano da ``0``. Se ``index`` è maggiore o uguale a ``0``, il carattere viene recuperato a partire dall'inizio della stringa. Se ``index`` è un valore negativo, viene recuperato a partire dalla fine. L'accesso a una stringa fuori dai limiti causerà un errore di esecuzione, mettendo in pausa l'esecuzione del progetto se eseguito dall'editor.
.. |virtual| replace:: :abbr:`virtual (Questo metodo dovrebbe solitamente essere sovrascritto dall'utente per aver un effetto.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Questo metodo non ha effetti collaterali. Non modifica alcuna variabile appartenente all'istanza.)`
.. |vararg| replace:: :abbr:`vararg (Questo metodo accetta qualsiasi numero di argomenti oltre a quelli descritti qui.)`
.. |constructor| replace:: :abbr:`constructor (Questo metodo è utilizzato per creare un tipo.)`
.. |static| replace:: :abbr:`static (Questo metodo non necessita di alcun'istanza per essere chiamato, quindi può essere chiamato direttamente usando il nome della classe.)`
.. |operator| replace:: :abbr:`operator (Questo metodo descrive un operatore valido da usare con questo tipo come operando di sinistra.)`
.. |bitfield| replace:: :abbr:`BitField (Questo valore è un intero composto da una maschera di bit dei seguenti flag.)`
.. |void| replace:: :abbr:`void (Nessun valore restituito.)`
Reference in New Issue View Git Blame Copy Permalink