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

2504 lines
147 KiB
ReStructuredText
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

:github_url: hide
.. _class_String:
String
======
Un type intégré pour les chaînes de caractères.
.. rst-class:: classref-introduction-group
Description
-----------
C’est le type Variant intégré de chaînes de caractères (et celui utilisé par GDScript). Les chaînes de caractères peuvent contenir n’importe quel nombre de caractères Unicode et exposer les méthodes utiles pour manipuler et générer des chaînes. Les chaînes de caractères sont comptées par référence et utilisent une approche de copie lors de l’écriture (toute modification à une chaîne renvoie une nouvelle **String**), donc les passer par référence à un coût faible en ressources.
Certaines méthodes de chaîne ont des variations correspondantes. ``n`` (:ref:`countn()<class_String_method_countn>`, :ref:`findn()<class_String_method_findn>`, :ref:`replacen()<class_String_method_replacen>`, etc.) sont ** insensibles à la casse** (ils ne font aucune distinction entre les lettres majuscules et minuscules). Les variations de méthode préfixées avec ``r`` (:ref:`rfind()<class_String_method_rfind>`, :ref:`rsplit()<class_String_method_rsplit>`, etc.) sont inversées et commencent à partir de la fin de la chaîne, au lieu du début.
Pour convertir tout :ref:`Variant<class_Variant>` en ou à partir d'une chaîne, voir :ref:`@GlobalScope.str()<class_@GlobalScope_method_str>`, :ref:`@GlobalScope.str_to_var()<class_@GlobalScope_method_str_to_var>`, et :ref:`@GlobalScope.var_to_str()<class_@GlobalScope_method_var_to_str>`.
\ **Note :** Dans un contexte booléen, une chaîne s’évaluera à ``false`` si elle est vide (``"``). Sinon, une chaîne s’évaluera toujours à ``true``.
.. note::
Il y a des différences notables dans l'utilisation de cette API en C#. Voir :ref:`doc_c_sharp_differences` pour plus d'informations.
.. rst-class:: classref-introduction-group
Tutoriels
------------------
- :doc:`Chaînes de format en GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`
.. rst-class:: classref-reftable-group
Constructeurs
--------------------------
.. table::
:widths: auto
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`String<class_String>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`NodePath<class_NodePath>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`String<class_String_constructor_String>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+--------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. 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
Opérateurs
--------------------
.. 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
Descriptions des constructeurs
------------------------------------------------------------
.. _class_String_constructor_String:
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ ) :ref:`🔗<class_String_constructor_String>`
Construit une chaîne **String** vide (``""``).
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`String<class_String>`\ )
Construit une nouvelle chaîne **String** comme copie d'une chaine **String** donnée.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`NodePath<class_NodePath>`\ )
Construit une nouvelle chaîne **String** à partir du :ref:`NodePath<class_NodePath>` donné.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`String<class_String>` **String**\ (\ from\: :ref:`StringName<class_StringName>`\ )
Construit une nouvelle chaîne **String** à partir du :ref:`StringName<class_StringName>` donné.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _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>`
Renvoie ``true`` si la chaîne de caractères commence par le texte ``text`` donné. Voir aussi :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>`
Renvoie un tableau contenant les « bigrams » (paires de lettres consécutives) de cette chaîne de caractères.
::
print("Lève toi !".bigrams()) # Affiche ["Lè", "èv" ,"ve", "e ", " t", "to", "oi", "i!"]
.. 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>`
Convertit la chaîne représentant un nombre binaire en une entier :ref:`int<class_int>`. La chaîne peut éventuellement être préfixée avec ``"0b"``, et un préfixe supplémentaire ``-`` pour les nombres négatifs.
.. tabs::
.. code-tab:: gdscript
print("101".bin_to_int()) # Affiche 5
print("0b101".bin_to_int()) # Affiche 5
print("-0b10".bin_to_int()) # Affiche -2
.. code-tab:: csharp
GD.Print("101".BinToInt()); // Affiche 5
GD.Print("0b101".BinToInt()); // Affiche 5
GD.Print("-0b10".BinToInt()); // Affiche -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>`
Renvoie une copie de la chaîne de caractères avec les caractères spéciaux échappés selon le standard du langage 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>`
Renvoie une copie de la chaîne avec les caractères d'échappement remplacés par leurs significations. Les caractères d'échappement supportés sont : ``\'``, ``\"``, ``\\``, ``\a``, ``\b``, ``\f``, ``\n``, ``\r``, ``\t``, ``\v``.
\ **Note :** Contrairement au parseur GDScript, cette méthode ne supporte pas la séquence d'échappement de caractères Unicode ``\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>`
Change l'apparence de la chaîne de caractères : remplace les tirets bas (``_``) par des espaces, ajoute des espaces avant les lettres majuscules au milieu d'un mot, convertit toutes les lettres en minuscule, puis convertit la première lettre et chacune après un espace en majuscules.
.. tabs::
.. code-tab:: gdscript
"move_local_x".capitalize() # Renvoie "Move Local X"
"sceneFile_path".capitalize() # Renvoie "Scene File Path"
"2D, FPS, PNG".capitalize() # Renvoie "2d, Fps, Png"
.. code-tab:: csharp
"move_local_x".Capitalize(); // Renvoie "Move Local X"
"sceneFile_path".Capitalize(); // Renvoie "Scene File Path"
"2D, FPS, PNG".Capitalize(); // Renvoie "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>`
Effectue une comparaison sensible à la casse avec une autre chaîne. Renvoie ``-1`` si elle est inférieure, ``1`` si elle est plus supérieure, ou ``0`` si elles sont égales. "Inférieur à" et "supérieur à" sont déterminés par `points de code Unicode <https://fr.m.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique.
Si la comparaison des caractères atteint la fin d'une chaîne, mais que l'autre chaîne contient plus de caractères, elle utilisera alors la longueur comme facteur déterminant : ``1`` sera renvoyé si cette chaîne est plus longue que la chaîne ``to``, ou ``-1`` si elle est plus courte. Notez que la longueur des chaînes vides est toujours de ``0``.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d'une comparaison de chaînes, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, et :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>`
Renvoie un seul caractère Unicode depuis l'entier ``code``. Vous pouvez utiliser `unicodelookup.com <https://unicodelookup.com/>`__ ou `unicode.org <https://www.unicode.org/charts/>`__ comme points de référence.
::
print(String.chr(65)) # Affiche "A"
print(String.chr(129302) # Affiche "🤖" (emoji tête de robot)
Voir aussi :ref:`unicode_at()<class_String_method_unicode_at>`, :ref:`@GDScript.char()<class_@GDScript_method_char>`, et :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>`
Renvoie ``true`` si la chaîne contient la chaîne ``what``. En GDScript, cela correspond à l'opérateur ``in``.
.. tabs::
.. code-tab:: gdscript
print("Nœud".contains("No") # Affiche true
print("équipe".contains("je") # Affiche false
print("je" dans "équipe") # Affiche false
.. code-tab:: csharp
GD.Print("Nœud".contains("No")); // Affiche True
GD.Print("équipe".contains("je")); // Affiche False
Si vous devez savoir où ``what`` se trouve dans la chaîne, utilisez :ref:`find()<class_String_method_find>`. Voir aussi :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>`
Renvoie ``true`` si la chaîne contient la chaîne ``what``, **ignorant la casse**.
Si vous devez savoir où ``what`` se trouve dans la chaîne, utilisez :ref:`findn()<class_String_method_findn>`. Voir aussi :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>`
Renvoie le nombre d’occurrences de la sous-chaîne ``what`` entre les positions ``from`` et ``to``. Si ``to`` vaut 0, la recherche continue jusque la fin de la chaîne.
.. 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>`
Renvoie le nombre d’occurrences de la sous-chaîne ``what`` entre les positions ``from`` et ``to``, **ignorant la casse**. Si ``to`` vaut 0, la recherche continue jusque la fin de la chaîne.
.. rst-class:: classref-item-separator
----
.. _class_String_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_String_method_dedent>`
Renvoie une copie de la chaîne de caractères avec l'indentation (les tabulations et les espaces) retirée. Voir aussi :ref:`indent()<class_String_method_indent>` pour ajouter une indentation.
.. rst-class:: classref-item-separator
----
.. _class_String_method_ends_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_ends_with>`
Renvoie ``true`` si la chaîne de caractères finit par la chaîne de caractères ``text`` donnée. Voir aussi :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>`
Renvoie une chaîne avec les ``chars`` premiers caractères effacés à partir d’une certaine ``position``. Si ``chars`` dépasse la longueur de la chaîne, compte tenu de la ``position`` spécifiée, moins de caractères seront effacés de la chaîne renvoyée. Renvoie une chaîne vide si ``position`` ou ``chars`` est négatif. Renvoie la chaîne originale non modifiée si ``chars`` est à ``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>`
Comme :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>` mais priorise les chaînes commençant par des points (``.``) et des tirets bas (``_``)) avant tout autre caractère. Utile lors du tri des dossiers ou des noms de fichiers.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d’une comparaison de chaîne, utilisez plutôt l’opérateur ``=``. Voir aussi :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, et :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>`
Comme :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>` mais priorise les chaînes commençant par des points (``.``) et des tirets bas (``_``)) avant tout autre caractère. Utile lors du tri des dossiers ou des noms de fichiers.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d’une comparaison de chaîne, utilisez plutôt l’opérateur ``=``. Voir aussi :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, et :ref:`nocasecmp_to()<class_String_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_find:
.. rst-class:: classref-method
:ref:`int<class_int>` **find**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_find>`
Returns the index of the **first** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the end of the string.
.. tabs::
.. code-tab:: gdscript
print("Team".find("I")) # Prints -1
print("Potato".find("t")) # Prints 2
print("Potato".find("t", 3)) # Prints 4
print("Potato".find("t", 5)) # Prints -1
.. code-tab:: csharp
GD.Print("Team".Find("I")); // Prints -1
GD.Print("Potato".Find("t")); // Prints 2
GD.Print("Potato".Find("t", 3)); // Prints 4
GD.Print("Potato".Find("t", 5)); // Prints -1
\ **Note:** If you just want to know whether the string contains ``what``, use :ref:`contains()<class_String_method_contains>`. In GDScript, you may also use the ``in`` operator.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_findn:
.. rst-class:: classref-method
:ref:`int<class_int>` **findn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| :ref:`🔗<class_String_method_findn>`
Renvoie l’index de la **première** occurrence **insensible à la casse** de ``what`` dans cette chaîne, ou ``-1`` s’il n’y en a pas. L’index de recherche de départ peut être spécifié avec ``from``, continuant jusqu’à la fin de la chaîne.
.. 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>`
Formate la chaîne en remplaçant toutes les occurrences de ``placeholder`` par les éléments de ``values``.
\ ``values`` peut être un :ref:`Dictionary<class_Dictionary>`, un :ref:`Array<class_Array>` ou un :ref:`Object<class_Object>`. Tout tiret-bas dans ``placeholder`` sera remplacé par les clés correspondantes à l'avance. Les éléments d'un tableau utilisent leur index comme clés.
::
# Affiche "En attendant Godot est une pièce de Samuel Beckett, et Godot Engine est nommé d'après elle."
var utiliser_valeurs_tableau = "En attendant {0} est une pièce de {1}, et {0} Engine est nommé d'après elle."
print(utiliser_valeurs_tableau.format(["Godot", "Samuel Beckett"]))
# Affiche "L'utilisateur 42 est Godot."
print("L'utilisateur {id} est {nom}.".format({"id": 42, "nom": "Godot"}))
Des manipulations supplémentaires sont effectués lorsque ``values`` est un :ref:`Array<class_Array>`. Si ``placeholder`` ne contient pas de tiret-bas, les éléments du tableau ``values`` seront utilisés pour remplacer une occurrence du placeholder dans l'ordre, si un élément de ``values`` est un autre tableau de 2 éléments, il sera interprété comme une paire de valeurs-clés.
::
# Affiche "L'utilisateur 42 est Godot."
print("L'utilisateur {} est {}.".format([42, "Godot"], "{}"))
print("L'utilisateur {id} est {nom}.".format([["id", 42], ["nom", "Godot"]))
Lorsque vous passez un :ref:`Object<class_Object>`, les noms de propriétés de :ref:`Object.get_property_list()<class_Object_method_get_property_list>` sont utilisés comme clés.
::
# Affiche "Visible true, position (0, 0)"
var noeud = Node2D.new()
print("Visible {visible}, position {position}".format(noeud))
Voir aussi le tutoriel :doc:`chaîne de format GDScript <../tutoriels/scripting/gdscript/gdscript_format_string>`.
\ **Note :** Chaque remplacement est effectué séquentiellement pour chaque élément de ``values``, **pas** tous à la fois. Cela signifie que si un élément est inséré et qu'il contient un autre placeholder, il peut être modifié par le prochain remplacement. Bien que cela puisse être très utile, cela provoque souvent des résultats inattendus. Si cela n'est pas nécessaire, assurez-vous que les éléments de ``values`` ne contiennent pas de placeholders.
::
print("{0} {1}".format(["{1}", "x"])) # Affiche "x x"
print("{0} {1}".format(["x", "{0}"])) # Affiche "x {0}"
print("{a} {b}".format({"a": "{b}", "b": "c"})) # Affiche "c c"
print("{a} {b}".format({"b": "c", "a": "{b}"})) # Affiche "{b} c"
\ **Note:** En C#, il est plutôt recommandé d'`interpoler les chaînes avec "$" <https://learn.microsoft.com/fr-fr/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>`
Si la chaîne est un chemin de fichier valide, renvoie le nom du répertoire de base.
::
var chemin_rep = "/chemin/vers/fichier.txt".get_base_dir() # chemin_rep vaut "/chemin/vers"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_String_method_get_basename>`
Si la chaîne est un chemin de fichier valide, renvoie le chemin de fichier complet, sans l'extension.
::
var base = "/chemin/vers/fichier.txt".get_basename() # la base est "/chemin/vers/fichier"
.. 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>`
Si la chaîne est un nom ou un chemin de fichier valide, renvoie l'extension de fichier sans le point du début (``.``). Sinon, renvoie une chaîne vide.
::
var a = "/chemin/vers/fichier.txt".get_extension() # a vaut "txt"
var b = "cool.txt".get_extension() # b vaut "txt"
var c = "cool.font.tres".get_extension() # c vaut "tres"
var d = ".pack1".get_extension() # d vaut "pack1"
var e = "file.txt.".get_extension() # e vaut ""
var f = "file.txt..".get_extension() # f vaut ""
var g = "txt".get_extension() # g vaut ""
var h = "".get_extension() # h vaut ""
.. 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>`
Si la chaîne est un chemin de fichier valide, renvoie le nom du fichier, avec l'extension.
::
var fichier = "/chemin/vers/icone.png".get_file() # chemin vaut "icone.png"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_slice:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slice**\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_get_slice>`
Splits the string using a ``delimiter`` and returns the substring at index ``slice``. Returns the original string if ``delimiter`` does not occur in the string. Returns an empty string if the ``slice`` does not exist.
This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.
::
print("i/am/example/hi".get_slice("/", 2)) # Prints "example"
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_slice_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_get_slice_count>`
Returns the total number of slices when the string is split with the given ``delimiter`` (see :ref:`split()<class_String_method_split>`).
Use :ref:`get_slice()<class_String_method_get_slice>` to extract a specific slice.
::
print("i/am/example/string".get_slice_count("/")) # Prints '4'.
print("i am example string".get_slice_count("/")) # Prints '1'.
.. rst-class:: classref-item-separator
----
.. _class_String_method_get_slicec:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_slicec**\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_get_slicec>`
Splits the string using a Unicode character with code ``delimiter`` and returns the substring at index ``slice``. Returns an empty string if the ``slice`` does not exist.
This is faster than :ref:`split()<class_String_method_split>`, if you only need one or two substrings.
This is a Unicode version of :ref:`get_slice()<class_String_method_get_slice>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_String_method_hash>`
Renvoie la valeur de hachage de 32 bits représentant le contenu de la chaîne.
\ **Note :** Des chaînes avec des valeurs de hachage identiques ne sont *pas* garanties d'être identiques, à cause des collisions de hachage. À l'inverse, les chaînes avec des valeurs de hachage différentes sont garanties d'être différentes.
.. 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>`
Décode une chaîne hexadécimale en un :ref:`PackedByteArray<class_PackedByteArray>`.
.. tabs::
.. code-tab:: gdscript
var texte = "bonjour le monde"
var encode = texte.to_utf8_buffer().hex_encode() # outputs "626f6e6a6f7572206c65206d6f6e6465"
print(encode.hex_decode().get_string_from_utf8())
.. code-tab:: csharp
var texte = "hello world";
var encode = texte.ToUtf8Buffer().HexEncode(); // outputs "626f6e6a6f7572206c65206d6f6e6465"
GD.Print(encode.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>`
Convertit la chaîne représentant un nombre hexadécimal en un entier :ref:`int<class_int>`. La chaîne peut éventuellement être préfixée avec ``"0x"``, et un préfixe supplémentaire ``-`` pour les nombres négatifs.
.. tabs::
.. code-tab:: gdscript
print("0xff".hex_to_int()) # Affiche 255
print("ab".hex_to_int()) # Affiche 171
.. code-tab:: csharp
GD.Print("0xff".HexToInt()); // Affiche 255
GD.Print("ab".HexToInt()); // Affiche 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>`
Convertit ``size`` qui représente un certain nombre d'octets en une forme facilement lisible.
Le résultat est au `format de préfixe CEI <https://fr.wikipedia.org/wiki/Pr%C3%A9fixe_binaire#Tableaux_des_pr%C3%A9fixes_binaires_et_d%C3%A9cimaux>`__, qui peut se terminer soit ``"B"``, ``"KiB"``, ``"MiB"``, ``"GiB"``, ``"TiB"``, ``"PiB"``, ou ``"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>`
Indente chaque ligne de la chaîne avec le préfixe ``prefix`` donné. Les lignes vides ne sont pas indentées. Voir aussi :ref:`dedent()<class_String_method_dedent>` pour supprimer l'indentation.
Par exemple, la chaîne peut être indentée avec deux tabulations en utilisant ``"\t\t"``, ou quatre espaces utilisant ``" "``.
.. 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>`
Insère la chaîne ``what`` à la position ``position`` donnée dans la chaîne.
.. 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>`
Renvoie ``true`` si la chaîne est un chemin vers un fichier ou un répertoire, et son point de départ est explicitement défini. Cette méthode est le contraire de :ref:`is_relative_path()<class_String_method_is_relative_path>`.
Cela inclut tous les chemins commençant par ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"``, etc.
.. rst-class:: classref-item-separator
----
.. _class_String_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_String_method_is_empty>`
Renvoie ``true`` si la longueur de la chaîne est de ``0`` (``""``). Voir aussi :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>`
Renvoie ``true`` si la chaîne est un chemin, et son point de départ est dépendant du contexte. Le chemin pourrait commencer du répertoire courant, ou le :ref:`Node<class_Node>` actuel (si la chaîne est dérivée d'un :ref:`NodePath<class_NodePath>`), et peut parfois être préfixée avec ``"./"``. Cette méthode est le contraire de :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>`
Renvoie ``true`` si tous les caractères de cette chaîne peuvent être trouvés dans le texte ``text`` dans leur ordre original. Ce n'est pas la même chose que :ref:`contains()<class_String_method_contains>`.
::
var texte = "Wow, incroyable!"
print("inroable".is_subsequence_of(texte)) # Affiche true
print("Woya!".is_subsequence_of(texte))) # Affiche true
print("Window".is_subsequence_of(texte))) # Affiche false
print("".is_subsequence_of(text)) # Affiche 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>`
Renvoie ``true`` si tous les caractères de cette chaîne peuvent être trouvés dans le texte ``text`` dans leur ordre original, **ignorant la casse**. Ce n'est pas la même chose que :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>`
Renvoie ``true`` si cette chaîne est un identifiant ASCII valide. Un identifiant ASCII valide ne peut contenir que des lettres, des chiffres et des tirets bas (``_``) et le premier caractère ne peut pas être un chiffre.
::
print("node_2d".is_valid_ascii_identifier()) # Affiche true
print("TYPE_FLOAT".is_valid_ascii_identifier()) # Affiche true
print("1st_method".is_valid_ascii_identifier()) # Affiche false
print("MyMethod#2".is_valid_ascii_identifier()) # Affiche false
Voir aussi :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>`
Renvoie ``true`` si cette chaîne est un nom de fichier valide. Un nom de fichier valide ne peut pas être vide, commencer ou finir avec des espaces, ou contenir des caractères qui ne sont pas autorisés (``:`` ``/`` ``\`` ``?`` ``*`` ``"`` ``|`` ``%`` ``<`` ``>``).
.. 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>`
Renvoie ``true`` si cette chaîne représente un nombre à virgule flottante valide. Un flottant valide ne peut contenir que des chiffres, un point décimal (``.``), et la lettre d'exposant (``e``). Il peut également être préfixé avec un signe positif (``+``) ou négatif (``-``). Tout entier valide est également un flottant valide (voir :ref:`is_valid_int()<class_String_method_is_valid_int>`). Voir aussi :ref:`to_float()<class_String_method_to_float>`.
::
print("1.7".is_valid_float()) # Affiche true
print("24".is_valid_float()) # Affiche true
print("7e3".is_valid_float()) # Affiche true
print("Hello".is_valid_float()) # Affiche 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>`
Renvoie ``true`` si cette chaîne est un nombre hexadécimal valide. Un nombre hexadécimal valide ne contient que des chiffres ou des lettres de ``A`` à ``F`` (en majuscule ou minuscule), et peut être préfixé avec un signe positif (``+``) ou négatif (``-``).
Si ``with_prefix`` vaut ``true``, le nombre hexadécimal doit être préfixé par ``"0x"`` pour être considéré valide.
::
print("A08E".is_valid_hex_number()) # Affiche true
print("-AbCdEf".is_valid_hex_number()) # Affiche true
print("2.5".is_valid_hex_number()) # Affiche false
print("0xDEADC0DE".is_valid_hex_number(true)) # Affiche 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>`
Renvoie ``true`` si cette chaîne est une couleur valide dans la notation HTML hexadécimale. La chaîne doit être une valeur hexadécimale (voir :ref:`is_valid_hex_number()<class_String_method_is_valid_hex_number>`) de 3, 4, 6 ou 8 chiffres, et peut être préfixée par un signe de croisillon (``#``). D'autres notations HTML pour les couleurs, telles que les noms ou ``hsl()``, ne sont pas considérées valides. Voir aussi :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>`
**Obsolète :** Use :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>` instead.
Renvoie ``true`` si cette chaîne est un identifiant valide. Un identifiant valide ne peut contenir que des lettres, des chiffres et des tirets du bas (``_``), et le premier caractère ne peut pas être un chiffre.
::
print("node_2d".is_valid_identifier()) # Affiche true
print("TYPE_FLOAT".is_valid_identifier()) # Affiche true
print("1ere_methode".is_valid_identifier()) # Affiche false
print("MaMethode#2".is_valid_identifier()) # Affiche 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>`
Renvoie ``true`` si cette chaîne représente un entier valide. Un entier valide ne contient que des chiffres et peut être préfixé avec un signe positif (``+``) ou négatif (``-``). Voir aussi :ref:`to_int()<class_String_method_to_int>`.
::
print("7".is_valid_int()) # Affiche true
print("1.65".is_valid_int()) # Affiche false
print("Hello".is_valid_int()) # Affiche false
print("+3".is_valid_int()) # Affiche true
print("-12".is_valid_int()) # Affiche 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>`
Renvoie ``true`` si cette chaîne représente une adresse IPv4 ou IPv6 bien formatée. Cette méthode considère les `adresses IP réservées <https://en.wikipedia.org/wiki/Reserved_IP_addresses>`__ comme ``"0.0.0.0"`` et ``"ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"`` comme valides.
.. 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>`
Renvoie ``true`` si cette chaîne est un identifiant Unicode valide.
Un identifiant Unicode valide doit commencer par un caractère Unicode de la classe ``XID_Start`` ou ``"_"``, et peut contenir des caractères Unicode de la classe ``XID_Continue`` dans les autres positions.
::
print("node_2d".is_valid_unicode_identifier()) # Affiche true
print("1ere_methode".is_valid_unicode_identifier()) # Affiche false
print("MaMethode#2".is_valid_unicode_identifier()) # Affiche false
print("állóképesség".is_valid_unicode_identifier()) # Affiche true
print("выносливость".is_valid_unicode_identifier()) # Affiche true
print("体力".is_valid_unicode_identifier()) # Affiche true
Voir aussi :ref:`is_valid_ascii_identifier()<class_String_method_is_valid_ascii_identifier>`.
\ **Note :** Cette méthode vérifie les identifiants de la même manière en GDScript. Voir :ref:`TextServer.is_valid_identifier()<class_TextServer_method_is_valid_identifier>` pour des vérifications plus avancées.
.. 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>`
Renvoie la concaténation des éléments du tableau ``parts``, avec chaque élément séparé par la chaîne appelant cette méthode. Cette méthode est l'opposé de :ref:`split()<class_String_method_split>`.
.. tabs::
.. code-tab:: gdscript
var fruits = ["Pomme", "Orange", "Poire", "Kiwi"]
print(", ".join(fruits)) # Affiche "Pomme, Orange, Poire, Kiwi"
print("---".join(fruits)) # Affiche "Pomme---Orange---Poire---Kiwi"
.. code-tab:: csharp
string[] fruits = ["Pomme", "Orange", "Poire", "Kiwi"];
// En C#, cette méthode est statique.
GD.Print(string.Join(", ", fruits)); // Affiche "Pomme, Orange, Poire, Kiwi"
GD.Print(string.Join("---", fruits)); // Affiche "Pomme---Orange---Poire---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>`
Renvoie une copie de la chaîne avec les caractères spéciaux échappés en utilisant la norme JSON. Comme elle correspond fortement à la norme C, il est possible d'utiliser :ref:`c_unescape()<class_String_method_c_unescape>` pour échapper la chaîne, si nécessaire.
.. 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>`
Renvoie les ``length`` premiers caractères du début de la chaîne. Si ``length`` est négatif, retire les ``length`` derniers caractères de la fin de la chaîne.
::
print("Bonjour monde!".left(3)) # Affiche "Bon"
print("Bonjour monde!".left(-4)) # Affiche "Bonjour mo"
.. rst-class:: classref-item-separator
----
.. _class_String_method_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_String_method_length>`
Renvoie le nombre de caractères dans la chaîne. Les chaînes vides (``"``) renvoient toujours ``0``. Voir aussi :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>`
Formate la chaîne pour qu'elle ait au moins ``min_length`` caractères en ajoutant ``character`` caractères à gauche de la chaîne, si nécessaire. Voir aussi :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>`
Retire un ensemble de caractères définis dans ``chars`` du début de la chaîne. Voir aussi :ref:`rstrip()<class_String_method_rstrip>`.
\ **Note :** ``chars`` n'est pas un préfixe. Utilisez :ref:`trim_prefix()<class_String_method_trim_prefix>` pour supprimer un seul préfixe, plutôt qu'un ensemble de caractères.
.. 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>`
Fait une correspondance simple de l'expression (aussi appelé "glob" ou "globbing"), où ``*`` correspond à 0 ou plus caractères arbitraires, et ``?`` correspond à n'importe quel caractère unique sauf un point (``.``). Une chaîne ou expression vide est toujours évaluée à ``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>`
Fait une correspondance simple **sensible à la casse** de l'expression, où ``*`` correspond à 0 ou plus caractères arbitraires, et ``?`` correspond à n'importe quel caractère unique sauf un point (``.``). Une chaîne ou expression vide est toujours évaluée à ``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>`
Renvoie le `hachage MD5 <https://fr.wikipedia.org/wiki/MD5>`__ de la chaîne en tant que :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>`
Renvoie le `hachage MD5 <https://fr.wikipedia.org/wiki/MD5>`__ de la chaîne en tant qu'autre **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>`
Effectue une comparaison **sensible à la casse** *dans l'ordre naturel* avec une autre chaîne. Renvoie ``-1`` si elle est inférieure, ``1`` si elle est supérieure, ou ``0`` si elles sont égales. "Inférieur à" et "supérieur à" sont déterminés par `points de code Unicode <https://fr.m.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique.
Lorsqu'elle est utilisée pour le tri, la comparaison dans l'ordre naturel ordonne des séquences de nombres par la valeur combinée de chaque chiffre comme s'y attend souvent, au lieu de la valeur du chiffre seul. Une séquence triée de chaînes de numéros sera ``["1, "2", "3", ...]``, et pas ``["1", "10", "2", "3", ...]``.
Si la comparaison des caractères atteint la fin d'une chaîne, mais que l'autre chaîne contient plus de caractères, elle utilisera alors la longueur comme facteur déterminant : ``1`` sera renvoyé si cette chaîne est plus longue que la chaîne ``to``, ou ``-1`` si elle est plus courte. Notez que la longueur des chaînes vides est toujours de ``0``.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d'une comparaison de chaînes, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`naturalnocasecmp_to()<class_String_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_String_method_filecasecmp_to>`, et :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>`
Effectue une comparaison **insensible à la casse** *dans l'ordre naturel* avec une autre chaîne. Renvoie ``-1`` si elle est inférieure, ``1`` si elle est supérieure, ou ``0`` si elles sont égales. "Inférieur à" et "supérieur à" sont déterminés par `points de code Unicode <https://fr.m.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique. En interne, les caractères minuscules sont convertis en majuscules pour la comparaison.
Lorsqu'elle est utilisée pour le tri, la comparaison dans l'ordre naturel ordonne des séquences de nombres par la valeur combinée de chaque chiffre comme s'y attend souvent, au lieu de la valeur du chiffre seul. Une séquence triée de chaînes de numéros sera ``["1, "2", "3", ...]``, et pas ``["1", "10", "2", "3", ...]``.
Si la comparaison des caractères atteint la fin d'une chaîne, mais que l'autre chaîne contient plus de caractères, elle utilisera alors la longueur comme facteur déterminant : ``1`` sera renvoyé si cette chaîne est plus longue que la chaîne ``to``, ou ``-1`` si elle est plus courte. Notez que la longueur des chaînes vides est toujours de ``0``.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d'une comparaison de chaînes, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`naturalcasecmp_to()<class_String_method_naturalcasecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, et :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>`
Effectue une comparaison **insensible à la casse** avec une autre chaîne. Renvoie ``-1`` si elle est inférieure, ``1`` si elle est supérieure, ou ``0`` si elles sont égales. "Inférieur à" et "supérieur à" sont déterminés par `points de code Unicode <https://fr.m.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique. En interne, les caractères minuscules sont convertis en majuscules pour la comparaison.
Si la comparaison des caractères atteint la fin d'une chaîne, mais que l'autre chaîne contient plus de caractères, elle utilisera alors la longueur comme facteur déterminant : ``1`` sera renvoyé si cette chaîne est plus longue que la chaîne ``to``, ou ``-1`` si elle est plus courte. Notez que la longueur des chaînes vides est toujours de ``0``.
Pour obtenir un résultat booléen :ref:`bool<class_bool>` d'une comparaison de chaînes, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`casecmp_to()<class_String_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_String_method_filenocasecmp_to>`, et :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>`
Convertit un :ref:`float<class_float>` en une représentation en chaîne d'un nombre décimal, avec le nombre de décimales spécifié dans ``decimals``.
Si ``decimals`` vaut ``-1`` comme par défaut, la représentation en chaîne peut avoir seulement jusqu'à 14 chiffres significatifs, avec les chiffres avant la virgule ayant priorité sur les chiffres après.
Les zéros de fin ne sont pas inclus dans la chaîne. Le dernier chiffre est arrondi, pas tronqué.
::
String.num(3.141593) # Renvoie "3.141593"
String.num(3.141593, 3) # Renvoie "3.142"
String.num(3.14159300) # Renvoie "3.141593"
# Ici, le dernier chiffre sera arrondi,
# ce qui réduit le nombre total de chiffres, puisque les zéros de fin sont supprimés :
String.num(42.129999, 5) # Renvoie "42.13"
# Si `decimals` n est pas spécifié, le nombre maximal de chiffres significatifs est de 14 :
String.num(-0.0000012345432123454321) # Renvoie "-0.00000123454321"
String.num(-10000.0000012345432123454321) # Renvoie "-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>`
Convertit le nombre ``number`` donné en une représentation en chaîne, avec la ``base`` donnée.
Par défaut, ``base`` est définie en décimal (``10``). D'autres bases communes en programmation sont par exemple le binaire (``2``), l'`octal <https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal>`__ (``8``), et l'hexadécimal (``16``).
Si ``capitalize_hex`` vaut ``true``, les chiffres supérieurs à 9 sont représentés en majuscules.
.. 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>`
Convertit le nombre ``number`` donné en une représentation en chaîne, en notation scientifique.
.. tabs::
.. code-tab:: gdscript
var n = -5.2e8
print(n) # Affiche -520000000
print(String.num_scientific(n)) # Affiche -5.2e+08
.. code-tab:: csharp
// Cette méthode n'est pas implémentée en C#.
// Utilisez `string.ToString()` avec "e" pour obtenir un résultat similaire.
var n = -5.2e8f;
GD.Print(n); // Affiche -520000000
GD.Print(n.ToString("e1")); // Affiche -5.2e+008
\ **Note :** En C#, cette méthode n'est pas implémentée. Pour obtenir des résultats similaires, voir `Chaînes de format numérique standard <https://learn.microsoft.com/fr-fr/dotnet/standard/base-types/standard-numeric-format-strings>`__ du 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>`
Convertit le :ref:`int<class_int>` non signé donné en une représentation en chaîne, avec la ``base`` donnée.
Par défaut, ``base`` est définie en décimal (``10``). D'autres bases communes en programmation sont par exemple le binaire (``2``), l'`octal <https://fr.wikipedia.org/wiki/Syst%C3%A8me_octal>`__ (``8``), et l'hexadécimal (``16``).
Si ``capitalize_hex`` vaut ``true``, les chiffres supérieurs à 9 sont représentés en majuscules.
.. 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>`
Formate la chaîne représentant un nombre pour avoir exactement ``digits`` chiffres *après* la virgule.
.. 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>`
Formate la chaîne représentant un nombre pour avoir exactement ``digits`` chiffres *avant* la virgule.
.. 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>`
Concatène ``path`` à la fin de la chaîne comme sous-chemin, ajoutant ``/`` si nécessaire.
\ **Exemple :** ``"cest/le".path_join("chemin") == "cest/le/chemin"``.
.. 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>`
Retire toutes les occurrences du caractère Unicode avec le code ``what``. Version plus rapide de :ref:`replace()<class_String_method_replace>` lorsque la clé n'est longue que d'un caractère et que le remplacement est ``""``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_String_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_String_method_repeat>`
Répète cette chaîne un certain nombre de fois. ``count`` doit être supérieur à ``0``. Sinon, renvoie une chaîne vide.
.. 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>`
Remplace toutes les occurrences de la chaîne ``what`` dans la chaîne courante avec la chaîne ``forwhat`` donnée.
.. 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>`
Remplace toutes les occurrences du caractère Unicode avec le code ``key`` par le caractère Unicode avec le code ``with``. Version plus rapide de :ref:`replace()<class_String_method_replace>` lorsque la clé est composée seulement d'un caractère. Pour obtenir un seul caractère, utilisez ``"X".unicode_at(0)`` (notez que certaines chaînes, comme les lettres composés et les émojis, peuvent être composées de plusieurs codes unicode, et ne fonctionneront pas avec cette méthode, utilisez :ref:`length()<class_String_method_length>` pour vous en assurer).
.. 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>`
Remplace toute occurrence des caractères de la chaîne ``keys`` par le caractère Unicode avec le code ``with``. Voir aussi :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>`
Remplace toutes les occurrences **insensibles à la casse** de la chaîne ``what`` à l'intérieur de la chaîne par la chaîne ``forwhat`` donnée.
.. rst-class:: classref-item-separator
----
.. _class_String_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_String_method_reverse>`
Renvoie la copie de cette chaîne en ordre inverse. Cette opération fonctionne sur des points de code unicode, plutôt que sur des séquences de points de code, et peut casser des choses comme les lettres composées ou les emojis.
.. rst-class:: classref-item-separator
----
.. _class_String_method_rfind:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfind**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_String_method_rfind>`
Returns the index of the **last** occurrence of ``what`` in this string, or ``-1`` if there are none. The search's start can be specified with ``from``, continuing to the beginning of the string. This method is the reverse of :ref:`find()<class_String_method_find>`.
\ **Note:** A negative value of ``from`` is converted to a starting index by counting back from the last possible index with enough space to find ``what``.
\ **Note:** A value of ``from`` that is greater than the last possible index with enough space to find ``what`` is considered out-of-bounds, and returns ``-1``.
.. rst-class:: classref-item-separator
----
.. _class_String_method_rfindn:
.. rst-class:: classref-method
:ref:`int<class_int>` **rfindn**\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| :ref:`🔗<class_String_method_rfindn>`
Renvoie l'index de la **dernière** occurrence **sensible à la casse** de la chaîne ``what`` dans cette chaîne, ou ``-1`` s'il n'y en a pas. Le début de la recherche peut être spécifié avec ``from``, continuant vers le début de la chaîne. Cette méthode est l'inverse de :ref:`find()<class_String_method_find>`.
.. 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>`
Renvoie les ``length`` derniers caractères depuis la fin de la chaîne. Si ``length`` est négatif, retire les ``length`` premiers caractères depuis le début de la chaîne.
::
print("Bonjour monde!".right(3)) # Prints "de!"
print("Bonjour monde!".right(-4)) # Prints "our monde!"
.. 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>`
Formate la chaîne pour être longue d'au moins ``min_length`` caractères, en ajoutant ``character`` caractères à la droite de la chaîne, si nécessaire. Voir aussi :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>`
Divise une chaîne de caractères en utilisant une chaîne de délimitation ``delimiter`` et renvoie un tableau avec ces sous-chaînes, en partant de la fin de la chaîne. Les divisions renvoyés dans le tableau sont dans le même ordre que la chaîne de caractères originale. Si ``delimiter`` est une chaîne vide, chaque sous-chaîne sera composée d'un seul caractère.
Si ``allow_empty`` vaut ``false``, les chaînes vides entre des délimiteurs adjacents sont exclues du tableau.
Si ``maxsplit`` est supérieur à ``0``, le nombre de divisions ne peut excéder ``maxsplit``. Par défaut, la chaîne entière est divisée, ce qui est globalement identique à :ref:`split()<class_String_method_split>`.
.. tabs::
.. code-tab:: gdscript
var une_chaine = "Un,Deux,Trois,Quatre"
var un_tableau = une_chaine.rsplit(",", true, 1)
print(un_tableau.size()) # Affiche 2
print(un_tableau[0]) # Affiche "Un,Deux,Trois"
print(un_tableau[1]) # Affiche "Quatre"
.. code-tab:: csharp
// En C#, il n'y a pas de méthode 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>`
Retire un ensemble de caractères définis dans ``chars`` depuis la fin de la chaîne. Voir aussi :ref:`rstrip()<class_String_method_rstrip>`.
\ **Note :** ``chars`` n'est pas un suffixe. Utilisez :ref:`trim_suffix()<class_String_method_trim_suffix>` pour supprimer un seul suffixe, plutôt qu'un ensemble de caractères.
.. 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>`
Renvoie le hachage `SHA-1 <https://fr.wikipedia.org/wiki/SHA-1>`__ de la chaîne en tant que :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>`
Renvoie le hachage `SHA-1 <https://fr.wikipedia.org/wiki/SHA-1>`__ de la chaîne en tant qu'autre **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>`
Renvoie le hash `SHA-256 <https://fr.wikipedia.org/wiki/SHA-2>`__ de la chaîne de caractères en :ref:`PackedByteArray<class_PackedByteArray>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_sha256_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_String_method_sha256_text>`
Renvoie le hash `SHA-256 <https://fr.wikipedia.org/wiki/SHA-2>`__ de la chaîne de caractères en **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>`
Renvoie l'indice de similarité (`Indice de Sørensen-Dice <https://fr.wikipedia.org/wiki/Indice_de_S%C3%B8rensen-Dice>`__) de cette chaîne de caractères par rapport à une autre. Un résultat de ``1.0`` signifie qu'elles sont identiques, alors que ``0.0`` signifie qu'elles sont complètement différentes.
::
print("ABC123".similarity("ABC123")) # Affiche 1.0
print("ABC123".similarity("XYZ456")) # Affiche 0.0
print("ABC123".similarity("123ABC")) # Affiche 0.8
print("ABC123".similarity("abc123")) # Affiche 0.4
.. rst-class:: classref-item-separator
----
.. _class_String_method_simplify_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_String_method_simplify_path>`
Si la chaîne est un chemin de fichier valide, convertit la chaîne en un chemin canonique. C'est le chemin le plus court possible, sans ``"./"``, et tous les ``".."`` et ``"/"`` inutiles.
::
var chemin_simple = "./chemin/vers///./fichier".simplify_path()
print(chemin_simple) # Affiche "chemin/fichier"
.. 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>`
Divise la chaîne en utilisant un délimiteur ``delimiter`` et renvoie un tableau des sous-chaînes. Si ``delimiter`` est une chaîne vide, chaque sous-chaîne sera un unique caractère. Cette méthode est le contraire de :ref:`join()<class_String_method_join>`.
Si ``allow_empty`` vaut ``false``, les chaînes vides entre les délimiteurs adjacents sont exclues du tableau.
Si ``maxsplit`` est supérieur à ``0``, le nombre de divisions ne peut excéder ``maxsplit``. Par défaut, la chaîne entière est divisée.
.. tabs::
.. code-tab:: gdscript
var un_tableau = "Un,Deux,Trois,Quatre".split(",", true, 2)
print(un_tableau.size()) # Prints 3
print(un_tableau[0]) # Affiche "One"
print(un_tableau[1]) # Affiche "Deux"
print(un_tableau[2]) # Affiche "Trois,Quatre"
.. code-tab:: csharp
// `Split()`en C# ne supporte pas le paramètre `maxsplit`.
var unTableau = "Un,Deux,Trois".Split(",");
GD.Print(unTableau[0]); // Affiche "Un"
GD.Print(unTableau[1]); // Affiche "Deux"
GD.Print(unTableau[2]); // Affiche "Trois"
\ **Note :** Si vous n'avez besoin que d'une sous-chaîne du tableau, envisagez d'utiliser :ref:`get_slice()<class_String_method_get_slice>` qui est plus rapide. Si vous devez diviser les chaînes avec des règles plus complexes, utilisez plutôt 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>`
Divise la chaîne en flottants en utilisant un délimiteur ``delimiter`` et renvoie un :ref:`PackedFloat64Array<class_PackedFloat64Array>`.
Si ``allow_empty`` vaut ``false``, les conversions de :ref:`float<class_float>` vides ou invalides entre les délimiteurs adjacents sont exclues.
::
var a = "1,2,4.5".split_floats(",") # a vaut [1.0, 2.0, 4.5]
var c = "1| ||4.5".split_floats("|") # c vaut [1.0, 0.0, 0.0, 4.5]
var b = "1| ||4.5".split_floats("|", false) # b vaut [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>`
Retire tous les caractères non-imprimables du début et de la fin de la chaîne. Il s'agit d'espaces, de tabulations (``\t``), et de caractères de nouvelle ligne (``\n`` ``\r``).
Si ``left`` vaut ``false``, ignore le début de la chaîne. De même, si ``right`` vaut ``false``, ignore la fin de la chaîne.
.. 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>`
Retire tous les caractères d'échappement de la chaîne. Il s'agit de tous les caractères de contrôle non-imprimables de la première page de la table ASCII (valeurs de 0 à 31), tels que les tabulations (``\t``) et les caractères de nouvelle ligne (``\n``, ``\r``), mais *pas* les espaces.
.. 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>`
Renvoie la partie de la chaîne commençant à la position ``from`` avec la longueur ``len``. Si ``len`` vaut ``-1`` (comme par défaut), renvoie le reste de la chaîne depuis la position donnée.
.. 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>`
Convertit la chaîne en un :ref:`PackedByteArray<class_PackedByteArray>` encodé en `ASCII <https://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange>`__/Latin-1. Cette méthode est légèrement plus rapide que :ref:`to_utf8_buffer()<class_String_method_to_utf8_buffer>`, mais remplace tous les caractères non supportés par des espaces. C'est l'inverse de :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>`
Renvoie la chaîne de caractères convertie en ``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>`
Convertit une chaîne représentant un nombre décimal en un :ref:`float<class_float>`. La méthode s'arrêtera sur le premier caractère qui n'est pas un chiffre, sauf le premier ``.`` (point décimal), et lettre d'exposant ``e``. Voir aussi :ref:`is_valid_float()<class_String_method_is_valid_float>`.
::
var a = "12.35".to_float() # a vaut 12.35
var b = "1.2.3".to_float() # b vaut 1.2
var c = "12xy3".to_float() # c vaut 12.0
var d = "1e3".to_float() # d vaut 1000.0
var e = "Hello !".to_float() # e vaut 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>`
Convertit une chaîne représentant un nombre entier en un :ref:`int<class_int>`. La méthode supprimera tout caractère qui n'est pas un chiffre et s'arrêtera au premier ``.`` (point décimal). Voir aussi :ref:`is_valid_int()<class_String_method_is_valid_int>`.
::
var a = "123".to_int() # a vaut 123
var b = "x1y2z3".to_int() # b vaut 123
var c = "-1.2.3".to_int() # c vaut -1
var d = "Hello !".to_int() # d vaut 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>`
Renvoie la chaîne convertie en ``kebab-case``.
\ **Note :** Les nombres suivis d'une *seule* lettre ne sont pas séparés dans la conversion pour garder quelques mots (comme "2D") ensemble.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_kebab_case() # Renvoie "node-2d"
"2de place".to_kebab_case() # Renvoie "2-de-place"
"Texture3DAssetFolder".to_kebab_case() # Renvoie "texture-3d-asset-folder"
.. code-tab:: csharp
"Node2D".ToKebabCase(); // Renvoie "node-2d"
"2de place".ToKebabCase(); // Renvoie "2-de-place"
"Texture3DAssetFolder".ToKebabCase(); // Renvoie "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>`
Renvoie la chaîne de caractères convertie en ``lowercase`` (minuscules).
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_multibyte_char_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_multibyte_char_buffer**\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| :ref:`🔗<class_String_method_to_multibyte_char_buffer>`
Converts the string to system multibyte code page encoded :ref:`PackedByteArray<class_PackedByteArray>`. If conversion fails, empty array is returned.
The values permitted for ``encoding`` are system dependent. If ``encoding`` is empty string, system default encoding is used.
- For Windows, see `Code Page Identifiers <https://learn.microsoft.com/en-us/windows/win32/Intl/code-page-identifiers>`__ .NET names.
- For macOS and Linux/BSD, see ``libiconv`` library documentation and ``iconv --list`` for a list of supported encodings.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_pascal_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_String_method_to_pascal_case>`
Renvoie la chaîne de caractères convertie en ``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>`
Renvoie la chaîne convertie en ``snake_case``.
\ **Note :** Les nombres suivis d'une *seule* lettre ne sont pas séparés dans la conversion pour garder quelques mots (comme "2D") ensemble.
.. tabs::
.. code-tab:: gdscript
"Node2D".to_snake_case() # Renvoie "node_2d"
"2de place".to_snake_case() # Renvoie "2_de_place"
"Texture3DAssetFolder".to_snake_case() # Renvoie "texture_3d_asset_folder"
.. code-tab:: csharp
"Node2D".ToSnakeCase(); // Renvoie "node_2d"
"2de place".ToSnakeCase(); // Renvoie "2_de_place"
"Texture3DAssetFolder".ToSnakeCase(); // Renvoie "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>`
Renvoie la chaîne de caractères convertie en ``UPPERCASE`` (majuscules).
.. 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>`
Convertit la chaîne en un tableau :ref:`PackedByteArray<class_PackedByteArray>` encodé en `UTF-8 <https://fr.wikipedia.org/wiki/UTF-8>`__. Cette méthode est légèrement plus lente que :ref:`to_ascii_buffer()<class_String_method_to_ascii_buffer>`, mais prend en charge tous les caractères UTF-8. Pour la plupart des cas, préférez utiliser cette méthode. C'est l'inverse de :ref:`PackedByteArray.get_string_from_utf8()<class_PackedByteArray_method_get_string_from_utf8>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_utf16_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf16_buffer>`
Convertit la chaîne en un tableau :ref:`PackedByteArray<class_PackedByteArray>` encodé en `UTF-16 <https://fr.wikipedia.org/wiki/UTF-16>`__. C'est l'inverse de :ref:`PackedByteArray.get_string_from_utf16()<class_PackedByteArray_method_get_string_from_utf16>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_utf32_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_utf32_buffer>`
Convertit la chaîne en un tableau :ref:`PackedByteArray<class_PackedByteArray>` encodé en `UTF-32 <https://fr.wikipedia.org/wiki/UTF-32>`__. C'est l'inverse de :ref:`PackedByteArray.get_string_from_utf32()<class_PackedByteArray_method_get_string_from_utf32>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_to_wchar_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_String_method_to_wchar_buffer>`
Convertit la chaîne de caractères en un :ref:`PackedByteArray<class_PackedByteArray>` encodé en `caractères larges <https://en.wikipedia.org/wiki/Wide_character>`__ (``wchar_t``, UTF-16 sur Windows, UTF-32 sur les autres plates-formes). C'est l'inverse de :ref:`PackedByteArray.get_string_from_wchar()<class_PackedByteArray_method_get_string_from_wchar>`.
.. rst-class:: classref-item-separator
----
.. _class_String_method_trim_prefix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_String_method_trim_prefix>`
Supprime le préfixe ``prefix`` donné depuis le début de la chaîne, ou renvoie la chaîne inchangée.
.. 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>`
Supprime le suffixe ``suffix`` donné depuis la fin de la chaîne, ou renvoie la chaîne inchangée.
.. 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>`
Renvoie le code du caractère à la position ``at``.
Voir aussi :ref:`chr()<class_String_method_chr>`, :ref:`@GDScript.char()<class_@GDScript_method_char>`, et :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>`
Décode la chaîne depuis son format encodé d'URL. Cette méthode est destinée à décoder correctement les paramètres dans une URL lors de la réception d'une requête HTTP. Voir aussi :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()) # Affiche "$DOCS_URL/?highlight=Godot Engine:docs"
.. code-tab:: csharp
var url = "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
GD.Print(url.URIDecode()) // Affiche "$DOCS_URL/?highlight=Godot Engine:docs"
\ **Note :** Cette méthode décode ``+`` en un espace.
.. 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>`
Encode la chaîne en un format d'URL. Cette méthode est destinée à encoder correctement les paramètres dans une URL lors de l'envoi d'une requête HTTP. Voir aussi :ref:`uri_decode()<class_String_method_uri_decode>`.
.. tabs::
.. code-tab:: gdscript
var prefixe = "$DOCS_URL/?highlight="
var url = prefixe + "Godot Engine:docs".uri_encode()
print(url) # Affiche "$DOCS_URL/?highlight=Godot%20Engine%3%docs"
.. code-tab:: csharp
var prefixe = "$DOCS_URL/?highlight=";
var url = prefixe + "Godot Engine:docs".URIEncode();
GD.Print(url); // Affiche "$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>`
Décode le chemin de fichier depuis son format encodé d'URL. Contrairement à :ref:`uri_decode()<class_String_method_uri_decode>`, cette méthode laisse ``+`` tel quel.
.. 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>`
Renvoie une copie de la chaîne avec tous les caractères qui ne sont pas autorisés dans :ref:`is_valid_filename()<class_String_method_is_valid_filename>` remplacés par des tirets du bas.
.. 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>`
Renvoie une copie de la chaîne avec tous les caractères qui ne sont pas autorisés dans :ref:`Node.name<class_Node_property_name>` (``.`` ``:`` ``@`` ``/`` ``"`` ``%``) remplacés par des tirets du bas.
.. 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>`
Renvoie une copie de la chaîne avec les caractères spéciaux échappés en utilisant la norme XML. Si ``escape_quotes`` vaut ``true``, les caractères de guillemet simples (``'``) et doubles (``"``) sont également échappés.
.. 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>`
Renvoie une copie de la chaîne avec des caractères échappés remplacés par leurs significations selon la norme XML.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des opérateurs
------------------------------------------------------
.. _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>`
Renvoie ``true`` si les deux chaînes ne contiennent pas la même séquence de caractères.
.. 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>`
Renvoie ``true`` si ce **String** n'est pas équivalent au :ref:`StringName<class_StringName>` donné.
.. 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>`
Formate le **String**, en remplaçant les placeholders par un ou plusieurs paramètres. Pour passer plusieurs paramètres, ``right`` doit être un :ref:`Array<class_Array>`.
::
print("J'ai attrapé %d poissons !" % 2) # Affiche "J'ai attrapé 2 poissons !"
var my_message = "Voyage vers %s, à %2.2f km/h."
var location = "Vallée lointaine"
var speed = 40.3485
print(my_message % [location, speed]) # Affiche "Voyage vers Vallée lointaine, à 40.35 km/h."
Pour plus d'informations, consultez le tutoriel :doc:`Chaînes de format en GDScript <../tutorials/scripting/gdscript/gdscript_format_string>`.
\ **Note :** En C#, cet opérateur n'est pas disponible. À la place, voir `Comment interpoler des chaînes avec "$" <https://learn.microsoft.com/fr-fr/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>`
Ajoute ``right`` à la fin de cet **String**, également appelé concaténation de chaînes.
.. 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>`
Ajoute ``right`` à la fin de ce **String**, en renvoyant un **String**. Ceci est également appelé une concaténation de chaînes.
.. 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>`
Renvoie ``true`` si la **String** de gauche arrive avant ``right`` dans l'`ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__, qui correspond à peu près à l'ordre alphabétique. Utile pour le tri.
.. 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>`
Renvoie ``true`` si la **String** de gauche arrive avant ``right`` dans l'`ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__, qui correspond à peu près à l'ordre alphabétique, ou si les deux sont égales.
.. 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>`
Renvoie ``true`` si les deux chaînes contiennent la même séquence de caractères.
.. 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>`
Renvoie ``true`` si cette **String** est équivalente au :ref:`StringName<class_StringName>` donné.
.. 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>`
Renvoie ``true`` si la **String** de gauche arrive après ``right`` dans l'`ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__, qui correspond à peu près à l'ordre alphabétique. Utile pour le tri.
.. 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>`
Renvoie ``true`` si la **String** de gauche arrive après ``right`` dans l'`ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__, qui correspond à peu près à l'ordre alphabétique, ou si les deux sont égales.
.. 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>`
Renvoie une nouvelle **String** qui ne contient que le caractère à ``index``. Les indices commencent de ``0``. Si ``index`` est supérieur ou égal à ``0``, le caractère est récupéré à partir du début de la chaîne. Si ``index`` est une valeur négative, il est récupéré à partir de la fin. L'accès à une chaîne hors de ses limites causera une erreur d'exécution, mettant en pause l'exécution du projet s'il est exécuté depuis l'éditeur.
.. |virtual| replace:: :abbr:`virtual (Cette méthode doit typiquement être redéfinie par l'utilisateur pour avoir un effet.)`
.. |required| replace:: :abbr:`required (This method is required to be overridden when extending its base class.)`
.. |const| replace:: :abbr:`const (Cette méthode n'a pas d'effets de bord. Elle ne modifie aucune des variables membres de l'instance.)`
.. |vararg| replace:: :abbr:`vararg (Cette méthode accepte n'importe quel nombre d'arguments après ceux décris ici.)`
.. |constructor| replace:: :abbr:`constructor (Cette méthode est utilisée pour construire un type.)`
.. |static| replace:: :abbr:`static (Cette méthode n'a pas besoin d'instance pour être appelée, elle peut donc être directement appelée en utilisant le nom de la classe.)`
.. |operator| replace:: :abbr:`operator (Cette méthode décrit un opérateur valide à utiliser avec ce type en tant qu'opérande gauche.)`
.. |bitfield| replace:: :abbr:`BitField (Cette valeur est un nombre entier composé d'un masque de bits des options suivantes.)`
.. |void| replace:: :abbr:`void (Aucune valeur de retour.)`
Reference in New Issue View Git Blame Copy Permalink