Strings do 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"
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, enter key, etc. For example, in string conversion, double quotes can be used as "\"".

All escape characters and their meanings:

operações de strings

Lua oferece muitos métodos para suportar operações de strings:

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

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

> string.reverse("Lua")
auL

> string.format("o valor é:%d",4)
o valor é: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")
pt.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"

String cutting

String cutting uses the sub() method.

string.sub() is used to cut the string, the prototype is：

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

参数说明：

• s：要截取的字符串。

• i：截取开始位置。

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

--　string
local sourcestr = "prefix--w3codeboxgoogletaobao--sufixo"
print("\nOriginal string", string.format("%q", sourcestr))
--　cut part, the1from the character15última
local first_sub = string.sub(sourcestr,　4,　15)
print("\nFirst cut", string.format("%q", first_sub))
--　to get the prefix of the string, the1from the character8última
local second_sub = string.sub(sourcestr,　1,　8)
print("\nSegunda extração", string.format("%q", second_sub))
--　cortar10última
local third_sub = string.sub(sourcestr,　-10)
print("\nTerceira extração", string.format("%q", third_sub))
--　Excedente de índice, saída da string original
local fourth_sub = string.sub(sourcestr,　-100)
print("\nQuarta extração", string.format("%q", fourth_sub))

O resultado da execução do código acima é:

String original:     "prefix--w3codeboxgoogletaobao--sufixo"
Primeira extração:     "fix--w3codeboxg"
Segunda extração:     "prefix--"
Terceira extração:     "ao--sufixo"
Quarta extração:     "prefix--w3codeboxgoogletaobao--sufixo"

Conversão de capitalização de string

Os seguintes exemplos demonstram como converter a capitalização de strings:

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

O resultado da execução do código acima é:

LUA
lua

Busca e inversão de string

Os seguintes exemplos demonstram como realizar operações de busca e inversão de strings:

string = "Lua Tutorial"
--　Procurar string
print(string.find(string,"Tutorial"))
reversedString = string.reverse(string)
print("A nova string é", reversedString)

O resultado da execução do código acima é:

5　　　　12
A nova string é:     lairotuT  auL

Formatação de string

Lua fornece a função string.format() para gerar strings com formato específico, onde o primeiro parâmetro é o formato e os dados correspondem a cada código de formato.

Devido à existência da string de formatação, a leitura da string longa resultante é significativamente melhorada. A forma dessa função é semelhante à da função printf() do linguagem C.

Os seguintes exemplos demonstram como formatar strings:

A string de formatação pode conter os seguintes códigos de escape:

• %c - Aceita um número e o converte para o caractere correspondente na tabela ASCII

• %d, %i - Aceita um número e o converte para o formato de inteiro assinado

• %o - Aceita um número e o converte para o formato de número octal

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

• %x - 接受一个数字并将其转化为十六进制数格式, 使用小写字母

• %X - 接受一个数字并将其转化为十六进制数格式, 使用大写字母

• %e - 接受一个数字并将其转化为科学记数法格式, 使用小写字母e

• %E - 接受一个数字并将其转化为科学记数法格式, 使用大写字母E

• %f - 接受一个数字并将其转化为浮点数格式

• %g(%G) - 接受一个数字并将其转化为%e(%E, 对应%G)及%f中较短的一种格式

• %q - 接受一个字符串并将其转化为可安全被Lua编译器读入的格式

• %s - 接受一个字符串并按照给定的参数格式化该字符串

为进一步细化格式, 可以在%号后添加参数. 参数将以如下的顺序读入:

• (1) 符号: 一个+) 号表示其后的数字转义符将让正数显示正号. 默认情况下只有负数显示符号.

• (2) 占位符: 一个0, 在后面指定了字串宽度时占位用. 不填时的默认占位符是空格.

• (3) 对齐标识: 在指定了字串宽度时, 默认为右对齐, 增加-号可以改为左对齐.

• (4) 宽度数值

• (5) 小数位数/字串裁切: 在宽度数值后增加的小数部分n, 若后接f(浮点数转义符, 如%6.3f)则设定该浮点数的小数只保留n位, 若后接s(字符串转义符, 如%5.3s)则设定该字符串只显示前n位.

string1　=　"Lua"
string2　=　"Tutorial"
number1　=　10
number2　=　20
--　基本字符串格式化
print(string.format("基本格式化　%s　%s",string1,string2)
--　日期格式化
date　=　2;　month　=　1;　year　=　2014
print(string.format("日期格式化　%02d/%02d/%03d",　date,　month,　year))
--　十进制格式化
print(string.format("%.4f",1/3)

O resultado da execução do código acima é:

基本格式化　Lua　Tutorial
日期格式化　02/01/2014
0.3333

其他实例：

string.format("%c",　83)　　　　　　　　　　　　　　　　　--　输出S
string.format("%",+d",　17.0)　　　　　　　　　　　　　　--　Saída+17
string.format("%05d",　17)　　　　　　　　　　　　　　　--　输出00017
string.format("%o",　17)　　　　　　　　　　　　　　　　　--　Saída21
string.format("眻,　3.14)　　　　　　　　　　　　　　　--　Saída3
string.format("%x",　13)　　　　　　　　　　　　　　　　　--　输出d
string.format("%X",　13)　　　　　　　　　　　　　　　　　--　Saída D
string.format("%e",　1000)　　　　　　　　　　　　　　　--　Saída1.000000e+03
string.format("%E",　1000)　　　　　　　　　　　　　　　--　Saída1.000000E+03
string.format("%",6.3f",　13)　　　　　　　　　　　　　　--　Saída13.000
string.format("%q", "One\nDois")　　　　　　　　　--　Saída "Um\
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--　　　"Dois"
string.format("%s", "macaco")　　　　　　　　　　　--　Saída macaco
string.format("%",10s", "macaco")　　　　　　　　　--　Saída
string.format("%",5.3s", "macaco")　　　　　　　　--　Saída

Conversão mútua entre caractere e inteiro

A seguir, alguns exemplos demonstram a conversão mútua entre caractere e inteiro:

--　Conversão de caractere
--　Conversão do primeiro caractere
print(string.byte("Lua"))
--　Conversão do terceiro caractere
print(string.byte("Lua",3)
--　Conversão do primeiro caractere no final
print(string.byte("Lua",-1)
--　Segundo caractere
print(string.byte("Lua",2)
--　Conversão do segundo caractere no final
print(string.byte("Lua",-2)
--　Conversão de código ASCII de inteiro para caractere
print(string.char(97)

O resultado da execução do código acima é:

76
97
97
117
117
a

Funções comuns

A seguir, alguns exemplos demonstram outras operações de strings, como cálculo do tamanho da string, conexão de strings, cópia de strings, etc.:

string1　= "www."
string2　= "w"3codebox"
string3　= ".com"
--　usando .. para conectar strings
print("Conexão de strings",string1..string2..string3)
--　Tamanho da string
print("Tamanho da string",string.len(string2)
--　Cópia de string　2　vezes
repeatedString = string.rep(string2,2)
print(repeatedString)

O resultado da execução do código acima é:

Conexão de strings pt.oldtoolbag.com
Tamanho da string　　　　　5
w3codeboxw3codebox

Padrão de correspondência

Os padrões de correspondência no Lua são descritos diretamente por strings normais. Eles são usados nas funções de correspondência de padrão string.find, string.gmatch, string.gsub, string.match.

Você também pode usar classes de caracteres na sequência de padrão.

Um item de padrão de classe de caracteres pode coincidir com qualquer caractere dentro de um conjunto específico de caracteres. Por exemplo, a classe de caracteres %d Coincidiu com qualquer número. Portanto, você pode usar a sequência de padrão %d%d/%d%d/%d%d%d%d Pesquisa dd/mm/aaaa Formatação da 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

A tabela a seguir lista todas as classes de caracteres suportadas pelo Lua:

Um caractere (exceto ^$()%.[]*+-? Fora): Combina com o caractere próprio

• (Ponto): Combina com qualquer caractere

• %a: Combina com qualquer letra

• %c: Combina com qualquer caractere de controle (por exemplo \n)

• %d: Combina com qualquer número

• %l: Combina com qualquer letra minúscula

• %p: Combina com qualquer pontuação (punctuation)

• %s: Combina com caracteres de espaço em branco

• ᧸mbina com qualquer letra maiúscula

• %w: Combina com qualquer letra/Números

• %x: Combina com qualquer número hexadecimal

• %z: Combina com qualquer caractere que representa 0

• %x(onde x é um caractere não alfabético não numérico): Combina com o caractere x. Principalmente usado para lidar com caracteres funcionais no expressão (^$()%.[]*+-?) problemas de combinação, por exemplo, %% combina com %

• [classe de caracteres]: Combina com qualquer caractere que está contido em []. Por exemplo, [%w_] combina com qualquer letra/Números, ou o sinal de sublinhado (_).

• [^classe de caracteres]: Combina com qualquer caractere que não está contido em []. Por exemplo, [^%s] combina com qualquer caractere não branco

Quando os classes de caracteres são escritos em maiúsculas, eles representam uma combinação com qualquer caractere não da classe. Por exemplo, %S representa uma combinação com qualquer caractere não branco. Por exemplo, '%A' não é um caractere alfabético:

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

Números4Não faz parte do resultado da string, é o segundo resultado retornado pelo gsub, representando a vez de substituição ocorrida.

Existem alguns caracteres especiais no ajuste de padrão, que têm significados especiais. Os caracteres especiais no Lua são os seguintes:

(　)　.　%　+　-　*　?　[　^　$

'%' usado como caractere de escape para caracteres especiais, portanto '%.' coincide com o ponto; '%%' coincide com o caractere '%'. O caractere de escape '%' pode ser usado não apenas para caracteres especiais, mas também para todos os caracteres não alfabéticos.

Um item de padrão pode ser:

• Uma classe de caractere única coincide com qualquer caractere único dessa classe;

• Uma classe de caractere única seguida por um '''*', Coincidirá com zero ou mais caracteres dessa classe. Este item sempre coincide com a sequência mais longa possível;

• Uma classe de caractere única seguida por um '''+', Coincidirá com um ou mais caracteres dessa classe. Este item sempre coincide com a sequência mais longa possível;

• Uma classe de caractere única seguida por um '''-', Coincidirá com zero ou mais caracteres dessa classe. e '*Diferente de ' Este item sempre coincide com a sequência mais curta possível;

• Uma classe de caractere única seguida por um '?', Coincidirá com zero ou um caractere dessa classe. Sempre que possível, ele coincidirá com um;

• %n, %b n Pode ser extraído de 1 até 9; Este item coincide com um igual a n Substring do objeto capturado (descrito a seguir).

• %b, %b x e y xy aqui x são dois caracteres claros; y esta entrada coincide com iniciar x e y terminar e que manter isto é, se ler a string da esquerda para a direita, para cada vez que encontrar umx que +1 ao ler um y que -1, o caractere na posição final y é o primeiro que conta até 0 y. Por exemplo, a entrada %b() pode matchar expressões entre parênteses balanceados.

• set] Denota Padrão de Fronteira; esta entrada coincidirá com uma localização set um caractere antes de um caractere dentro de E essa posição não pertence a set . Conjunto set Significado conforme descrito anteriormente. A contagem do início e do fim do string matchado é vista como se houvesse um caractere '\0' de mesma forma.

Padrão:

Padrão Denota uma sequência de entradas de padrão. Adicionar o sinal '^' no início do padrão fará com que o match seja ancorado no início da string. Adicionar o sinal '$' no final do padrão fará com que o processo de match seja ancorado no final da string. Se '^' e '$' aparecerem em outras posições, não têm significado especial, apenas representam a si mesmos.

Captura:

Os padrões podem usar parênteses pequenos para agrupar um subpadrão interno; Esses subpadrões são chamados Capturamentos. Quando o match é bem-sucedido, por Capturamentos Os subcadeias correspondentes ao que foi matchado são salvas para uso futuro. Os capturamentos são numerados na ordem dos seus parênteses esquerdos. Por exemplo, para o padrão "(a*(.)%w(%s*))", A string correspondente ao "a*(.)%w(%s*)" parte é (Portanto, é编号 1 ); Os caracteres correspondentes ao ". 2 N°. corresponde ao capturamento "%s*A parte que está entre " 3 N°.

Como uma exceção, um capturamento vazio () capturará a posição atual da string (é um número). Por exemplo, se aplicar o padrão "()aa()" à string "flaaap", serão gerados dois capturamentos: 3 e 5 .