Comparación de Luau y C#

Roblox usa el lenguaje de programación Luau. Las siguientes muestras de código y tablas indican algunas de las diferencias entre los lenguajes de programación C# y Luau.

Fin de la línea

No necesitas semicolones en Luau, pero no rompen la sintaxis.

Palabras Clave Reservadas

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

Comentarios

Comentarios en Luau
-- Comentario de línea hacer un comentario

--[[ Resultado de Salida:
	Block comment
--]]

Comments in C#
// Single line comment

/*
	Block comment
*/

Cuerdas

Cuerdas en Luau
-- Cadena cadena
local multiLineString = [[This is a string that,
when printed, appears
on multiple lines]]

-- Concatenación
local s1 = "This is a string "
local s2 = "made with two parts."
local endString = s1 .. s2

Strings in C#
// Multi-line string
string multiLineString1 = "This is a string that,\nwhen printed, appears\n on multiple lines.";

string multiLineString2 = @"This is a string that,
when printed, appears
on multiple lines";

// Concatenation
string s1 = "This is a string ";
string s2 = "made with two parts.";
string endString = s1 + s2;

Tablas

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

Tablas de diccionario

Puedes usar tablas en Luau como diccionarios justo como en C#.

Tablas de diccionario en Luau
local dictionary = {
	val1 = "this",
	val2 = "is"
}

print(dictionary.val1)  -- Outputs 'this'
print(dictionary["val1"])  -- Outputs 'this'

dictionary.val1 = nil  -- Elimina 'val1' de la tabla
dictionary["val3"] = "a dictionary"  -- Overwrites 'val3' or sets new key-value pair

Dictionary Tables in C#
Dictionary dictionary = new Dictionary()
{
	{ "val1", "this" },
	{ "val2", "is" }
};

Console.WriteLine(dictionary["val1"]);  // Outputs 'this'
dictionary.Remove("val1");  // Removes 'val1' from dictionary

dictionary["val3"] = "a dictionary";  // Overwrites 'val3' or sets new key-value pair
dictionary.Add("val3", "a dictionary");  // Creates a new key-value pair

Tablas Indexadas Numéricamente

Puedes usar tablas en Luau como matrizes justo como en C#. Los índices comienzan en 1 en Luau y 0 en C#.

Tablas numéricamente indexadas en Luau
local npcAttributes = {"strong", "intelligent"}

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

-- Añadir a la lista
table.insert(npcAttributes, "humble")
-- Otra manera...
npcAttributes[#npcAttributes+1] = "humble"

-- Inserta al comienzo de la lista
table.insert(npcAttributes, 1, "brave")

-- Eliminar el artículo en un índice específico
table.remove(npcAttributes, 3)

Numerically-Indexed Tables in C#
List npcAttributes = new List{"strong", "intelligent"};

Console.WriteLine(npcAttributes[0]);  // Outputs 'strong'
Console.WriteLine(npcAttributes.Count);  // Outputs the size of the list

// Append to the list
npcAttributes.Add("humble");
// Another way...
npcAttributes.Insert(npcAttributes.Count, "humble");

// Insert at the beginning of the list
npcAttributes.Insert(0, "brave");

// Remove item at a given index
npcAttributes.Remove(2);

Operadores

Operadores Condicionales

Operadores aritméticos

variables

En Luau, las variables no especifican su tipo cuando las declaras. Las variables de Luau no tienen modificadores de acceso, aunque puedes prender "servidor privado" con un signo de interrogación para aumentar la legibilidad.

Variables en Luau
local stringVariable = "value"

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

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

Variables in C#
string stringVariable = "value";

// Public declaration
public string variableName

// Private declaration
string variableName;

Mira

En Luau, puedes escribir variables y lógica en un alcance más estricto que su función o clase al hacer que la lógica esté dentro de do y end palabras clave, similares a los signos de curva {} en C#. Para más detalles, see 1> alcance1> .

Luau de alcance
local outerVar = 'Outer scope text'

do
    -- Modificar 'outerVar'
    outerVar = 'Inner scope modified text'
    -- Introduce una variable local
    local innerVar = 'Inner scope text'
    print('1: ' .. outerVar)    -- imprime "1: Inner scope modified text"
    print('2: ' .. innerVar)    -- imprime "2: Inner scope text"
end

print('3: ' .. outerVar)        -- imprime "3: " texto de alcance interior modificado"
-- Attempting to print 'innerVar' here would fail

Scoping in C#
var outerVar = "Outer scope text";

{
	// Modify 'outerVar'
	outerVar = "Inner scope modified text";
	// Introduce a local variable
	var innerVar = "Inner scope text";
	Console.WriteLine("1: " + outerVar);    // prints "1: Inner scope modified text"
	Console.WriteLine("2: " + innerVar);    // prints "2: Inner scope text"
}

Console.WriteLine("3: " + outerVar);		// prints "3: "Inner scope modified text"
// Attempting to print 'innerVar' here would fail

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

Conditional Statements in C#
// One condition
if (boolExpression) {
	doSomething();
}


// Multiple conditions
if (!boolExpression) {
	doSomething();
}
else if (otherBoolExpression) {
	doSomething();
}
else {
	doSomething();
}

Operador Condicional

Operador condicional en Luau
local max = if x > y then x else y

Conditional Operator in C#
int max = (x > y) ? x : y;

Ciclos

Para aprender más sobre los ciclos en Luau, see Estructuras de control .

Mientras que y Repeat Loops

Mientras que y Repeat Loops en Luau
while boolExpression do
	doSomething()
end

repeat
	doSomething()
until not boolExpression

While and Repeat Loops in C#
while (boolExpression) {
	doSomething();
}

do {
	doSomething();
} while (boolExpression)

Para bucles

Genérico para Forcles en Luau
-- Ciclo de forward
for i = 1, 10 do
	doSomething()
end

-- Bobina de rechazo
for i = 10, 1, -1 do
	doSomething()
end

Generic For Loops in C#
// Forward loop
for (int i = 1; i <= 10; i++) {
	doSomething();
}

// Reverse loop
for (int i = 10; i >= 1; i--) {
	doSomething();
}

Para bucles 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

For Loops Over Lists in 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 las funciones en Luau, see Funciones .

Funciones genéricas

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

Generic Functions in C#
// Generic function
int increment(int number) {
	return number + 1;
}

Número de argumento variable

Número de argumento variable en Luau
-- Número de argumento variable
local function variableArguments(...)
	print(...)
end

Variable Argument Number in C#
// Variable argument number
void variableArguments(params string[] inventoryItems) {
	for (item in inventoryItems) {
		Console.WriteLine(item);
	}
}

Argumentos de nombre

ArgUMENTOS NOMBRADOS en Luau
-- Argumentos de nombre
local function namedArguments(args)
	return args.name .. "'s birthday: " .. args.dob
end

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

Named Arguments in C#
// Named arguments
string namedArguments(string name, string dob) {
	return name + "'s birthday: " + dob;
}

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

Estructuras de prueba y captura

Intentar/Atrapar Estructuras en Luau
local function fireWeapon()
	if not weaponEquipped then
		error("No weapon equipped!")
	end
	-- Proceder...
end

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

Try/Catch Structures in C#
void fireWeapon() {
	if (!weaponEquipped) {
		// Use a user-defined exception
		throw new InvalidWeaponException("No weapon equipped!");
	}
	// Proceed...
}

try {
	fireWeapon();
} catch (InvalidWeaponException ex) {
	// An error was raised
}