Vergleich von Luau und C#

Kommentare in Luau
-- Einzeiliger Kommentar

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

Kommentare in C#
// Einzeiliger Kommentar

/*
	Block Kommentar
*/

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;

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 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);

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
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 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 in Luau
local max = if x > y then x else y

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

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)

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);
}

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 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 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 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
}