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