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 K Neu in PHP 4
|  | K.1 Konfiguration von PHP
|  | K.2 foreach-Struktur
|  | K.3 Array-Funktionen
|  | K.4 Funktionen mit variablen Parameterlisten
|  | K.5 include-Anweisung, Rückgabewert
|  | K.6 Operatoren
|  | K.7 PDF-Funktionen
|  | K.8 Perl-Funktionen
|  | K.9 PostgreSQL-Datenbank-Funktionen
|  | K.10 Session-Funktionen
|  | K.11 Zeichenketten-Funktionen
# Kapitel K Neu in PHP 4 In diesem Abschnitt sollen dem Umsteiger von PHP 3 zu PHP 4 Hinweise zu den wichtigsten Neuheiten der neuen Version und zu den Unterschieden zwischen den Versionen gegeben werden. stabil, zuverlässig Bei PHP 4 handelt es sich um eine konsequente Weiterentwicklung von PHP. Viele wichtige Eigenschaften treten für den PHP-Programmierer nicht unmittelbar in Erscheinung, äußern sich allerdings in einer deutlich verbesserten Performance. Sie machen PHP zu einem stabilen und zuverlässigen Entwicklungssystem. Komplexere Programme In den bisherigen Versionen von PHP wurde der Programm-Code gelesen und unmittelbar ausgeführt. Dies führte dazu, daß kleine, einfache Programme sehr schnell waren. Mit der Zeit wurden die unter PHP entwickelten Programme allerdings immer komplexer. Teile der Programme mußten mehrmals gelesen und ausgeführt werden. Somit sank die Performance von PHP mit wachsender Komplexität der Programme. Zend Engine Der Kern von PHP 4, die so genannte Zend Engine, wurde neu erschaffen. Es wurde ein PHP-Entwicklungssystem erzeugt, mit dessen Hilfe der gesamte Programm-Code zuerst übersetzt und anschließend erst ausgeführt wird. kompatibel Dabei wurde sehr auf die Kompatibilität zu der Vorgänger-Version geachtet. Es gibt schon zahlreiche Programme in PHP 3, die wiederum mit den zahlreichen, vorhandenen Funktionen von PHP 3 arbeiten. Die Umsteiger von PHP 3 sollten nicht gezwungen sein, diese Programme für die neue Version vollständig zu überarbeiten. schneller Die Programme laufen unter der Version 4 deutlich schneller. Bei umfangreichen Programmen ergaben sich Faktoren zwischen 5 und 200, bei kleinen Programmen wurden keine Verschlechterungen, manchmal dagegen leichte Verbesserungen festgestellt. modular, unabhängig Es wurde auf die Modularität und die Unabhängigkeit von verwandten Produkten eingegangen. Dadurch wird eine kontinuierliche Verbesserung von Teilen des Entwicklungs-Systemes und anderer Programme, die häufig im Zusammenhang mit PHP eingesetzt werden, erleichtert. Webserver-Unterstützung Es wurde eine bessere Zusammenarbeit mit vielen verschiedenen Webservern ermöglicht. In den Vorgänger-Versionen wurde nur der Apache Web Server unmittelbar unterstützt. PHP konnte allerdings auch auf den anderen Web Servern in Form von CGI-Skripten eingesetzt werden. Die Schnittstelle der Version 4 zu Web Servern allgemein wurde standardisiert, damit wurde eine direkte Unterstützung von vielen gängigen Web Servern erreicht. Änderungen und Ergänzungen in PHP 4 gegenüber PHP 3 haben sich im Einzelnen u. a. in folgenden Bereichen ergeben: ## K.1 Konfiguration von PHP php.ini Der Name der Konfigurationsdatei wurde von php3.ini wird zu php.ini geändert. Es gibt außerdem nun weniger Apache-Anweisungen, die es erlauben, die Konfigurations-Einstellungen zu ändern (siehe Manual: Einführung/Konfiguration). ## K.2 foreach-Struktur Die Kontrollstruktur foreach entspricht einer Schleife und erleichtert die Bearbeitung von Arrays, insbesondere von assoziativen Arrays. Mit Hilfe von foreach kann ein gesamtes Array durchlaufen werden. Dabei werden alle Werte eines Arrays und alle Keys (Schlüssel) eines assoziativen Arrays bzw. alle Indizes eines numerischen Arrays ermittelt. Es gibt zwei Schreibweisen für foreach. Im nachfolgenden Beispiel werden beide Schreibweisen jeweils an Hand eines eindimensionalen assoziativen und eines eindimensionalen numerischen Arrays vorgestellt. Vor allem bei assoziativen Arrays ergeben sich Vorteile, da die bisher genutzte Methode mit den Funktionen reset(), each() und list() etwas sperrig in der Handhabung ist. Listing K.1 Datei uk01.php
    <html>
    <body>
    <?php
       $f = array(84, 25, -3, 6.447);

       /* 1 */
       foreach($f as $w) echo "$w, ";
       echo "<p>";

       /* 2 */
       foreach($f as $x => $w) echo "$x => $w, ";
       echo "<p>";

       $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;

       /* 3 */
       foreach($tp as $w) echo "$w, ";
       echo "<p>";

       /* 4 */
       foreach($tp as $x => $w)
       {
          echo "$x => $w, ";
       }
    ?>
    </body>
    </html>
Das erste Array ($f) ist numerisch, mit vier Elementen. Zu 1: Für jedes Element im Array $f (foreach $f as $w) bekommt die Variable $w einen aktualisierten Wert, dieser wird ausgegeben. Anders ausgedrückt: Das gesamte Array wird durchlaufen, jedes Element wird ausgegeben. Zu 2: Für jedes Element im Array $f (foreach $f as $x => $w) bekommen die beiden Variablen $x und $w einen aktualisierten Wert, diese werden ausgegeben. Dabei entspricht $x dem Index des Elementes. Anders ausgedrückt: Das gesamte Array wird durchlaufen, jedes Element wird zusammen mit seiner laufenden Nummer ausgegeben. Das zweite Array ($tp) ist assoziativ, mit sieben Elementen. Zu 3: Für jedes Element im Array $tp (foreach $tp as $w) bekommt die Variable $w einen aktualisierten Wert, dieser wird ausgegeben. Anders ausgedrückt: Das gesamte Array wird durchlaufen, jedes Element wird ausgegeben. Zu 4: Für jedes Element im Array $tp (foreach $tp as $x => $w) bekommen die beiden Variablen $x und $w einen aktualisierten Wert, diese werden ausgegeben. Dabei entspricht $x dem Key des Elementes. Anders ausgedrückt: Das gesamte Array wird durchlaufen, jedes Element wird zusammen mit seinem Schlüssel ausgegeben. Anmerkung zu 4: Falls innerhalb einer foreach-Struktur mehrere Anweisungen ausgeführt werden sollen, so müssen diese Anweisungen in geschweifte Klammern gesetzt werden, genau wie bei den anderen Schleifen-Strukturen (for, while). Die Bildschirm-Ausgabe des Programmes: ## K.3 Array-Funktionen ### K.3.1 Arrays untersuchen Die Untersuchung von Arrays wird mit den folgenden Funktionen erleichtert: Die Funktion array_keys() gibt es in zwei Varianten:
| Variante 1 Es werden alle Keys eines Arrays in ein neues Array gespeichert
| Variante 2 Es werden alle Keys eines Arrays, die einen bestimmten Wert haben, in ein neues Array gespeichert
Die Funktion array_values() speichert alle Werte eines Arrays in ein neues Array. Mit Hilfe der Funktion in_array() kann nach bestimmten Werten innerhalb eines Arrays gesucht werden. Es wird true oder false zurückgeliefert, je nachdem, ob der gesuchte Wert gefunden wurde oder nicht. Die Funktion array_count_values() ermittelt die Häufigkeit aller Werte eines Arrays. In einem neuen Array werden die Werte des alten Arrays als Keys und die Häufigkeiten des alten Arrays als Werte gespeichert. Die Funktion arbeitet allerdings nur für Arrays, die Zeichenketten (Strings) oder ganze Zahlen beinhalten. Bei Arrays mit Elementen, die Nachkommastellen haben, erfolgt eine Fehlermeldung. Es folgt ein Beispiel: Listing K.2 Datei uk02.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"] = 21.8;
       $tp["Sonntag"] = 16.6;

       echo "Das gesamte Array: ";
       foreach($tp as $x => $w) echo "$x => $w, ";
       echo "<p>";

       echo "Alle Keys in ein neues Array: ";
       $tpkeys = array_keys($tp);
       foreach($tpkeys as $w) echo "$w, ";
       echo "<p>";

       echo "Alle Keys mit bestimmtem Wert in neues Array: ";
       $tpspec = array_keys($tp,21.8);
       foreach($tpspec as $w) echo "$w, ";
       echo "<p>";

       echo "Alle Werte in ein neues Array: ";
       $tpvalues = array_values($tp);
       foreach($tpvalues as $w) echo "$w, ";
       echo "<p>";

       /* Suche */
       $such = 21.8;
       if(in_array($such,$tp))
          echo "Gesuchter Wert $such ist vorhanden<p>";
       else
          echo "Gesuchter Wert $such ist nicht vorhanden<p>";

       $such = 12.3;
       if(in_array($such,$tp))
          echo "Gesuchter Wert $such ist vorhanden<p>";
       else
          echo "Gesuchter Wert $such ist nicht vorhanden<p>";

       echo "Häufigkeit feststellen:<br>";
       echo "Das gesamte Array: ";
       $tpx = array(17,19,21,21,17,22,16,18,17,22,26);
       for($i=0; $i<sizeof($tpx); $i++)
       {
          echo "$tpx[$i], ";
       }
       $freq = array_count_values($tpx);
       foreach($freq as $x => $w)
          echo "<br>$x kommt $w mal vor";
    ?>
    </body>
    </html>
Das Array $tpkeys beinhaltet alle Keys des alten Arrays (ohne seine Werte). Der Array $tpspec beinhaltet alle Keys des alten Arrays, die den Wert 21.8 haben. Das Array $tpvalues beinhaltet alle Werte des alten Arrays (ohne seine Keys). Die Werte 21.8 bzw. 12.3 werden mit Hilfe der Funktion in_array() im Array gesucht und (nicht) gefunden. Der Rückgabewert (true oder false) wird als Bedingung einer if-Verzweigung eingesetzt. Zur Verdeutlichung der Funktion array_count_values() wurde ein neues Array mit ganzzahligen Werten erzeugt. Die Häufigkeit der einzelnen Werte wird im Array $freq gespeichert. Die Bildschirm-Ausgabe des Programmes:
Abbildung K.1 Arrays untersuchen
### K.3.2 Arrays anfügen Die Funktion array_merge() dient zum Anfügen mehrerer Arrays. Bei numerischen Arrays werden die einzelnen Arrays einfach aneinandergehängt. Falls ein Wert mehrmals innerhalb der Arrays vorkommt, so kommt er auch im resultierenden Array mehrmals vor. Bei assoziativen Arrays kann es passieren, daß der gleiche Key mehrmals vorkommt. Im resultierenden Array kommt dieser Key nur noch einmal vor. Ihm zugeordnet ist der zuletzt angefügte Wert. Es folgt ein Beispiel: Listing K.3 Datei uk03.php
    <html>
    <body>
    <?php
       echo "<p>merge bei assoziativen Arrays<br>";
       $tpa["Montag"] = 10;
       $tpa["Dienstag"] = 11;
       $tpa["Mittwoch"] = 12;

       $tpb["Montag"] = 13;
       $tpb["Freitag"] = 14;
       $tpb["Samstag"] = 15;

       $tpc["Samstag"] = 16;
       $tpc["Sonntag"] = 17;

       echo "Array tpa: ";
       foreach($tpa as $x => $w) echo "$x => $w, ";
       echo "<br>";

       echo "Array tpb: ";
       foreach($tpb as $x => $w) echo "$x => $w, ";
       echo "<br>";

       echo "Array tpc: ";
       foreach($tpc as $x => $w) echo "$x => $w, ";
       echo "<br>";

       $tp = array_merge($tpa, $tpb, $tpc);
       echo "resultierendes Array tp:<br>";
       foreach($tp as $x => $w) echo "$x => $w, ";

       echo "<p>merge bei numerischen Arrays<br>";
       $fa = array(10, 11, 12);
       $fb = array(13, 14, 15);
       $fc = array(16, 17);

       echo "Array fa: ";
       foreach($fa as $x => $w) echo "$x => $w, ";
       echo "<br>";

       echo "Array fb: ";
       foreach($fb as $x => $w) echo "$x => $w, ";
       echo "<br>";

       echo "Array fc: ";
       foreach($fc as $x => $w) echo "$x => $w, ";
       echo "<br>";

       $f = array_merge($fa, $fb, $fc);
       echo "resultierendes Array f:<br>";
       foreach($f as $x => $w) echo "$x => $w, ";
    ?>
    </body>
    </html>
Das assoziative Array $tp wird aus den Arrays $tpa, $tpb und $tpc zusammengesetzt. Zwei Keys kommen jeweils zweimal vor, daher hat das resultierende Array nicht acht Elemente (3+3+2), sondern nur sechs Elemente. Das numerische Array $f wird aus den Arrays $fa, $fb und $fc zusammengesetzt. Das resultierende Array beinhaltet alle acht Elemente (3+3+2) dieser Arrays. Die Bildschirm-Ausgabe des Programmes:
Abbildung K.2 Arrays anfügen
### K.3.3 Arrays zerlegen Extraktion von Teil-Arrays Teile von Arrays können mit der Funktion array_slice() extrahiert werden. Es muß angegeben werden, ab welcher Position innerhalb des Arrays und über welche Länge extrahiert werden soll (analog zur Funktion substr() bei Zeichenketten):
| Falls der zweite Parameter der Funktion array_slice() positiv ist, beginnt die zurückgegebene Teil-Zeichenkette ab der angegebenen Nummer vom Beginn des Originals aus gemessen. Die Nummer des ersten Zeichens des Originals ist 0.
| Falls der zweite Parameter der Funktion array_slice() negativ ist, beginnt die zurückgegebene Teil-Zeichenkette ab der angegebenen Nummer vom Ende des Originals aus gemessen.
| Falls der dritte Parameter der Funktion array_slice() existiert und positiv ist, werden entsprechend viele Zeichen zurückgegeben.
Es folgt ein Beispiel: Listing K.4 Datei uk04.php
    <html>
    <body>
    <?php
       $f = array("a", "b", "c", "d", "e", "f", "g");
       echo("Vollständiges Array: ");
       foreach($f as $w) echo "$w, ";
       echo("<p>");

       $tf = array_slice($f,3);
       echo("Teil-Array ab Position 3: ");
       foreach($tf as $w) echo "$w, ";
       echo("<p>");

       $tf = array_slice($f,-3);
       echo("Teil-Array ab Position 3, vom Ende gerechnet: ");
       foreach($tf as $w) echo "$w, ";
       echo("<p>");

       $tf = array_slice($f,3,2);
       echo("Teil-Array ab Position 3, zwei Elemente: ");
       foreach($tf as $w) echo "$w, ";
       echo("<p>");
    ?>
    </body>
    </html>
Die Bildschirm-Ausgabe des Programmes:
Abbildung K.3 Arrays zerlegen
### K.3.4 Arrays einfügen Die Funktion array_splice() dient zum Einfügen eines Arrays in ein anderes Array. Es muß angegeben werden, ab welcher Position innerhalb des Arrays und über welche Länge eingefügt werden soll (analog zur Funktion array_slice()). Die Funktion verändert das Original-Array durch das zusätzliche Array. Außerdem werden die entfernten Elemente als Rückgabewert zurückgeliefert.
| Das zusätzliche Array wird ab der Position eingefügt, die im zweiten Parameter der Funktion array_splice() angegeben wird.
| Im dritten Parameter wird angegeben, wie viele Elemente aus dem Original-Array beim Einfügen des zusätzlichen Arrays entfernt werden sollen.
| Falls dieser Wert 0 ist, so wird kein Element entfernt. Das zusätzliche Array wird nur eingefügt. Falls dieser Wert größer als 0 ist, so ersetzt das zusätzliche Array entsprechend viele Elemente.
| Falls man alle restlichen Elemente des Original-Arrays ersetzen möchte, so kann man mit der Funktion count() arbeiten. Diese Funktion ermittelt die Anzahl der Elemente des Arrays.
Es folgt ein Beispiel: Listing K.5 Datei uk05.php
    <html>
    <body>
    <?php
       $f = array("a", "b", "c", "d", "e", "f", "g");
       echo("Vollständiges Array: ");
       foreach($f as $w) echo "$w, ";
       echo("<p>");
       $f_ori = $f;

       $z = array("p", "q", "r", "s");
       echo("Zusätzliches Array: ");
       foreach($z as $w) echo "$w, ";
       echo("<p>");

       $nf = array_splice($f,3,0,$z);
       echo("geändertes Array, zusätzliches Array wurde ab Position 3
    eingefügt: ");
       foreach($f as $w) echo "$w, ";
       echo("<br>");
       echo("bei dieser Aktion entfernte Elemente: ");
       foreach($nf as $w) echo "$w, ";
       echo("<p>");

       $f = $f_ori;
       $nf = array_splice($f,3,2,$z);
       echo("geändertes Array, zusätzliches Array wurde ab Position 3
    eingefügt, zwei Elemente wurden entfernt: ");
       foreach($f as $w) echo "$w, ";
       echo("<br>");
       echo("bei dieser Aktion entfernte Elemente: ");
       foreach($nf as $w) echo "$w, ";
       echo("<p>");

       $f = $f_ori;
       $nf = array_splice($f,3,count($f)-3,$z);
       echo("geändertes Array, zusätzliches Array wurde ab Position 3
    eingefügt, Rest wurde entfernt: ");
       foreach($f as $w) echo "$w, ";
       echo("<br>");
       echo("bei dieser Aktion entfernte Elemente: ");
       foreach($nf as $w) echo "$w, ";
       echo("<p>");
    ?>
    </body>
    </html>
Die Bildschirm-Ausgabe des Programmes:
Abbildung K.4 Arrays einfügen
### K.3.5 Ausgabe von mehrdimensionalen Arrays Elemente von mehrdimensionalen Arrays können nun auch innerhalb von Zeichenketten ausgegeben werden. Bisher mußte die Zeichenkette zur Ausgabe beendet werden und der Verkettungs-Operator . (Punkt) eingesetzt werden. In PHP 4 benötigt man nur ein Paar von geschweiften Klammern({}). Ein kleines Beispiel: Listing K.6 Datei uk06.php
    <html>
    <body>
    <?php
       echo "numerische Arrays:<br>";
       $f[2][3] = 42;
       echo "bisher war nur dies: " . $f[2][3] . " möglich<br>";
       echo "jetzt geht dies: {$f[2][3]} auch<p>";

       echo "assoziative oder gemischte Arrays:<br>";
       $f[2]["antwort"] = 42;
       echo "bisher war nur dies: " . $f[2]["antwort"] . " möglich<br>";
       echo "jetzt geht dies: {$f[2]["antwort"]} auch";
    ?>
    </body>
    </html>
### K.3.6 Weitere neue Array-Funktionen Weitere neue Array-Funktionen sind nachfolgend angegeben:
Funktionsname | Erläuterung
array_flip() | gibt ein Array in flip-Reihenfolge zurück
array_pop() | entfernt das letzte Element eines Arrays
array_push() | fügt an ein Array weitere Elemente am Ende an
array_reverse() | gibt ein Array in umgekehrter Reihenfolge zurück
array_shift() | entfernt das erste Element eines Arrays
array_unshift() | fügt an ein Array weitere Elemente am Anfang an
compact() | zum Erzeugen eines Arrays
## K.4 Funktionen mit variablen Parameterlisten Es ist seit PHP 4 möglich, auch eigene Funktionen mit variablen Parameterlisten einzusetzen. Dies erhöht die Flexibilität von Funktionen. Bisher mußte die Anzahl der Parameter bei einem Funktionsaufruf genau der Anzahl der Parameter entsprechen, die bei der Definition der Funktion vorgegeben wurden. Mit Hilfe der folgenden Funktionen ist dies nicht mehr zwingend notwendig:
| Die Funktion func_num_args() liefert die Anzahl der übergebenen Parameter
| Die Funktion func_get_arg() liefert einen bestimmten Parameter aus der Parameterliste
| Die Funktion func_get_args() (mit »s« am Ende) liefert einen Array mit allen übergebenen Parametern
| Das nachfolgende Programm verdeutlicht den Einsatz von func_num_args() und func_get_arg().
Listing K.7 Datei uk07.php
    <html>
    <body>
    <?php
       function addiere()
       {
          $anz = func_num_args();
          echo "Anzahl der Werte: $anz<br>";

          $sum = 0;
          for($i=0; $i<$anz; $i++)
          {
             $sum = $sum + func_get_arg($i);
          }
          echo "Summe der Werte: $sum<p>";
       }

       addiere(2,3,6);
       addiere(13,26);
       addiere(65,-3,88,31,12.5,7);
    ?>
    </body>
    </html>
Die Funktion addiere() wird insgesamt dreimal aufgerufen, jedes Mal mit einer anderen Anzahl an Parametern. Mit Hilfe von func_num_args() wird diese Anzahl ermittelt. Sie wird zur Steuerung einer for-Schleife verwendet. Innerhalb der for-Schleife werden alle gelieferten Parameter mit Hilfe von func_get_arg() ermittelt und anschließend addiert. Nach Beendigung der Schleife wird die Summe der Werte ausgegeben. Eine alternative Lösung mit der Funktion func_get_args() bietet das folgende Programm: Listing K.8 Datei uk08.php
    <html>
    <body>
    <?php
       function addiere()
       {
          $param = func_get_args();
          $anz = func_num_args();
          echo "Anzahl der Werte: $anz<br>";

          $sum = 0;
          for($i=0; $i<$anz; $i++)
          {
             $sum = $sum + $param[$i];
          }
          echo "Summe der Werte: $sum<p>";
       }

       addiere(2,3,6);
       addiere(13,26);
       addiere(65,-3,88,31,12.5,7);
    ?>
    </body>
    </html>
Mit Hilfe der Anweisung $param = func_get_args(); werden alle Parameter im Array $param gespeichert. Die Funktion func_num_args() ermittelt wiederum die Anzahl der Parameter. Innerhalb der for-Schleife werden alle gelieferten Parameter aus dem Array $param abgerufen und anschließend addiert. ## K.5 include-Anweisung, Rückgabewert Benutzerdefinierte Funktionen, die von mehreren Programmen benutzt werden sollen, können in externe Dateien ausgelagert werden. Mit Hilfe der include-Anweisung wird der Inhalt dieser Dateien in das Programm eingebunden, welches sie benötigt. Dabei ist zu beachten, daß der Programmcode in den externen Dateien in gültige PHP-Markierungen eingeschlossen sein muß. Falls diese Funktionen einen Rückgabwert haben, so kann dieser Wert wie gewohnt mit Hilfe der return-Anweisung zur aufrufenden Stelle zurückgeliefert werden. Diese return-Anweisung kann in PHP 4 auch innerhalb eines Blockes von Anweisungen, also innerhalb von geschweiften Klammern stehen. Im nachfolgenden Beispiel wird zunächst innerhalb der Datei math.inc eine Funktion maxi() definiert. Diese ermittelt aus den beiden übergebenen Parametern das Maximum, speichert ihn in die Variable $erg und liefert diesen Wert mit Hilfe der return-Anweisung zurück. Die return-Anweisung steht im vorliegenden Fall innerhalb des if-Blockes bzw. innerhalb des else-Blockes. Listing K.9 Datei math.inc
    <?php
       function maxi($x, $y)
       {
          if ($x > $y)
          {
             $erg = $x;
             return $erg;
          }
          else
          {
             $erg = $y;
             return $erg;
          }
       }
    ?>
Die Funktion wird vom nachfolgenden Programm aufgerufen. Dort wird zunächst die Datei math.inc mit Hilfe der include-Anweisung eingebunden. Damit sind alle Funktionen aus der Datei math.inc im aktuellen Programm bekannt und können verwendet werden.. Listing K.10 Datei uk09.php
    <html>
    <body>
    <?php
       include "math.inc";
       $a = 2;
       $b = 6;
       $c = maxi($a, $b);
       echo "Das Maximum von $a und $b ist $c";
    ?>
    </body>
    </html>
## K.6 Operatoren ### K.6.1 Zuweisungoperator Der Zuweisungsoperator = (Gleichheitszeichen) ermöglicht auch die Zuweisung einer Variablen über eine Referenz. Man kann also über zwei verschiedene Namen auf eine Variable zugreifen, dabei wird nur für eine Variable Speicherplatz beansprucht. ### K.6.2 Identitätsoperator Zu den bisherigen Vergleichsoperatoren wurde der Identitätsoperator === (drei Gleichheitszeichen) hinzugefügt. Mit Hilfe dieses Operators wird die Identität von zwei Variablen nur dann festgestellt, wenn ihr Wert gleich ist (das ist auch schon bei dem Operator == der Fall, also mit nur zwei Gleichheitszeichen) und wenn ihr Datentyp gleich ist. Im nachfolgenden Beispiel werden mehrere Variablen, die den gleichen Wert besitzen, aber nicht vom gleichen Datentyp sind, miteinander verglichen. Es handelt sich dabei um ganzzahlige Variablen, Variablen mit Nachkommastellen und Zahlenwerte innerhalb von Zeichenketten. Listing K.11 Datei uk10.php
    <html>
    <body>
    <?php
       $a = 5;
       $b = 5.0;
       $c = "5";
       $d = 5;

       echo "ganze Zahl a: $a<br>";
       echo "Zahl mit Nachkommastellen b: $b<br>";
       echo "Zeichenkette mit Zahl c: $c<br>";
       echo "ganze Zahl d: $d<p>";

       if ($a == $b) echo "a und b sind gleich<br>";
       if ($a === $b) echo "a und b sind identisch<br>";
       if ($a === $d) echo "a und d sind identisch<br>";
       if ($a == $c) echo "a und c sind gleich<br>";
       if ($a === $c) echo "a und c sind identisch<br>";
    ?>
    </body>
    </html>
Die Bildschirm-Ausgabe des Programmes:
Abbildung K.5 Identitätsoperator
## K.7 PDF-Funktionen Bei der Erzeugung von PDF-Dateien mit PHP hat sich Grundlegendes geändert (siehe Manual: Funktionsreferenz/PDF-Funktionen). ## K.8 Perl-Funktionen Perl-kompatible reguläre Ausdrücke (für Suchausdrücke) gibt es seit Version PHP 3.0.9. Die Liste der möglichen Zeichen für Suchvorgänge wurde erweitert. In PHP 4 sind außerdem folgende Funktionen hinzugekommen:
Funktionsname | Erläuterung
preg_grep() | Liefert Array mit gefundenen Elementen zu einem Suchausdruck
preg_replace() | Führt Suchen und Ersetzen durch
## K.9 PostgreSQL-Datenbank-Funktionen Zwei Funktionen wurden erweitert. Dies sind:
Funktionsname | Erläuterung
pg_fetch_array() | Holt eine Datenbankreihe als Array
pg_fetch_object() | Holt einen Datensatz als Objekt
## K.10 Session-Funktionen sessions Die Bearbeitung von Sessions wurde ermöglicht. Folgende Funktionen werden bereitgestellt:
Funktionsname | Erläuterung
session_name() | Setzt oder liest den Session-Namen
session_save_path() | Setzt oder liest den Sicherungspfad für eine Session
session_start() | Initialisiert die Daten einer Session
session_decode() | Dekodiert Session-Daten aus einer Zeichenkette
session_destroy() | Zerstört alle Daten zu einer Session
session_encode() | Kodiert Session-Daten in eine Zeichenkette
session_id() | Setzt oder liest die Session ID
session_is_registered() | Stellt fest, ob eine Variable in einer Session registriert ist
session_module_name() | Setzt oder liest das Session Modul
session_register() | Registriert Variablen für eine Session
session_unregister() | Entfernt die Registrierung von Variablen für eine Session
## K.11 Zeichenketten-Funktionen Die Überprüfung des Rückgabewertes der Funktion strpos() kann auf eine neue Weise durchgeführt werden. Außerdem wurden einige Funktionen hinzugefügt. Dies sind:
Funktionsname | Erläuterung
addcslashes() | zum Hinzufügen von Backslashes vor bestimmten Zeichen in einer Zeichenkette
count_chars() | zum Zählen von Zeichen innerhalb einer Zeichenkette
get_html_translation_table() | Liefert die verwendete HTML-Translation Table
metaphone() | ermittelt den Metaphone-Schlüssel einer Zeichenkette
str_repeat() | Wiederholung eines Strings
str_replace() | Ersetzung von Teilen eines Strings
strip_tags() | Entfernt HTML und PHP-Tags aus einer Zeichenkette
stripcslashes() | Entfernt Backslashes aus einer Zeichenkette
strtr() | Änderung einzelner Zeichen eines Strings
substr_replace() | Ersetzung von Teilen eines Strings
<< 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