Strings

O tipo de dado string é uma sequência de caracteres, como letras, números e símbolos. É o tipo de dado para armazenar a maioria das informações baseadas em texto.

Declarar strings

Para declarar uma variável string, coloque aspas em torno dos caracteres. É mais comum usar aspas duplas ("), mas aspas simples (') também funcionam. Se você quiser incluir uma aspa simples ou uma aspa dupla em sua string, envolva sua string no outro tipo de aspa ou use uma aspa escapada.

local string1 = "Olá mundo!"
print(string1)  --> Olá mundo!

local string2 = 'Olá "mundo"!'
print(string2)  --> Olá "mundo"!

Para incluir tanto aspas simples quanto duplas em uma string, ou para criar strings em múltiplas linhas, declare-as usando colchetes duplos:

local string1 = [[Olá
mundo!
Olá "mundo"!
Olá 'mundo'!]]

print(string1)
--> Olá
--> mundo!
--> Olá "mundo"!
--> Olá 'mundo'!

Se necessário, você pode aninhar múltiplos colchetes dentro de uma string usando o mesmo número de sinais de igual no início e no final do colchete:

local string1 = [=[Olá
[[mundo!]]
]=]

print(string1)
--> Olá
--> [[mundo!]]

Combinar strings

Para combinar strings, concatená-las com dois pontos (..). Concatenar strings não insere um espaço entre elas, então você precisará incluir espaço(s) no final/início de uma string anterior/subsequente ou concatenar um espaço entre as duas strings.

local hello = "Olá"
local helloWithSpace = "Olá "
local world = "mundo!"

local string1 = hello .. world
local string2 = helloWithSpace .. world
local string3 = hello .. " " .. world

print(string1)  --> Olámundo!
print(string2)  --> Olá mundo!
print(string3)  --> Olá mundo!

Note que o comando print() aceita múltiplos argumentos e os combina com espaços, então você pode usar , em vez de .. para obter espaços nas saídas de print().

local hello = "Olá"
local world = "mundo"
local exclamationMark = "!"

print(hello .. world .. exclamationMark)  --> Olámundo!
print(hello, world .. exclamationMark)  --> Olá mundo!
print(hello, world, exclamationMark)  --> Olá mundo !

Converter strings

Para converter uma string em um número, use a função tonumber(). Se a string não tiver uma representação numérica, tonumber() retorna nil.

local numericString = "123"
print(tonumber(numericString))  --> 123

local alphanumericString = "Olá123"
print(tonumber(alphanumericString))  --> nil

Escapar strings

Para escapar uma declaração de string com aspas duplas ou simples e incorporar quase qualquer caractere, coloque uma barra invertida (\) antes do caractere. Por exemplo:

• Para incorporar uma aspa simples em uma string com aspas simples, use \'.
• Para incorporar uma aspa dupla em uma string com aspas duplas, use \".

local string1 = 'Olá \'mundo\'!'
print(string1)  --> Olá 'mundo'!

local string2 = "Olá \"mundo\"!"
print(string2)  --> Olá "mundo"!

Certos caracteres que seguem barras invertidas geram caracteres especiais em vez de caracteres escapados:

• Para incorporar uma nova linha, use \n.
• Para incorporar uma tabulação horizontal, use \t.

local string1 = "Olá\nmundo!"
print(string1)
--> Olá
--> mundo!

local string2 = "Olá\tmundo!"
print(string2)  --> Olá	mundo!

Interpolação de strings

Luau suporta interpolação de strings, um recurso que permite inserir expressões em strings. Use crases (`) para declarar uma string interpolada, em seguida, adicione expressões dentro de chaves:

local world = "mundo"

local string1 = `Olá {world}!`
print(string1)  --> Olá mundo!

Embora variáveis sejam o uso mais comum, você pode usar qualquer expressão, incluindo matemática:

local world = "mundo"
local number = 1
local letters = {"w", "o", "r", "l", "d"}

local string1 = `Olá {world}, {number} vez!`
local string2 = `Olá {world}, {number + 1} vezes!`
local string3 = `Olá {table.concat(letters)} uma terceira vez!`

print(string1)  --> Olá mundo, 1 vez!
print(string2)  --> Olá mundo, 2 vezes!
print(string3)  --> Olá mundo uma terceira vez!

Regras de escape padrão se aplicam para crases, chaves e barras invertidas:

local string1 = `Olá \`\{world\}\`!`
print(string1)  --> Olá `{world}`!

Conversão matemática

Se você realizar operações matemáticas em uma string, Luau automaticamente converte a string em um número. Se a string não tiver uma representação numérica, gerará um erro.

print("55" + 10)  --> 65
print("55" - 10)  --> 45
print("55" * 10)  --> 550
print("55" / 10)  --> 5.5
print("55" % 10)  --> 5
print("Olá" + 10)	 --> print("Olá" + 10):1: tentativa de realizar aritmética (adição) em string e número

Comparações

Strings podem ser comparadas usando os operadores <, <=, > e >=, que comparam usando a ordem lexicográfica com base nos códigos ASCII de cada caractere em uma string. Isso resultará em números em strings não sendo comparados corretamente, por exemplo, "100" será menor que "20", já que os bytes "0" e "1" têm códigos ASCII mais baixos do que o byte "2".

print("Maçã" < "maçã") --> true
print("Banana" < "maçã") --> true (B vem antes de a no ASCII)
print("numero100" < "numero20") --> true

Referência de padrões de strings

Um padrão de string é uma combinação de caracteres que você pode usar com string.match(), string.gmatch() e outras funções para encontrar um pedaço, ou substring, de uma string mais longa.

Combinações diretas

Você pode usar combinações diretas em uma função Luau como string.match(), exceto para caracteres mágicos. Por exemplo, esses comandos buscam a palavra Roblox dentro de uma string:

local match1 = string.match("Bem-vindo ao Roblox!", "Roblox")
local match2 = string.match("Bem-vindo ao meu jogo incrível!", "Roblox")
print(match1)  --> Roblox
print(match2)  --> nil

Classes de caracteres

Classes de caracteres são essenciais para buscas de strings mais avançadas. Você pode usá-las para buscar algo que não é necessariamente específico de um caractere, mas se encaixa dentro de uma categoria conhecida (classe), incluindo letras, dígitos, espaços, pontuação e mais.

A tabela a seguir mostra as classes de caracteres oficiais para padrões de string Luau:

Para classes de caracteres com uma única letra, como %a e %s, a letra correspondente maiúscula representa o "oposto" da classe. Por exemplo, %p representa um caractere de pontuação enquanto %P representa todos os caracteres exceto pontuação.

Caracteres mágicos

Existem 12 "caracteres mágicos" que são reservados para propósitos especiais em padrões:

Você pode escapar e buscar caracteres mágicos usando o símbolo %. Por exemplo, para buscar roblox.com, escape o símbolo . (ponto) precedendo-o com um %, como em %..

-- "roblox.com" combina com "roblox#com" porque o ponto é interpretado como "qualquer caractere"
local match1 = string.match("O que é roblox#com?", "roblox.com")
print(match1)  --> roblox#com

-- Escape o ponto com % para que ele seja interpretado como um caractere literal
local match2 = string.match("Eu amo roblox.com!", "roblox%.com")
print(match2)  --> roblox.com

Âncoras

Você pode buscar um padrão no início ou no final de uma string usando os símbolos ^ e $.

local start1 = string.match("primeiro segundo terceiro", "^primeiro")  -- Combina porque "primeiro" está no início
print(start1)  --> primeiro

local start2 = string.match("terceiro segundo primeiro", "^primeiro")  -- Não combina porque "primeiro" não está no início
print(start2)  --> nil

local end1 = string.match("primeiro segundo terceiro", "terceiro$")  -- Combina porque "terceiro" está no final
print(end1)  --> terceiro

local end2 = string.match("terceiro segundo primeiro", "terceiro$")  -- Não combina porque "terceiro" não está no final
print(end2)  --> nil

Você também pode usar ^ e $ juntos para garantir que um padrão combine apenas com a string completa e não apenas com alguma parte dela.

-- Usando tanto ^ quanto $ para combinar em uma string completa
local match1 = string.match("Roblox", "^Roblox$")  -- Combina porque "Roblox" é a string inteira (igualdade)
print(match1)  --> Roblox

local match2 = string.match("Eu jogo Roblox", "^Roblox$")  -- Não combina porque "Roblox" não está no início E no final
print(match2)  --> nil

local match3 = string.match("Eu jogo Roblox", "Roblox")  -- Combina porque "Roblox" está contido em "Eu jogo Roblox"
print(match3)  --> Roblox

Modificadores de classe

Por si só, uma classe de caracteres combina um caractere em uma string. Por exemplo, o seguinte padrão ("%d") começa a ler a string da esquerda para a direita, encontra o primeiro dígito (2) e para.

local match = string.match("O Reino das Nuvens tem 25 gemas de poder", "%d")
print(match)  --> 2

Você pode usar modificadores com qualquer classe de caracteres para controlar o resultado:

Adicionar um modificador ao mesmo padrão ("%d+" em vez de "%d"), produz 25 em vez de 2:

local match1 = string.match("O Reino das Nuvens tem 25 gemas de poder", "%d")
print(match1)  --> 2

local match2 = string.match("O Reino das Nuvens tem 25 gemas de poder", "%d+")
print(match2)  --> 25

Conjuntos de classes

Conjuntos devem ser usados quando uma única classe de caracteres não pode fazer todo o trabalho. Por exemplo, você pode querer combinar tanto letras minúsculas (%l) quanto caracteres de pontuação (%p) usando um único padrão.

Os conjuntos são definidos por colchetes [] ao redor deles. No exemplo a seguir, note a diferença entre usar um conjunto ("[%l%p]+") e não usar um conjunto ("%l%p+").

local match1 = string.match("Olá!!! Eu sou outra string.", "[%l%p]+")  -- Conjunto
print(match1)  --> olo!!!

local match2 = string.match("Olá!!! Eu sou outra string.", "%l%p+")  -- Não-conjunto
print(match2)  --> o!!!

O primeiro comando (conjunto) diz a Luau para encontrar tanto caracteres minúsculos quanto pontuação. Com o quantificador + adicionado após o conjunto inteiro, ele encontra todos esses caracteres (olo!!!), parando quando chega ao espaço.

No segundo comando (não-conjunto), o quantificador + aplica-se apenas à classe %p antes dele, então Luau pega apenas o primeiro caractere minúsculo (o) antes da série de pontuação (!!!).

Assim como classes de caracteres, conjuntos podem ser "opostos" de si mesmos. Isso é feito adicionando um caractere ^ no início do conjunto, logo após a abertura [. Por exemplo, "[%p%s]+" representa tanto pontuação quanto espaços, enquanto "[^%p%s]+" representa todos os caracteres exceto pontuação e espaços.

Os conjuntos também suportam intervalos, que permitem que você encontre um intervalo inteiro de combinações entre um caractere inicial e final. Este é um recurso avançado que é descrito em mais detalhes no Manual Lua 5.1.

Capturas de strings

Capturas de strings são sub-padrões dentro de um padrão. Estes são encerrados em parênteses () e são usados para obter (capturar) substrings coincidentes e salvá-las em variáveis. Por exemplo, o seguinte padrão contém duas capturas, (%a+) e (%d+), que retornam duas substrings após uma combinação bem-sucedida.

local pattern = "(%a+)%s?=%s?(%d+)"

local key1, val1 = string.match("VinteUm = 21", pattern)
print(key1, val1)  --> VinteUm 21

local key2, val2 = string.match("DoisMil= 2000", pattern)
print(key2, val2)  --> DoisMil 2000

local key3, val3 = string.match("UmMilhão=1000000", pattern)
print(key3, val3)  --> UmMilhão 1000000

O quantificador ? que segue ambas as classes %s é uma adição segura porque torna o espaço em ambos os lados do sinal de igual opcional. Isso significa que a combinação é bem-sucedida se um (ou ambos) os espaços estiverem ausentes ao redor do sinal de igual.

Na função string.gsub(), você pode incluir grupos de captura na string de substituição usando %1, %2, %3, etc., até %9. Embora Luau suporte até 32 grupos de captura antes de gerar um erro, você pode apenas referenciar os primeiros nove com esta sintaxe:

local str = "amo2jogar Roblox"
local pattern = "(%w+)(%d+)(%w+)%s+(%w+)"
local replacement = "Eu %1 %2 %3 %4!"

local result = string.gsub(str, pattern, replacement)
print(result) --> Eu amo 2 jogar Roblox!

Você também pode aninhar capturas de strings:

local places = "O Reino das Nuvens é celestial, O Reino da Floresta é pacífico"
local pattern = "(O%s(%a+%sReino)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
	print(description)
	print(kingdom)
end
--> O Reino das Nuvens é celestial
--> Reino das Nuvens
--> O Reino da Floresta é pacífico
--> Reino da Floresta

Essa busca de padrão funciona da seguinte forma:

O iterador string.gmatch() procura uma combinação no padrão "descrição" definido pelo par externo de parênteses. Isso para na primeira vírgula e captura o seguinte:

Usando sua primeira captura bem-sucedida, o iterador então procura uma combinação no padrão "reino" definido pelo par interno de parênteses. Esse padrão aninhado simplesmente captura o seguinte:

O iterador então retorna e continua procurando na string completa, capturando o seguinte:

Além de tudo isso, há um caso especial com uma captura vazia (()). Se uma captura estiver vazia, então a posição na string será capturada:

local match1 = "Onde acontece a captura? Quem sabe!"
local match2 = "Esta string é mais longa que a primeira. Onde acontece a captura? Quem sabe?!"

local pattern = "()Onde acontece a captura%? Quem sabe!()"

local start1, finish1 = string.match(match1, pattern)
print(start1, finish1)  --> 1 42

local start2, finish2 = string.match(match2, pattern)
print(start2, finish2)  --> 43 84

Essas capturas especiais podem ser aninhadas como as normais:

local places = "O Reino das Nuvens é celestial, O Reino da Floresta é pacífico."
local pattern = "O (%a+()) Reino é %a+"

for kingdom, position in string.gmatch(places, pattern) do
	print(kingdom, position)
end
--> Nuvens 10
--> Floresta 42

Os valores retornados são incomuns, pois são números em vez de strings:

local match = "Este é um exemplo"
local pattern = "Este é um ()exemplo"

local position = string.match(match, pattern)
print(typeof(position))  --> number