Chaînes Lua

A string or string (String) is a sequence of characters consisting of numbers, letters, and underscores.

In Lua, strings can be represented in the following three ways:

• A sequence of characters between single quotes.

• A sequence of characters between double quotes.

• [[ With ]] is a sequence of characters.

The following are examples of the three ways of string representation:

string1　= "Lua"
print("\"string"　1　Is		"",string1)
string2　= 'oldtoolbag.com'
print("string"　2　Is		"string"2)
string3　= [["Lua Tutorial"]]
print("string"　3　Is		"string"3)

The output result of the above code is:

"String"　1　Is		"Lua"
字符串　2　Is		oldtoolbag.com
字符串　3　Is		"Lua Tutorial"

Escape characters are used to represent characters that cannot be displayed directly, such as the backspace key, enter key, etc. For example, in string conversion, double quotes can be used as "\"".

All escape characters and their meanings:

opérations sur les chaînes de caractères

Lua offre de nombreux méthodes pour soutenir les opérations sur les chaînes de caractères :

> string.gsub("aaaa","a","z",3);
zzza　　　　3

> string.find("Hello　Lua　user",　"Lua",　1)　
7　　　　9

> string.reverse("Lua")
auL

> string.format("la valeur est:%d",4)
la valeur est :4

> string.char(97,98,99,100)
abcd
> string.byte("ABCD",4)
68
> string.byte("ABCD")
65
>

string.len("abc")
3

> string.rep("abcd",2)
abcdabcd

> print("www.w3codebox.".."com"
fr.oldtoolbag.com

> for word in string.gmatch("Hello Lua user", "%a+") do print(word) end
Hello
Lua
user

> = string.match("I have　2　questions for you., "%d+　%a+")
2　questions
> = string.format("%d, %q", string.match("I have　2　questions for you., "(%d+) (%a+)"))
2, "questions"

字符串截取

字符串截取使用 sub() 方法。

string.sub() 用于截取字符串，原型为：

string.sub(s, i[, j])

参数说明：

• s：要截取的字符串。

• i：截取开始位置。

• j：截取结束位置，默认为 -1，最后一个字符。

--　字符串
local sourcestr = "prefix--w3codeboxgoogletaobao--suffix"
print("\n原始字符串", string.format("%q", sourcestr))
--　截取部分，第1个到第15
local first_sub = string.sub(sourcestr,　4,　15)
print("\n第一次截取", string.format("%q", first_sub))
--　取字符串前缀，第1个到第8
local second_sub = string.sub(sourcestr,　1,　8)
print("\nDeuxième coupure",　string.format("%q",　second_sub))
--　Couper le dernier10
local　third_sub　=　string.sub(sourcestr,　-10)
print("\nTroisième coupure",　string.format("%q",　third_sub))
--　
local　fourth_sub　=　string.sub(sourcestr,　-100)
print("\nQuatrième coupure",　string.format("%q",　fourth_sub))

以上代码执行结果为：

Chaîne originale　　　　"prefix--w3codeboxgoogletaobao--suffix"
Première coupure　　　　"fix--w3codeboxg"
Deuxième coupure　　　　"prefix--"
Troisième coupure　　　　"ao--suffix"
Quatrième coupure　　　　"prefix--w3codeboxgoogletaobao--suffix"

Conversion de casse de chaîne

Les exemples suivants montrent comment convertir la casse des chaînes de caractères:

string1　=　"Lua";
print(string.upper(string1))
print(string.lower(string1))

以上代码执行结果为：

LUA
lua

Recherche et renversement de chaîne

Les exemples suivants montrent comment effectuer des opérations de recherche et de renversement sur les chaînes de caractères:

string　=　"Lua　Tutorial"
--　Recherche de chaîne
print(string.find(string,"Tutorial"))
reversedString　=　string.reverse(string)
print("La nouvelle chaîne est",reversedString)

以上代码执行结果为：

5　　　　12
La nouvelle chaîne est　　　　lairotuT　auL

Formatage de chaîne

Lua fournit la fonction string.format() pour générer des chaînes de caractères avec un format spécifique, le premier paramètre est le format, suivi des données correspondantes à chaque code du format.

Grâce à la présence de la chaîne de format, la lisibilité des chaînes de caractères longues est considérablement améliorée. La fonction de format ressemble beaucoup à printf() en C.

Les exemples suivants montrent comment formatter une chaîne de caractères:

La chaîne de format peut contenir les codes d'échappement suivants:

• %c - Accepter un nombre et le convertir en le caractère correspondant dans le tableau ASCII

• %d, %i - Accepter un nombre et le convertir en format nombre entier signé

• %o - Accepter un nombre et le convertir en format octal

• %u - 接受一个数字并将其转化为无符号整数格式

• accepte un nombre et le transforme en format de nombre entier non signé - %x

• accepte un nombre et le transforme en format de nombre hexadécimal, en utilisant des lettres minuscules - %X

• accepte un nombre et le transforme en format de nombre hexadécimal, en utilisant des lettres majuscules - %e

• accepte un nombre et le transforme en format de nombre en exposant scientifique, en utilisant des lettres minuscules e - %E

• accepte un nombre et le transforme en format de nombre en exposant scientifique, en utilisant des lettres majuscules E - %f

• accepte un nombre et le transforme en format de nombre flottant - %g(%G)

• accepte un nombre et le transforme en un format plus court de %e (%E, correspondant à %G) - %q

• accepte une chaîne et la transforme en un format sécurisé pour être lu par le compilateur Lua - %s

accepte une chaîne et la formate selon le format donné

• (1) pour affiner davantage le format, il est possible d'ajouter des paramètres après le % . Les paramètres seront lus dans l'ordre suivant :+) symbole : un

• (2) caractère de remplacement : un 0, utilisé comme remplacement lorsque la largeur de la chaîne est spécifiée. Le remplacement par défaut est un espace si il n'est pas rempli.

• (3) indicateur d'alignement : par défaut, il est aligné à droite lorsque la largeur de la chaîne est spécifiée, augmenter-) peut être modifié pour aligner à gauche.

• (4) nombre de largeur

• (5) nombre de décimales/Coupe de chaîne : après le nombre de largeur, le nombre décimal supplémentaire n, si il est suivi de f (déflecteur de nombre flottant, comme %6.3f) alors la virgule décimale du nombre flottant est définie pour conserver n chiffres, si elle est suivie de s (déflecteur de chaîne, comme %5.3s) alors la chaîne est définie pour afficher uniquement les n premiers caractères.

string1　= "Lua"
string2　= "Tutorial"
number1　=　10
number2　=　20
--　Formatage de base de chaîne
print(string.format("Formatage de base %s %s",string1,string2))
--　Formatage de date
date =　2; mois =　1; an =　2014
print(string.format("Formatage de date %02d/%02d/%03d", date, mois, an))
--　Formatage décimal
print(string.format("%.",4f",1/3))

以上代码执行结果为：

Formatage de base Lua Tutorial
Formatage de date 02/01/2014
0.3333

Autres exemples :

string.format("%c",　83)　　　　　　　　　　　　　　　　　--　sortie S
string.format("%",+d",　17.0)　　　　　　　　　　　　　　--　输出+17
string.format("%05d",　17)　　　　　　　　　　　　　　　--　sortie 00017
string.format("%o",　17)　　　　　　　　　　　　　　　　　--　输出21
string.format("眻,　3.14)　　　　　　　　　　　　　　　--　输出3
string.format("%x",　13)　　　　　　　　　　　　　　　　　--　sortie d
string.format("%X",　13)　　　　　　　　　　　　　　　　　--　输出D
string.format("%e",　1000)　　　　　　　　　　　　　　　--　输出1.000000e+03
string.format("%E",　1000)　　　　　　　　　　　　　　　--　输出1.000000E+03
string.format("%",6.3f",　13)　　　　　　　　　　　　　　--　输出13.000
string.format("%q", "One\nTwo")　　　　　　　　　--　输出"One\
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--　　　Two"
string.format("%s", "monkey")　　　　　　　　　　　--　输出monkey
string.format("%",10s, "monkey")　　　　　　　　　--　输出　　monkey
string.format("%",5.3s, "monkey")　　　　　　　　--　输出　　mon

字符与整数相互转换

以下示例演示了字符与整数相互转换：

--　字符转换
--　转换第一个字符
print(string.byte("Lua"))
--　转换第三个字符
print(string.byte("Lua",3))
--　转换末尾第一个字符
print(string.byte("Lua",-1))
--　第二个字符
print(string.byte("Lua",2))
--　转换末尾第二个字符
print(string.byte("Lua",-2))
--　整数　ASCII　码转换为字符
print(string.char(97))

以上代码执行结果为：

76
97
97
117
117
a

其他常用函数

以下示例演示了其他字符串操作，如计算字符串长度，字符串连接，字符串复制等：

string1　= "www."
string2　= "w"3codebox
string3　= ".com"
--　使用　..　进行字符串连接
print("连接字符串 " ,string1..string2..string3)
--　字符串长度
print("字符串长度 " ,string.len(string2))
--　字符串复制　2　次
repeatedString = string.rep(string2,2)
print(repeatedString)

以上代码执行结果为：

连接字符串　　fr.oldtoolbag.com
字符串长度　　　　　5
w3codeboxw3codebox

匹配模式

Lua 中的匹配模式直接用常规的字符串来描述。 它用于模式匹配函数 string.find, string.gmatch, string.gsub, string.match.

你还可以在模式串中使用字符类。

字符类指可以匹配一个特定字符集合内任何字符的模式项。比如，字符类 %d 匹配任意数字。所以你可以使用模式串 %d%d/%d%d/%d%d%d%d 搜索 dd/mm/yyyy 格式的日期：

s = "Deadline is　30/05/1999, firm"
date = "%d%d/%d%d/%d%d%d%d"
print(string.sub(s, string.find(s, date)))　　　　-->　30/05/1999

Le tableau suivant liste toutes les catégories de caractères prises en charge par Lua :

Un caractère unique (sauf ^$()%.[]*+-? Extérieur): Correspond avec ce caractère lui-même.

• (Point): Correspond avec n'importe quel caractère.

• %a: Correspond avec n'importe quel caractère alphabétique.

• %c: Correspond avec n'importe quel caractère de contrôle (par exemple \n).

• %d: Correspond avec n'importe quel chiffre.

• %l: Correspond avec n'importe quel caractère en minuscule.

• %p: Correspond avec n'importe quel caractère de ponctuation.

• %s: Correspond avec n'importe quel caractère blanc.

• ᧸rrespond avec n'importe quel caractère en majuscule.

• %w: Correspond avec n'importe quel caractère alphabétique./Numérique correspondant

• %x: Correspond avec n'importe quel nombre hexadécimal.

• %z: Correspond avec n'importe quel caractère représentant zéro.

• %x(ici x est un caractère non alphabétique non numérique): Correspond avec le caractère x. Utilisé principalement pour traiter les caractères fonctionnels dans l'expression (^$()%.[])*+-?) problèmes de correspondance, par exemple %% correspond à %

• [catégorie de caractères]: Correspond avec n'importe quel caractère inclus dans []. Par exemple, [%w_] correspond à n'importe quel caractère alphabétique./Numérique, ou le symbole de soulignement (_) correspond.

• [^catégorie de caractères]: Correspond avec n'importe quel caractère ne faisant pas partie de la catégorie incluse dans []. Par exemple, [^%s] correspond à n'importe quel caractère non blanc.

Lorsque les catégories de caractères sont écrites en majuscules, elles représentent un correspondance avec n'importe quel caractère ne faisant pas partie de cette catégorie. Par exemple, %S correspond à n'importe quel caractère non blanc. Par exemple, '%A' correspond à n'importe quel caractère non alphabétique :

>　print(string.gsub("hello,　up-down!"", "%A", ".")
hello..up.down.　　　　4

Numérique4Ne fait pas partie du résultat de la chaîne, c'est le deuxième résultat retourné par gsub, représentant le nombre de remplacements effectués.

Dans la correspondance de modèle, certains caractères spéciaux ont des significations spéciales, voici les caractères spéciaux dans Lua :

(　)　.　%　+　-　*　?　[　^　$

'%' est utilisé comme caractère d'échappement pour les caractères spéciaux, donc '%.' correspond à un point ; '%%' correspond au caractère '%'. Le caractère d'échappement '%' peut non seulement être utilisé pour échapper aux caractères spéciaux, mais aussi pour tous les caractères non alphabétiques.

Les entrées de modèle peuvent être :

• Une catégorie de caractères unique correspond à n'importe quel caractère de cette catégorie.

• Une catégorie de caractères unique suivie d'un '*', Il correspondra à zéro ou plusieurs caractères de cette catégorie. Cette entrée correspond toujours à la plus longue chaîne possible;

• Une catégorie de caractères unique suivie d'un '+', Il correspondra à un ou plusieurs caractères de cette catégorie. Cette entrée correspond toujours à la plus longue chaîne possible;

• Une catégorie de caractères unique suivie d'un '-', Il correspondra à zéro ou plusieurs caractères de cette catégorie. et '*Différent de ' Cette entrée correspond toujours à la plus courte chaîne possible;

• Une catégorie de caractères unique suivie d'un '? Il correspondra à zéro ou un caractère de cette catégorie. S'il est possible, il correspondra à un ;

• %n, xy n Il peut provenir de 1 à 9; Cette entrée correspond à une égale n Sous-chaîne de l'objet capturé (décrit ci-après).

• %b, xy x et y Ici Sont deux caractères distincts ; x Cette entrée correspond à y Commence Se termine x et y Et parmi eux Maintenir Conserver Cela signifie que si on lit cette chaîne de gauche à droite, on lit unex Est +1 Lecture d'un y Est -1, Celui qui se termine finalement y Est le premier à compter à 0 y. Par exemple, l'entrée %b() peut correspondre à une expression d'expression entre parenthèses équilibrées.

• set] C'est Modèle de frontière; Cette entrée correspondra à une position située set Une chaîne vide avant un caractère dans Et ce caractère précédent n'appartient pas à set . Ensemble set Signification comme décrit précédemment. Le calcul du début et de la fin de la chaîne vide correspondante est traité comme s'il y avait un caractère '\0' est pareil.

Modèle :

Modèle C'est une séquence d'éléments de modèle. Ajouter le symbole '^' au début du modèle ancre le processus de correspondance à partir du début de la chaîne. Ajouter le symbole '$' à la fin du modèle rend le processus de correspondance ancré à la fin de la chaîne. Si '^' et '$' apparaissent à d'autres endroits, ils n'ont pas de sens spécial, ils représentent simplement eux-mêmes.

Capture :

Un modèle peut utiliser des parenthèses parenthèses pour encadrer un sous-modele interne ; Ces sous-modes sont appelés Captures. Lorsque la correspondance est réussie, par Captures Les sous-chaînes correspondantes sont sauvegardées pour une utilisation future. Les captures sont numérotées suivant l'ordre de leurs parenthèses gauche. Par exemple, pour le modèle "(a*(.)%w(%s*))", La chaîne correspondante à "a*(.)%w(%s*)" de la partie est conservé dans la première capture (par conséquent, c'est le numéro 1 ); Les caractères correspondant à "." sont 2 N° de capture, correspondant à "%s*La partie après "" est 3 N°.

En tant que cas particulier, une capture vide () capturera la position actuelle de la chaîne (c'est un nombre). Par exemple, si le modèle "()aa()" est appliqué à la chaîne "flaaap", il produira deux captures : 3 et 5 .