Comparaison de Luau et de C#

Roblox utilise le langage de programmation Luau. Les exemples de code et les tables suivantes indiquent certaines des différences entre les syntaxes pour C# et Luau.

Finitions de ligne

Vous n'avez pas besoin de virgules dans Luau, mais elles ne violent pas la syntaxe.

Mots réservés

La table suivante a les mots-clés réservés de Luau mappés à leur équivalent C#. Remarquez qu'elle ne montre pas tous les mots-clés C#.

Commentaires

Commentaires dans Luau
-- commenterd'une ligne unique

--[[ Résultat de sortie :
	Block comment
--]]

Comments in C#
// Single line comment

/*
	Block comment
*/

chaînes

Chaînes dans Luau
-- Chaîne chaîne
local multiLineString = [[This is a string that,
when printed, appears
on multiple lines]]

-- Concaténation
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;

Tables

Pour en savoir plus sur les tables dans Luau, voir tables.

Tables de dictionnaire

Vous pouvez utiliser des tables dans Luau comme dictionnaires tout comme dans C#.

Tables de dictionnaire dans Luau
local dictionary = {
	val1 = "this",
	val2 = "is"
}

print(dictionary.val1)  -- Produit 'ceci'
print(dictionary["val1"])  -- Produit 'ceci'

dictionary.val1 = nil  -- Supprime 'val1' de la table
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

Tables numérotées indexées

Vous pouvez utiliser des tables dans Luau comme des tableaux tout comme dans C#. Les indexes commencent à 1 dans Luau et 0 dans C#.

Tables numérotées indexées dans Luau
local npcAttributes = {"strong", "intelligent"}

print(npcAttributes[1])  -- Produit 'strong'
print(#npcAttributes)  -- Affiche la taille de la liste

-- Ajouter à la liste
table.insert(npcAttributes, "humble")
-- Une autre façon...
npcAttributes[#npcAttributes+1] = "humble"

-- Insérer au début de la liste
table.insert(npcAttributes, 1, "brave")

-- Supprimer l'élément à un index donné
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);

Opérateurs

Opérateurs conditionnels

Opérateurs arithmétiques

Variables

Dans Luau, les variables ne spécifient pas leur type lorsque vous les déclarez.Les variables Luau n'ont pas d'修改者 d'accès, bien que vous puissiez préfixer les variables "privées" avec un tiret pour la lisibilité.

Variables dans Luau
local stringVariable = "value"

-- Déclaration "publique"
local variableName

-- Déclaration "privée" - analysée de la même manière
local _variableName

Variables in C#
string stringVariable = "value";

// Public declaration
public string variableName

// Private declaration
string variableName;

Portée

Dans Luau, vous pouvez écrire des variables et de la logique dans un domaine plus restreint que leur fonction ou leur classe en nidant la logique dans do et end les mots-clés, similaire aux crochets courbes {} dans C#.Pour plus de détails, voir portée .

Délimitation dans Luau
local outerVar = 'Outer scope text'

do
    -- Modifier 'outerVar'
    outerVar = 'Inner scope modified text'
    -- Présenter une variable locale
    local innerVar = 'Inner scope text'
    print('1: ' .. outerVar)    -- imprime « 1 : texte modifié de la portée interne »
    print('2: ' .. innerVar)    -- imprime « 2 : Texte de portée interne »
end

print('3: ' .. outerVar)        -- imprime "3 : texte modifié de portée interne"
-- 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

Statements conditionnels

Statements conditionnels dans Luau
-- Une condition
if boolExpression then
	doSomething()
end

-- Plusieurs conditions
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();
}

Opérateur conditionnel

Opérateur conditionnel dans Luau
local max = if x > y then x else y

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

Boucles

Pour en savoir plus sur les boucles dans Luau, voir structures de contrôle.

Boucles while et repeat

Boucles while et repeat dans Luau
while boolExpression do
	doSomething()
end

repeat
	doSomething()
until not boolExpression

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

do {
	doSomething();
} while (boolExpression)

Pour les boucles

Générique pour les boucles dans Luau
-- Boucle en avant
for i = 1, 10 do
	doSomething()
end

-- Boucle inversée
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();
}

Pour les boucles sur les tables dans 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 prend également en charge une itération généralisée , ce qui simplifie encore le travail avec des tables.

Fonctions

Pour en savoir plus sur les fonctions dans Luau, voir Fonctions.

Fonctions génériques

Fonctions génériques dans Luau
-- Fonction générique
local function increment(number)
	return number + 1
end

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

Nombre d'argument variable

Nombre d'argument variable dans Luau
-- Nombre d'argument 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);
	}
}

Arguments nommés

Arguments nommés dans Luau
-- Arguments nommés
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");

Structures d'essai-attrape

Essayer/attraper des structures dans Luau
local function fireWeapon()
	if not weaponEquipped then
		error("No weapon equipped!")
	end
	-- Procéder...
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
}