In unserem Alltag kennen wir viele Handlungsauläufe: Stell dir vor. Du willst ein Parkticket an einem Parkautomat kaufen. Für dich lautet die Aufgabe in deinem Kopf "Kaufe ein Parkticket". In Wirklichkeit sind es aber mehrer Schritte: Du gehst zum Automat, drückst auf "Parkticket", liest die Informationen zur Zahlung, holst deinen Geldbeutel raus, wirfst ein paar Münzen in den Automaten und bekommst dann dein Ticket. "Parkticket kaufen" ist alo ein Set aus mehreren Aktionen. Stell dir vor, du würdest einen Roboter programmieren ein Parkticket zu kaufen - was würdest du lieber tun: Dem Roboter jedes Mal, wenn er ein Parkticket kaufen soll alle Aktionen und Befehle einzeln geben - oder würdest du lieber all diese Befehle in einem Befehl namens "Parkticket kaufen" bündeln?

Genau das machen Funktionen. Funktionen bündeln mehrere Befehle zu einem Befehl bündeln. Das ist vor allem dann sinnvoll, wenn du dasselbe Set an Befehlen an einer anderen Stelle im Code wiederverwenden möchtest. Schriebe also niemals denselben Code zweimal - mache stattdessen eine Funktion daraus. Außerdem kann du deinen Code durch Funktionen besser aufteilen und strukturieren. Durch die Namen des Funktionen ist schnell kar, was dein Code macht. Und zuletzt: Funktionen vermeiden Fehler. Stell dir vor, du hast an zwei Stellen denselben Code (weil du keine Funktion daraus gemacht hast) und musst diesen Code anpassen/verändern. Dabei vergisst du aber, dass der Code ja auch an der anderen Stelle verändert werden muss - schon hast du jede Menge Bugs. Das kann dir nicht passieren, wenn sich Code nicht wiederholt, weil er in Funktionen ist.

Die 3 großen Vorteile von Funktionen sind also:

• Wiederverwendbarkeit
• Struktur
• Fehlervermeidung

Du hast übrigens schon Funktionen benutzt, in der Form von "Befehlen" wie size(), ellipse() und rect() sind Funktionen, die das Processing-Team für dich geschrieben hat. In diesem Kapitel lernst du, wie du selbst solche Befehle erstellst.

Funktion definieren

Bevor du eine neue Funktion verwenden kannst, musst du Processing sagen, was diese Funktion genau tun soll. Da machst du mit der Definition der Funktion.

Allgemein definiert man eine (einfache) Funktion wie folgt:

void NAME() {
   CODE
}

Wobei CODE für eine beliebige Anzahl von Codezeilen stehen kann. Diese Funktion hier zeichnet zum Beispiel ein Gesicht mit zwei schwarzen Knopfaugen an der Stelle (x, y), wobei x und y bereits oben im Code deklariert sein müssen:

void zeichneGesicht() {
   fill(255); // weiß
   ellipse(x, y, 80, 80); // Gesicht
   fill(0); // schwarz
   ellipse(x-15, y-15, 20, 20); // Auge
   ellipse(x+15, y-15, 20, 20); // Auge
} 

Etwas merkwürdig sehen noch die runden Klammern hinter dem Funktionsnamen aus, diese bekommen im Abschnitt Parameter Sinn.

Funktion aufrufen

Wir haben oben die Funktion zeichneGesicht definiert. Diese steht uns ab sofort als Befehl zur Verfügung, genauso wie die "eingebauten" Befehle ellipse, size, stroke usw.

Du rufst den Befehl dann so auf:

zeichneGesicht();

 
Sehen wir uns das vollständige Programm an:

int x = 50;
int y = 50;
 
void setup() { // nichts zu tun
}
 
void draw() {
   // sehr übersichtlich :)
   background(255);
   zeichneGesicht(); // Funktionsaufruf
   x++;
}
 
// Funktionsdefinition:
void zeichneGesicht() {
   fill(255);
   ellipse(x, y, 80, 80);
   fill(0);
   ellipse(x-15, y-15, 20, 20);
   ellipse(x+15, y-15, 20, 20);
}

 
Der Vorteil hier ist zunächst mal, dass dein Programm übersichtlicher wird. Wenn man in draw() hineinschaut, sieht man direkt, dass offenbar etwas entlang der x-Achse bewegt wird. Der Name der Funktion zeichneGesicht sagt klar, was bei Aufruf des Befehls zu erwarten ist. Das heißt: Funktionen helfen, Code übersichtlicher und lesbarer zu gestalten. Man spricht auch von selbsterklärendem Code, d.h. der Code spricht für sich selbst und muss nicht (oder kaum) durch Kommentare ergänzt werden. Dabei ist wichtig, aussagekräftige Namen für die Funktionen zu wählen.

 
Zusammenfassung

Du kannst eigene Funktionen definieren, die du dann im Code beliebig oft aufrufen kannst. Allgemein sieht eine Funktionsdefinition so aus:

void NAME() {
  CODE
}

Funktionen dienen dazu, den Code übersichtlicher und lesbarer zu gestalten. Dazu sollten die gewählten Funktionsnamen möglichst aussagekräftig sein.

Eigene Funktionen kann man nur im aktiven Modus definieren.