Vergleich von Luau und C# | Dokumentation

Roblox verwendet die Programmiersprache Luau. Die folgenden Codebeispiele und Tabellen zeigen einige der Unterschiede zwischen der Syntax von C# und Luau.

Zeilenenden

Du benötigst in Luau keine Semikolons, aber sie brechen die Syntax nicht.

Reservierte Schlüsselwörter

Die folgende Tabelle zeigt die reservierten Schlüsselwörter von Luau im Vergleich zu den entsprechenden C#-Äquivalenten. Beachte, dass nicht alle C#-Schlüsselwörter gezeigt werden.

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

Kommentare

Kommentare in Luau

-- Einzeiliger Kommentar

--[[ Ergebnis:
	Block Kommentar
--]]

Kommentare in C#

// Einzeiliger Kommentar

/*
	Block Kommentar
*/

Strings

Strings in Luau

-- Mehrzeiliger String
local multiLineString = [[Das ist ein String, der,
beim Drucken
auf mehreren Zeilen erscheint]]

-- Verkettung
local s1 = "Das ist ein String "
local s2 = "bestehend aus zwei Teilen."
local endString = s1 .. s2

Strings in C#

// Mehrzeiliger String
string multiLineString1 = "Das ist ein String,\nbeim Drucken erscheint\n auf mehreren Zeilen.";

string multiLineString2 = @"Das ist ein String, der,
beim Drucken erscheint
auf mehreren Zeilen";

// Verkettung
string s1 = "Das ist ein String ";
string s2 = "bestehend aus zwei Teilen.";
string endString = s1 + s2;

Tabellen

Um mehr über Tabellen in Luau zu erfahren, siehe Tabellen.

Dictionary-Tabellen

Du kannst Tabellen in Luau wie Dictionaries, genau wie in C# verwenden.

Dictionary-Tabellen in Luau

local dictionary = {
	val1 = "dies",
	val2 = "ist"
}

print(dictionary.val1)  -- Gibt 'dies' aus
print(dictionary["val1"])  -- Gibt 'dies' aus

dictionary.val1 = nil  -- Entfernt 'val1' aus der Tabelle
dictionary["val3"] = "ein Dictionary"  -- Überschreibt 'val3' oder setzt ein neues Schlüssel-Wert-Paar

Dictionary-Tabellen in C#

Dictionary dictionary = new Dictionary()
{
	{ "val1", "dies" },
	{ "val2", "ist" }
};

Console.WriteLine(dictionary["val1"]);  // Gibt 'dies' aus
dictionary.Remove("val1");  // Entfernt 'val1' aus dem Dictionary

dictionary["val3"] = "ein Dictionary";  // Überschreibt 'val3' oder setzt ein neues Schlüssel-Wert-Paar
dictionary.Add("val3", "ein Dictionary");  // Erstellt ein neues Schlüssel-Wert-Paar

Numerisch indizierte Tabellen

Du kannst Tabellen in Luau wie Arrays verwenden, genau wie in C#. Indizes beginnen bei 1 in Luau und 0 in C#.

Numerisch indizierte Tabellen in Luau

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

print(npcAttributes[1])  -- Gibt 'stark' aus
print(#npcAttributes)  -- Gibt die Größe der Liste aus

-- An die Liste anhängen
table.insert(npcAttributes, "bescheiden")
-- Eine andere Möglichkeit...
npcAttributes[#npcAttributes+1] = "bescheiden"

-- Am Anfang der Liste einfügen
table.insert(npcAttributes, 1, "mutig")

-- Element an einem bestimmten Index entfernen
table.remove(npcAttributes, 3)

Numerisch indizierte Tabellen in C#

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

Console.WriteLine(npcAttributes[0]);  // Gibt 'stark' aus
Console.WriteLine(npcAttributes.Count);  // Gibt die Größe der Liste aus

// An die Liste anhängen
npcAttributes.Add("bescheiden");
// Eine andere Möglichkeit...
npcAttributes.Insert(npcAttributes.Count, "bescheiden");

// Am Anfang der Liste einfügen
npcAttributes.Insert(0, "mutig");

// Element an einem bestimmten Index entfernen
npcAttributes.Remove(2);

Operatoren

Bedingte Operatoren

Operator	Luau	C#
Gleich	==	==
Größer als	>	>
Kleiner als	<	<
Größer oder gleich	>=	>=
Kleiner oder gleich	<=	<=
Nicht gleich	~=	!=
Und	and	&&
Oder	or	\|\|

Arithmetische Operatoren

	Luau	C#
Addition	+	+
Subtraktion	-	-
Multiplikation	*	*
Division	/	/
Modulus	%	%
Exponentiation	^	**

In Luau geben Variablen bei ihrer Deklaration ihren Typ nicht an. Luau-Variablen haben keine Zugriffsmodifikatoren, obwohl du "private" Variablen zur besseren Lesbarkeit mit einem Unterstrich versehen kannst.

Variablen in Luau

local stringVariable = "wert"

-- "Öffentliche" Deklaration
local variableName

-- "Private" Deklaration - wird gleich interpretiert
local _variableName

Variablen in C#

string stringVariable = "wert";

// Öffentliche Deklaration
public string variableName

// Private Deklaration
string variableName;

Gültigkeitsbereich

In Luau kannst du Variablen und Logik in einem engeren Gültigkeitsbereich schreiben als in ihrer Funktion oder Klasse, indem du die Logik innerhalb der Schlüsselwörter do und end schachtelst, ähnlich wie geschweifte Klammern {} in C#. Für weitere Details siehe Gültigkeitsbereich.

Gültigkeitsbereich in Luau

local outerVar = 'Text aus äußerem Gültigkeitsbereich'

do
    -- Änderung von 'outerVar'
    outerVar = 'Text aus innerem Gültigkeitsbereich geändert'
    -- Einführung einer lokalen Variablen
    local innerVar = 'Text aus innerem Gültigkeitsbereich'
    print('1: ' .. outerVar)    -- gibt "1: Text aus innerem Gültigkeitsbereich geändert" aus
    print('2: ' .. innerVar)    -- gibt "2: Text aus innerem Gültigkeitsbereich" aus
end

print('3: ' .. outerVar)        -- gibt "3: Text aus innerem Gültigkeitsbereich geändert" aus
-- Der Versuch, 'innerVar' hier auszugeben, würde fehlschlagen

Gültigkeitsbereich in C#

var outerVar = "Text aus äußerem Gültigkeitsbereich";

{
	// Änderung von 'outerVar'
	outerVar = "Text aus innerem Gültigkeitsbereich geändert";
	// Einführung einer lokalen Variablen
	var innerVar = "Text aus innerem Gültigkeitsbereich";
	Console.WriteLine("1: " + outerVar);    // gibt "1: Text aus innerem Gültigkeitsbereich geändert" aus
	Console.WriteLine("2: " + innerVar);    // gibt "2: Text aus innerem Gültigkeitsbereich" aus
}

Console.WriteLine("3: " + outerVar);		// gibt "3: Text aus innerem Gültigkeitsbereich geändert" aus
// Der Versuch, 'innerVar' hier auszugeben, würde fehlschlagen

Bedingte Anweisungen

Bedingte Anweisungen in Luau

-- Eine Bedingung
if boolExpression then
	doSomething()
end

-- Mehrere Bedingungen
if not boolExpression then
	doSomething()
elseif otherBoolExpression then
	doSomething()
else
	doSomething()
end

Bedingte Anweisungen in C#

// Eine Bedingung
if (boolExpression) {
	doSomething();
}


// Mehrere Bedingungen
if (!boolExpression) {
	doSomething();
}
else if (otherBoolExpression) {
	doSomething();
}
else {
	doSomething();
}

Bedingter Operator

Bedingter Operator in Luau

local max = if x > y then x else y

Bedingter Operator in C#

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

Schleifen

Um mehr über Schleifen in Luau zu erfahren, siehe Kontrollstrukturen.

While- und Repeat-Schleifen

While- und Repeat-Schleifen in Luau

while boolExpression do
	doSomething()
end

repeat
	doSomething()
until not boolExpression

While- und Repeat-Schleifen in C#

while (boolExpression) {
	doSomething();
}

do {
	doSomething();
} while (boolExpression)

For-Schleifen

Generische For-Schleifen in Luau

-- Vorwärts-Schleife
for i = 1, 10 do
	doSomething()
end

-- Rückwärts-Schleife
for i = 10, 1, -1 do
	doSomething()
end

Generische For-Schleifen in C#

// Vorwärts-Schleife
for (int i = 1; i <= 10; i++) {
	doSomething();
}

// Rückwärts-Schleife
for (int i = 10; i >= 1; i--) {
	doSomething();
}

For-Schleifen über Tabellen in 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-Schleifen über Listen 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 unterstützt auch generalisierte Iteration, die die Arbeit mit Tabellen weiter vereinfacht.

Funktionen

Um mehr über Funktionen in Luau zu erfahren, siehe Funktionen.

Generische Funktionen

Generische Funktionen in Luau

-- Generische Funktion
local function increment(number)
	return number + 1
end

Generische Funktionen in C#

// Generische Funktion
int increment(int number) {
	return number + 1;
}

Variable Argumentanzahl

Variable Argumentanzahl in Luau

-- Variable Argumentanzahl
local function variableArguments(...)
	print(...)
end

Variable Argumentanzahl in C#

// Variable Argumentanzahl
void variableArguments(params string[] inventoryItems) {
	for (item in inventoryItems) {
		Console.WriteLine(item);
	}
}

Benannte Argumente

Benannte Argumente in Luau

-- Benannte Argumente
local function namedArguments(args)
	return args.name .. "'s Geburtstag: " .. args.dob
end

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

Benannte Argumente in C#

// Benannte Argumente
string namedArguments(string name, string dob) {
	return name + "'s Geburtstag: " + dob;
}

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

Try-Catch-Strukturen

Try/Catch-Strukturen in Luau

local function fireWeapon()
	if not weaponEquipped then
		error("Keine Waffe ausgerüstet!")
	end
	-- Fortfahren...
end

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

Try/Catch-Strukturen in C#

void fireWeapon() {
	if (!weaponEquipped) {
		// Benutzerdefinierte Ausnahme verwenden
		throw new InvalidWeaponException("Keine Waffe ausgerüstet!");
	}
	// Fortfahren...
}

try {
	fireWeapon();
} catch (InvalidWeaponException ex) {
	// Ein Fehler wurde ausgelöst
}