Comparación de Luau y C# | Documentación del Centro de creación de Roblox

Roblox utiliza el lenguaje de programación Luau. Los siguientes ejemplos de código y tablas indican algunas de las diferencias entre las sintaxis de C# y Luau.

Finales de línea

No necesitas punto y coma en Luau, pero no rompen la sintaxis.

Palabras clave reservadas

La siguiente tabla tiene las palabras clave reservadas de Luau mapeadas a su equivalente en C#. Ten en cuenta que no muestra todas las palabras clave de C#.

Luau	C#
and
break	break
do	do
if	if
else	else
elseif	else if
then
end
true	true
false	false
for	for o foreach
function
in	in
local
nil	null
not
or
repeat
return	return
until
while	while

Comentarios

Comentarios en Luau

-- Comentario de una sola línea

--[[ Salida resultante:
	Comentario de bloque
--]]

Comentarios en C#

// Comentario de una sola línea

/*
	Comentario de bloque
*/

Cadenas

Cadenas en Luau

-- Cadena de múltiples líneas
local multiLineString = [[Esta es una cadena que,
cuando se imprime, aparece
en múltiples líneas]]

-- Concatenación
local s1 = "Esta es una cadena "
local s2 = "hecha con dos partes."
local endString = s1 .. s2

Cadenas en C#

// Cadena de múltiples líneas
string multiLineString1 = "Esta es una cadena que,\ncuando se imprime, aparece\n en múltiples líneas.";

string multiLineString2 = @"Esta es una cadena que,
cuando se imprime, aparece
en múltiples líneas";

// Concatenación
string s1 = "Esta es una cadena ";
string s2 = "hecha con dos partes.";
string endString = s1 + s2;

Tablas

Para aprender más sobre tablas en Luau, consulta Tablas.

Tablas de diccionario

Puedes usar tablas en Luau como diccionarios, al igual que en C#.

Tablas de Diccionario en Luau

local dictionary = {
	val1 = "esto",
	val2 = "es"
}

print(dictionary.val1)  -- Salida 'esto'
print(dictionary["val1"])  -- Salida 'esto'

dictionary.val1 = nil  -- Elimina 'val1' de la tabla
dictionary["val3"] = "un diccionario"  -- Sobrescribe 'val3' o establece un nuevo par clave-valor

Tablas de Diccionario en C#

Dictionary dictionary = new Dictionary()
{
	{ "val1", "esto" },
	{ "val2", "es" }
};

Console.WriteLine(dictionary["val1"]);  // Salida 'esto'
dictionary.Remove("val1");  // Elimina 'val1' del diccionario

dictionary["val3"] = "un diccionario";  // Sobrescribe 'val3' o establece un nuevo par clave-valor
dictionary.Add("val3", "un diccionario");  // Crea un nuevo par clave-valor

Tablas indexadas numéricamente

Puedes usar tablas en Luau como arreglos, al igual que en C#. Los índices comienzan en 1 en Luau y en 0 en C#.

Tablas Indexadas Numéricamente en Luau

local npcAttributes = {"fuerte", "inteligente"}

print(npcAttributes[1])  -- Salida 'fuerte'
print(#npcAttributes)  -- Salida del tamaño de la lista

-- Agregar a la lista
table.insert(npcAttributes, "humilde")
-- Otra forma...
npcAttributes[#npcAttributes+1] = "humilde"

-- Insertar al principio de la lista
table.insert(npcAttributes, 1, "valiente")

-- Eliminar item en un índice dado
table.remove(npcAttributes, 3)

Tablas Indexadas Numéricamente en C#

List npcAttributes = new List{"fuerte", "inteligente"};

Console.WriteLine(npcAttributes[0]);  // Salida 'fuerte'
Console.WriteLine(npcAttributes.Count);  // Salida del tamaño de la lista

// Agregar a la lista
npcAttributes.Add("humilde");
// Otra forma...
npcAttributes.Insert(npcAttributes.Count, "humilde");

// Insertar al principio de la lista
npcAttributes.Insert(0, "valiente");

// Eliminar item en un índice dado
npcAttributes.Remove(2);

Operadores

Operadores condicionales

Operador	Luau	C#
Igual a	==	==
Mayor que	>	>
Menor que	<	<
Mayor o igual a	>=	>=
Menor o igual a	<=	<=
No igual a	~=	!=
Y	and	&&
O	or	\|\|

Operadores aritméticos

	Luau	C#
Adición	+	+
sustracción	-	-
Multiplicación	*	*
División	/	/
Módulo	%	%
Exponenciación	^	**

En Luau, las variables no especifican su tipo cuando las declaras. Las variables de Luau no tienen modificadores de acceso, aunque puedes prefijar las variables "privadas" con un guion bajo para mayor legibilidad.

Variables en Luau

local stringVariable = "valor"

-- Declaración "pública"
local variableName

-- Declaración "privada" - se analiza de la misma manera
local _variableName

Variables en C#

string stringVariable = "valor";

// Declaración pública
public string variableName

// Declaración privada
string variableName;

Alcance

En Luau, puedes escribir variables y lógica en un alcance más cerrado que su función o clase anidando la lógica dentro de las palabras clave do y end, similar a las llaves {} en C#. Para más detalles, consulta Alcance.

Alcance en Luau

local outerVar = 'Texto de alcance externo'

do
    -- Modificar 'outerVar'
    outerVar = 'Texto modificado de alcance interno'
    -- Introducir una variable local
    local innerVar = 'Texto de alcance interno'
    print('1: ' .. outerVar)    -- imprime "1: Texto modificado de alcance interno"
    print('2: ' .. innerVar)    -- imprime "2: Texto de alcance interno"
end

print('3: ' .. outerVar)        -- imprime "3: "Texto modificado de alcance interno"
-- Intentar imprimir 'innerVar' aquí fallaría

Alcance en C#

var outerVar = "Texto de alcance externo";

{
	// Modificar 'outerVar'
	outerVar = "Texto modificado de alcance interno";
	// Introducir una variable local
	var innerVar = "Texto de alcance interno";
	Console.WriteLine("1: " + outerVar);    // imprime "1: Texto modificado de alcance interno"
	Console.WriteLine("2: " + innerVar);    // imprime "2: Texto de alcance interno"
}

Console.WriteLine("3: " + outerVar);		// imprime "3: "Texto modificado de alcance interno"
// Intentar imprimir 'innerVar' aquí fallaría

Declaraciones condicionales

Declaraciones Condicionales en Luau

-- Una condición
if boolExpression then
	doSomething()
end

-- Múltiples condiciones
if not boolExpression then
	doSomething()
elseif otherBoolExpression then
	doSomething()
else
	doSomething()
end

Declaraciones Condicionales en C#

// Una condición
if (boolExpression) {
	doSomething();
}


// Múltiples condiciones
if (!boolExpression) {
	doSomething();
}
else if (otherBoolExpression) {
	doSomething();
}
else {
	doSomething();
}

Operador condicional

Operador Condicional en Luau

local max = if x > y then x else y

Operador Condicional en C#

int max = (x > y) ? x : y;

Bucles

Para aprender más sobre bucles en Luau, consulta Estructuras de Control.

Bucles while y repeat

Bucles While y Repeat en Luau

while boolExpression do
	doSomething()
end

repeat
	doSomething()
until not boolExpression

Bucles While y Repeat en C#

while (boolExpression) {
	doSomething();
}

do {
	doSomething();
} while (boolExpression)

Bucles for

Bucles For Genéricos en Luau

-- Bucle hacia adelante
for i = 1, 10 do
	doSomething()
end

-- Bucle inverso
for i = 10, 1, -1 do
	doSomething()
end

Bucles For Genéricos en C#

// Bucle hacia adelante
for (int i = 1; i <= 10; i++) {
	doSomething();
}

// Bucle inverso
for (int i = 10; i >= 1; i--) {
	doSomething();
}

Bucles For sobre Tablas en Luau

local abcList = {"a", "b", "c"}

for i, v in ipairs(abcList) do
	print(v)
end

local abcDictionary = { a=1, b=2, c=3 }

for k, v in pairs(abcDictionary) do
	print(k, v)
end

Bucles For sobre Listas en C#

List<string> abcList = new List<string>{"a", "b", "c"};

foreach (string v in abcList) {
	Console.WriteLine(v);
}

Dictionary<string, int> abcDictionary = new Dictionary<string, int>
{ {"a", 1}, {"b", 2}, {"c", 3} };


foreach (KeyValuePair<string, int> entry in abcDictionary) {
	Console.WriteLine(entry.Key + " " + entry.Value);
}

Luau también soporta iteración generalizada, lo que simplifica aún más el trabajo con tablas.

Funciones

Para aprender más sobre funciones en Luau, consulta Funciones.

Funciones genéricas

Funciones Genéricas en Luau

-- Función genérica
local function increment(number)
	return number + 1
end

Funciones Genéricas en C#

// Función genérica
int increment(int number) {
	return number + 1;
}

Número de argumentos variables

Número de Argumentos Variables en Luau

-- Número de argumentos variables
local function variableArguments(...)
	print(...)
end

Número de Argumentos Variables en C#

// Número de argumentos variables
void variableArguments(params string[] inventoryItems) {
	for (item in inventoryItems) {
		Console.WriteLine(item);
	}
}

Argumentos nombrados

Argumentos Nombrados en Luau

-- Argumentos nombrados
local function namedArguments(args)
	return args.name .. "'s birthday: " .. args.dob
end

namedArguments{name="Bob", dob="4/1/2000"}

Argumentos Nombrados en C#

// Argumentos nombrados
string namedArguments(string name, string dob) {
	return name + "'s birthday: " + dob;
}

namedArguments(name: "Bob", dob: "4/1/2000");

Estructuras try-catch

Estructuras Try/Catch en Luau

local function fireWeapon()
	if not weaponEquipped then
		error("¡Ningún arma equipada!")
	end
	-- Proceder...
end

local success, errorMessage = pcall(fireWeapon)
if not success then
	print(errorMessage)
end

Estructuras Try/Catch en C#

void fireWeapon() {
	if (!weaponEquipped) {
		// Usar una excepción definida por el usuario
		throw new InvalidWeaponException("¡Ninguna arma equipada!");
	}
	// Proceder...
}

try {
	fireWeapon();
} catch (InvalidWeaponException ex) {
	// Se produjo un error
}