Inhalt
A Einführung
B HTML für PHP
C Strukturierte Programmierung mit PHP
D Bearbeitung von Formularen
E Datenbanken mit MySQL
F Programmierung von MySQL–Datenbanken mit PHP
G Text-Dateien
H Arrays
I Mathematische Funktionen
J Zeichenketten-Funktionen
K Neu in PHP 4
L HTML
M Anhang
N Lösungen
Index
Download (ca. 3,4 MB)
<< zurück | Galileo Computing / <openbook> / PHP 4 | vor >>
PHP 4 von Thomas Theis Webserver-Programmierung für Einsteiger
| Kapitel H Arrays
|  | H.1 Eindimensionale numerische Arrays
|  | H.2 Eindimensionale assoziative Arrays
|  | H.3 Eindimensionale Arrays und Datenbanken
|  | H.4 Zweidimensionale Arrays
|  | H.5 Zweidimensionale numerische Arrays
|  | H.6 Zweidimensionale gemischte Arrays
|  | H.7 Zweidimensionale assoziative Arrays, Datenbanken
|  | H.8 Ein Datenbank-Browser
|  | H.9 Alle Funktionen für Arrays
# Kapitel H Arrays In diesem Abschnitt werden numerische und assoziative Arrays zur temporären Speicherung von größeren Datenmengen vorgestellt. Außerdem kommen einige MySQL-Array-Funktionen zum Einsatz. Zur Speicherung einer größeren Menge von zusammengehörigen Daten kann man entweder viele einzelne Variablen, jeweils mit einem eigenen Namen, oder ein einzelnes Array von Variablen mit einem einheitlichen Namen nutzen. Ein Array ist ein Feld von Variablen. Arrays sind dabei zu bevorzugen, da sie eine schnellere und komfortablere Verarbeitung bieten. PHP unterstützt zwei Typen von Arrays: Numerische Arrays
| numerische Arrays: Die einzelnen Variablen in einem numerischen Array werden über eine laufende Nummer innerhalb des Arrays angesprochen.
Assoziative Arrays
| assoziative Arrays: Die einzelnen Variablen in einem assoziativen Array werden über eine eindeutige Bezeichnung innerhalb des Arrays angesprochen.
Arrays können eine oder mehrere Dimensionen haben. Dimensionen
| Ein eindimensionales Array kann man sich als einen mathematischen Vektor oder einfach als eine Art Liste vorstellen. Dies könnte z. B. eine Preisliste oder die Namensliste von Mitgliedern einer Gruppe sein.
| Ein zweidimensionales Array kann man sich als eine mathematische Matrix oder einfach als eine Tabelle vorstellen. Dies könnte z. B. der Inhalt einer Datenbank-Tabelle mit verschiedenen Feldern und Datensätzen sein. Zweidimensionale Arrays gibt es in drei Varianten: rein numerisch, rein assoziativ, gemischt (numerisch / assoziativ).
| In einigen Fällen können auch Arrays mit mehr als zwei Dimensionen zum Einsatz kommen. Allerdings kann man sich solche Arrays mit wachsender Anzahl an Dimensionen immer schwerer vorstellen.
Einer der Vorteile von PHP ist die schnelle Verarbeitung von Arrays. Die Elemente eines Arrays können u. a. ganze Zahlen, Zahlen mit Nachkommastellen oder Zeichenketten sein. ## H.1 Eindimensionale numerische Arrays eindimensional, numerisch Nehmen wir an, es wäre eine Woche lang jeden Tag an einem bestimmten Ort eine Temperatur gemessen worden. Es stehen somit sieben Temperaturwerte zur weiteren Betrachtung und Untersuchung zur Verfügung. Diese Werte werden zunächst in einem numerischen Array gespeichert und ausgegeben: Listing H.1 Datei uh01.php
    <html>
    <body>

    <?php
       $tp = array(17.5, 19.2, 21.8, 21.6, 17.5);
       $tp[5] = 20.2;
       $tp[6] = 16.6;
       for($i=0; $i<=6; $i = $i+1)
       {
          echo "$tp[$i] <p>";
       }
    ?>

    </body>
    </html>
In diesem Programm werden zwei häufig eingesetzte Techniken zur Erzeugung bzw. Vergrößerung von Arrays gezeigt: array
| Mit Hilfe der Funktion array() wird die Variable $tp zu einem Array mit fünf Elementen. Diese Elemente sind automatisch durchnummeriert worden, beginnend bei 0.
| Arrays können auch einfach durch die Zuweisung einzelner Elemente erzeugt oder vergrößert werden. Dies ist hier mit den beiden Zuweisungen $tp[5] = 20.2; und $tp[6] = 16.6; geschehen. Dabei ist die bisherige Nummerierung zu beachten, ansonsten könnten vorhandene Elemente überschrieben werden.
Insgesamt hat das Array nun sieben Elemente und die folgende Struktur:
Name des Elementes | Nummer (=Index) des Elementes | Wert des Elementes
$tp[0] | 0 | 17.5
$tp[1] | 1 | 19.2
$tp[2] | 2 | 21.8
$tp[3] | 3 | 21.6
$tp[4] | 4 | 17.5
$tp[5] | 5 | 20.2
$tp[6] | 6 | 16.6
Index Diese Elemente werden anschließend mit Hilfe einer for-Schleife untereinander ausgegeben. Dabei nimmt die Schleifen-Variable $i nacheinander die verwendeten Index-Werte an (0 bis 6). #### Übung UH02 Es sollen Vorname und Alter von sechs verschiedenen Personen untersucht werden. Diese sechs Angaben sollen in zwei Arrays gespeichert werden. Das erste Array soll die Vornamen enthalten, das zweite Array die zugehörigen Altersangaben. Die Elemente der beiden Arrays sollen paarweise in der folgenden Form auf dem Bildschirm ausgegeben werden (Datei uh02.php):
    Peter, 35 Jahre
    Markus, 42 Jahre
    Jens, 16 Jahre
    ....
### H.1.1 Maximum, Minimum Mit Hilfe des folgenden Programmes wird herausgefunden, welches der höchste Temperaturwert war und an welchem Tag er gemessen wurde. Listing H.2 Datei uh03.php
    <html>
    <body>

    <?php
       $tp = array(17.5,19.2,21.8,21.6,17.5,20.2,16.6);
       $max = $tp[0];
       $posmax = 0;

       for($i=1; $i<=6; $i=$i+1)
       {
          if ($tp[$i] > $max)
          {
             $max = $tp[$i];
             $posmax = $i;
          }
       }

       echo "Das größte Element hat den Wert $max <p>";
       echo "und steht an der Position $posmax";
    ?>

    </body>
    </html>
Maxima, Minima Zunächst wird die Annahme getroffen, dass der erste Wert der größte Wert (Variable $max) ist. Die Position des ersten Elementes wird gespeichert (Variable $posmax). Anschließend werden die restlichen Array-Elemente untersucht. Falls man feststellt, dass eines der Elemente größer ist, so wird dieses Element zum neuen Maximum und dessen Position wird gespeichert. Als Alternative könnten auch die mathematischen Funktionen max() und min() benutzt werden. Diese geben allerdings nur die Maximal- bzw. Minimalwerte aus, nicht die Position dieser Werte innerhalb eines Arrays. Weiteres zu mathematischen Funktionen behandelt ein eigener Abschnitt. #### Übung UH04 Stellen Sie fest, welche die jüngste Person aus dem Array aus der vorherigen Übung ist (Datei uh04.php). Die Ausgabe soll wie folgt aussehen:
    Jens, 16 Jahre, ist der jüngste von allen
### H.1.2 Sortierung Mit Hilfe des folgenden Programmes wird das Array mit den Temperaturwerten einmal aufsteigend und einmal absteigend sortiert und ausgegeben: Listing H.3 Datei uh05.php
    <html>
    <body>

    <?php
       $tp = array(17.5,19.2,21.8,21.6,17.5,20.2,16.6);

       // aufsteigend sortieren
       sort($tp);
       for($i=0; $i<=6; $i=$i+1)
       {
          echo "$tp[$i] / ";
       }
       echo "<p>";

       // absteigend sortieren
       rsort($tp);
       for($i=0; $i<=6; $i=$i+1)
       {
          echo "$tp[$i] / ";
       }
    ?>

    </body>
    </html>
sort, rsort Dabei kommen die beiden Array-Funktionen sort() und rsort() (= reverse sort) zum Einsatz. #### Übung UH06 Geben Sie die Arrays aus der vorherigen Übung wie folgt aus (Datei uh06.php):
| die Vornamen, sortiert von A-Z
| die sortierten Altersangaben, beginnend mit dem höchsten Alter
### H.1.3 Statistische Auswertung Mit Hilfe des nachfolgenden Programmes wird festgestellt, welcher Anteil einer Menge von Temperaturwerten oberhalb einer definierten Grenze liegt. Diese Grenze kann vom Benutzer gewählt werden. Die Werte werden aus einer Textdatei eingelesen (siehe Abschnitt über Bearbeitung von Textdateien), in der sie zeilenweise gespeichert wurden, wie nachfolgend angegeben:
Abbildung H.1 Werte für ein Array in einer Text-Datei
Das Formular für die Eingabe des Grenzwertes hat folgendes Aussehen: Hier der Programmcode: Listing H.4 Datei uh07.htm
    <html>
    <body>
    Bitte geben Sie den Grenzwert ein:
    <form action = "uh07.php" method = "post">
        <input name="gr"> Grenzwert<p>
        <input type="submit">
        <input type="reset">
    </form>
    </body>
    </html>
Abbildung H.2 Eingabe des Grenzwertes
Das Auswertungsprogramm liefert das folgende Ergebnis:
Abbildung H.3 Auswertungsprogramm zur Untersuchung des Arrays
Es folgt der Programmcode: Listing H.5 Datei uh07.php
    <html>
    <body>
    <?php
       $fp = fopen("ug14data.txt","r");
       if ($fp)
       {

          // Alle Werte in einen Array lesen
          $i = 0;
          while (!feof($fp))
          {
             $zeile = fgets($fp, 100);
             $tp[$i] = doubleval($zeile);
             $i = $i + 1;
          }
          fclose($fp);

          // Anzahl feststellen
          $anzahl = sizeof($tp);

          // Werte oberhalb der Grenze zählen
          $c = 0;
          $grenze = doubleval($gr);
          for($i=0; $i < $anzahl; $i=$i+1)
          {
             if ($tp[$i] > $grenze)
                $c = $c + 1;
          }

          // Ausgabe
          if ($anzahl > 0)
          {
             $anteil = $c / $anzahl * 100;
             $ausgabe = number_format($anteil,2);
             echo "$ausgabe Prozent der Werte";
             echo " liegen oberhalb von $gr";
          }
          else
             echo "Die Datei beinhaltete keine Werte";
       }
       else
          echo "Datei wurde nicht gefunden";
    ?>
    </body>
    </html>
doubleval Nach dem erfolgreichen Öffnen der Textdatei uh07data.txt werden die Werte zeilenweise gelesen, mit Hilfe der Funktion doubleval() in Zahlen verwandelt und im Array $tp gespeichert. Der Index des Arrays steht zunächst auf 0, nach dem Lesen jeder Zeile vergrößert er sich um 1. Es kann also das nächste Element des numerischen Arrays eingelesen werden. Der Einsatz der Funktion doubleval() (siehe Abschnitt über Strukturierte Programmierung mit PHP/Umwandlung von Zeichenketten in Zahlen) ist hier notwendig, da die Werte aus der Datei zunächst als Zeichenketten eingelesen werden und daher zunächst in Zahlen mit Nachkommastellen umgewandelt werden müssen.
    $zeile = fgets($fp, 100);
    $tp[$i] = doubleval($zeile);
Dynamische Arrays Falls Sie schon Erfahrungen mit anderen Programmiersprachen haben, wird Ihnen spätestens an dieser Stelle auffallen, dass das Array dynamisch vergrößert wird. Der Entwickler muss keine statische Array-Größe zu Beginn des Programmes festlegen. sizeof Mit Hilfe der Array-Funktion sizeof() kann nach dem vollständigen Einlesen die Größe des Arrays, also die Anzahl der darin enthaltenen Elemente festgestellt werden.
    $anzahl = sizeof($tp);
Der vom Benutzer eingegebene Grenzwert steht im Programm in der Variablen $gr zur Verfügung. Auch diese Zeichenkette wird in eine Zahl mit Nachkommastellen (Variable $grenze) umgewandelt.
    $grenze = doubleval($gr);
Innerhalb einer for-Schleife über alle Elemente des Arrays wird der Zähler (Variable $c) erhöht, falls ein Element gefunden wurde, dass oberhalb der eingegebenen Grenze liegt.
    if ($tp[$i] > $grenze) $c = $c + 1;
number_format Der prozentuale Anteil dieser Werte an der Gesamtzahl der Elemente wird berechnet (Variable $anteil). Diese Variable wird mittels der mathematischen Funktion number_format() in eine Zeichenkette (Variable $ausgabe) umgewandelt, die die Zahl beinhaltet, begrenzt auf zwei Stellen nach dem Komma. Weitere Informationen zu den mathematischen Funktionen finden sich in einem eigenen Abschnitt.
    $ausgabe = number_format($anteil,2);
#### Übung UH08 In einer Textdatei (uh08data.txt) sind Namen und Altersangaben aller Mitarbeiter einer Firma gespeichert. In der ersten Zeile steht der Name des ersten Mitarbeiters, in der zweiten Zeile das Alter des ersten Mitarbeiters, in der dritten Zeile der Name des zweiten Mitarbeiters usw. Schreiben Sie ein Programm (Datei ug15.php), mit dessen Hilfe Informationen über die Altersstruktur ermittelt werden. Es soll der prozentuale Anteil der Mitarbeiter ausgegeben werden, die jünger als 25 Jahre sind. Außerdem soll der prozentuale Anteil der Mitarbeiter ausgegeben werden, die älter als 50 Jahre sind. ## H.2 Eindimensionale assoziative Arrays eindimensional, assoziativ Die Temperaturwerte aus dem vorherigen Abschnitt sollen nun in ein assoziatives Array angeordnet werden. Die Elemente eines solchen Arrays werden nicht über eine laufende Nummer, sondern über eine Schlüssel-Bezeichnung (Key) identifiziert. Dadurch wird es möglich, die Array-Elemente eindeutigen Begriffen zuzuordnen und die Suche nach bestimmten Array-Elementen zu vereinfachen. Zunächst sollen die Werte wiederum gespeichert und ausgegeben werden: Listing H.6 Datei uh09.php
    <html>
    <body>

    <?php
       $tp = array("Montag"=>17.5, "Dienstag"=>19.2,
                   "Mittwoch"=>21.8);
       $tp["Donnerstag"] = 21.6;
       $tp["Freitag"] = 17.5;
       $tp["Samstag"] = 20.2;
       $tp["Sonntag"] = 16.6;

       // Das erste Element
       list($name,$wert) = each($tp);
       echo "$name, $wert <p>";
       reset($tp);

       // Alle Elemente aus dem Array
       while(list($name,$wert) = each($tp))
       {
          echo "$name, $wert <p>";
       }
    ?>
    </body>
    </html>
Die Verwendung von assoziativen Arrays erscheint zunächst etwas unübersichtlicher. Nachdem man sich aber mit der Vorgehensweise vertraut gemacht hat, können sie je nach Problemstellung einige Vorteile mit sich bringen. Auch hier werden gleich zwei Techniken zur Erzeugung eines Arrays gezeigt: Key, Value, =>
| Mit Hilfe der Funktion array() wird die Variable $tp zu einem Array mit drei Elementen. Diese Elemente haben eindeutige Schlüsselbezeichnungen (Keys) und zugehörige Werte (Values). Diese Paare werden einander mit dem Operator => zugeordnet.
| Arrays können auch einfach durch die Zuweisung einzelner Elemente erzeugt oder vergrößert werden. Dies ist hier mit den Zuweisungen in der Form $tp["Samstag"] = 20.2; usw. geschehen. Dabei sind die bisher verwendeten Keys zu beachten, ansonsten könnten vorhandene Elemente überschrieben werden.
Insgesamt hat das Array nun sieben Elemente und die folgende Struktur:
Name des Elementes | Schlüssel-Bezeichnung (Key) des Elementes | Wert (Value) des Elementes
$tp["Montag"] | Montag | 17.5
$tp["Dienstag"] | Dienstag | 19.2
$tp["Mittwoch"] | Mittwoch | 21.8
$tp["Donnerstag"] | Donnerstag | 21.6
$tp["Freitag"] | Freitag | 17.5
$tp["Samstag"] | Samstag | 20.2
$tp["Sonntag"] | Sonntag | 16.6
Array-Zeiger Beim Bearbeiten eines assoziativen Arrays kommt ein sogenannter »Array-Zeiger« zum Einsatz. Dieser Zeiger zeigt immer auf ein bestimmtes Element des Arrays, welches dann bearbeitet werden kann. Zunächst zeigt dieser Array-Zeiger auf das erste Element. each Die Funktion each() ermittelt an der aktuellen Position des Array-Zeigers zwei Informationen: den Key und den Value des Elementes. Diese beiden Informationen werden zusammengehörig als Array geliefert. Rückgabewert der Funktion ist also ein Array, eine Konstruktion, die beim ersten Mal etwas ungewöhnlich erscheinen mag, aber Vorteile bei der Bearbeitung bietet. list Mit Hilfe der Funktion list() können diese beiden Informationen zwei Variablen zugeordnet werden (hier sind dies $name und $wert):
    list($name,$wert) = each($tp);
Diese beiden Variablen werden anschließend ausgegeben:
    echo "$name, $wert";
Der Array-Zeiger zeigt anschließend auf das nächste Element. Da aber in dem vorliegenden Programm nun alle Elemente auf einmal ausgegeben werden sollen, wird der Array-Zeiger mit Hilfe der Funktion reset() auf das erste Element zurückgesetzt: reset
    reset($tp);
Solange die Funktion each() Informations-Paare liefert, werden diese den beiden Variablen $name und $wert zugeordnet und ausgegeben. Nach dem letzten Element gibt die Funktion each() den Wert false zurück und die while-Schleife wird beendet. Anders ausgedrückt: Der Array-Zeiger zeigt auf kein Element mehr.
    while(list($name,$wert) = each($tp))
       echo "$name, $wert <p>";
Anmerkung: Falls man einem bestimmten Key bei der Erzeugung des Arrays oder später einen neuen Wert zuordnet, so wird nicht etwa ein neues Element hinzugefügt, sondern der erste Wert wird überschrieben. Überschreiben Die folgende Anweisung erzeugt also nur die beiden Array-Elemente mit den Keys "Montag" und "Dienstag" und den Values 19.2 und 21.8:
    $tp = array("Montag"=>17.5, "Dienstag"=>19.2, "Montag"=>21.8);
#### Übung UH10 Es sollen Vorname und Alter von sechs verschiedenen Personen untersucht werden. Diese sechs Angaben werden in einem assoziativen Array gespeichert. Die Vornamen sollen die Keys, die Altersangaben die Values darstellen. Die Elemente der beiden Arrays sollen paarweise in der folgenden Form auf dem Bildschirm ausgegeben werden (Datei uh10.php):
    Peter, 35 Jahre
    Markus, 42 Jahre
    Jens, 16 Jahre
    ....
### H.2.1 Sortierung Im folgenden Programm werden verschiedene Sortier-Funktionen, die sich besonders für assoziative Arrays eignen, dargestellt. Listing H.7 Datei uh11.php
    <html>
    <body>
    <?php
       $tp["Montag"] = 17.5;
       $tp["Dienstag"] = 19.2;
       $tp["Mittwoch"] = 21.8;
       $tp["Donnerstag"] = 21.6;
       $tp["Freitag"] = 17.5;
       $tp["Samstag"] = 20.2;
       $tp["Sonntag"] = 16.6;

       // Ausgabe unsortiert
       while(list($name,$wert) = each($tp))
          echo "$name, $wert ";

       // sortiert nach Werten, aufsteigend
       // also Maximum zuerst
       echo "<p>";
       asort($tp);
       while(list($name,$wert) = each($tp))
          echo "$name, $wert ";

       // sortiert nach Werten, absteigend
       // also Minimum zuerst
       echo "<p>";
       arsort($tp);
       while(list($name,$wert) = each($tp))
          echo "$name, $wert ";

       // sortiert nach Keys, aufsteigend
       echo "<p>";
       ksort($tp);
       while(list($name,$wert) = each($tp))
          echo "$name, $wert ";

    ?>

    </body>
    </html>
asort, arsort, ksort Es wird ein assoziatives Array mit sieben Werten erzeugt. Es wird zunächst unsortiert ausgegeben.
| Mit Hilfe der Funktion asort() wird das Array nach Werten aufsteigend sortiert.
| Mit Hilfe der Funktion arsort() wird das Array nach Werten absteigend sortiert.
| Mit Hilfe der Funktion ksort() wird das Array nach Keys aufsteigend sortiert.
Zur Kontrolle wird das Array nach der jeweiligen Sortierung ausgegeben. In allen drei Fällen bleibt die Zuordnung Key zu Value erhalten. Die Ergebnisse der Sortierung sehen aus wie folgt:
Abbildung H.4 Sortier-Ergebnisse
## H.3 Eindimensionale Arrays und Datenbanken Häufig werden Arrays auch im Zusammenhang mit Datenbanken verwendet. Im nachfolgenden Programm wird eine Abfrage an eine Datenbank gesendet. Das Ergebnis der Abfrage wird datensatzweise mit Hilfe eines assoziativen Arrays dargestellt. Listing H.8 Datei uh12.php
    <html>
    <body>
    <?php
       // Die Informationen werden aus der Datenbank geholt
       $db = mysql_connect();
       $res = mysql_db_query("firma",
              "select * from personen");
       mysql_close($db);

       // Die Datensätze werden einzeln gelesen
       while($zeile = mysql_fetch_array($res))
       {
          echo $zeile["vorname"] . " ";
          echo $zeile["name"] . "<p>";
       }

    ?>
    </body>
    </html>
mysql_db_query Mit Hilfe der Funktion mysql_db_query() werden alle Datensätze der Tabelle personen aus der Datenbank firma ausgewählt. Über die Ergebnis-Kennung (Variable $res) kann auf alle Informationen des Ergebnisses zurückgegriffen werden. Die Datenbank-Verbindung kann bereits jetzt beendet werden. mysql_fetch_array Die MySQL-Funktion mysql_fetch_array() holt aus dem Ergebnis einen Datensatz und legt ihn als assoziativen Array mit dem Namen $zeile ab. Die Keys des assoziativen Arrays sind die Namen der Datenbank-Felder, die Values des assoziativen Arrays sind die Werte aus den Datenbank-Feldern. Somit können die gewünschten Inhalte aus dem Datensatz leicht dargestellt werden. Außerdem arbeitet die Funktion mysql_fetch_array() sehr schnell, was gerade bei größeren Datenmengen vorteilhaft ist. Nach dem Aufruf der Funktion mysql_fetch_array() wird ein interner Zeiger auf den nächsten Datensatz gestellt. Folglich wird beim nächsten Aufruf der nächste Datensatz gelesen. Nach dem letzten Datensatz gibt die Funktion mysql_fetch_array() den Wert false zurück. Dadurch wird die while-Schleife beendet. Doppelte Hochkommata Anmerkung: Der Wert eines Elementes aus einem assoziativen Array wird ermittelt über die Angaben: [Name des Datenbank-Feldes] und [Name des Keys] (in Hochkommata eingeschlossen). Dies müssen doppelte Hochkommata sein! Eine der folgenden Anweisungen hätte also nicht zum Erfolg geführt: echo "$zeile['vorname'] $zeile['name'] <p>"; Es wurden statt doppelter Hochkommata bei den Keys einfache Hochkommata gesetzt, dies ist ein Fehler bei der Benutzung des assoziativen Arrays. echo "$zeile["vorname"] $zeile["name"] <p>"; Es wurden überall doppelte Hochkommata gesetzt, dies ist ein Fehler bei der Benutzung der echo-Anweisung. echo '$zeile["vorname"] $zeile["name"] <p>'; Es wurden bei der echo-Anweisung einfache Hochkommata gesetzt, dies ist erlaubt, liefert aber nur den Namen der Variablen, nicht jedoch ihren Wert. #### Übung UH13 Aus der Tabelle fp der Datenbank hardware sollen alle Datensätze gelesen und mit Hilfe der Funktion mysql_fetch_array() jeweils in ein assoziatives Array gespeichert werden (Datei uh13.php). Anschließend soll eine HTML-Tabelle mit folgenden Spalten ausgegeben werden: Artikelnummer, Kapazität in MByte, Preis und Preis/Leistungsverhältnis. Dieses Verhältnis (PLV) wird wie folgt berechnet:
    PLV = MByte / Preis
Es wird aus den Werten des aktuellen Datensatzes berechnet und unmittelbar ausgegeben. Die Antwort könnte wie folgt aussehen:
Abbildung H.5 Ausgabe des Arrays
## H.4 Zweidimensionale Arrays Betrachten wir einmal die folgende Tabelle. Sie wird Ihnen bereits aus dem Abschnitt über Datenbanken bekannt sein und soll uns hier zur Einführung von zweidimensionalen Arrays dienen. Es wurde nur das Feld Geburtstag weggelassen, um das Programm nicht zu aufwendig werden zu lassen.
Name | Vorname | Personalnummer | Gehalt
Maier | Hans | 6714 | 3500,00
Schmitz | Peter | 81343 | 3750,00
Mertens | Julia | 2297 | 3621,50
Gemischte Arrays Bei mehrdimensionalen Arrays kann man sowohl numerische Arrays und assoziative Arrays als auch gemischte Arrays anwenden. Ein gemischtes Array beinhaltet sowohl numerische als auch assoziative Komponenten. Die Daten sollen in einem zweidimensionalen Array abgelegt werden, um sie innerhalb eines Programmes bearbeiten zu können. Im ersten Beispiel ist dies ein rein numerisches Array, im zweiten Beispiel ein gemischtes Array. Später wird erläutert, wie die Daten aus einer Datenbank in ein zweidimensionales assoziatives Array gelesen werden können. Dadurch ergibt sich innerhalb des Programmes eine komfortable Zugriffsmöglichkeit auf die einzelnen Daten. ## H.5 Zweidimensionale numerische Arrays zweidimensional, numerisch Ein zweidimensionales numerisches Array hat zwei Indizes statt eines Indexes. Der erste Index stellt die Nummer der Zeile dar, der zweite Index die Nummer der Spalten. Dies ist nur ein mögliches Vorstellungsmodell, genausogut könnte es umgekehrt sein. Man sollte allerdings bei einem einmal gewählten Modell bleiben, dies erleichtert die Bearbeitung zweidimensionaler Probleme (und später auch die höherdimensionaler Probleme). Listing H.9 Datei uh14.php
    <html>
    <body>
    <?php
       // 1. Zeile und 2. Zeile
       $pers = array(array("Maier", "Hans", 6714, 3500),
                array("Schmitz", "Peter", 81343, 3750));

       // 3. Zeile
       $pers[2][0] = "Mertens";
       $pers[2][1] = "Julia";
       $pers[2][2] = 2297;
       $pers[2][3] = 3621.50;

       for($i=0; $i<3; $i=$i+1)
       {
          for($k=0; $k<4; $k=$k+1)
          {
             echo $pers[$i][$k] . " ";
          }
          echo "<p>";
       }
    ?>
    </body>
    </html>
In dem Array $pers sind nur die reinen Daten aus der Tabelle abgelegt, nicht jedoch die Spalten-Überschriften. Auch hier werden gleich zwei Techniken zur Erzeugung eines Arrays gezeigt: Arrays, Teil-Arrays
| Mit Hilfe der Funktion array() wird die Variable $pers zu einem Array mit zwei Elementen. Diese Elemente sind wiederum Teil-Arrays, haben die Namen $pers[0] und $pers[1] und bestehen jeweils aus vier Elementen, die unterschiedliche Datentypen haben können. Die Nummerierung der Elemente beginnt auf der Ebene der Arrays und auf der Ebene der Teil-Arrays jeweils bei 0. Jedes Teil-Array wurde ebenfalls mit Hilfe der Funktion array() erzeugt.
| Mehrdimensionale Arrays können ebenfalls einfach durch die Zuweisung einzelner Elemente erzeugt oder vergrößert werden. Dies ist hier mit den Zuweisungen in der Form $pers[2][0] = "Mertens"; usw. geschehen. Dabei ist die bisherige Nummerierung zu beachten, ansonsten könnten auch hier vorhandene Elemente überschrieben werden.
Insgesamt hat das Array nun 12 Elemente (drei Teil-Arrays mit je vier Elementen) und ist von folgender Struktur:
Name des Elementes | Zeilen-Index des Elementes | Spalten-Index des Elementes | Wert des Elementes
$pers[0][0] | 0 | 0 | “Maier”
$pers[0][1] | 0 | 1 | “Hans”
$pers[0][2] | 0 | 2 | 6714
$pers[0][3] | 0 | 3 | 3500
$pers[1][0] | 1 | 0 | “Schmitz”
$pers[1][1] | 1 | 1 | “Peter”
$pers[1][2] | 1 | 2 | 81343
$pers[1][3] | 1 | 3 | 3750
$pers[2][0] | 2 | 0 | “Mertens”
$pers[2][1] | 2 | 1 | “Julia”
$pers[2][2] | 2 | 2 | 2297
$pers[2][3] | 2 | 3 | 3621,50
Geschachtelte Schleife Diese Elemente werden anschließend mit Hilfe einer geschachtelten for-Schleife (siehe Strukturierte Programmierung mit PHP) ausgegeben. Eine Zeile der Tabelle wird als eine Zeile auf dem Bildschirm dargestellt. Zeilen-Index, Spalten-Index Dabei nimmt die Schleifen-Variable $i nacheinander die verwendeten Werte für den Zeilen-Index an (0 bis 2). Die Schleifen-Variable $k nimmt nacheinander die verwendeten Werte für den Spalten-Index an (0 bis 3). #### Übung UH15 Speichern Sie die Daten aus der folgenden Tabelle (ohne die Spalten-Überschriften) in einem zweidimensionalen Array ab. Geben Sie anschließend die Daten dieses Arrays auf dem Bildschirm aus (Datei uh15.php).
Hersteller | Typ | MB | Preis | Artikelnummer
Quantum | Fireball CX | 6400 | 215,00 | HDA-208
Quantum | Fireball Plus | 9100 | 269,00 | HDA-163
Fujitsu | MPE 3136 | 13600 | 275,00 | HDA-171
Seagate | 310232A | 10200 | 245,00 | HDA-144
## H.6 Zweidimensionale gemischte Arrays zweidimensional, gemischt Ein zweidimensionales gemischtes Array hat ebenfalls zwei Indizes. Der erste Index stellt die Nummer der Zeile dar, der zweite Index die Bezeichnung der Spalten. Dies ist ebenfalls nur ein mögliches Vorstellungsmodell. Listing H.10 Datei uh15.php
    <html>
    <body>
    <?php
       // 1. Zeile und 2. Zeile
       $pers = array(array("Name"=>"Maier",
                           "Vorname"=>"Hans",
                           "Personalnummer"=>6714,
                           "Gehalt"=>3500),
                     array("Name"=>"Schmitz",
                           "Vorname"=>"Peter",
                           "Personalnummer"=>81343,
                           "Gehalt"=>3750));

       // 3. Zeile
       $pers[2]["Name"] = "Mertens";
       $pers[2]["Vorname"] = "Julia";
       $pers[2]["Personalnummer"] = 2297;
       $pers[2]["Gehalt"] = 3621.50;

       // Ausgabe
       for($i=0; $i<3; $i = $i+1)
       {
          // Teil-Arrays
          while(list($name,$wert) = each($pers[$i]))
          {
             echo "$wert ";
          }
          echo "<p>";
       }
    ?>
    </body>
    </html>
In dem Array $pers sind nur die Daten aus der Tabelle und die Spalten-Überschriften (als Keys) abgelegt. Auch hier werden gleich zwei Techniken zur Erzeugung eines Arrays gezeigt:
| Mit Hilfe der Funktion array() wird die Variable $pers zu einem numerischen Array mit zwei Elementen. Die Nummerierung des numerischen Arrays beginnt bei 0.
Assoziative Teil-Arrays
| Die beiden Elemente des Arrays sind assoziative Teil-Arrays, haben die Namen $pers[0] und $pers[1] und bestehen jeweils aus vier Elementen. Die einzelnen assoziativen Teil-Arrays werden genau so wie eindimensionale assoziative Arrays (mit Key und Value) erzeugt.
| Gemischte Arrays können auch einfach durch die Zuweisung einzelner Elemente erzeugt oder vergrößert werden. Dies ist hier mit den Zuweisungen in der Form $pers[2]["Name"] = "Mertens"; usw. geschehen.
Insgesamt hat das Array nun 12 Elemente (drei Teil-Arrays mit je vier Elementen) und die folgende Struktur:
Name des Elementes | Index des Teil-Arrays | Key des Elementes innerhalb des Teil-Arrays | Wert des Elementes
$pers[0]["Name"] | 0 | “Name” | “Maier”
$pers[0]["Vorname"] | 0 | “Vorname” | “Hans”
$pers[0] ["Personalnummer"] | 0 | “Personalnummer” | 6714
$pers[0]["Gehalt"] | 0 | “Gehalt” | 3500
$pers[1]["Name"] | 1 | “Name” | “Schmitz”
$pers[1]["Vorname"] | 1 | “Vorname” | “Peter”
$pers[1] ["Personalnummer"] | 1 | “Personalnummer” | 81343
$pers[1]["Gehalt"] | 1 | “Gehalt” | 3750
$pers[2]["Name"] | 2 | “Name” | “Mertens”
$pers[2]["Vorname"] | 2 | “Vorname” | “Julia”
$pers[2] ["Personalnummer"] | 2 | “Personalnummer” | 2297
$pers[2]["Gehalt"] | 2 | “Gehalt” | 3621,50
Diese Elemente werden anschließend mit Hilfe einer geschachtelten Schleife ausgegeben. Eine Zeile der Tabelle wird als eine Zeile auf dem Bildschirm dargestellt. Dabei nimmt die Schleifen-Variable $i nacheinander die verwendeten Werte für die Nummer des Teil-Arrays an (0 bis 2). Innerhalb der for-Schleife werden, jeweils mit Hilfe einer while-Schleife, die Elemente der Teil-Arrays ausgegeben. Jedes Teil-Array entspricht einem eindimensionalen assoziativen Array. Der Ablauf ist daher sehr ähnlich, die Funktion each() wird jedoch mit dem Namen des Teil-Arrays aufgerufen, nämlich each($pers[$i]). #### Übung UH17 Speichern Sie die Daten der Hardware-Tabelle (mit den Spalten-Überschriften) aus der vorherigen Übung in einem gemischten Array ab. Geben Sie anschließend die Daten dieses Arrays auf dem Bildschirm aus (Datei uh17.php). ## H.7 Zweidimensionale assoziative Arrays, Datenbanken zweidimensional, assoziativ Im nachfolgenden Programm wird eine Abfrage an eine Datenbank gesendet. Das Ergebnis der Abfrage wird vollständig in einem zweidimensionalen assoziativen Array gespeichert. Auf alle Elemente des Arrays kann zu einem späteren Zeitpunkt des Programmes zugegriffen werden. Als Key der ersten Dimension des Arrays wird eine eindeutige Bezeichnung benötigt. Dazu bietet sich das eindeutige Feld der Tabelle an. Im vorliegenden Fall ist dies das Feld Personalnummer aus der Tabelle personen. Jeder beliebige Feldinhalt aus jedem Datensatz steht dann über die Personalnummer auf komfortable Weise zur Verfügung. Listing H.11 Datei uh18.php
    <html>
    <body>
    <?php
       // Die Informationen werden aus der Datenbank geholt
       $db = mysql_connect();
       $res = mysql_db_query("firma",
              "select * from personen");
       mysql_close($db);

       // Die Datensätze werden einzeln gelesen
       while($temp = mysql_fetch_array($res))
       {
          // Key für den zweidim. Array ermitteln
          $ax = $temp["personalnummer"];

          // Die Informationen aus dem Datensatz werden
          // über den Key im zweidim. Array gespeichert
          $tab[$ax]["name"] = $temp["name"];
          $tab[$ax]["vorname"] = $temp["vorname"];
          $tab[$ax]["gehalt"] = $temp["gehalt"];
       }

       // Alle Datensätze mit allen Inhalten anzeigen
       while(list($dsname,$dswert) = each($tab))
       {
          // Der Key wird ausgegeben
          echo "$dsname : ";

          // Informationen aus dem Datensatz ausgeben
          while(list($name,$wert) = each($dswert))
          {
             echo "$wert ";
          }
          echo "<p>";
       }

       // Einzelne Beispiel-Informationen werden angezeigt
       echo $tab["2297"]["name"] . "<p>";
       echo $tab["6715"]["vorname"] . "<p>";
       echo $tab["6714"]["gehalt"] . "<p>";
    ?>
    </body>
    </html>
#### Übung UH19 Aus der Tabelle fp der Datenbank hardware sollen alle Datensätze gelesen und mit Hilfe der Funktion mysql_fetch_array() in einem zweidimensionalen assoziativen Array gespeichert werden (Datei uh19.php). Anschließend soll eine HTML-Tabelle mit folgenden Spalten ausgegeben werden: Artikelnummer, Kapazität in MByte, Preis und Preis/Leistungsverhältnis. Dieses Verhältnis (PLV) wird wie folgt berechnet:
    PLV = MByte / Preis
Im Unterschied zur Aufgabe UH13 soll das Ergebnis für PLV nicht nur temporär berechnet und unmittelbar ausgegeben werden. Statt dessen soll für die zweite Dimension des assoziativen Arrays eine weitere Spalte mit dem Key "plv" angelegt werden. Der Wert steht somit für die gesamte Dauer des Programmes innerhalb des assoziativen Arrays zur Verfügung. ## H.8 Ein Datenbank-Browser Alle Datenbanken In diesem Abschnitt wird ein Projekt, das aus zwei Programmen besteht, vorgestellt und beschrieben, mit dessen Hilfe die Strukturen und Inhalte aller aktuell vorhandenen Datenbanken unter MySQL übersichtlich dargestellt werden können.
| Zum einen kann man dieses Programm von der CD kopieren (Dateien uh20.php und uh21.php) und als Übersichts-Tool während der Bearbeitung und Programmierung der eigenen Datenbanken nutzen.
| Zum anderen werden viele MySQL-Funktionen, und zwar sowohl bekannte als auch bisher unbekannte, hier nicht nur an einem kleinen Beispiel gezeigt, sondern im Zusammenspiel innerhalb eines größeren Projektes.
Struktur, Inhalt Innerhalb des ersten Programmes werden die Strukturen der Datenbanken ermittelt und ausgegeben. Im zweiten Programm werden bei Bedarf die Inhalte der ausgewählten Tabelle dargestellt. ### H.8.1 Struktur aller Datenbanken Die Ausgabe der Struktur aller Datenbanken ist natürlich umfangreich (siehe Scroll-Balken), deshalb wird hier beispielhaft nur der Anfang gezeigt, nämlich die Struktur der Datenbank firma:
Abbildung H.6 Datenbank-Browser, Struktur aller Datenbanken
Die einzelnen Teile des ersten Programmes sind zur besseren Übersicht nummeriert und werden anschließend erläutert: Listing H.12 Datei uh20.php
    <html>
    <body>
    <?php
       /* 1: Verbindung aufnehmen */
       $con = mysql_connect();

       /* 2: Liste der Datenbanken */
       $dbresult = mysql_list_dbs($con);

       /* 3: Anzahl der Datenbanken, Überschrift */
       $numdbs = mysql_num_rows($dbresult);
       echo "<h3 align='center'>MySQL, Informationen über ";
       echo "Struktur und Inhalt aller $numdbs vorhandenen ";
       echo "Datenbanken</h3>";

       /* 4: Schleife über alle Datenbanken */
       for ($d=0; $d<$numdbs; $d++)
       {
          /* 5: Nummer und Name der Datenbank */
          $dp = $d+1;
          $dbname = mysql_result($dbresult, $d);

          /* 6: Liste der Tabellen der akt. Datenbank */
          $tabresult = mysql_list_tables($dbname);

          /* 7: Anzahl der Tabellen */
          $numtabs = mysql_num_rows($tabresult);
          if ($numtabs==1) $tabtext = "Tabelle";
          else $tabtext = "Tabellen";

          /* 8: Tabelle beginnen, Überschrift */
          echo "<table border width='100%'>";
          echo "<tr><td colspan='6' bgcolor='#c3c3c3'>";
          echo "<b>Datenbank $dp: $dbname</b><br>";
          echo "$numtabs $tabtext</td></tr>";

          /* 9: Schleife über alle Tabellen */
          for ($t=0; $t<$numtabs; $t=$t+1)
          {
             /* 10: Nummer und Name der Tabelle */
             $tp = $t+1;
             $tabname = mysql_result($tabresult, $t);

             /* 11: Liste der Felder der akt. Tabelle */
             $fdresult = mysql_list_fields($dbname, $tabname);

             /* 12: Anzahl der Felder */
             $numfds = mysql_num_fields($fdresult);
             if ($numfds==1) $fdtext = "Feld";
             else $fdtext = "Felder";

             /* 13: Anzahl der Datensätze */
             $dataresult = mysql_db_query($dbname,
                "select * from " . $tabname);
             $numdata = mysql_num_rows($dataresult);
             if ($numdata==1) $datatext = "Datensatz";
             else $datatext = "Datensätze";

             /* 14: Anzeigebutton */
             if ($numdata==0) $ft = "&nbsp;";
             else
             {
                $ft = "<form action='uh21.php' method='post'>";
                $ft .= "<input type='hidden' name='dbname' ";
                $ft .= "value=$dbname><input type='hidden' ";
                $ft .= "name='tabname' value=$tabname>";
                $ft .= "<input type='submit' value='ansehen'>";
                $ft .= "</form>";
             }

             /* 15: Tabelle der Felder, Überschrift */
             echo "<tr><td width='25%' bgcolor='#c3c3c3'>";
             echo "Tabelle $dp / $tp : $tabname<br>$numfds ";
             echo "$fdtext, $numdata $datatext</td>";
             echo "<td width='15%' align='center' ";
             echo "bgcolor='#c3c3c3'>$ft</td>";
             echo "<td width='12%' bgcolor='#c3c3c3'>";
             echo "Feldname:</td><td width='12%' ";
             echo "bgcolor='#c3c3c3'>Feldtyp:</td>";
             echo "<td width='12%' bgcolor='#c3c3c3'>";
             echo "Feldlänge:</td><td width='24%' ";
             echo "bgcolor='#c3c3c3'>Feldflags:</td></tr>";

             /* 16: Schleife über alle Felder */
             for ($f=0; $f<$numfds; $f=$f+1)
             {
                /* 17: Feldname, -typ, – länge und -flags */
                $fp = $f+1;
                $fdname  = mysql_field_name ($fdresult, $f);
                $fdtype  = mysql_field_type ($fdresult, $f);
                $fdlen   = mysql_field_len  ($fdresult, $f);
                $fdflags = mysql_field_flags($fdresult, $f);

                if (!$fdflags) $fdflags = "&nbsp;";

                /* 18: Ausgabe der Feldinformationen */
                echo "<td colspan='2'>Feld $dp / $tp / $fp :";
                echo "</td><td>$fdname</td><td>$fdtype</td>";
                echo "<td>$fdlen</td><td>$fdflags</td></tr>";
             }
          }

          /* 19: Tabelle beenden */
          echo "</table><p>";
       }

       /* 20: Verbindung beenden */
       mysql_close($con);
    ?>
    </body>
    </html>
1. Die Verbindung zur Datenbank wird aufgenommen, Ergebnis ist eine Verbindungskennung. mysql_list_dbs 2. Mit Hilfe der Funktion mysql_list_dbs() wird eine Liste der verfügbaren Datenbanken auf dem Server in $dbresult gespeichert. 3. Mit Hilfe der Funktion mysql_num_rows() wird die Anzahl der verfügbaren Datenbanken auf dem Server in $numdbs gespeichert. Es wird eine Überschrift mit dieser Anzahl ausgegeben. 4. Innerhalb einer for-Schleife wird jede einzelne Datenbank bearbeitet. 5. Eine laufende Nummer für die Datenbank wird ermittelt. Mit Hilfe der Funktion mysql_result() wird bei jedem Schleifen-Durchlauf der Name der aktuellen Datenbank in $dbname gespeichert. 6. mysql_list_tables 7. Mit Hilfe der Funktion mysql_list_tables() wird eine Liste der Tabellen, die sich innerhalb der aktuellen Datenbank befinden, in $tabresult gespeichert. 8. Mit Hilfe der Funktion mysql_num_rows() wird die Anzahl der Tabellen, die sich innerhalb der aktuellen Datenbank befinden, in $numtabs gespeichert. 9. Die Ausgabe der Struktur der aktuellen Datenbank in Form einer HTML-Tabelle wird begonnen. Es wird der Name der Datenbank und die Anzahl der Tabellen ausgegeben. 10. Innerhalb einer for-Schleife wird jede einzelne Tabelle der aktuellen Datenbank bearbeitet. 11. Eine laufende Nummer für die Tabelle wird ermittelt. Mit Hilfe der Funktion mysql_result() wird bei jedem Schleifen-Durchlauf der Name der aktuellen Tabelle in $tabname gespeichert. mysql_list_fields 12. Mit Hilfe der Funktion mysql_list_fields() wird eine Liste der Felder, die sich innerhalb der aktuellen Tabelle befinden, in $fdresult gespeichert. mysql_num_fields 13. Mit Hilfe der Funktion mysql_num_fields() wird die Anzahl der Felder, die sich innerhalb der aktuellen Tabelle befinden, in $numfds gespeichert. 14. Mit Hilfe der Funktionen mysql_db_query() und mysql_num_rows() wird die Anzahl der Datensätze, die sich innerhalb der aktuellen Tabelle befinden, in $numdata gespeichert. 15. Falls es Datensätze innerhalb der Tabelle gibt, soll ein Button dargestellt werden. Zur Anzeige aller Datensätze kann dieser Button betätigt werden, es wird dann das zweite Programm des Projektes aufgerufen. Beim Aufruf werden der Name der Datenbank und der Name der Tabelle als versteckte Formular-Elemente an das ausführende Programm übermittelt. 16. Die Ausgabe der Struktur der aktuellen Tabelle wird begonnen. In einer Kopfzeile werden ausgegeben: Nummer und Name der Tabelle, Anzahl der Felder, Anzahl der Datensätze, evtl. der Anzeigebutton für die Datensätze und die vier Feld-Eigenschaften. 17. Innerhalb einer for-Schleife wird jedes einzelne Feld der aktuellen Tabelle bearbeitet. mysql_field_name, mysql_field_type, mysql_field_len, mysql_field_flags 18. Eine laufende Nummer für das Feld wird ermittelt. Mit Hilfe der vier Funktionen mysql_field_name(), mysql_field_type(), mysql_field_len() und mysql_field_flags() werden bei jedem Schleifen-Durchlauf die Werte der vier Feldeigenschaften in $fdname, $fdtype, $fdlen und $fdflags gespeichert. 19. Es wird die laufende Nummer des Feldes und es werden die gesammelten Feld-Eigenschaften ausgegeben. 20. Nach Beendigung der beiden inneren Schleifen wird die HTML-Tabelle zur Ausgabe einer Datenbank beendet. 21. Die Verbindung wird beendet. ### H.8.2 Inhalt aller Datenbanken Falls man im o. a. Programm den Button »anzeigen« für die Datenbank firma betätigt, so ergibt sich das folgende Bild:
Abbildung H.7 Datenbank-Browser, Inhalt einer Datenbank
Das zweite Programm zur Darstellung der Inhalte der ausgewählten Tabelle beinhaltet keine neu hinzugekommenen Funktionen: Listing H.13 Datei uh21.php
    <html>
    <body>
    <?php
       /* Verbindung aufnehmen */
       $con = mysql_connect();

       /* Datensätze ermitteln */
       $dataresult = mysql_db_query($dbname,
           "select * from " . $tabname);

       /* Anzahl der Datensätze ermitteln */
       $numdata = mysql_num_rows($dataresult);

       /* Überschrift ausgeben */
       echo "<h3>Datenbank $dbname</h3>";
       echo "<h4>Tabelle $tabname</h4>";
       echo "$numdata Datensätze:<p>";

       /* Felder ermitteln */
       $fdresult = mysql_list_fields($dbname, $tabname);

       /* Anzahl der Felder ermitteln */
       $numfds = mysql_num_fields($fdresult);

       /* Ausgabebreite für die Felder ermitteln */
       $avwidth = 100 / $numfds;

       /* Tabelle beginnen, alle Feldnamen ausgeben */
       echo "<table width='100%' border><tr>";
       for ($f=0; $f<$numfds; $f++)
       {
          $fdname[$f] = mysql_field_name ($fdresult, $f);
          echo "<td bgcolor='#c3c3c3'>$fdname[$f]</td>";
       }

       echo "</tr>";

       /* Schleife über alle Datensätze */
       for ($i=0; $i<$numdata; $i++)
       {
          echo "<tr>";

          /* Schleife über alle Felder */
          for ($f=0; $f<$numfds; $f++)
          {
             /* Feldinhalt ermitteln, ausgeben*/
             $data = mysql_result($dataresult, $i, $fdname[$f]);
             if ($data=="") $data = "&nbsp;";
             echo "<td width='$avwidth%'>$data</td>";
          }
          echo "</tr>";
       }

       echo "</table>";
       mysql_close($con);
    ?>
    </body>
    </html>
Beim Aufruf wurden der Name der Datenbank ($dbname) und der Name der Tabelle ($tabname) als versteckte Formular-Elemente (hidden) an dieses Programm übermittelt. Es werden alle Datensätze aus allen Feldern der Tabelle ausgewählt, die Ergebniskennung ist $dataresult. Die Anzahl der Felder wird mit Hilfe der Funktion mysql_num_fields() in $fdresult gespeichert. Jedem Feld soll die gleiche Ausgabebreite in der HTML-Tabelle gegeben werden. Der Wert für die Breite wird ermittelt und in $avwidth gepeichert. Während der Ausgabe muß darauf geachtet werden, daß leere Einträge aus der Datenbank in der HTML-Tabelle mit einem expliziten Leerzeichen (&nbsp;) abgebildet werden. ## H.9 Alle Funktionen für Arrays alle Funktionen Im vorliegenden Abschnitt werden eine ganze Reihe von PHP-Funktionen für die Behandlung von Arrays eingesetzt. Zur besseren Übersicht folgt zunächst eine Liste aller Funktionen mit einer kurzen Erläuterung. Weitergehende Ausführungen finden sich im PHP-Manual.
Funktionsname | Erläuterung
array() | Erstellt ein Array. Dies ist eigentlich keine Funktion, sondern ein Sprach-Konstrukt.
array_count_values() | Zählt alle Werte eines Arrays
array_flip() | Liefert ein Array in Flip-Anordnung
array_keys() | Liefert alle Schlüssel eines Arrays
array_merge() | Führt zwei oder mehr Arrays in ein Array zusammen
array_pad() | Vergrößert ein Array und füllt ihn am Anfang oder am Ende auf
array_pop() | Liefert das letzte Element eines Arrays und entfernt es aus dem Array
array_push() | Fügt ein oder mehrere Elemente an das Ende eines Arrays an
array_reverse() | Ordnet die Elemente eines Arrays in umgekehrter Reihenfolge an
array_shift() | Liefert das erste Element eines Arrays und entfernt es aus dem Array
array_slice() | Liefert einen Teil eines Arrays
array_splice() | Entfernt Teil eines Arrays und ersetzt die entfernten Elemente durch neue
array_unshift() | Fügt ein oder mehrere Elemente am Anfang eines Arrays ein
array_values() | Liefert alle Werte eines Arrays
array_walk() | Führt eine Funktion für jedes Element eines Arrays aus
arsort() | Sortiert die Elemente eines assoziativen Arrays in umgekehrter Wert-Reihenfolge
asort() | Sortiert die Elemente eines assoziativen Arrays in Wert-Reihenfolge
compact() | Erstellt ein Array
count() | Zählt Elemente eines Arrays
current() | Liefert das aktuelle Element eines Arrays
each() | Liefert das nächste Paar, bestehend aus Schlüssel und Wert eines assoziativen Arrays
end() | Setzt den internen Array-Zeiger auf das letzte Element
extract() | Importiert Variablen in die Symbol-Tabelle eines Arrays
in_array() | Liefert »true«, falls ein bestimmter Wert innerhalb eines Arrays existiert
key() | Liefert einen Schlüssel eines assoziativen Arrays
krsort() | Sortiert die Elemente eines assoziativen Arrays in umgekehrter Schlüssel-Reihenfolge
ksort() | Sortiert die Elemente eines assoziativen Arrays in Schlüssel-Reihenfolge
list() | Dient der gleichzeitigen Zuweisung von mehreren Variablen. Dies ist eigentlich keine Funktion, sondern ein Sprach-Konstrukt.
next() | Setzt den internen Array-Zeiger auf das nächste Element
pos() | Liefert das aktuelle Element eines Arrays
prev() | Setzt den internen Array-Zeiger auf das vorherige Element
range() | Erstellt einen Array, bestehend aus einer Folge von Ganzzahlen
reset() | Setzt den internen Array-Zeiger auf das letzte Element
rsort() | Sortiert die Elemente eines Arrays in umgekehrter Reihenfolge
shuffle() | Mischt ein Array
sizeof() | Liefert die Anzahl der Elemente eines Arrays
sort() | Sortiert die Elemente eines Arrays
uasort() | Sortiert die Elemente eines numerischen Arrays gemäß einer vorgegebenen Sortier-Funktion
uksort() | Sortiert die Elemente eines assoziativen Arrays gemäß einer vorgegebenen Sortier-Funktion
usort() | Sortiert die Elemente eines Arrays gemäß einer vorgegebenen Sortier-Funktion
<< zurück | <top> | vor >>
Zum Katalog
PHP 4 bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung

Noch Fragen?
Tauschen Sie sich mit anderen Lesern aus Zum Forum

Empfehlung
| PHP 4-Workshop

Neue Bücher
Einstieg in Python JavaScript (4. Aufl.) CSS Praxis Einstieg in XML

Empfehlung
| MySQL 4

Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

MyGalileo
Der Service für registrierte Leser: Info

Copyright © Galileo Press GmbH 2001 - 2002
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken und speichern. Ansonsten unterliegt das <openbook> denselben Bestimmungen wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Die Veröffentlichung der Inhalte oder Teilen davon bedarf der ausdrücklichen schriftlichen Genehmigung von Galileo Press. Falls Sie Interesse daran haben sollten, die Inhalte auf Ihrer Website oder einer CD anzubieten, melden Sie sich bitte bei: stefan.krumbiegel@galileo-press.de

[Galileo Computing]
Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, fon: 0228.42150.0, fax 0228.42150.77, info@galileo-press.de