[LUA]
[DE]
[SCRIPT] code/inspect.lua
[SCRIPT] code/class.lua
[SCRIPT] code/try-catch-finally.lua
[FUN]
```
function updateConfig(id) {
  console.log(id,Inputs[id])
  switch (id) {
    case 'input1': appConfig.user=Inputs[id]; break;
  }
}
```

# Einführung in die Programmierung mit der Skriptsprache Lua

[INPUT] Name { label:"username"; eval:updateConfig; }
[INPUT] Matrikelnummer

## Einführung

Eine Programmiersprache besteht aus eine Menge von Programmieranweisungen die man in folgende Klassen unterteilen kann:

1. Berechnung
2. Steuerung
3. Ein- und Ausgabe
3. Komposition
4. Typensystem (wenn überhaupt)

Berechnungen bestehen wiederum aus folgenden Komponenten:

1. Werten (Konstanten, Literale)
2. Variablen
3. Operationen (Addition, usw.)

Eine Variable kann

- veränderlich wie Speicher sein,
- oder unveränderlich wie eine symbolische Variable in der Mathematik.

In den folgenden Beispielen und Aufgaben können Werte und Variableninhalte mit der `print` Funktion in dem unter dem Code befindlichen Ausgabefenster ausgegeben werden. Hat man komplexere Werte, wie z.B. Datenstrukturen und Arrays, kann man stattdessen die `inspect` Funktion verwenden.

Dieses Tutorial ist in Snippets untertielt. Ein Snippet besteht aus einem Texteditorfenster und einem darunter befindlichen Kontroll- und Ausgabefenster. Das Kontrollfenster hat links den *Run* Knopf, der den Code ausführt, und rechts ein *Erase* Knopf, der das Ausgabefenster löscht.

Alle Codesnippets werden in einem sogenannten globalen Kontext ausgeführt, d.h., praktisch bilden sie ein Programm! Einzelne Codesnipptes können von der Ausführung vorheriger abhängen.

> Daher bei einem Fehler prüfen ob die vorherigen Codesnipptes fehlerfrei ausgeführt wurden!

Alle Eingabefelder (Code und Antworten auf Fragen) können gespeichert und wieder in das interaktive Tutorial geladen werden (Linker und rechter Knopf in der Kopfzeile).

Die Inhalte von Programmcodefeldern können über ein WEB Clipboard mit anderen Teilnehmern geteilt werden (wenn sie gleichzeitig am Tutorial arbeiten). Dazu befindet sich rechts oben in einem Codeeditorfeld ein Kopfsymbol. Das WEB Clipboard Fenster ist spezifisch für dieses Codefeld! Der *Copy* Befefhl fügt den eigenen Programmcode zum Clipboard hinzu. Code anderer Nutzer kann aus der Liste durch öffnen des Spoiler importiert werden. Der aktuell ausgwählte Code kann durch den *Paste* Befehl übernommen werden. Code Schnippsel verschwinden nach einer gewissen Zeit wieder aus dem Clipboard (ca. 5 Minuten).

Der Lua Interpreter ist in diese WEB App **integriert**. Es werden keine externen Programme benötigt! Der Zustand des Interpreters kann momentan nur durch erneutes Laden der Seite zurückgesetzt werden (vorher alle Eingaben speichern).

*In Lua werden einzelne Anweisungen entweder durch einen Zeilenumbruch oder ein Semikolon `;` getrennt. Einzelne Anweisungen werden immer in der angegebenen Reihenfolge ausgeführt (imperative Programmierung).*

Weitere Informationen über Lua gibt es hier:

http://edu-9.de/uploads/documents/lua_tutorial.pdf

## Werte, Variablen, Ausdrücke

Werte und Ausdrücke können über den `=` Operator einer Variablen zugewiesen werden. Lua kennt keine statische Typisierung, d.h., der Variablentyp ist **polymorph** und wird ausschließlich durch den aktuellen Inhalt bestimmt, der sich zur Laufzeit ändern kann.

Füge in den folgenden Code die `print` Anweisung für *y* und *z* ein.

[CODE] Variablen und Werte
```
x=1       -- type number
y=false   -- type boolean
z='text'  -- type string 
print(x)
```

Ausdrücke bestehen aus Operanden (können auch wieder Ausdrücke sein) und Operatoren:

[INFO] Lua Operatoren
- Addition: `+`
- Subtraktion: `-`
- Multiplikation: `*`
- Division: `/`
- Modulo: `%`
- Boolesches Und: `and`
- Boolesches Oder: `or`
- Boolesches Nicht: `not`
- usw.

[CODE] Ausdrücke
```
x=x+23     
y=(x-1)*(x+1)  
z=y/2 
print(x,y,z)
```

Man unterscheidet globale und lokale Variablen. Eine globale Variable wird einfach durch eine Zuweisungsanweisung `x=v` eingeführt. Eine lokale Variable wird durch die Anweisung `local x=v` eingeführt. Der Initialwert *v* ist optional. In Funktionen immer nur lokale Variablen definieren!

[CODE] Lokale und globale Variablen
```
x1=100
function foo1(x1)
  local x2
  x1=x1+1
  x2=x1*2
  return x2*x2
end
function foo2(x3)
  local x4=x3-1
  return x4*2
end
print(x1,foo1(x1),foo2(12))
```

Gebe in obigen Beispiel den Wert von *x1* in *foo2* aus. Was passiert? Und wenn *x2* ausgegeben wird? Welchen Wert hat die globale Variable *x1* nach der Ausführung von *foo1*?

[INPUT]

<br>

> Lokale Variablen können in Funktionen aber auch in Anweisungsblöcken (Schleifen, Bedingte Verzweigung) definiert und benutzt werden.

## Steueranweisungen

Steueranweisungen dienen zur Beeinflussung des Programmflusses. Man unterscheidet (mit `s` als Anweisung oder einer Reihe von Anweisungen):

1. **Bedingte Verzweigungen**: `if e then s1 else s2 end`
2. **Bedingte Schleifen**: `while e do s end`
3. **Zählschleifen**: `for i=a,b do s end`

Folgendes Beispiel zeigt die Implementierung der ??????????????? Funktion:

[CODE]
```
local r=1
for index=1,10 do
  r=r*index
end
print(r)
if r > 100000 then print('Big Number!') end
```

Der Programmfluss von Schleifen ist in folgender Abbildung dargestellt (Flussdiagramme).

![#loops width=100%](images/loops1.png)

Im folgenden Beispiel wird mit einer Turtlegraphik ein Oktagon gezeichnet. Ersetze den Code mit einer Zählschleife die die gleiche Figur zeichnet.

[INFO] Lua Turtle API
- `turtle:forward(n)` moves the turtle in current direction `n` pixels forward
- `turtle:goTo(x,y)` moves the turtle to a new position
- `turtle:left(n)` turns turtle `n` degree left
- `turtle:right(n)` turns turtle `n` degree right
- `turtle:reset()` clears the drawing area
- `turtle:up()` activates the pen
- `turtle:down()` deactivates the pen

[TURTLE] Beispiel Turtlegrafik
```
turtle:reset()
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
turtle:right(45)
turtle:forward(50)
```

## Funktionen

Funktionen dienen der Programmkomposition und der Wiederverwendung von Code. Man unterscheidet:

1. Funktionsdefinition
2. Funktionsapplikation

Eine Funktionsdefinition besteht aus:

1. Einem Namen (wobei anonyme Funktionen als sog. Lambda-ausdrücke zur Verfügung stehen);
2. Keinem, einen, oder mehrere Fuktionsparameter;
3. Einem Funktionsrumpf der eine Berechnung (mit den Parametern) durchführt UND/ODER prozedural wirkt (d.h. Ein- und Ausgabe, globalen Speicher verändern)
4. Einem Rückgabewert (auch bei Prozeduren: *nil*!), der mit der Anweisung `return` zurückgegeben wird.

Die Applikation ist einfach: Name der Funktion mit folgender Liste von Argumenten, d.h., `foo(1,2,3)`. Füge in folgenden Beispielen Funktionsaufrufe (Applikationen) von *foo* und *foo2* ein und gebe die Werte mit *print* aus.

[CODE] Funktionsdefiniton
```
function foo(a,b,c)
  return a+b+c
end
function foo2(a,b,c)
  return not a and b and c
end
```

[QUESTION]
Was passiert wenn die Anzahl der Argumente kleiner oder größer als die Anzahl der Funktionsparameter ist? Teste es mit *foo* und *foo2*

[INPUT]

[QUESTION]
Was ist Funktionsrekursion?

[ANSWER]
Wenn eine Funktion sich in ihrem Funktionsrumpf selbst aufruft!

Wende die Funktionen *fac* und *facsq* für die Werte *1,10,20* an und gebe die Werte aus. Ein kleiner Tipp: Obwohl Lua eigentlich nur Fliesskommawerte (quasi reelle Zahlen) verarbeitet (und keine ganzen), unterscheidet der Lua Interpreter der in diese WEB App integriert ist (aus einem mir nicht bekannten Grund) ganze Zahlen (Integer, 1,2,3,..) und Fliesskommazahlen (Float, 1.0, 1.1, 1.2, ..). Probiere einmal als Wert `10` und dann `10.0` ...

[CODE] Funktionskomposition
```
function fac(n)
  if n > 1 then return n*fac(n-1)
  else return n end
end
function facsq(n)
  return fac(n)*fac(n)
end
```

[QUESTION]
Wie kann die Berechnung von *facsq* optimiert werden (Annahme: Berechung von *fac* ist rechenintensiv!)

In der folgenden Aufgabe soll die Fibonacci Funktion implementiert und getestet werden. Benutze Funktionsrekursion!

![#fib width=200px](images/fib.png)

[CODE] Fibonacci Funktion
```
function fib(n)
 -- Hier Code!
end
```

## Datentypen

Variablen in Lua sind polymorph. Somit auch Funktionen, d.h. deren Funktionsparameter und der Rückgabewert! Es gibt nur wenige Grunddatentypen in Lua:

1. *number*
2. *boolean*
3. *string*
4. *table*
5. *function*
6. (*userdata*)

That's all folks!

Der Datentyp eines Wertes (einer Variablen) kann mit der `type` Funktionen ermittelt werden (gibt einen Stringwert zurück).

[CODE] Datentypen
```
x=fac(2)
y='test'
sq=function (x) return x*x end 
```

Teste und gebe die Datentypen der Werte von *x*, *y*, und *sq* mit der `print(type(v))` Anweisung aus.

> Ja richtig erkannt: Funktionen sind Werte in Lua!!! Funktionen können in Variablen enthalten sein, an Funktionen als Argument übergeben werden, und von Funktionen als Wert zurückgegebn werden!

## Funktionen höherer Ordnung

Da Funktionen auch Werte (erster Ordnung) sind, kann man damit viele Berechnungen vereinfachen bzw. abstrahieren.

Beispiel ist die Berechnung eines bestimmten Integrals einer beliebigen Funktion. Man müsste für jede Funktion die Integralberechnung immer wieder definieren. Es geht auch anders:

[CODE]
```
function integral(f)
  return function (a,b) 
    local res=0
    for i=a,b do
      res = res + f(i)
    end
    return res / (b-a)
  end
end
ix = integral(function (x) return x end)
print(ix(1,100))
```

Füge eine Integralfunktion *isqx* für die Quadratfunktion *x • x* und *isinx* für die Sinusfunktion `math.sin` hinzu und teste exemplarisch.

## Arrays und Records

Um Daten namentlich zu binden verwendet man Arrays und Records (Datenstrukturen). Der Unterschied zwischen beiden ist gering. Die Elemente von Arrays werden über einen numerischen Index (1,2,..) ausgewählt, die von Records durch die vom Programmierer gegebenen Namen der Elemente. Anders als in Programmiersprachen mit statischen Typsystem (*C*, *Java*) können auch Arrays in Lua mehrsortig sein, d.h. die Elemente können unterschiedliche Datentypen haben!

Arrays und Records sind in Lua sog. Tabellen. Genau genommen sind es beide Hashtabellen. Arrays und Records werden in Lua wie folgt definiert (*v*~i~ sind Werte oder Ausdrücke):

```lua
-- Array
local a = {v1,v2,..,vn}
-- Record
local r = {e1=v1, e2=v2, .. , en:vn}
```

Es gibt zwei Arten auf die Elemente von Records zuzugreifen:

```lua
x=r['ei']
x=r.ei
```

Die Länge eines Arrays kann durch den `#a` Operator ermittelt werden (d.h. die Anzahl der Elemente).

Folgende Beispiele sollen dies verdeutlichen:

[CODE]
```
a1 = {1,2,3,4}
ax1 = a1[2]
ax2 = a1['2']
ax3 = a1['name']

r1 = {a=1,b=2,c=3}
rx1 = r1.a
rx2 = r1['a']
rx3 = r1.b

a2 = {1,false,'name'}
ax4 = a2[2]
```

Welche Werte haben die einzelnen Variablen *ax*~i~ und *rx*~i~? Lese nach was Hashtabellen sind (Wikepedia https://de.wikipedia.org/wiki/Hashtabelle) und erkläre die Ergebnisse.

[INPUT]

Arrays und Records gehören zur prozeduralen Programmierung. D.h., man definiert Arrays/Records getrennt von Funktionen die die Arrays/Records verarbeiten. Beispiele:

[CODE]
```
function sum(a)
  local z=0
  for i=1,#a do
    z = z + a[i]
  end
  return z
end

function sum2(r)
  local z=0
  for p in pairs(r) do
    z = z + r[p]
  end
  return z
end

a={10,34,12,56}
print(sum(a))

r={a=10,b=34,c=12,d=56}
print(sum2(r))
```

Was ist das Problem bei dieser getrennten Programmierung von Daten und Funktionen die auf diesen Daten arbeiten?

Betrachte folgendes Beispiel:

[CODE]
```
print(sum(r))
print(sum2(a))
```

[INPUT]

## Objekte und Klassen

Objekte binden Daten und Funktionen (hier genannt Methoden). Die Methoden arbeiten nur auf Daten ihres Objekts. Objekte werden von Klassenprototypen erzeugt.

> In Lua gibt es keine Klassen und somit auch keine Objekte. Diese müssen mit Tabellen "emuliert" werden, d.h. die Bindung von Prototypenfunktionen an Tabellen.

Da Funktionen Werte sind kann man erst einmal Records (also Tabellen) direkt verwenden. Ist das schon ein Objekt nach obiger Definition?

[CODE]
```
local r = {
  x  = 16,
  sq = function (x) return x*x end
}
print(r.sq(r.x))
```

Da die Bindung von Prototypenfunktionen an Tabellen etwas kompliziert ist gibt es eine einfache Funktion um eine leere Klasse als Tabelle zu definieren: `class()`. Es können dann "Methoden" (also Funktionsprototypen) hinzugefügt werden und beliebig viele Objekte von dieser Klasse erzeugt werden:

[CODE]
```
-- Definition einer leeren Klasse
local myclass = class()
-- Hinzufügen von Methoden (init wird bei Erzeugung aufgerufen)
function myclass:init(x) self.x=x end
function myclass:getx()  return self.x end
function myclass:setx(v) self.x=v end

-- Erzeugung eines Objekts der Klasse myclass
local o1 = myclass:new(100)
-- Anwendung einer Methode
print(o1:getx())
```

Erweitere die Klasse um die Methoden `incr` und `decr` die die Objektvariable *x* um eins erhöht oder erniedrigt. Teste die Methoden exemplarisch.

> Zu beachten ist der Doppelpunkt zwischen Klassenname und Methodenname! Dieser sorgt für eine Bindung der Funktion an das Objekt!

[INFO] Implementierung der class Funktion
```
function class()
  local Class = {}; Class.__index = Class;
  function Class:new(...)
    local self = setmetatable({}, Class)
    if Class.init then Class.init(self,...) end
    return self
  end
  return Class
end
```

## Fehlerbehandlung und Signale^extra^

In einem Programm können Fehler auftreten:

- Eine undefinierte Variable oder Funktion wird verwendet/aufgerufen
- Division durch Null
- Eine Variable mit dem Wert *nil* wird weiter dereferenziert (z.B. `x[9], x.attr`)
- ..

Ein Fehler löst ein Signal aus (ein Ausnahmesignal). Wird dieses Signal nicht behandelt, führt dies zum Abbruch des Programms (i.A.). Es gibt aber auch Signale die man verwendet um an einer Stelle des Programms an eine andere "höhergelegene" Stelle zu gelangen. Entweder geplant oder auch um "seitwärts" aus einer Funktion bei einem Fehler (nicht schwerwiegend) wieder zum aufrufenden Kontext zu gelangen.

Programmiersprachen wie Java oder JavaScript bieten Signalbehandlung mittels einer *try* *catch* Anweisung, Lua leider nicht direkt/komfortabel (nur mittels der `pcall` oder `xpcall` Funktionen).

Ein Signal kann in Lua durch die `raise(signal)` Anweisung ausgelöst werden. Das Signal ist i.A. ein Stringname.

[CODE]
```
function incr(x)
  if x == nil then raise "Invalid argument" end
  return x+1
end
print(incr(10))
pcall(function () print(incr(10)) end)
```

[QUESTION]
Was passiert wenn die Funktion ohne Argument aufgerufen wird? Wie ändert sich das Verhalten bei Aufruf von `incr` durch `pcall(function () .. end)`? Was gibt *pcall* als Wert zurück (mit *print* testen)?

[INPUT]

Man kann die fehlende *try*-*catch* Anweisung aber funktional ergänzen, und man erhält dann:

[CODE]
```
try (function () 
  print(incr(2))
  print(incr())
end).catch(function (err)
  print(err)
end)
```

[INFO] Try-catch Code
```
local functionType = "function"
function try (tryBlock)
    local status, err = true, nil, trace
    function traceback(e)
      trace = e;
      return e 
    end
	if type(tryBlock) == functionType then
		status, err = xpcall(tryBlock,traceback)
	end

local _finally = function (finallyBlock, catchBlockDeclared)
		if type(finallyBlock) == functionType then
			finallyBlock()
		end
		
		if not catchBlockDeclared and not status then
			raise(err)
		end
	end

local _catch = function (catchBlock)
		local catchBlockDeclared = type(catchBlock) == functionType;

if not status and catchBlockDeclared then
			local ex = err or "unknown error occurred"
			catchBlock(ex,trace)
		end

return {
			finally = function(finallyBlock)
				_finally(finallyBlock, catchBlockDeclared)
			end
		}
	end

return
	{
		catch = _catch,
		finally = function(finallyBlock)
		    _finally(finallyBlock, false)
		  end
	}
end
```

---
Autor: Stefan Bosse<br>
Version: 3.12.2019 A<br>
Tutorial 1

Interactive NoteBook (c) Dr. Stefan Bosse

Einführung in die Programmierung mit der Skriptsprache Lua

Name
Matrikelnummer

Einführung

Eine Programmiersprache besteht aus eine Menge von Programmieranweisungen die man in folgende Klassen unterteilen kann:

Berechnung
Steuerung
Ein- und Ausgabe
Komposition
Typensystem (wenn überhaupt)

Berechnungen bestehen wiederum aus folgenden Komponenten:

Werten (Konstanten, Literale)
Variablen
Operationen (Addition, usw.)

Eine Variable kann

veränderlich wie Speicher sein,
oder unveränderlich wie eine symbolische Variable in der Mathematik.

In den folgenden Beispielen und Aufgaben können Werte und Variableninhalte mit der print Funktion in dem unter dem Code befindlichen Ausgabefenster ausgegeben werden. Hat man komplexere Werte, wie z.B. Datenstrukturen und Arrays, kann man stattdessen die inspect Funktion verwenden.

Dieses Tutorial ist in Snippets untertielt. Ein Snippet besteht aus einem Texteditorfenster und einem darunter befindlichen Kontroll- und Ausgabefenster. Das Kontrollfenster hat links den Run Knopf, der den Code ausführt, und rechts ein Erase Knopf, der das Ausgabefenster löscht.

Alle Codesnippets werden in einem sogenannten globalen Kontext ausgeführt, d.h., praktisch bilden sie ein Programm! Einzelne Codesnipptes können von der Ausführung vorheriger abhängen.

Daher bei einem Fehler prüfen ob die vorherigen Codesnipptes fehlerfrei ausgeführt wurden!

Alle Eingabefelder (Code und Antworten auf Fragen) können gespeichert und wieder in das interaktive Tutorial geladen werden (Linker und rechter Knopf in der Kopfzeile).

Die Inhalte von Programmcodefeldern können über ein WEB Clipboard mit anderen Teilnehmern geteilt werden (wenn sie gleichzeitig am Tutorial arbeiten). Dazu befindet sich rechts oben in einem Codeeditorfeld ein Kopfsymbol. Das WEB Clipboard Fenster ist spezifisch für dieses Codefeld! Der Copy Befefhl fügt den eigenen Programmcode zum Clipboard hinzu. Code anderer Nutzer kann aus der Liste durch öffnen des Spoiler importiert werden. Der aktuell ausgwählte Code kann durch den Paste Befehl übernommen werden. Code Schnippsel verschwinden nach einer gewissen Zeit wieder aus dem Clipboard (ca. 5 Minuten).

Der Lua Interpreter ist in diese WEB App integriert. Es werden keine externen Programme benötigt! Der Zustand des Interpreters kann momentan nur durch erneutes Laden der Seite zurückgesetzt werden (vorher alle Eingaben speichern).

In Lua werden einzelne Anweisungen entweder durch einen Zeilenumbruch oder ein Semikolon ; getrennt. Einzelne Anweisungen werden immer in der angegebenen Reihenfolge ausgeführt (imperative Programmierung).

Weitere Informationen über Lua gibt es hier:

http://edu-9.de/uploads/documents/lua_tutorial.pdf

Werte, Variablen, Ausdrücke

Werte und Ausdrücke können über den = Operator einer Variablen zugewiesen werden. Lua kennt keine statische Typisierung, d.h., der Variablentyp ist polymorph und wird ausschließlich durch den aktuellen Inhalt bestimmt, der sich zur Laufzeit ändern kann.

Füge in den folgenden Code die print Anweisung für y und z ein.

Variablen und Werte

x=1       -- type number
y=false   -- type boolean
z='text'  -- type string 
print(x)

▸

✗

Ausdrücke bestehen aus Operanden (können auch wieder Ausdrücke sein) und Operatoren:

Information. Lua Operatoren

Addition: +
Subtraktion: -
Multiplikation: *
Division: /
Modulo: %
Boolesches Und: and
Boolesches Oder: or
Boolesches Nicht: not
usw.

Ausdrücke

x=x+23     
y=(x-1)*(x+1)  
z=y/2 
print(x,y,z)

▸

✗

Man unterscheidet globale und lokale Variablen. Eine globale Variable wird einfach durch eine Zuweisungsanweisung x=v eingeführt. Eine lokale Variable wird durch die Anweisung local x=v eingeführt. Der Initialwert v ist optional. In Funktionen immer nur lokale Variablen definieren!

Lokale und globale Variablen

x1=100
function foo1(x1)
  local x2
  x1=x1+1
  x2=x1*2
  return x2*x2
end
function foo2(x3)
  local x4=x3-1
  return x4*2
end
print(x1,foo1(x1),foo2(12))

▸

✗

Gebe in obigen Beispiel den Wert von x1 in foo2 aus. Was passiert? Und wenn x2 ausgegeben wird? Welchen Wert hat die globale Variable x1 nach der Ausführung von foo1?

Lokale Variablen können in Funktionen aber auch in Anweisungsblöcken (Schleifen, Bedingte Verzweigung) definiert und benutzt werden.

Steueranweisungen

Steueranweisungen dienen zur Beeinflussung des Programmflusses. Man unterscheidet (mit s als Anweisung oder einer Reihe von Anweisungen):

Bedingte Verzweigungen: if e then s1 else s2 end
Bedingte Schleifen: while e do s end
Zählschleifen: for i=a,b do s end

Folgendes Beispiel zeigt die Implementierung der Funktion:

local r=1
for index=1,10 do
  r=r*index
end
print(r)
if r > 100000 then print('Big Number!') end

▸

✗

Der Programmfluss von Schleifen ist in folgender Abbildung dargestellt (Flussdiagramme).