From c5b6113677e6d1a596d7e5ca53c642482412cacd Mon Sep 17 00:00:00 2001 From: Martin Schimandl Date: Sun, 11 Oct 2015 08:38:45 +0200 Subject: Improve grammar and correct spelling errors. --- de-de/lua-de.html.markdown | 91 +++++++++++++++++++++++----------------------- 1 file changed, 45 insertions(+), 46 deletions(-) (limited to 'de-de') diff --git a/de-de/lua-de.html.markdown b/de-de/lua-de.html.markdown index 875629ad..eccfcf1e 100644 --- a/de-de/lua-de.html.markdown +++ b/de-de/lua-de.html.markdown @@ -12,33 +12,33 @@ filename: learnlua-de.lua --[[ Fügt man zwei '[' und ']' hinzu, - erzeugt man ein mehrzeiliges Kommentar. + erzeugt man einen mehrzeiligen Kommentar. --]] -------------------------------------------------------------------------------- -- 1. Variablen und Fluß-Kontrolle. -------------------------------------------------------------------------------- -num = 42 -- All Nummern sind vom Typ: Double. +num = 42 -- Alle Nummern sind vom Typ: Double. -- Werd nicht nervös, 64-Bit Double haben 52 Bits zum Speichern von exakten -- Ganzzahlen; Maschinen-Genauigkeit ist kein Problem für Ganzzahlen kleiner als -- 52 Bit. -s = 'walternate' -- Unveränderliche Zeichenkette wie by Python. +s = 'walternate' -- Zeichenketten sind unveränderlich, wie bei Python. t = "Doppelte Anführungszeichen sind auch OK" u = [[ Doppelte eckige Klammern beginnen und beenden mehrzeilige Zeichenketten.]] -t = nil -- Undefineren von t; Lua hat Garbage Collection. +t = nil -- Undefineren von t; Lua hat einen Garbage Collection. --- Blöcke werden durch Schlüsselwörter markiert wie do/end: +-- Blöcke werden durch Schlüsselwörter wie do/end markiert: while num < 50 do - num = num + 1 -- Keine Operatoren wie ++ oder += + num = num + 1 -- Es gibt Keine Operatoren wie ++ oder += end -- If Bedingungen: if num > 40 then print('over 40') -elseif s ~= 'walternate' then -- ~= ist ungleich +elseif s ~= 'walternate' then -- ~= bedeutet ungleich -- Gleichheits-Check == wie bei Python; OK für Zeichenketten. io.write('not over 40\n') -- Standard ist stdout. else @@ -94,7 +94,7 @@ end -- Closures und anonyme Funktionen sind ok: function adder(x) - -- Die zurückgegbe Funktion wird erzeugt wenn addr aufgerufen wird und merkt + -- Die zurückgegebene Funktion wird erzeugt wenn addr aufgerufen wird und merkt -- sich den Wert von x: return function (y) return x + y end end @@ -103,12 +103,12 @@ a2 = adder(36) print(a1(16)) --> 25 print(a2(64)) --> 100 --- Rückgabewerte. Funktions-Aufrufe und Zuweisungen funktionieren all mit --- Listen die nicht immer gleich lang sein müssen. Überzählige Empfanger --- bekommen nil; überzählige Sende werden entfernt. +-- Rückgabewerte, Funktions-Aufrufe und Zuweisungen funktionieren alle mit +-- Listen die nicht immer gleich lang sein müssen. Überzählige Empfänger +-- bekommen nil; überzählige Sender werden ignoriert. x, y, z = 1, 2, 3, 4 --- Nun ist x = 1, y = 2, z = 3, und 4 wird entfernt. +-- Nun ist x = 1, y = 2, z = 3, und 4 wird ignoriert. function bar(a, b, c) print(a, b, c) @@ -116,30 +116,30 @@ function bar(a, b, c) end x, y = bar('zaphod') --> prints "zaphod nil nil" --- Nun ist x = 4, y = 8, die Werte 15..42 werden entfernt. +-- Nun ist x = 4, y = 8, die Werte 15..42 werden ignoriert. -- Funktionen sind erste Klasse, und können lokal oder global sein. -- Das ist alles das Gleiche: function f(x) return x * x end f = function (x) return x * x end --- Und diese auch: +-- Das auch: local function g(x) return math.sin(x) end local g = function(x) return math.sin(x) end -- Äquivalent zu local function g(x)..., außer das Referenzen auf g im -- Funktions-Körper nicht wie erwartet funktionieren. local g; g = function (x) return math.sin(x) end --- Die 'local g' Deklaration macht G-Selbst-Referenzen OK. +-- Die Deklaration 'local g' macht Selbst-Referenzen auf g OK. -- Nebenbei gesagt, Trigonometrie-Funktionen verwenden Radianten. -- Funktionsaufrufe mit nur einem Zeichenketten-Parameter brauch keine runden -- Klammern. -print 'hello' -- Works fine. +print 'hello' -- Funktioniert wunderbar. --- Funktionsaufruge mit einem Tabellen-Parameter brauchen auch keine runden --- Klammern. Mehr zu Tabellen später. -print {} -- Works fine too. +-- Funktionsaufrufe mit einem Tabellen-Parameter brauchen auch keine runden +-- Klammern. Mehr zu Tabellen kommt später. +print {} -- Funktioniert auch wunderbar. -------------------------------------------------------------------------------- -- 3. Tabellen. @@ -151,19 +151,18 @@ print {} -- Works fine too. -- werden können. -- Verwenden von Tabellen als Dictionaries oder Maps: --- Using tables as dictionaries / maps: --- Dict lieterale haben standardmäßig Zeichenketten-Schlüssel: +-- Dict-Literale haben standardmäßig Zeichenketten als Schlüssel: t = {key1 = 'value1', key2 = false} --- Zeichenketten-Schlüssel verwenden ein JavaScript ähnliche Punkt-Notation. +-- Zeichenketten-Schlüssel verwenden eine JavaScript ähnliche Punkt-Notation. print(t.key1) -- Ausgabe 'value1'. -t.newKey = {} -- Neues Schlüssel/Wert Paar hinzufügen. +t.newKey = {} -- Neues Schlüssel/Wert-Paar hinzufügen. t.key2 = nil -- key2 aus der Tabelle entfernen. -- Literale notation für jeden (nicht-nil) Wert als Schlüssel: u = {['@!#'] = 'qbert', [{}] = 1729, [6.28] = 'tau'} -print(u[6.28]) -- ausgabe "tau" +print(u[6.28]) -- Ausgabe "tau" -- Schlüssel-Vergleiche funktionieren per Wert für Nummern und Zeichenketten, -- aber über die Identität bei Tabellen. @@ -176,9 +175,9 @@ b = u[{}] -- Wir würden 1729 erwarten, aber es ist nil: -- Eine Funktion mit nur einem Tabellen-Parameter benötigt keine Klammern. function h(x) print(x.key1) end -h{key1 = 'Sonmi~451'} -- Prints 'Sonmi~451'. +h{key1 = 'Sonmi~451'} -- Ausgabe 'Sonmi~451'. -for key, val in pairs(u) do -- Tabellen-Interation. +for key, val in pairs(u) do -- Tabellen-Iteration. print(key, val) end @@ -193,14 +192,14 @@ for i = 1, #v do -- #v ist die Größe von v für Listen. print(v[i]) -- Indices beginnen mit 1 !! SO VERRÜCKT! end -- Eine 'Liste' ist kein echter Typ. v ist nur eine Tabelle mit fortlaufenden --- Ganzzahlen als Schlüssel, behandelt wie eine Liste. +-- Ganzzahlen als Schlüssel, die behandelt wird wie eine Liste. -------------------------------------------------------------------------------- -- 3.1 Metatabellen und Metamethoden -------------------------------------------------------------------------------- --- Eine Tabelle kann eine Metatabelle haben die ihr so etwas wie --- Tabellen-Operator-Überladungs-Verhalten verleiht. Später sehen wir wie +-- Eine Tabelle kann eine Metatabelle haben. Diese verleiht ihr so etwas wie +-- Tabellen-Operator-Überladungs-Verhalten. Später sehen wir wie -- Metatabellen js-prototypen artiges Verhalten unterstützen. f1 = {a = 1, b = 2} -- Repräsentiert den Bruch a/b. @@ -220,9 +219,9 @@ end setmetatable(f1, metafraction) setmetatable(f2, metafraction) -s = f1 + f2 -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf +s = f1 + f2 -- Rufe __add(f1, f2) vom der Metatabelle von f1 auf. --- f1 und f2 haben keine Schlüssel für ihrer Metatabellen, anders als bei js +-- f1 und f2 haben keine Schlüssel für ihre Metatabellen, anders als bei js -- Prototypen. Daher muss mithilfe von getmetatable(f1) darauf zugegriffen -- werden. Eine Metatabelle ist wie eine normale Tabelle mit Schlüsseln die -- Lua bekannt sind, so wie __add. @@ -247,7 +246,7 @@ eatenBy = myFavs.animal -- Funktioniert dank Metatabelle! -- Damit kann man Lookups weiter anpassen. -- Werte wie __index,add, .. werden Metamethoden genannt. --- Vollständige Liste aller Metamethoden. +-- HIer eine vollständige Liste aller Metamethoden. -- __add(a, b) für a + b -- __sub(a, b) für a - b @@ -266,10 +265,10 @@ eatenBy = myFavs.animal -- Funktioniert dank Metatabelle! -- __call(a, ...) für a(...) -------------------------------------------------------------------------------- --- 3.2 Klassen-Artihe Tabellen und vererbung. +-- 3.2 Klassen-Artige Tabellen und Vererbung. -------------------------------------------------------------------------------- --- Klassen sind in Lua nicht eingebaut; es gibt verschieden Wege sie mithilfe +-- Klassen sind in Lua nicht eingebaut. Es gibt verschieden Wege sie mithilfe -- von Tabellen und Metatabellen zu erzeugen. -- Die Erklärund des Beispiels erfolgt unterhalb. @@ -294,7 +293,7 @@ mrDog:makeSound() -- 'I say woof' -- 8. -- "function tablename.fn(self, ...)", Der : fügt nur ein Argument namens -- self hinzu. Siehe 7 & 8 um zu sehen wie self seinen Wert bekommt. -- 3. newObj wird eine Instanz von Dog. --- 4. "self" ist die zu Instanzierende Klasse. Meisterns ist self = Doh, aber +-- 4. "self" ist die zu Instanzierende Klasse. Meistern ist self = Dog, aber -- dies kann durch Vererbung geändert werden. newObj bekommt die Funktionen -- von self wenn wir die Metatabelle von newObj und __index von self auf -- self setzen. @@ -325,12 +324,12 @@ seymour:makeSound() -- 'woof woof woof' -- 4. -- denn LoudDog hat keinen 'new' Schlüssel, aber "__index = Dog" steht in der -- Metatabelle. -- Ergebnis: Die Metatabelle von seymour ist LoudDog und "LoudDog.__index = Dog". --- Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nacdem +-- Daher ist seymour.key gleich seymour.key, LoudDog.key, Dog.key, je nachdem -- welche Tabelle als erstes einen passenden Schlüssel hat. -- 4. Der 'makeSound' Schlüssel wird in LoudDog gefunden: Das ist das Gleiche -- wie "LoudDog.makeSound(seymour)". --- Wenn nötig, sieht new() eine Sub-Klasse genau so aus wie new() der +-- Wenn nötig, sieht new() einer Sub-Klasse genau so aus wie new() der -- Basis-Klasse: function LoudDog:new() local newObj = {} @@ -374,13 +373,13 @@ end)() -- Es ist als ob mod.lua eine Funktion wäre, sodass lokale Variablen in -- mod.lua ausserhalb unsichtbar sind. --- Das funktioniert weil mod hier ist M in mod.lua: +-- Das funktioniert weil mod hier das Gleiche wie M in mod.lua ist: mod.sayHello() -- Says hello to Hrunkner. --- Das ist Falsch: syMyName existiert nur in mod.lua: -mod.sayMyName() -- error +-- Das ist Falsch: sayMyName existiert nur in mod.lua: +mod.sayMyName() -- Fehler --- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass module nur +-- Der Rückgabe-Wert von require wird zwischengespeichert. Sodass Module nur -- einmal abgearbeitet werden, auch wenn sie mit require öfters eingebunden -- werden. @@ -397,14 +396,14 @@ f = loadfile('mod2') -- Sobald f() aufgerufen wird läuft mod2.lua. -- loadstring ist loadfile für Zeichenketten g = loadstring('print(343)') -- Gibt eine Funktion zurück.. -g() -- Ausgabe 343; Es kam keine Ausgabe bevor hier. +g() -- Ausgabe 343; Vorher kam keine Ausgabe. --]] ``` ## Referenzen -Ich war so begeistert Lua zu lernen, um damit Spiele mit Love 2D game engine zu programmieren. +Ich war so begeistert Lua zu lernen, damit ich Spiele mit Love 2D game engine programmieren konnte. Ich habe angefangen mit BlackBulletIV's Lua for programmers. Danach habe ich das offizielle Lua Buch gelesen: Programming in Lua @@ -412,7 +411,7 @@ Danach habe ich das offizielle Lua Buch gelesen: Lua short reference -Wichtige Themen die hier nicht angesprochen wurden, die Standard-Bibliotheken: +Wichtige Themen die hier nicht angesprochen wurden; die Standard-Bibliotheken: * string library * table library @@ -420,7 +419,7 @@ Wichtige Themen die hier nicht angesprochen wurden, die Standard-Bibliotheken: * io library * os library -Übrigends, die gesamte Datei ist gültiges Lua. Speichere es als learn.lua und -starte es als "lua learn.lua" ! +Übrigends, die gesamte Datei ist gültiges Lua. Speichere sie als learn.lua und +starte sie als "lua learn.lua" ! Die Erstfassung ist von tylerneylon.com, und ist auch hier verfügbar: github gist. Viel Spaß mit Lua! -- cgit v1.2.3