|
Documentation language LUA |
Fonctions sur les chaînes de caractères LUA |
Ce document présente les fonctions de manipulation de chaînes de caractères en LUA. Ces fonctions peuvent être utilisées dans les scripts LUA de LoriotPro.
Voici la liste préliminaire de description des fonctions de Chaînes de caratères
Note: Dans les chaînes de caractères de Lua les index (offset d'un caractère dans la chaîne) commencent à la valeur d'index 1, et non pas la valeur d'index 0 comme en C.
Consultez le chapitre Expressions régulières pour la recherche de caractères dans les chaînes de caractères
Renvoie le code numérique ASCII du caractère situé à l'index I de la chaine s en argument.
> = string.byte("ABCDE les") -- aucun index, ainsi index
1 du premier soit le caractère A
65
> = string.byte("ABCDE", 1) -- commencent à 1
65
> = string.byte("ABCDE", 0) -- nous n'employons pas
C
> = string.byte("ABCDE", 100) -- index hors de la gamme, aucune valeur
retournée
Création d'une chaîne de caractères à partir des codes ASCII passés comme arguments en i1, i2 ....
Remarque: Les codes ASCII ne
sont pas nécessairement compatibles à travers les systèmes d'exploitations.
> = string.char(65,66,67)
ABC
> = string.char() -- chaîne de caractères vide
Renvoie une représentation binaire de la fonction donnée, de sorte que loadstring postérieur sur cette chaîne de caractères renvoie une copie de la fonction. La fonction doit être une fonction de Lua sans upvalues.
Recherche une sous chaîne de caractère dans une chaîne
Recherche la première occurence de la sous chaîne pattern dans la chaînes de caractères s. Si la sous chaîne est trouvé une paire de
valeurs représentant le début et l'extrémité de la chaîne de caractères est
retournée. Si le modèle ne peut pas être trouvé la valeur nil est retournée.
> = string.find("Hello Lua user ", "Lua")
7 9
> = string.find("Hello Lua user","banana")
nil
Nous pouvons en option indiquer où commencer la recherche avec un troisième argument init. L'argument peut également être négatif pour débuter la recherche dans la chaîne de caractères en partant de l'extrémité droite.
> = string.find("Hello Lua user ", "Lua", 1) --
commencez au premier caractère
7 9
> =
string.find("Hello Lua user ", "Lua", 8) -- "Lua" non trouvé après
le 8 caractère de la chaîne
nil
> = string.find("Hello Lua user ", "e",
-5) -- d'abord "e" 5 caractères de l'extrémité
13 13
L'argument pattern permet également des
recherches plus complexes. Voyez le
Patterns Tutorial pour plus d'information. Nous
pouvons arrêter le dispositif régulier d'expression en employant le
quatrième argument facultatif plain. plain prend une
valeur booléenne et doit être précédé de init.
Par exemple,
> = string.find("Hello Lua user ",
"%su") -- trouvez un caractère d'espace suivi de "u"
10 11
> =
string.find("Hello Lua user ", "%su", 1, vrai) -- activer
les recherches simple, maintenant pas a trouvé
nil
Créez une chaîne de caractères composée et des
arguments fournis e1, e2 et respectant le format défini par formatstring. Fonction semblable à printf("format",...) en language C. Une option additionnelle %q permet la création de double guillement
autour d'une chaîne de caractères.
c, d, E, e, f, g, G, I, o, u, X, et x tous s'attendent à un nombre comme argument.
q et s attendent une chaîne de caractères.
> = string.format("%s %q", "Hello", "Lua User
!") -- chaîne de caractères et chaîne de caractères entre double guillement
Hello "Lua user!"
> = string.format("%c%c%c", 76.117.97) -- Code caratères en ASCII
Lua
> =
string.format("%e, %E", math.pi, math.pi) -- exposant
3.141593e+000,
3.141593E+000
> = string.format("%f, %g", math.pi, nombre entier
signé, signé, non signé de math.pi) -- virgule flottante
3.141593, 3.14159
> = string.format("%d, %i, %u", -100, -100,
-100 compact) -- signé, non signé
-100, -100, 4294967196
> = string.format("%o, %x,
%X", -100, -100, -100) -- octal,hexa,hexa
37777777634,
ffffff9c, FFFFFF9C
| Type | Format de la sortie |
|---|---|
| d ou i | entier décimal signé |
| o | entier octal non signé |
| u | entier décimal non signé |
| x | entier hexadécimal non signé |
| X | entier hexadécimal non signé en majuscules |
| f | réel de la forme [-]dddd.ddd |
| e | réel de la forme [-]d.ddd e [+/-]ddd |
| E | comme e mais l'exposant est la lettre E |
| g | format e ou f suivant la précision |
| G | comme g mais l'exposant est la lettre E |
| c | caractère |
| s | affiche les caractères jusqu'au caractère nul '\0' ou jusqu'à ce que la précision soit atteinte |
| p | pointeur |
Ceci renvoie un modèle trouvant l'iterator. L'iteration recherchera dans la chaînes de caractères passée la sous chaîne passée pat.
>for word in string.gmatch("Hello
Lua user ", "%a+") do print(word)
end
Hello
Lua
user
C'est une fonction très puissante qui peut être
employée de différente manières. Utilisé simplement elle
peut remplacer tous les occurence d'une sous chaîne pattern dans la chapine s.
Une paire de valeurs est retournée, les chaînes de caractères modifiée et le
nombre de substitutions faites. Le quatrième argument
facultatif n peut être employé pour limiter le nombre de
substitutions faites :
> = string.gsub("Hello banana", "banana", "LUA user")
Hello Lua user 1
> = string.gsub("banana", "a",
"A", 2) -- substitutions de limite faites 2 à la
bAnAna 2
Si une capture est employée ceci peut être mis en référence dans les chaînes de caractères de rechange en utilisant la notation %capture_index, par exemple,
> = string.gsub("banana", "()", "%1 -") --
capturent tous les occurances "d'" et les remplacent
ban-an-a 2
> =
string.gsub("banana", "a(n)", "a(%1)") -- des parenthèses autour des
n qui suivent un s
ba(n)a(n)a 2
> = string.gsub("banana", "(a)(n)",
"%2%1") -- renversent tous les "an"s
bnanaa 2 d'an"s
Si le remplacement est une
fonction et pas une chaîne de caractères, les arguments passés à la
fonction sont toutes les captures qui sont faites. Si la
fonction renvoie une chaîne de caractères, la valeur retournée est substituée de
nouveau dans les chaînes de caractères. Juste comme string.find() nous pouvons
employer des expressions régulières pour rechercher dans les chaînes de caractères .
Des exemples sont présents dans le
Patterns Tutorial.
> = string.gsub("Hello Lua user ",
"(%w+)", print) -- imprime tous les mots trouvés
Hello
Lua
user
3
> = string.gsub("Hello Lua user ",
"(%w+)", function(w) return string.len(w) end) --
remplacent par les longueurs des sous chaines
5 3 4 3
> = string.gsub("banana", "(a)",
string.upper) -- convertie les "a" en majuscule
bAnAnA 3
> =
string.gsub("banana", "(a)(n)", function(a, b) return b..a end)
-- inverse les lettres a et b
bnanaa 2
L'expression la plus courante pour une sélection serait (.-). Par exemple l'expression {(.-)}" sélectionne tous les caractères entre parenthèse {}. Une autre sélection fréquente est (. *) qui sélectionne tous les caractères entre parenthèse {} en incluant les parenthèses trouvés , deux exemples ici illustrent la différence.
> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.-)}", function(a) print(a) end )
brown
over
dog
> = string.gsub("The big {brown} fox jumped {over} the lazy {dog}.","{(.*)}", function(a) print(a) end )
brown} fox jumped {over} the lazy {dog
Renvoyez la longueur de les chaînes de caractères passée.
> = string.len("Lua")
3
> = string.len("")
0
> = string.len("Lua\000user") -- Lua strings are 8 bit pure so \000 does not terminate
8
Convertit les majuscules en minuscules
Convertit les lettres majuscules la lettre minuscule.
> = string.lower("Hello, Lua user!")
hello, lua user!
Convertit les lettres les minuscules en lettres majuscules.
> = string.upper("Hello, Lua user!")
HELLO, LUA USER!
Crée une chaîne par concaténation multiple
Crée une chaîne par concaténation multiple de la chaîne de caractères passée en argument.
> = string.rep("Lua",5)
Lua
Lua
Lua
Lua
Lua
> =
string.rep("Lua\n", 3)
Lua
Lua
Lua
Inverse une chaîne de caractères s
> = string.reverse("lua")
aul
Renvoie une sous-chaîne de caractères de la chaîne passée en argument.
Le début de sous-chaîne est précisé par i. Si le
troisième argument j n'est pas donné, la sous-chaîne
finira à l'extrémité de les chaînes de caractères. Si le troisième argument
est donné, la sous-chaîne finit à et inclut j.
> = string.sub("Hello Lua user", 7) -- from character 7 until the end
Lua user
> = string.sub("Hello Lua user", 7, 9) -- from character 7 until and including 9
Lua
> = string.sub("Hello Lua user", -8) -- 8 from the end until the end
Lua user
> = string.sub("Hello Lua user", -8, 9) -- 8 from the end until 9 from the start
Lua
> = string.sub("Hello Lua user", -8, -6) -- 8 from the end until 6 from the end
Lua
 www.loriotpro.com |
|