Cuerdas

El tipo de datos cadena es una secuencia de caracteres, como letras, números y símbolos. Es el tipo de datos para almacenar la mayoría de la información basada en texto.

Declarando Cadenas

Para declarar una variable de cadena, ponga signos de interrogación alrededor de los caracteres. Es más común usar signos de interrogación dobles ( " ) que solteros ( ' ), pero también se pueden usar signos de interrogación únicos ( > ) o escapados ( 1>>1> ) si lo desea. Si desea incluir un signo de interrogación único o escapado en su cadena, envuelva su cadena alrededor del otro tipo de cita o use un

local string1 = "Hello world!"
print(string1)  --> ¡Hola mundo!

local string2 = 'Hello "world"!'
print(string2)  --> Hello "world"!

Para incluir tanto signos de unión como signos de doble muerte en una cadena, o para crear cadenas multilíneas, decláralos usando dos guiones:

local string1 = [[Hello
world!
Hello "world"!
Hello 'world'!]]

print(string1)
--> Hola
--> mundo!
--> Hola "mundo"!
--> Hello 'world'!

Si es necesario, puede anidar múltiples brackets dentro de una cadena usando el mismo número de signos iguales en ambos los brackets de inicio y final:

local string1 = [=[Hello
[[world!]]
]=]

print(string1)
--> Hola
--> [[world!]]

Combinar Cuerdas

Para combinar cadenas, concatenate con ellas con dos puntos ( .. ). Concatenar cadenas no introduce un espacio entre ellas, por lo que necesitará incluir espacio(s) al final/inicio de una cadena anterior/siguiente, o concatenar un espacio entre las dos cadenas.

local hello = "Hello"
local helloWithSpace = "Hello "
local world = "world!"

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

print(string1)  --> ¡Helloworld!
print(string2)  --> ¡Hola mundo!
print(string3)  --> Hello world!

Nota que el comando print() toma múltiples argumentos y los combina con espacios, por lo que puede usar , en lugar de , para producir espacios en los resultados de 2>print()2> .

local hello = "Hello"
local world = "world"
local exclamationMark = "!"

print(hello .. world .. exclamationMark)  --> ¡Helloworld!
print(hello, world .. exclamationMark)  --> ¡Hola mundo!
print(hello, world, exclamationMark)  --> Hello world !

Convirtiendo cadenas

Para convertir una cadena en un número, usa la función tonumber(). Si la cadena no tiene una representación de número, tonumber()返回nil .

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

local alphanumericString = "Hello123"
print(tonumber(alphanumericString))  --> nil

Escapando Cuerdas

Para escapar de una declaración de cadena de doble o sencilla y embeber casi cualquier personaje, ponga un espacio de vuelta ( \ ) antes del personaje. Por ejemplo:

• Para incrustar una sola cita en una sola cadena de cita, usa \' .
• Para insertar una doble cita en una cadena de doble cita, usa \" .

local string1 = 'Hello \'world\'!'
print(string1)  --> ¡Hola mundo!

local string2 = "Hello \"world\"!"
print(string2)  --> Hello "world"!

Algunos personajes después de los signos de escape producen personajes especiales en lugar de personajes escapados:

• Para insertar una nueva línea, usa \n .
• Para insertar una pestaña horizontal, usa \t .

local string1 = "Hello\nworld!"
print(string1)
--> Hola
--> mundo!

local string2 = "Hello\tworld!"
print(string2)  --> Hello	world!

Interinterpretación de cuerda

Luau soporta interpretación de cadenas , una característica que te permite insertar expresiones en cadenas. Usa signos de retorno ( ` ) para declarar una cadena interpretada, luego agregar expresiones dentro de los signos de curva:

local world = "world"

local string1 = `Hello {world}!`
print(string1)  --> Hello world!

Aunque las variables son el uso más común, puedes usar cualquier expresión, incluida la matemática:

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

local string1 = `Hello {world}, {number} time!`
local string2 = `Hello {world}, {number + 1} times!`
local string3 = `Hello {table.concat(letters)} a third time!`

print(string1)  --> Hola mundo, 1 vez!
print(string2)  --> ¡Hola mundo, 2 veces!
print(string3)  --> Hello world a third time!

Las reglas de escape estándar se aplican a los backticks, curly brackets y backslashes:

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

Conversión de matemáticas

Si realiza operaciones de matemáticas en una cadena, Luau convierte automáticamente la cadena en un número. Si la cadena no tiene una representación de número, se produce un error.

print("55" + 10)  --> 65
print("55" - 10)  --> 45
print("55" * 10)  --> 550
print("55" / 10)  --> 5.5
print("55" % 10)  --> 5
print("Hello" + 10)	 --> print("Hello" + 10):1: attempt to perform arithmetic (add) on string and number

Comparaciones

Las cuerdas se pueden comparar utilizando los operadores <, <=, > y 2> que se comparan utilizando el orden léxico

print("Apple" < "apple") --> verdadero
print("Banana" < "apple") --> verdadero (B está antes de a en ASCII)
print("number100" < "number20") --> true

Referencia del patrón de cuerda

Un patrón de cadena es una combinación de caracteres que puedes usar con string.match(), string.gmatch() y otras funciones para encontrar una pieza, o subsecuencia, de una cadena más larga.

Partidos Directos

Puedes usar partidos directos en una función Luau como string.match() , excepto para personajes mágicos . Por ejemplo, estos comandos buscan la palabra Roblox dentro de una cadena:

local match1 = string.match("Welcome to Roblox!", "Roblox")
local match2 = string.match("Welcome to my awesome game!", "Roblox")
print(match1)  --> Roblox
print(match2)  --> nil

Clases de personaje

Las clases de personaje son esenciales para las búsquedas de cuerda más avanzadas. Puedes usarlas para buscar algo que no es necesariamente de carácter, pero que encaja dentro de una categoría conocida (clase), incluida la letras , el digite , el espacio , la 1> puntuación1> y más.

La siguiente tabla muestra las clases de personajes oficiales para los patrones de cuerda Luau:

Para clases de personaje de una sola letra, como %a y %s, la letra superior correspondiente representa el "opuesto" de la clase. Por instancia, %p representa un carácter de puntuación mientras que 1> %P1> representa todos los caracteres excepto el puntuación.

Personajes mágicos

Hay 12 "caracteres mágicos" que se reservan para propósitos especiales en los patrones:

Puede escapar y buscar personajes mágicos usando el símbolo %. Por ejemplo, para buscar roblox.com , escapa del símbolo . (símbolo de período) precedido con un 1> %1> como en 4> % 4> .

-- «roblox.com» coincide con «roblox#com» porque el período se interpreta como «cualquier personaje»
local match1 = string.match("What is roblox#com?", "roblox.com")
print(match1)  --> roblox#com

-- Escapa el período con % para que se interprete como un personaje de período literal
local match2 = string.match("I love roblox.com!", "roblox%.com")
print(match2)  --> roblox.com

Anclas

Puede buscar un patrón al comienzo o al final de una cadena usando los símbolos ^ y $.

local start1 = string.match("first second third", "^first")  -- Coincide porque "primer" está en el principio
print(start1)  --> primero

local start2 = string.match("third second first", "^first")  -- No coincide porque "primer" no está en el comienzo
print(start2)  --> nulo

local end1 = string.match("first second third", "third$")  -- Coincide porque "tercer" está al finalizar
print(end1)  --> tercero

local end2 = string.match("third second first", "third$")  -- No coincide porque "tercer" no está al finalizar
print(end2)  --> nil

También puede usar ambos ^ y $ juntos para asegurarse de que el patrón coincida con solo la cadena completa y no con solo una parte de ella.

-- Usando tanto ^ como $ para coincidir en una cadena completa
local match1 = string.match("Roblox", "^Roblox$")  -- Coincide porque "Roblox" es toda la cadena (igualdad)
print(match1)  --> Roblox

local match2 = string.match("I play Roblox", "^Roblox$")  -- No coincide porque "Roblox" no está al comienzo Y finalizar
print(match2)  --> nulo

local match3 = string.match("I play Roblox", "Roblox")  -- Coincide porque «Roblox» está contenido dentro de «Yo juego Roblox»
print(match3)  --> Roblox

Modificadores de clase

Por sí mismo, una clase de personaje sólo coincide con un personaje uno en una cadena. Por instancia, el patrón siguiente ( %) comienza a leer la cadena desde la izquierda a la derecha, encuentra el primer dígito ( 1> 2 1> ) y termina.

local match = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match)  --> 2

Puedes usar modificadores con cualquier clase de personaje para controlar el resultado:

Añadiendo un modificador al mismo patrón ( "%d+" en lugar de "%d" ) salen 25 en lugar de 1> " 2"1> :

local match1 = string.match("The Cloud Kingdom has 25 power gems", "%d")
print(match1)  --> 2

local match2 = string.match("The Cloud Kingdom has 25 power gems", "%d+")
print(match2)  --> 25

Sets de clase

Se deben usar las siguientes conjugaciones cuando una sola clase de personaje no puede hacer todo el trabajo. Por instancia, puede que quieras igualar las letras mayúsculas y minúsculas ( %l ) y los signos de puntuación ( %p ) con un patrón.

Las definiciones se definen por brackets [] alrededor de ellas. En el siguiente ejemplo, observe la diferencia entre usar un conjunto ( "[%l%p]+" ) y no usar un conjunto ( "%l%p+").

local match1 = string.match("Hello!!! I am another string.", "[%l%p]+")  -- Configurar
print(match1)  --> ¡¡¡hola!!!

local match2 = string.match("Hello!!! I am another string.", "%l%p+")  -- No configurado
print(match2)  --> o!!!

El primer comando (establecer) le dice a Luau que encuentre tanto carácteres mayúsculas como signos de puntuación. Con el contador de + añadido después de todo el establecer, encuentra todos de esos caracteres ( ello!!! ) cuando llega al espacio.

En el segundo comando (no definido), el contador de + solo se aplica a la clase %p antes de que, por lo tanto, Luau sólo agarre el primer carácter de mayúscula ( o ) antes de la serie de puntuación ( 2>!!!2> ).

Al igual que Clasesde personajes, los conjuntos pueden ser "opuestos" de sí mismos. Esto se hace agregando un personaje ^ en el comienzo del establecer, directamente después de la apertura [ . Por instancia, "[%p%s]+" representa tanto la puntuación y espacios, mientras que

También soporta rangos que te permiten encontrar un rango entero de partidos entre un personaje de inicio y final. Esta es una característica avanzada que se explica con más detalle en el Manual de Lua 5.1 .

Capturas de cuerda

Las capturas de String son sub patrones dentro de un patrón. Estos están encerrados en paréntesis () y se usan para obtener (capturar) sub patrones que coinciden y guardarlos a variables. Por ejemplo, el siguiente patrón contiene dos capturas, (%a+) y 1> percentd+1>, que devuelven dos sub patrones al momento de un coincidirexitoso.

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

local key1, val1 = string.match("TwentyOne = 21", pattern)
print(key1, val1)  --> Versión 21 de TwentyOne

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

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

En el patrón anterior, el contador de cuantificación ? que sigue ambas de las clases %s es una adición segura porque hace que el espacio en ambos lados del signo de igualdad sea opcional. Eso significa que el match succeeds si se pierde uno (o ambos) espacios alrededor del signo de igualdad.

Las capturas de cuerda también se pueden nestar como el siguiente ejemplo:

local places = "The Cloud Kingdom is heavenly, The Forest Kingdom is peaceful"
local pattern = "(The%s(%a+%sKingdom)[%w%s]+)"

for description, kingdom in string.gmatch(places, pattern) do
	print(description)
	print(kingdom)
end
--> El Reino de las Nubes es celestial
--> Reino de las Nubes
--> El Reino de los Bosques es pacífico
--> Forest Kingdom

Esta búsqueda de patrón funciona como sigue:

El string.gmatch() itador busca un match en todo el patrón de "descripción" definido por el par de guiones externos. Esto termina en el primer coma y captura lo siguiendo:

Usa su captura exitosa de primer captura, el itador luego busca un match en el patrón "kingdom" definido por el par de padres interiores. Este patrón basado en capas simplemente captura lo siguiendo:

El iterador entonces se detiene y continúa buscando la cadena completa, capturando lo siguiendo:

Además de todo lo anterior, hay un caso especial con un Captura vacía ( () ). Si una captura es vacía, entonces la posición en la cadena se capturará:

local match1 = "Where does the capture happen? Who knows!"
local match2 = "This string is longer than the first one. Where does the capture happen? Who knows?!"

local pattern = "()Where does the capture happen%? Who knows!()"

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

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

Estas capturas especiales pueden estar anidadas como las normales:

local places = "The Cloud Kingdom is heavenly, The Forest Kingdom is peaceful."
local pattern = "The (%a+()) Kingdom is %a+"

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

Los valores devueltos son inusuales en que son números en lugar de cadenas:

local match = "This is an example"
local pattern = "This is an ()example"

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