Alles auf einer Seite

Willkommen

Willkommen in der offiziellen YueScript-Dokumentation!
Hier findest du Sprachfeatures, Nutzung, Referenzbeispiele und Ressourcen.
Bitte wähle ein Kapitel in der Navigation, um mit YueScript zu beginnen.

Einführung in YueScript

YueScript ist eine dynamische Sprache, die zu Lua kompiliert. Sie ist ein Dialekt von MoonScript. Code, der in YueScript geschrieben wird, ist ausdrucksstark und sehr kompakt. YueScript eignet sich zum Schreiben von veränderlicher Anwendungslogik mit besser wartbarem Code und läuft in eingebetteten Lua-Umgebungen wie Spielen oder Webservern.

Yue (月) ist das chinesische Wort für Mond und wird als [jyɛ] ausgesprochen.

Ein Vorgeschmack auf YueScript

-- Import-Syntax
import p, to_lua from "yue"

-- Objekt-Literale
inventory =
  equipment:
    - "Schwert"
    - "Schild"
  items:
    - name: "Trank"
      count: 10
    - name: "Brot"
      count: 3

-- Listen-Abstraktion
map = (arr, action) ->
  [action item for item in *arr]

filter = (arr, cond) ->
  [item for item in *arr when cond item]

reduce = (arr, init, action): init ->
  init = action init, item for item in *arr

-- Pipe-Operator
[1, 2, 3]
  |> map (x) -> x * 2
  |> filter (x) -> x > 4
  |> reduce 0, (a, b) -> a + b
  |> print

-- Metatable-Manipulation
apple =
  size: 15
  <index>:
    color: 0x00ffff

with apple
  p .size, .color, .<index> if .<>?

-- export-Syntax (ähnlich wie in JavaScript)
export 🌛 = "Skript des Mondes"

Kompilieren

Über Dora SSR

YueScript wird zusammen mit der Open-Source-Spiel-Engine Dora SSR entwickelt und gepflegt. Es wird zum Erstellen von Engine-Tools, Spiel-Demos und Prototypen eingesetzt und hat seine Leistungsfähigkeit in realen Szenarien unter Beweis gestellt, während es gleichzeitig die Dora-SSR-Entwicklungserfahrung verbessert.

Installation

Lua-Modul

Installiere luarocks, einen Paketmanager für Lua-Module. Installiere YueScript dann als Lua-Modul und ausführbare Datei mit:

luarocks install yuescript

Oder du kannst die Datei yue.so bauen mit:

make shared LUAI=/usr/local/include/lua LUAL=/usr/local/lib/lua

Anschließend findest du die Binärdatei unter bin/shared/yue.so.

Binär-Tool bauen

Klone dieses Repo und baue/installiere die ausführbare Datei mit:

make install

YueScript-Tool ohne Makro-Feature bauen:

make install NO_MACRO=true

YueScript-Tool ohne eingebautes Lua-Binary bauen:

make install NO_LUA=true

Vorgefertigtes Binary herunterladen

Du kannst vorkompilierte Binärdateien herunterladen, inklusive ausführbarer Dateien für unterschiedliche Lua-Versionen und Bibliotheksdateien.

Lade vorkompilierte Binärdateien von hier herunter.

Verwendung

Lua-Modul

YueScript-Modul in Lua verwenden:

• Fall 1

  “your_yuescript_entry.yue” in Lua require’n.

  require("yue")("your_yuescript_entry")

  Dieser Code funktioniert weiterhin, wenn du “your_yuescript_entry.yue” im gleichen Pfad zu “your_yuescript_entry.lua” kompilierst. In den restlichen YueScript-Dateien verwendest du einfach normales require oder import. Die Zeilennummern in Fehlermeldungen werden korrekt behandelt.

• Fall 2

  YueScript-Modul require’n und das Fehlermapping manuell umschreiben.

  local yue = require("yue")
  yue.insert_loader()
  local success, result = xpcall(function()
    return require("yuescript_module_name")
  end, function(err)
    return yue.traceback(err)
  end)

• Fall 3

  Die YueScript-Compilerfunktion in Lua verwenden.

  local yue = require("yue")
  local codes, err, globals = yue.to_lua([[
    f = ->
      print "Hallo Welt"
    f!
  ]],{
    implicit_return_root = true,
    reserve_line_number = true,
    lint_global = true,
    space_over_tab = false,
    options = {
      target = "5.4",
      path = "/script"
    }
  })

YueScript-Tool

YueScript-Tool verwenden mit:

> yue -h
Verwendung: yue
          [Optionen] [<Datei/Verzeichnis>] ...
          yue -e <code_oder_datei> [argumente...]
          yue -w [<verzeichnis>] [optionen]
          yue -

Hinweise:
   - '-' / '--' muss das erste und einzige Argument sein.
   - '-o/--output' kann nicht mit mehreren Eingabedateien verwendet werden.
   - '-w/--watch' kann nicht mit Dateieingabe verwendet werden (nur Verzeichnisse).
   - Mit '-e/--execute' werden verbleibende Tokens als Skriptargumente behandelt.

Optionen:
   -h, --help                 Zeigt diese Hilfemeldung an und beendet das Programm.
   -e <str>, --execute <str>  Datei oder Quellcode ausführen
   -m, --minify               Minimierten Code erzeugen
   -r, --rewrite              Ausgabe so umschreiben, dass die Zeilennummern dem Original entsprechen
   -t <ziel>, --output-to <ziel>
                              Ziel für kompilierte Dateien angeben
   -o <datei>, --output <datei>
                              Schreibe die Ausgabe in eine Datei
   -p, --print                Schreibe die Ausgabe auf die Standardausgabe
   -b, --benchmark            Gibt die Kompilierungszeit aus (keine Ausgabe schreiben)
   -g, --globals              Gibt verwendete globale Variablen im Format NAME ZEILE SPALTE aus
   -s, --spaces               Verwende Leerzeichen anstelle von Tabs im generierten Code
   -l, --line-numbers         Schreibe Zeilennummern aus dem Quellcode
   -j, --no-implicit-return   Deaktiviert implizites Rückgabe am Datei-Ende
   -c, --reserve-comments     Kommentare aus dem Quellcode vor Anweisungen beibehalten
   -w [<verz>], --watch [<verz>]
                              Änderungen beobachten und alle Dateien im Verzeichnis kompilieren
   -v, --version              Version ausgeben
   -                          Lese von Standardinput, schreibe auf Standardausgabe
                              (muss das erste und einzige Argument sein)
   --                         Wie '-', bleibt zur Abwärtskompatibilität bestehen

   --target <version>         Gib an, welche Lua-Version erzeugt werden soll
                              (Version nur von 5.1 bis 5.5 möglich)
   --path <pfad_str>          Füge einen zusätzlichen Lua-Suchpfad zu package.path hinzu
   --<schlüssel>=<wert>       Übertrage Compileroption im Schlüssel=Wert-Format (bestehendes Verhalten)

   Ohne Optionen wird die REPL gestartet, gebe das Symbol '$'
   in eine einzelne Zeile ein, um den Multi-Line-Modus zu starten/beenden

Anwendungsfälle:

Rekursiv jede YueScript-Datei mit der Endung .yue unter dem aktuellen Pfad kompilieren: yue .

Kompilieren und Ergebnisse in einen Zielpfad schreiben: yue -t /target/path/ .

Kompilieren und Debug-Infos beibehalten: yue -l .

Kompilieren und minifizierten Code erzeugen: yue -m .

Rohcode ausführen: yue -e ‘print 123’

Eine YueScript-Datei ausführen: yue -e main.yue

Leerraum

YueScript ist eine whitespace-sensible Sprache. Du musst bestimmte Code-Blöcke mit derselben Einrückung (Leerzeichen ’ ‘ oder Tab ’\t’) schreiben, z. B. Funktionskörper, Wertelisten und Kontrollblöcke. Ausdrücke mit unterschiedlichem Leerraum können unterschiedliche Bedeutungen haben. Ein Tab wird wie 4 Leerzeichen behandelt, aber es ist besser, Leerzeichen und Tabs nicht zu mischen.

Anweisungs-Trenner

Eine Anweisung endet normalerweise an einem Zeilenumbruch. Du kannst auch ein Semikolon ; verwenden, um eine Anweisung explizit zu beenden, wodurch mehrere Anweisungen in einer Zeile möglich sind:

a = 1; b = 2; print a + b

Kompilieren

Mehrzeiliges Chaining

Du kannst mehrzeilige, verkettete Funktionsaufrufe mit derselben Einrückung schreiben.

Rx.Observable
  .fromRange 1, 8
  \filter (x) -> x % 2 == 0
  \concat Rx.Observable.of 'who do we appreciate'
  \map (value) -> value .. '!'
  \subscribe print

Kompilieren

Kommentare

-- Ich bin ein Kommentar

str = --[[
Dies ist ein mehrzeiliger Kommentar.
Alles okay.
]] strA \ -- Kommentar 1
  .. strB \ -- Kommentar 2
  .. strC

func --[[Port]] 3000, --[[IP]] "192.168.1.1"

Kompilieren

Literale

Alle primitiven Literale in Lua können verwendet werden. Das gilt für Zahlen, Strings, Booleans und nil.

Anders als in Lua sind Zeilenumbrüche innerhalb einfacher und doppelter Anführungszeichen ohne Escape-Sequenz erlaubt:

some_string = "Hier ist ein String
  mit einem Zeilenumbruch."

-- Mit der #{}-Syntax kannst du Ausdrücke in String-Literale einbinden.
-- String-Interpolation gibt es nur in doppelt angeführten Strings.
print "Ich bin mir zu #{math.random! * 100}% sicher."

Kompilieren

Zahlenliterale

Du kannst Unterstriche in Zahlenliteralen verwenden, um die Lesbarkeit zu erhöhen.

integer = 1_000_000
hex = 0xEF_BB_BF
binary = 0B10011

Kompilieren

YAML-Mehrzeilen-String

Das Präfix | führt ein mehrzeiliges String-Literal im YAML-Stil ein:

str = |
  key: value
  list:
    - item1
    - #{expr}

Kompilieren

Damit lässt sich strukturierter, mehrzeiliger Text bequem schreiben. Alle Zeilenumbrüche und Einrückungen bleiben relativ zur ersten nicht-leeren Zeile erhalten, und Ausdrücke innerhalb von #{...} werden automatisch als tostring(expr) interpoliert.

Der YAML-Mehrzeilen-String erkennt automatisch das gemeinsame führende Leerraumpräfix (minimale Einrückung über alle nicht-leeren Zeilen) und entfernt es aus allen Zeilen. So kannst du deinen Code optisch einrücken, ohne den resultierenden String zu verändern.

fn = ->
  str = |
    foo:
      bar: baz
  return str

Kompilieren

Die interne Einrückung bleibt relativ zum entfernten gemeinsamen Präfix erhalten, wodurch saubere, verschachtelte Strukturen möglich sind.

Alle Sonderzeichen wie Anführungszeichen (") und Backslashes (\) im YAML-Mehrzeilen-Block werden automatisch escaped, sodass der erzeugte Lua-String syntaktisch korrekt ist und wie erwartet funktioniert.

str = |
  path: "C:\Program Files\App"
  note: 'He said: "#{Hello}!"'

Kompilieren

Operatoren

Alle binären und unären Operatoren von Lua sind verfügbar. Zusätzlich ist != ein Alias für ~=, und entweder **** oder **::** kann für verkettete Funktionsaufrufe wie tb\func! oder tb::func! verwendet werden. Außerdem bietet YueScript einige spezielle Operatoren für ausdrucksstärkeren Code.

tb\func! if tb ~= nil
tb::func! if tb != nil

Kompilieren

Verkettete Vergleiche

Vergleiche können beliebig verkettet werden:

print 1 < 2 <= 2 < 3 == 3 > 2 >= 1 == 1 < 3 != 5
-- Ausgabe: true

a = 5
print 1 <= a <= 10
-- Ausgabe: true

Kompilieren

Beachte das Auswertungsverhalten verketteter Vergleiche:

v = (x) ->
  print x
  x

print v(1) < v(2) <= v(3)
--[[
  Ausgabe:
  2
  1
  3
  true
]]

print v(1) > v(2) <= v(3)
--[[
  Ausgabe:
  2
  1
  false
]]

Kompilieren

Der mittlere Ausdruck wird nur einmal ausgewertet, nicht zweimal wie bei v(1) < v(2) and v(2) <= v(3). Die Auswertungsreihenfolge in verketteten Vergleichen ist jedoch undefiniert. Es wird dringend empfohlen, in verketteten Vergleichen keine Ausdrücke mit Seiteneffekten (z. B. print) zu verwenden. Wenn Seiteneffekte nötig sind, sollte der Short-Circuit-Operator and explizit verwendet werden.

Tabellenerweiterung

Der Operator [] = wird verwendet, um Werte an Tabellen anzuhängen.

tab = []
tab[] = "Wert"

Kompilieren

Du kannst auch den Spread-Operator ... verwenden, um alle Elemente einer Liste an eine andere anzuhängen:

tbA = [1, 2, 3]
tbB = [4, 5, 6]
tbA[] = ...tbB
-- tbA ist jetzt [1, 2, 3, 4, 5, 6]

Kompilieren

Tabellen-Spread

Du kannst Array-Tabellen oder Hash-Tabellen mit dem Spread-Operator ... vor Ausdrücken in Tabellenliteralen zusammenführen.

Wenn in ein Tabellenliteral mit geschweiften Klammern gespreadet wird (zum Beispiel {...other}), werden sowohl der Array-Teil als auch der Hash-Teil der Lua-Tabelle kopiert.

parts =
  * "Schultern"
  * "Knie"
lyrics =
  * "Kopf"
  * ...parts
  * "und"
  * "Zehen"

copy = {...other}

a = {1, 2, 3, x: 1}
b = {4, 5, y: 1}
merge = {...a, ...b}

Kompilieren

List-Tabellen-Spread

Wenn in ein Tabellenliteral mit eckigen Klammern gespreadet wird (zum Beispiel [...other,]), wird nur der Array-Teil kopiert.

source = {1, 2, 3, name: "Yue"}
fullCopy = {...source}
listCopy = [...source,]
-- fullCopy => {1, 2, 3, name: "Yue"}
-- listCopy => [1, 2, 3]

Kompilieren

Umgekehrter Tabellenindex

Mit dem Operator # kannst du auf die letzten Elemente einer Tabelle zugreifen.

last = data.items[#]
second_last = data.items[#-1]
data.items[#] = 1

Kompilieren

Metatable

Der Operator <> kann als Abkürzung für Metatable-Manipulation verwendet werden.

Metatable erstellen

Erzeuge eine normale Tabelle mit leeren Klammern <> oder einem Metamethod-Schlüssel, der von <> umschlossen ist.

mt = {}
add = (right) => <>: mt, value: @value + right.value
mt.__add = add

a = <>: mt, value: 1
 -- Feld mit gleichnamiger Variable setzen
b = :<add>, value: 2
c = <add>: mt.__add, value: 3

d = a + b + c
print d.value

close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs"

Kompilieren

Metatable-Zugriff

Metatable mit <> oder einem von <> umschlossenen Metamethod-Namen aufrufen oder einen Ausdruck in <> schreiben.

-- erstellen mit Metatable, das das Feld "value" enthält
tb = <"value">: 123
tb.<index> = tb.<>
print tb.value

tb.<> = __index: {item: "hallo"}
print tb.item

Kompilieren

Metatable-Destrukturierung

Destrukturiere Metatable mit Metamethoden-Schlüssel, der von <> umschlossen ist.

{item, :new, :<close>, <index>: getter} = tb
print item, new, close, getter

Kompilieren

Existenz

Der Operator ? kann in verschiedenen Kontexten verwendet werden, um die Existenz zu prüfen.

func?!
print abc?["hello world"]?.xyz

x = tab?.value
len = utf8?.len or string?.len or (o) -> #o

if print and x?
  print x

with? io.open "test.txt", "w"
  \write "hello"
  \close!

Kompilieren

Piping

Anstelle einer Reihe verschachtelter Funktionsaufrufe kannst du Werte mit dem Operator |> weiterleiten.

"hello" |> print
1 |> print 2 -- Pipe-Element als erstes Argument einfügen
2 |> print 1, _, 3 -- Pipe mit Platzhalter

-- Pipe-Ausdruck über mehrere Zeilen
readFile "example.txt"
  |> extract language, {}
  |> parse language
  |> emit
  |> render
  |> print

Kompilieren

Nil-Coalescing

Der Nil-Coalescing-Operator ?? gibt den Wert des linken Operanden zurück, wenn er nicht nil ist; andernfalls wird der rechte Operand ausgewertet und sein Ergebnis zurückgegeben. Der ??-Operator wertet seinen rechten Operanden nicht aus, wenn der linke Operand nicht nil ergibt.

local a, b, c, d
a = b ?? c ?? d
func a ?? {}

a ??= false

Kompilieren

Implizites Objekt

Du kannst innerhalb eines Tabellenblocks eine Liste impliziter Strukturen schreiben, die mit dem Symbol * oder - beginnt. Beim Erstellen eines impliziten Objekts müssen die Felder des Objekts dieselbe Einrückung haben.

-- Zuweisung mit implizitem Objekt
list =
  * 1
  * 2
  * 3

-- Funktionsaufruf mit implizitem Objekt
func
  * 1
  * 2
  * 3

-- Rückgabe mit implizitem Objekt
f = ->
  return
    * 1
    * 2
    * 3

-- Tabelle mit implizitem Objekt
tb =
  name: "abc"

  values:
    - "a"
    - "b"
    - "c"

  objects:
    - name: "a"
      value: 1
      func: => @value + 1
      tb:
        fieldA: 1

    - name: "b"
      value: 2
      func: => @value + 2
      tb: { }

Kompilieren

Attribute

Syntax-Unterstützung für Lua-5.4-Attribute. Du kannst weiterhin die Deklarationen const und close verwenden und erhältst Konstantenprüfung sowie Scoped-Callbacks, wenn du auf Lua-Versionen unter 5.4 zielst.

const a = 123
close _ = <close>: -> print "Außerhalb des Gültigkeitsbereichs."

Kompilieren

Du kannst Destructuring mit als konstant markierten Variablen verwenden.

const {:a, :b, c, d} = tb
-- a = 1

Kompilieren

Du kannst auch eine globale Variable als const deklarieren.

global const Constant = 123
-- Constant = 1

Kompilieren

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.

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

Kompilieren

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.

do
  import tostring
  import table.concat
  print concat ["a", tostring 1]

Kompilieren

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.

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

Kompilieren

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.

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"

Kompilieren

Benannter Export mit Destructuring.

export :loadstring, to_lua: tolua = yue
export {itemA: {:fieldA = 'default'}} = tb

Kompilieren

Benannte Elemente aus dem Modul exportieren, ohne lokale Variablen zu erstellen.

export.itemA = tb
export.<index> = items
export["a-b-c"] = 123

Kompilieren

Unbenannter Export

Unbenannter Export fügt das Ziel-Element in den Array-Teil der exportierten Tabelle ein.

d, e, f = 3, 2, 1
export d, e, f

export if this
  123
else
  456

export with tmp
  j = 2000

Kompilieren

Default-Export

Mit dem Schlüsselwort default in einer export-Anweisung wird die exportierte Tabelle durch ein beliebiges Objekt ersetzt.

export default ->
  print "hallo"
  123

Kompilieren

Zuweisung

Variablen sind dynamisch typisiert und standardmäßig local. Du kannst den Geltungsbereich mit den Statements local und global ändern.

hello = "world"
a, b, c = 1, 2, 3
hello = 123 -- nutzt die bestehende Variable

Kompilieren

Update-Zuweisung

Du kannst Update-Zuweisungen mit vielen binären Operatoren durchführen.

x = 1
x += 1
x -= 1
x *= 10
x /= 10
x %= 10
s ..= "world" -- legt eine neue lokale Variable an, wenn sie nicht existiert
arg or= "default value"

Kompilieren

Verkettete Zuweisung

Mit verketteten Zuweisungen kannst du mehrere Variablen auf denselben Wert setzen.

a = b = c = d = e = 0
x = y = z = f!

Kompilieren

Explizite Locals

do
  local a = 1
  local *
  print "forward declare all variables as locals"
  x = -> 1 + y + z
  y, z = 2, 3
  global instance = Item\new!

do
  local X = 1
  local ^
  print "only forward declare upper case variables"
  a = 1
  B = 2

Kompilieren

Explizite Globals

do
  global a = 1
  global *
  print "declare all variables as globals"
  x = -> 1 + y + z
  y, z = 2, 3

do
  global X = 1
  global ^
  print "only declare upper case variables as globals"
  a = 1
  B = 2
  local Temp = "a local value"

Kompilieren

Destructuring-Zuweisung

Destructuring-Zuweisung ist eine Möglichkeit, schnell Werte aus einer Tabelle nach Name oder Position in array-basierten Tabellen zu extrahieren.

Normalerweise steht ein Tabellenliteral wie {1,2,3} auf der rechten Seite einer Zuweisung, weil es ein Wert ist. Destructuring-Zuweisung tauscht die Rolle des Tabellenliterals und setzt es auf die linke Seite der Zuweisung.

Am besten lässt sich das mit Beispielen erklären. So entpackst du die ersten zwei Werte einer Tabelle:

thing = [1, 2]

[a, b] = thing
print a, b

Kompilieren

Im Destructuring-Tabellenliteral repräsentiert der Schlüssel den zu lesenden Schlüssel der rechten Seite, und der Wert ist der Name, dem der gelesene Wert zugewiesen wird.

obj = {
  hello: "Welt"
  day: "Dienstag"
  length: 20
}

{hello: hello, day: the_day} = obj
print hello, the_day

:day = obj -- einfache Destructuring-Zuweisung ohne Klammern ist ok

Kompilieren

Das funktioniert auch mit verschachtelten Datenstrukturen:

obj2 = {
  numbers: [1, 2, 3, 4]
  properties: {
    color: "grün"
    height: 13.5
  }
}

{numbers: [first, second], properties: {color: color}} = obj2
print first, second, color

Kompilieren

Wenn die Destructuring-Anweisung kompliziert ist, kannst du sie gerne auf mehrere Zeilen verteilen. Ein etwas komplexeres Beispiel:

{
  numbers: [first, second]
  properties: {
    color: color
  }
} = obj2

Kompilieren

Es ist üblich, Werte aus einer Tabelle zu extrahieren und ihnen lokale Variablen mit demselben Namen wie der Schlüssel zuzuweisen. Um Wiederholungen zu vermeiden, kannst du den Präfix-Operator : verwenden:

{:concat, :insert} = table

Kompilieren

Das ist effektiv dasselbe wie import, aber du kannst Felder umbenennen, indem du die Syntax mischst:

{:mix, :max, random: rand} = math

Kompilieren

Du kannst Standardwerte beim Destructuring angeben, z. B.:

{:name = "namenlos", :job = "arbeitlos"} = person

Kompilieren

Du kannst _ als Platzhalter verwenden, wenn du eine Listen-Destructuring-Zuweisung machst:

[_, two, _, four] = items

Kompilieren

Bereichs-Destructuring

Du kannst den Spread-Operator ... in Listen-Destructuring verwenden, um einen Wertebereich zu erfassen. Das ist nützlich, wenn du bestimmte Elemente am Anfang und Ende einer Liste extrahieren und den Rest dazwischen sammeln willst.

orders = ["erster", "zweiter", "dritter", "vierter", "letzter"]
[first, ...bulk, last] = orders
print first  -- gibt aus: erster
print bulk   -- gibt aus: {"zweiter", "dritter", "vierter"}
print last   -- gibt aus: letzter

Kompilieren

Der Spread-Operator kann an unterschiedlichen Positionen verwendet werden, um unterschiedliche Bereiche zu erfassen, und du kannst _ als Platzhalter für Werte verwenden, die du nicht erfassen willst:

-- Alles nach dem ersten Element erfassen
[first, ...rest] = orders

-- Alles vor dem letzten Element erfassen
[...start, last] = orders

-- Alles außer den mittleren Elementen erfassen
[first, ..._, last] = orders

Kompilieren

Destructuring an anderen Stellen

Destructuring kann auch an Stellen vorkommen, an denen eine Zuweisung implizit erfolgt. Ein Beispiel ist eine for-Schleife:

tuples = [
  ["hallo", "Welt"]
  ["Ei", "Kopf"]
]

for [left, right] in *tuples
  print left, right

Kompilieren

Wir wissen, dass jedes Element der Array-Tabelle ein 2er-Tupel ist, daher können wir es direkt in der Namensliste der for-Anweisung mittels Destructuring entpacken.

If-Zuweisung

if- und elseif-Blöcke können eine Zuweisung anstelle eines Bedingungsausdrucks enthalten. Beim Auswerten der Bedingung findet die Zuweisung statt, und der zugewiesene Wert wird als Bedingung verwendet. Die zugewiesene Variable ist nur im Geltungsbereich des Bedingungsblocks verfügbar, d. h. sie ist nicht verfügbar, wenn der Wert nicht truthy ist. Für die Zuweisung musst du den “Walrus-Operator” := statt = verwenden.

if user := database.find_user "moon"
  print user.name

Kompilieren

if hello := os.getenv "hello"
  print "Du hast hello", hello
elseif world := os.getenv "world"
  print "Du hast world", world
else
  print "nichts :("

Kompilieren

If-Zuweisung mit mehreren Rückgabewerten. Nur der erste Wert wird geprüft, andere Werte bleiben im Scope.

if success, result := pcall -> "Ergebnis ohne Probleme erhalten"
  print result -- Variable result ist im Scope
print "OK"

Kompilieren

While-Zuweisung

Du kannst if-Zuweisung auch in einer while-Schleife verwenden, um den Wert als Schleifenbedingung zu nutzen.

while byte := stream\read_one!
  -- mit dem Byte etwas anfangen
  print byte

Kompilieren

Varargs-Zuweisung

Du kannst Rückgabewerte einer Funktion dem Varargs-Symbol ... zuweisen und dann den Inhalt auf die Lua-Weise auslesen.

list = [1, 2, 3, 4, 5]
fn = (ok) -> ok, table.unpack list
ok, ... = fn true
count = select '#', ...
first = select 1, ...
print ok, count, first

Kompilieren

Die Using-Klausel: Destruktive Zuweisung kontrollieren

Lexikalisches Scoping kann die Komplexität des Codes stark reduzieren, aber mit wachsendem Codeumfang kann es unübersichtlich werden. Betrachte folgendes Beispiel:

i = 100

-- viele Zeilen Code...

my_func = ->
  i = 10
  while i > 0
    print i
    i -= 1

my_func!

print i -- wird 0 ausgeben

Kompilieren

In my_func haben wir den Wert von i versehentlich überschrieben. In diesem Beispiel ist es offensichtlich, aber in einer großen oder fremden Codebasis ist oft nicht klar, welche Namen bereits deklariert wurden.

Es wäre hilfreich, anzugeben, welche Variablen aus dem umschließenden Scope wir verändern wollen, um versehentliche Änderungen zu vermeiden.

Das Schlüsselwort using ermöglicht das. using nil stellt sicher, dass keine geschlossenen Variablen bei Zuweisungen überschrieben werden. Die using-Klausel steht nach der Argumentliste einer Funktion oder ersetzt sie, wenn es keine Argumente gibt.

i = 100

my_func = (using nil) ->
  i = "hello" -- hier wird eine neue lokale Variable erstellt

my_func!
print i -- gibt 100 aus, i bleibt unverändert

Kompilieren

Mehrere Namen können durch Kommas getrennt werden. Closure-Werte können weiterhin gelesen, aber nicht verändert werden:

tmp = 1213
i, k = 100, 50

my_func = (add using k, i) ->
  tmp = tmp + add -- ein neues lokales tmp wird erstellt
  i += tmp
  k += tmp

my_func(22)
print i, k -- diese wurden aktualisiert

Kompilieren

Funktionsliterale

Alle Funktionen werden mit einem Funktionsausdruck erstellt. Eine einfache Funktion wird mit dem Pfeil -> notiert.

my_function = ->
my_function() -- leere Funktion aufrufen

Kompilieren

Der Funktionskörper kann entweder eine einzelne Anweisung direkt nach dem Pfeil sein oder aus mehreren Anweisungen bestehen, die in den folgenden Zeilen eingerückt werden:

func_a = -> print "Hallo Welt"

func_b = ->
  value = 100
  print "Der Wert:", value

Kompilieren

Wenn eine Funktion keine Argumente hat, kann sie mit dem !-Operator statt leerer Klammern aufgerufen werden. Der !-Aufruf ist die bevorzugte Art, Funktionen ohne Argumente aufzurufen.

func_a!
func_b()

Kompilieren

Funktionen mit Argumenten werden erstellt, indem der Pfeil von einer Argumentliste in Klammern eingeleitet wird:

sum = (x, y) -> print "Summe", x + y

Kompilieren

Funktionen können aufgerufen werden, indem die Argumente hinter dem Namen eines Ausdrucks stehen, der zu einer Funktion evaluiert. Beim Verketten mehrerer Funktionsaufrufe werden die Argumente der nächstliegenden Funktion links zugeordnet.

sum 10, 20
print sum 10, 20

a b c "a", "b", "c"

Kompilieren

Um Mehrdeutigkeiten beim Aufruf zu vermeiden, können die Argumente auch in Klammern gesetzt werden. Das ist hier nötig, damit die richtigen Argumente an die richtigen Funktionen gehen.

print "x:", sum(10, 20), "y:", sum(30, 40)

Kompilieren

Zwischen öffnender Klammer und Funktionsname darf kein Leerzeichen stehen.

Funktionen wandeln die letzte Anweisung im Funktionskörper in ein return um. Das nennt sich implizites Return:

sum = (x, y) -> x + y
print "Die Summe ist ", sum 10, 20

Kompilieren

Wenn du explizit zurückgeben willst, verwende return:

sum = (x, y) -> return x + y

Kompilieren

Wie in Lua können Funktionen mehrere Werte zurückgeben. Die letzte Anweisung muss eine Liste von Werten sein, getrennt durch Kommas:

mystery = (x, y) -> x + y, x - y
a, b = mystery 10, 20

Kompilieren

Fat Arrows

Da es in Lua üblich ist, beim Methodenaufruf ein Objekt als erstes Argument zu übergeben, gibt es eine spezielle Syntax zum Erstellen von Funktionen, die automatisch ein self-Argument enthalten.

func = (num) => @value + num

Kompilieren

Standardwerte für Argumente

Es ist möglich, Standardwerte für Funktionsargumente anzugeben. Ein Argument gilt als leer, wenn sein Wert nil ist. Alle nil-Argumente mit Standardwert werden vor Ausführung des Funktionskörpers ersetzt.

my_function = (name = "etwas", height = 100) ->
  print "Hallo, ich bin", name
  print "Meine Größe ist", height

Kompilieren

Der Ausdruck für den Standardwert wird im Funktionskörper in der Reihenfolge der Argumentdeklarationen ausgewertet. Daher können Standardwerte auf zuvor deklarierte Argumente zugreifen.

some_args = (x = 100, y = x + 1000) ->
  print x + y

Kompilieren

Hinweise

Aufgrund der ausdrucksstarken, klammerlosen Funktionsaufrufe müssen einige Einschränkungen gelten, um Parsing-Mehrdeutigkeiten mit Leerraum zu vermeiden.

Das Minuszeichen hat zwei Rollen: unäre Negation und binäre Subtraktion. Sieh dir an, wie die folgenden Beispiele kompiliert werden:

a = x - 10
b = x-10
c = x -y
d = x- z

Kompilieren

Die Präzedenz des ersten Arguments eines Funktionsaufrufs kann mit Leerraum gesteuert werden, wenn das Argument ein String-Literal ist. In Lua lässt man bei Aufrufen mit einem einzelnen String- oder Tabellenliteral häufig die Klammern weg.

Wenn kein Leerzeichen zwischen Variable und String-Literal steht, hat der Funktionsaufruf Vorrang vor nachfolgenden Ausdrücken. In dieser Form können keine weiteren Argumente übergeben werden.

Steht ein Leerzeichen zwischen Variable und String-Literal, verhält sich der Aufruf wie oben gezeigt. Das String-Literal gehört dann zu nachfolgenden Ausdrücken (falls vorhanden) und dient als Argumentliste.

x = func"hallo" + 100
y = func "hallo" + 100

Kompilieren

Mehrzeilige Argumente

Wenn Funktionsaufrufe viele Argumente haben, ist es praktisch, die Argumentliste auf mehrere Zeilen zu verteilen. Wegen der whitespace-sensitiven Natur der Sprache muss man dabei sorgfältig sein.

Wenn eine Argumentliste in der nächsten Zeile fortgesetzt wird, muss die aktuelle Zeile mit einem Komma enden. Die folgende Zeile muss stärker eingerückt sein als die aktuelle. Sobald eingerückt, müssen alle weiteren Argumentzeilen auf derselben Einrückungsebene liegen, um Teil der Argumentliste zu sein.

my_func 5, 4, 3,
  8, 9, 10

cool_func 1, 2,
  3, 4,
  5, 6,
  7, 8

Kompilieren

Diese Art des Aufrufs kann verschachtelt werden. Die Einrückungsebene bestimmt, zu welcher Funktion die Argumente gehören.

my_func 5, 6, 7,
  6, another_func 6, 7, 8,
    9, 1, 2,
  5, 4

Kompilieren

Da Tabellen ebenfalls das Komma als Trennzeichen verwenden, hilft diese Einrückungssyntax dabei, Werte zur Argumentliste gehören zu lassen, statt zur Tabelle.

x = [
  1, 2, 3, 4, a_func 4, 5,
    5, 6,
  8, 9, 10
]

Kompilieren

Obwohl es selten ist: Du kannst Funktionsargumente tiefer einrücken, wenn du weißt, dass du später eine geringere Einrückungsebene verwenden wirst.

y = [ my_func 1, 2, 3,
   4, 5,
  5, 6, 7
]

Kompilieren

Dasselbe lässt sich mit anderen Block-Statements wie Bedingungen machen. Wir können die Einrückungsebene verwenden, um zu bestimmen, zu welcher Anweisung ein Wert gehört:

if func 1, 2, 3,
  "hallo",
  "Welt"
    print "hallo"
    print "Ich bin innerhalb der if-Bedingung"

if func 1, 2, 3,
    "hallo",
    "Welt"
  print "hallo"
  print "Ich bin innerhalb der if-Bedingung"

Kompilieren

Parameter-Destructuring

YueScript unterstützt jetzt Destructuring von Funktionsparametern, wenn das Argument ein Objekt ist. Es gibt zwei Formen von Destructuring-Tabellenliteralen:

• Geschweifte Klammern/Objektparameter, die optionale Standardwerte erlauben, wenn Felder fehlen (z. B. {:a, :b}, {a: a1 = 123}).
• Unverpackte einfache Tabellensyntax, die mit einer Sequenz aus Key-Value- oder Shorthand-Bindings beginnt und so lange läuft, bis ein anderer Ausdruck sie beendet (z. B. :a, b: b1, :c). Diese Form extrahiert mehrere Felder aus demselben Objekt.

f1 = (:a, :b, :c) ->
  print a, b, c

f1 a: 1, b: "2", c: {}

f2 = ({a: a1 = 123, :b = 'abc'}, c = {}) ->
  print a1, b, c

arg1 = {a: 0}
f2 arg1, arg2

Kompilieren

Präfixiertes Return-Expression

Wenn du mit tief verschachtelten Funktionskörpern arbeitest, kann es mühsam sein, die Lesbarkeit und Konsistenz des Rückgabewerts zu erhalten. Dafür führt YueScript die Syntax der präfixierten Return-Expression ein. Sie hat folgende Form:

findFirstEven = (list): nil ->
  for item in *list
    if type(item) == "table"
      for sub in *item
        if sub % 2 == 0
          return sub

Kompilieren

Das ist äquivalent zu:

findFirstEven = (list) ->
  for item in *list
    if type(item) == "table"
      for sub in *item
        if sub % 2 == 0
          return sub
  nil

Kompilieren

Der einzige Unterschied ist, dass du den finalen Rückgabeausdruck vor das ->- oder =>-Token ziehen kannst, um den impliziten Rückgabewert der Funktion als letzte Anweisung zu kennzeichnen. So musst du selbst bei Funktionen mit mehreren verschachtelten Schleifen oder bedingten Zweigen kein abschließendes return am Ende des Funktionskörpers mehr schreiben, was die Logikstruktur klarer und leichter nachvollziehbar macht.

Benannte Varargs

Mit der Syntax (...t) -> kannst du Varargs automatisch in einer benannten Tabelle speichern. Diese Tabelle enthält alle übergebenen Argumente (einschließlich nil-Werten), und das Feld n der Tabelle speichert die tatsächliche Anzahl übergebener Argumente (einschließlich nil-Werten).

f = (...t) ->
  print "Anzahl der Argumente:", t.n
  print "Tabellenlänge:", #t
  for i = 1, t.n
    print t[i]

f 1, 2, 3
f "a", "b", "c", "d"
f!

-- Fälle mit nil-Werten behandeln
process = (...args) ->
  sum = 0
  for i = 1, args.n
    if args[i] != nil and type(args[i]) == "number"
      sum += args[i]
  sum

process 1, nil, 3, nil, 5

Kompilieren

Backcalls

Backcalls werden verwendet, um Callbacks zu entkoppeln (unnesting). Sie werden mit Pfeilen nach links definiert und füllen standardmäßig als letzter Parameter einen Funktionsaufruf. Die Syntax ist weitgehend wie bei normalen Pfeilfunktionen, nur dass der Pfeil in die andere Richtung zeigt und der Funktionskörper keine Einrückung benötigt.

x <- f
print "hallo" .. x

Kompilieren

Fat-Arrow-Funktionen sind ebenfalls verfügbar.

<= f
print @value

Kompilieren

Du kannst einen Platzhalter angeben, an welcher Stelle die Backcall-Funktion als Parameter eingesetzt werden soll.

(x) <- map _, [1, 2, 3]
x * 2

Kompilieren

Wenn du nach deinen Backcalls weiteren Code haben willst, kannst du sie mit einem do-Statement absetzen. Bei Nicht-Fat-Arrow-Funktionen können die Klammern weggelassen werden.

result, msg = do
  data <- readAsync "dateiname.txt"
  print data
  info <- processAsync data
  check info
print result, msg

Kompilieren

Funktions-Stubs

Es ist üblich, eine Funktion eines Objekts als Wert weiterzureichen, z. B. eine Instanzmethode als Callback. Wenn die Funktion das Objekt, auf dem sie arbeitet, als erstes Argument erwartet, musst du dieses Objekt irgendwie mit der Funktion bündeln, damit sie korrekt aufgerufen werden kann.

Die Funktions-Stub-Syntax ist eine Kurzform, um eine neue Closure-Funktion zu erstellen, die sowohl Objekt als auch Funktion bündelt. Diese neue Funktion ruft die umschlossene Funktion im richtigen Kontext des Objekts auf.

Die Syntax entspricht dem Aufruf einer Instanzmethode mit dem \-Operator, jedoch ohne Argumentliste.

my_object = {
  value: 1000
  write: => print "der Wert:", @value
}

run_callback = (func) ->
  print "Callback wird ausgeführt..."
  func!

-- das funktioniert nicht:
-- die Funktion darf keine Referenz auf my_object haben
run_callback my_object.write

-- Funktions-Stub-Syntax
-- bindet das Objekt in eine neue Funktion ein
run_callback my_object\write

Kompilieren

Bedingungen

have_coins = false
if have_coins
  print "Münzen erhalten"
else
  print "Keine Münzen"

Kompilieren

Eine Kurzsyntax für einzelne Anweisungen kann ebenfalls verwendet werden:

have_coins = false
if have_coins then print "Münzen erhalten" else print "Keine Münzen"

Kompilieren

Da if-Anweisungen als Ausdrücke verwendet werden können, kann man das auch so schreiben:

have_coins = false
print if have_coins then "Münzen erhalten" else "Keine Münzen"

Kompilieren

Bedingungen können auch in return-Anweisungen und Zuweisungen verwendet werden:

is_tall = (name) ->
  if name == "Rob"
    true
  else
    false

message = if is_tall "Rob"
  "Ich bin sehr groß"
else
  "Ich bin nicht so groß"

print message -- gibt aus: Ich bin sehr groß

Kompilieren

Das Gegenteil von if ist unless:

unless os.date("%A") == "Monday"
  print "Es ist nicht Montag!"

Kompilieren

print "You're lucky!" unless math.random! > 0.1

Kompilieren

In-Ausdruck

Mit einem in-Ausdruck kannst du Bereichsprüfungen schreiben.

a = 5

if a in [1, 3, 5, 7]
  print "Gleichheitsprüfung mit diskreten Werten"

if a in list
  print "Prüfen, ob `a` in einer Liste ist"

Kompilieren

Der in-Operator kann auch mit Tabellen verwendet werden und unterstützt die Variante not in für Verneinungen:

has = "foo" in {"bar", "foo"}

if a in {1, 2, 3}
  print "a ist in der Tabelle"

not_exist = item not in list

check = -> value not in table

Kompilieren

Eine Ein-Element-Liste oder Tabelle prüft auf Gleichheit mit diesem Element:

-- [1,] prüft, ob wert == 1
c = a in [1,]

-- {1} prüft auch, ob wert == 1
c = a in {1}

-- Ohne Komma ist [1] ein Indexzugriff (tb[1])
with tb
  c = a in [1]

Kompilieren

For-Schleife

Es gibt zwei Formen der for-Schleife, genau wie in Lua: eine numerische und eine generische.

for i = 10, 20
  print i

for k = 1, 15, 2 -- ein optionaler Schritt
  print k

for key, value in pairs object
  print key, value

Kompilieren

Die Slicing- und *-Operatoren können verwendet werden, genau wie bei Comprehensions:

for item in *items[2, 4]
  print item

Kompilieren

Eine kürzere Syntax ist für alle Varianten verfügbar, wenn der Rumpf nur eine Zeile hat:

for item in *items do print item

for j = 1, 10, 3 do print j

Kompilieren

Eine for-Schleife kann auch als Ausdruck verwendet werden. Die letzte Anweisung im Schleifenrumpf wird in einen Ausdruck umgewandelt und an eine wachsende Array-Tabelle angehängt.

Alle geraden Zahlen verdoppeln:

doubled_evens = for i = 1, 20
  if i % 2 == 0
    i * 2
  else
    i

Kompilieren

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:

first_large = for n in *numbers
  break n if n > 10

Kompilieren

Diese break-mit-Wert-Syntax ermöglicht knappe und ausdrucksstarke Such- bzw. Early-Exit-Muster direkt in Schleifenausdrücken.

key, score = for k, v in pairs data
  break k, v * 10 if k == "target"

Kompilieren

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.

func_a = -> for i = 1, 10 do print i
func_b = -> return for i = 1, 10 do i

print func_a! -- gibt nil aus
print func_b! -- gibt Tabellenobjekt aus

Kompilieren

Das verhindert die unnötige Erstellung von Tabellen in Funktionen, die die Ergebnisse der Schleife nicht zurückgeben müssen.

While-Schleife

Die while-Schleife gibt es ebenfalls in vier Variationen:

i = 10
while i > 0
  print i
  i -= 1

while running == true do my_function!

Kompilieren

i = 10
until i == 0
  print i
  i -= 1

until running == false do my_function!

Kompilieren

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.

value, doubled = while true
  n = get_next!
  break n, n * 2 if n > 10

Kompilieren

Damit eine Funktion den akkumulierten Wert einer while-Schleife zurückgibt, muss die Anweisung explizit mit return zurückgegeben werden.

Repeat-Schleife

Die repeat-Schleife stammt aus Lua:

i = 10
repeat
  print i
  i -= 1
until i == 0

Kompilieren

repeat-Ausdrücke unterstützen ebenfalls break mit mehreren Rückgabewerten:

i = 1
value, scaled = repeat
  break i, i * 100 if i > 3
  i += 1
until false

Kompilieren

Continue

Eine continue-Anweisung überspringt die aktuelle Iteration einer Schleife.

i = 0
while i < 10
  i += 1
  continue if i % 2 == 0
  print i

Kompilieren

continue kann auch mit Schleifenausdrücken verwendet werden, um zu verhindern, dass diese Iteration in das Ergebnis akkumuliert wird. Dieses Beispiel filtert die Array-Tabelle auf gerade Zahlen:

my_numbers = [1, 2, 3, 4, 5, 6]
odds = for x in *my_numbers
  continue if x % 2 == 1
  x

Kompilieren

Goto

YueScript unterstützt die goto-Anweisung und die Label-Syntax zur Steuerung des Programmflusses, wobei die gleichen Regeln wie bei Luas goto-Anweisung gelten. Hinweis: Die goto-Anweisung erfordert Lua 5.2 oder höher. Beim Kompilieren zu Lua 5.1 führt die Verwendung der goto-Syntax zu einem Kompilierfehler.

Ein Label wird mit doppelten Doppelpunkten definiert:

::start::
::done::
::mein_label::

Kompilieren

Die goto-Anweisung springt zu einem angegebenen Label:

a = 0
::start::
a += 1
goto done if a == 5
goto start
::done::
print "a ist jetzt 5"

Kompilieren

Die goto-Anweisung ist nützlich, um aus tief verschachtelten Schleifen zu springen:

for z = 1, 10
  for y = 1, 10 do for x = 1, 10
    if x^2 + y^2 == z^2
      print 'Pythagoreisches Tripel gefunden:', x, y, z
      goto ok
::ok::

Kompilieren

Sie können auch Labels verwenden, um zu einer bestimmten Schleifenebene zu springen:

for z = 1, 10
  for y = 1, 10
    for x = 1, 10
      if x^2 + y^2 == z^2
        print 'Pythagoreisches Tripel gefunden:', x, y, z
        print 'versuche nächstes z...'
        goto zcontinue
  ::zcontinue::

Kompilieren

Hinweise

• Labels müssen innerhalb ihres Geltungsbereichs eindeutig sein
• goto kann zu Labels auf derselben oder äußeren Geltungsbereichsebenen springen
• goto kann nicht in innere Geltungsbereiche springen (wie in Blöcke oder Schleifen)
• Verwenden Sie goto sparsam, da es den Code schwieriger zu lesen und zu warten machen kann

Switch

Die switch-Anweisung ist eine Kurzform für eine Reihe von if-Anweisungen, die gegen denselben Wert prüfen. Der Wert wird nur einmal ausgewertet. Wie bei if kann switch einen else-Block haben, wenn keine Übereinstimmung gefunden wird. Verglichen wird mit dem Operator ==. In einer switch-Anweisung kannst du auch eine Zuweisung verwenden, um den temporären Wert zu speichern.

switch name := "Dan"
  when "Robert"
    print "Du bist Robert"
  when "Dan", "Daniel"
    print "Dein Name ist Dan"
  else
    print "Ich kenne dich nicht mit dem Namen #{name}"

Kompilieren

Eine when-Klausel kann mehrere Werte prüfen, indem sie kommasepariert aufgelistet werden.

switch kann auch als Ausdruck verwendet werden. Hier wird das Ergebnis der switch-Anweisung einer Variable zugewiesen:

b = 1
next_number = switch b
  when 1
    2
  when 2
    3
  else
    error "so hoch kann ich nicht zählen!"

Kompilieren

Du kannst das Schlüsselwort then verwenden, um einen when-Block in einer Zeile zu schreiben. Für den else-Block braucht es kein zusätzliches Schlüsselwort.

msg = switch math.random(1, 5)
  when 1 then "Du hast Glück"
  when 2 then "Du hast fast Glück"
  else "nicht so viel Glück"

Kompilieren

Wenn du eine Einrückung weniger möchtest, kannst du die erste when-Klausel in die Startzeile der Anweisung setzen und alle weiteren Klauseln mit einer Einrückung weniger schreiben.

switch math.random(1, 5)
  when 1
    print "Du hast Glück" -- zwei Einrückungen
  else
    print "nicht so viel Glück"

switch math.random(1, 5) when 1
  print "Du hast Glück" -- eine Einrückung
else
  print "nicht so viel Glück"

Kompilieren

Beachte die Reihenfolge des Case-Vergleichsausdrucks. Der Case-Ausdruck steht auf der linken Seite. Das kann nützlich sein, wenn der Case-Ausdruck die Vergleichslogik über eine __eq-Metamethod selbst definiert.

Tabellen-Matching

Du kannst in einer switch-when-Klausel Tabellen-Matching verwenden, wenn die Tabelle durch eine bestimmte Struktur destrukturiert werden kann und dabei nicht-nil-Werte liefert.

items =
  * x: 100
    y: 200
  * width: 300
    height: 400

for item in *items
  switch item
    when :x, :y
      print "Vec2 #{x}, #{y}"
    when :width, :height
      print "Größe #{width}, #{height}"

Kompilieren

Du kannst Standardwerte verwenden, um bestimmte Felder optional zu destrukturieren.

item = {}

{pos: {:x = 50, :y = 200}} = item -- Fehler: Versuch, einen nil-Wert zu indexieren (Feld 'pos')

switch item
  when {pos: {:x = 50, :y = 200}}
    print "Vec2 #{x}, #{y}" -- Tabellen-Destrukturierung greift trotzdem

Kompilieren

Du kannst auch gegen Array-Elemente, Tabellenfelder und sogar verschachtelte Strukturen mit Array- oder Tabellenliteralen matchen.

Matchen gegen Array-Elemente.

switch tb
  when [1, 2, 3]
    print "1, 2, 3"
  when [1, b, 3]
    print "1, #{b}, 3"
  when [1, 2, b = 3] -- b hat einen Standardwert
    print "1, 2, #{b}"

Kompilieren

Matchen gegen Tabellenfelder mit Destructuring.

switch tb
  when success: true, :result
    print "Erfolg", result
  when success: false
    print "fehlgeschlagen", result
  else
    print "ungültig"

Kompilieren

Matchen gegen verschachtelte Tabellenstrukturen.

switch tb
  when data: {type: "success", :content}
    print "Erfolg", content
  when data: {type: "error", :content}
    print "fehlgeschlagen", content
  else
    print "ungültig"

Kompilieren

Matchen gegen Array von Tabellen.

switch tb
  when [
      {a: 1, b: 2}
      {a: 3, b: 4}
      {a: 5, b: 6}
      fourth
    ]
    print "getroffen", fourth

Kompilieren

Matchen gegen eine Liste und einen Bereich von Elementen erfassen.

segments = ["admin", "users", "logs", "view"]
switch segments
  when [...groups, resource, action]
    print "Gruppe:", groups -- gibt aus: {"admin", "users"}
    print "Ressource:", resource -- gibt aus: "logs"
    print "Aktion:", action -- gibt aus: "view"

Kompilieren

Tabellenliterale

Wie in Lua werden Tabellen mit geschweiften Klammern definiert.

some_values = {1, 2, 3, 4}

Kompilieren

Anders als in Lua weist man einem Schlüssel in einer Tabelle mit : (statt =) einen Wert zu.

some_values = {
  name: "Bill",
  age: 200,
  ["Lieblingsessen"]: "Reis"
}

Kompilieren

Die geschweiften Klammern können weggelassen werden, wenn eine einzelne Tabelle aus Schlüssel-Wert-Paaren zugewiesen wird.

profile =
  height: "4 Fuß",
  shoe_size: 13,
  favorite_foods: ["Eis", "Donuts"]

Kompilieren

Zeilenumbrüche können Werte statt eines Kommas trennen (oder zusätzlich):

values = {
  1, 2, 3, 4
  5, 6, 7, 8
  name: "Superman"
  occupation: "Verbrechensbekämpfung"
}

Kompilieren

Beim Erstellen eines einzeiligen Tabellenliterals können die geschweiften Klammern ebenfalls weggelassen werden:

my_function dance: "Tango", partner: "keiner"

y = type: "Hund", legs: 4, tails: 1

Kompilieren

Die Schlüssel eines Tabellenliterals können Sprach-Schlüsselwörter sein, ohne sie zu escapen:

tbl = {
  do: "etwas"
  end: "Hunger"
}

Kompilieren

Wenn du eine Tabelle aus Variablen konstruierst und die Schlüssel den Variablennamen entsprechen sollen, kannst du den Präfix-Operator : verwenden:

hair = "golden"
height = 200
person = { :hair, :height, shoe_size: 40 }

print_table :hair, :height

Kompilieren

Wenn der Schlüssel eines Feldes das Ergebnis eines Ausdrucks sein soll, kannst du ihn wie in Lua in [ ] setzen. Du kannst auch ein String-Literal direkt als Schlüssel verwenden und die eckigen Klammern weglassen. Das ist nützlich, wenn dein Schlüssel Sonderzeichen enthält.

t = {
  [1 + 2]: "hallo"
  "Hallo Welt": true
}

Kompilieren

Lua-Tabellen haben sowohl einen Array-Teil als auch einen Hash-Teil, aber manchmal ist es nützlich, hier eine semantische Unterscheidung zu treffen. Du kannst [ ] anstelle von { } verwenden, um eine Tabelle explizit als Array zu deklarieren; dadurch wird verhindert, dass Schlüssel-Wert-Paare hineingeschrieben werden.

some_values = [1, 2, 3, 4]
list_with_one_element = [1, ]

Kompilieren

Comprehensions

Comprehensions bieten eine bequeme Syntax, um eine neue Tabelle zu erzeugen, indem man über ein bestehendes Objekt iteriert und einen Ausdruck auf seine Werte anwendet. Es gibt zwei Arten: Listen-Comprehensions und Tabellen-Comprehensions. Beide erzeugen Lua-Tabellen; Listen-Comprehensions sammeln Werte in einer array-ähnlichen Tabelle, und Tabellen-Comprehensions erlauben es, Schlüssel und Wert pro Iteration zu setzen.

Listen-Comprehensions

Das folgende Beispiel erstellt eine Kopie der items-Tabelle, aber mit verdoppelten Werten.

items = [ 1, 2, 3, 4 ]
doubled = [item * 2 for i, item in ipairs items]

Kompilieren

Die Elemente in der neuen Tabelle können mit einer when-Klausel eingeschränkt werden:

slice = [item for i, item in ipairs items when i > 1 and i < 3]

Kompilieren

Da es üblich ist, über die Werte einer numerisch indizierten Tabelle zu iterieren, gibt es den *-Operator. Das Verdopplungsbeispiel kann so umgeschrieben werden:

doubled = [item * 2 for item in *items]

Kompilieren

In Listen-Comprehensions kannst du außerdem den Spread-Operator ... verwenden, um verschachtelte Listen zu flatten und einen Flat-Map-Effekt zu erzielen:

data =
  a: [1, 2, 3]
  b: [4, 5, 6]

flat = [...v for k,v in pairs data]
-- flat ist jetzt [1, 2, 3, 4, 5, 6]

Kompilieren

Die for- und when-Klauseln können beliebig oft verkettet werden. Die einzige Anforderung ist, dass eine Comprehension mindestens eine for-Klausel enthält.

Mehrere for-Klauseln entsprechen verschachtelten Schleifen:

x_coords = [4, 5, 6, 7]
y_coords = [9, 2, 3]

points = [ [x, y] for x in *x_coords \
for y in *y_coords]

Kompilieren

Numerische for-Schleifen können ebenfalls in Comprehensions verwendet werden:

evens = [i for i = 1, 100 when i % 2 == 0]

Kompilieren

Tabellen-Comprehensions

Die Syntax für Tabellen-Comprehensions ist sehr ähnlich, unterscheidet sich jedoch dadurch, dass { und } verwendet werden und pro Iteration zwei Werte erzeugt werden.

Dieses Beispiel erstellt eine Kopie von thing:

thing = {
  color: "rot"
  name: "schnell"
  width: 123
}

thing_copy = {k, v for k, v in pairs thing}

Kompilieren

no_color = {k, v for k, v in pairs thing when k != "color"}

Kompilieren

Der *-Operator wird ebenfalls unterstützt. Hier erstellen wir eine Nachschlagetabelle für Quadratwurzeln einiger Zahlen.

numbers = [1, 2, 3, 4]
sqrts = {i, math.sqrt i for i in *numbers}

Kompilieren

Das Schlüssel-Wert-Tupel in einer Tabellen-Comprehension kann auch aus einem einzelnen Ausdruck stammen; der Ausdruck muss dann zwei Werte zurückgeben. Der erste wird als Schlüssel und der zweite als Wert verwendet:

In diesem Beispiel konvertieren wir ein Array von Paaren in eine Tabelle, wobei das erste Element des Paars der Schlüssel und das zweite der Wert ist.

tuples = [ ["hallo", "Welt"], ["foo", "bar"]]
tbl = {unpack tuple for tuple in *tuples}

Kompilieren

Slicing

Eine spezielle Syntax erlaubt es, die iterierten Elemente bei Verwendung des *-Operators einzuschränken. Das ist äquivalent zum Setzen von Iterationsgrenzen und Schrittweite in einer for-Schleife.

Hier setzen wir die minimalen und maximalen Grenzen und nehmen alle Elemente mit Indizes zwischen 1 und 5 (inklusive):

slice = [item for item in *items[1, 5]]

Kompilieren

Jedes der Slice-Argumente kann weggelassen werden, um einen sinnvollen Standard zu verwenden. Wenn der maximale Index weggelassen wird, entspricht er der Länge der Tabelle. Dieses Beispiel nimmt alles außer dem ersten Element:

slice = [item for item in *items[2,]]

Kompilieren

Wenn die Mindestgrenze weggelassen wird, ist sie standardmäßig 1. Hier geben wir nur die Schrittweite an und lassen die anderen Grenzen leer. Das nimmt alle ungerad indizierten Elemente (1, 3, 5, …):

slice = [item for item in *items[,,2]]

Kompilieren

Sowohl die Mindest- als auch die Maximalgrenze können negativ sein; dann werden die Grenzen vom Ende der Tabelle gezählt.

-- die letzten 4 Elemente nehmen
slice = [item for item in *items[-4,-1]]

Kompilieren

Die Schrittweite kann ebenfalls negativ sein, wodurch die Elemente in umgekehrter Reihenfolge genommen werden.

reverse_slice = [item for item in *items[-1,1,-1]]

Kompilieren

Slicing-Ausdruck

Slicing kann auch als Ausdruck verwendet werden. Das ist nützlich, um eine Teilliste einer Tabelle zu erhalten.

-- das 2. und 4. Element als neue Liste nehmen
sub_list = items[2, 4]

-- die letzten 4 Elemente nehmen
last_four_items = items[-4, -1]

Kompilieren

Objektorientierte Programmierung

In diesen Beispielen kann der generierte Lua-Code überwältigend wirken. Am besten konzentrierst du dich zunächst auf die Bedeutung des YueScript-Codes und schaust dir den Lua-Code nur an, wenn du die Implementierungsdetails wissen möchtest.

Eine einfache Klasse:

class Inventory
  new: =>
    @items = {}

  add_item: (name) =>
    if @items[name]
      @items[name] += 1
    else
      @items[name] = 1

Kompilieren

Eine Klasse wird mit einem class-Statement deklariert, gefolgt von einer tabellenähnlichen Deklaration mit allen Methoden und Eigenschaften.

Die Eigenschaft new ist besonders, da sie zum Konstruktor wird.

Beachte, dass alle Methoden in der Klasse die Fat-Arrow-Syntax verwenden. Beim Aufruf von Methoden auf einer Instanz wird die Instanz selbst als erstes Argument übergeben. Der Fat-Arrow übernimmt die Erstellung des self-Arguments.

Das @-Präfix ist Kurzform für self.. @items wird zu self.items.

Der Klassenblock unterstützt auch Metatable-Felder, indem Metamethod-Schlüssel in spitzen Klammern geschrieben werden, zum Beispiel <tostring>.

class User
  new: (@name) =>
  <tostring>: => "User(#{@name})"

print tostring User "Yue"

Kompilieren

Eine Instanz der Klasse wird erstellt, indem man den Klassennamen wie eine Funktion aufruft.

inv = Inventory!
inv\add_item "T-Shirt"
inv\add_item "Hose"

Kompilieren

Da die Instanz bei Methodenaufrufen an die Methoden übergeben werden muss, wird der \-Operator verwendet.

Alle Eigenschaften einer Klasse werden von allen Instanzen gemeinsam genutzt. Für Funktionen ist das ok, aber bei anderen Objekten kann das zu unerwünschten Ergebnissen führen.

Im folgenden Beispiel wird die Eigenschaft clothes von allen Instanzen geteilt, sodass Änderungen in einer Instanz in einer anderen sichtbar werden:

class Person
  clothes: []
  give_item: (name) =>
    table.insert @clothes, name

a = Person!
b = Person!

a\give_item "Hose"
b\give_item "Hemd"

-- gibt sowohl Hose als auch Hemd aus
print item for item in *a.clothes

Kompilieren

Der richtige Weg, das zu vermeiden, ist, den veränderlichen Zustand im Konstruktor zu erstellen:

class Person
  new: =>
    @clothes = []

Kompilieren

Vererbung

Das Schlüsselwort extends kann in einer Klassendeklaration verwendet werden, um Eigenschaften und Methoden von einer anderen Klasse zu erben.

class BackPack extends Inventory
  size: 10
  add_item: (name) =>
    if #@items > size then error "Rucksack ist voll"
    super name

Kompilieren

Hier erweitern wir unsere Inventory-Klasse und begrenzen die Anzahl der Elemente.

In diesem Beispiel definieren wir keinen Konstruktor in der Subklasse, daher wird der Konstruktor der Elternklasse beim Erstellen einer neuen Instanz aufgerufen. Definieren wir einen Konstruktor, können wir mit super den Elternkonstruktor aufrufen.

Wenn eine Klasse von einer anderen erbt, sendet sie eine Nachricht an die Elternklasse, indem die Methode __inherited der Elternklasse aufgerufen wird, falls vorhanden. Die Funktion erhält zwei Argumente: die Klasse, die vererbt wird, und die Kindklasse.

class Shelf
  @__inherited: (child) =>
    print @__name, "wurde vererbt von", child.__name

-- gibt aus: Shelf wurde von Cupboard geerbt
class Cupboard extends Shelf

Kompilieren

Super

super ist ein spezielles Schlüsselwort, das auf zwei Arten verwendet werden kann: als Objekt oder als Funktionsaufruf. Es hat besondere Funktionalität nur innerhalb einer Klasse.

Wenn es als Funktion aufgerufen wird, ruft es die gleichnamige Funktion in der Elternklasse auf. self wird automatisch als erstes Argument übergeben (wie im Vererbungsbeispiel oben).

Wenn super als normaler Wert verwendet wird, ist es eine Referenz auf das Objekt der Elternklasse.

Du kannst es wie jedes andere Objekt verwenden, um Werte der Elternklasse zu lesen, die von der Kindklasse überschattet wurden.

Wenn der \-Aufrufoperator mit super verwendet wird, wird self als erstes Argument eingefügt statt des Wertes von super. Wenn man . zum Abrufen einer Funktion verwendet, wird die rohe Funktion zurückgegeben.

Ein paar Beispiele für super in unterschiedlichen Formen:

class MyClass extends ParentClass
  a_method: =>
    -- Folgendes hat dieselbe Wirkung:
    super "hallo", "Welt"
    super\a_method "hallo", "Welt"
    super.a_method self, "hallo", "Welt"

    -- super als Wert entspricht der Elternklasse:
    assert super == ParentClass

Kompilieren

super kann auch links einer Funktions-Stub verwendet werden. Der einzige große Unterschied ist, dass die resultierende Funktion statt an super an self gebunden wird.

Typen

Jede Instanz einer Klasse trägt ihren Typ in sich. Dieser wird in der speziellen Eigenschaft __class gespeichert. Diese Eigenschaft enthält das Klassenobjekt. Das Klassenobjekt wird aufgerufen, um eine neue Instanz zu erstellen. Wir können das Klassenobjekt auch indizieren, um Klassenmethoden und Eigenschaften abzurufen.

b = BackPack!
assert b.__class == BackPack

print BackPack.size -- gibt 10 aus

Kompilieren

Klassenobjekte

Das Klassenobjekt entsteht, wenn wir ein class-Statement verwenden. Es wird in einer Variablen mit dem Klassennamen gespeichert.

Das Klassenobjekt kann wie eine Funktion aufgerufen werden, um neue Instanzen zu erstellen. So haben wir die Instanzen in den Beispielen oben erstellt.

Eine Klasse besteht aus zwei Tabellen: der Klassentabelle selbst und der Basistabelle. Die Basis wird als Metatable für alle Instanzen verwendet. Alle in der Klassendeklaration aufgeführten Eigenschaften werden in der Basis platziert.

Das Metatable des Klassenobjekts liest Eigenschaften aus der Basis, wenn sie im Klassenobjekt nicht existieren. Das bedeutet, dass wir Funktionen und Eigenschaften direkt von der Klasse aus aufrufen können.

Wichtig: Zuweisungen an das Klassenobjekt schreiben nicht in die Basis. Das ist keine gültige Methode, um neue Methoden zu Instanzen hinzuzufügen. Stattdessen muss die Basis explizit geändert werden. Siehe das Feld __base unten.

Das Klassenobjekt hat einige spezielle Eigenschaften:

Der Name der Klasse, wie sie deklariert wurde, wird im Feld __name gespeichert.

print BackPack.__name -- gibt Backpack aus

Kompilieren

Die Basistabelle ist in __base gespeichert. Du kannst diese Tabelle ändern, um Instanzen Funktionalität hinzuzufügen, die bereits existieren oder noch erstellt werden.

Wenn die Klasse von etwas erbt, ist das Elternklassenobjekt in __parent gespeichert.

Klassenvariablen

Du kannst Variablen direkt im Klassenobjekt statt in der Basis erstellen, indem du in der Klassendeklaration @ vor den Eigenschaftsnamen setzt.

class Things
  @some_func: => print "Hallo von", @__name

Things\some_func!

-- Klassenvariablen in Instanzen nicht sichtbar
assert Things().some_func == nil

Kompilieren

In Ausdrücken können wir @@ verwenden, um auf einen Wert zuzugreifen, der in self.__class gespeichert ist. @@hello ist also eine Kurzform für self.__class.hello.

class Counter
  @count: 0

  new: =>
    @@count += 1

Counter!
Counter!

print Counter.count -- gibt 2 aus

Kompilieren

Die Aufrufsemantik von @@ ist ähnlich wie bei @. Wenn du einen @@-Namen aufrufst, wird die Klasse als erstes Argument übergeben (Lua-:-Syntax).

@@hello 1,2,3,4

Kompilieren

Klassendeklarations-Statements

Im Rumpf einer Klassendeklaration können wir normale Ausdrücke zusätzlich zu Schlüssel/Wert-Paaren haben. In diesem Kontext ist self gleich dem Klassenobjekt.

Hier ist eine alternative Möglichkeit, eine Klassenvariable zu erstellen:

class Things
  @class_var = "Hallo Welt"

Kompilieren

Diese Ausdrücke werden ausgeführt, nachdem alle Eigenschaften zur Basis hinzugefügt wurden.

Alle Variablen, die im Klassenkörper deklariert werden, sind lokal zu den Klasseneigenschaften. Das ist praktisch, um private Werte oder Hilfsfunktionen zu platzieren, auf die nur die Klassenmethoden zugreifen können:

class MoreThings
  secret = 123
  log = (msg) -> print "LOG:", msg

  some_method: =>
    log "Hallo Welt: " .. secret

Kompilieren

@- und @@-Werte

Wenn @ und @@ vor einem Namen stehen, repräsentieren sie den Namen in self bzw. self.__class.

Wenn sie alleine verwendet werden, sind sie Aliase für self und self.__class.

assert @ == self
assert @@ == self.__class

Kompilieren

Zum Beispiel kannst du mit @@ in einer Instanzmethode schnell eine neue Instanz derselben Klasse erzeugen:

some_instance_method = (...) => @@ ...

Kompilieren

Konstruktor-Property-Promotion

Um Boilerplate beim Definieren einfacher Value-Objekte zu reduzieren, kannst du eine Klasse so schreiben:

class Something
  new: (@foo, @bar, @@biz, @@baz) =>

-- Kurzform für

class Something
  new: (foo, bar, biz, baz) =>
    @foo = foo
    @bar = bar
    @@biz = biz
    @@baz = baz

Kompilieren

Du kannst diese Syntax auch für eine gemeinsame Funktion verwenden, um Objektfelder zu initialisieren.

new = (@fieldA, @fieldB) => @
obj = new {}, 123, "abc"
print obj

Kompilieren

Klassenausdrücke

Die class-Syntax kann auch als Ausdruck verwendet werden, der einer Variable zugewiesen oder explizit zurückgegeben wird.

x = class Bucket
  drops: 0
  add_drop: => @drops += 1

Kompilieren

Anonyme Klassen

Der Name kann beim Deklarieren einer Klasse weggelassen werden. Das __name-Attribut ist dann nil, es sei denn, der Klassenausdruck steht in einer Zuweisung. In diesem Fall wird der Name auf der linken Seite statt nil verwendet.

BigBucket = class extends Bucket
  add_drop: => @drops += 10

assert Bucket.__name == "BigBucket"

Kompilieren

Du kannst sogar den Körper weglassen und eine leere anonyme Klasse schreiben:

x = class

Kompilieren

Class Mixing

Du kannst mit dem Schlüsselwort using mischen, um Funktionen aus einer einfachen Tabelle oder einem vordefinierten Klassenobjekt in deine neue Klasse zu kopieren. Beim Mischen mit einer einfachen Tabelle kannst du die Klassen-Indexing-Funktion (Metamethod __index) überschreiben. Beim Mischen mit einem bestehenden Klassenobjekt werden dessen Metamethoden nicht kopiert.

MyIndex = __index: var: 1

class X using MyIndex
  func: =>
    print 123

x = X!
print x.var

class Y using X

y = Y!
y\func!

assert y.__class.__parent ~= X -- X ist nicht die Elternklasse von Y

Kompilieren

With-Statement

Ein häufiges Muster bei der Erstellung eines Objekts ist, unmittelbar danach eine Reihe von Funktionen aufzurufen und Eigenschaften zu setzen.

Das führt dazu, dass der Objektname mehrfach wiederholt wird und unnötiges Rauschen entsteht. Eine gängige Lösung ist, eine Tabelle als Argument zu übergeben, die eine Sammlung von Schlüsseln und Werten enthält, die überschrieben werden sollen. Der Nachteil ist, dass der Konstruktor dieses Objekts diese Form unterstützen muss.

Der with-Block hilft, das zu vermeiden. Innerhalb eines with-Blocks können wir spezielle Anweisungen verwenden, die mit . oder \ beginnen und die Operationen auf das Objekt anwenden, mit dem wir gerade arbeiten.

Zum Beispiel arbeiten wir mit einem neu erstellten Objekt:

with Person!
  .name = "Oswald"
  \add_relative my_dad
  \save!
  print .name

Kompilieren

Das with-Statement kann auch als Ausdruck verwendet werden und gibt den Wert zurück, auf den es Zugriff gewährt.

file = with File "Lieblingsessen.txt"
  \set_encoding "utf8"

Kompilieren

with-Ausdrücke unterstützen break mit genau einem Wert:

result = with obj
  break .value

Kompilieren

Sobald break value in with verwendet wird, gibt der with-Ausdruck nicht mehr sein Zielobjekt zurück, sondern den von break gelieferten Wert.

a = with obj
  .x = 1
-- a ist obj

b = with obj
  break .x
-- b ist .x, nicht obj

Kompilieren

Im Unterschied zu for / while / repeat / do unterstützt with nur einen break-Wert.

Oder …

create_person = (name,  relatives) ->
  with Person!
    .name = name
    \add_relative relative for relative in *relatives

me = create_person "Leaf", [dad, mother, sister]

Kompilieren

In dieser Verwendung kann with als spezielle Form des K-Kombinators gesehen werden.

Der Ausdruck im with-Statement kann auch eine Zuweisung sein, wenn du dem Ausdruck einen Namen geben willst.

with str := "Hallo"
  print "Original:", str
  print "Großbuchstaben:", \upper!

Kompilieren

Du kannst in einem with-Statement über [] auf spezielle Schlüssel zugreifen.

with tb
  [1] = 1
  print [2]
  with [abc]
    [3] = [2]\func!
    ["key-name"] = value
  [] = "abc" -- an "tb" anhängen

Kompilieren

with? ist eine erweiterte Version der with-Syntax, die einen Existenz-Check einführt, um Objekte, die nil sein könnten, sicher zuzugreifen, ohne explizite Nullprüfungen.

with? obj
  print .name

Kompilieren

Makros

Häufige Verwendung

Makrofunktionen werden verwendet, um zur Compile-Zeit einen String auszuwerten und den generierten Code in die finale Kompilierung einzufügen.

macro PI2 = -> math.pi * 2
area = $PI2 * 5

macro HELLO = -> "'Hallo Welt'"
print $HELLO

macro config = (debugging) ->
  global debugMode = debugging == "true"
  ""

macro asserts = (cond) ->
  debugMode and "assert #{cond}" or ""

macro assert = (cond) ->
  debugMode and "assert #{cond}" or "#{cond}"

$config true
$asserts item ~= nil

$config false
value = $assert item

-- übergebene Ausdrücke werden als Strings behandelt
macro and = (...) -> "#{ table.concat {...}, ' and ' }"
if $and f1!, f2!, f3!
  print "OK"

Kompilieren

Rohcode einfügen

Eine Makrofunktion kann entweder einen YueScript-String oder eine Konfigurationstabelle mit Lua-Code zurückgeben.

macro yueFunc = (var) -> "local #{var} = ->"
$yueFunc funcA
funcA = -> "Zuweisung an die vom Yue-Makro definierte Variable schlägt fehl"

macro luaFunc = (var) -> {
  code: "local function #{var}() end"
  type: "lua"
}
$luaFunc funcB
funcB = -> "Zuweisung an die vom Lua-Makro definierte Variable schlägt fehl"

macro lua = (code) -> {
  :code
  type: "lua"
}

-- führende und abschließende Symbole des Raw-Strings werden automatisch getrimmt
$lua[==[
-- Einfügen von rohem Lua-Code
if cond then
  print("Ausgabe")
end
]==]

Kompilieren

Makros exportieren

Makrofunktionen können aus einem Modul exportiert und in ein anderes Modul importiert werden. Exportierte Makros müssen in einer einzelnen Datei liegen, und im Export-Modul dürfen nur Makrodefinitionen, Makro-Imports und Makro-Expansionen stehen.

-- Datei: utils.yue
export macro map = (items, action) -> "[#{action} for _ in *#{items}]"
export macro filter = (items, action) -> "[_ for _ in *#{items} when #{action}]"
export macro foreach = (items, action) -> "for _ in *#{items}
  #{action}"

-- Datei main.yue
import "utils" as {
  $, -- Symbol zum Importieren aller Makros
  $foreach: $each -- Makro $foreach in $each umbenennen
}
[1, 2, 3] |> $map(_ * 2) |> $filter(_ > 4) |> $each print _

Kompilieren

Eingebaute Makros

Es gibt einige eingebaute Makros, aber du kannst sie überschreiben, indem du Makros mit denselben Namen deklarierst.

print $FILE -- String des aktuellen Modulnamens
print $LINE -- gibt 2 aus

Kompilieren

Makros mit Makros erzeugen

In YueScript erlauben Makrofunktionen Codegenerierung zur Compile-Zeit. Durch das Verschachteln von Makrofunktionen kannst du komplexere Generierungsmuster erzeugen. Damit kannst du eine Makrofunktion definieren, die eine andere Makrofunktion erzeugt.

macro Enum = (...) ->
  items = {...}
  itemSet = {item, true for item in *items}
  (item) ->
    error "erhalten: \"#{item}\", erwartet eines von #{table.concat items, ', '}" unless itemSet[item]
    "\"#{item}\""

macro BodyType = $Enum(
  Static
  Dynamic
  Kinematic
)

print "Gültiger Enum-Typ:", $BodyType Static
-- print "Kompilierungsfehler bei Enum-Typ:", $BodyType Unknown

Kompilieren

Mehrzeiligen Code erzeugen

Wenn ein Makro mehrzeiligen Yue-Code zurückgibt, ist eine mehrzeilige Zeichenkette in Anführungszeichen nicht zu empfehlen. Verwende stattdessen bevorzugt -> |.

Eine Zeichenkette in Anführungszeichen behält den Text wörtlich bei, während ein YAML-Mehrzeilen-String die gemeinsame führende Einrückung entfernt. Dadurch bleiben erzeugte Yue-Blöcke in der Regel stabiler, besonders wenn der erzeugte Code Kommentare oder verschachtelte Blöcke enthält.

macro default_conf = (conf) -> "
  -- useful; only set once
#{conf}.identity = 'LOVE'
#{conf}.version = \"11.5\"
  "

love.conf = (t) ->
  $default_conf t

Kompilieren

macro default_conf = (conf) -> |
  -- useful; only set once
  #{conf}.identity = 'LOVE'
  #{conf}.version = "11.5"

love.conf = (t) ->
  $default_conf t

Kompilieren

Argument-Validierung

Du kannst erwartete AST-Knotentypen in der Argumentliste deklarieren und zur Compile-Zeit prüfen, ob die übergebenen Makroargumente den Erwartungen entsprechen.

macro printNumAndStr = (num `Num, str `String) -> |
  print(
    #{num}
    #{str}
  )

$printNumAndStr 123, "hallo"

Kompilieren

Wenn du flexiblere Argumentprüfungen brauchst, kannst du das eingebaute Makro $is_ast verwenden, um manuell an der passenden Stelle zu prüfen.

macro printNumAndStr = (num, str) ->
  error "als erstes Argument Num erwartet" unless $is_ast Num, num
  error "als zweites Argument String erwartet" unless $is_ast String, str
  "print(#{num}, #{str})"

$printNumAndStr 123, "hallo"

Kompilieren

Weitere Details zu verfügbaren AST-Knoten findest du in den großgeschriebenen Definitionen in yue_parser.cpp.

Annotation-Anweisungen

Annotation-Anweisungen wenden ein Makro auf die direkt folgende Anweisung an.

Das entspricht einem Makroaufruf, bei dem der Quelltext der folgenden Anweisung als letztes Argument zusätzlich übergeben wird.

macro ShowName = (code) -> |
  print "#{code\match '^[%w_]*'}"

$[ShowName]
myFunc = ->

return

Kompilieren

Wenn das Annotationsmakro eine Konfigurationstabelle zurückgibt, steuert das optionale Feld before, ob das Ergebnis vor oder nach der annotierten Anweisung eingefügt wird.

macro Tag = (tag, code) ->
  tableName = code\match "^[%w_]+"
  return
    type: "text"
    before: tag == "before"
    code: "-- #{tag}:#{tableName}"

$[Tag before]
tableA = {}

$[Tag after]
tableB = {}

return

Kompilieren

Da die folgende Anweisung als zusätzliches Makroargument übergeben wird, lassen sich mit Annotationen auch direkt Registrierungszeilen aus Klassendeklarationen erzeugen. Du kannst dabei dieselben AST-Argumentprüfungen wie bei normalen Makros verwenden.

macro Register = (registry, code`ClassDecl) ->
  className = code\match "^class%s+(%w+)"
  return |
    #{registry}["#{className}"] = #{className}

registry = {}

$[Register(registry)]
class Worker
  run: => "ok"

return

Kompilieren

Annotationen können auch Wrapper-Code um Funktionen herum einfügen:

macro ValidateNumberArgs = (code) ->
  funcName = code\match "^(%w+)%s*="
  return |
    local __orig_#{funcName} = #{funcName}
    #{funcName} = (...) ->
      for i = 1, select "#", ...
        assert type(select i, ...) == "number", "expected number for arg \#{i}"
      __orig_#{funcName} ...

$[ValidateNumberArgs]
add = (a, b) -> a + b

Kompilieren

Auf eine Annotation muss immer eine Anweisung folgen, und sie kann nicht auf eine return-Anweisung angewendet werden. Wenn die annotierte Anweisung am Ende eines Blocks steht und du die rohe AST-Form der Anweisung brauchst, füge ein explizites return danach ein, damit sie nicht in einen implizit zurückgegebenen Ausdruck eingebettet wird.

Line-Decorators

Zur Vereinfachung können for-Schleifen und if-Anweisungen auf einzelne Anweisungen am Zeilenende angewendet werden:

print "Hallo Welt" if name == "Rob"

Kompilieren

Und mit einfachen Schleifen:

print "Element: ", item for item in *items

Kompilieren

Und mit while-Schleifen:

game\update! while game\isRunning!

reader\parse_line! until reader\eof!

Kompilieren

Do

Als Statement verhält sich do wie in Lua.

do
  var = "hallo"
  print var
print var -- nil hier

Kompilieren

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.

counter = do
  i = 0
  ->
    i += 1
    i

print counter!
print counter!

Kompilieren

tbl = {
  key: do
    print "Schlüssel wird zugewiesen!"
    1234
}

Kompilieren

do-Ausdrücke unterstützen die Verwendung von break, um den Kontrollfluss zu unterbrechen und mehrere Rückgabewerte vorzeitig zurückzugeben.

status, value = do
  n = 12
  if n > 10
    break "large", n
  break "small", n

Kompilieren

Try

Die Syntax für Fehlerbehandlung in Lua in einer gängigen Form.

try
  func 1, 2, 3
catch err
  print yue.traceback err

success, result = try
  func 1, 2, 3
catch err
  yue.traceback err

try func 1, 2, 3
catch err
  print yue.traceback err

success, result = try func 1, 2, 3

try
  print "Versuche"
  func 1, 2, 3

-- Verwendung mit if-Zuweisungsmuster
if success, result := try func 1, 2, 3
catch err
    print yue.traceback err
  print result

Kompilieren

Try?

try? ist eine vereinfachte Fehlerbehandlungs-Syntax, die den booleschen Status aus dem try-Statement weglässt. Bei Erfolg gibt sie das Ergebnis des try-Blocks zurück, ansonsten nil statt eines Fehlerobjekts.

a, b, c = try? func!

-- mit Nil-Verschmelzungs-Operator
a = (try? func!) ?? "Standardwert"

-- als Funktionsargument
f try? func!

-- mit catch-Block
f try?
  print 123
  func!
catch e
  print e
  e

Kompilieren

Die YueScript-Bibliothek

Zugriff in Lua über local yue = require("yue").

yue

Beschreibung:

Die YueScript-Sprachbibliothek.

version

Typ: Feld.

Beschreibung:

Die YueScript-Version.

Signatur:

version: string

dirsep

Typ: Feld.

Beschreibung:

Der Dateitrennzeichen-String der aktuellen Plattform.

Signatur:

dirsep: string

yue_compiled

Typ: Feld.

Beschreibung:

Der Cache für kompilierten Modulcode.

Signatur:

yue_compiled: {string: string}

to_lua

Typ: Funktion.

Beschreibung:

Die YueScript-Compilerfunktion. Sie kompiliert YueScript-Code zu Lua-Code.

Signatur:

to_lua: function(code: string, config?: Config):
    --[[codes]] string | nil,
    --[[error]] string | nil,
    --[[globals]] {{string, integer, integer}} | nil

Parameter:

Parameter	Typ	Beschreibung
code	string	Der YueScript-Code.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
string | nil	Der kompilierte Lua-Code oder nil, falls die Kompilierung fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls die Kompilierung erfolgreich war.
{{string, integer, integer}} | nil	Die globalen Variablen im Code (mit Name, Zeile und Spalte) oder nil, wenn die Compiler-Option lint_global false ist.

file_exist

Typ: Funktion.

Beschreibung:

Prüft, ob eine Quelldatei existiert. Kann überschrieben werden, um das Verhalten anzupassen.

Signatur:

file_exist: function(filename: string): boolean

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.

Rückgabe:

Rückgabetyp	Beschreibung
boolean	Ob die Datei existiert.

read_file

Typ: Funktion.

Beschreibung:

Liest eine Quelldatei. Kann überschrieben werden, um das Verhalten anzupassen.

Signatur:

read_file: function(filename: string): string

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.

Rückgabe:

Rückgabetyp	Beschreibung
string	Der Dateiinhalt.

insert_loader

Typ: Funktion.

Beschreibung:

Fügt den YueScript-Loader in die Package-Loader (Searcher) ein.

Signatur:

insert_loader: function(pos?: integer): boolean

Parameter:

Parameter	Typ	Beschreibung
pos	integer	[Optional] Position, an der der Loader eingefügt wird. Standard ist 3.

Rückgabe:

Rückgabetyp	Beschreibung
boolean	Ob der Loader erfolgreich eingefügt wurde. Scheitert, wenn er bereits eingefügt ist.

remove_loader

Typ: Funktion.

Beschreibung:

Entfernt den YueScript-Loader aus den Package-Loadern (Searchern).

Signatur:

remove_loader: function(): boolean

Rückgabe:

Rückgabetyp	Beschreibung
boolean	Ob der Loader erfolgreich entfernt wurde. Scheitert, wenn er nicht eingefügt ist.

loadstring

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einem String in eine Funktion.

Signatur:

loadstring: function(input: string, chunkname: string, env: table, config?: Config):
    --[[loaded function]] nil | function(...: any): (any...),
    --[[error]] string | nil

Parameter:

Parameter	Typ	Beschreibung
input	string	Der YueScript-Code.
chunkname	string	Der Name des Code-Chunks.
env	table	Die Environment-Tabelle.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
function | nil	Die geladene Funktion oder nil, falls das Laden fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls das Laden erfolgreich war.

loadstring

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einem String in eine Funktion.

Signatur:

loadstring: function(input: string, chunkname: string, config?: Config):
    --[[loaded function]] nil | function(...: any): (any...),
    --[[error]] string | nil

Parameter:

Parameter	Typ	Beschreibung
input	string	Der YueScript-Code.
chunkname	string	Der Name des Code-Chunks.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
function | nil	Die geladene Funktion oder nil, falls das Laden fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls das Laden erfolgreich war.

loadstring

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einem String in eine Funktion.

Signatur:

loadstring: function(input: string, config?: Config):
    --[[loaded function]] nil | function(...: any): (any...),
    --[[error]] string | nil

Parameter:

Parameter	Typ	Beschreibung
input	string	Der YueScript-Code.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
function | nil	Die geladene Funktion oder nil, falls das Laden fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls das Laden erfolgreich war.

loadfile

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einer Datei in eine Funktion.

Signatur:

loadfile: function(filename: string, env: table, config?: Config):
    nil | function(...: any): (any...),
    string | nil

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.
env	table	Die Environment-Tabelle.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
function | nil	Die geladene Funktion oder nil, falls das Laden fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls das Laden erfolgreich war.

loadfile

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einer Datei in eine Funktion.

Signatur:

loadfile: function(filename: string, config?: Config):
    nil | function(...: any): (any...),
    string | nil

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
function | nil	Die geladene Funktion oder nil, falls das Laden fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls das Laden erfolgreich war.

dofile

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.

Signatur:

dofile: function(filename: string, env: table, config?: Config): any...

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.
env	table	Die Environment-Tabelle.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
any…	Die Rückgabewerte der geladenen Funktion.

dofile

Typ: Funktion.

Beschreibung:

Lädt YueScript-Code aus einer Datei in eine Funktion und führt sie aus.

Signatur:

dofile: function(filename: string, config?: Config): any...

Parameter:

Parameter	Typ	Beschreibung
filename	string	Der Dateiname.
config	Config	[Optional] Die Compiler-Optionen.

Rückgabe:

Rückgabetyp	Beschreibung
any…	Die Rückgabewerte der geladenen Funktion.

find_modulepath

Typ: Funktion.

Beschreibung:

Löst den YueScript-Modulnamen in einen Dateipfad auf.

Signatur:

find_modulepath: function(name: string): string

Parameter:

Parameter	Typ	Beschreibung
name	string	Der Modulname.

Rückgabe:

Rückgabetyp	Beschreibung
string	Der Dateipfad.

pcall

Typ: Funktion.

Beschreibung:

Ruft eine Funktion im geschützten Modus auf. Fängt Fehler ab und gibt einen Statuscode sowie Ergebnisse oder ein Fehlerobjekt zurück. Schreibt die Fehlerzeilennummer bei Fehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.

Signatur:

pcall: function(f: function, ...: any): boolean, any...

Parameter:

Parameter	Typ	Beschreibung
f	function	Die aufzurufende Funktion.
…	any	Argumente für die Funktion.

Rückgabe:

Rückgabetyp	Beschreibung
boolean, …	Statuscode und Funktionsresultate oder Fehlerobjekt.

require

Typ: Funktion.

Beschreibung:

Lädt ein Modul (Lua oder YueScript). Schreibt die Fehlerzeilennummer auf die ursprüngliche Zeilennummer im YueScript-Code um, wenn das Modul ein YueScript-Modul ist und das Laden fehlschlägt.

Signatur:

require: function(name: string): any...

Parameter:

Parameter	Typ	Beschreibung
modname	string	Der Name des zu ladenden Moduls.

Rückgabe:

Rückgabetyp	Beschreibung
any	Der Wert in package.loaded[modname], falls das Modul bereits geladen ist. Andernfalls wird ein Loader gesucht und der finale Wert von package.loaded[modname] sowie Loader-Daten als zweites Ergebnis zurückgegeben.

p

Typ: Funktion.

Beschreibung:

Inspiziert die Struktur der übergebenen Werte und gibt String-Repräsentationen aus.

Signatur:

p: function(...: any)

Parameter:

Parameter	Typ	Beschreibung
…	any	Die zu inspizierenden Werte.

options

Typ: Feld.

Beschreibung:

Die aktuellen Compiler-Optionen.

Signatur:

options: Config.Options

traceback

Typ: Funktion.

Beschreibung:

Die Traceback-Funktion, die Stacktrace-Zeilennummern auf die ursprünglichen Zeilennummern im YueScript-Code umschreibt.

Signatur:

traceback: function(message: string): string

Parameter:

Parameter	Typ	Beschreibung
message	string	Die Traceback-Nachricht.

Rückgabe:

Rückgabetyp	Beschreibung
string	Die umgeschriebene Traceback-Nachricht.

is_ast

Typ: Funktion.

Beschreibung:

Prüft, ob der Code dem angegebenen AST entspricht.

Signatur:

is_ast: function(astName: string, code: string): boolean

Parameter:

Parameter	Typ	Beschreibung
astName	string	Der AST-Name.
code	string	Der Code.

Rückgabe:

Rückgabetyp	Beschreibung
boolean	Ob der Code dem AST entspricht.

AST

Typ: Feld.

Beschreibung:

Die AST-Typdefinition mit Name, Zeile, Spalte und Unterknoten.

Signatur:

type AST = {string, integer, integer, any}

to_ast

Typ: Funktion.

Beschreibung:

Konvertiert Code in AST.

Signatur:

to_ast: function(code: string, flattenLevel?: number, astName?: string, reserveComment?: boolean):
    --[[AST]] AST | nil,
    --[[error]] nil | string

Parameter:

Parameter	Typ	Beschreibung
code	string	Der Code.
flattenLevel	integer	[Optional] Der Flatten-Level. Höher bedeutet mehr Flattening. Standard ist 0. Maximum ist 2.
astName	string	[Optional] Der AST-Name. Standard ist “File”.
reserveComment	boolean	[Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist false.

Rückgabe:

Rückgabetyp	Beschreibung
AST | nil	Der AST oder nil, falls die Konvertierung fehlgeschlagen ist.
string | nil	Die Fehlermeldung oder nil, falls die Konvertierung erfolgreich war.

format

Typ: Funktion.

Beschreibung:

Formatiert den YueScript-Code.

Signatur:

format: function(code: string, tabSize?: number, reserveComment?: boolean): string

Parameter:

Parameter	Typ	Beschreibung
code	string	Der Code.
tabSize	integer	[Optional] Die Tab-Größe. Standard ist 4.
reserveComment	boolean	[Optional] Ob die ursprünglichen Kommentare beibehalten werden. Standard ist true.

Rückgabe:

Rückgabetyp	Beschreibung
string	Der formatierte Code.

__call

Typ: Metamethod.

Beschreibung:

Required das YueScript-Modul. Schreibt die Fehlerzeilennummer bei Ladefehlern auf die ursprüngliche Zeilennummer im YueScript-Code um.

Signatur:

metamethod __call: function(self: yue, module: string): any...

Parameter:

Parameter	Typ	Beschreibung
module	string	Der Modulname.

Rückgabe:

Rückgabetyp	Beschreibung
any	Der Modulwert.

Config

Beschreibung:

Die Compiler-Optionen.

lint_global

Typ: Feld.

Beschreibung:

Ob der Compiler die globalen Variablen im Code sammeln soll.

Signatur:

lint_global: boolean

implicit_return_root

Typ: Feld.

Beschreibung:

Ob der Compiler für den Root-Codeblock ein implizites Return verwenden soll.

Signatur:

implicit_return_root: boolean

reserve_line_number

Typ: Feld.

Beschreibung:

Ob der Compiler die ursprüngliche Zeilennummer im kompilierten Code beibehalten soll.

Signatur:

reserve_line_number: boolean

reserve_comment

Typ: Feld.

Beschreibung:

Ob der Compiler die ursprünglichen Kommentare im kompilierten Code beibehalten soll.

Signatur:

reserve_comment: boolean

space_over_tab

Typ: Feld.

Beschreibung:

Ob der Compiler statt Tabzeichen Leerzeichen verwenden soll.

Signatur:

space_over_tab: boolean

same_module

Typ: Feld.

Beschreibung:

Ob der Compiler den zu kompilierenden Code als dasselbe aktuell kompilierte Modul behandeln soll. Nur für internen Gebrauch.

Signatur:

same_module: boolean

line_offset

Typ: Feld.

Beschreibung:

Ob die Compiler-Fehlermeldung einen Zeilennummern-Offset enthalten soll. Nur für internen Gebrauch.

Signatur:

line_offset: integer

yue.Config.LuaTarget

Typ: Enumeration.

Beschreibung:

Die Ziel-Lua-Version.

Signatur:

enum LuaTarget
  "5.1"
  "5.2"
  "5.3"
  "5.4"
  "5.5"
end

options

Typ: Feld.

Beschreibung:

Zusätzliche Optionen für die Kompilierung.

Signatur:

options: Options

Options

Beschreibung:

Zusätzliche Compiler-Optionen.

target

Typ: Feld.

Beschreibung:

Die Ziel-Lua-Version für die Kompilierung.

Signatur:

target: LuaTarget

path

Typ: Feld.

Beschreibung:

Zusätzlicher Modul-Suchpfad.

Signatur:

path: string

dump_locals

Typ: Feld.

Beschreibung:

Ob lokale Variablen in Traceback-Fehlermeldungen ausgegeben werden sollen. Standard ist false.

Signatur:

dump_locals: boolean

simplified

Typ: Feld.

Beschreibung:

Ob Fehlermeldungen vereinfacht werden sollen. Standard ist true.

Signatur:

simplified: boolean

Maskottchen, Xiaoyu

Über

Xiaoyu (小玉, “kleines Jade”) ist ein Cyber-Kaninchen und das offizielle Maskottchen des YueScript-Projekts. Sie sitzt auf einer Mondsichel und schreibt YueScript auf ihrem Laptop.

Ihr vollständiger Titel ist Xiaoyu das Cyber-Kaninchen (机兔小玉). Sie spiegelt wider, was YueScript anstrebt: klar, ausdrucksstark und verspielt.

Tyson Tan hat Xiaoyu kostenlos für das Projekt entworfen und illustriert. Wir sind dankbar für seinen Beitrag.

Bilder

Klicken Sie auf ein Bild, um es in voller Größe zu öffnen.

Vollständiges Kunstwerk

Vollständiges PNG herunterladen

Transparenter Hintergrund

Transparentes PNG herunterladen

Gezippte .kra-Datei

Gezippte .kra-Datei herunterladen

Lizenz

Xiaoyu ist unter der MIT-Lizenz und der Creative-Commons-Lizenz CC-BY-SA 4.0 doppelt lizenziert.

Lizenz: MIT

Hinweis: Die MIT-Lizenz ist unten im englischen Originaltext wiedergegeben.

Urheberrecht (c) 2017-2026 Li Jin dragon-fly@qq.com

Hiermit wird unentgeltlich jeder Person, die eine Kopie dieser Software und der zugehörigen Dokumentationsdateien (die “Software”) erhält, die Erlaubnis erteilt, uneingeschränkt mit der Software zu verfahren, einschließlich und ohne Beschränkung der Rechte, die Software zu benutzen, zu kopieren, zu verändern, zusammenzuführen, zu veröffentlichen, zu verbreiten, zu unterlizenzieren und/oder zu verkaufen, sowie Personen, denen die Software zur Verfügung gestellt wird, dies ebenfalls zu gestatten, unter den folgenden Bedingungen:

Der obige Urheberrechtshinweis und dieser Genehmigungshinweis müssen in allen Kopien oder wesentlichen Teilen der Software enthalten sein.

DIE SOFTWARE WIRD OHNE JEGLICHE AUSDRÜCKLICHE ODER STILLSCHWEIGENDE GARANTIE ZUR VERFÜGUNG GESTELLT, EINSCHLIESSLICH DER GARANTIEN DER MARKTGÄNGIGKEIT, DER EIGNUNG FÜR EINEN BESTIMMTEN ZWECK UND DER NICHTVERLETZUNG. IN KEINEM FALL SIND DIE AUTOREN ODER URHEBERRECHTSINHABER FÜR ANSPRÜCHE, SCHÄDEN ODER SONSTIGE HAFTUNGEN VERANTWORTLICH, SEI ES AUS EINEM VERTRAG, EINER UNERLAUBTEN HANDLUNG ODER ANDERWEITIG, DIE SICH AUS DER SOFTWARE ODER DER BENUTZUNG DER SOFTWARE ODER ANDEREN GESCHÄFTEN MIT DER SOFTWARE ERGEBEN ODER DAMIT IN ZUSAMMENHANG STEHEN.

YueScript Online-Compiler

Probiere YueScript im Browser mit WASM aus.