Einführung in die Programmierung mit der Skriptsprache Lua

In diesem Tutorial sollen grundlegendene Kenntnisse in der Programmierung mit der Programmiersprache Lua erworben werden.

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
4. Komposition
5. 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.

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

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!

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):

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:

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

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

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.

Frage. Was passiert wenn die Anzahl der Argumente kleiner oder größer als die Anzahl der Funktionsparameter ist? Teste es mit foo und foo2

Frage. Was ist Funktionsrekursion?

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

Frage. 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!

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).

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:

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):

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

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:

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.

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

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

Betrachte folgendes Beispiel:

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?

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:

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!

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

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.

Frage. 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)?

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

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