Eine Datei ist zunächst mal für unsere Zwecke ein Text, der auf der Festplatte unter einem Namen wie z.B. "foo.txt" gespeichert wird. Die Datei können wir dann nicht nur mit Processing, sondern auch mit handelsüblichen Text-Editoren wie Notepad, Word etc. lesen und ändern.

Daten schreiben

Das Schreiben von Daten nennt man auch save (engl. für Retten). Wir können mit der Funktion saveStrings() einen beliebig großen Array von Strings abspeichern. Dazu übergeben wir der Funktion den Namen der Datei und den Array. Die Datei wird im Verzeichnis unseres Processing-Programms gespeichert. Sie enthält auf jeder Zeile einen String. Im folgenden Beispiel wird eine Textdatei mit Namen "meineDaten.txt" mit drei Zeilen erzeugt:

// drei Zeilen speichern
 
String[] zeilen = new String[3];
 
zeilen[0] = "Das ist";
zeilen[1] = "ein Text";
zeilen[2] = "auf drei Zeilen";
 
saveStrings("meineDaten.txt", zeilen);

Wenn wir "meineDaten.txt" mit einem Texteditor öffnen, sehen wir:

Das ist
ein Text
auf drei Zeilen

Daten lesen

Das Lesen von Daten nennt man auch load (engl. für Laden). Die Funktion loadStrings() erwartet einen Dateinamen und liefert ein String-Array zurück, welches den Text in der Datei zeilenweise enthält.

Das Beispielprogramm liest eine Datei mit Namen "meineDaten.txt", die sich im "data"-Ordner des Verzeichnis des Processing-Programms befinden muss, und schreibt den Inhalt zeilenweise auf die Konsole:

// Textdatei lesen
 
String[] lines = loadStrings("meineDaten.txt");
 
for (int i = 0; i < lines.length; i++) {
  println("> " + lines[i]);
}

Wir müssen nicht unbedingt die gleichen Daten einlesen wie die, die wir oben erzeugt haben. Probiere folgendes: Schreibe einen Text mit einem Editor und lade ihn mit obigen Programm (Dateiname anpassen!).

Objekt speichern

Inwiefern helfen mir Dateien, wenn ich in einem Spiel den Punktestand und die Position der Spielerfigur und der gegnerischen Figuren etc. abspeichern will?

Wir sehen uns dazu Beispiele an. Da wir in Dateien mit Texten arbeiten, müssen wir dafür sorgen, dass z.B. numerische Daten beim Schreiben in Text umgewandelt werden. Umgekehrt, wenn wir den Text wieder lesen, muss der Text wieder in eine Zahl umgewandelt werden.

Als Beispiel nehmen wir uns einen Ball, der umherfliegt und von den Wänden abprallt. Als Code:

int x;
int y;
int xspeed;
int yspeed;
 
void setup() {
  size(200, 200);
  x = width/2;
  y = height/2;
  xspeed = (int)random(1, 2);
  yspeed = (int)random(2, 4);
}
 
void draw() {
  background(100);
  noStroke();
  fill(255);
 
  ellipse(x, y, 20, 20);
  x += xspeed;
  y += yspeed;
 
  if (x < 0 || x > width) {
    xspeed = -xspeed;
  }
  if (y < 0 || y > height) {
    yspeed = -yspeed;
  }
}

Die Frage, die man sich stellen muss, wenn man ein Objekt speichern und später wieder laden will, lautet: Welches sind die Eigenschaften, die das Objekt beschreiben? Unser Ball wird beschrieben durch vier Integer-Werte: x-Position, y-Position, x-Geschwindigkeit, y-Geschwindigkeit. Diese Werte wollen wir speichern. Das machen wir ganz einfach, indem wir jeden Wert auf eine Zeile schreiben:

void saveConf() {
  String[] data = new String[4];
 
  // Zahlen werden hier in Strings umgewandelt ...
  data[0] = "" + x;        // einmal mithilfe von "" +
  data[1] = "" + y;        // Wichtig: Kein Leerzeichen einbauen!
  data[2] = nf(xspeed);    // Alternativ geht auch nf()
  data[3] = nf(yspeed);
 
  saveStrings("conf.txt", data);
}

Beachte, dass wir die Zahlen in Strings umwandeln, indem wir die doppelten Quotes voranstellen. Das ist aber keine richtig schöne Lösung, eher ein Trick. Alternativ kannst du die Zahl auch mithilfe von nf() in einen String umwandeln. Hier hast du auch die Möglichkeit den String nochmal etwas zu formatieren, z.B. mit vorangestellten Nullen (siehe Strings verarbeiten). Dann wird der String-Array mit saveStrings() gespeichert.

Vorsicht: Setze kein Leerzeichen zwischen die Quotes, sonst gibt es Probleme beim Einlesen, da Processing eine Zahl mit führendem Leerzeichen nicht als Zahl erkennt.

Jetzt brauchen wir eine Funktion, welche die Daten aus der Datei wieder ausliest. Hier verwenden wir die Processing-Funktion int(), um aus einem String (z.B. in data[0], wo die erste Zeile steht) eine Integer-Zahl zu machen:

void loadConf() {
  String[] data = loadStrings("conf.txt");
 
  // Strings jeweils in Zahlen umwandeln
  x = int(data[0]);
  y = int(data[1]);
  xspeed = int(data[2]);
  yspeed = int(data[3]);
}

Um das Ganze auszuprobieren, bauen wir eine Tastatursteuerung ein, die die aktuelle Ball-Konfiguration mit "s" speichert und mit "l" wieder lädt.

void keyPressed() {
  if (key == 's') {
    saveConf();
  }
  if (key == 'l') {
    loadConf();
  }
}

Wir können jetzt jederzeit die aktuelle Position mit "s" speichern. Sobald wir "l" drücken, springt der Ball an die gespeicherte Position zurück. Sieh dir auch die Datei "conf.txt" auf deiner Festplatte an.

Zusammenfassung

Eine wichtige Möglichkeit zum lesen und und speichern von Daten in der Programmierung ist das Erzeugen und Lesen von Dateien. Mithilfe von Processing ist dies sehr leicht möglich in Verbindung mit den Funktionen saveStrings() und loadString().

Mithilfe von saveStrings() kann eine Datei erzeugt werden. Die Funktion benötigt 2 Parameter: Den Text, der gespeichert werden soll und den Namen der Text-Datei, die angelegt werden soll. Der Text liegt in Form eines einfachen String-Arrays vor. Dabei ist jedes Element im Array später eine neue Zeile im Text-Dokument.
Mithilfe von loadStrings() kann eine Datei gelesen werden. Die Funktion benötigt als Parameter den Namen der Text-Datei, die gelesen werden soll. Außerdem liefert die Funktion als Rückgabewert einen einfachen String-Array. Jedes Element im Array enthält genau eine Zeile der Text-Datei.
Die Text-Datei, die Gelesen bzw. erzeugt wird, befindet sich im "data"-Ordner deines Procesing Projektordners.