# Chaînes de texte ```lua txt = "lalala" = type(txt) -- renvoie "string" ``` Le type `string` a le fonctionnement habituel mais ne dispose pas des nombreuses fonctionnalités existantes en Python. ## Définir une chaîne ```lua -- classiques " " et ' ' txt = "lalala" txt = 'lalala' -- pour le texte multilignes : txt = [[lalala pwet ]] ``` ## Longueur Une fonction `len` comme en Python. Il y a plusieurs façons d'appeler cette méthode ce qui nous permet de voir comment Lua traite les objets. ```lua text = "ABC" = string.len(text) -- renvoie 3 = string.len("ABC") -- 3 également = text:len() -- idem = "ABC":len() -- erreur ! = ("ABC"):len() -- renvoie 3 ``` `len` est une méthode liée au type `string`. `text` étant une instance de `string`, il est possible d'appeler `len` comme on le fait avec les instances de classe. Mais il faut alors utiliser `:` comme vous le voyez dans l'exemple. On ne peut pas appeler la méthode directement avec `"ABC"` mais les parenthèses `("ABC")` permettent de contourner le problème. Il existe aussi un raccourci `#text` pour obtenir la longueur de la chaîne `text`. ## Encodage On peut créer directement une chaîne à partir d'octets : ```lua text = string.char(65,66,67) -- text = "ABC" ``` Les codes fournis sont en ASCII. > Comme déjà signalé auparavant, en Lua, il ne devrait pas y avoir une expression comme `2 + 3` sans rien. Il faut forcément envoyer ce résultat comme `x = 2 + 3` ou `print(2 + 3)` ou encore `= 2 + 3` ce qui en console affiche le résultat. L'inverse est possible : ```lua = string.byte("ABC", 1) -- renvoie 65, code ASCII de 'A' = text:byte(1) -- même chose = "ABC":byte(1) -- erreur = ("ABC"):byte(1) -- renvoie 65 = string.byte("ABC", 1, -1) -- renvoie 65, 66, 67 ``` **Très important :** En Lua, l'indice de début est `1` au lieu de l'habituel `0`. Le caractère `1` de `"ABC"` est donc le `A`. Le dernier cas montre un cas qui évoque les indices en Python : la fonction renvoie tous les résultats pour les indices allant de `1` à `-1`, c'est à dire du premier au dernier. **Unicode ?** A, B, C sont des caractères ASCII. On aimerait connaître le résultat pour des caractères hors ASCII. La difficulté ici est que cela va dépendre de l'éditeur utilisé. Quand j'écrie `"é"` dans mon éditeur, quel encodage est utilisé ? Par exemple, quand je teste pour `"é"` j'obtiens `130` ce qui ne correspond ni à ISO 8859-1, ni à ANSI de Microsoft, ni UTF-8 ni Unicode... > Il paraît que la version 5.3 de lua donne accès à un module utf8 mais je n'ai pas essayé. J'en suis à la version 5.1. ## Des fonctions Comme pour `len` et `byte` on aura toujours le choix entre la notation `string.lafonction(chaine, ...)` et `chaine:lafonction(...)`. ### recherche ```lua = string.find("le texte exemple", "ex") -- renvoie 5 6 pour la première occurence = string.find("le texte exemple", "ex", 7) -- renvoie 10 11 pour la deuxième occurence -- recherchée à partir du caractère en position 7 ``` ### sous chaîne ```lua = string.sub("le texte exemple", 4) -- renvoie "texte exemple" (à partir du rang 4) = string.sub("le texte exemple", 4, 8) -- renvoie "texte", rangs 4 à 8 compris ``` ### ordre inverse ```lua = string.reverse("abc") -- renvoie "cba" ``` ### case ```lua = string.upper("Chaîne") -- renvoie "CHAîNE" = string.lower("CHAÎNe") -- renvoie "chaÎne" ``` Remarquez l'échec sur les caractères accentués. ### remplacement ````lua = string.gsub("banana", "n", "x") -- renvoie "baxaxa" 2 -- 2 car il y a 2 remplacements = string.gsub("banana", "n", "x", 1) -- renvoie "baxana" 1 -- limité à 1 remplacement = string.gsub("banana", "an", "zz") -- renvoie "bzzzza" = string.gsub("nombre 345 lalala 11", "(%d+)", "x [%1]") ```` Le dernier cas plus compliqué est donné pour montrer ce qui est possible. `%d+` signifie au moins 1 caractère de type chiffre, `(%d+)` signifie que l'on veut mémoriser toute éventuelle détection ce motif. Dans `nombre 345 lalala 11` on détecte les occurrences `345` et `11` qui seront remplacées par `"x [%1]"`. Le `%1` permet de reprendre ce qui a été détecté. Ici `345` est remplacé par `x [345]` et `11` est remplacé par `x [11]`. ### formatage Même principe qu'en C. ```lua = string.format("Le nombre est %d.", 45) -- %d est remplacé par le nombre = string.format("Le nombre est %x.", 45) -- %x est remplacé par le nombre en hexa : 2d ``` ## Concaténation On utilise `..` ```lua = "abc".."def" -- renvoie "abcdef" x = 10 = "le nombre est "..x -- renvoie "le nombre est 45" ``` Dans le dernier exemple, on voit que le nombre 45 est automatiquement transtypé en chaîne.