Stringhe di Lua

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

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

• A series of characters between single quotes.

• A series of characters between double quotes.

• [[ and ]] A series of characters between

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", string2)
string3 = [["Lua Tutorial"]]
print("String 3 is", string3)

The output result of the above code is:

"String 1 is"		Lua
String 2 is		oldtoolbag.com
String 3 is		"Lua Tutorial"

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

All escape characters and their meanings:

Operazioni di stringa

Lua fornisce molti metodi per supportare le operazioni di stringa:

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

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

>　string.reverse("Lua")
auL

>　string.format("il valore è:%d",4)
il valore è: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")
it.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"

Estrazione di stringhe

Estrazione di stringhe utilizzando il metodo sub()

string.sub() è usato per estrarre stringhe, la sua firma è:

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

Spiegazione dei parametri:

• s: stringa da estrarre.

• i: posizione di fine della sezione da estrarre.

• j: posizione di inizio della sezione da estrarre, predefinita a -1, l'ultimo carattere.

-- Stringa
local sourcestr = "prefix--w3codeboxgoogletaobao--suffix"
print("\nStringa originale", string.format("%q", sourcestr))
--　Estrazione parziale, dal primo al quindicesimo
local　first_sub　=　string.sub(sourcestr,　4,　15)
print("\nPrima estrazione",　string.format("%q",　first_sub))
--　Prendere il prefisso della stringa, dal primo al第八个
local　second_sub　=　string.sub(sourcestr,　1,　8)
print("\nSeconda estrazione",　string.format("%q",　second_sub))
--　Estrazione degli ultimi 10
local　third_sub　=　string.sub(sourcestr,　-10)
print("\nTerza estrazione",　string.format("%q",　third_sub))
--　Indice fuori dai limiti, output della stringa originale
local　fourth_sub　=　string.sub(sourcestr,　-100)
print("\nQuarta estrazione",　string.format("%q",　fourth_sub))

Il risultato dell'esecuzione del codice sopra è:

Stringa originale　　　　"prefix--w3codeboxgoogletaobao--suffix"
Prima estrazione　　　　"fix--w3codeboxg"
Seconda estrazione　　　　"prefix--"
Terza estrazione　　　　"ao--suffix"
Quarta estrazione　　　　"prefix--w3codeboxgoogletaobao--suffix"

Conversione delle maiuscole e minuscole delle stringhe

Esempio seguente dimostra come convertire la maiuscolizzazione delle stringhe:

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

Il risultato dell'esecuzione del codice sopra è:

LUA
lua

Ricerca e inversione delle stringhe

Esempio seguente dimostra come cercare e invertire una stringa:

string　=　"Lua　Tutorial"
--　Ricerca della stringa
print(string.find(string,"Tutorial"))
reversedString　=　string.reverse(string)
print("La nuova stringa è",reversedString)

Il risultato dell'esecuzione del codice sopra è:

5　　　　12
La nuova stringa è　　　　lairotuT　auL

String formatting

Lua provides the string.format() function to generate strings with a specific format, where the first parameter is the format, followed by various data corresponding to each code in the format.

Due to the presence of the format string, the readability of the generated long string is greatly improved. The format of this function is very similar to that of the C language printf().

The following examples demonstrate how to perform string formatting operations:

The format string may contain the following escape codes:

• %c - Accepts a number and converts it into the corresponding character in the ASCII code table

• %d, %i - Accepts a number and converts it into signed integer format

• %o - Accepts a number and converts it into octal number format

• 蒚ccepts a number and converts it into unsigned integer format

• %x - Accepts a number and converts it into hexadecimal number format, using lowercase letters

• %X - Accepts a number and converts it into hexadecimal number format, using uppercase letters

• %e - Accepts a number and converts it into scientific notation format, using lowercase letter e

• %E - Accepts a number and converts it into scientific notation format, using uppercase letter E

• %f - Accepts a number and converts it into floating-point number format

• %g(%G) - Accepts a number and converts it into the shorter format of %e(%E, corresponding to %G) and %f

• %q - Accepts a string and converts it into a format that can be safely read by the Lua compiler

• %s - Accepts a string and formats it according to the given parameters

To further refine the format, parameters can be added after the % sign. The parameters will be read in the following order:

• (1) Symbol: A plus sign indicates that the number escape character after it will display the positive sign for positive numbers. By default, only negative numbers display the sign.

• (2) Placeholder: A zero, used as a placeholder when the string width is specified. The default placeholder when not specified is a space.

• (3) Alignment identifier: When the string width is specified, the default is right-aligned; adding a minus sign can be changed to left-aligned.

• (4) Width value

• (5) Decimal places/substring cutting: The decimal part n added after the width value, if followed by f(float escape character, such as %6.3f), then the decimal part of the floating-point number is set to retain only n places; if followed by s(string escape character, such as %5.3s), then the string is set to display only the first n characters.

string1 = "Lua"
string2 = "Tutorial"
number1 = 10
number2 = 20
-- Base string formatting
print(string.format("Basic formatting \t%s \t%s", string1, string2))
--　Formattazione della data
date = 2; month = 1; year = 2014
print(string.format("Formattazione della data　%02d/%02d/%03d", date, month, year))
--　Decimal format
print(string.format("%.4f", 1/3))

Il risultato dell'esecuzione del codice sopra è:

Formattazione di base Lua Tutorial
Formattazione della data 02/01/2014
0.3333

Altri esempi:

string.format("%c", 83)　　　　　　　　　　　　　　　　　--　OutputS
string.format("%+d", 17.0)　　　　　　　　　　　　　　--　Output+17
string.format("%05d", 17)　　　　　　　　　　　　　　　--　Output00017
string.format("%o", 17)　　　　　　　　　　　　　　　　　--　Output21
string.format("眻, 3.14)　　　　　　　　　　　　　　　--　Output3
string.format("%x", 13)　　　　　　　　　　　　　　　--　Outputd
string.format("%X", 13)　　　　　　　　　　　　　　　--　OutputD
string.format("%e", 1000)　　　　　　　　　　　　　　　--　Output1.000000e+03
string.format("%E", 1000)　　　　　　　　　　　　　　　--　Output1.000000E+03
string.format("%6.3f", 13)　　　　　　　　　　　　　　--　Output13.000
string.format("%q", "One\nTwo")　　　　　　　　　--　Output"One\
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--　　　Two"
string.format("%s", "monkey")　　　　　　　　　　　--　Outputmonkey
string.format("%10s", "monkey")　　　　　　　　　--　Output　　　　monkey
string.format("%5.3s", "monkey")　　　　　　　　--　Output　　mon

Conversione tra caratteri e interi

Esempio di conversione tra caratteri e interi:

--　字符转换
-- Conversione del primo carattere
print(string.byte("Lua"))
-- Conversione del terzo carattere
print(string.byte("Lua", 3))
-- Conversione del primo carattere alla fine
print(string.byte("Lua", -1))
-- Secondo carattere
print(string.byte("Lua", 2))
-- Conversione del secondo carattere alla fine
print(string.byte("Lua", -2))
-- Conversione del codice ASCII intero in carattere
print(string.char(97))

Il risultato dell'esecuzione del codice sopra è:

76
97
97
117
117
a

Altre funzioni comuni

Di seguito è riportato un esempio che dimostra altre operazioni sugli stringhe, come calcolare la lunghezza della stringa, concatenare stringhe, copiare stringhe, ecc.:

string1 = "www."
string2 = "w3codebox"
string3 = ".com"
-- Utilizzo di .. per concatenare stringhe
print("Concatenazione di stringhe ", string1..string2..string3)
-- Lunghezza della stringa
print("Lunghezza della stringa ", string.len(string2))
-- Copia della stringa 2 volte
repeatedString = string.rep(string2, 2)
print(repeatedString)

Il risultato dell'esecuzione del codice sopra è:

Concatenazione di stringhe                  it.oldtoolbag.com
Lunghezza della stringa                   5
w3codeboxw3codebox

Modelli di corrispondenza

I modelli di corrispondenza in Lua sono descritti direttamente con stringhe normali. Sono usati dalle funzioni di corrispondenza di modello string.find, string.gmatch, string.gsub, string.match.

Puoi anche usare i tipi di carattere nella stringa di modello.

Un tipo di carattere è un oggetto che può corrispondere a qualsiasi carattere all'interno di un insieme di caratteri specifici. Ad esempio, il tipo di carattere %d Corrisponde a qualsiasi numero. Quindi puoi usare la stringa di modello %d%d/%d%d/%d%d%d%d per cercare dd/mm/yyyy Formato della data:

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

La seguente tabella elenca tutti i tipi di caratteri supportati da Lua:

Un singolo carattere (eccetto}} ^$()%.[]*+-? ). Con il carattere stesso.

• .(punto): Corrisponde a qualsiasi carattere.

• %a: Corrisponde a qualsiasi lettera.

• %c: Corrisponde a qualsiasi carattere di controllo (ad esempio \n).

• %d: Corrisponde a qualsiasi numero.

• %l: Corrisponde a qualsiasi lettera minuscola.

• %p: Corrisponde a qualsiasi carattere di punteggiatura.

• %s: Corrisponde a qualsiasi carattere bianco.

• ᧸rrisponde a qualsiasi lettera maiuscola.

• %w: Corrisponde a qualsiasi lettera/numero.

• %x: Corrisponde a qualsiasi numero esadecimale.

• %z: Corrisponde a qualsiasi carattere che rappresenta 0.

• %x(qui x è un carattere non letterale o numerico): Corrisponde al carattere x. Mainmente usato per risolvere problemi di combinazione di caratteri funzionali nell'espressione (^$()%.[]*+-?). Ad esempio, %% corrisponde a %.

• [characteri di classe]: Corrisponde a qualsiasi carattere incluso in []. Ad esempio, [%w_] corrisponde a qualsiasi lettera/numero o simbolo di sottolineatura (_).

• [^characteri di classe]: Corrisponde a qualsiasi carattere non incluso in []. Ad esempio, [^%s] corrisponde a qualsiasi carattere non bianco.

Quando i caratteri di classe sono scritti in maiuscolo, rappresentano una combinazione con qualsiasi carattere non della classe. Ad esempio, %S corrisponde a qualsiasi carattere non bianco. Ad esempio, '%A' corrisponde a qualsiasi carattere non letterale:

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

Il numero 4 non fa parte del risultato della stringa, è il secondo risultato restituito da gsub, che rappresenta il numero di sostituzioni effettuate.

In una corrispondenza di modello ci sono alcuni caratteri speciali che hanno un significato speciale, i caratteri speciali in Lua sono i seguenti:

(　)　.　%　+　-　*　?　[　^　$

'%' è usato come carattere di escape per i caratteri speciali, quindi '%.' corrisponde al punto; '%%' corrisponde al carattere '%'. Il carattere di escape '%' può essere usato non solo per i caratteri speciali, ma anche per tutti i caratteri non letterali.

Un voce di modello può essere:

• Una classe di caratteri corrisponde a qualsiasi singolo carattere della classe;

• Una classe di caratteri seguita da un '*', Corrisponderà a zero o più di questa classe di caratteri. Questa voce corrisponde sempre alla stringa più lunga possibile;

• Una classe di caratteri seguita da un '+', Corrisponderà a uno o più di questa classe di caratteri. Questa voce corrisponde sempre alla stringa più lunga possibile;

• Una classe di caratteri seguita da un '-', Corrisponderà a zero o più di questa classe di caratteri. Diversamente da '*', Questa voce corrisponde sempre alla stringa più corta possibile;

• Una classe di caratteri seguita da un '?', Corrisponderà a zero o a uno di questa classe di caratteri. Se possibile, corrisponderà a uno;

• %n, Questa n può essere da 1 a 9; Questa voce corrisponde a un valore uguale a n sottostringa del capturo (descritto dopo).

• %bxy, Questa x e y Sono due caratteri chiari; Questa voce corrisponde a x e y e e x e y mantenere bilanciato stringa. significa che, leggendo la stringa da sinistra a destra, per ogni lettura di unx è +1 e, leggere un y è -1, e il punto finale y è il primo contatore che arriva a 0 y. Facciamo un esempio, la voce %b() può corrispondere a un'espressione di parentesi bilanciate.

• %f[set] Rappresenta 边境模式; Questa voce corrisponderà a una posizione situata set un carattere prima di uno在内的某个字符之前的一个空串， e questa posizione non appartiene a set . insieme set Il significato è come descritto sopra. Il calcolo dell'inizio e della fine della stringa vuota trovata è considerato come se ci fosse un carattere '\0' allo stesso modo.

Modello:

Modello Rappresenta una sequenza di entry di modello. Aggiungendo il simbolo '^' all'inizio del modello, il processo di match viene ancorato dall'inizio della stringa. Aggiungendo il simbolo '$' alla fine del modello, il processo di match viene ancorato alla fine della stringa. Se '^' e '$' appaiono in altre posizioni, non hanno significato speciale, rappresentano solo sé stessi.

Cattura:

Un modello può racchiudere un sottomodello con parentesi quadre all'interno; Questi sottomodelli sono chiamati Catture. Quando il match è riuscito, da Catture Le sottostringhe corrispondenti trovate vengono salvate per uso futuro. Le catture sono numerate in base all'ordine dei loro parentesi aperti. Ad esempio, per il modello "(a*(.)%w(%s*))", La parte della stringa che corrisponde a "a*(.)%w(%s*)" viene salvata nella prima cattura (quindi è la cattura numero 1); Il carattere corrispondente a "." è la cattura numero 2, La parte corrispondente a "%s*" è la cattura numero 3.

Come eccezione, una cattura vuota () catturerà la posizione attuale della stringa (è un numero). Ad esempio, se si applica il modello "()aa()" alla stringa "flaaap", si genereranno due catture: 3 e 5 .