From d63779ec0a6f00854f53b48b0f6a67707879b6d1 Mon Sep 17 00:00:00 2001 From: Li Jin Date: Thu, 12 Feb 2026 10:29:07 +0800 Subject: Updated docs. --- doc/docs/de/doc/advanced/do.md | 22 ++- doc/docs/de/doc/advanced/module.md | 253 ----------------------------- doc/docs/de/doc/control-flow/for-loop.md | 16 +- doc/docs/de/doc/control-flow/while-loop.md | 42 ++++- doc/docs/de/doc/language-basics/module.md | 253 +++++++++++++++++++++++++++++ doc/docs/de/doc/objects/with-statement.md | 44 +++++ 6 files changed, 374 insertions(+), 256 deletions(-) delete mode 100644 doc/docs/de/doc/advanced/module.md create mode 100644 doc/docs/de/doc/language-basics/module.md (limited to 'doc/docs/de') diff --git a/doc/docs/de/doc/advanced/do.md b/doc/docs/de/doc/advanced/do.md index 265a5ba..c6c41cf 100644 --- a/doc/docs/de/doc/advanced/do.md +++ b/doc/docs/de/doc/advanced/do.md @@ -20,7 +20,27 @@ print var -- nil hier -YueScripts **do** kann auch als Ausdruck verwendet werden. So kannst du mehrere Zeilen in einem Ausdruck kombinieren. Das Ergebnis des `do`-Ausdrucks ist die letzte Anweisung im Block. +YueScripts **do** kann auch als Ausdruck verwendet werden. So kannst du mehrere Zeilen in einem Ausdruck kombinieren. Das Ergebnis des `do`-Ausdrucks ist die letzte Anweisung im Block. `do`-Ausdrücke unterstützen die Verwendung von `break`, um den Kontrollfluss zu unterbrechen und mehrere Rückgabewerte vorzeitig zurückzugeben. + +```yuescript +status, value = do + n = 12 + if n > 10 + break "large", n + break "small", n +``` + + + +```yue +status, value = do + n = 12 + if n > 10 + break "large", n + break "small", n +``` + + ```yuescript counter = do diff --git a/doc/docs/de/doc/advanced/module.md b/doc/docs/de/doc/advanced/module.md deleted file mode 100644 index f20deec..0000000 --- a/doc/docs/de/doc/advanced/module.md +++ /dev/null @@ -1,253 +0,0 @@ -# Module - -## Import - -Die `import`-Anweisung ist syntaktischer Zucker für `require` und hilft beim Extrahieren von Einträgen aus importierten Modulen. Importierte Elemente sind standardmäßig `const`. - -```yuescript --- als Tabellen-Destrukturierung -do - import insert, concat from table - -- Fehler beim Zuweisen zu insert, concat - import C, Ct, Cmt from require "lpeg" - -- Kurzform für implizites Require - import x, y, z from 'mymodule' - -- Import im Python-Stil - from 'module' import a, b, c - --- Kurzform zum Laden eines Moduls -do - import 'module' - import 'module_x' - import "d-a-s-h-e-s" - import "module.part" - --- Modul mit Alias oder Tabellen-Destrukturierung laden -do - import "player" as PlayerModule - import "lpeg" as :C, :Ct, :Cmt - import "export" as {one, two, Something:{umm:{ch}}} -``` - - - -```yue --- als Tabellen-Destrukturierung -do - import insert, concat from table - -- Fehler beim Zuweisen zu insert, concat - import C, Ct, Cmt from require "lpeg" - -- Kurzform für implizites Require - import x, y, z from 'mymodule' - -- Import im Python-Stil - from 'module' import a, b, c - --- Kurzform zum Laden eines Moduls -do - import 'module' - import 'module_x' - import "d-a-s-h-e-s" - import "module.part" - --- Modul mit Alias oder Tabellen-Destrukturierung laden -do - import "player" as PlayerModule - import "lpeg" as :C, :Ct, :Cmt - import "export" as {one, two, Something:{umm:{ch}}} -``` - - - -## Import von Globals - -Du kannst mit `import` bestimmte Globals in lokale Variablen importieren. Wenn du eine Kette von Globalzugriffen importierst, wird das letzte Feld der lokalen Variable zugewiesen. - -```yuescript -do - import tostring - import table.concat - print concat ["a", tostring 1] -``` - - - -```yue -do - import tostring - import table.concat - print concat ["a", tostring 1] -``` - - - -### Automatischer Global-Import - -Du kannst `import global` am Anfang eines Blocks platzieren, um automatisch alle Namen zu importieren, die im aktuellen Scope nicht explizit deklariert oder zugewiesen sind. Diese impliziten Importe werden als lokale `const` behandelt, die an die entsprechenden Globals zum Zeitpunkt der Anweisung gebunden sind. - -Namen, die im selben Scope explizit als `global` deklariert werden, werden nicht importiert, sodass du sie weiterhin zuweisen kannst. - -```yuescript -do - import global - print "hallo" - math.random 3 - -- print = nil -- Fehler: importierte Globals sind const - -do - -- explizite globale Variable wird nicht importiert - import global - global FLAG - print FLAG - FLAG = 123 -``` - - - -```yue -do - import global - print "hallo" - math.random 3 - -- print = nil -- Fehler: importierte Globals sind const - -do - -- explizite globale Variable wird nicht importiert - import global - global FLAG - print FLAG - FLAG = 123 -``` - - - -## Export - -Die `export`-Anweisung bietet eine knappe Möglichkeit, Module zu definieren. - -### Benannter Export - -Benannter Export definiert eine lokale Variable und fügt ein Feld in die exportierte Tabelle ein. - -```yuescript -export a, b, c = 1, 2, 3 -export cool = "Katze" - -export What = if this - "abc" -else - "def" - -export y = -> - hallo = 3434 - -export class Something - umm: "cool" -``` - - - -```yue -export a, b, c = 1, 2, 3 -export cool = "Katze" - -export What = if this - "abc" -else - "def" - -export y = -> - hallo = 3434 - -export class Something - umm: "cool" -``` - - - -Benannter Export mit Destructuring. - -```yuescript -export :loadstring, to_lua: tolua = yue -export {itemA: {:fieldA = 'default'}} = tb -``` - - - -```yue -export :loadstring, to_lua: tolua = yue -export {itemA: {:fieldA = 'default'}} = tb -``` - - - -Benannte Elemente aus dem Modul exportieren, ohne lokale Variablen zu erstellen. - -```yuescript -export.itemA = tb -export. = items -export["a-b-c"] = 123 -``` - - - -```yue -export.itemA = tb -export. = items -export["a-b-c"] = 123 -``` - - - -### Unbenannter Export - -Unbenannter Export fügt das Ziel-Element in den Array-Teil der exportierten Tabelle ein. - -```yuescript -d, e, f = 3, 2, 1 -export d, e, f - -export if this - 123 -else - 456 - -export with tmp - j = 2000 -``` - - - -```yue -d, e, f = 3, 2, 1 -export d, e, f - -export if this - 123 -else - 456 - -export with tmp - j = 2000 -``` - - - -### Default-Export - -Mit dem Schlüsselwort **default** in einer `export`-Anweisung wird die exportierte Tabelle durch ein beliebiges Objekt ersetzt. - -```yuescript -export default -> - print "hallo" - 123 -``` - - - -```yue -export default -> - print "hallo" - 123 -``` - - diff --git a/doc/docs/de/doc/control-flow/for-loop.md b/doc/docs/de/doc/control-flow/for-loop.md index 827d983..16b5418 100644 --- a/doc/docs/de/doc/control-flow/for-loop.md +++ b/doc/docs/de/doc/control-flow/for-loop.md @@ -86,7 +86,7 @@ doubled_evens = for i = 1, 20 -Zusätzlich unterstützen `for`-Schleifen `break` mit Rückgabewert, sodass die Schleife selbst als Ausdruck verwendet werden kann, der früh mit einem sinnvollen Ergebnis endet. +Zusätzlich unterstützen `for`-Schleifen `break` mit Rückgabewerten, sodass die Schleife selbst als Ausdruck verwendet werden kann, der früh mit einem sinnvollen Ergebnis endet. `for`-Ausdrücke unterstützen mehrere `break`-Werte. Beispiel: die erste Zahl größer als 10 finden: @@ -106,6 +106,20 @@ first_large = for n in *numbers Diese `break`-mit-Wert-Syntax ermöglicht knappe und ausdrucksstarke Such- bzw. Early-Exit-Muster direkt in Schleifenausdrücken. +```yuescript +key, score = for k, v in pairs data + break k, v * 10 if k == "target" +``` + + + +```yue +key, score = for k, v in pairs data + break k, v * 10 if k == "target" +``` + + + Du kannst Werte auch filtern, indem du den `for`-Ausdruck mit `continue` kombinierst. `for`-Schleifen am Ende eines Funktionsrumpfs werden nicht in eine Tabelle für einen Rückgabewert gesammelt (stattdessen gibt die Funktion `nil` zurück). Du kannst entweder explizit `return` verwenden oder die Schleife in eine Listen-Comprehension umwandeln. diff --git a/doc/docs/de/doc/control-flow/while-loop.md b/doc/docs/de/doc/control-flow/while-loop.md index 6d9f089..98776ec 100644 --- a/doc/docs/de/doc/control-flow/while-loop.md +++ b/doc/docs/de/doc/control-flow/while-loop.md @@ -45,7 +45,25 @@ until running == false do my_function! -Wie bei `for`-Schleifen kann die `while`-Schleife auch als Ausdruck verwendet werden. Damit eine Funktion den akkumulierten Wert einer `while`-Schleife zurückgibt, muss die Anweisung explizit mit `return` zurückgegeben werden. +Wie bei `for`-Schleifen kann die `while`-Schleife auch als Ausdruck verwendet werden. `while`- und `until`-Ausdrücke unterstützen `break` mit mehreren Rückgabewerten. + +```yuescript +value, doubled = while true + n = get_next! + break n, n * 2 if n > 10 +``` + + + +```yue +value, doubled = while true + n = get_next! + break n, n * 2 if n > 10 +``` + + + +Damit eine Funktion den akkumulierten Wert einer `while`-Schleife zurückgibt, muss die Anweisung explizit mit `return` zurückgegeben werden. ## Repeat-Schleife @@ -70,3 +88,25 @@ until i == 0 ``` + +`repeat`-Ausdrücke unterstützen ebenfalls `break` mit mehreren Rückgabewerten: + +```yuescript +i = 1 +value, scaled = repeat + break i, i * 100 if i > 3 + i += 1 +until false +``` + + + +```yue +i = 1 +value, scaled = repeat + break i, i * 100 if i > 3 + i += 1 +until false +``` + + diff --git a/doc/docs/de/doc/language-basics/module.md b/doc/docs/de/doc/language-basics/module.md new file mode 100644 index 0000000..f20deec --- /dev/null +++ b/doc/docs/de/doc/language-basics/module.md @@ -0,0 +1,253 @@ +# Module + +## Import + +Die `import`-Anweisung ist syntaktischer Zucker für `require` und hilft beim Extrahieren von Einträgen aus importierten Modulen. Importierte Elemente sind standardmäßig `const`. + +```yuescript +-- als Tabellen-Destrukturierung +do + import insert, concat from table + -- Fehler beim Zuweisen zu insert, concat + import C, Ct, Cmt from require "lpeg" + -- Kurzform für implizites Require + import x, y, z from 'mymodule' + -- Import im Python-Stil + from 'module' import a, b, c + +-- Kurzform zum Laden eines Moduls +do + import 'module' + import 'module_x' + import "d-a-s-h-e-s" + import "module.part" + +-- Modul mit Alias oder Tabellen-Destrukturierung laden +do + import "player" as PlayerModule + import "lpeg" as :C, :Ct, :Cmt + import "export" as {one, two, Something:{umm:{ch}}} +``` + + + +```yue +-- als Tabellen-Destrukturierung +do + import insert, concat from table + -- Fehler beim Zuweisen zu insert, concat + import C, Ct, Cmt from require "lpeg" + -- Kurzform für implizites Require + import x, y, z from 'mymodule' + -- Import im Python-Stil + from 'module' import a, b, c + +-- Kurzform zum Laden eines Moduls +do + import 'module' + import 'module_x' + import "d-a-s-h-e-s" + import "module.part" + +-- Modul mit Alias oder Tabellen-Destrukturierung laden +do + import "player" as PlayerModule + import "lpeg" as :C, :Ct, :Cmt + import "export" as {one, two, Something:{umm:{ch}}} +``` + + + +## Import von Globals + +Du kannst mit `import` bestimmte Globals in lokale Variablen importieren. Wenn du eine Kette von Globalzugriffen importierst, wird das letzte Feld der lokalen Variable zugewiesen. + +```yuescript +do + import tostring + import table.concat + print concat ["a", tostring 1] +``` + + + +```yue +do + import tostring + import table.concat + print concat ["a", tostring 1] +``` + + + +### Automatischer Global-Import + +Du kannst `import global` am Anfang eines Blocks platzieren, um automatisch alle Namen zu importieren, die im aktuellen Scope nicht explizit deklariert oder zugewiesen sind. Diese impliziten Importe werden als lokale `const` behandelt, die an die entsprechenden Globals zum Zeitpunkt der Anweisung gebunden sind. + +Namen, die im selben Scope explizit als `global` deklariert werden, werden nicht importiert, sodass du sie weiterhin zuweisen kannst. + +```yuescript +do + import global + print "hallo" + math.random 3 + -- print = nil -- Fehler: importierte Globals sind const + +do + -- explizite globale Variable wird nicht importiert + import global + global FLAG + print FLAG + FLAG = 123 +``` + + + +```yue +do + import global + print "hallo" + math.random 3 + -- print = nil -- Fehler: importierte Globals sind const + +do + -- explizite globale Variable wird nicht importiert + import global + global FLAG + print FLAG + FLAG = 123 +``` + + + +## Export + +Die `export`-Anweisung bietet eine knappe Möglichkeit, Module zu definieren. + +### Benannter Export + +Benannter Export definiert eine lokale Variable und fügt ein Feld in die exportierte Tabelle ein. + +```yuescript +export a, b, c = 1, 2, 3 +export cool = "Katze" + +export What = if this + "abc" +else + "def" + +export y = -> + hallo = 3434 + +export class Something + umm: "cool" +``` + + + +```yue +export a, b, c = 1, 2, 3 +export cool = "Katze" + +export What = if this + "abc" +else + "def" + +export y = -> + hallo = 3434 + +export class Something + umm: "cool" +``` + + + +Benannter Export mit Destructuring. + +```yuescript +export :loadstring, to_lua: tolua = yue +export {itemA: {:fieldA = 'default'}} = tb +``` + + + +```yue +export :loadstring, to_lua: tolua = yue +export {itemA: {:fieldA = 'default'}} = tb +``` + + + +Benannte Elemente aus dem Modul exportieren, ohne lokale Variablen zu erstellen. + +```yuescript +export.itemA = tb +export. = items +export["a-b-c"] = 123 +``` + + + +```yue +export.itemA = tb +export. = items +export["a-b-c"] = 123 +``` + + + +### Unbenannter Export + +Unbenannter Export fügt das Ziel-Element in den Array-Teil der exportierten Tabelle ein. + +```yuescript +d, e, f = 3, 2, 1 +export d, e, f + +export if this + 123 +else + 456 + +export with tmp + j = 2000 +``` + + + +```yue +d, e, f = 3, 2, 1 +export d, e, f + +export if this + 123 +else + 456 + +export with tmp + j = 2000 +``` + + + +### Default-Export + +Mit dem Schlüsselwort **default** in einer `export`-Anweisung wird die exportierte Tabelle durch ein beliebiges Objekt ersetzt. + +```yuescript +export default -> + print "hallo" + 123 +``` + + + +```yue +export default -> + print "hallo" + 123 +``` + + diff --git a/doc/docs/de/doc/objects/with-statement.md b/doc/docs/de/doc/objects/with-statement.md index adeeda6..f299902 100644 --- a/doc/docs/de/doc/objects/with-statement.md +++ b/doc/docs/de/doc/objects/with-statement.md @@ -44,6 +44,50 @@ file = with File "Lieblingsessen.txt" +`with`-Ausdrücke unterstützen `break` mit genau einem Wert: + +```yuescript +result = with obj + break .value +``` + + + +```yue +result = with obj + break .value +``` + + + +Sobald `break value` in `with` verwendet wird, gibt der `with`-Ausdruck nicht mehr sein Zielobjekt zurück, sondern den von `break` gelieferten Wert. + +```yuescript +a = with obj + .x = 1 +-- a ist obj + +b = with obj + break .x +-- b ist .x, nicht obj +``` + + + +```yue +a = with obj + .x = 1 +-- a ist obj + +b = with obj + break .x +-- b ist .x, nicht obj +``` + + + +Im Unterschied zu `for` / `while` / `repeat` / `do` unterstützt `with` nur einen `break`-Wert. + Oder … ```yuescript -- cgit v1.2.3-55-g6feb