Comparaison entre Luau et C# | Documentation

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

Fin de ligne

Vous n'avez pas besoin de points-virgules dans Luau, mais ils ne rompent pas la syntaxe.

Mots clés réservés

Le tableau suivant montre les mots clés réservés de Luau mappés à leur équivalent en C#. Notez qu'il ne montre pas tous les mots clés du C#.

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

Commentaires

Commentaires dans Luau

-- Commentaire sur une seule ligne

--[[ Sortie résultante :
	Commentaire bloc
--]]

Commentaires en C#

// Commentaire sur une seule ligne

/*
	Commentaire bloc
*/

Chaînes

Chaînes dans Luau

-- Chaîne multi-lignes
local multiLineString = [[Ceci est une chaîne qui,
lorsqu'elle est imprimée, apparaît
sur plusieurs lignes]]

-- Concaténation
local s1 = "Ceci est une chaîne "
local s2 = "faite de deux parties."
local endString = s1 .. s2

Chaînes en C#

// Chaîne multi-lignes
string multiLineString1 = "Ceci est une chaîne qui,\nLorsqu'elle est imprimée, apparaît\n sur plusieurs lignes.";

string multiLineString2 = @"Ceci est une chaîne qui,
lorsqu'elle est imprimée, apparaît
sur plusieurs lignes";

// Concaténation
string s1 = "Ceci est une chaîne ";
string s2 = "faite de deux parties.";
string endString = s1 + s2;

Tables

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

Tables de dictionnaires

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

Tables de dictionnaires dans Luau

local dictionary = {
	val1 = "ceci",
	val2 = "est"
}

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

dictionary.val1 = nil  -- Supprime 'val1' de la table
dictionary["val3"] = "un dictionnaire"  -- Écrase 'val3' ou définit une nouvelle paire clé-valeur

Tables de dictionnaires en C#

Dictionary dictionary = new Dictionary()
{
	{ "val1", "ceci" },
	{ "val2", "est" }
};

Console.WriteLine(dictionary["val1"]);  // Retourne 'ceci'
dictionary.Remove("val1");  // Supprime 'val1' du dictionnaire

dictionary["val3"] = "un dictionnaire";  // Écrase 'val3' ou définit une nouvelle paire clé-valeur
dictionary.Add("val3", "un dictionnaire");  // Crée une nouvelle paire clé-valeur

Tables indexées numériquement

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

Tables indexées numériquement dans Luau

local npcAttributes = {"fort", "intelligent"}

print(npcAttributes[1])  -- Retourne 'fort'
print(#npcAttributes)  -- Retourne 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, "courageux")

-- Supprimer un élément à un indice donné
table.remove(npcAttributes, 3)

Tables indexées numériquement en C#

List npcAttributes = new List{"fort", "intelligent"};

Console.WriteLine(npcAttributes[0]);  // Retourne 'fort'
Console.WriteLine(npcAttributes.Count);  // Retourne la taille de la liste

// Ajouter à la liste
npcAttributes.Add("humble");
// Une autre façon...
npcAttributes.Insert(npcAttributes.Count, "humble");

// Insérer au début de la liste
npcAttributes.Insert(0, "courageux");

// Supprimer un élément à un indice donné
npcAttributes.Remove(2);

Opérateurs

Opérateurs conditionnels

Opérateur	Luau	C#
Égal à	==	==
Supérieur à	>	>
Inférieur à	<	<
Supérieur ou égal à	>=	>=
Inférieur ou égal à	<=	<=
Différent de	~=	!=
Et	and	&&
Ou	or	\|\|

Opérateurs arithmétiques

	Luau	C#
Addition	+	+
Soustraction	-	-
Multiplication	*	*
Division	/	/
Modulus	%	%
Exponentiation	^	**

Dans Luau, les variables ne spécifient pas leur type lors de leur déclaration. Les variables Luau n'ont pas de modificateurs d'accès, bien que vous puissiez préfixer les variables "privées" par un soulignement pour des raisons de lisibilité.

Variables dans Luau

local stringVariable = "valeur"

-- Déclaration "Publique"
local variableName

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

Variables en C#

string stringVariable = "valeur";

// Déclaration publique
public string variableName

// Déclaration privée
string variableName;

Portée

Dans Luau, vous pouvez écrire des variables et de la logique dans une portée plus étroite que leur fonction ou classe en imbriquant la logique au sein des mots clés do et end, similaire aux accolades {} en C#. Pour plus de détails, voir Portée.

Portée dans Luau

local outerVar = 'Texte de portée extérieure'

do
    -- Modifier 'outerVar'
    outerVar = 'Texte modifié de portée intérieure'
    -- Introduire une variable locale
    local innerVar = 'Texte de portée intérieure'
    print('1: ' .. outerVar)    -- imprime "1: Texte modifié de portée intérieure"
    print('2: ' .. innerVar)    -- imprime "2: Texte de portée intérieure"
end

print('3: ' .. outerVar)        -- imprime "3: "Texte modifié de portée intérieure"
-- Tenter d'imprimer 'innerVar' ici échouerait

Portée en C#

var outerVar = "Texte de portée extérieure";

{
	// Modifier 'outerVar'
	outerVar = "Texte modifié de portée intérieure";
	// Introduire une variable locale
	var innerVar = "Texte de portée intérieure";
	Console.WriteLine("1: " + outerVar);    // imprime "1: Texte modifié de portée intérieure"
	Console.WriteLine("2: " + innerVar);    // imprime "2: Texte de portée intérieure"
}

Console.WriteLine("3: " + outerVar);		// imprime "3: "Texte modifié de portée intérieure"
// Tenter d'imprimer 'innerVar' ici échouerait

Instructions conditionnelles

Instructions conditionnelles dans Luau

-- Une condition
if boolExpression then
	doSomething()
end

-- Plusieurs conditions
if not boolExpression then
	doSomething()
elseif otherBoolExpression then
	doSomething()
else
	doSomething()
end

Instructions conditionnelles en C#

// Une condition
if (boolExpression) {
	doSomething();
}


// Plusieurs 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

Opérateur conditionnel en 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

Boucles While et Repeat en C#

while (boolExpression) {
	doSomething();
}

do {
	doSomething();
} while (boolExpression)

Boucles For

Boucles For générales dans Luau

-- Boucle avancée
for i = 1, 10 do
	doSomething()
end

-- Boucle inversée
for i = 10, 1, -1 do
	doSomething()
end

Boucles For générales en C#

// Boucle avancée
for (int i = 1; i <= 10; i++) {
	doSomething();
}

// Boucle inversée
for (int i = 10; i >= 1; i--) {
	doSomething();
}

Boucles For sur des 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

Boucles For sur des listes 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 prend également en charge l'itération généralisée, qui simplifie encore plus le travail avec les 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

Fonctions génériques en C#

// Fonction générique
int increment(int number) {
	return number + 1;
}

Nombre d'arguments variable

Nombre d'arguments variable dans Luau

-- Nombre d'arguments variable
local function variableArguments(...)
	print(...)
end

Nombre d'arguments variable en C#

// Nombre d'arguments variable
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="01/04/2000"}

Arguments nommés en C#

// Arguments nommés
string namedArguments(string name, string dob) {
	return name + "'s birthday: " + dob;
}

namedArguments(name: "Bob", dob: "01/04/2000");

Structures try-catch

Structures Try/Catch dans Luau

local function fireWeapon()
	if not weaponEquipped then
		error("Pas d'arme équipée !")
	end
	-- Poursuivre...
end

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

Structures Try/Catch en C#

void fireWeapon() {
	if (!weaponEquipped) {
		// Utiliser une exception définie par l'utilisateur
		throw new InvalidWeaponException("Pas d'arme équipée !");
	}
	// Poursuivre...
}

try {
	fireWeapon();
} catch (InvalidWeaponException ex) {
	// Une erreur a été levée
}