MyWiki

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen: • lua • python_2 • mysql • bash • pyparsing • raspberry_pi • python_3 • git
lua

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen Revision Vorhergehende Überarbeitung
Nächste Überarbeitung 		Vorhergehende Überarbeitung
lua [2024/03/30 09:10]
root [Logische Operatoren] 		lua [2024/05/26 17:30] (aktuell)
root [Funktionen]
Zeile 2: Zeile 2:
 Ende von Statements/Instruktionen wird automatisch erkannt, es können also mehrere auf einer Zeile stehen ohne Trennzeichen oder Zeilenumbruch. Ende von Statements/Instruktionen wird automatisch erkannt, es können also mehrere auf einer Zeile stehen ohne Trennzeichen oder Zeilenumbruch.
  
 +
 +===== Allgemein =====
 +
 +  * am Verbeitetsten ist Lua 5.1
 +  * alle Versionen nach 5.1 -> 5.2, 5.3, 5.4 sind jeweils nicht abwärtskompatibel 
 +      * z.B erzeugt ... in einer Funktionsdeklaration in 5.1 eine Tabelle arg, in 5.4 mus ... an eine Tabelle übergeben werden um eine Tabelle zu bekommen
 +      * in 5.1 gibt es eine Funktion unpack zum entpacken von Tabellen, in 5.4 ist unpack eine Methode von table -> table.unpack()
 +
 +
 +  * Einführung: https://www.lua.org/pil/5.3.html
  
 ====== Keywords/Onboard-Funktionen ====== ====== Keywords/Onboard-Funktionen ======
Zeile 33: Zeile 43:
  
  
 +  * mehrere Variablen können in einem Statement zugewiesen werden
 +      * werden mehr Variablen als Werte zugewiesen wird nil zugewiesen
 +      * werden mehr Werte als Variablen angegeben, werden die Werte ohne Meldung verworfen
 +<sxh lua>
 +a, g, f = 1, 3
 +</sxh>
 +  * a = 1
 +  * g = 3
 +  * f = nil
 +      * da weniger Werte als Variablen angegeben
 +
 +
 +==== Scopes/local ====
 +
 +  * Variablen sind per default global
 +  * lokale Variablen -> local variablename = assignment
 +      * wobei assignment nicht an der Stelle erfoglen muss -> dann ist der Wert nil
 +  * lokale Variablen sind innerhalb eines Chunks (Datei) oder einer Struktur gültig 
 +      * if, loops usw.
 +  * lokale Variablen können überall im Code deklariert werden
 +  * auf lokale Variablen kann schneller zugegriffen werden als auf globale
 +
 +
 +<sxh lua>
 +a=6
 +do
 +    local a=1
 +    print(a)
 +end
 +print(a)
 +</sxh>
 +
 +^ Würde 1 und 6 ausgeben.
 +
 +  * do kann man nutzen wenn man den Scope einschränken will, aber keinen "natürlichen (durch ein if oder eine Schleife) definierten Block hat
 ===== Kommentare ===== ===== Kommentare =====
  
Zeile 111: Zeile 156:
  
  
 +=== Instanzieren ===
 +
 +<sxh lua>
 +a={2,3,x=6}
 +print(a[1])
 +print(a["x"])
 +</sxh>
 +
 +  * hier wird eine gemischte Table erstellt, die ersten beiden Werte können über einen klassischen Index (1-x) angesprochen werden, der 3. Wert ist per named Index erreichbar ("x"), so wie in einem dict/hashmap.
 +  * das erste print gibt 2 zurück, es wird per index 1 zugegriffen
 +      * die Indexierung beginnt bei 1, nicht bei 0
 +      * es wird hier auf die Table wie auf eine normale Liste zugegriffen
 +  * das zweite print gibt 6 zurück, es wird per index "x" zugegriffen
 +
 +
 +=== Iterieren ===
 +
 +Funktioniert über Funktionen. 
 +  * pairs() iteriert über alle Einträge einer Table und liefert den Key (Index) und den jeweiligen Wert zurück
 +      * gibt es einen expliziten Key (wie bei Hashmaps/Dicts) dann wird dieser zurückgegeben
 +      * gibt es keinen expliziten Key (wie bei Lists, arrays) wird der Index zurückgegeben
 +  * ipairs() iteriert über alle Einträge mit numerischem Index und gibt Index und Wert zurück
 +      * Werte die einen expliziten Index/Key haben (wie bei einer Hashmap) werden nicht zurückgegeben
 +
 +
 +<sxh lua>
 +a={6,8,'bla'='blub', 99}
 +for key, value in pairs(a) do
 +    print(key, value)
 +end
 +
 +for key, value in ipairs(a) do
 +    print(key, value)
 +end
 +</sxh>
 +
 +  * erste Schleife gibt aus:
 +      * 1  6
 +      * 2  8
 +      * bla  blub
 +      * 99
 +  * zweite Schleife gibt aus:
 +      * 1  6
 +      * 2  8
 +      * 3 99
 +      * der Key und Wert für 'bla' werden übersprungen, der Index ist fortlaufend -> 'bla' wird nicht mitgezählt 
 ===== Operators ===== ===== Operators =====
  
Zeile 167: Zeile 258:
  
 ".." ist der Verkettungsoperator ".." ist der Verkettungsoperator
 +
 +
 +
 +===== if-then-elif-else =====
 +
 +<sxh lua>
 +if a > b then
 +    print("A is bigger than B")
 +elif a < b then
 +    print("A is smaller than B)
 +else
 +    print("A is equal to B or something else ;)")
 +end
 +</sxh>
 +
 +
 +
 +===== while =====
 +
 +<sxh lua>
 +i=0
 +while i<5 do
 +    print(i)
 +    i = i + 1
 +end
 +</sxh>
 +
 +
 +===== repeat-until =====
 +
 +<sxh lua>
 +i=0
 +repeat
 +    print(i)
 +    i = i + 1
 +until 
 +</sxh>
 +
 +
 +===== numerische for-Schleife =====
 +
 +
 +<sxh lua>
 +for i=0, 5, 1 do
 +    print(i)
 +end
 +</sxh>
 +
 +Führt die Schleife beginnend bei 0 bis 5 in Schritten von 1 aus.
 +
 +Abstrakt sieht es so aus:
 +
 +<sxh lua>
 +for Variable=Startwert, Stop-Wert, Schritt-Länge do
 +   Code
 +end
 +</sxh>
 +
 +  * Startwert = erster Wert mit dem die Schleife durchlaufen wird
 +  * Stop-Wert = der letzte Wert mit dem die Schleife durchlaufen wird
 +  * Schritt-Länge = Um wie viel die Variable bei jedem Schleifendurchlauf erhöht (oder wenn es eine negative Zahl ist) reduziert wird
 +      * dieser Parameter kann weggelassen werden, dann wird 1 angenommen
 +  * die loop-Variable kann innerhalb der Schleife nicht geändert werden (ähnlich Python) und ist automatisch eine lokale Variable (existiert nur innerhalb der Schleife)
 +
 +
 +===== Generische for-Schleife ===== 
 +
 +  * bezieht Werte aus einem Iterator
 +
 +<sxh lua>
 +a = {"a","b","c","d"}
 +for i, v in ipairs(a) do
 +    print(v)
 +end
 +</sxh>
 +
 +  * i bekommt den Index übergeben
 +  * v den Wert
 +  * ipairs ist der Iterator
 +  * a ist die Tabelle über die iteriert wird
 +
 +
 +Abstrakt:
 +<sxh lua>
 +for Variablen in Iteratoren do
 +    Code
 +end
 +</sxh>
 +
 +  * Variablen sind die Variablen die bei jedem Durchlauf der Schleife aus dem Iterator besetzt werden
 +  * Iterator ist ein Iterator der bei jedem Schleifendurchlauf einen neuen Wert (oder mehrere) zurückgibt
 +
 +
 +===== break =====
 +
 +  * Bricht aus einer Schleife aus
 +
 +
 +===== return =====
 +
 +  * Bricht aus einer Funktion aus
 +  * gibt am Ende einer Funktion Werte an den Aufrufer zurück
 +      * sollen am Ende einer Funktion keine Werte zurückgeben werden braucht kein return angegeben werden
 +
 +
 +===== Funktionen =====
 +
 +  * Keyword function
 +  * Parameter sind lokale Variablen
 +  * Parameter die beim Aufruf nicht übergeben werden, bekommen nil als Wert
 +  * Parameter die zu viel übergeben werden werden ohne Fehler verworfen
 +  * Funktionen sind First-Class-Values
 +      * sie können also wie strings, int usw. Variablen zugewiesen werden
 +          * technisch gesehen function <Name> weißt den Code der Variable <Name> zu
 +  * Funktionen müssen mit Funktionsname() aufgerufen werden
 +      * die Klammern müssen also zwingend angegeben werden
 +      * Ausnahme es gibt nur einen Parameter der ein literal String ist oder eine table
 +
 +<sxh lua>
 +function myfunction(param1, param2)
 +      somecode
 +end
 +
 +myfunction("a")
 +</sxh>
 +
 +
 +  * param2 wurde in obigem Beispiel beim Aufruf der Funktion nicht übergeben und hätte in der Funktion den Wert nil
 +
 +
 +**Rückgabewerte**
 +
 +  * Funktionen können mehr als 1 Return-Value haben
 +  * sind mehr Variablen als Rückgabewerte vorhanden, wird mit nil aufgefüllt
 +  * Default-Rückgabewert = nil
 +
 +<sxh lua>
 +function somefunction()
 +    return "return1", "return2"
 +end
 +
 +somefunction()
 +a = somefunction()
 +b, c = somefunction()
 +d, e, f = somefunction()
 +</sxh>
 +
 +
 +
 +**Variable Anzahl Paramater**
 +
 +  * per "..." kann angegeben werden das eine unbestimmte Menge Parameter übergeben werden kann
 +      * entspricht Pythons *args
 +  * die Werte befinden sich anschließend in der Tabelle arg
 +
 +<sxh lua>
 +function my(param1, ...)
 +    print(param1)
 +    print(unpack(arg))
 +end
 +
 +my(1,2,3,4,5)
 +</sxh>
 +
 +  * gibt 1 und auf einer neuen Zeile 2,3,4.5 aus
 +  * unpack entpackt eine Tabelle (wie * in Python)
 +  * arg ist die Tabelle die die zusätzlichen Parameter enthält
 +
 +
 +** Named Arguments: **
 +
 +  * gibt es nicht
 +  * kann durch tables (man übergibt eine Table) simuliert werden
 +
 +
 +** Anonyme Funktionen/Lambda **
 +
 +  * man kann einfach keinen Namen angeben
 +  * der Name nach "function" ist nur die Zuweisung an eine Variable
 +
 +
 +<sxh lua>
 +function dosomething(f, parameter)
 +    f(parameter)
 +end
 +
 +dosomething(function (string) print(string) end, "hello")
 +</sxh>
 +
 +  * dosomething erwartet in diesem Beispiel als ersten Parameter f und als zweiten Parameter einen Parameter den es der Funktion übergibt
 +  * 'function (string) print(string) end' übergibt eine anonyme Funktion (ohne Namen) beim Funktionsaufruf
 +  * letztendlich wird die anonyme Funktion aufgerufen und gibt "hello" zurück
 +
 +
 +===== Closure =====
 +
 +  * Funktionen in anderen Funktionen haben Zugriff auf die Variablen der sie umgebenden Funktion
 +  * der Zugriff und die Werte bleiben bestehen, auch wenn der Scope der sie umgebenden Funktion nicht mehr existiert
 +      * im Prinzip bekommt die Unterfunktion eine Kopie der Variablen der sie umgebenden Funkion
 +      * im Prinzip kann man es vergleichen mit einem Objekt, dessen Methode Zugang zu den Funktionen eben des Objektes hat
 +
 +
 +<sxh lua>
 +function outer(base)
 +    local result = base * 5
 +    inner = function()
 +        print(result)
 +        end
 +    return inner
 +end
 +
 +bla = outer(6)
 +bla()
 +</sxh>
 +
 +  * gibt 30 aus
 +  * inner wird zurückgegeben, hat aber (noch) Zugriff auf die Variablen seiner (nicht mehr existierenden) Eltern-Funktion outer
 ====== Begriffe/Konzepte ====== ====== Begriffe/Konzepte ======
  
lua.1711786230.txt.gz · Zuletzt geändert: 2024/03/30 09:10 von root

Seiten-Werkzeuge

Falls nicht anders bezeichnet, ist der Inhalt dieses Wikis unter der folgenden Lizenz veröffentlicht: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki