[[ags|{{:contents.gif}}]] [[scripting|{{:up.gif}}]] [[screen|{{:back.gif}}]] [[system|{{:forward.gif}}]]
----
=====Fonctions de Texte (String)=====

====Append====
 // (Anciennement fonction globale StrCat, désormais obsolète) // \\
  
  String.Append(string str2)

Accole la chaîne de caractères (//string//) STR2 à la fin de la chaîne de caractères
(//string//) spécifiée, et retourne le résultat de l'opération.\\ \\ 
 ** IMPORTANT : **  Le résultat de ce collage est retourné en tant qu'une nouvelle
chaîne de caractères (//string//) par cette commande. La chaîne originale ** NE SERA PAS **
modifiée. Par exemple, le script suivant ne fera rien :
 
  montexte.Append("World"); 
 
ce que vous désireriez plutôt serait :
 
  montexte = montexte.Append("World"); \\ \\ 
Exemple :
  
  String montexte = "Hello";
  montexte = montexte.Append("World");
  Display(montexte);

ce qui affichera "HelloWorld".\\ \\ 
 // Voir aussi : //  [[String#AppendChar|String.AppendChar]],
[[String#Substring|String.Substring]], [[String#String.Truncate|String.Truncate]]\\ \\ 



----

====AppendChar====
  
  String.AppendChar(char extraChar)

Ajoute un simple caractère à la fin du texte spécifié, et retourne le résultat.\\ \\ 
 ** IMPORTANT: **  Le nouveau texte est retourné comme une nouvelle chaîne de caractère par cette commande.
La chaîne originale restera ** inchangée **. Par exemple, le script suivant n'aura aucun effet :
 
montexte.AppendChar('o'); 
 
ce que vous voudriez plutôt est :
 
montexte = montexte.AppendChar('o'); \\ \\ 
Exemple :
  
  String montexte = "Hell";
  montexte = montexte.AppendChar('o');
  Display(montexte);

ce qui affichera "Hello".\\ \\ 
 // Voir aussi : //  [[String#Append|String.Append]]\\ \\ 



----

====CompareTo====
 // (Anciennement fonction globale StrCaseComp, désormais obsolète) //  
 

 // (Anciennement fonction globale StrComp, désormais obsolète) // \\ \\ 
  
  String.CompareTo(string str2, optional bool caseSensitive)

Compare le texte spécifié à STR2.  // caseSensitive //  détermine si "Chien" et "chien"
sont équivalents ; par défaut, la sensibilité à la casse n'est pas prise en compte.\\ \\ 
Retourne 0 si les textes sont identiques, un nombre inférieur à 0 si la chaîne précède STR2 dans l'ordre alphabétique,
et un nombre supérieur à 0 si la chaîne se trouve plus loin dans l'alphabet que STR2.\\ \\ 
 ** ASTUCE : **  Pour effectuer une comparaison susceptible à la casse de deux textes, il est plus
facile d'utiliser simplement l'opérateur ==.\\ \\ 
Exemple :
  
  String montexte = "Bonjour";
  if (montexte.CompareTo("bonjour") == 0) {
    Display("Les textes correspondent avec insensibilité à la casse !");
  }
  else {
    Display("Les textes ne correspondent pas avec insensibilité à la casse !");
  }
  
  if (montexte == "bonjour") {
    Display("Les textes correspondent avec sensibilité à la casse !");
  }
  else {
    Display("Les textes ne correspondent pas avec sensibilité  à la casse !");
  }

ce qui affichera "Les textes correspondent avec insensibilité à la casse !", puis
"Les textes ne correspondent pas avec sensibilité à la casse !".\\ \\ 



----

====Copy====
 // (Anciennement fonction globale StrCopy, désormais obsolète) // \\ \\ 
  
  String.Copy()

Retourne une copie de la chaîne spécifiée. En temps normal, vous  n'en aurez pas
l'utilité, puisque les chaînes peuvent être définies en utilisant l'opérateur =.\\ \\ 
Exemple :
  
  String machaine = "Ceci est une chaîne-test.";
  String nouvellechaine = machaine.Copy();
  Display(nouvellechaine);

affichera "Ceci est une chaîne-test.".\\ \\ 



----

====EndsWith====
  
  bool String.EndsWith(string texteRecherche, optional bool caseSensitive)

Retourne // true // si la chaîne se termine par // texteRecherche // , ou // false // sinon.\\ \\ 
 // caseSensitive //  vaut  // false //  par défaut, mais vous pouvez passer // true // de façon
à ce que la fonction ne retourne // true // lors d'une correspondance susceptible à la casse.\\ \\ 
Exemple :
  
  String maChaine = "Bonjour depuis le script !";
  if (maChaine.EndsWith("script !"))
  {
    Display("Finit par script !");
  }

affichera le message "Finit avec script !".\\ \\ 
 // Compatibilité : //  Supporté par  ** AGS 3.1.0 **  et les versions plus récentes.\\ \\ 
 // Voir aussi : //  [[String#IndexOf|String.IndexOf]],
[[String#StartsWith|String.StartsWith]]\\ \\ 



----

====Format====
 // (Anciennement fonction globale StrFormat, désormais obsolète) // \\ \\ 
  
  static String.Format(string fmt, ...)

Traite la chaîne FMT de la même façon que le fait la fonction [[Speech#Display|Display]]
mais plutôt que de l'afficher à  l'écran, retourne le résultat comme une nouvelle chaîne.\\ \\ 
Vous pouvez ainsi insérer des valeurs de variables dans la chaîne. Pour plus d'informations,
voir la section [[La syntaxe des chaînes de caractères#StringFormats|syntaxe des chaînes de caractères]].\\ \\ 
 ** NOTE : **  Cette fonction est statique, ce qui signifie que vous
ne devez pas l'appeler depuis une variable chaîne existante, mais
plutôt en utilisant directement String.Format().\\ \\ 
Exemple :
  
  int sante=10;
  String texte = String.Format("%d", sante);

créera une chaîne de texte contenant "10".\\ \\ 
 // Voir aussi : //  [[Speech#Display|Display]]\\ \\ 



----

====IndexOf====
 // (Anciennement fonction globale StrContains, désormais obsolète) //  
 
 // (Anciennement String.Contains, désormais obsolète) // \\ \\ 
  
  String.IndexOf(string aiguille)

Verifie si AIGUILLE est contenue dans la chaîne de texte testée. Retourne la position du caractère
correspondant si c'est le cas, ou -1 s'il n'y a pas de correspondance.\\ \\ 
Cette fonction ne prend pas la casse en compte ; c'est-à-dire que chercher "cHaInE" dans "chaine de test"
retournerait bien une correspondance.\\ \\ 
Exemple :
  
  String botte = "Il y a une aiguille dans la botte de foin.";
  int resultat = botte.IndexOf("une aiguille");
  
  if (resultat == -1) {
    Display("La chaîne ne contenait pas une aiguille.");
  }
  else {
    Display("une aiguille a été trouvée au caractère numéro %d dans la chaîne.", resultat);
  }

 // Voir aussi : //  [[String#EndsWith|String.EndsWith]],
[[String#StartsWith|String.StartsWith]]\\ \\ 



----

====IsNullOrEmpty====
  
  static bool String.IsNullOrEmpty(String chaineTestee)

Renseigne si la chaîne est vide ou nulle. C'est un simple raccourci pour le test suivant :
  
  if ((chaineTestee == null) || (chaineTestee == ""))

autrement dit, vous pouvez l'utiliser facilement pour vérifier si une chaîne contient du texte ou non.\\ \\ 
 ** NOTE : **  Cette fonction est statique, ce qui signifie que vous ne devez pas l'appeler
à partir d'une variable chaîne de caractère. Utilisez plutôt directement String.IsNullOrEmpty().
Voir l'exemple.\\ \\ 
Exemple :
  
  String maChaine;
  if (String.IsNullOrEmpty(maChaine))
  {
    maChaine = "Du texte";
  }

donnera la valeur "Du texte" à la variable maChaine si celle-ci est nulle ou vide (ce qui est le cas en l'occurrence).\\ \\ 
 // Compatibilité : //  Supporté par  ** AGS 3.0.1 **  et les versions plus récentes.\\ \\ 



----

====LowerCase====
 // (Anciennement fonction globale StrToLowerCase, désormais obsolète) // \\ \\ 
  
  String.LowerCase()

Retourne une version minuscule de la chaîne de texte spécifiée.\\ \\ 
 ** NOTE : **  Cette fonction retourne une nouvelle chaîne ;
elle ** NE MODIFIE PAS ** la chaîne originale.\\ \\ 
Exemple :
  
  String maChaine = "CECI est une chaîne de test";
  String minuscule = maChaine.LowerCase();
  Display("Ancienne : %s, nouvelle : %s", maChaine, minuscule);

affichera "Ancienne : CECI est une chaîne de test, nouvelle : ceci est une chaîne de test".\\ \\ 
 // Voir aussi : //  [[String#UpperCase|String.UpperCase]]\\ \\ 



----

====Replace====
  
  String.Replace(string texteCherche, string texteRemplacant,
                 optional bool sensibleCasse)

Crée une copie de cette chaîne, où toutes les occurrences de // texteCherche // sont remplacées par // texteRemplacant // .\\ \\ 
 // sensibleCasse //  vaut  // false //  par défaut, mais vous pouvez le passer comme // true //
de façon à ce que seules les occurrences dont la casse est la même que celle de  // texteCherche //  soient remplacées.\\ \\ 
 ** NOTE : **  Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne ** N'EST PAS MODIFIÉE ** par cette fonction.
Exemple :
  
  String originale = "Salut depuis le script !";
  String changee = originale.Replace("salut", "adieu");
  Display("Ancienne : %s, nouvelle : %s", originale, changee);

affichera "Ancienne : Salut depuis le script !, nouvelle : adieu depuis le script !".\\ \\ 
 // Compatibilité : //  Supporté par  ** AGS 3.1.0 **  et les versions plus récentes.\\ \\ 
 // Voir aussi : //  [[String#ReplaceCharAt|String.ReplaceCharAt]]\\ \\ 



----

====ReplaceCharAt====
 // (Anciennement fonction globale StrSetCharAt, désormais obsolète) // \\ \\ 
  
  String.ReplaceCharAt(int index, char nouvelleLettre)

Remplace le caractère à la position INDEX dans la chaîne par NOUVELLELETTRE. \\ 
INDEX correspond à l'index du caractère dans la chaîne (où 0 renvoie au premier caractère,
et où la plus haute valeur possible correspond à la longueur de la chaîne moins 1).\\ \\ 
 ** NOTE : **  Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne ** N'EST PAS MODIFIÉE ** par cette fonction.\\ \\ 
Exemple :
  
  String machaine = "Salut";
  String changee = machaine.ReplaceCharAt(2, 'm');
  Display("Ancienne : %s, nouvelle : %s", machaine, changee);

affichera "Ancienne : Salut, nouvelle : Samut".\\ \\ 
 // Voir aussi : //  [[String#Chars|String.Chars]], 
[[String#Replace|String.Replace]]\\ \\ 



----

====StartsWith====
  
  bool String.StartsWith(string texteCherche, optional bool sensibleCasse)

Retourne // true // si la chaîne commence par // texteCherche // , ou // false // si ce n'est pas le cas.\\ \\ 
 // sensibleCasse //  vaut  // false //  par défaut, mais vous pouvez le passer comme // true // pour que la fonction
ne retourne // true // que lorsque la correspondance est sensible à la casse.\\ \\ 
Exemple :
  
  String maChaine = "Salut depuis le script !";
  if (maChaine.StartsWith("salut"))
  {
    Display("Commence par salut !");
  }

affichera le message "Commence par salut !".\\ \\ 
 // Compatibilité : //  Supporté par  ** AGS 3.1.0 **  et les versions plus récentes.\\ \\ 
 // Voir aussi : //  [[String#EndsWith|String.EndsWith]], 
[[String#IndexOf|String.IndexOf]]\\ \\ 



----

====Substring====
  
  String.Substring(int index, int longueur)

Retourne une partie de la chaîne, depuis le caractère // index // sur une longueur de // longueur //.\\ \\ 
 // index //  correspond à la position du caractère initial de la sous-chaîne que vous voulez récupérer,
où 0 représente le tout premier caractère et (Longueur - 1) le dernier.
  // longueur //  spécifie combien de caractères vous voulez récupérer depuis cette position.\\ \\ 
Exemple :
  
  String machaine = "Hello World!";
  String souschaine = machaine.Substring(3, 5);
  Display("Originale : %s, Sous-chaine : %s", machaine, souschaine);

affichera "Originale : Hello World!, Sous-chaine : lo Wo".\\ \\ 
 // Voir aussi : //  [[String#Append|String.Append]], [[String#String.Chars|String.Chars]]\\ \\ 



----

====Truncate====
  
  String.Truncate(int longueur)

Retourne une version de la chaîne qui aura été coupée à  // longueur //  caractères.\\ \\ 
 ** NOTE : **  Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne ** N'EST PAS MODIFIÉE ** par cette fonction.\\ \\ 
Exemple :
  
  String machaine = "Hello World!";
  String tronquee = machaine.Truncate(4);
  Display("Originale : %s, Tronquee : %s", machaine, tronquee);

affichera "Originale : Hello World!, Tronquee : Hell".\\ \\ 
 // Voir aussi : //  [[String#Append|String.Append]], [[String#String.Substring|String.Substring]]\\ \\ 



----

====UpperCase====
 // (Anciennement fonction globale StrToUpperCase, désormais obsolète) // \\ \\ 
  
  String.UpperCase()

Retourne une version majuscule de la chaîne spécifiée.\\ \\ 
 ** NOTE : **  Cette fonction retourne une nouvelle chaîne ; l'ancienne chaîne ** N'EST PAS MODIFIÉE ** par cette fonction.
Exemple :
  
  String machaine = "CECI est une chaine de test";
  String majuscules = machaine.UpperCase();
  Display("Ancienne : %s, nouvelle : %s", machaine, majuscules);

affichera "Ancienne : CECI est une chaine de test, nouvelle : CECI EST UNE CHAINE DE TEST".\\ \\ 
 // Voir aussi : //  [[String#LowerCase|String.LowerCase]]\\ \\ 



----

====AsFloat====
  
  readonly float String.AsFloat;

Convertit une chaîne en nombre flottant (à virgules), et retourne cette valeur.
Retourne 0.0 si la chaîne ne contient pas un nombre.\\ \\ 
Exemple :
  
  String texte1, texte2;
  float nombre1,nombre2;
  texte1 = "57.362";
  texte2 = "Salut";
  nombre1 = texte1.AsFloat;
  nombre2 = texte2.AsFloat;

définira la valeur de //nombre1// à 57.362 et de //nombre2// à 0.0.
Cette fonction est pratique pour traiter le texte entré par l'utilisateur.\\ \\ 
 ** NOTE : **  Pour convertir un flottant en chaîne de caractères, vous pouvez utiliser
la commande [[String#Format|String.Format]].\\ \\ 
 // Voir aussi : //  [[Game#InputBox|Game.InputBox]],
[[String#AsInt|String.AsInt]],
[[String#Format|String.Format]]\\ \\ 



----

====AsInt====
 // (Anciennement fonction globale StringToInt, désormais obsolète) // \\ \\ 
  
  readonly int String.AsInt;

Convertit la chaîne de texte en nombre entier, et retourne cette valeur.
Retourne 0 si la chaîne ne contient pas un nombre.\\ \\ 
Exemple :
  
  String texte1, texte2;
  int nombre1,nombres2;
  texte1 = "53";
  texte2 = "Salut";
  nombre1 = texte1.AsInt;
  nombre2 = texte2.AsInt;

définira la valeur de //nombre1// à 53 et celle de //nombre2// à 0.
Cette fonction est utile pour traiter le texte entré par l'utilisateur.\\ \\ 
 ** NOTE : **  Pour convertir un entier en chaîne de texte, vous pouvez utiliser
la commande [[String#Format|String.Format]].\\ \\ 
 // Voir aussi : //  [[Game#InputBox|Game.InputBox]], [[String#String.AsFloat|String.AsFloat]],
[[String#Format|String.Format]]\\ \\ 



----

====Chars====
 // (Anciennement fonction globale StrGetCharAt, désormais obsolète) // \\ \\ 
  
  readonly char String.Chars[position];

Retourne le caractère à POSITION dans la chaîne.\\ \\ 
POSITION est la position du caractère dans la chaîne (où 0 correspond au tout
premier caractère, et où la plus haute valeur possible correspond à la longueur
de la chaîne moins 1)\\ \\ 
Si POSITION vaut plus que la longueur de la chaîne, la fonction retourne 0.\\ \\ 
 ** NOTE : **  Le tableau  // Chars // est en lecture seule. Si vous désirez
changer l'un des caractères dans la chaîne, utilisez [[String#ReplaceCharAt|String.ReplaceCharAt]].\\ \\ 
Exemple :
  
  String texte = "Voici ma chaine.";
  Display("La 4eme lettre est : %c", texte.Chars[3]);

affichera "La 4eme lettre est : s".\\ \\ 
 // Voir aussi : //  [[String#Length|String.Length]],
[[String#ReplaceCharAt|String.ReplaceCharAt]]\\ \\ 



----

====Length====
 // (Anciennement fonction globale StrLen, désormais obsolète) // \\ \\ 
  
  readonly int String.Length;

Retourne la longueur de la chaîne, c'est-à-dire le nombre de caractères qu'elle contient.\\ \\ 
Exemple :
  
  String texte = "Voici ma chaine.";
  Display("Longueur: %d", texte.Length);

affichera "Longueur: 18".

{{tag>français}}