godotengine/godot-docs-l10n
1
0
Fork 0
mirror of https://github.com/godotengine/godot-docs-l10n.git synced 2026-01-05 14:10:19 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
4.x
godot-docs-l10n/classes/fr/class_stringname.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

2317 lines
139 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_StringName:
StringName
==========
Un type intégré pour les chaînes uniques.
.. rst-class:: classref-introduction-group
Description
-----------
Les **StringName**\ s sont des chaînes immuables conçues pour une représentation générale des noms uniques (également appelé « string interning », litt. internement de chaîne). Deux **StringName**\ s avec la même valeur sont le même objet. La comparaison est extrêmement rapide par rapport aux :ref:`String<class_String>` habituelles.
Vous passerez généralement un :ref:`String<class_String>` à des méthodes qui s'attendent à un **StringName** et il sera automatiquement converti (souvent au moment de la compilation), mais dans de rares cas vous pouvez construire un **StringName** en avance avec le constructeur **StringName** ou, en GDScript, la syntaxe littérale ``)&"exemple"``. La construction manuelle d'un **StringName** vous permet de contrôler lorsque la conversion depuis :ref:`String<class_String>` se produit ou d'utiliser le littéral et d'empêcher les conversions entièrement.
Voir aussi :ref:`NodePath<class_NodePath>`, qui est un concept similaire spécifiquement conçu pour stocker des chemins d'arborescence de scène préparés.
Toutes les méthodes de :ref:`String<class_String>` sont également disponibles dans cette classe. Ils convertissent le **StringName** en une chaîne, et ils renvoient également une chaîne. Ceci est très inefficace et ne devrait être utilisé que si la chaîne est souhaitée.
\ **Note :** En C#, une conversion explicite à ``System.String`` est nécessaire pour utiliser les méthodes énumérées sur cette page. Utilisez la méthode ``ToString()`` pour cast une **StringName** en une chaîne, puis utilisez les méthodes équivalentes dans ``System.String`` ou ``StringExtensions``.
\ **Note :** Dans un contexte booléen, **StringName** évaluera à ``false`` si elle est vide (``StringName("")``). Sinon, un **StringName** é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-reftable-group
Constructeurs
--------------------------
.. table::
:widths: auto
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`StringName<class_StringName>`\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
| :ref:`StringName<class_StringName>` | :ref:`StringName<class_StringName_constructor_StringName>`\ (\ from\: :ref:`String<class_String>`\ ) |
+-------------------------------------+--------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Méthodes
----------------
.. table::
:widths: auto
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`begins_with<class_StringName_method_begins_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`bigrams<class_StringName_method_bigrams>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`bin_to_int<class_StringName_method_bin_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_escape<class_StringName_method_c_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`c_unescape<class_StringName_method_c_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`capitalize<class_StringName_method_capitalize>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`casecmp_to<class_StringName_method_casecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`contains<class_StringName_method_contains>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`containsn<class_StringName_method_containsn>`\ (\ what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`count<class_StringName_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_StringName_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_StringName_method_dedent>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`ends_with<class_StringName_method_ends_with>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`erase<class_StringName_method_erase>`\ (\ position\: :ref:`int<class_int>`, chars\: :ref:`int<class_int>` = 1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filecasecmp_to<class_StringName_method_filecasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`filenocasecmp_to<class_StringName_method_filenocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`find<class_StringName_method_find>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`findn<class_StringName_method_findn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = 0\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`format<class_StringName_method_format>`\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_base_dir<class_StringName_method_get_base_dir>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_basename<class_StringName_method_get_basename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_extension<class_StringName_method_get_extension>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_file<class_StringName_method_get_file>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slice<class_StringName_method_get_slice>`\ (\ delimiter\: :ref:`String<class_String>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`get_slice_count<class_StringName_method_get_slice_count>`\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`get_slicec<class_StringName_method_get_slicec>`\ (\ delimiter\: :ref:`int<class_int>`, slice\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hash<class_StringName_method_hash>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`hex_decode<class_StringName_method_hex_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`hex_to_int<class_StringName_method_hex_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`indent<class_StringName_method_indent>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`insert<class_StringName_method_insert>`\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_absolute_path<class_StringName_method_is_absolute_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_empty<class_StringName_method_is_empty>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_relative_path<class_StringName_method_is_relative_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_of<class_StringName_method_is_subsequence_of>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_subsequence_ofn<class_StringName_method_is_subsequence_ofn>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ascii_identifier<class_StringName_method_is_valid_ascii_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_filename<class_StringName_method_is_valid_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_float<class_StringName_method_is_valid_float>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_hex_number<class_StringName_method_is_valid_hex_number>`\ (\ with_prefix\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_html_color<class_StringName_method_is_valid_html_color>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_identifier<class_StringName_method_is_valid_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_int<class_StringName_method_is_valid_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_ip_address<class_StringName_method_is_valid_ip_address>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`is_valid_unicode_identifier<class_StringName_method_is_valid_unicode_identifier>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`join<class_StringName_method_join>`\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`json_escape<class_StringName_method_json_escape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`left<class_StringName_method_left>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`length<class_StringName_method_length>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lpad<class_StringName_method_lpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`lstrip<class_StringName_method_lstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`match<class_StringName_method_match>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`matchn<class_StringName_method_matchn>`\ (\ expr\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`md5_buffer<class_StringName_method_md5_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`md5_text<class_StringName_method_md5_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalcasecmp_to<class_StringName_method_naturalcasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`naturalnocasecmp_to<class_StringName_method_naturalnocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`nocasecmp_to<class_StringName_method_nocasecmp_to>`\ (\ to\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_decimals<class_StringName_method_pad_decimals>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`pad_zeros<class_StringName_method_pad_zeros>`\ (\ digits\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`path_join<class_StringName_method_path_join>`\ (\ path\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_char<class_StringName_method_remove_char>`\ (\ what\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`remove_chars<class_StringName_method_remove_chars>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`repeat<class_StringName_method_repeat>`\ (\ count\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace<class_StringName_method_replace>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_char<class_StringName_method_replace_char>`\ (\ key\: :ref:`int<class_int>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replace_chars<class_StringName_method_replace_chars>`\ (\ keys\: :ref:`String<class_String>`, with\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`replacen<class_StringName_method_replacen>`\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`reverse<class_StringName_method_reverse>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfind<class_StringName_method_rfind>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`rfindn<class_StringName_method_rfindn>`\ (\ what\: :ref:`String<class_String>`, from\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`right<class_StringName_method_right>`\ (\ length\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`rpad<class_StringName_method_rpad>`\ (\ min_length\: :ref:`int<class_int>`, character\: :ref:`String<class_String>` = " "\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`rsplit<class_StringName_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_StringName_method_rstrip>`\ (\ chars\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha1_buffer<class_StringName_method_sha1_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha1_text<class_StringName_method_sha1_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`sha256_buffer<class_StringName_method_sha256_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`sha256_text<class_StringName_method_sha256_text>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`similarity<class_StringName_method_similarity>`\ (\ text\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`simplify_path<class_StringName_method_simplify_path>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedStringArray<class_PackedStringArray>` | :ref:`split<class_StringName_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_StringName_method_split_floats>`\ (\ delimiter\: :ref:`String<class_String>`, allow_empty\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_edges<class_StringName_method_strip_edges>`\ (\ left\: :ref:`bool<class_bool>` = true, right\: :ref:`bool<class_bool>` = true\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`strip_escapes<class_StringName_method_strip_escapes>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`substr<class_StringName_method_substr>`\ (\ from\: :ref:`int<class_int>`, len\: :ref:`int<class_int>` = -1\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_ascii_buffer<class_StringName_method_to_ascii_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_camel_case<class_StringName_method_to_camel_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`float<class_float>` | :ref:`to_float<class_StringName_method_to_float>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`to_int<class_StringName_method_to_int>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_kebab_case<class_StringName_method_to_kebab_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_lower<class_StringName_method_to_lower>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_multibyte_char_buffer<class_StringName_method_to_multibyte_char_buffer>`\ (\ encoding\: :ref:`String<class_String>` = ""\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_pascal_case<class_StringName_method_to_pascal_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_snake_case<class_StringName_method_to_snake_case>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`to_upper<class_StringName_method_to_upper>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf8_buffer<class_StringName_method_to_utf8_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf16_buffer<class_StringName_method_to_utf16_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_utf32_buffer<class_StringName_method_to_utf32_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`PackedByteArray<class_PackedByteArray>` | :ref:`to_wchar_buffer<class_StringName_method_to_wchar_buffer>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_prefix<class_StringName_method_trim_prefix>`\ (\ prefix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`trim_suffix<class_StringName_method_trim_suffix>`\ (\ suffix\: :ref:`String<class_String>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`int<class_int>` | :ref:`unicode_at<class_StringName_method_unicode_at>`\ (\ at\: :ref:`int<class_int>`\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_decode<class_StringName_method_uri_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_encode<class_StringName_method_uri_encode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`uri_file_decode<class_StringName_method_uri_file_decode>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_filename<class_StringName_method_validate_filename>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`validate_node_name<class_StringName_method_validate_node_name>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_escape<class_StringName_method_xml_escape>`\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`xml_unescape<class_StringName_method_xml_unescape>`\ (\ ) |const| |
+-----------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-reftable-group
Opérateurs
--------------------
.. table::
:widths: auto
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator !=<class_StringName_operator_neq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator %<class_StringName_operator_mod_Variant>`\ (\ right\: :ref:`Variant<class_Variant>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`String<class_String>` | :ref:`operator +<class_StringName_operator_sum_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<<class_StringName_operator_lt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator \<=<class_StringName_operator_lte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_String>`\ (\ right\: :ref:`String<class_String>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ==<class_StringName_operator_eq_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator ><class_StringName_operator_gt_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
| :ref:`bool<class_bool>` | :ref:`operator >=<class_StringName_operator_gte_StringName>`\ (\ right\: :ref:`StringName<class_StringName>`\ ) |
+-----------------------------+------------------------------------------------------------------------------------------------------------------+
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des constructeurs
------------------------------------------------------------
.. _class_StringName_constructor_StringName:
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ ) :ref:`🔗<class_StringName_constructor_StringName>`
Construit un **StringName** vide.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`StringName<class_StringName>`\ )
Construit une **StringName** en tant que copie de la **StringName** donnée.
.. rst-class:: classref-item-separator
----
.. rst-class:: classref-constructor
:ref:`StringName<class_StringName>` **StringName**\ (\ from\: :ref:`String<class_String>`\ )
Crée un nouveau **StringName** de la :ref:`String<class_String>` donnée. En GDScript, ``StringName("exemple")`` est équivalent à ``&"exemple"``.
.. rst-class:: classref-section-separator
----
.. rst-class:: classref-descriptions-group
Descriptions des méthodes
--------------------------------------------------
.. _class_StringName_method_begins_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **begins_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_begins_with>`
Renvoie ``true`` si la chaîne de caractères commence par le texte ``text`` donné. Voir aussi :ref:`ends_with()<class_StringName_method_ends_with>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_bigrams:
.. rst-class:: classref-method
:ref:`PackedStringArray<class_PackedStringArray>` **bigrams**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_bin_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **bin_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_c_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_escape**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_c_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **c_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_capitalize:
.. rst-class:: classref-method
:ref:`String<class_String>` **capitalize**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_casecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **casecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_casecmp_to>`
Effectue une comparaison sensible à la casse avec une autre chaîne. Renvoie ``-1`` si c’est inferieur, ``1`` si c’est plus grand, ou ``0`` si c’est égal. "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.
Avec des longueurs de chaîne différentes, renvoie ``1`` 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* ``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_StringName_method_nocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, et :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_contains:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **contains**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_find>`. Voir aussi :ref:`containsn()<class_StringName_method_containsn>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_containsn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **containsn**\ (\ what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_findn>`. Voir aussi :ref:`contains()<class_StringName_method_contains>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_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_StringName_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_StringName_method_dedent:
.. rst-class:: classref-method
:ref:`String<class_String>` **dedent**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_indent>` pour ajouter une indentation.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_ends_with:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **ends_with**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_begins_with>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_method_filecasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filecasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filecasecmp_to>`
Comme :ref:`naturalcasecmp_to()<class_StringName_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_StringName_method_filenocasecmp_to>`, :ref:`naturalcasecmp_to()<class_StringName_method_naturalcasecmp_to>`, et :ref:`casecmp_to()<class_StringName_method_casecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_filenocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **filenocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_filenocasecmp_to>`
Comme :ref:`naturalnocasecmp_to()<class_StringName_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_StringName_method_filecasecmp_to>`, :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, et :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_method_format:
.. rst-class:: classref-method
:ref:`String<class_String>` **format**\ (\ values\: :ref:`Variant<class_Variant>`, placeholder\: :ref:`String<class_String>` = "{_}"\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_get_base_dir:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_base_dir**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_get_basename:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_basename**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_get_extension:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_extension**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_get_file:
.. rst-class:: classref-method
:ref:`String<class_String>` **get_file**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_get_slice>`
Divise la chaîne en utilisant un délimiteur ``delimiter`` et renvoie la sous-chaîne à l'index ``slice``. Renvoie la chaîne d'origine si ``delimiter`` n’apparaît pas dans la chaîne. Renvoie une chaîne vide si l'index ``slice`` n'existe pas.
Ceci est plus rapide que :ref:`split()<class_StringName_method_split>`, si vous n'avez besoin qu'une seule sous-chaîne.
::
print("je/suis/exemple/hello".get_slice("/", 2)) # Affiche "exemple"
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_get_slice_count:
.. rst-class:: classref-method
:ref:`int<class_int>` **get_slice_count**\ (\ delimiter\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_get_slice_count>`
Renvoie le nombre total de tranches quand la chaîne est divisée avec le délimiteur ``delimiter`` donné (voir :ref:`split()<class_StringName_method_split>`).
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_method_get_slicec>`
Divise la chaîne en utilisant un caractère Unicode avec le code ``delimiter`` et renvoie la sous-chaîne à l'index ``slice``. Renvoie une chaîne vide si l'index ``slice`` n'existe pas.
Ceci est plus rapide que :ref:`split()<class_StringName_method_split>`, si vous n'avez besoin que d'une sous-chaîne.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_hash:
.. rst-class:: classref-method
:ref:`int<class_int>` **hash**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_hex_decode:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **hex_decode**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_hex_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **hex_to_int**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_indent:
.. rst-class:: classref-method
:ref:`String<class_String>` **indent**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_insert:
.. rst-class:: classref-method
:ref:`String<class_String>` **insert**\ (\ position\: :ref:`int<class_int>`, what\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_insert>`
Insère la chaîne ``what`` à la position ``position`` donnée dans la chaîne.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_absolute_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_absolute_path**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_relative_path>`.
Cela inclut tous les chemins commençant par ``"res://"``, ``"user://"``, ``"C:\"``, ``"/"``, etc.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_empty:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_empty**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_empty>`
Renvoie ``true`` si la longueur de la chaîne est de ``0`` (``""``). Voir aussi :ref:`length()<class_StringName_method_length>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_relative_path:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_relative_path**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_absolute_path>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_subsequence_of:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_of**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_is_subsequence_ofn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_subsequence_ofn**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_containsn>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_ascii_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ascii_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_valid_unicode_identifier>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_is_valid_filename:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_filename**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_valid_float:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_float**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_valid_int>`). Voir aussi :ref:`to_float()<class_StringName_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_StringName_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_StringName_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_StringName_method_is_valid_html_color:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_html_color**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_is_valid_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_method_is_valid_identifier>`
**Obsolète :** Use :ref:`is_valid_ascii_identifier()<class_StringName_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_StringName_method_is_valid_int:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_int**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_is_valid_ip_address:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_ip_address**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_valid_unicode_identifier:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **is_valid_unicode_identifier**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **join**\ (\ parts\: :ref:`PackedStringArray<class_PackedStringArray>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_json_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **json_escape**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_c_unescape>` pour échapper la chaîne, si nécessaire.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_left:
.. rst-class:: classref-method
:ref:`String<class_String>` **left**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_length:
.. rst-class:: classref-method
:ref:`int<class_int>` **length**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_empty>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_method_rpad>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_lstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **lstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_lstrip>`
Retire un ensemble de caractères définis dans ``chars`` du début de la chaîne. Voir aussi :ref:`rstrip()<class_StringName_method_rstrip>`.
\ **Note :** ``chars`` n'est pas un préfixe. Utilisez :ref:`trim_prefix()<class_StringName_method_trim_prefix>` pour supprimer un seul préfixe, plutôt qu'un ensemble de caractères.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_match:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **match**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_matchn:
.. rst-class:: classref-method
:ref:`bool<class_bool>` **matchn**\ (\ expr\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_md5_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **md5_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_md5_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **md5_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_md5_text>`
Renvoie le `hachage MD5 <https://fr.wikipedia.org/wiki/MD5>`__ de la chaîne en tant qu'autre :ref:`String<class_String>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalcasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalcasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalcasecmp_to>`
Effectue une comparaison *dans l'ordre naturel*, **sensible à la casse** avec une autre chaîne. Renvoie ``-1`` si inférieure à, ``1`` si plus supérieure à, ou ``0`` si égales. "Inférieure à" ou "supérieure à" sont déterminés par les `points de code Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique.
Lorsqu'utilisé pour le tri, la comparaison en ordre naturel ordonne des séquences de nombres par la valeur combinée de chaque chiffre comme généralement attendu, au lieu de la valeur du chiffre seul. Une séquence de chaînes de nombres triée sera ``["1, "2", "3", ...]``, pas ``["1", "10", "2", "3", ...]``.
Avec différentes longueurs de chaîne, renvoie ``1`` 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 en :ref:`bool<class_bool>` d'une comparaison de chaîne, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, et :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_naturalnocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **naturalnocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_naturalnocasecmp_to>`
Effectue une comparaison *dans l'ordre naturel*, **insensible à la casse** avec une autre chaîne. Renvoie ``-1`` si inférieure à, ``1`` si plus supérieure à, ou ``0`` si égales. "Inférieure à" ou "supérieure à" sont déterminés par les `points de code Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__ de chaque chaîne, qui correspond approximativement à l'ordre alphabétique.
Lorsqu'utilisé pour le tri, la comparaison en ordre naturel ordonne des séquences de nombres par la valeur combinée de chaque chiffre comme généralement attendu, au lieu de la valeur du chiffre seul. Une séquence de chaînes de nombres triée sera ``["1, "2", "3", ...]``, pas ``["1", "10", "2", "3", ...]``.
Avec différentes longueurs de chaîne, renvoie ``1`` 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 en :ref:`bool<class_bool>` d'une comparaison de chaîne, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`, :ref:`filecasecmp_to()<class_StringName_method_filecasecmp_to>`, et :ref:`nocasecmp_to()<class_StringName_method_nocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_nocasecmp_to:
.. rst-class:: classref-method
:ref:`int<class_int>` **nocasecmp_to**\ (\ to\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_nocasecmp_to>`
Effectue une comparaison **insensible à la casse** avec une autre chaîne. Renvoie ``-1`` si inférieure à ``1`` si plus supérieure à, ou ``0`` si égales. "Inférieure à" ou "supérieure à" sont déterminés par les `points de code Unicode <https://fr.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.
Avec des longueurs de chaîne différentes, renvoie ``1`` 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 en :ref:`bool<class_bool>` d'une comparaison de chaîne, utilisez plutôt l'opérateur ``==``. Voir aussi :ref:`casecmp_to()<class_StringName_method_casecmp_to>`, :ref:`filenocasecmp_to()<class_StringName_method_filenocasecmp_to>`, et :ref:`naturalnocasecmp_to()<class_StringName_method_naturalnocasecmp_to>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_pad_decimals:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_decimals**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_pad_zeros:
.. rst-class:: classref-method
:ref:`String<class_String>` **pad_zeros**\ (\ digits\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_path_join:
.. rst-class:: classref-method
:ref:`String<class_String>` **path_join**\ (\ path\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_remove_char:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_char**\ (\ what\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_remove_char>`
Retire toutes les occurrences du caractère Unicode avec le code ``what``. Version plus rapide de :ref:`replace()<class_StringName_method_replace>` lorsque la clé n'est longue que d'un caractère et que le remplacement est ``""``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_remove_chars:
.. rst-class:: classref-method
:ref:`String<class_String>` **remove_chars**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_remove_chars>`
Removes all occurrences of the characters in ``chars``. See also :ref:`remove_char()<class_StringName_method_remove_char>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_repeat:
.. rst-class:: classref-method
:ref:`String<class_String>` **repeat**\ (\ count\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_replace:
.. rst-class:: classref-method
:ref:`String<class_String>` **replace**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_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_StringName_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_StringName_method_length>` pour vous en assurer).
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_method_replace_char>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_replacen:
.. rst-class:: classref-method
:ref:`String<class_String>` **replacen**\ (\ what\: :ref:`String<class_String>`, forwhat\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_reverse:
.. rst-class:: classref-method
:ref:`String<class_String>` **reverse**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_method_find>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_right:
.. rst-class:: classref-method
:ref:`String<class_String>` **right**\ (\ length\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_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_StringName_method_lpad>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_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_StringName_method_rstrip:
.. rst-class:: classref-method
:ref:`String<class_String>` **rstrip**\ (\ chars\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_method_rstrip>`
Retire un ensemble de caractères définis dans ``chars`` depuis la fin de la chaîne. Voir aussi :ref:`rstrip()<class_StringName_method_rstrip>`.
\ **Note :** ``chars`` n'est pas un suffixe. Utilisez :ref:`trim_suffix()<class_StringName_method_trim_suffix>` pour supprimer un seul suffixe, plutôt qu'un ensemble de caractères.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha1_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha1_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_sha1_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha1_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha1_text>`
Renvoie le hachage `SHA-1 <https://fr.wikipedia.org/wiki/SHA-1>`__ de la chaîne en tant qu'autre :ref:`String<class_String>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_sha256_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **sha256_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_sha256_text:
.. rst-class:: classref-method
:ref:`String<class_String>` **sha256_text**\ (\ ) |const| :ref:`🔗<class_StringName_method_sha256_text>`
Renvoie le hash `SHA-256 <https://fr.wikipedia.org/wiki/SHA-2>`__ de la chaîne de caractères en :ref:`String<class_String>`.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_similarity:
.. rst-class:: classref-method
:ref:`float<class_float>` **similarity**\ (\ text\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_simplify_path:
.. rst-class:: classref-method
:ref:`String<class_String>` **simplify_path**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_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_StringName_method_strip_escapes:
.. rst-class:: classref-method
:ref:`String<class_String>` **strip_escapes**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_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_StringName_method_to_ascii_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_ascii_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_to_camel_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_camel_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_camel_case>`
Renvoie la chaîne de caractères convertie en ``camelCase``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_float:
.. rst-class:: classref-method
:ref:`float<class_float>` **to_float**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_to_int:
.. rst-class:: classref-method
:ref:`int<class_int>` **to_int**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_to_kebab_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_kebab_case**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_to_lower:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_lower**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_lower>`
Renvoie la chaîne de caractères convertie en ``lowercase`` (minuscules).
.. rst-class:: classref-item-separator
----
.. _class_StringName_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_StringName_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_StringName_method_to_pascal_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_pascal_case**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_pascal_case>`
Renvoie la chaîne de caractères convertie en ``PascalCase``.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_snake_case:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_snake_case**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_to_upper:
.. rst-class:: classref-method
:ref:`String<class_String>` **to_upper**\ (\ ) |const| :ref:`🔗<class_StringName_method_to_upper>`
Renvoie la chaîne de caractères convertie en ``UPPERCASE`` (majuscules).
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_to_utf8_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf8_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_to_utf16_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf16_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_to_utf32_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_utf32_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_to_wchar_buffer:
.. rst-class:: classref-method
:ref:`PackedByteArray<class_PackedByteArray>` **to_wchar_buffer**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_trim_prefix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_prefix**\ (\ prefix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_trim_suffix:
.. rst-class:: classref-method
:ref:`String<class_String>` **trim_suffix**\ (\ suffix\: :ref:`String<class_String>`\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_unicode_at:
.. rst-class:: classref-method
:ref:`int<class_int>` **unicode_at**\ (\ at\: :ref:`int<class_int>`\ ) |const| :ref:`🔗<class_StringName_method_unicode_at>`
Renvoie le code du caractère à la position ``at``.
Voir aussi :ref:`String.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_StringName_method_uri_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_decode**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_uri_encode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_encode**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_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_StringName_method_uri_file_decode:
.. rst-class:: classref-method
:ref:`String<class_String>` **uri_file_decode**\ (\ ) |const| :ref:`🔗<class_StringName_method_uri_file_decode>`
Décode le chemin de fichier depuis son format encodé d'URL. Contrairement à :ref:`uri_decode()<class_StringName_method_uri_decode>`, cette méthode laisse ``+`` tel quel.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_filename:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_filename**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_is_valid_filename>` remplacés par des tirets du bas.
.. rst-class:: classref-item-separator
----
.. _class_StringName_method_validate_node_name:
.. rst-class:: classref-method
:ref:`String<class_String>` **validate_node_name**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_xml_escape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_escape**\ (\ escape_quotes\: :ref:`bool<class_bool>` = false\ ) |const| :ref:`🔗<class_StringName_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_StringName_method_xml_unescape:
.. rst-class:: classref-method
:ref:`String<class_String>` **xml_unescape**\ (\ ) |const| :ref:`🔗<class_StringName_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_StringName_operator_neq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_neq_String>`
Renvoie ``true`` si ce **StringName** n'est pas équivalent au :ref:`String<class_String>` donné.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_neq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator !=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_neq_StringName>`
Renvoie ``true`` si **StringName** et ``right`` ne se réfèrent pas au même nom. Les comparaisons entre **StringName**\ s sont beaucoup plus rapides que les comparaisons de :ref:`String<class_String>` habituelles.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_mod_Variant:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator %**\ (\ right\: :ref:`Variant<class_Variant>`\ ) :ref:`🔗<class_StringName_operator_mod_Variant>`
Formate le **StringName**, remplaçant les placeholders par un ou plusieurs paramètres, et renvoyant un :ref:`String<class_String>`. Pour passer plusieurs paramètres, ``right`` doit être un :ref:`Array<class_Array>`.
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. Au lieu de cela, voir `Interpolation de chaîne à l’aide de "$" <https://learn.microsoft.com/fr-fr/dotnet/csharp/language-reference/tokens/interpolated>`__.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_sum_String:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_sum_String>`
Ajoute la chaîne ``right`` à la fin de ce **StringName**, renvoyant une :ref:`String<class_String>`. Ceci est également connu comme une concaténation de chaînes.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_sum_StringName:
.. rst-class:: classref-operator
:ref:`String<class_String>` **operator +**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_sum_StringName>`
Ajoute la chaîne ``right`` à la fin de ce **StringName**, renvoyant une :ref:`String<class_String>`. Ceci est également connu comme une concaténation de chaînes.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_lt_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lt_StringName>`
Renvoie ``true`` si le pointeur du **StringName** de gauche arrive avant le pointeur de ``right``. Notez que cela ne correspondra pas à leur `ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_lte_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator <=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_lte_StringName>`
Renvoie ``true`` si le pointeur du **StringName** de gauche arrive avant le pointeur de ``right`` ou s'ils sont les mêmes. Notez que cela ne correspondra pas à leur `ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_eq_String:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`String<class_String>`\ ) :ref:`🔗<class_StringName_operator_eq_String>`
Renvoie ``true`` si ce **StringName** est équivalent au :ref:`String<class_String>` donné.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_eq_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator ==**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_eq_StringName>`
Renvoie ``true`` si **StringName** et ``right`` se réfèrent au même nom. Les comparaisons entre **StringName**\ s sont beaucoup plus rapides que les comparaisons de :ref:`String<class_String>` habituelles.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_gt_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gt_StringName>`
Renvoie ``true`` si le pointeur du **StringName** de gauche arrive après le pointeur de ``right``. Notez que cela ne correspondra pas à leur `ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__.
.. rst-class:: classref-item-separator
----
.. _class_StringName_operator_gte_StringName:
.. rst-class:: classref-operator
:ref:`bool<class_bool>` **operator >=**\ (\ right\: :ref:`StringName<class_StringName>`\ ) :ref:`🔗<class_StringName_operator_gte_StringName>`
Renvoie ``true`` si le pointeur du **StringName** de gauche arrive après le pointeur de ``right`` ou s'ils sont les mêmes. Notez que cela ne correspondra pas à leur `ordre Unicode <https://fr.wikipedia.org/wiki/Table_des_caract%C3%A8res_Unicode>`__.
.. |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