Programmieren mit PHP 5

14.2 Beispiel mit Datenerfassung (objektorientiert)

Ein solches Objekt beschreibt einen Schüler mit den Attributen: "Name" (Zeichenkette mit beliebig viele Zeichen),; "Notendurchschnitt" (rationale Zahl vom Typ float) und; "Klasse" (Zeichenkette mit einer fixen Anzahl von Zeichen - in diesem Beispiel immer genau 7 Zeichen).

Über die Standardeingabe (Tastatur/Formular) sollen zunächst die Attribute von mehreren Schülerobjekten eingelesen und danach in einer Datei gespeichert werden. Dazu werden 2 Klassen definiert: die Klasse DAOerfassenSchueler zum Erfassen der Daten und die Klasse DAOschreibenSchueler zum Schreiben (Speichern) der Daten. Ein Schüler wird repräsentiert als Instanz einer Klasse Schueler.

Eine zweite Anwendung soll die Datei lesen und die Daten der Datei auf der Standardausgabe (Bildschirm/Webseite) anzeigen. Zu diesem Zweck gibt es die Klasse DAOlesenSchueler, die das Lesen der gespeicherten Daten ermöglicht. Eine weitere Klasse - DAOausgebenSchueler - ist zuständig für das Aufbereiten und Ausgeben der Daten.

Das Beispiel zeigt 2 Varianten der Dateiverarbeitung: Speicherung der Daten in einer Textdatei und Speicherung der Daten in einer Binärdatei. Die beiden Klassen zum Schreiben und Lesen gibt es nachfolgend daher in 2 Varianten.

Die 4 Klassen zum Erfassen, Schreiben, Lesen und Ausgeben der Daten sind sog. DAO-Klassen ("Data Access Object"), die Klasse Schueler ist eine sog. Model-Klasse ("model" engl. für "Daten") - siehe auch Kap.5.2.1.1.

Bem.:: Es wäre durchaus sinnvoll, die 3 erstgenannten Klassen zu 1 einzigen zusammenzufassen, denn die Datenerfassung mit Speichern und späterem Lesen definiert die Schnittstelle zu dem erwähnten Objekt ("Datei"). Auf diese Weise sind die Beispielprogramme und die darin geübten Techniken jedoch leichter zu verstehen.; Die 4. Klasse (DAOausgebenSchueler) jedoch ist nicht abhängig von der Datei, sondern nur von den Wünschen der Benutzer, die die Daten anschauen möchten (beispielsweise könnte man die Daten in einer Tabelle darstellen).

Zu den Klassen:: Model-Klasse Schueler; DAO-Klassen; DAOerfassenSchueler; DAOschreibenSchuelerText; DAOschreibenSchuelerBinaer; DAOlesenSchuelerText; DAOlesenSchuelerBinaer; DAOausgebenSchueler
Zu den Anwendungsprogrammen:: Daten erfassen und speichern; Daten lesen und ausgeben
Zum UML-Klassendiagramm:: Allgemeines Klassendiagramm für die DAO-Klassen

14.2.1 Model-Klasse `Schueler` für Daten

Datei `Schueler.class.php`
<?php class Schueler { // ------------------------------------------------------------------------- // Klassenkonstante // Die Klassenbezeichnung hat immer 7 Stellen. const LAENGEKLASSE = 7; // ------------------------------------------------------------------------- // Instanzattribute private $name; // Zeichenkette mit variabler Länge private $notenschnitt; // float private $klasse; // Zeichenkette mit fixer Länge // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getName() { return $this->name; } public function setName($name) { $this->name = $name; } // ---------- public function getNotenschnitt() { return $this->notenschnitt; } public function setNotenschnitt($notenschnitt) { $this->notenschnitt = $notenschnitt; } // ---------- public function getKlasse() { return $this->klasse; } /* Ändert das dritte Datenfeld (Klassenbezeichnung) und kontrolliert auch gleichzeitig die Länge dieses Feldes. Eine zu kurze Zeichenkette wird mit Leerzeichen aufgefüllt, eine zu lange wird einfach abgeschnitten. / public function setKlasse($klasse)* { // mit Leerzeichen erweitern: $this->klasse = str_pad($klasse, self::LAENGEKLASSE); // kürzen auf fixe Länge: $this->klasse = substr($this->klasse, 0, self::LAENGEKLASSE); } // ------------------------------------------------------------------------- // Magische Methode '__toString' public function __toString() { return "Name = " . $this->name . " (Länge = " . strlen($this->name) . "), Notendurchschnitt = " . $this->notenschnitt . ", Klassenbezeichnung = " . $this->klasse . "" ; } } ?>

Datei Schueler.class.php

<?php class Schueler { // ------------------------------------------------------------------------- // Klassenkonstante // Die Klassenbezeichnung hat immer 7 Stellen. const LAENGEKLASSE = 7; // ------------------------------------------------------------------------- // Instanzattribute private $name; // Zeichenkette mit variabler Länge private $notenschnitt; // float private $klasse; // Zeichenkette mit fixer Länge // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getName() { return $this->name; } public function setName($name) { $this->name = $name; } // ---------- public function getNotenschnitt() { return $this->notenschnitt; } public function setNotenschnitt($notenschnitt) { $this->notenschnitt = $notenschnitt; } // ---------- public function getKlasse() { return $this->klasse; } /* Ändert das dritte Datenfeld (Klassenbezeichnung) und kontrolliert auch gleichzeitig die Länge dieses Feldes. Eine zu kurze Zeichenkette wird mit Leerzeichen aufgefüllt, eine zu lange wird einfach abgeschnitten. */ public function setKlasse($klasse) { // mit Leerzeichen erweitern: $this->klasse = str_pad($klasse, self::LAENGEKLASSE); // kürzen auf fixe Länge: $this->klasse = substr($this->klasse, 0, self::LAENGEKLASSE); } // ------------------------------------------------------------------------- // Magische Methode '__toString' public function __toString() { return "Name = " . $this->name . " (Länge = " . strlen($this->name) . "), Notendurchschnitt = " . $this->notenschnitt . ", Klassenbezeichnung = *" . $this->klasse . "*" ; } } ?>

14.2.2 DAO-Klassen

14.2.2.1 Klasse `DAOerfassenSchueler` für Datenerfassung (Standardeingabe)

Bem.: Methoden "oeffnen" und "schliessen" sind nicht notwendig, weil die Standardeingabe (= Tastatur) immer geöffnet ist.

Datei `DAOerfassenSchueler.class.php`
<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOerfassenSchueler { // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu erfassenden Daten / private $schueler; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler()* { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden /* Prüfen und aufbereiten der Eingabedaten. Erstellen eines Schülerobjekts. Parameter: $eingabe Datenstruktur mit 3 Datenfeldern (name, notenschnitt, klasse) return: true, wenn die Erfassung der Daten erfolgreich war / public function aufbereitenDaten($eingabe)* { // 1. Datenfeld (Zeichenkette mit variabler Länge) $name = trim($eingabe->name); if (empty($name)) { $this->schueler = NULL; return FALSE; // fehlt ein Attribut, wird kein Datensatz erstellt } // 2. Datenfeld (Zahl) $notenschnitt = trim($eingabe->notenschnitt); if (!is_numeric($notenschnitt)) { $this->schueler = NULL; return FALSE; // ist Attribut falsch, wird kein Datensatz erstellt } settype($notenschnitt, "float"); // 3. Datenfeld (Zeichenkette mit fixer Länge) $klasse = trim($eingabe->klasse); if (empty($klasse)) { $this->schueler = NULL; return FALSE; // fehlt ein Attribut, wird kein Datensatz erstellt } // Erfasste Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); return TRUE; } // ---------- public function beenden() { $this->eof = TRUE; // Datenerfassung beenden (EOF setzen) } } ?>

Datei DAOerfassenSchueler.class.php

<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOerfassenSchueler { // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu erfassenden Daten */ private $schueler; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler() { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden /* Prüfen und aufbereiten der Eingabedaten. Erstellen eines Schülerobjekts. Parameter: $eingabe Datenstruktur mit 3 Datenfeldern (name, notenschnitt, klasse) return: true, wenn die Erfassung der Daten erfolgreich war */ public function aufbereitenDaten($eingabe) { // 1. Datenfeld (Zeichenkette mit variabler Länge) $name = trim($eingabe->name); if (empty($name)) { $this->schueler = NULL; return FALSE; // fehlt ein Attribut, wird kein Datensatz erstellt } // 2. Datenfeld (Zahl) $notenschnitt = trim($eingabe->notenschnitt); if (!is_numeric($notenschnitt)) { $this->schueler = NULL; return FALSE; // ist Attribut falsch, wird kein Datensatz erstellt } settype($notenschnitt, "float"); // 3. Datenfeld (Zeichenkette mit fixer Länge) $klasse = trim($eingabe->klasse); if (empty($klasse)) { $this->schueler = NULL; return FALSE; // fehlt ein Attribut, wird kein Datensatz erstellt } // Erfasste Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); return TRUE; } // ---------- public function beenden() { $this->eof = TRUE; // Datenerfassung beenden (EOF setzen) } } ?>

14.2.2.2 Klasse `DAOschreibenSchueler` für Speichern von Daten in einer Datei (Textdatei und Binärdatei)

Am einfachsten ist es, alle Daten als Text, d.h. als Zeichenketten, abzuspeichern. Dabei wird jede Zahl in eine Ziffernfolge umgewandelt. Beim Lesen einer solchen Textdatei müssen die Ziffernfolgen dann wieder in eine Zahl konvertiert werden. Eine Textdatei kann im Allg. völlig problemlos auf jedem Rechner mit jeder Programmiersprache verarbeitet werden.

Wesentlich schwieriger ist es, eine Zahl binär so abzuspeichern, dass sie auf einem anderen Rechner oder mit einer anderen Programmiersprache wieder korrekt gelesen werden kann. Das Problem besteht darin, dass die internen Zahlenformate auf verschiedenen Rechnern sehr unterschiedlich sein können und manche Programmiersprachen keine maschinenunabhängigen Zahlenformate spezifizieren (in PHP gibt es beispielsweise kein definiertes Gleitkommaformat).

Schreiben der Daten in eine Textdatei

Datei `DAOschreibenTextSchueler.class.php`
<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOschreibenTextSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Länge der Attribute der Klasse 'Schueler' als Zeichenketten bzw. bei variabler Länge eines Attributs: Länge des zum Attribut gehörenden Längenfelds. Die Länge des Namens ist variabel - das Längenfeld für den Namen ist eine int-Zahl, für die 4 Stellen reserviert werden. Für den Notendurchschnitt werden 5 Stellen reserviert. Da diese Längenangaben auch in der Klasse 'LesenSchueler' benötigt werden, könnten sie alternativ in einem Interface definiert werden. Die Klassenbezeichnung ist eine Zeichenkette fixer Länge, diese ist daher in der Klasse 'Schueler' als Klassenkonstante definiert. / const LAENGENAME = 4; const LAENGENOTENSCHNITT = 5; // ------------------------------------------------------------------------- // Instanzattribute / Datenobjekt für die zu schreibenden Daten / private $schueler; / Verbindungsobjekt zur Datei / private $datei; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler)* { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname, $open) { $this->datei = fopen($dateiname, $open) or die("<p>Die Datei <b>$dateiname</b> konnte nicht geöffnet werden.</p>"); } // ---------- /* Schreibt einen neuen Schüler-Datensatz in die Textdatei. Die Datenfelder werden - entsprechend dem Satzaufbau - der Reihe nach geschrieben. Jedes Datenfeld wird gegebenenfalls in eine Zeichenkette konvertiert und - entsprechend den definierten Längen - mit Leerzeichen rechts aufgefüllt. / public function schreiben()* { // Speichern der Länge des 1. Datenfeldes $anzByte = strlen($this->schueler->getName()); $anzByteStr = (string) $anzByte; $anzByteStr = str_pad($anzByteStr, self::LAENGENAME); fwrite($this->datei, $anzByteStr, self::LAENGENAME); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) fwrite($this->datei, $this->schueler->getName(), $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $notenschnittStr = (string) $this->schueler->getNotenschnitt(); $notenschnittStr = str_pad($notenschnittStr, self::LAENGENOTENSCHNITT); fwrite($this->datei, $notenschnittStr, self::LAENGENOTENSCHNITT); // 3. Datenfeld (Klasse - Zeichenkette mit fixer Länge) fwrite($this->datei, $this->schueler->getKlasse(), Schueler::LAENGEKLASSE); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Datei DAOschreibenTextSchueler.class.php

<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOschreibenTextSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Länge der Attribute der Klasse 'Schueler' als Zeichenketten bzw. bei variabler Länge eines Attributs: Länge des zum Attribut gehörenden Längenfelds. Die Länge des Namens ist variabel - das Längenfeld für den Namen ist eine int-Zahl, für die 4 Stellen reserviert werden. Für den Notendurchschnitt werden 5 Stellen reserviert. Da diese Längenangaben auch in der Klasse 'LesenSchueler' benötigt werden, könnten sie alternativ in einem Interface definiert werden. Die Klassenbezeichnung ist eine Zeichenkette fixer Länge, diese ist daher in der Klasse 'Schueler' als Klassenkonstante definiert. */ const LAENGENAME = 4; const LAENGENOTENSCHNITT = 5; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu schreibenden Daten */ private $schueler; /* Verbindungsobjekt zur Datei */ private $datei; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler) { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname, $open) { $this->datei = fopen($dateiname, $open) or die("Die Datei $dateiname konnte nicht geöffnet werden."); } // ---------- /* Schreibt einen neuen Schüler-Datensatz in die Textdatei. Die Datenfelder werden - entsprechend dem Satzaufbau - der Reihe nach geschrieben. Jedes Datenfeld wird gegebenenfalls in eine Zeichenkette konvertiert und - entsprechend den definierten Längen - mit Leerzeichen rechts aufgefüllt. */ public function schreiben() { // Speichern der Länge des 1. Datenfeldes $anzByte = strlen($this->schueler->getName()); $anzByteStr = (string) $anzByte; $anzByteStr = str_pad($anzByteStr, self::LAENGENAME); fwrite($this->datei, $anzByteStr, self::LAENGENAME); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) fwrite($this->datei, $this->schueler->getName(), $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $notenschnittStr = (string) $this->schueler->getNotenschnitt(); $notenschnittStr = str_pad($notenschnittStr, self::LAENGENOTENSCHNITT); fwrite($this->datei, $notenschnittStr, self::LAENGENOTENSCHNITT); // 3. Datenfeld (Klasse - Zeichenkette mit fixer Länge) fwrite($this->datei, $this->schueler->getKlasse(), Schueler::LAENGEKLASSE); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Schreiben der Daten in eine Binärdatei

Für die nachfolgende Speicherung der Länge des Namens (eine ganze Zahl) wird das duale Format mit 2 Byte und normaler Byte-Folge (= Big Endian) verwendet. Da es in PHP aber kein spezifiziertes Gleitkommaformat gibt, wird das Format von MS-Windows verwendet: Länge = 4B (einfache Genauigkeit) mit verkehrter Byte-Folge (= Little Endian).

Datei `DAOschreibenBinaerSchueler.class.php`
<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOschreibenBinaerSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Die Länge und die Byte-Folge einer Gleitkommazahl mit einfacher Genauigkeit ist maschinenabhängig!! In PHP gibt es derzeit noch kein maschinenunabhängiges Formatzeichen für die 'pack'-/'unpack'-Funktionen. Für MS-Windows-Betriebssysteme gilt: Länge = 4B, Byte-Folge = Little Endian! / const LAENGEFLOAT = 4; // ------------------------------------------------------------------------- // Instanzattribute / Datenobjekt für die zu schreibenden Daten / private $schueler; / Verbindungsobjekt zur Datei / private $datei; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler)* { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname, $open) { $this->datei = fopen($dateiname, $open) or die("<p>Die Datei <b>$dateiname</b> konnte nicht geöffnet werden.</p>"); } // ---------- /* Schreibt einen neuen Schüler-Datensatz in die Binärdatei. Die Datenfelder werden - entsprechend dem Satzaufbau - der Reihe nach geschrieben. Jedes Datenfeld wird entsprechend seinem Datentyp gespeichert. / public function schreiben()* { // Speichern der Länge des 1. Datenfeldes $anzByte = strlen($this->schueler->getName()); $packzahl = pack("n", $anzByte); // n = 16b = 2B, normale Byte-Folge (Big Endian) fwrite($this->datei, $packzahl, 2); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) fwrite($this->datei, $this->schueler->getName(), $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $packzahl = pack("f", $this->schueler->getNotenschnitt()); // f ... maschinenabhängig!! fwrite($this->datei, $packzahl, self::LAENGEFLOAT); // 3. Datenfeld (Klasse - Zeichenkette mit fixer Länge) fwrite($this->datei, $this->schueler->getKlasse(), Schueler::LAENGEKLASSE); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Datei DAOschreibenBinaerSchueler.class.php

<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOschreibenBinaerSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Die Länge und die Byte-Folge einer Gleitkommazahl mit einfacher Genauigkeit ist maschinenabhängig!! In PHP gibt es derzeit noch kein maschinenunabhängiges Formatzeichen für die 'pack'-/'unpack'-Funktionen. Für MS-Windows-Betriebssysteme gilt: Länge = 4B, Byte-Folge = Little Endian! */ const LAENGEFLOAT = 4; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu schreibenden Daten */ private $schueler; /* Verbindungsobjekt zur Datei */ private $datei; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler) { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname, $open) { $this->datei = fopen($dateiname, $open) or die("Die Datei $dateiname konnte nicht geöffnet werden."); } // ---------- /* Schreibt einen neuen Schüler-Datensatz in die Binärdatei. Die Datenfelder werden - entsprechend dem Satzaufbau - der Reihe nach geschrieben. Jedes Datenfeld wird entsprechend seinem Datentyp gespeichert. */ public function schreiben() { // Speichern der Länge des 1. Datenfeldes $anzByte = strlen($this->schueler->getName()); $packzahl = pack("n", $anzByte); // n = 16b = 2B, normale Byte-Folge (Big Endian) fwrite($this->datei, $packzahl, 2); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) fwrite($this->datei, $this->schueler->getName(), $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $packzahl = pack("f", $this->schueler->getNotenschnitt()); // f ... maschinenabhängig!! fwrite($this->datei, $packzahl, self::LAENGEFLOAT); // 3. Datenfeld (Klasse - Zeichenkette mit fixer Länge) fwrite($this->datei, $this->schueler->getKlasse(), Schueler::LAENGEKLASSE); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

14.2.2.3 Klasse `DAOlesenSchueler` für Lesen von Daten aus einer Datei (Textdatei und Binärdatei)

Lesen der Daten aus einer Textdatei

Datei `DAOlesenTextSchueler.class.php`
<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOlesenTextSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Länge der Attribute der Klasse 'Schueler' als Zeichenketten bzw. bei variabler Länge eines Attributs: Länge des zum Attribut gehörenden Längenfelds. Die Länge des Namens ist variabel - das Längenfeld für den Namen ist eine int-Zahl, für die 4 Stellen reserviert werden. Für den Notendurchschnitt werden 5 Stellen reserviert. Da diese Längenangaben auch in der Klasse 'SchreibenSchueler' benötigt werden, könnten sie alternativ in einem Interface definiert werden. Die Klassenbezeichnung ist eine Zeichenkette fixer Länge, diese ist daher in der Klasse 'Schueler' als Klassenkonstante definiert. / const LAENGENAME = 4; const LAENGENOTENSCHNITT = 5; // ------------------------------------------------------------------------- // Instanzattribute / Datenobjekt für die zu lesenden Daten / private $schueler; / Verbindungsobjekt zur Datei / private $datei; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler()* { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname) { $this->datei = fopen($dateiname, "rb") or die("<p>Die Datei <b>$dateiname</b> existiert nicht.</p>"); } // ---------- /* Liest den nächsten Schüler-Datensatz aus der Datei - alle Attribute eines Schülerobjekts sind nebeneinander ohne Abstand gespeichert. Die Attribute werden (entsprechend dem Satzaufbau) der Reihe nach aus dem Datensatz gelesen. Achtung: 1 Datensatz besteht immer aus allen Attributen, d.h. EOF wird nur am Beginn des Datensatzes geprüft! / public function lesen()* { // Länge des 1. Datenfeldes $datenfeld = fread($this->datei, self::LAENGENAME); if (feof($this->datei)) { $this->schueler = NULL; $this->eof = TRUE; return; } $anzByte = (int) trim($datenfeld); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) $name = fread($this->datei, $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $datenfeld = fread($this->datei, self::LAENGENOTENSCHNITT); $notenschnitt = (float) trim($datenfeld); // 3. Datenfeld (Klassenbezeichnung - Zeichenkette mit fixer Länge) $klasse = fread($this->datei, Schueler::LAENGEKLASSE); // Gelesene Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Datei DAOlesenTextSchueler.class.php

<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOlesenTextSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Länge der Attribute der Klasse 'Schueler' als Zeichenketten bzw. bei variabler Länge eines Attributs: Länge des zum Attribut gehörenden Längenfelds. Die Länge des Namens ist variabel - das Längenfeld für den Namen ist eine int-Zahl, für die 4 Stellen reserviert werden. Für den Notendurchschnitt werden 5 Stellen reserviert. Da diese Längenangaben auch in der Klasse 'SchreibenSchueler' benötigt werden, könnten sie alternativ in einem Interface definiert werden. Die Klassenbezeichnung ist eine Zeichenkette fixer Länge, diese ist daher in der Klasse 'Schueler' als Klassenkonstante definiert. */ const LAENGENAME = 4; const LAENGENOTENSCHNITT = 5; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu lesenden Daten */ private $schueler; /* Verbindungsobjekt zur Datei */ private $datei; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler() { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname) { $this->datei = fopen($dateiname, "rb") or die("Die Datei $dateiname existiert nicht."); } // ---------- /* Liest den nächsten Schüler-Datensatz aus der Datei - alle Attribute eines Schülerobjekts sind nebeneinander ohne Abstand gespeichert. Die Attribute werden (entsprechend dem Satzaufbau) der Reihe nach aus dem Datensatz gelesen. Achtung: 1 Datensatz besteht immer aus allen Attributen, d.h. EOF wird nur am Beginn des Datensatzes geprüft! */ public function lesen() { // Länge des 1. Datenfeldes $datenfeld = fread($this->datei, self::LAENGENAME); if (feof($this->datei)) { $this->schueler = NULL; $this->eof = TRUE; return; } $anzByte = (int) trim($datenfeld); // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) $name = fread($this->datei, $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $datenfeld = fread($this->datei, self::LAENGENOTENSCHNITT); $notenschnitt = (float) trim($datenfeld); // 3. Datenfeld (Klassenbezeichnung - Zeichenkette mit fixer Länge) $klasse = fread($this->datei, Schueler::LAENGEKLASSE); // Gelesene Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Lesen der Daten aus einer Binärdatei

Datei `DAOlesenBinaerSchueler.class.php`
<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOlesenBinaerSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Die Länge und die Byte-Folge einer Gleitkommazahl mit einfacher Genauigkeit ist maschinenabhängig!! In PHP gibt es derzeit noch kein maschinenunabhängiges Formatzeichen für die 'pack'-/'unpack'-Funktionen. Für MS-Windows-Betriebssysteme gilt: Länge = 4B, Byte-Folge = Little Endian! / const LAENGEFLOAT = 4; // ------------------------------------------------------------------------- // Instanzattribute / Datenobjekt für die zu lesenden Daten / private $schueler; / Verbindungsobjekt zur Datei / private $datei; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler()* { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname) { $this->datei = fopen($dateiname, "rb") or die("<p>Die Datei <b>$dateiname</b> existiert nicht.</p>"); } // ---------- /* Liest den nächsten Schüler-Datensatz aus der Datei - alle Attribute eines Schülerobjekts sind nebeneinander ohne Abstand gespeichert. Die Attribute werden (entsprechend dem Satzaufbau) der Reihe nach aus dem Datensatz gelesen. Achtung: 1 Datensatz besteht immer aus allen Attributen, d.h. EOF wird nur am Beginn des Datensatzes geprüft! / public function lesen()* { // Länge des 1. Datenfeldes $datenfeld = fread($this->datei, 2); if (feof($this->datei)) { $this->schueler = NULL; $this->eof = TRUE; return; } $arr = unpack("nzahl", $datenfeld); // n = 16b = 2B, normale Byte-Folge (Big Endian) $anzByte = $arr["zahl"]; // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) $name = fread($this->datei, $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $datenfeld = fread($this->datei, self::LAENGEFLOAT); $arr = unpack("fzahl", $datenfeld); // f ... maschinenabhängig!! $notenschnitt = $arr["zahl"]; // 3. Datenfeld (Klassenbezeichnung - Zeichenkette mit fixer Länge) $klasse = fread($this->datei, Schueler::LAENGEKLASSE); // Gelesene Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

Datei DAOlesenBinaerSchueler.class.php

<?php require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOlesenBinaerSchueler { // ------------------------------------------------------------------------- // Klassenkonstante /* Die Länge und die Byte-Folge einer Gleitkommazahl mit einfacher Genauigkeit ist maschinenabhängig!! In PHP gibt es derzeit noch kein maschinenunabhängiges Formatzeichen für die 'pack'-/'unpack'-Funktionen. Für MS-Windows-Betriebssysteme gilt: Länge = 4B, Byte-Folge = Little Endian! */ const LAENGEFLOAT = 4; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die zu lesenden Daten */ private $schueler; /* Verbindungsobjekt zur Datei */ private $datei; private $eof = FALSE; // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function getSchueler() { return $this->schueler; } // ---------- public function getEof() { return $this->eof; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function oeffnen($dateiname) { $this->datei = fopen($dateiname, "rb") or die("Die Datei $dateiname existiert nicht."); } // ---------- /* Liest den nächsten Schüler-Datensatz aus der Datei - alle Attribute eines Schülerobjekts sind nebeneinander ohne Abstand gespeichert. Die Attribute werden (entsprechend dem Satzaufbau) der Reihe nach aus dem Datensatz gelesen. Achtung: 1 Datensatz besteht immer aus allen Attributen, d.h. EOF wird nur am Beginn des Datensatzes geprüft! */ public function lesen() { // Länge des 1. Datenfeldes $datenfeld = fread($this->datei, 2); if (feof($this->datei)) { $this->schueler = NULL; $this->eof = TRUE; return; } $arr = unpack("nzahl", $datenfeld); // n = 16b = 2B, normale Byte-Folge (Big Endian) $anzByte = $arr["zahl"]; // 1. Datenfeld (Name - Zeichenkette mit variabler Länge) $name = fread($this->datei, $anzByte); // 2. Datenfeld (Notendurchschnitt - rationale Zahl) $datenfeld = fread($this->datei, self::LAENGEFLOAT); $arr = unpack("fzahl", $datenfeld); // f ... maschinenabhängig!! $notenschnitt = $arr["zahl"]; // 3. Datenfeld (Klassenbezeichnung - Zeichenkette mit fixer Länge) $klasse = fread($this->datei, Schueler::LAENGEKLASSE); // Gelesene Daten sind korrekt - Objekt für Datensatz instanzieren $this->schueler = new Schueler(); $this->schueler->setName($name); $this->schueler->setNotenschnitt($notenschnitt); $this->schueler->setKlasse($klasse); } // ---------- public function schliessen() { fclose($this->datei); } } ?>

14.2.2.4 Klasse `DAOausgebenSchueler` für die Ausgabe von Daten (Standardausgabe)

Die Schnittstelle IAusgabesteuerung enthält die Konstanten 'NEUESEITE' und 'LEERZEILE' - siehe Kap.5.2.3.2.

Datei `DAOausgebenSchueler.class.php`
<?php require_once PFAD . "ooSkripte/daoKlassen/IAusgabesteuerung.interface.php"; require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOausgebenSchueler implements IAusgabesteuerung { // ------------------------------------------------------------------------- // Klassenkonstante const UEBER = "<strong>NAME NOTENDURCHSCHNITT KLASSE</strong><br />"; const F_AB = "%-25s %5.2f %s<br />"; const ZZMAX = 20; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die auszugebenden Daten / private $schueler; / Zeilenzähler / private $zz; // ------------------------------------------------------------------------- // Konstruktor public function __construct()* { $this->zz = self::ZZMAX; } // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler) { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function schreibenZeile() { if ($this->zz >= self::ZZMAX) { printf(self::NEUESEITE); printf(self::UEBER); printf(self::LEERZEILE); $this->zz = 2; } printf(self::F_AB, $this->schueler->getName(), $this->schueler->getNotenschnitt(), $this->schueler->getKlasse()); $this->zz = $this->zz + 1; } } ?>

Datei DAOausgebenSchueler.class.php

<?php require_once PFAD . "ooSkripte/daoKlassen/IAusgabesteuerung.interface.php"; require_once PFAD . "ooSkripte/modelKlassen/Schueler.class.php"; class DAOausgebenSchueler implements IAusgabesteuerung { // ------------------------------------------------------------------------- // Klassenkonstante const UEBER = "NAME NOTENDURCHSCHNITT KLASSE "; const F_AB = "%-25s %5.2f %s "; const ZZMAX = 20; // ------------------------------------------------------------------------- // Instanzattribute /* Datenobjekt für die auszugebenden Daten */ private $schueler; /* Zeilenzähler */ private $zz; // ------------------------------------------------------------------------- // Konstruktor public function __construct() { $this->zz = self::ZZMAX; } // ------------------------------------------------------------------------- // Zugriffsmethoden (Get- und Set-Methoden) public function setSchueler(Schueler $schueler) { $this->schueler = $schueler; } // ------------------------------------------------------------------------- // Sonstige Instanzmethoden public function schreibenZeile() { if ($this->zz >= self::ZZMAX) { printf(self::NEUESEITE); printf(self::UEBER); printf(self::LEERZEILE); $this->zz = 2; } printf(self::F_AB, $this->schueler->getName(), $this->schueler->getNotenschnitt(), $this->schueler->getKlasse()); $this->zz = $this->zz + 1; } } ?>

14.2.3 Anwendungsprogramme

Diese Applikation besteht aus 2 Webseiten:
Die Startseite (Programm pKap14-2-3-1.php ) enthält 2 Formulare - das 1. Formular dient zur Erfassung der Schülerdaten (Name, Notenschnitt und Klasse). Nach jeder Eingabe (d.h. nach jedem Drücken der Submit-Schaltfläche "Senden") wird das Formular wieder angezeigt (mit den Zusatzinformationen über die Anzahl der bisher gespeicherten Datensätze und die letzte Eingabe). Dies geschieht solange, bis der Benutzer im 2. Formular durch Drücken der Submit-Schaltfläche "Ende der Datenerfassung" seine Eingabe beendet.
Die darauf folgende Abschlussseite (Programm pKap14-2-3-2.php ) zeigt den Inhalt der Datei an. Diese Abschlussseite kann auch als eigenständige Applikation durchgeführt werden.

Die nachfolgenden Programme gibt es zweimal - für die Verarbeitung sowohl einer Textdatei als auch einer Binärdatei (unterschiedlich sind nur die DAO-Klassen für Schreiben und Lesen). Gezeigt wird die Anwendung für eine Binärdatei.

14.2.3.1 Daten erfassen und speichern

Datei `pErfassenSchreiben-Binaer.php`
<!doctype html> <!-- Programm "pErfassenSchreiben-Binaer.php" --> <html> <head> <meta charset="iso-8859-1" /> <meta name="author" content="Beringer Alfred" /> <meta name="description" content="Programmieren mit PHP 5" /> <title>Daten erfassen und speichern in einer Datei</title> </head> <body>
<?php const ENDESEITE = "pLesenAusgeben-Binaer.php"; // Pfad zum privaten Projektverzeichnis (siehe Kapitel 16.1.2) require_once "projektpfad.inc.php"; require_once PFAD . "ooSkripte/daoKlassen/DOAerfassenSchueler.class.php"; require_once PFAD . "ooSkripte/daoKlassen/DAOschreibenBinaerSchueler.class.php"; // Der Einfachheit halber wird der Dateiname mit dem Pfad fix vorgegeben $AUSGABEDATEI = PFAD . "Dateien/schuelerBinaer.dat"; $OPEN = "ab"; // ***************************************************************************** $eingabedaten = new DOAerfassenSchueler(); $ausgabedaten = new DAOschreibenBinaerSchueler(); $ausgabedaten->oeffnen($AUSGABEDATEI, $OPEN); if (isset($_POST['fButGesendet'])) { // Eingabedaten aus dem Formular übernehmen (lesen) $eingabe = new stdClass(); $eingabe->name = $_POST['fTxfName']; $eingabe->notenschnitt = $_POST['fTxfNotenschnitt']; $eingabe->klasse = $_POST['fTxfKlasse']; // Eingabedaten aufbereiten und in die Datei schreiben $ok = $eingabedaten->aufbereitenDaten($eingabe); if ($ok) { // Daten übernehmen (d.h. Datenobjekt füllen mit den Eingabedaten): $ausgabedaten->setSchueler($eingabedaten->getSchueler()); $ausgabedaten->schreiben(); // Zähler erhöhen $i = $_POST['fHidZaehler'] + 1; } else { print("<p>Fehler in den Eingabedaten!!!</p>"); // Zähler nicht erhöhen $i = $_POST['fHidZaehler']; } } else { // Zähler initialisieren $i = 0; } /* -------------------------------------------------------------------------- */ ?>
<p> Bitte geben Sie die Daten des Schülers bzw. der Schülerin ein: </p> <form name="formEingabe" action="<?php echo $_SERVER["PHP_SELF"]; ?>" method="post" accept-charset="iso-8859-1"> <table> <tr> <td><b>Name:</b></td> <td><input type="text" name="fTxfName" size="20" /></td> </tr> <tr> <td><b>Notenschnitt:</b></td> <td><input type="text" name="fTxfNotenschnitt" size="4" /></td> </tr> <tr> <td><b>Klasse:</b></td> <td><input type="text" name="fTxfKlasse" size="8" /></td> </tr> </table> <p> <input type="submit" name="fButGesendet" value=" Senden " /> <input type="reset" name="fButReset" value="Zurücksetzen" /> </p> <input type="hidden" name="fHidZaehler" value="<?php echo $i; ?>" /> <input type="hidden" name="fHidDateiname" value="<?php echo $AUSGABEDATEI; ?>" /> </form> <p>
<?php if ($i == 1) { $textbaustein = "Datensatz"; } else if ($i > 1) { $textbaustein = "Datensätze"; } if ($i >= 1) { print("<p>Bisher $i $textbaustein geschrieben.</p> <p>Letzte Eingabe: $eingabe->name $eingabe->notenschnitt $eingabe->klasse </p>"); } ?>
</p> <form name="formEnde" action="<?php echo ENDESEITE; ?>" method="post" accept-charset="iso-8859-1"> <input type="submit" name="fButEnde" value="Ende der Datenerfassung" /> <input type="hidden" name="fHidZaehler" value="<?php echo $i; ?>" /> <input type="hidden" name="fHidDateiname" value="<?php echo $AUSGABEDATEI; ?>" /> </form> <p> </p><hr /><p> </p> <footer> <address id="ende"> Copyright © 2009<br /> Letzte Aktualisierung: 2013-10-30<br /> Beringer Alfred<br /> Wögerer Wolfgang </address> </footer> </body> </html>

14.2.3.2 Daten lesen und ausgeben

Datei `pLesenAusgeben-Binaer.php`
<!doctype html> <!-- Programm "pLesenAusgeben-Binaer.php" --> <html> <head> <meta charset="iso-8859-1" /> <meta name="author" content="Beringer Alfred" /> <meta name="description" content="Programmieren mit PHP 5" /> <title>Daten von einer Datei lesen und ausgeben</title> </head> <body> <pre>
<?php // Pfad zum privaten Projektverzeichnis (siehe Kapitel 16.2) require_once "projektpfad.inc.php"; require_once PFAD . "ooSkripte/daoKlassen/DAOlesenBinaerSchueler.class.php"; require_once PFAD . "ooSkripte/daoKlassen/DAoausgebenSchueler.class.php"; if (isset($_POST['fButEnde'])) { $EINGABEDATEI = $_POST['fHidDateiname']; $i = $_POST['fHidZaehler']; if ($i == 0) { print("<p>Sie haben keine Datensätze eingegeben.</p>"); } else if ($i == 1) { print("<p>Sie haben 1 Datensatz eingegeben.</p>"); } else { print("<p>Sie haben $i Datensätze eingegeben."); } } else { // falls dieses Programm direkt aufgerufen wird $EINGABEDATEI = PFAD . "Dateien/schuelerBinaer.dat"; } // ----------------------------------------------------------------------------- $eingabedaten = new DAOlesenBinaerSchueler(); $ausgabedaten = new DAoausgebenSchueler(); $eingabedaten->oeffnen($EINGABEDATEI); $eingabedaten->lesen(); while (!$eingabedaten->getEof()) { $ausgabedaten->setSchueler($eingabedaten->getSchueler()); $ausgabedaten->schreibenZeile(); $eingabedaten->lesen(); } $eingabedaten->schliessen(); // ----------------------------------------------------------------------------- ?>
</pre> <p> </p><hr /><p> </p> <footer> <address id="ende"> Copyright © 2009<br /> Letzte Aktualisierung: 2013-10-30<br /> Beringer Alfred<br /> Wögerer Wolfgang </address> </footer> </body> </html>

Include-Datei projektpfad.class.php ... siehe Kap.16.1.2.

14.2.4 Allgemeines Klassendiagramm für die DAO-Klassen

Das folgende Klassendiagramm zeigt allgemein die DAO-Klassen (nicht nur spezifisch für PHP). Beispielsweise steht Standardeingabe für die Tatstatur und Standardausgabe für den Bildschirm. Die Klassenattribute der Klasse DAOausgeben (wie z.B. ZZMAX) fehlen, weil diese Klasse ja sehr individuell von den Benutzerwünschen abhängt.

Die Klasse Schueler steht beispielhaft für eine Datenklasse, die Methoden getSchueler und setSchueler stehen beispielhaft für die Methoden getDatenObjekt bzw. setDatenobjekt.

Weiter zu: Kapitel 15.1.1 - SQL-Skript; Kapitel 15.2 - Einführende Beispiele (Datenbanken, prozedural); Kapitel 15.3 - Beispiel mit Datenerfassung (Datenbanken, objektorientiert); Kapitel 16.1.2 - Projektpfad - Include-Datei "projektpfad.inc.php"
Zurück: zum Anfang dieses Kapitels; zu Kapitel 3.2.1.2 - Programm 1 (prozedural); zu Kapitel 3.2.2.2 - Programm 2 (prozedural); zu Kapitel 3.2.3.2 - Programm 3 (prozedural); zu Kapitel 4.2.1.2 - Programm 1 (objektorientiert); zu Kapitel 4.2.2.2 - Programm 2 (objektorientiert); zu Kapitel 4.2.3.2 - Programm 3 (objektorientiert); zu Kapitel 8.7.1 - Demo-Programm (Werte- und Referenztypen); zu Kapitel 9.1.4 - Demo-Programm (Parameterübergabe); zum Inhaltsverzeichnis