3. Die Grundlagen von PHP
3.1. Die Skript-Verzeichnisstruktur
3.2. Konfiguration von PHP
PHP wird durch eine Textdatei namens [php.ini] vorkonfiguriert. Alle diese Einstellungen können programmgesteuert geändert werden. Die Konfiguration von PHP hat großen Einfluss auf die Ausführung der Skripte. Es ist daher wichtig, sich damit vertraut zu machen. Das folgende Skript [phpinfo.php] ermöglicht dies:
Kommentare
- Zeile 3: Die Funktion [phpinfo] zeigt die Konfiguration von PHP an;
Ausführungsergebnisse
Die Funktion [phpinfo] zeigt hier mehr als 800 Konfigurationszeilen an. Wir werden diese nicht näher erläutern, da die meisten davon die fortgeschrittene Nutzung von PHP betreffen. Eine wichtige Zeile ist Zeile 13 oben: Sie gibt an, welche Datei „[php.ini]“ zur Konfiguration der Datei „PHP“ verwendet wurde, die Sie zur Ausführung Ihrer Skripte nutzen werden. Wenn Sie die Ausführungskonfiguration von PHP ändern möchten, müssen Sie diese Datei bearbeiten. In dieser Datei finden sich zahlreiche Kommentare, die die Funktion der verschiedenen Konfigurationen erläutern.
3.3. Ein erstes Beispiel
3.3.1. Der Code
Nachfolgend finden Sie ein Programm namens [bases-01.php], das die ersten Funktionen von PHP enthält.
<?php
// Dies ist ein Kommentar
// Variable wird verwendet, ohne deklariert worden zu sein
$nom = "dupont";
// eine Bildschirmanzeige
print "nom=$nom\n";
// ein Array mit Elementen unterschiedlichen Typs
$tableau = array("un", "deux", 3, 4);
// die Anzahl der Elemente
$n = count($tableau);
// eine Schleife
for ($i = 0; $i < $n; $i++) {
print "tableau[$i]=$tableau[$i]\n";
}
// Initialisierung von 2 Variablen mit dem Inhalt eines Arrays
list($chaine1, $chaine2) = array("chaine1", "chaine2");
// Verkettung der beiden Zeichenfolgen
$chaine3 = $chaine1 . $chaine2;
// Anzeige des Ergebnisses
print "[$chaine1,$chaine2,$chaine3]\n";
// Verwendung einer Funktion
affiche($chaine1);
// Der Typ einer Variablen kann bekannt sein
afficheType("n", $n);
afficheType("chaine1", $chaine1);
afficheType("tableau", $tableau);
// Der Typ einer Variablen kann sich während der Ausführung ändern
$n = "a changé";
afficheType("n", $n);
// Eine Funktion kann ein Ergebnis zurückgeben
$res1 = f1(4);
print "res1=$res1\n";
// Eine Funktion kann ein Array von Werten zurückgeben
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// Man hätte diese Werte in einem Array abrufen können
$t = f2();
for ($i = 0; $i < count($t); $i++) {
print "t[$i]=$t[$i]\n";
}
// Tests
for ($i = 0; $i < count($t); $i++) {
// zeigt nur Zeichenfolgen an
if (getType($t[$i]) === "string") {
print "t[$i]=$t[$i]\n";
}
}
// Vergleichsoperatoren == und ===
if("2"==2){
print "avec l'opérateur ==, la chaîne 2 est égale à l'entier 2\n";
}else{
print "avec l'opérateur ==, la chaîne 2 n'est pas égale à l'entier 2\n";
}
if("2"===2){
print "avec l'opérateur ===, la chaîne 2 est égale à l'entier 2\n";
}
else{
print "avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2\n";
}
// weitere Tests
for ($i = 0; $i < count($t); $i++) {
// zeigt nur ganze Zahlen >10 an
if (getType($t[$i]) === "integer" and $t[$i] > 10) {
print "t[$i]=$t[$i]\n";
}
}
// eine while-Schleife
$t = [8, 5, 0, -2, 3, 4];
$i = 0;
$somme = 0;
while ($i < count($t) and $t[$i] > 0) {
print "t[$i]=$t[$i]\n";
$somme += $t[$i]; //$somme=$somme+$t[$i]
$i++; //$i=$i+1
}//while
print "somme=$somme\n";
// Programmende
exit;
//----------------------------------
function affiche($chaine) {
// zeigt $chaine an
print "chaine=$chaine\n";
}
//zeigt an
//----------------------------------
function afficheType($name, $variable) {
// zeigt den Typ von $variable an
print "type[variable $" . $name . "]=" . getType($variable) . "\n";
}
//afficheType
//----------------------------------
function f1($param) {
// addiert 10 zu $param
return $param + 10;
}
//----------------------------------
function f2() {
// gibt 3 Werte zurück
return array("un", 0, 100);
}
?>
Die Ergebnisse:
nom=dupont
tableau[0]=un
tableau[1]=deux
tableau[2]=3
tableau[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[variable $n]=integer
type[variable $chaine1]=string
type[variable $tableau]=array
type[variable $n]=string
res1=14
(res1,res2,res3)=[un,0,100]
t[0]=un
t[1]=0
t[2]=100
t[0]=un
avec l'opérateur ==, la chaîne 2 est égale à l'entier 2
avec l'opérateur ===, la chaîne 2 n'est pas égale à l'entier 2
t[2]=100
t[0]=8
t[1]=5
somme=13
Anmerkungen
- Zeile 5: In PHP wird der Typ der Variablen nicht deklariert. Diese haben einen dynamischen Typ, der sich im Laufe der Zeit ändern kann. $nom steht für die Variable mit dem Bezeichner „nom“;
- Zeile 7: Um etwas auf den Bildschirm auszugeben, kann man die Anweisung print oder die Anweisung „echo“ verwenden;
- Zeile 9: Mit dem Schlüsselwort array lässt sich ein Array definieren. Die Variable $nom[$i] steht für das Element $i des Arrays $tableau;
- Zeile 11: Die Funktion count($tableau) gibt die Anzahl der Elemente des Arrays $tableau zurück;
- Zeilen 13–15: eine Schleife. Da diese nur eine Anweisung enthält, sind die geschweiften Klammern hier optional. Im weiteren Verlauf dieses Dokuments werden wir die geschweiften Klammern systematisch setzen, unabhängig von der Anzahl der Anweisungen;
- Zeile 14: Zeichenketten werden in Anführungszeichen „“ oder Apostrophe ' gesetzt. Innerhalb von Anführungszeichen werden die Variablen $variable ausgewertet, innerhalb von Apostrophen jedoch nicht;
- Zeile 17: Mit der Funktion list lassen sich Variablen in einer Liste zusammenfassen und ihnen mit einer einzigen Zuweisungsoperation einen Wert zuweisen. Hier gilt $chaine1="Zeichenkette1" und $chaine2="Zeichenkette2";
- Zeile 19: Der Operator „.“ ist der Operator zur Verkettung von Zeichenketten;
- Zeilen 83–86: Das Schlüsselwort function definiert eine Funktion. Ob eine Funktion Werte zurückgibt oder nicht, wird durch die Anweisung return festgelegt. Der aufrufende Code kann die Ergebnisse einer Funktion ignorieren oder abrufen. Eine Funktion kann an beliebiger Stelle im Code definiert werden.
- Zeile 92: Die vordefinierte Funktion getType($variable) gibt eine Zeichenkette zurück, die den Typ von $variable darstellt. Dieser Typ kann sich im Laufe der Zeit ändern;
- Zeile 45: Der Operator === vergleicht zwei Elemente streng: Sie müssen denselben Typ haben, um verglichen werden zu können. Der Operator == ist weniger streng: Zwei Elemente können gleich sein, ohne denselben Typ zu haben. Dies zeigen die Anweisungen in den Zeilen 50–60. Im Fall des Operators == erfolgt der Vergleich erst, nachdem beide verglichenen Elemente in denselben Typ umgewandelt wurden. Dabei finden implizite Typumwandlungen statt. Es passiert leicht, dass man diese impliziten Typumwandlungen „vergisst“ und dadurch zu unerwarteten Ergebnissen gelangt, beispielsweise wenn man feststellt, dass eine Bedingung wahr ist, obwohl man erwartet hatte, dass sie falsch ist. Um diese Falle zu vermeiden, verwenden wir systematisch den Vergleichsoperator ===;
- Zeile 64: Man kann auch die booleschen Operatoren „or“ und „!“ verwenden;
- Zeile 69: Anstelle der Schreibweise „array()“ kann man die Schreibweise „[]“ verwenden, um ein Array aus „PHP7“ zu initialisieren;
- Zeile 80: Die vordefinierte Funktion exit beendet die Ausführung des Skripts;
- Zeile 107: Das Tag ?> markiert das Ende des Skripts PHP. Es ist nicht zwingend erforderlich. Außerdem kann sie im Webkontext Probleme verursachen, wenn ihr Leerzeichen oder Zeilenumbrüche folgen, die schwer zu erkennen sind, da sie in einem Texteditor nicht sichtbar sind. Daher werden wir diesen Tag im weiteren Verlauf des Dokuments systematisch weglassen;
Hinweis: In diesem Dokument verwenden wir das Schlüsselwort [print], um Text auf der Konsole anzuzeigen. Eine andere Methode, um dasselbe zu erreichen, ist die Verwendung des Schlüsselworts [echo]. Es gibt subtile Unterschiede zwischen diesen beiden Schlüsselwörtern, die im Kontext dieses Dokuments jedoch keine Rolle spielen. Wenn Sie also lieber [echo] verwenden möchten, tun Sie dies bitte.
3.3.2. Verwendung von NetBeans
NetBeans gibt verschiedene Warnungen aus, die Sie überprüfen sollten. Nehmen wir das Beispiel des Skripts [bases-01.php]:
In Zeile 5 gibt NetBeans eine Warnung aus, dass die Datei die Empfehlung PSR-1 (PHP Standardempfehlungen Nr. 1) nicht einhält. Die PSR sind Empfehlungen zur Erstellung von standardisiertem Code, um die Interoperabilität und Wartung von Code zu erleichtern, der von verschiedenen Personen geschrieben wurde. Es kann lästig sein, Warnungen zu erhalten, wenn man bewusst gegen die Standards verstoßen möchte, weil beispielsweise das Projektteam andere Standards verwendet. Was mit NetBeans überprüft werden soll und was nicht, ist konfigurierbar:
- Unter [5] finden sich die Elemente, die man mit NetBeans überprüfen möchte;
- in [6] den Schweregrad, der dem von NetBeans gemeldeten Fehler zugewiesen wird;
In [7] ist zu sehen, dass überprüft werden soll, ob der Code den Empfehlungen PSR-0 und PSR-1 entspricht. Es gibt keine verbindlichen Vorgaben. In der Einarbeitungsphase in die Programmiersprache empfiehlt es sich, möglichst viele der von NetBeans angebotenen Optionen zu überprüfen. Auf diese Weise lernt man viel dazu. Später passt man diese NetBeans-Prüfung dann an die Codierungsstandards des Projektteams an.
Sehen wir uns die Codierungsstandards PSR-1 und [8, 9] an:
Option | Prüfung |
| Klassenkonstanten MUST müssen in Großbuchstaben mit Unterstrichen als Trennzeichen deklariert werden. Beispiel: const TAUX_TVA |
| Methodennamen wie MUST müssen in camelCase() deklariert werden. Beispiel: public function executeBatchImpots{} |
| Eigenschaftsnamen wie SHOULD müssen in $StudlyCaps, $camelCase oder $under_score deklariert werden (einheitlich innerhalb eines Gültigkeitsbereichs) Beispiel: public SalaireAnnuel (StudlyCaps), public salaireAnnuel (camelCase), public salaire_annuel (under_score) |
| Eine Datei SHOULD deklariert neue Symbole und verursacht keine weiteren Nebenwirkungen, oder sie SHOULD führt Logik mit Nebenwirkungen aus, aber SHOULD NOT tut beides. |
| Typnamen MUST müssen in StudlyCaps deklariert werden (Code, der für 5.2.x und früher geschrieben wurde, verwendet die Pseudonamespacing-Konvention von Vendor_-Präfixen für Typnamen). Jeder Typ befindet sich in einer eigenen Datei und gehört zu einem Namespace mit mindestens einer Ebene: einem Anbieternamen auf oberster Ebene. Beispiel: class EtudiantBoursier {} |
Die Empfehlung PSR-1 / 4 besagt, dass in einer Datei PHP Folgendes enthalten sein muss:
- entweder die Deklaration eines Typs (Klassen, Schnittstellen);
- oder ausführbaren Code ohne Deklaration neuer Typen;
Es gibt weitere PHP-Empfehlungen, die nicht von NetBeans überprüft werden: PSR-3, PSR-4, PSR-6, PSR-7 und PSR-13.
Der Einfachheit halber überprüfen nicht alle Beispiele in diesem Dokument die Empfehlung PSR-1, da dies erfordert, den Code der Klassen und Schnittstellen auf separate Dateien zu verteilen, was für einfache Beispiele zu aufwendig ist. Es ist daher einfacher, alles in einer Datei unterzubringen. Für das Anwendungsbeispiel, das als roter Faden dieses Dokuments dient, wurde versucht, die Empfehlung PSR-1 so gut wie möglich zu befolgen.
Einige Warnungen von NetBeans weisen auf einen möglichen Fehler hin:
Die Warnung [Unitialized Variables] weist auf einen wahrscheinlichen Fehler hin, oft handelt es sich um einen Tippfehler im Namen einer Variablen. Gleiches gilt für die Warnung [Unused Variables].
Schließlich empfiehlt es sich, alle NetBeans-Warnungen zu überprüfen, die durch ein Feld am linken Rand des Codes und einen gelben Strich am rechten Rand angezeigt werden:
3.4. Der Gültigkeitsbereich von Variablen
3.4.1. Beispiel 1
Das Skript [bases-02.php] lautet wie folgt:
<?php
// Gültigkeitsbereich der Variablen
function f1() {
// Es wird die globale Variable $i verwendet
global $i;
$i++;
$j = 10;
print "f1[i,j]=[$i,$j]\n";
}
function f2() {
// Es wird die globale Variable $i verwendet
global $i;
$i++;
$j = 20;
print "f2[i,j]=[$i,$j]\n";
}
function f3() {
// Es wird eine lokale Variable $i verwendet
$i = 4;
$j = 30;
print "f3[i,j]=[$i,$j]\n";
}
// Tests
$i = 0;
$j = 0; // Diese beiden Variablen sind einer Funktion f
// nur dann bekannt, wenn diese sie explizit mit der Anweisung „global“
// erklärt, dass sie diese verwenden möchte
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
Die Ergebnisse:
Anmerkungen
- Zeilen 29–30: Definieren die beiden Variablen $i und $j des Hauptprogramms. Diese Variablen sind innerhalb der Funktionen nicht bekannt. So ist beispielsweise in Zeile 9 die Variable $j der Funktion f1 eine lokale Variable der Funktion f1 und unterscheidet sich von der Variable $j des Hauptprogramms. Eine Funktion kann über das Schlüsselwort „global“ auf eine Variable $variable des Hauptprogramms zugreifen;
- In Zeile 7 bezieht sich die Anweisung auf die globale Variable $i des Hauptprogramms;
3.4.2. Beispiel 3
Das Skript [bases-03.php] lautet wie folgt:
<?php
// Der Geltungsbereich einer Variablen erstreckt sich über alle Codeblöcke
$i = 0; {
$i = 4;
$i++;
}
print "i=$i\n";
Die Ergebnisse:
Anmerkungen
In manchen Programmiersprachen hat eine innerhalb von geschweiften Klammern definierte Variable nur den Geltungsbereich dieser Klammern: Außerhalb dieser Klammern ist sie nicht bekannt. Die obigen Ergebnisse zeigen, dass dies in PHP nicht der Fall ist. Die in Zeile 5 innerhalb der geschweiften Klammern definierte Variable $i ist dieselbe wie die in den Zeilen 4 und 8 außerhalb der geschweiften Klammern verwendete.
3.5. Typänderungen
Die Variablen in PHP haben keinen konstanten Typ. Dieser kann sich während der Ausführung je nach dem der Variablen zugewiesenen Wert ändern. Bei Operationen mit Daten verschiedener Typen führt der Interpreter PHP implizite Konvertierungen durch, um die Operanden auf einen gemeinsamen Typ zu bringen. Diese impliziten Konvertierungen können, wenn sie dem Entwickler nicht bekannt sind, eine Quelle für schwer zu findende Fehler sein. Im Folgenden wird ein [bases-04.php]-Skript vorgestellt, das implizite und explizite Konvertierungen veranschaulicht:
<?php
// Strenge Typen bei der Parameterübergabe
declare(strict_types=1);
// implizite Typumwandlungen
// Typ --> bool
print "Conversion vers un booléen------------------------------\n";
showBool("abcd", "abcd");
showBool("", "");
showBool("[1, 2, 3]", [1, 2, 3]);
showBool("[]", []);
showBool("NULL", NULL);
showBool("0.0", 0.0);
showBool("0", 0);
showBool("4.6", 4.6);
function showBool(string $prefixe, $var) : void {
print "(bool) $prefixe : ";
// Die Konvertierung von $var in einen Booleschen Wert erfolgt automatisch im folgenden Test
if ($var) {
print "true";
} else {
print "false";
}
print "\n";
}
Kommentare
- Zeile 4: Fordert eine strenge Typüberprüfung der Funktionsparameter, wenn diese angegeben sind;
- Zeile 18: Die Funktion [showBool] soll die implizite (automatische) Umwandlung veranschaulichen, die der Interpreter PHP vornimmt, wenn ein Wert beliebigen Typs in einen booleschen Wert umgewandelt werden muss (Zeile 21);
- Zeile 18: Dem Parameter $var ist kein Typ zugewiesen. Der tatsächliche Parameter kann daher einen beliebigen Typ haben. Der Parameter $prefixe muss hingegen vom Typ „string“ sein. Die Funktion showBool gibt keinen Wert zurück (void);
- Zeile 21: In der Anweisung if($var) muss der Wert von $var in einen booleschen Wert umgewandelt werden, damit if ausgewertet wird. Erstaunlicherweise liefert der Interpreter PHP für jeden Wert, der ihm übergeben wird, eine Antwort;
- Zeilen 9–16: Der Wert des Funktionsparameters von [showBool] ist nacheinander:
- Zeile 9: eine nicht leere Zeichenkette: Ergebnis TRUE (Groß-/Kleinschreibung spielt keine Rolle, TRUE = true);
- Zeile 10: eine leere Zeichenkette: Ergebnis FALSE;
- Zeile 11: ein nicht leeres Array: Ergebnis TRUE;
- Zeile 12: ein leeres Array: Ergebnis FALSE;
- Zeile 14: die reelle Zahl 0: Ergebnis FALSE;
- Zeile 15: die ganze Zahl 0: Ergebnis FALSE;
- Zeile 16: die von 0 verschiedene reelle (oder ganzzahlige) Zahl: Ergebnis TRUE;
Dies zeigen die erhaltenen Bildschirmanzeigen:
Conversion vers un booléen------------------------------
(bool) abcd : true
(bool) : false
(bool) [1, 2, 3] : true
(bool) [] : false
(bool) NULL : false
(bool) 0.0 : false
(bool) 0 : false
(bool) 4.6 : true
Fahren wir mit dem Skriptcode fort:
//
// implizite Typumwandlungen von String in einen numerischen Typ
// Zeichenkette --> Zahl
print "Conversion chaîne vers nombre------------------------------\n";
showNumber("12");
showNumber("45.67");
showNumber("abcd");
function showNumber(string $var) : void {
$nombre = $var + 1;
var_dump($nombre);
print "($var): $nombre\n";
}
Anmerkungen
- Zeile 9: Die Funktion [showNumber] akzeptiert einen Parameter vom Typ „string“ und gibt kein Ergebnis zurück (void);
- Zeile 10: Dieser Parameter wird in einer arithmetischen Operation verwendet, was den Interpreter PHP dazu zwingt, zu versuchen, $var in eine Zahl umzuwandeln;
- Zeile 5: wandelt die Zeichenkette „12“ in die Ganzzahl 12 um;
- Zeile 6: wandelt die Zeichenkette „45.67“ in die reelle Zahl 45.67 um;
- Zeile 7: gibt eine Warnung aus, wandelt die Zeichenfolge „abcd“ aber dennoch in die Zahl 0 um;
Hier sind die Ergebnisse der Ausführung:
Fahren wir mit dem Skriptcode fort:
// Explizite Typumwandlungen
// in int
showInt("12.45");
showInt(67.8);
showInt(TRUE);
showInt(NULL);
function showInt($var) : void {
print "paramètre : ";
var_dump($var);
print "\n";
print "résultat de la conversion : ";
var_dump((int) $var);
print "\n";
}
Kommentare
- Zeile 21: Die Funktion [showInt] nimmt einen Parameter beliebigen Typs entgegen und gibt kein Ergebnis zurück. Sie versucht, den Parameter $var in eine Ganzzahl umzuwandeln (Zeile 26). Um eine Variable $var in einen Typ T umzuwandeln, schreibt man im Allgemeinen (T) $var, wobei T folgende Werte annehmen kann: int, integer, bool, boolean, float, double, real, string, array, object, unset;
- Zeile 16: Konvertiert die Zeichenkette „12.45“ in die Ganzzahl 12;
- Zeile 17: Konvertiert die reelle Zahl 67,8 in die Ganzzahl 67;
- Zeile 18: Konvertiert den Booleschen Wert TRUE in die Ganzzahl 1 (den Booleschen Wert FALSE in die Ganzzahl 0);
- Zeile 19: wandelt den Zeiger NULL in die Ganzzahl 0 um;
Dies zeigen die Bildschirmausgaben:
Wir setzen die Untersuchung des Skripts mit der expliziten Umwandlung von Werten in den Typ „float“ fort:
// zu „float“
showFloat("12.45");
showFloat(67);
showFloat(TRUE);
showFloat(NULL);
function showFloat($var) : void {
print "paramètre : ";
var_dump($var);
print "\n";
print "résultat de la conversion : ";
var_dump((float) $var);
print "\n";
}
Kommentare
- Zeile 35: Die Funktion [showFloat] erhält einen Parameter beliebigen Typs und gibt kein Ergebnis zurück;
- Zeile 40: Der Wert dieses Parameters wird explizit in float umgewandelt;
- Zeile 30: Die Zeichenkette „12.45“ wird in die reelle Zahl 12.45 umgewandelt;
- Zeile 31: Die Ganzzahl 67 wird in die reelle Zahl 67 umgewandelt;
- Zeile 32: Der Boolesche Wert TRUE wird in die reelle Zahl 1 umgewandelt (der Wert FALSE in die Zahl 0);
- Zeile 33: Der Zeiger NULL wird in die reelle Zahl 0 umgewandelt;
Dies zeigen die Bildschirmausgaben:
Wir setzen die Vorstellung des Skripts fort und betrachten nun Umwandlungen in den Typ „string“:
// zu String
showstring(5);
showString(6.7);
showString(FALSE);
showString(NULL);
function showString($var) : void {
print "paramètre : ";
var_dump($var);
print "\n";
print "résultat de la conversion : ";
var_dump((string) $var);
print "\n";
}
- Zeile 49: Die Funktion [showString] erhält einen Parameter beliebigen Typs und gibt kein Ergebnis zurück;
- Zeile 54: Der Wert des Parameters wird in einen String-Typ umgewandelt;
- Zeile 44: Die Ganzzahl 5 wird in die Zeichenkette „5“ umgewandelt;
- Zeile 45: Die reelle Zahl 6,7 wird in die Zeichenkette „6,7“ umgewandelt;
- Zeile 46: Der Boolesche Wert FALSE wird in eine leere Zeichenkette umgewandelt;
- Zeile 47: Der Zeiger NULL wird in eine leere Zeichenkette umgewandelt;
Hier sind die Bildschirmausgaben:
3.6. Arrays
3.6.1. Klassische eindimensionale Arrays
Das Skript [bases-05.php] lautet wie folgt:
<?php
// klassische Arrays
// Initialisierung
$tab1 = array(0, 1, 2, 3, 4, 5);
// Durchlauf – 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
print "tab1[$i]=$tab1[$i]\n";
}
// Durchlauf – 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1)) {
print "tab1[$clé]=$valeur\n";
}
// Hinzufügen von Elementen
$tab1[] = $i++;
$tab1[] = $i++;
// Durchlauf – 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
print "tab1[$i]=$élément\n";
$i++;
}
// Letztes Element löschen
array_pop($tab1);
// Durchlauf – 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
print "tab1[$i]=$tab1[$i]\n";
}
// erstes Element löschen
array_shift($tab1);
// Durchlauf – 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
print "tab1[$i]=$tab1[$i]\n";
}
// am Ende der Tabelle hinzufügen
array_push($tab1, -2);
// Durchlauf – 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
print "tab1[$i]=$tab1[$i]\n";
}
// Hinzufügen am Anfang des Arrays
array_unshift($tab1, -1);
// Durchlauf – 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++) {
print "tab1[$i]=$tab1[$i]\n";
}
Die Ergebnisse:
tab1 a 6 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 éléments
Deprecated: The each() function is deprecated. This message will be suppressed on further calls in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_04.php on line 14
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 8 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=7
tab1 a 7 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 a 6 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 a 7 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 a 8 éléments
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2
Kommentare
Das obige Programm zeigt Operationen zur Bearbeitung eines Wert-Arrays. In PHP gibt es zwei Notationen für Arrays:
Das Array 1 wird als Array bezeichnet, das Array 2 als Wörterbuch oder assoziatives Array, bei dem die Elemente als Schlüssel => Wert notiert werden. Die Notation $contraires["beau"] bezeichnet den Wert, der dem Schlüssel „schön“ zugeordnet ist. Hier ist dies also die Zeichenkette „hässlich“. Das Array 1 ist lediglich eine Variante des assoziativen Arrays und könnte wie folgt notiert werden:
So ergibt sich $tableau[2] = „drei“. Letztendlich gibt es nur Wörterbücher. Bei einem klassischen Array mit n Elementen sind die Schlüssel die ganzen Zahlen aus dem Intervall [0,n-1].
- Zeile 14: Mit der Funktion each($tableau) lässt sich ein Wörterbuch durchlaufen. Bei jedem Aufruf gibt sie ein (Schlüssel, Wert)-Paar daraus zurück. Wie Zeile 10 der Ergebnisse zeigt, ist die Funktion each in PHP 7 mittlerweile veraltet;
- Zeile 13: Die Funktion `reset($dictionnaire)` setzt die Funktion `each` auf das erste (Schlüssel, Wert)-Paar des Wörterbuchs.
- Zeile 14: Die Schleife while wird beendet, wenn die Funktion each am Ende des Wörterbuchs ein leeres Paar zurückgibt. Hier kommt eine implizite Konvertierung zum Tragen: Das leere Paar wird in den Booleschen Wert FALSE umgewandelt;
- Zeile 18: Die Schreibweise $tableau[]=Wert fügt das Element valeur als letztes Element von $tableau hinzu;
- Zeile 23: Das Array wird mit einem foreach durchlaufen. Dieses syntaktische Element ermöglicht es, ein Wörterbuch – also ein Array – anhand von zwei Syntaxen zu durchlaufen:
Die erste Syntax gibt bei jeder Iteration ein Paar (clé,valeur) zurück, während die zweite Syntax nur das Element valeur aus dem Wörterbuch zurückgibt.
- Zeile 28: Die Funktion array_pop($tableau) entfernt das letzte Element aus $tableau;
- Zeile 35: Die Funktion array_shift($tableau) löscht das erste Element aus $tableau;
- Zeile 42: Die Funktion array_push($tableau, Wert) fügt valeur als letztes Element zu $tableau hinzu;
- Zeile 49: Die Funktion array_unshift($tableau, Wert) fügt valeur als erstes Element von $tableau hinzu;
3.6.2. Das Wörterbuch oder assoziative Array
Das Skript [bases-06.php] lautet wie folgt:
<?php
// Wörterbücher
$conjoints = ["Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => ""];
// Durchlauf – 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints)) {
print "conjoints[$clé]=$valeur\n";
}
// Sortierung des Wörterbuchs nach dem Schlüssel
ksort($conjoints);
// Durchlauf – 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints)) {
print "conjoints[$clé]=$valeur\n";
}
// Liste der Schlüssel des Wörterbuchs
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++) {
print "clés[$i]=$clés[$i]\n";
}
// Liste der Werte des Wörterbuchs
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++) {
print "valeurs[$i]=$valeurs[$i]\n";
}
// Suche nach einem Schlüssel
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");
// Löschen eines Schlüssel-Wert-Paares
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
print "conjoints[$clé]=$valeur\n";
}
// Ende
exit;
function existe($conjoints, $mari) {
// Prüft, ob der Schlüssel $mari im Wörterbuch $conjoints vorhanden ist
if (isset($conjoints[$mari])) {
print "La clé [$mari] existe associée à la valeur [$conjoints[$mari]]\n";
} else {
print "La clé [$mari] n'existe pas\n";
}
}
Die Ergebnisse:
Nombre d'éléments du dictionnaire : 4
Deprecated: The each() function is deprecated. This message will be suppressed on further calls in C:\Data\st-2019\dev\php7\php5-exemples\exemples\exemple_05.php on line 8
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle
clés[0]=Jacques
clés[1]=Jean
clés[2]=Paul
clés[3]=Pierre
valeurs[0]=Lucette
valeurs[1]=
valeurs[2]=Virginie
valeurs[3]=Gisèle
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
conjoints[Jacques]=Lucette
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle
Anmerkungen
Der obige Code wendet das zuvor für ein einfaches Array Gesehene auf ein Wörterbuch an. Wir gehen nur auf die Neuerungen ein:
- Zeile 12: Mit der Funktion ksort (Key Sort) lässt sich ein Wörterbuch in der natürlichen Reihenfolge der Schlüssel sortieren;
- Zeile 19: Die Funktion array_keys($dictionnaire) gibt die Liste der Schlüssel des Wörterbuchs in Form eines Arrays zurück;
- Zeile 24: Die Funktion array_values($dictionnaire) gibt die Liste der Werte des Wörterbuchs als Array zurück;
- Zeile 43: Die Funktion isset($variable) gibt TRUE zurück, wenn die Variable $variable definiert wurde, andernfalls FALSE;
- Zeile 33: Die Funktion unset($variable) löscht die Variable $variable.
3.6.3. Mehrdimensionale Arrays
Das Skript [bases-07.php] lautet wie folgt:
<?php
// klassische mehrdimensionale Tabellen
// Initialisierung
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// Durchlauf
for ($i1 = 0; $i1 < count($multi); $i1++) {
for ($i2 = 0; $i2 < count($multi[$i1]); $i2++) {
print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
}
}
// mehrdimensionale Wörterbücher
// Initialisierung
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// Durchlauf
foreach ($multi as $clé => $valeur) {
for ($i2 = 0; $i2 < count($valeur); $i2++) {
print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
}
}
Ergebnisse:
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zéro][0]=0
multi[zéro][1]=1
multi[zéro][2]=2
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24
Anmerkungen
- Zeile 5: Die Elemente des Arrays $multi sind selbst Arrays;
- Zeile 14: Das Array $multi wird zu einem Dictionary (clé,valeur), in dem jedes valeur ein Array ist;
3.7. Zeichenketten
3.7.1. Notation
Das Skript [bases-08.php] lautet wie folgt:
<?php
// Notation von Zeichenketten
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>
Ergebnisse:
3.7.2. Vergleich
Das Skript [bases-09.php] lautet wie folgt:
<?php
// Strikte Einhaltung des Typs der Funktionsparameter
declare(strict_types=1);
// Vergleichsfunktion
function compareModele2Chaine(string $chaine1, string $chaine2): void {
// vergleicht Zeichenkette1 und Zeichenkette2
if ($chaine1 === $chaine2) {
print "[$chaine1] est égal à [$chaine2]\n";
} else {
print "[$chaine1] est différent de [$chaine2]\n";
}
}
// Tests zum Vergleich von Zeichenketten
compareModele2Chaine("abcd", "abcd");
compareModele2Chaine("", "");
compareModele2Chaine("1", "");
exit;
Ergebnisse:
[abcd] est égal à [abcd]
[] est égal à []
[1] est différent de []
Kommentare
- Zeile 9 des Codes: Man hätte den Vergleichsoperator == anstelle von === verwenden können. Letzterer Operator ist insofern restriktiver, als er vorschreibt, dass beide Operanden denselben Typ haben müssen. Zu beachten ist, dass er hier durch den Operator == ersetzt werden könnte, da der Typ beider Parameter in der Funktionssignatur auf „string“ festgelegt ist;
3.7.3. Verknüpfungen zwischen Zeichenketten und Arrays
Das Skript [bases-10.php] lautet wie folgt:
<?php
// Zeichenkette in Array
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);
// Array durchlaufen
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++) {
print "tab[$i]=$tab[$i]\n";
}
// Array in Zeichenkette
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";
// Fügen wir ein leeres Feld hinzu
$chaine .= ":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// Durchlauf durch das Array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++) {
print "tab[$i]=$tab[$i]\n";
} // Wir haben nun 5 Elemente, wobei das letzte leer ist
// Fügen wir erneut ein leeres Feld hinzu
$chaine .= ":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// Durchlauf durch das Array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++) {
print "tab[$i]=$tab[$i]\n";
} // Es gibt nun 6 Elemente, wobei die letzten beiden leer sind
Ergebnisse:
tab a 4 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
chaine2=1:2:3:4
chaîne=1:2:3:4:
tab a 5 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
chaîne=1:2:3:4::
tab a 6 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=
Kommentare
- Zeile 5: Die Funktion `explode($séparateur,$chaine)` ermöglicht es, die durch `$séparateur` getrennten Felder aus `$chaine` zu extrahieren. So werden mit `explode(":",$chaine)` die Elemente von $chaine, die durch die Zeichenfolge „:“ getrennt sind, als Array abgerufen;
- Zeile 12: Die Funktion implode($séparateur,$tableau) führt die umgekehrte Operation der Funktion explode durch. Sie gibt eine Zeichenkette zurück, die aus den Elementen von $tableau besteht, getrennt durch $séparateur;
3.7.4. Reguläre Ausdrücke
Das Skript [bases-11.php] lautet wie folgt:
<?php
// Strikte Typangabe für Funktionsparameter
declare (strict_types=1);
// Reguläre Ausdrücke in PHP
// Die verschiedenen Felder einer Zeichenkette extrahieren
// Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
// Es soll nur die Ziffernfolge extrahiert werden
$modèle = "/(\d+)/";
// Die Zeichenkette wird mit dem Muster abgeglichen
compareModele2Chaine($modèle, "xyz1234abcd");
compareModele2Chaine($modèle, "12 34");
compareModele2Chaine($modèle, "abcd");
// Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
// Wir möchten die Ziffernfolge sowie die vorangehenden und nachfolgenden Felder
$modèle = "/^(.*?)(\d+)(.*?)$/";
// Die Zeichenfolge wird mit dem Muster abgeglichen
compareModele2Chaine($modèle, "xyz1234abcd");
compareModele2Chaine($modèle, "12 34");
compareModele2Chaine($modèle, "abcd");
// Das Muster: ein Datum im Format TT/MM/JJ
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
compareModele2Chaine($modèle, "10/05/97");
compareModele2Chaine($modèle, " 04/04/01 ");
compareModele2Chaine($modèle, "5/1/01");
// das Muster – eine Dezimalzahl
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
compareModele2Chaine($modèle, "187.8");
compareModele2Chaine($modèle, "-0.6");
compareModele2Chaine($modèle, "4");
compareModele2Chaine($modèle, ".6");
compareModele2Chaine($modèle, "4.");
compareModele2Chaine($modèle, " + 4");
// Ende
exit;
// --------------------------------------------------------------------------
function compareModele2Chaine(string $modèle, string $chaîne): void {
// vergleicht die Zeichenfolge $chaîne mit dem Muster $modèle
// Die Zeichenfolge wird mit dem Muster abgeglichen
$champs = [];
$correspond = preg_match($modèle, $chaîne, $champs);
// Anzeige der Ergebnisse
print "\nRésultats($modèle,$chaîne)\n";
if ($correspond) {
for ($i = 0; $i < count($champs); $i++) {
print "champs[$i]=$champs[$i]\n";
}
} else {
print "La chaîne [$chaîne] ne correspond pas au modèle [$modèle]\n";
}
}
Ergebnisse:
Résultats(/(\d+)/,xyz1234abcd)
champs[0]=1234
champs[1]=1234
Résultats(/(\d+)/,12 34)
champs[0]=12
champs[1]=12
Résultats(/(\d+)/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/(\d+)/]
Résultats(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
champs[0]=xyz1234abcd
champs[1]=xyz
champs[2]=1234
champs[3]=abcd
Résultats(/^(.*?)(\d+)(.*?)$/,12 34)
champs[0]=12 34
champs[1]=
champs[2]=12
champs[3]= 34
Résultats(/^(.*?)(\d+)(.*?)$/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/^(.*?)(\d+)(.*?)$/]
Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
champs[0]=10/05/97
champs[1]=10
champs[2]=05
champs[3]=97
Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/, 04/04/01 )
champs[0]= 04/04/01
champs[1]=04
champs[2]=04
champs[3]=01
Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
La chaîne [5/1/01] ne correspond pas au modèle [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
champs[0]=187.8
champs[1]=
champs[2]=187.8
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
champs[0]=-0.6
champs[1]=-
champs[2]=0.6
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
champs[0]=4
champs[1]=
champs[2]=4
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
champs[0]=.6
champs[1]=
champs[2]=.6
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
champs[0]=4.
champs[1]=
champs[2]=4.
Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
champs[0]= + 4
champs[1]=+
champs[2]=4
Anmerkungen
- Hier verwenden wir reguläre Ausdrücke, um die verschiedenen Felder einer Zeichenkette zu extrahieren. Mit regulären Ausdrücken lassen sich die Einschränkungen der Funktion implode umgehen. Das Prinzip besteht darin, eine Zeichenfolge mit einer anderen Zeichenfolge namens modèle mithilfe der Funktion preg_match zu vergleichen:
$correspond = preg_match($modèle, $chaîne, $champs);
Die Funktion preg_match gibt einen booleschen Wert TRUE zurück, wenn modèle in chaîne gefunden werden kann. Ist dies der Fall, stellt $champs[0] die dem Muster entsprechende Teilzeichenfolge dar. Enthält modèle zudem Untermodelle in Klammern, so ist $champs[1] der Teil von $chaîne, der dem ersten Untermodell entspricht, „$champs[2]“ ist der Teil von „$chaîne“, der dem zweiten Untermuster entspricht, usw.
Betrachten wir das erste Beispiel. Das Muster wird in Zeile 10 definiert: Es bezeichnet eine Folge von einer oder mehreren (+) Ziffern (\d), die an beliebiger Stelle in einer Zeichenkette stehen. Außerdem definiert das Muster ein in Klammern gesetztes Untermuster;
- Zeile 12: Das Muster /(\d+)/ (eine Folge von einer oder mehreren Ziffern an beliebiger Stelle in der Zeichenkette) wird mit der Zeichenkette „xyz1234abcd“ verglichen. Man sieht, dass die Teilzeichenkette 1234 dem Muster entspricht. Wir erhalten also $champs[0], was „1234“ entspricht. Außerdem enthält das Muster Untermuster in Klammern. Es ergibt sich $champs[1] = „1234“;
- Zeile 13: Das Muster /(\d+)/ wird mit der Zeichenkette „12 34“ verglichen. Man sieht, dass die Teilzeichenfolgen 12 und 34 dem Muster entsprechen. Der Vergleich endet bei der ersten Teilzeichenfolge, die dem Muster entspricht. Man erhält also $champs[0]=12 und $champs[1]=12;
- Zeile 14: Das Muster /(\d+)/ wird mit der Zeichenkette „abcd“ verglichen. Es wird keine Übereinstimmung gefunden;
Lassen Sie uns die im weiteren Verlauf des Codes verwendeten Muster näher erläutern:
$modèle = "/^(.*?)(\d+)(.*?)$/";
entspricht dem Zeichenfolgenanfang (^), gefolgt von 0 oder mehreren (*) beliebigen Zeichen (.), gefolgt von 1 oder mehreren (+) Ziffern, gefolgt von erneut 0 oder mehreren (*) beliebigen Zeichen (.). Das Muster (.*) steht für 0 oder mehrere beliebige Zeichen. Ein solches Muster passt auf jede beliebige Zeichenfolge. Daher wird das Muster /^(.*)(\d+)(.*)$/ niemals gefunden, da das erste Untermuster (.*) die gesamte Zeichenfolge aufnimmt. Das Muster (.*?)(\d+) bezeichnet hingegen 0 oder mehrere beliebige Zeichen bis zum nächsten Untermuster (?), hier \d+. Die Ziffern werden also nun nicht mehr vom Muster (.*) aufgesaugt. Das obige Muster passt daher zu [début de chaîne (^), une suite de caractères quelconques (.*?), une suite d'un ou plusieurs chiffres (\d+), une suite de caractères quelconques (.*?), la fin de la chaîne ($)].
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
entspricht [début de chaîne (^), 2 chiffres (\d\d), le caractère / (\/), 2 chiffres, /, 2 chiffres, une suite de 0 ou plusieurs espaces (\s*), la fin de chaîne ($)].
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
entspricht dem Zeichenfolgenanfang (^), 0 oder mehreren Leerzeichen (\s*), einem Plus- oder Minuszeichen [+|-], das 0 oder 1 Mal vorkommt (?), einer Folge von 0 oder mehreren Leerzeichen (\s*), 1 oder mehrere Ziffern, gefolgt von einem Dezimalpunkt und anschließend null oder mehreren Ziffern (\d+\.\d*) oder (|) einem Dezimalpunkt (\.) gefolgt von einer oder mehreren Ziffern (\d+) oder (|) einer oder mehreren Ziffern (\d+), einer Folge von null oder mehreren Leerzeichen (\s*)].
Hinweis: Der Begriff [espace] in regulären Ausdrücken bezeichnet eine Reihe von Zeichen: Leerzeichen, Zeilenumbruch \n, Tabulator \t, Wagenrücklauf \r, Seitenumbruch \f…
3.8. Die Funktionen
3.8.1. Parameterübergabe
Das Skript [base-12.php] lautet wie folgt:
<?php
// Art der Parameterübergabe an eine Funktion
// Strikte Einhaltung des Parametertyps
declare(strict_types=1);
function f(int &$i, int $j): void {
// $i wird per Referenz übergeben
// $j wird per Wert übergeben
$i++;
$j++;
print "f[i,j]=[$i,$j]\n";
}
// Tests
$i = 0;
$j = 0;
//, $i und $j wurden an die Funktion f übergeben
f($i, $j);
print "test[i,j]=[$i,$j]\n";
Ergebnisse:
Anmerkungen
Der obige Code veranschaulicht die beiden Arten der Parameterübergabe an eine Funktion. Betrachten wir das folgende Beispiel:
- Zeile 1: Definiert die formalen Parameter $a und $b der Funktion f. Diese verarbeitet diese beiden formalen Parameter und gibt ein Ergebnis zurück;
- Zeile 7: Aufruf der Funktion f mit zwei tatsächlichen Parametern $i und $j. Die Zuordnungen zwischen den formalen Parametern ($a, $b) und den tatsächlichen Parametern ($i, $j) werden durch die Zeilen 1 und 7 definiert:
- &$a: Das Zeichen & gibt an, dass der formale Parameter $a den Wert der Adresse des effektiven Parameters $i annimmt. Anders ausgedrückt: $a und $i sind zwei Verweise auf denselben Speicherplatz. Die Bearbeitung des formalen Parameters $a entspricht der Bearbeitung des effektiven Parameters $i. Dies zeigt die Ausführung des Codes. Diese Art der Übergabe eignet sich für Ausgabeparameter und umfangreiche Daten wie Arrays und Dictionaries. Diese Art der Übergabe wird als Referenzübergabe bezeichnet.
- $b: Der formale Parameter $b erhält den Wert des effektiven Parameters $j. Dies ist eine Wertübergabe. Formale und effektive Parameter sind zwei verschiedene Variablen. Die Bearbeitung des formalen Parameters $b hat keinerlei Auswirkungen auf den effektiven Parameter $j. Dies zeigt die Ausführung des Codes. Diese Übergabemethode eignet sich für Eingabeparameter.
- Nehmen wir die Funktion échange, die zwei formale Parameter $a und $b akzeptiert. Die Funktion vertauscht die Werte dieser beiden Parameter. Bei einem Aufruf mit Parametervertauschung ($i, $j) erwartet der aufrufende Code also, dass die Werte der beiden tatsächlichen Parameter vertauscht werden. Es handelt sich also um Ausgabeparameter (sie werden verändert). Man schreibt daher:
Das folgende Skript [base-13.php] zeigt weitere Beispiele:
<?php
// Typen im strengen Modus
// declare(strict_types = 1);
// Parameterübergabemodus
function f(&$i, $j) {
// $i wird per Referenz übergeben
// $j wird als Wert übergeben
$i++;
$j++;
print "f[i,j]=[$i,$j]\n";
}
function g(int &$i, int $j) : void {
// $i wird per Referenz übergeben
// $j wird als Wert übergeben
$i++;
$j++;
print "g[i,j]=[$i,$j]\n";
}
// Tests
$i = 0;
$j = 0;
// $i und $j werden an die Funktion f übergeben
f($i, $j);
print "test[i,j]=[$i,$j]\n";
// $i und $j werden an die Funktion g übergeben
g($i, $j);
print "test[i,j]=[$i,$j]\n";
// Es werden falsche Parameter an f übergeben
$a=5.3;
$b=6.2;
f($a, $b);
print "test[a,b]=[$a,$b]\n";
// Es werden falsche Parameter an f übergeben
$a=5.3;
$b=6.2;
g($a, $b);
print "test[a,b]=[$a,$b]\n";
Anmerkungen
- Zeilen 8–14: Die im vorigen Absatz behandelte Funktion f, allerdings wurden die Parameter nicht typisiert;
- Zeilen 16–22: Die Funktion g macht dasselbe wie die Funktion f, aber der Typ der erwarteten Parameter wird angegeben – das ist eine Neuerung PHP 7. Es werden zwei Parameter vom Typ int erwartet. Wir wollen sehen, was passiert, wenn der tatsächlich an die Funktion übergebene Parameter nicht den von ihr erwarteten Typ hat;
- Zeilen 25–26: $i und $j sind zwei Ganzzahlen;
- Zeilen 28–29: Aufruf der Funktion f mit Parametern des erwarteten Typs;
- Zeilen 31–32: Aufruf der Funktion g mit Parametern des erwarteten Typs;
- Zeilen 34–35: Die Variablen $a und $b sind vom Typ „float“;
- Zeilen 36–37: Aufruf der Funktion f mit Parametern, die nicht vom erwarteten Typ sind;
- Zeilen 41–42: Aufruf der Funktion g mit Parametern, die nicht dem erwarteten Typ entsprechen;
Ergebnisse
- Die Zeilen 5–6 zeigen, dass die Funktion f die beiden Parameter vom Typ float angenommen und mit ihnen gearbeitet hat;
- Die Zeilen 7–8 zeigen, dass die Funktion g die beiden Parameter vom Typ „float“ akzeptiert, sie jedoch in den Typ „int“ umgewandelt hat (Zeile 7);
Entfernen wir nun die Auskommentierung in Zeile 4:
Diese Anweisung besagt, dass die Typen der formalen Parameter eingehalten werden müssen. Ist dies nicht der Fall, wird ein Fehler gemeldet. Die Ergebnisse der Ausführung lauten dann:
- Zeilen 9–10: Der Interpreter PHP 7 hat eine Ausnahme ausgelöst, um anzuzeigen, dass der erste an die Funktion g übergebene Parameter nicht den richtigen Typ hatte. Es wird empfohlen, bei den Parametertypen, wann immer möglich, streng zu sein, um Fehler beim Aufruf von Funktionen zu erkennen;
3.8.2. Von einer Funktion zurückgegebene Ergebnisse
Das Skript [base-15.php] lautet wie folgt:
<?php
// Typen im strengen Modus
declare(strict_types=1);
// Von einer Funktion zurückgegebene Ergebnisse
// Eine Funktion kann mehrere Werte in einem Array zurückgeben
list($res1, $res2, $res3) = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++) {
print "f1 : res[$i]=$res[$i]\n";
}
// Eine Funktion kann ein Objekt zurückgeben
$res = f2(10);
print "f2 : [$res->res1,$res->res2,$res->res3]\n";
// Objekt welcher Art?
print "nature de l'objet : ";
var_dump($res);
print "\n";
// Das Gleiche machen wir mit der Funktion f3
$res = f3(10);
print "f3 : [$res->res1,$res->res2,$res->res3]\n";
// Welche Art von Objekt?
print "nature de l'objet : ";
var_dump($res);
print "\n";
// Ende
exit;
// Funktion f1
function f1(int $valeur): array {
// gibt ein Array zurück ($valeur+1,$valeur+2,$valeur+3)
return array($valeur + 1, $valeur + 2, $valeur + 3);
}
// Funktion f2
function f2(int $valeur): object {
// gibt ein Objekt zurück ($valeur+1,$valeur+2,$valeur+3)
$res->res1 = $valeur + 1;
$res->res2 = $valeur + 2;
$res->res3 = $valeur + 3;
// gibt das Objekt zurück
return $res;
}
// Funktion f3 – macht dasselbe wie die Funktion f2
function f3(int $valeur): object {
// gibt ein Objekt zurück ($valeur+1,$valeur+2,$valeur+3)
$res = new stdclass();
$res->res1 = $valeur + 1;
$res->res2 = $valeur + 2;
$res->res3 = $valeur + 3;
// gibt das Objekt zurück
return $res;
}
Ergebnisse
[11,12,13]
f1 : res[0]=11
f1 : res[1]=12
f1 : res[2]=13
Warning: Creating default object from empty value in C:\Data\st-2019\dev\php7\php5-exemples\exemples\bases\base-15.php on line 43
f2 : [11,12,13]
nature de l'objet : object(stdClass)#1 (3) {
["res1"]=>
int(11)
["res2"]=>
int(12)
["res3"]=>
int(13)
}
f3 : [11,12,13]
nature de l'objet : object(stdClass)#2 (3) {
["res1"]=>
int(11)
["res2"]=>
int(12)
["res3"]=>
int(13)
}
Anmerkungen
- Das vorherige Programm zeigt, dass eine Funktion PHP mehrere Ergebnisse und nicht nur ein einziges in Form eines Arrays oder eines Objekts zurückgeben kann. Der Begriff „Objekt“ wird etwas weiter unten näher erläutert;
- Zeilen 35–38: Die Funktion f1 gibt mehrere Werte in Form eines Arrays zurück;
- Zeilen 41–48: Die Funktion f2 gibt mehrere Werte in Form eines Objekts (object) zurück;
- Zeilen 51–59: Die Funktion f3 ist identisch mit der Funktion f2, außer dass sie in Zeile 53 explizit ein Objekt erstellt;
- Zeile 6 der Ergebnisse gibt eine Warnung (warning) aus, die darauf hinweist, dass PHP in Zeile 43 des Codes gezwungen war, ein Standardobjekt zu erstellen, d. h. bei der Verwendung der Notation [$res→res1]. Die Funktion var_dump in Zeile 20 des Codes ermöglicht den Zugriff auf den Typ des Objekts und dessen Inhalt. In den Ergebnissen ist Folgendes zu sehen:
- Zeile 8: Das standardmäßig erstellte Objekt ist vom Typ stdClass;
- Zeilen 9–10: Die Eigenschaft res1 ist vom Typ entier und hat den Wert 11;
- usw.
- Um die Warnung in Zeile 6 der Ergebnisse zu vermeiden, wird in Zeile 53 der Funktion f3 explizit ein Objekt vom Typ stdClass erstellt;
3.9. Die Textdateien
Das Skript [bases-16.php] lautet wie folgt:
<?php
// strikte Einhaltung des Typs der Funktionsparameter
declare (strict_types=1);
// sequenzielle Verarbeitung einer Textdatei
// Diese besteht aus einer Reihe von Zeilen der Form „login:pwd:uid:gid:infos:dir:shell“
// Jede Zeile wird in Form von „login => uid:gid:infos:dir:shell“ in ein Wörterbuch aufgenommen
// Der Dateiname wird festgelegt
$INFOS = "infos.txt";
// Die Datei wird zum Erstellen geöffnet
if (!$fic = fopen($INFOS, "w")) {
print "Erreur d'ouverture du fichier $INFOS en écriture\n";
exit;
}
// Es wird ein beliebiger Inhalt generiert
for ($i = 0; $i < 100; $i++) {
fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
}
// Die Datei wird geschlossen
fclose($fic);
// die Datei wird ausgewertet – fgets behält die Zeilenende-Markierung bei
// Dadurch wird verhindert, dass beim Lesen einer Leerzeile eine leere Zeichenkette abgerufen wird
// Die Datei wird zum Lesen geöffnet
if (!$fic = fopen($INFOS, "r")) {
print "Erreur d'ouverture du fichier $INFOS en lecture\n";
exit;
}
// Die Zeilen sind kürzer als 1000 Zeichen
// Das Einlesen der Zeile endet am Zeilenendezeichen
// oder am Dateiendezeichen
while ($ligne = fgets($fic, 1000)) {
// Das Zeilenendezeichen wird entfernt, falls vorhanden
$ligne = cutNewLineChar($ligne);
// Die Zeile wird in ein Array eingefügt
$infos = explode(":", $ligne);
// das Login wird abgerufen
$login = array_shift($infos);
// das Passwort wird ignoriert
array_shift($infos);
// Es wird ein Eintrag im Wörterbuch angelegt
$dico[$login] = $infos;
}
// man schließt es
fclose($fic);
// Auswertung des Wörterbuchs
afficheInfos($dico, "login10");
afficheInfos($dico, "X");
// Ende
exit;
// --------------------------------------------------------------------------
function afficheInfos(array $dico, string $clé): void {
// Zeigt den Wert an, der im Wörterbuch dem Schlüssel $dico zugeordnet ist, sofern er existiert
if (isset($dico[$clé])) {
// Wert vorhanden – handelt es sich um ein Array?
$valeur = $dico[$clé];
if (is_array($valeur)) {
print "[$clé," . join(":", $valeur) . "]\n";
} else {
// $valeur ist kein Array
print "[$clé,$valeur]\n";
}
} else {
// $clé ist kein Schlüssel im Wörterbuch $dico
print "la clé [$clé] n'existe pas\n";
}
}
// --------------------------------------------------------------------------
function cutNewLinechar(string $ligne): string {
// Das Zeilenendezeichen von $ligne wird entfernt, falls es vorhanden ist
$L = strlen($ligne); // Zeilenlänge
while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
$ligne = substr($ligne, 0, $L - 1);
$L--;
}
// Ende
return($ligne);
}
Die Datei infos.txt:
Die Ergebnisse:
[login10,uid10:gid10:infos10:dir10:shell10]
la clé [X] n'existe pas
Anmerkungen
- Zeile 12: fopen(nom_fichier, „w“) öffnet die Datei nom_fichier zum Schreiben (w=write). Wenn die Datei nicht existiert, wird sie angelegt. Wenn sie existiert, wird sie geleert. Wenn das Anlegen fehlschlägt, gibt fopen den Wert false zurück. In der Anweisung if (!$fic = fopen($INFOS, "w")) {…} finden zwei aufeinanderfolgende Operationen statt: 1) $fic = fopen(..) 2) if (!$fic) {…};
- Zeile 18: fputs($fic,$chaîne) schreibt chaîne in die Datei $fic. $chaine wird mit dem Zeilenendezeichen \n am Ende geschrieben;
- Zeile 21: fclose($fic) schließt die Datei $fic;
- Zeile 26: fopen(nom_fichier, „r“) öffnet die Datei nom_fichier im Lesemodus (r=read). Wenn das Öffnen fehlschlägt (die Datei existiert beispielsweise nicht), gibt fopen den Wert „false“ zurück;
- Zeile 34: fgets($fic, 1000) liest die nächste Zeile der Datei mit einer Begrenzung auf 1000 Zeichen. In der Schleife while ($ligne = fgets($fic, 1000)) {…} finden zwei aufeinanderfolgende Operationen statt: 1) $ligne = fgets(…) 2) while ( ! $ligne). Nachdem das letzte Zeichen der Datei gelesen wurde, gibt die Funktion fgets den Wert false zurück und die Schleife while wird beendet. Die Funktion fgets versucht hier, maximal 1000 Zeichen zu lesen, bricht jedoch ab, sobald ein Zeilenendezeichen auftritt. Da hier alle Zeilen weniger als 1000 Zeichen haben, liest [fgets] eine Textzeile einschließlich des Zeilenendezeichens. Die Funktion cutNewLineChar in den Zeilen 75–84 entfernt eventuelle Zeilenendezeichen;
- Zeile 77: Die Funktion strlen($chaîne) gibt die Anzahl der Zeichen von $chaîne zurück;
- Zeile 78: Die Funktion substr($ligne, $position, $taille) gibt $taille Zeichen aus $ligne zurück, beginnend ab dem Zeichen mit der Nummer $position, wobei das erste Zeichen die Nummer 0 hat. Auf Windows-Rechnern lautet das Zeilenendezeichen „\r\n“. Auf Unix-Rechnern ist es die Zeichenkette „\n“;
- Zeile 40: Die Funktion array_shift($tableau) entfernt das erste Element aus $tableau und gibt es als Ergebnis zurück. Das von array_shift zurückgegebene Ergebnis wird hier vernachlässigt;
- Zeile 62: Die Funktion is_array($variable) gibt true zurück, wenn $variable ein Array ist, andernfalls false;
- Zeile 63: Die Funktion join verhält sich genauso wie die bereits behandelte Funktion implode;
3.10. Kodierung/Dekodierung jSON
Die Kodierung/Dekodierung jSON (JavaScript Object Notation) werden wir in der Übung, die als roter Faden durch das Dokument zieht, intensiv nutzen. Die Skripte [json-01.php, json-02.php, json-03.php] erklären, was man für den weiteren Verlauf wissen muss.
Das Skript [json-01.php] lautet wie folgt:
<?php
$array1 = ["nom" => "séléné", "prénom" => "bénédicte", "âge" => 34];
// JSON-Kodierung des Arrays „array1“ mit escaped Unicode-Zeichen
print "encodage json du tableau array1 avec caractères Unicode échappés\n";
$json1 = json_encode($array1);
print "json1=$json1\n";
// JSON-Kodierung des Arrays „array1“ mit nicht maskierten Unicode-Zeichen
print "encodage json du tableau array1 avec caractères Unicode non échappés\n";
$json2 = json_encode($array1, JSON_UNESCAPED_UNICODE);
print "json2=$json2\n";
// Dekodierung von jSON in ein assoziatives Array
print "décodage jSON de json2 dans tableau associatif\n";
$array2 = json_decode($json2, true);
var_dump($array2);
foreach ($array2 as $key => $value) {
print "$key:$value\n";
}
// Dekodierung von jSON in ein Objekt
print "décodage jSON de json2 dans objet stdClass\n";
$array2 = json_decode($json2);
var_dump($array2);
print "prénom=$array2->prénom\n";
print "nom=$array2->nom\n";
print "âge=$array2->âge\n";
Ergebnisse
Kommentare
- Zeile 6 des Codes: Die Funktion [json_encode] wandelt ihren Parameter in die Zeichenkette jSON um;
- Zeile 2 der Ergebnisse: Die erzeugte Zeichenfolge jSON. Die Unicode-Zeichen éâ wurden durch ihren Unicode-Code ersetzt, der mit \u beginnt;
- Zeile 10 des Codes: Wir wiederholen den Vorgang und weisen diesmal an, dass die Unicode-Zeichen unverändert beibehalten werden sollen;
- Zeile 4 der Ergebnisse: Die resultierende Zeichenkette jSON. Sie ist wesentlich besser lesbar;
- Zeilen 14–18 des Codes: Wir führen den umgekehrten Vorgang durch. Wir wandeln die Zeichenkette „jSON“ in ein assoziatives Array um;
- Zeilen 6–13 der Ergebnisse: Man sieht, dass ein assoziatives Array zurückgegeben wurde;
- Zeilen 19–25 des Codes: Wir wandeln eine Zeichenkette jSON in ein Objekt vom Typ [stdClass] um;
- Zeilen 18–25 der Ergebnisse: Man sieht, dass ein Objekt vom Typ [stdClass] abgerufen wurde;
- Zeilen 23–25 des Codes: Das Attribut A eines Objekts O wird als [O→A] bezeichnet;
Man kann mehrstufige Tabellen in jSON kodieren, wie das folgende Skript [json-02.php] zeigt:
<?php
$array = ["nom" => "séléné", "prénom" => "bénédicte", "âge" => 34,
"mari" => ["nom" => "icariù", "prénom" => "ignacio", "âge" => 35],
"enfants" => [
["prénom" => "angèle", "age" => 8],
["prénom" => "andré", "age" => 2],
]];
// Kodierung des mehrstufigen Arrays in jSON
print "encodage jSON d'un tableau à plusieurs niveaux\n";
$json = json_encode($array, JSON_UNESCAPED_UNICODE);
print "json=$json\n";
Ergebnisse
encodage jSON d'un tableau à plusieurs niveaux
json={"nom":"séléné","prénom":"bénédicte","âge":34,"mari":{"nom":"icariù","prénom":"ignacio","âge":35},"enfants":[{"prénom":"angèle","age":8},{"prénom":"andré","age":2}]}
Kommentare
In der Zeichenkette jSON:
- werden nicht-assoziative Arrays in eckige Klammern [] gesetzt;
- Assoziative Arrays werden in geschweifte Klammern {} gesetzt;
Das Skript [json-03.php] zeigt, wie die folgende Datei jSON [famille.json] verarbeitet wird:
{
"épouse": {
"nom": "séléné",
"prénom": "bénédicte",
"âge": 34
},
"mari": {
"nom": "icariù",
"prénom": "ignacio",
"âge": 35
},
"enfants": [
{
"prénom": "angèle",
"age": 8
},
{
"prénom": "andré",
"age": 2
}
]
}
Das Skript [json-03.php] lautet wie folgt:
<?php
// Einlesen der Datei jSON
$json = file_get_contents("famille.json");
// JSON-Decodierung in ein Objekt
$famille1 = json_decode($json);
print "----famille1\n";
var_dump($famille1);
// Dekodierung von JSON in ein assoziatives Array
print "----famille2\n";
$famille2 = json_decode($json, true);
var_dump($famille2);
Kommentare
- Zeile 4: Die Funktion [file_get_contents] liest den Inhalt der Datei mit dem Namen [famille.json] und speichert ihn in der Variablen [$json];
- die Variable wird anschließend in ein Objekt (Zeilen 5–8) und in ein assoziatives Array (Zeilen 9–12) dekodiert;
Ergebnisse
----famille1
object(stdClass)#2 (3) {
["épouse"]=>
object(stdClass)#1 (3) {
["nom"]=>
string(9) "séléné"
["prénom"]=>
string(11) "bénédicte"
["âge"]=>
int(34)
}
["mari"]=>
object(stdClass)#3 (3) {
["nom"]=>
string(7) "icariù"
["prénom"]=>
string(7) "ignacio"
["âge"]=>
int(35)
}
["enfants"]=>
array(2) {
[0]=>
object(stdClass)#4 (2) {
["prénom"]=>
string(7) "angèle"
["age"]=>
int(8)
}
[1]=>
object(stdClass)#5 (2) {
["prénom"]=>
string(6) "andré"
["age"]=>
int(2)
}
}
}
----famille2
array(3) {
["épouse"]=>
array(3) {
["nom"]=>
string(9) "séléné"
["prénom"]=>
string(11) "bénédicte"
["âge"]=>
int(34)
}
["mari"]=>
array(3) {
["nom"]=>
string(7) "icariù"
["prénom"]=>
string(7) "ignacio"
["âge"]=>
int(35)
}
["enfants"]=>
array(2) {
[0]=>
array(2) {
["prénom"]=>
string(7) "angèle"
["age"]=>
int(8)
}
[1]=>
array(2) {
["prénom"]=>
string(6) "andré"
["age"]=>
int(2)
}
}
}
Kommentare
- Zeilen 1–38: das Objekt, das aus der Dekodierung der Datei „jSON [famille.json]“ stammt;
- Zeilen 39–76: das assoziative Array, das aus der Dekodierung der Datei jSON [famille.json] stammt;