Skip to content

3. Die Grundlagen von PHP

3.1. Die Verzeichnisstruktur der Skripte

Die Skripte dieses Kapitels befinden sich in zwei Ordnern innerhalb des Ordners [scripts-console] des Kurscodes:

php8-oct-2026
└── scripts-console
    ├── basics
    │   ├── phpinfo.php
    │   ├── basics-01.php
    │   ├── basics-02.php
    │   ├── ...
    │   ├── basics-17.php
    │   └── info.txt
    └── json
        ├── family.json
        ├── json-01.php
        ├── json-02.php
        └── json-03.php

Dies sind „Konsolenskripte“: Sie werden in einem Terminal mit dem Befehl [php script-name.php] ausgeführt und geben ihre Ergebnisse in dasselbe Terminal aus. Webskripte, die vom Server [Apache] unter [Laragon] ausgeführt und in einem Browser angezeigt werden, folgen später.

3.2. Konfiguration von PHP

PHP wird vorkonfiguriert über eine Textdatei namens [php.ini] geliefert. Alle diese Einstellungen lassen sich programmatisch ändern. Die Konfiguration von PHP beeinflusst die Ausführung von Skripten erheblich. Es ist daher wichtig, sie zu verstehen. Das folgende Skript [phpinfo.php], ermöglicht dies:

1
2
3
4
5
6
<?php

declare(strict_types=1);

// zeigt die PHP-Konfiguration an
phpinfo();

Kommentare:

  • Zeile 3: Diese Zeile steht am Anfang aller Skripte dieses Kurses. Wir erklären sie im Abschnitt über Typumwandlungen;
  • Zeile 6: Die Funktion [phpinfo] zeigt die Konfiguration von PHP an.

Öffnen wir ein Terminal im Ordner [scripts-console/basics] und führen das Skript aus. Hier ein Auszug:

> php phpinfo.php
phpinfo()
PHP Version => 8.5.11
…
Server API => Command Line Interface
…
PHP API => 20250925
PHP Extension => 20250925
Zend Extension => 420250925
PHP Integer Size => 64 bits
Debug Build => no
Zend Memory Manager => enabled
IPv6 Support => enabled
…
display_errors => STDOUT => STDOUT
error_reporting => 30719 => 30719
memory_limit => 512M => 512M
max_execution_time => 0 => 0
…

Die Funktion [phpinfo] zeigt hier fast 1.500 Konfigurationszeilen an. Wir kommentieren sie nicht, da die meisten die fortgeschrittene Verwendung von PHP betreffen. Heben wir einige hervor:

  • [PHP Version]: die verwendete Version von PHP, hier 8.5;
  • [Server API]: wie PHP gestartet wurde. [Command Line Interface] (CLI) bezeichnet den Interpreter, der in einem Terminal läuft. Wird PHP vom Server [Apache] ausgeführt, ändert sich diese Zeile, und die Konfiguration kann eine andere sein;
  • [display_errors] und [error_reporting]: PHP zeigt alle Fehler, Warnungen und Hinweise auf veraltete Funktionen an. Der Wert 30719 entspricht ab PHP 8.4 der Konstante [E_ALL] . Dies ist die für den Kurs erforderliche Konfiguration: Eine Warnung weist fast immer auf einen Programmierfehler hin.

Eine wichtige Zeile der vollständigen Ausgabe ist die Zeile [Loaded Configuration File]: Sie gibt an, welche Datei [php.ini] zur Konfiguration des PHP verwendet wurde, das Ihre Skripte ausführt. Mit [Laragon] ist dies eine Datei wie [C:\laragon\bin\php\php-8.5.x-Win32-vs17-x64\php.ini]. Sie erhalten sie auch direkt mit dem Befehl [php --ini]. Wenn Sie die Ausführungskonfiguration von PHP ändern möchten, müssen Sie diese Datei bearbeiten ([Laragon] bietet über sein Menü im Abschnitt [PHP > php.ini] Zugriff darauf). Diese Datei enthält zahlreiche Kommentare, die den Zweck der einzelnen Einstellungen erklären.

3.3. Ein erstes Beispiel

3.3.1. Der Code

Nachfolgend ein Programm [basics-01.php], das die grundlegenden Funktionen von PHP demonstriert:

<?php

// strenge Typprüfung der Funktionsparameter und -ergebnisse
declare(strict_types=1);

// dies ist ein Kommentar
// Variable wird verwendet, ohne deklariert worden zu sein
$name = "dupont";
// eine Bildschirmausgabe
print "name=$name\n";
// ein Array mit Elementen unterschiedlicher Typen
$array = ["one", "two", 3, 4];
// seine Elementanzahl
$n = count($array);
// eine Schleife
for ($i = 0; $i < $n; $i++) {
    print "array[$i]=$array[$i]\n";
}
// Initialisierung von 2 Variablen mit dem Inhalt eines Arrays
[$string1, $string2] = ["string1", "string2"];
// Verkettung der 2 Zeichenketten
$string3 = $string1 . $string2;
// Ergebnis anzeigen
print "[$string1,$string2,$string3]\n";
// Verwendung einer Funktion
display($string1);
// der Typ einer Variablen lässt sich ermitteln
displayType("n", $n);
displayType("string1", $string1);
displayType("array", $array);
// der Typ einer Variablen kann sich während der Ausführung ändern
$n = "has changed";
displayType("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
[$res1, $res2, $res3] = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// wir hätten diese Werte auch in einem Array abrufen können
$t = f2();
for ($i = 0; $i < count($t); $i++) {
    print "t[$i]=$t[$i]\n";
}
// einige Tests
for ($i = 0; $i < count($t); $i++) {
    // zeigt nur die Zeichenketten an
    if (gettype($t[$i]) === "string") {
        print "t[$i]=$t[$i]\n";
    }
}
// Vergleichsoperatoren == und ===
if ("2" == 2) {
    print "with the == operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the == operator, the string 2 is not equal to the integer 2\n";
}
if ("2" === 2) {
    print "with the === operator, the string 2 is equal to the integer 2\n";
} else {
    print "with the === operator, the string 2 is not equal to the integer 2\n";
}
// ein Vergleich, dessen Ergebnis sich mit PHP 8 geändert hat
if (0 == "abc") {
    print "with the == operator, the integer 0 is equal to the string abc\n";
} else {
    print "with the == operator, the integer 0 is not equal to the string abc\n";
}
// weitere Tests
for ($i = 0; $i < count($t); $i++) {
    // zeigt nur die ganzen Zahlen > 10 an
    if (is_int($t[$i]) && $t[$i] > 10) {
        print "t[$i]=$t[$i]\n";
    }
}
// eine while-Schleife
$t = [8, 5, 0, -2, 3, 4];
$i = 0;
$sum = 0;
while ($i < count($t) && $t[$i] > 0) {
    print "t[$i]=$t[$i]\n";
    $sum += $t[$i];   // $sum = $sum + $t[$i]
    $i++;             // $i = $i + 1
}
print "sum=$sum\n";

// Programmende
exit;

//----------------------------------
function display(string $string): void
{
    // zeigt $string an
    print "string=$string\n";
}

//----------------------------------
function displayType(string $name, mixed $variable): void
{
    // zeigt den Typ von $variable an
    print "type[variable $" . $name . "]=" . gettype($variable) . "\n";
}

//----------------------------------
function f1(int $param): int
{
    // addiert 10 zu $param
    return $param + 10;
}

//----------------------------------
function f2(): array
{
    // gibt 3 Werte zurück
    return ["one", 0, 100];
}

Die Ergebnisse:

> php basics-01.php
name=dupont
array[0]=one
array[1]=two
array[2]=3
array[3]=4
[string1,string2,string1string2]
string=string1
type[variable $n]=integer
type[variable $string1]=string
type[variable $array]=array
type[variable $n]=string
res1=14
(res1,res2,res3)=[one,0,100]
t[0]=one
t[1]=0
t[2]=100
t[0]=one
with the == operator, the string 2 is equal to the integer 2
with the === operator, the string 2 is not equal to the integer 2
with the == operator, the integer 0 is not equal to the string abc
t[2]=100
t[0]=8
t[1]=5
sum=13

Kommentare:

  • Zeile 4: weist PHP an, die deklarierten Typen der Parameter und Funktionsrückgaben strikt zu prüfen. Wir kommen im Abschnitt über Typänderungen darauf zurück. Merken Sie sich vorerst, dass alle Skripte dieses Kurses so beginnen;
  • Zeile 8: In PHP werden Variablen nicht deklariert. Sie haben einen dynamischen Typ, der sich im Lauf der Zeit ändern kann. [$name] steht für die Variable mit dem Bezeichner [name];
  • Zeile 10: Zur Ausgabe auf dem Bildschirm können Sie die Anweisung [print] oder die Anweisung [echo] verwenden;
  • Zeile 12: Die Schreibweise [[...]] dient zur Definition eines Arrays. Die Schreibweise [$array[$i]] steht für das Element Nr. [$i] des Arrays [$array], wobei das erste Element die Nummer 0 trägt. Die ältere Schreibweise [array("one", "two", 3, 4)] wird weiterhin akzeptiert, aber wir verwenden sie nicht;
  • Zeile 14: Die Funktion [count($array)] liefert die Anzahl der Elemente des Arrays [$array] zurück;
  • Zeilen 16–18: eine Schleife. Da diese Schleife nur eine Anweisung enthält, sind die geschweiften Klammern optional. Im weiteren Verlauf dieses Dokuments verwenden wir stets geschweifte Klammern, unabhängig von der Anzahl der Anweisungen;
  • Zeile 17: Zeichenketten werden in doppelte Anführungszeichen " oder einfache Anführungszeichen ' gesetzt. In doppelten Anführungszeichen werden die Variablen [$variable] ausgewertet (man spricht auch von „Interpolation“), in einfachen nicht;
  • Zeile 20: Sie können die Elemente eines Arrays in einer einzigen Operation mehreren Variablen zuweisen. Hier gilt [$string1="string1"] und [$string2="string2"]. Diese Syntax, Destrukturierung genannt, ersetzt die Funktion [list] älterer PHP-Versionen: [list($string1, $string2) = ...] wird weiterhin akzeptiert;
  • Zeile 22: Der Operator . (Punkt) ist der Operator zur Verkettung von Zeichenketten;
  • Zeilen 91–95: Das Schlüsselwort [function] definiert eine Funktion. Eine Funktion kann an beliebiger Stelle im Skript definiert werden, auch nach ihrer Verwendung. Hier bedeutet [string $string], dass der Parameter [$string] eine Zeichenkette sein muss, und [: void] zeigt an, dass die Funktion kein Ergebnis zurückgibt. Diese Typdeklarationen sind in PHP optional, wir verwenden sie aber durchgängig: Sie dokumentieren den Code und ermöglichen es PHP (und dem Editor), Fehler zu erkennen;
  • Zeile 98: Der Typ [mixed] (PHP 8.0) bedeutet „beliebiger Typ“. Der Parameter [$variable] kann eine Ganzzahl, eine Zeichenkette, ein Array usw. aufnehmen;
  • Zeile 101: Die vordefinierte Funktion [gettype($variable)] liefert eine Zeichenkette zurück, die den Typ von [$variable] darstellt. Die Ergebnisse zeigen, dass sich dieser Typ im Lauf der Zeit ändern kann: [$n] ist zuerst eine Ganzzahl und dann eine Zeichenkette;
  • Zeile 105: Eine Funktion gibt ein Ergebnis mit der Anweisung [return] zurück. Der Typ dieses Ergebnisses wird hinter den Klammern deklariert: [: int]. Der aufrufende Code kann die Ergebnisse einer Funktion ignorieren oder abrufen;
  • Zeile 112: Eine Funktion kann mehrere Werte zurückgeben, indem sie diese in einem Array zusammenfasst;
  • Zeilen 53–62: Der Operator [===] führt einen strikten Vergleich zweier Elemente durch: Sie müssen denselben Typ und denselben Wert haben, um gleich zu sein. Der Operator [] ist weniger streng: Zwei Elemente können gleich sein, ohne denselben Typ zu haben. In diesem Fall erfolgt der Vergleich, nachdem beide Elemente in denselben Typ umgewandelt wurden. Man „übersieht“ diese impliziten Umwandlungen leicht und gelangt so zu unerwarteten Ergebnissen, etwa wenn sich eine Bedingung als wahr erweist, obwohl man sie für falsch hielt. Um diese Falle zu vermeiden, verwenden wir durchgängig den Vergleichsoperator [=] (und seine Negation [!==]);
  • Zeilen 64–68: ein Beispiel für diese impliziten Umwandlungen. In PHP 7 wurde die Zeichenkette „abc“ in die Zahl 0 umgewandelt, und der Ausdruck [0 == "abc"] war wahr! Seit PHP 8.0 wird beim Vergleich einer Zahl mit einer Zeichenkette, die keine Zahl darstellt, die Zahl in eine Zeichenkette umgewandelt, und der Ausdruck ist falsch. Das Verhalten von [] hat sich also von einer Version zur anderen geändert: ein Grund mehr, [=] den Vorzug zu geben;
  • Zeile 72: Die Funktion [is_int] liefert [true] zurück, wenn ihr Parameter eine Ganzzahl ist. Entsprechend gibt es [is_string], [is_float], [is_bool], [is_array] … Der Operator [&&] ist das logische UND. Sie können auch die logischen Operatoren [||] (ODER) und [!] (NICHT) verwenden. PHP unterstützt außerdem die Schlüsselwörter [and] und [or], doch ihre im Vergleich zur Zuweisung niedrigere Priorität kann zu unerwarteten Ergebnissen führen: Wir verwenden sie nicht;
  • Zeile 80: eine [while]-Schleife. Sie endet, sobald die Bedingung falsch ist – hier, sobald das Array durchlaufen ist oder ein negatives oder null betragendes Element gefunden wird;
  • Zeile 88: Die Anweisung [exit] beendet die Ausführung des Skripts. Die folgenden Funktionen werden an dieser Stelle nicht ausgeführt, sind aber dem gesamten Skript bekannt.

Beachten Sie, dass das Skript nicht mit dem schließenden PHP-Tag [?>] endet. Es ist nicht zwingend erforderlich. Außerdem kann es in einem Web-Kontext Probleme verursachen, wenn ihm Leerzeichen oder Zeilenumbrüche folgen, die schwer zu erkennen sind, weil sie in einem Texteditor nicht sichtbar sind. Die Empfehlung [PSR-12] legt tatsächlich fest, dass es in Dateien, die nur PHP enthalten, wegzulassen ist. Daher lassen wir es im weiteren Verlauf dieses Dokuments systematisch weg.

Hinweis: In diesem Dokument verwenden wir das Schlüsselwort [print] , um Text auf der Konsole auszugeben. Dasselbe lässt sich auch mit dem Schlüsselwort [echo] erreichen. Zwischen diesen beiden Schlüsselwörtern gibt es feine Unterschiede, die im Rahmen dieses Dokuments jedoch keine Rolle spielen. Wenn Sie also lieber [echo] verwenden, nur zu.

3.3.2. Verwendung von VS Code

Um mit den Kursskripten zu arbeiten, öffnen Sie den Ordner [php8-oct-2026] in [VS Code] (Menü [File > Open Folder]). Der Dateibaum erscheint im Explorer am linken Fensterrand. So führen Sie ein Skript aus:

  • Öffnen Sie ein integriertes Terminal (Menü [Terminal > New Terminal]). Es öffnet sich im Ordner [php8-oct-2026];
  • wechseln Sie in den Ordner des Skripts: [cd scripts-console/basics];
  • führen Sie das Skript aus: [php basics-01.php]. Die Ergebnisse werden im Terminal angezeigt. Alternativ können Sie im Datei-Explorer mit der rechten Maustaste auf den Ordner [basics] klicken und [Open in Integrated Terminal] wählen.

Wird der Befehl [php] nicht erkannt, befindet sich der PHP-Ordner nicht im Windows-PATH: [Laragon] trägt ihn dort ein, wenn Sie die entsprechende Option in seinem Menü [Tools > Path] aktivieren. Der Befehl [php -v] sollte Version 8.5 anzeigen.

Die Erweiterung [PHP Intelephense] analysiert den Code während der Eingabe und markiert Probleme durch eine Wellenlinie unter dem fehlerhaften Code. Fahren Sie mit der Maus über diese Linie, wird die Meldung angezeigt. Alle Probleme der Datei werden im Bereich [Problems] (Menü [View > Problems]) aufgelistet. Zu den nützlichen Warnungen zählen:

  • [Undefined variable]: Eine Variable wird verwendet, ohne initialisiert worden zu sein. Oft ist dies ein Tippfehler im Variablennamen;
  • [Undefined function]: Es wird eine Funktion aufgerufen, die nicht existiert; auch hier handelt es sich oft um einen Tippfehler;
  • [Expected type 'int'. Found 'string'.]: Ein aktueller Parameter hat nicht den von der Funktion deklarierten Typ. Dies ist einer der großen Vorteile von Typdeklarationen: Der Fehler wird schon vor der Ausführung gemeldet;
  • [Expected 2 arguments. Found 1.]: Die Anzahl der aktuellen Parameter entspricht nicht der Definition der Funktion.

Fährt man mit der Maus über einen Funktionsnamen, werden seine Signatur (Parameter, Typen, Rückgabewert) und seine Dokumentation angezeigt, auch für die vordefinierten Funktionen von PHP. Damit [Intelephense] die jüngsten Neuerungen der Sprache kennt, prüfen Sie die Einstellungen von [VS Code] (Menü [File > Preferences > Settings], Suche nach „intelephense php version“) und stellen Sie sicher, dass als PHP-Version 8.5 angegeben ist. Beim Erlernen der Sprache ist es ratsam, alle gemeldeten Warnungen zu beheben. Das ist eine hervorragende Lernmethode.

[Intelephense] kann eine Datei außerdem formatieren (Rechtsklick, [Format Document]) – gemäß den Codierempfehlungen von [PSR-12]. Die PSR (PHP Standard Recommendations) sind Richtlinien zur Erstellung von Standardcode, die die Interoperabilität und die Wartung von Code erleichtern, der von verschiedenen Personen geschrieben wurde. Sie werden von der [PHP-FIG] auf der Website www.php-fig.org veröffentlicht. Die Empfehlungen [PSR-1] und [PSR-12] legen die Regeln für das Schreiben von Code fest. Hier die Regeln aus [PSR-1]:

Element
Regel
Klassenkonstanten
Klassenkonstanten MÜSSEN in Großbuchstaben mit dem Zeichen _ als Trennzeichen geschrieben werden.
Beispiel: [const VAT_RATE]
Methoden
Methodennamen MÜSSEN in camelCase geschrieben werden.
Beispiel: [public function executeBatchTaxes()]
Eigenschaften
Eigenschaftsnamen SOLLTEN innerhalb einer Codebasis einheitlich als StudlyCaps, camelCase oder under_score geschrieben werden.
Beispiele: [$AnnualSalary], [$annualSalary], [$annual_salary]
Nebeneffekte
Eine Datei SOLLTE entweder neue Symbole (Klassen, Funktionen, Konstanten usw.) ohne Nebeneffekte deklarieren oder Code mit Nebeneffekten ausführen, aber NICHT beides tun.
Typen
Typnamen (Klassen, Schnittstellen usw.) MÜSSEN in StudlyCaps geschrieben werden. Jeder Typ befindet sich in einer eigenen Datei und in einem Namespace mit mindestens einer Ebene.
Beispiel: [class ScholarshipStudent]

Die Regel zu den Nebeneffekten besagt, dass eine Datei Folgendes enthalten muss:

  • entweder Deklarationen von Typen (Klassen, Schnittstellen), Funktionen oder Konstanten;
  • oder ausführbaren Code ohne Deklarationen neuer Typen.

Der Einfachheit halber befolgen die Beispiele dieses Kapitels diese Regel nicht: Jedes Skript ist eine einzelne Datei, die ihre Funktionen definiert und verwendet. Den Code auf mehrere Dateien aufzuteilen, wäre für einfache Beispiele zu umständlich. Bei der Anwendung, die den roten Faden dieses Dokuments bildet, bemühen wir uns, diese Empfehlungen so genau wie möglich einzuhalten, sobald sie mit Klassen geschrieben ist.

3.4. Gültigkeitsbereich von Variablen

3.4.1. Beispiel 1

Das Skript [basics-02.php] lautet wie folgt:

<?php

declare(strict_types=1);

// Gültigkeitsbereich von Variablen

function f1(): void
{
    // wir verwenden die globale Variable $i
    global $i;
    $i++;
    $j = 10;
    print "f1[i,j]=[$i,$j]\n";
}

function f2(): void
{
    // wir verwenden die globale Variable $i
    global $i;
    $i++;
    $j = 20;
    print "f2[i,j]=[$i,$j]\n";
}

function f3(): void
{
    // wir verwenden eine lokale Variable $i
    $i = 4;
    $j = 30;
    print "f3[i,j]=[$i,$j]\n";
}

// Tests
$i = 0;
$j = 0;  // diese beiden Variablen sind einer Funktion f nur bekannt,
// wenn sie mit der Anweisung global ausdrücklich
// deklariert, dass sie sie verwenden will
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";

Die Ergebnisse:

1
2
3
4
5
> php basics-02.php
f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[4,30]
test[i,j]=[2,0]

Kommentare:

  • Zeilen 34–35: Definieren zwei Variablen, [$i] und [$j], im Hauptprogramm. Diese Variablen sind innerhalb der Funktionen unbekannt. So ist in Zeile 12 die Variable [$j] der Funktion [f1] eine lokale Variable der Funktion [f1] und unterscheidet sich von der Variablen [$j] des Hauptprogramms;
  • Zeile 10: Eine Funktion kann über das Schlüsselwort [global] auf eine Variable namens [$variable] des Hauptprogramms zugreifen. Hier bezieht sich die Anweisung auf die globale Variable [$i] des Hauptprogramms;
  • Zeile 28: Die Funktion [f3] hat [$i] nicht als global deklariert; ihre Variable [$i] ist eine lokale Variable, die mit der des Hauptprogramms nichts zu tun hat.

Von der Verwendung von [global] wird abgeraten: Eine Funktion, die globale Variablen ändert, ist schwer zu verstehen und zu testen. Besser ist es, wenn eine Funktion ihre Daten über ihre Parameter erhält und ihre Ergebnisse über [return] zurückgibt. Genau das tun wir im folgenden Beispiel.

3.4.2. Beispiel 2

Das Skript [basics-03.php] lautet wie folgt:

<?php

declare(strict_types=1);

// der Gültigkeitsbereich einer Variablen ist global für Codeblöcke
$i = 0;
{
    $i = 4;
    $i++;
}
print "i=$i\n";

Die Ergebnisse:

> php basics-03.php
i=5

Kommentare:

In manchen Sprachen ist der Gültigkeitsbereich einer Variablen, die innerhalb geschweifter Klammern definiert wird, auf diese Klammern beschränkt: Außerhalb ist sie nicht zugänglich. Die obigen Ergebnisse zeigen, dass dies in PHP nicht der Fall ist. Die Variable [$i] , die in Zeile 8 innerhalb der geschweiften Klammern verwendet wird, ist dieselbe wie die in den Zeilen 6 und 11 außerhalb davon.

3.5. Typänderungen

Variablen in PHP haben keinen festen Typ. Der Typ kann sich zur Laufzeit abhängig vom zugewiesenen Wert ändern. Bei Operationen mit Daten verschiedener Typen führt der PHP-Interpreter implizite Umwandlungen durch, um die Operanden auf einen gemeinsamen Typ zu bringen. Sind diese impliziten Umwandlungen dem Entwickler nicht bekannt, können sie eine Quelle schwer zu entdeckender Fehler sein. Nachfolgend ein Skript [basics-04.php], das implizite und explizite Umwandlungen demonstriert. Beginnen wir mit dem ersten Teil:

<?php

// strikte Typen bei der Parameterübergabe
declare(strict_types=1);

// implizite Typänderungen
// Typ --> bool
print "Conversion to a boolean------------------------------\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);
showBool("\"0\"", "0");

function showBool(string $prefix, mixed $var): void
{
    print "(bool) $prefix : ";
    // die Umwandlung von $var in einen booleschen Wert erfolgt im folgenden Test automatisch
    if ($var) {
        print "true";
    } else {
        print "false";
    }
    print "\n";
}

Kommentare:

  • Zeile 4: Fordert die strikte Typprüfung der Parameter einer Funktion, sofern der Typ angegeben ist (und des Typs ihres Rückgabewerts). Wir erklären diese Anweisung etwas später;
  • Zeile 19: Die Funktion [showBool] soll die implizite (automatische) Umwandlung demonstrieren, die der PHP-Interpreter durchführt, wenn ein Wert beliebigen Typs in einen booleschen Wert umgewandelt werden muss (Zeile 23);
  • Zeile 19: Der Parameter [$prefix] muss vom Typ [string] sein. Der Parameter [$var] hat den Typ [mixed]: Der aktuelle Parameter kann also beliebigen Typs sein. Die Funktion [showBool] gibt keinen Wert zurück ([void]);
  • Zeile 23: In der Anweisung [if ($var)] muss der Wert von [$var] in einen booleschen Wert umgewandelt werden, damit [if] ausgewertet werden kann. Erstaunlicherweise liefert der PHP-Interpreter für jeden Wert, den man ihm übergibt, ein Ergebnis;
  • Zeilen 9–17: 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 13: der Wert [null] (kein Wert): Ergebnis [false];
    • Zeile 14: die reelle Zahl 0: Ergebnis [false];
    • Zeile 15: die Ganzzahl 0: Ergebnis [false];
    • Zeile 16: eine reelle Zahl (oder Ganzzahl) ungleich 0: Ergebnis [true];
    • Zeile 17: eine Falle: Die Zeichenkette "0" wird in [false] umgewandelt, jede andere nicht leere Zeichenkette dagegen in [true].

Dies zeigen die resultierenden Bildschirmausgaben:

Conversion to a boolean------------------------------
(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
(bool) "0" : false

Fahren wir mit dem Code des Skripts fort:

// implizite Typänderungen von string in einen numerischen Typ
// string --> number
print "Conversion string to number------------------------------\n";
showNumber("12");
showNumber("45.67");
showNumber("12abcd");
try {
    showNumber("abcd");
} catch (TypeError $error) {
    print "(abcd): error [" . $error->getMessage() . "]\n";
}

function showNumber(string $var): void
{
    $number = $var + 1;
    var_dump($number);
    print "($var): $number\n";
}

Kommentare:

  • Zeile 43: Die Funktion [showNumber] akzeptiert einen Parameter vom Typ [string] und gibt kein Ergebnis zurück ([void]);
  • Zeile 45: Dieser Parameter wird in einer arithmetischen Operation verwendet, die den PHP-Interpreter zwingt, [$var] in eine Zahl umzuwandeln:
    • Zeile 34: wandelt die Zeichenkette "12" in die Ganzzahl 12 um;
    • Zeile 35: wandelt die Zeichenkette "45.67" in die reelle Zahl 45.67 um;
    • Zeile 36: Die Zeichenkette "12abcd" beginnt mit einer Zahl. PHP verwendet diese Zahl, 12, gibt aber eine Warnung aus;
    • Zeile 38: Die Zeichenkette "abcd" enthält keine Zahlen. In PHP 7 wurde sie mit einer einfachen Warnung in 0 umgewandelt. Seit PHP 8.0 ist diese Operation nicht mehr möglich: PHP löst einen Fehler vom Typ [TypeError] aus, der, wenn er nicht abgefangen wird, das Skript beenden würde;
  • Zeilen 37–41: Die Struktur [try { ... } catch (TypeError $error) { ... }] erlaubt es, diesen Fehler abzufangen und die Ausführung fortzusetzen. [$error->getMessage()] ist die Fehlermeldung. Ausnahmen werden in einem späteren Kapitel behandelt; vorerst genügt es zu wissen, dass der Code im Block [catch] ausgeführt wird, wenn der Code im Block [try] einen Fehler vom Typ [TypeError] verursacht.

Hier die Ergebnisse der Ausführung:

Conversion string to number------------------------------
int(13)
(12): 13
float(46.67)
(45.67): 46.67

Warning: A non-numeric value encountered in .../php8-oct-2026/scripts-console/basics/basics-04.php on line 45
int(13)
(12abcd): 13
(abcd): error [Unsupported operand types: string + int]

Die Funktion [var_dump] zeigt Typ und Wert ihres Parameters an: int(13) ist die Ganzzahl 13, und float(46.67) ist die Gleitkommazahl 46.67.

Beachten Sie, dass die Anweisung [declare(strict_types=1)] nicht verhindert hat, dass die Zeichenkette "12" in eine Zahl umgewandelt wurde. Das ist ein wichtiger Punkt: Der strikte Modus gilt nur für die Übergabe von Parametern an Funktionen und für die Ergebnisse, die sie zurückgeben. Auf Umwandlungen durch Operatoren (+, ., ==…) oder durch das [if] wirkt er sich nicht aus. Das ändert er konkret:

  • ohne [declare(strict_types=1)] (sogenannter „koerzitiver“ Modus) wandelt PHP die Zeichenkette in die Ganzzahl 12 um, wenn eine Funktion ein [int] erwartet und ihr die Zeichenkette „12“ übergeben wird;
  • mit [declare(strict_types=1)] (strikter Modus) führt derselbe Aufruf zu einem Fehler vom Typ [TypeError]. Der aktuelle Parameter muss genau den erwarteten Typ haben. Es gibt eine Ausnahme: Ein [int] wird dort akzeptiert, wo ein [float] erwartet wird.

Diese Anweisung muss die erste in der Datei sein und gilt nur für Funktionsaufrufe, die in dieser Datei erfolgen. Wir verwenden sie in allen Skripten: Sie verwandelt stille Umwandlungen, die Fehlerquellen sind, in gemeldete Fehler. Ein Beispiel dazu sehen wir im Abschnitt über die Parameterübergabe.

Setzen wir den Code des Skripts mit den expliziten Typumwandlungen fort:

// explizite Typänderungen
// nach int
print "Explicit conversion to int------------------------------\n";
showInt("12.45");
showInt(67.8);
showInt(true);
showInt(null);

function showInt(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((int) $var);
}

Kommentare:

  • Zeile 58: Die Funktion [showInt] akzeptiert einen Parameter beliebigen Typs ([mixed]) und gibt kein Ergebnis zurück. Sie wandelt den Parameter [$var] in eine Ganzzahl um (Zeile 63). Um eine Variable des Typs [$var] in den Typ T umzuwandeln, schreibt man [(T) $var], wobei T einer der Typen int, bool, float, string, array oder object sein kann. Die Schreibweisen (integer), (boolean), (double) und (binary) aus älteren PHP-Versionen sind überholt: PHP 8.5 kennzeichnet sie als veraltet. Die Syntax (real) wurde dagegen bereits mit PHP 8.0 entfernt;
  • Zeile 53: wandelt die Zeichenkette "12.45" in die Ganzzahl 12 um;
  • Zeile 54: wandelt die Gleitkommazahl 67.8 in die Ganzzahl 67 um (der Nachkommaanteil geht verloren);
  • Zeile 55: wandelt den booleschen Wert [true] in die Ganzzahl 1 um (den booleschen Wert [false] in die Ganzzahl 0);
  • Zeile 56: wandelt den Wert [null] in die Ganzzahl 0 um.

Dies zeigen die Bildschirmausgaben:

1
2
3
4
5
6
7
8
9
Explicit conversion to int------------------------------
parameter: string(5) "12.45"
result of the conversion: int(12)
parameter: float(67.8)
result of the conversion: int(67)
parameter: bool(true)
result of the conversion: int(1)
parameter: NULL
result of the conversion: int(0)

Wir setzen die Analyse des Skripts mit der expliziten Umwandlung von Werten in den Typ [float] fort:

// nach float
print "Explicit conversion to float------------------------------\n";
showFloat("12.45");
showFloat(67);
showFloat(true);
showFloat(null);

function showFloat(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((float) $var);
}

Kommentare:

  • Zeile 73: Die Funktion [showFloat] nimmt einen Parameter beliebigen Typs entgegen und gibt kein Ergebnis zurück;
  • Zeile 78: Der Wert dieses Parameters wird explizit in [float] umgewandelt;
  • Zeile 68: Die Zeichenkette "12.45" wird in die reelle Zahl 12.45 umgewandelt;
  • Zeile 69: Die Ganzzahl 67 wird in die reelle Zahl 67 umgewandelt;
  • Zeile 70: Der boolesche Wert [true] wird in die reelle Zahl 1 umgewandelt (der Wert [false] in die Zahl 0);
  • Zeile 71: Der Wert [null] wird in die reelle Zahl 0 umgewandelt.

Dies zeigt die Bildschirmausgabe:

1
2
3
4
5
6
7
8
9
Explicit conversion to float------------------------------
parameter: string(5) "12.45"
result of the conversion: float(12.45)
parameter: int(67)
result of the conversion: float(67)
parameter: bool(true)
result of the conversion: float(1)
parameter: NULL
result of the conversion: float(0)

Wir schließen die Vorstellung des Skripts mit der Untersuchung der Umwandlungen in den Typ [string] ab:

// nach string
print "Explicit conversion to string------------------------------\n";
showString(5);
showString(6.7);
showString(false);
showString(null);

function showString(mixed $var): void
{
    print "parameter: ";
    var_dump($var);
    print "result of the conversion: ";
    var_dump((string) $var);
}

Kommentare:

  • Zeile 88: Die Funktion [showString] nimmt einen Parameter beliebigen Typs entgegen und gibt kein Ergebnis zurück;
  • Zeile 93: Der Parameterwert wird in den Typ [string] umgewandelt;
  • Zeile 83: Die Ganzzahl 5 wird in die Zeichenkette "5" umgewandelt;
  • Zeile 84: Die Gleitkommazahl 6.7 wird in die Zeichenkette "6.7" umgewandelt;
  • Zeile 85: Der boolesche Wert [false] wird in eine leere Zeichenkette umgewandelt;
  • Zeile 86: Der Wert [null] wird in eine leere Zeichenkette umgewandelt.

Hier die Bildschirmergebnisse:

1
2
3
4
5
6
7
8
9
Explicit conversion to string------------------------------
parameter: int(5)
result of the conversion: string(1) "5"
parameter: float(6.7)
result of the conversion: string(3) "6.7"
parameter: bool(false)
result of the conversion: string(0) ""
parameter: NULL
result of the conversion: string(0) ""

3.6. Arrays

3.6.1. Standardmäßige eindimensionale Arrays

In PHP gibt es zwei Schreibweisen für Arrays:

$array = ["one", 2, "three"];
$opposites = ["small" => "big", "beautiful" => "ugly", "expensive" => "cheap"];

Array 1 wird als Array (oder Liste) bezeichnet, Array 2 als Dictionary oder assoziatives Array, dessen Elemente als Schlüssel => Wert notiert werden. Die Schreibweise [$opposites["beautiful"]] bezeichnet den Wert, der dem Schlüssel "beautiful" zugeordnet ist. Hier ist das die Zeichenkette "ugly". Array 1 ist lediglich eine Variante des Dictionarys und könnte so geschrieben werden:

$array = [0 => "one", 1 => 2, 2 => "three"];

Damit erhalten wir [$array[2]="three"]. Letztlich gibt es nur Dictionarys. Bei einem klassischen Array mit n Elementen sind die Schlüssel die Ganzzahlen im Bereich [0,n-1].

Das Skript [basics-05.php] demonstriert Operationen zur Bearbeitung eines Arrays von Werten:

<?php

declare(strict_types=1);

// klassische Arrays
// Initialisierung
$tab1 = [0, 1, 2, 3, 4, 5];
// Durchlauf - 1
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// Durchlauf - 2
print "tab1 has " . count($tab1) . " elements\n";
foreach ($tab1 as $key => $value) {
    print "tab1[$key]=$value\n";
}
// Elemente hinzufügen
$tab1[] = $i++;
$tab1[] = $i++;
// Durchlauf - 3
print "tab1 has " . count($tab1) . " elements\n";
$i = 0;
foreach ($tab1 as $element) {
    print "tab1[$i]=$element\n";
    $i++;
}
// letztes Element entfernen
array_pop($tab1);
// Durchlauf - 4
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// erstes Element entfernen
array_shift($tab1);
// Durchlauf - 5
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// am Ende des Arrays hinzufügen
array_push($tab1, -2);
// Durchlauf - 6
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// am Anfang des Arrays hinzufügen
array_unshift($tab1, -1);
// Durchlauf - 7
print "tab1 has " . count($tab1) . " elements\n";
for ($i = 0; $i < count($tab1); $i++) {
    print "tab1[$i]=$tab1[$i]\n";
}
// erstes und letztes Element (PHP 8.5)
print "first element: " . array_first($tab1) . ", last element: " . array_last($tab1) . "\n";

Die Ergebnisse:

> php basics-05.php
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 has 8 elements
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 has 7 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 has 6 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 has 7 elements
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 has 8 elements
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2
first element: -1, last element: -2

Kommentare:

  • Zeile 15: Das Array wird mit einer [foreach]-Schleife durchlaufen. Dieses Sprachelement erlaubt es, ein Dictionary – und damit ein Array – mit zwei verschiedenen Syntaxformen zu durchlaufen: [foreach ($dictionary as $key => $value)] und [foreach ($array as $value)]. Die erste Syntax liefert bei jedem Durchlauf ein Paar (Schlüssel, Wert), die zweite nur den Wert. Der PHP-7-Kurs verwendete hier die Funktion [each], die schon damals überholt war: Sie wurde in PHP 8.0 entfernt. [foreach] ist der Standardweg, ein Array zu durchlaufen;
  • Zeile 19: Die Schreibweise [$array[] = value] fügt das Element [value] als letztes Element von [$array] hinzu. Hier ist [$i] nach der ersten Schleife [for] gleich 6: Es wird 6 hinzugefügt, dann 7;
  • Zeile 24: ein Durchlauf mit der zweiten Syntax von [foreach];
  • Zeile 29: Die Funktion [array_pop($array)] entfernt das letzte Element aus [$array];
  • Zeile 36: Die Funktion [array_shift($array)] entfernt das erste Element aus [$array]. Die verbleibenden Elemente werden ab 0 neu nummeriert;
  • Zeile 43: Die Funktion [array_push($array, value)] fügt [value] als letztes Element zu [$array] hinzu;
  • Zeile 50: Die Funktion [array_unshift($array, value)] fügt [value] als erstes Element zu [$array] hinzu;
  • Zeile 57: Die mit PHP 8.5 eingeführten Funktionen [array_first] und [array_last] liefern das erste bzw. letzte Element eines Arrays zurück (oder [null] , wenn das Array leer ist).

3.6.2. Das Dictionary oder assoziative Array

Das Skript [basics-06.php] lautet wie folgt:

<?php

declare(strict_types=1);

// Dictionaries
$spouses = ["Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => ""];
// Durchlauf - 1
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// Dictionary nach Schlüssel sortieren
ksort($spouses);
// Durchlauf - 2
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// Liste der Schlüssel des Dictionarys
$keys = array_keys($spouses);
for ($i = 0; $i < count($keys); $i++) {
    print "keys[$i]=$keys[$i]\n";
}
// Liste der Werte des Dictionarys
$values = array_values($spouses);
for ($i = 0; $i < count($values); $i++) {
    print "values[$i]=$values[$i]\n";
}
// ist ein klassisches Array eine Liste? und ein Dictionary?
print "values is a list: " . var_export(array_is_list($values), true) . "\n";
print "spouses is a list: " . var_export(array_is_list($spouses), true) . "\n";
// Suche nach einem Schlüssel
exists($spouses, "Jacques");
exists($spouses, "Lucette");
exists($spouses, "Jean");
// Standardwert, falls der Schlüssel nicht existiert: Operator ??
print "spouse of Lucette: " . ($spouses["Lucette"] ?? "unknown") . "\n";
// ein Schlüssel-Wert-Paar entfernen
unset($spouses["Jean"]);
print "Number of elements in the dictionary: " . count($spouses) . "\n";
foreach ($spouses as $key => $value) {
    print "spouses[$key]=$value\n";
}
// Ende
exit;

function exists(array $spouses, string $husband): void
{
    // prüft, ob der Schlüssel $husband im Dictionary $spouses existiert
    if (isset($spouses[$husband])) {
        print "The key [$husband] exists, associated with the value [$spouses[$husband]]\n";
    } else {
        print "The key [$husband] does not exist\n";
    }
}

Die Ergebnisse:

> php basics-06.php
Number of elements in the dictionary: 4
spouses[Pierre]=Gisèle
spouses[Paul]=Virginie
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Jacques]=Lucette
spouses[Jean]=
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle
keys[0]=Jacques
keys[1]=Jean
keys[2]=Paul
keys[3]=Pierre
values[0]=Lucette
values[1]=
values[2]=Virginie
values[3]=Gisèle
values is a list: true
spouses is a list: false
The key [Jacques] exists, associated with the value [Lucette]
The key [Lucette] does not exist
The key [Jean] exists, associated with the value []
spouse of Lucette: unknown
Number of elements in the dictionary: 3
spouses[Jacques]=Lucette
spouses[Paul]=Virginie
spouses[Pierre]=Gisèle

Kommentare:

Der obige Code wendet auf ein Dictionary an, was wir zuvor bei einem einfachen Array gesehen haben. Wir kommentieren nur die Neuerungen:

  • Zeile 13: Die Funktion [ksort] (key sort) sortiert ein Dictionary in natürlicher Schlüsselreihenfolge;
  • Zeile 19: Die Funktion [array_keys($dictionary)] liefert die Liste der Schlüssel des Dictionarys als Array zurück;
  • Zeile 24: Die Funktion [array_values($dictionary)] liefert die Liste der Werte des Dictionarys als Array zurück;
  • Zeile 29: Die Funktion [array_is_list] (PHP 8.1) liefert [true] zurück, wenn die Schlüssel des Arrays in dieser Reihenfolge 0, 1, 2 … lauten, das Array also eine Liste ist. Die Funktion [var_export] liefert die PHP-Darstellung eines Werts („true“ oder „false“);
  • Zeile 46: Die Funktion [exists] nimmt ein Array ([array]) und eine Zeichenkette ([string]) entgegen;
  • Zeile 49: Die Funktion [isset($variable)] liefert [true] zurück, wenn die Variable [$variable] existiert und nicht den Wert [null] hat; andernfalls liefert sie [false] zurück. Auf ein Array-Element angewendet, prüft sie, ob ein Schlüssel existiert. Die Funktion [array_key_exists($key, $array)] tut dasselbe, liefert aber auch dann [true] zurück, wenn der dem Schlüssel zugeordnete Wert [null] ist;
  • Zeile 36: Der Operator [??] („Null-Coalescing“) liefert seinen linken Operanden zurück, wenn dieser existiert und nicht [null] ist, andernfalls seinen rechten Operanden. Das ist eine knappe Möglichkeit, für einen fehlenden Schlüssel einen Standardwert ohne Warnung zu erhalten;
  • Zeile 38: Die Funktion [unset($variable)] löscht die Variable [$variable], die hier ein Element des Dictionarys ist.

3.6.3. Mehrdimensionale Arrays

Das Skript [basics-07.php] lautet wie folgt:

<?php

declare(strict_types=1);

// klassische mehrdimensionale Arrays
// Initialisierung
$multi = [[0, 1, 2], [10, 11, 12, 13], [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 Dictionaries
// Initialisierung
$multi = ["zero" => [0, 1, 2], "one" => [10, 11, 12, 13], "two" => [20, 21, 22, 23, 24]];
// Durchlauf
foreach ($multi as $key => $value) {
    for ($i2 = 0; $i2 < count($value); $i2++) {
        print "multi[$key][$i2]={$multi[$key][$i2]}\n";
    }
}

Ergebnisse:

> php basics-07.php
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[zero][0]=0
multi[zero][1]=1
multi[zero][2]=2
multi[one][0]=10
multi[one][1]=11
multi[one][2]=12
multi[one][3]=13
multi[two][0]=20
multi[two][1]=21
multi[two][2]=22
multi[two][3]=23
multi[two][4]=24

Kommentare:

  • Zeile 7: Die Elemente des Arrays [$multi] sind selbst Arrays;
  • Zeile 11: Innerhalb einer Zeichenkette in Anführungszeichen funktioniert die einfache Interpolation von [$multi[$i1][$i2]] nicht: PHP würde nur [$multi[$i1]] auswerten. Deshalb nehmen wir den Ausdruck aus der Zeichenkette heraus und verwenden die Verkettung;
  • Zeile 16: Das Array [$multi] wird zu einem Dictionary (Schlüssel, Wert), in dem jeder Wert ein Array ist;
  • Zeile 20: eine andere Lösung: Innerhalb einer Zeichenkette in Anführungszeichen erlaubt die Schreibweise [{$expression}] die Auswertung eines komplexen Ausdrucks. Darauf kommen wir im nächsten Abschnitt zurück.

3.7. Zeichenketten

3.7.1. Schreibweise

Das Skript [basics-08.php] lautet wie folgt:

<?php

declare(strict_types=1);

// Zeichenkettennotation
$string1 = "one";
$string2 = 'one';
print "[$string1,$string2]\n";
// zwischen einfachen Anführungszeichen werden Variablen nicht ausgewertet
print '[$string1,$string2]' . "\n";
// die Notation {$...} begrenzt den auszuwertenden Ausdruck
$person = ["name" => "dupont", "age" => 34];
print "{$person['name']} is {$person['age']} years old\n";
// eine Zeichenkette über mehrere Zeilen (Heredoc)
$text = <<<END
    name: $string1
    age: {$person['age']}
    END;
print "$text\n";

Ergebnisse:

1
2
3
4
5
6
> php basics-08.php
[one,one]
[$string1,$string2]
dupont is 34 years old
name: one
age: 34

Kommentare:

  • Zeilen 6–7: Eine Zeichenkette kann in doppelte oder einfache Anführungszeichen gesetzt werden;
  • Zeile 8: In doppelten Anführungszeichen werden Variablen ausgewertet;
  • Zeile 10: In einfachen Anführungszeichen werden sie nicht ausgewertet: Die Zeichenkette wird unverändert ausgegeben. Ebenso bezeichnet [\n] hier keinen Zeilenumbruch, daher die Verkettung mit ["\n"];
  • Zeile 13: Die Schreibweise [{$...}] erlaubt es, innerhalb einer Zeichenkette Ausdrücke auszuwerten, die komplexer sind als eine einfache Variable – hier Elemente eines Dictionarys. Die Schreibweise [${variable}] aus älteren PHP-Versionen ist seit PHP 8.2 veraltet: Sie sollte nicht verwendet werden;
  • Zeilen 15–18: Die [heredoc]-Syntax erlaubt es, eine Zeichenkette über mehrere Zeilen zu erstrecken. Die Zeichenkette beginnt nach [<<<END] und endet mit der Marke [END] (der Name ist beliebig). Variablen darin werden so ausgewertet, als stünden sie in Anführungszeichen. Ab PHP 7.3 darf die Endmarke eingerückt sein: Diese Einrückung wird dann von allen Zeilen der Zeichenkette entfernt.

3.7.2. Vergleich

Das Skript [basics-09.php] lautet wie folgt:

<?php

// strikte Einhaltung der Typen der Funktionsparameter
declare(strict_types=1);

// Vergleichsfunktion
function compareStrings(string $string1, string $string2): void
{
    // vergleicht string1 und string2
    if ($string1 === $string2) {
        print "[$string1] is equal to [$string2]\n";
    } else {
        print "[$string1] is different from [$string2]\n";
    }
}

// Tests zum Vergleich von Zeichenketten
compareStrings("abcd", "abcd");
compareStrings("", "");
compareStrings("1", "");

// Suche nach einer Teilzeichenkette (PHP 8)
$file = "taxpayersdata.txt";
print "[$file] contains [data]: " . var_export(str_contains($file, "data"), true) . "\n";
print "[$file] starts with [tax]: " . var_export(str_starts_with($file, "tax"), true) . "\n";
print "[$file] ends with [.json]: " . var_export(str_ends_with($file, ".json"), true) . "\n";
// Position einer Teilzeichenkette
print "position of [data] in [$file]: " . strpos($file, "data") . "\n";
// Länge, Großbuchstaben
print "length of [$file]: " . strlen($file) . ", in uppercase: " . strtoupper($file) . "\n";
// Achtung: strlen zählt Bytes, mb_strlen zählt Zeichen
print "strlen(\"café\")=" . strlen("café") . ", mb_strlen(\"café\")=" . mb_strlen("café") . "\n";

Ergebnisse:

> php basics-09.php
[abcd] is equal to [abcd]
[] is equal to []
[1] is different from []
[taxpayersdata.txt] contains [data]: true
[taxpayersdata.txt] starts with [tax]: true
[taxpayersdata.txt] ends with [.json]: false
position of [data] in [taxpayersdata.txt]: 9
length of [taxpayersdata.txt]: 17, in uppercase: TAXPAYERSDATA.TXT
strlen("café")=5, mb_strlen("café")=4

Kommentare:

  • Zeile 10: Wir hätten den Vergleichsoperator [] statt [=] verwenden können. Letzterer ist restriktiver, da er verlangt, dass beide Operanden denselben Typ haben. Beachten Sie, dass er hier durch den Operator [] ersetzbar gewesen wäre, da der Typ beider Parameter in der Funktionssignatur auf [string]* festgelegt ist. Wir verwenden jedoch weiterhin *[=];
  • Zeile 24: Die Funktion [str_contains($string, $substring)] (PHP 8.0) liefert [true] zurück, wenn [$substring] in [$string] enthalten ist;
  • Zeile 25: Die Funktion [str_starts_with] (PHP 8.0) prüft den Anfang einer Zeichenkette;
  • Zeile 26: Die Funktion [str_ends_with] (PHP 8.0) prüft das Ende einer Zeichenkette;
  • Zeile 28: Die Funktion [strpos($string, $substring)] liefert die Position von [$substring] in [$string] zurück, wobei das erste Zeichen die Position 0 hat, und [false] , wenn die Teilzeichenkette fehlt. Vor PHP 8 prüfte man das Vorhandensein einer Teilzeichenkette mit [strpos(...) !== false], was eine irreführende Schreibweise war, da die Position 0 in [false] umgewandelt wird: [str_contains] ist deutlich lesbarer;
  • Zeile 30: Die Funktion [strlen] liefert die Länge einer Zeichenkette zurück, und [strtoupper] wandelt sie in Großbuchstaben um;
  • Zeile 32: [strlen] zählt Bytes, nicht Zeichen. Die Dateien des Kurses sind in UTF-8 codiert, wo ein Zeichen mit Akzent zwei Bytes belegt: „café“ hat 4 Zeichen, aber 5 Bytes. Die Funktionen der Erweiterung [mbstring] (mb_strlen, mb_substr, mb_strtoupper …) arbeiten auf Zeichen.

3.7.3. Beziehungen zwischen Zeichenketten und Arrays

Das Skript [basics-10.php] lautet wie folgt:

<?php

declare(strict_types=1);

// Zeichenkette in Array
$string = "1:2:3:4";
$tab = explode(":", $string);
// Durchlauf des Arrays
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
}
// Array in Zeichenkette
$string2 = implode(":", $tab);
print "string2=$string2\n";
// fügen wir ein leeres Feld hinzu
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// Durchlauf des Arrays
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // wir haben jetzt 5 Elemente, das letzte ist leer
// fügen wir erneut ein leeres Feld hinzu
$string .= ":";
print "string=$string\n";
$tab = explode(":", $string);
// Durchlauf des Arrays
print "tab has " . count($tab) . " elements\n";
for ($i = 0; $i < count($tab); $i++) {
    print "tab[$i]=$tab[$i]\n";
} // wir haben jetzt 6 Elemente, die letzten beiden sind leer

Ergebnisse:

> php basics-10.php
tab has 4 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
string2=1:2:3:4
string=1:2:3:4:
tab has 5 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
string=1:2:3:4::
tab has 6 elements
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

Kommentare:

  • Zeile 7: Die Funktion [explode($separator, $string)] ermittelt die Felder von [$string] , die durch [$separator] getrennt sind. So ermittelt [explode(":", $string)] die Elemente von [$string]—die durch die Zeichenkette ":" getrennt sind – in Form eines Arrays;
  • Zeile 14: Die Funktion [implode($separator, $array)] führt die umgekehrte Operation der Funktion [explode] aus. Sie liefert eine Zeichenkette zurück, die aus den Elementen von [$array] besteht, getrennt durch [$separator];
  • Zeile 17: Der Operator [.=] hängt eine Zeichenkette an das Ende einer anderen an. Die Ergebnisse zeigen, dass ein leeres Feld am Ende einer Zeichenkette zu einem leeren Element im von [explode] zurückgegebenen Array führt.

3.7.4. Reguläre Ausdrücke

Das Skript [basics-11.php] lautet wie folgt:

<?php

// strikter Typ für Funktionsparameter
declare(strict_types=1);

// reguläre Ausdrücke in PHP
// die verschiedenen Felder einer Zeichenkette abrufen
// das Muster: eine Ziffernfolge, umgeben von beliebigen Zeichen
// wir wollen nur die Ziffernfolge abrufen
$pattern = "/(\d+)/";
// wir gleichen die Zeichenkette mit dem Muster ab
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// das Muster: eine Ziffernfolge, umgeben von beliebigen Zeichen
// wir wollen die Ziffernfolge sowie die Felder, die ihr folgen und vorangehen
$pattern = "/^(.*?)(\d+)(.*?)$/";
// wir gleichen die Zeichenkette mit dem Muster ab
comparePattern2String($pattern, "xyz1234abcd");
comparePattern2String($pattern, "12 34");
comparePattern2String($pattern, "abcd");

// das Muster - ein Datum im Format dd/mm/yy
$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
comparePattern2String($pattern, "10/05/97");
comparePattern2String($pattern, "  04/04/01  ");
comparePattern2String($pattern, "5/1/01");

// das Muster - eine Dezimalzahl
$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
comparePattern2String($pattern, "187.8");
comparePattern2String($pattern, "-0.6");
comparePattern2String($pattern, "4");
comparePattern2String($pattern, ".6");
comparePattern2String($pattern, "4.");
comparePattern2String($pattern, " + 4");

// Ende
exit;

// --------------------------------------------------------------------------
function comparePattern2String(string $pattern, string $string): void
{
    // vergleicht die Zeichenkette $string mit dem Muster $pattern
    // wir gleichen die Zeichenkette mit dem Muster ab
    $fields = [];
    $matches = preg_match($pattern, $string, $fields);
    // Ergebnisse anzeigen
    print "\nResults($pattern,$string)\n";
    if ($matches === 1) {
        for ($i = 0; $i < count($fields); $i++) {
            print "fields[$i]=$fields[$i]\n";
        }
    } else {
        print "The string [$string] does not match the pattern [$pattern]\n";
    }
}

Ergebnisse:

> php basics-11.php

Results(/(\d+)/,xyz1234abcd)
fields[0]=1234
fields[1]=1234

Results(/(\d+)/,12 34)
fields[0]=12
fields[1]=12

Results(/(\d+)/,abcd)
The string [abcd] does not match the pattern [/(\d+)/]

Results(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
fields[0]=xyz1234abcd
fields[1]=xyz
fields[2]=1234
fields[3]=abcd

Results(/^(.*?)(\d+)(.*?)$/,12 34)
fields[0]=12 34
fields[1]=
fields[2]=12
fields[3]= 34

Results(/^(.*?)(\d+)(.*?)$/,abcd)
The string [abcd] does not match the pattern [/^(.*?)(\d+)(.*?)$/]

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
fields[0]=10/05/97
fields[1]=10
fields[2]=05
fields[3]=97

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
fields[0]=  04/04/01
fields[1]=04
fields[2]=04
fields[3]=01

Results(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
The string [5/1/01] does not match the pattern [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
fields[0]=187.8
fields[1]=
fields[2]=187.8

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
fields[0]=-0.6
fields[1]=-
fields[2]=0.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
fields[0]=4
fields[1]=
fields[2]=4

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
fields[0]=.6
fields[1]=
fields[2]=.6

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
fields[0]=4.
fields[1]=
fields[2]=4.

Results(/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
fields[0]= + 4
fields[1]=+
fields[2]=4

Kommentare:

Hier verwenden wir reguläre Ausdrücke, um die verschiedenen Felder aus einer Zeichenkette zu extrahieren. Reguläre Ausdrücke erlauben es, die Grenzen der Funktion [explode] zu überwinden. Das Prinzip besteht darin, eine Zeichenkette mit einer anderen Zeichenkette, dem Muster, mit der Funktion [preg_match] zu vergleichen: [$matches = preg_match($pattern, $string, $fields)] (Zeile 48). Die Funktion [preg_match] liefert die Ganzzahl 1 zurück, wenn das Muster in der Zeichenkette gefunden werden kann, andernfalls 0. In diesem Fall stellt [$fields[0]] die Teilzeichenkette dar, die dem Muster entspricht. Enthält das Muster außerdem in Klammern eingeschlossene Teilmuster, so ist [$fields[1]] der Teil von [$string] , der dem ersten Teilmuster entspricht, [$fields[2]] der Teil von [$string] , der dem zweiten Teilmuster entspricht, und so weiter. Kehren wir zum Skript zurück:

  • Zeile 10: Das Muster entspricht einer Folge von einer oder mehr (+) Ziffern (\d), die an beliebiger Stelle in einer Zeichenkette vorkommt. Außerdem definiert das Muster ein in Klammern eingeschlossenes Teilmuster;
  • Zeile 12: Das Muster /(\d+)/ wird mit der Zeichenkette "xyz1234abcd." verglichen. Wir sehen, dass die Teilzeichenkette 1234 dem Muster entspricht. Daher ist [$fields[0]] gleich "1234." Außerdem hat das Muster ein in Klammern eingeschlossenes Teilmuster. Wir erhalten [$fields[1]="1234"];
  • Zeile 13: Das Muster /(\d+)/ wird mit der Zeichenkette "12 34" verglichen. Wir sehen, dass die Teilzeichenketten 12 und 34 dem Muster entsprechen. Der Vergleich endet bei der ersten Teilzeichenkette, die dem Muster entspricht. Daher gilt [$fields[0]=12] und [$fields[1]=12];
  • Zeile 14: Das Muster /(\d+)/ wird mit der Zeichenkette "abcd" verglichen. Es wird keine Übereinstimmung gefunden;
  • Zeile 51: [preg_match] liefert eine Ganzzahl zurück (und [false] , wenn das Muster fehlerhaft ist): Sie wird strikt mit 1 verglichen.

Erläutern wir die im weiteren Code verwendeten Muster:

$pattern = "/^(.*?)(\d+)(.*?)$/";

entspricht dem Anfang der Zeichenkette (^), gefolgt von null oder mehr (*) beliebigen Zeichen (.), gefolgt von einer oder mehr (+) Ziffern, gefolgt von null oder mehr (*) beliebigen Zeichen (.). Das Muster (.*) entspricht null oder mehr beliebigen Zeichen. Ein solches Muster passt auf jede Zeichenkette. Im Muster /^(.*)(\d+)(.*)$/ würde das erste Teilmuster (.*) also alle Ziffern außer der letzten aufnehmen, die dem Teilmuster (\d+) als einzige bleibt. Das Muster (.*?)(\d+) entspricht 0 oder mehr beliebigen Zeichen bis zum nächsten Teilmuster (?), hier \d+. Die Ziffern werden daher nicht mehr vom Muster (.*) erfasst. Das obige Muster entspricht somit [Anfang der Zeichenkette (^), einer Folge beliebiger Zeichen (.*?), einer Folge von einer oder mehr Ziffern (\d+), einer Folge beliebiger Zeichen (.*?), dem Ende der Zeichenkette ($)].

$pattern = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

entspricht [Anfang der Zeichenkette (^), einer Folge von 0 oder mehr Leerzeichen (\s*), 2 Ziffern (\d\d), dem Zeichen / (\/), 2 Ziffern, /, 2 Ziffern, einer Folge von 0 oder mehr Leerzeichen (\s*), dem Ende der Zeichenkette ($)].

$pattern = "/^\s*([+-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";

entspricht [Anfang der Zeichenkette (^), 0 oder mehr Leerzeichen (\s*), einem Vorzeichen + oder - ([+-]), das 0- oder 1-mal (?) vorkommt, einer Folge von 0 oder mehr Leerzeichen (\s*), 1 oder mehr Ziffern gefolgt von einem Dezimalpunkt gefolgt von null oder mehr Ziffern (\d+\.\d*) oder (|) einem Dezimalpunkt (\.) gefolgt von einer oder mehr Ziffern (\d+) oder (|) einer oder mehr Ziffern (\d+), einer Folge von 0 oder mehr Leerzeichen (\s*)]. Der PHP-7-Kurs schrieb es als [+|-]: In eckigen Klammern hat das Zeichen | keine besondere Bedeutung, und dieses Muster akzeptierte auch das Symbol | vor einer Zahl. [+-] ist die korrekte Schreibweise.

Hinweis: Der Begriff [space] bezeichnet in regulären Ausdrücken eine Menge von Zeichen: Leerzeichen, Zeilenumbruch \n, Tabulator \t, Wagenrücklauf \r, Seitenvorschub \f …

3.8. Funktionen

3.8.1. Art der Parameterübergabe

Das Skript [basics-12.php] lautet wie folgt:

<?php

// wie Parameter an eine Funktion übergeben werden
// strikte Einhaltung der Parametertypen
declare(strict_types=1);

function f(int &$i, int $j): void
{
    // $i wird als Referenz übergeben
    // $j wird als Wert übergeben
    $i++;
    $j++;
    print "f[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";

Ergebnisse:

1
2
3
> php basics-12.php
f[i,j]=[1,1]
test[i,j]=[1,0]

Kommentare:

Der obige Code demonstriert die beiden Arten, Parameter an eine Funktion zu übergeben. Betrachten wir das folgende Beispiel:

1
2
3
4
5
6
7
8
9
function f(int &$a, int $b): void
{
    …
}

// Hauptprogramm
$i = 10;
$j = 20;
f($i, $j);
  • Zeile 1: Definiert die formalen Parameter [$a] und [$b] der Funktion [f]. Diese Funktion verarbeitet diese beiden formalen Parameter;
  • Zeile 9: Ruft die Funktion [f] mit zwei aktuellen Parametern auf, [$i] und [$j]. Die Beziehungen zwischen den formalen Parametern ([$a], [$b]) und den aktuellen Parametern ([$i], [$j]) werden durch die Zeilen 1 und 9 festgelegt:
    • [&$a]: Das Symbol & zeigt an, dass der formale Parameter [$a] den Wert der Adresse des aktuellen Parameters [$i] annimmt. Mit anderen Worten: [$a] und [$i] sind zwei Referenzen auf dieselbe Speicherstelle. Die Bearbeitung des formalen Parameters [$a] ist gleichbedeutend mit der Bearbeitung des aktuellen Parameters [$i]. Dies zeigt die Ausführung des Codes. Diese Übergabeart eignet sich für Ausgabeparameter. Sie wird „Übergabe per Referenz“ genannt;
    • [$b]: Der formale Parameter [$b] nimmt den Wert des aktuellen Parameters [$j] an. Dies ist die Übergabe per Wert. Der formale und der aktuelle Parameter sind zwei verschiedene Variablen. Die Bearbeitung des formalen Parameters [$b] hat keine Auswirkung auf den aktuellen Parameter [$j]. Dies zeigt die Ausführung des Codes. Diese Übergabeart eignet sich für Eingabeparameter.

Betrachten wir die Funktion [swap], die zwei formale Parameter akzeptiert: [$a] und [$b]. Die Funktion vertauscht die Werte dieser beiden Parameter. Beim Aufruf von [swap($i, $j)] erwartet der aufrufende Code daher, dass die Werte der beiden aktuellen Parameter vertauscht werden. Es handelt sich also um Ausgabeparameter (sie werden geändert). Wir schreiben daher:

1
2
3
4
function swap(mixed &$a, mixed &$b): void
{
    [$a, $b] = [$b, $a];
}

Hinweis: Man könnte meinen, die Übergabe per Referenz eigne sich auch für große Datenmengen, Arrays und Dictionarys, um ihr Kopieren zu vermeiden. Das ist unnötig: PHP kopiert ein per Wert übergebenes Array tatsächlich nur dann, wenn die Funktion es ändert. Die Übergabe per Referenz sollte daher Ausgabeparametern vorbehalten bleiben.

Das folgende Skript [basics-13.php], zeigt weitere Beispiele:

<?php

// wie Parameter übergeben werden
// kein declare(strict_types=1) in diesem Skript: wir befinden uns im „coercive"-Modus

function f(&$i, $j)
{
    // $i wird als 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 als 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";
// wir übergeben float-Parameter an f
$a = 5.0;
$b = 6.2;
f($a, $b);
print "test[a,b]=[$a,$b]\n";
// wir übergeben float-Parameter an g
$a = 5.0;
$b = 6.0;
g($a, $b);
print "test[a,b]=[$a,$b]\n";

Kommentare:

  • Zeile 4: Anders als alle anderen Skripte dieses Kurses enthält dieses Skript nicht die Anweisung [declare(strict_types=1)]: PHP arbeitet im „koerzitiven“ Modus;
  • Zeilen 6–13: Die im vorigen Absatz besprochene Funktion [f], hier aber mit nicht typisierten Parametern;
  • Zeilen 15–22: Die Funktion [g] tut dasselbe wie die Funktion [f], aber die Typen der erwarteten Parameter sind angegeben. Sie erwartet zwei Parameter vom Typ [int]. Wir wollen sehen, was geschieht, wenn der an die Funktion übergebene aktuelle Parameter nicht den von der Funktion erwarteten Typ hat;
  • Zeilen 25–26: [$i] und [$j] sind zwei Ganzzahlen;
  • Zeile 28: Aufruf der Funktion [f] mit Parametern des erwarteten Typs;
  • Zeile 31: Aufruf der Funktion [g] mit Parametern des erwarteten Typs;
  • Zeilen 34–35: Die Variablen [$a] und [$b] haben den Typ [float];
  • Zeile 36: Aufruf der Funktion [f] mit Parametern vom Typ [float];
  • Zeilen 39–41: Aufruf der Funktion [g] mit Parametern vom Typ [float], der nicht der erwartete Typ ist.

Ergebnisse:

1
2
3
4
5
6
7
8
9
> php basics-13.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]
g[i,j]=[6,7]
test[a,b]=[6,6]
  • Die Funktion [f], deren Parameter nicht typisiert sind, hat beide Parameter vom Typ [float] akzeptiert und wie folgt verarbeitet: [$i] ist 6.0 (angezeigt als 6), und [$j] ist 7.2;
  • die Funktion [g] beide Parameter vom Typ [float] akzeptiert, sie aber in den Typ [int] umgewandelt hat. Das sieht man an der Variablen [$a], die als Referenz übergeben wurde und zur ganzen Zahl 6 geworden ist.

Die Gleitkommazahlen 5.0 und 6.0 haben keinen Nachkommaanteil: Ihre Umwandlung in ganze Zahlen führt zu keinem Informationsverlust. Was würde mit der Gleitkommazahl 5.3 geschehen? In PHP 7 wurde sie stillschweigend in die ganze Zahl 5 umgewandelt. Seit PHP 8.1 ist diese Umwandlung, bei der Information verloren geht, als veraltet (deprecated) markiert: In einer künftigen PHP-Version wird sie zu einem Fehler.

Machen wir nun dasselbe im strikten Modus. Das Skript [basics-13b.php] ist identisch mit dem Skript [basics-13.php] , beginnt jedoch mit der Anweisung:

declare(strict_types=1);

Diese Anweisung legt fest, dass die Typen der formalen Parameter eingehalten werden müssen. Andernfalls wird ein Fehler gemeldet. Die Ausführung liefert dann folgende Ergebnisse:

> php basics-13b.php
f[i,j]=[1,1]
test[i,j]=[1,0]
g[i,j]=[2,1]
test[i,j]=[2,0]
f[i,j]=[6,7.2]
test[a,b]=[6,6.2]

Fatal error: Uncaught TypeError: g(): Argument #1 ($i) must be of type int, float given, called in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 42 and defined in .../php8-oct-2026/scripts-console/basics/basics-13b.php:16
Stack trace:
#0 .../php8-oct-2026/scripts-console/basics/basics-13b.php(42): g(5.0, 6.0)
#1 {main}
  thrown in .../php8-oct-2026/scripts-console/basics/basics-13b.php on line 16

Der PHP-Interpreter hat einen Fehler vom Typ [TypeError] ausgelöst, um anzuzeigen, dass der erste an die Funktion [g] übergebene Parameter den falschen Typ hatte: g(): Argument #1 ($i) must be of type int; float was provided. Die Meldung nennt die Zeilennummer des fehlerhaften Aufrufs (42) und die der Funktionsdefinition (16). Da dieser Fehler nicht abgefangen wird (es gibt kein [try / catch]), wird das Skript beendet. Es empfiehlt sich, bei den Parametertypen möglichst strikt zu sein, um Fehler bei Funktionsaufrufen zu erkennen: Deshalb beginnen alle Skripte des Kurses mit [declare(strict_types=1)].

3.8.2. Funktionsparameter in PHP 8

PHP 8 hat die Deklaration und den Aufruf von Funktionen erheblich verbessert. Das Skript [basics-14.php] zeigt diese Neuerungen:

<?php

// Funktionsparameter in PHP 8
declare(strict_types=1);

// 1 - Parameter mit Standardwert
function greeting(string $name, string $phrase = "Hello", bool $uppercase = false): string
{
    $message = "$phrase $name";
    return $uppercase ? strtoupper($message) : $message;
}

print greeting("Pierre") . "\n";
print greeting("Pierre", "Good evening") . "\n";
// 2 - benannte Argumente (PHP 8.0): man kann einen Parameter auslassen und sie in beliebiger Reihenfolge angeben
print greeting("Pierre", uppercase: true) . "\n";
print greeting(uppercase: true, phrase: "Hi", name: "Paul") . "\n";
// vordefinierte Funktionen akzeptieren ebenfalls benannte Argumente
print str_pad(string: "7", length: 3, pad_string: "0", pad_type: STR_PAD_LEFT) . "\n";

// 3 - Union-Typ (PHP 8.0): der Parameter kann einen der aufgelisteten Typen haben
function double(int|float $number): int|float
{
    return 2 * $number;
}

var_dump(double(4));
var_dump(double(4.5));

// 4 - nullable Typ: ?string entspricht string|null
function length(?string $string): int
{
    // der Operator ?? gibt seinen rechten Operanden zurück, wenn der linke Operand null ist
    return strlen($string ?? "");
}

print "length(\"abc\")=" . length("abc") . ", length(null)=" . length(null) . "\n";

// 5 - Typ mixed (PHP 8.0) und match-Ausdruck (PHP 8.0)
function describe(mixed $value): string
{
    // match vergleicht mit === und gibt einen Wert zurück
    return match (true) {
        is_int($value), is_float($value) => "the number $value",
        is_string($value) => "the string [$value]",
        is_bool($value) => "the boolean " . ($value ? "true" : "false"),
        is_array($value) => "an array of " . count($value) . " element(s)",
        default => "a value of type " . get_debug_type($value),
    };
}

foreach ([12, 3.5, "abc", false, [1, 2], null] as $value) {
    print describe($value) . "\n";
}

// match auf einen Wert
$children = 3;
$shares = match ($children) {
    0 => 0.0,
    1, 2 => $children * 0.5,
    default => 1 + ($children - 2) * 1.0,
};
print "$children child(ren) bring $shares share(s)\n";

// 6 - variable Parameteranzahl (variadisch) und der Operator ... (Spread)
function sum(int|float ...$numbers): int|float
{
    // $numbers ist ein Array
    return array_sum($numbers);
}

print "sum()=" . sum() . "\n";
print "sum(1, 2, 3)=" . sum(1, 2, 3) . "\n";
$values = [10, 20, 30.5];
// das Array wird in tatsächliche Parameter „entpackt"
print "sum(...\$values)=" . sum(...$values) . "\n";
// der Operator ... ermöglicht auch das Zusammenführen von Arrays
$all = [0, ...$values, 40];
print "all=[" . implode(",", $all) . "]\n";

Ergebnisse:

> php basics-14.php
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
007
int(8)
float(9)
length("abc")=3, length(null)=0
the number 12
the number 3.5
the string [abc]
the boolean false
an array of 2 element(s)
a value of type null
3 child(ren) bring 2 share(s)
sum()=0
sum(1, 2, 3)=6
sum(...$values)=60.5
all=[0,10,20,30.5,40]

Kommentare:

  • Zeile 7: Die Parameter [$phrase] und [$uppercase] haben Standardwerte. Sie können beim Aufruf der Funktion weggelassen werden (Zeile 13); in diesem Fall nehmen sie ihre Standardwerte an;
  • Zeile 10: Der ternäre Operator [condition ? value1 : value2] liefert [value1] , wenn die Bedingung wahr ist, andernfalls [value2];
  • Zeile 16: benannte Argumente (PHP 8.0). Dem aktuellen Parameter wird der Name des formalen Parameters, gefolgt von einem Doppelpunkt (:), vorangestellt. So können Sie dem dritten Parameter einen Wert zuweisen, ohne den zweiten anzugeben, der seinen Standardwert behält;
  • Zeile 17: Bei benannten Argumenten spielt die Reihenfolge der Parameter keine Rolle mehr. Das verbessert die Lesbarkeit des Codes: [uppercase: true] ist aussagekräftiger als ein alleinstehendes [true];
  • Zeile 19: Auch die vordefinierten Funktionen von PHP akzeptieren benannte Argumente. Ihre Namen sind diejenigen, die in der Dokumentation auf php.net aufgeführt sind;
  • Zeile 22: Der Union-Typ [int|float] (PHP 8.0) gibt an, dass der Parameter ein [int] oder ein [float] sein kann. Dasselbe gilt für das Ergebnis;
  • Zeile 31: Der Typ [?string] ist ein Nullable-Typ: Der Parameter ist ein String oder der Wert [null]. Das ist eine Kurzschreibweise für [string|null]. Hinweis: In PHP 7 schrieb man häufig [string $string = null] , um denselben Effekt zu erzielen. Diese Schreibweise („implizit nullable“) ist seit PHP 8.4 veraltet (deprecated): Man muss [?string $string = null] schreiben;
  • Zeile 34: der Operator [??], dem wir bereits begegnet sind: Wenn [$string] gleich [null] ist, wird der leere String verwendet. Tatsächlich ist es seit PHP 8.1 veraltet (deprecated), [null] an einen nicht nullbaren Parameter einer vordefinierten Funktion zu übergeben, wie hier bei [strlen(null)];
  • Zeile 40: Der Parameter vom Typ [mixed] akzeptiert jeden beliebigen Wert, einschließlich [null];
  • Zeilen 43–49: der Ausdruck [match] (PHP 8.0). Er vergleicht den Wert in den Klammern mit den Werten links von den Pfeilen => und liefert den Wert rechts vom ersten Pfeil, bei dem der Vergleich wahr ist. Bei [match (true)] stehen links Bedingungen: Die erste wahre Bedingung hat Vorrang. Mehrere Werte können durch Kommas getrennt werden (Zeile 44). [default] deckt alle übrigen Fälle ab;
  • Zeile 48: Die Funktion [get_debug_type] (PHP 8.0) liefert den Namen des Typs eines Werts so, wie er im Code geschrieben wird: int, float, string, null oder den Klassennamen eines Objekts. [gettype] lieferte dagegen historische Namen wie integer oder double;
  • Zeilen 58–62: [match] auf einen Wert angewendet. Hier wird die Variable [$children] mit den Werten 0, dann 1 und dann 2 verglichen; andernfalls greift der Fall [default]. Anders als die Anweisung [switch], die [match] praktisch ersetzt, erfolgt der Vergleich mit [===], [match] ist ein Ausdruck, der einen Wert liefert, und man muss sich nicht um eine [break]-Anweisung kümmern. Passt kein Zweig und gibt es kein *[default]*, löst *[match] einen Fehler *[UnhandledMatchError] aus;
  • Zeile 66: [int|float ...$numbers] ist ein variadischer Parameter: Die Funktion akzeptiert beliebig viele aktuelle Parameter (auch keinen), die PHP im Array [$numbers] sammelt. Ein variadischer Parameter steht immer an letzter Stelle;
  • Zeile 76: Der Operator [...] (Spread), der in einem Aufruf vor einem Array steht, „entfaltet“ das Array: Seine Elemente werden zu den aktuellen Parametern der Funktion. [sum(...$values)] entspricht [sum(10, 20, 30.5)];
  • Zeile 78: Derselbe Operator erlaubt es, die Elemente eines Arrays in ein anderes Array einzufügen.

3.8.3. Von einer Funktion zurückgegebene Ergebnisse

Das Skript [basics-15.php] lautet wie folgt:

<?php

// Typen im strikten Modus
declare(strict_types=1);

// von einer Funktion zurückgegebene Ergebnisse
// eine Funktion kann mehrere Werte in einem Array zurückgeben
[$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";
}
// ein assoziatives Array kann ebenfalls „destrukturiert" werden
["min" => $min, "max" => $max] = minMax([4, -2, 17, 8]);
print "minMax: [min=$min,max=$max]\n";

// eine Funktion kann ein Objekt zurückgeben
$res = f2(10);
print "f2: [$res->res1,$res->res2,$res->res3]\n";
// was für ein Objekt?
print "kind of object: ";
var_dump($res);

// dasselbe machen wir mit der Funktion f3
$res = f3(10);
print "f3: [$res->res1,$res->res2,$res->res3]\n";
// was für ein Objekt?
print "kind of object: ";
var_dump($res);

// eine Funktion kann ein Objekt oder null zurückgeben
$res = f4(10);
// der Nullsafe-Operator ?-> gibt null zurück, statt einen Fehler auszulösen, wenn $res null ist
print "f4(10): res1=" . ($res?->res1 ?? "none") . "\n";
$res = f4(-10);
print "f4(-10): res1=" . ($res?->res1 ?? "none") . "\n";

// Ende
exit;

// Funktion f1
function f1(int $value): array
{
    // gibt ein Array ($value+1,$value+2,$value+3) zurück
    return [$value + 1, $value + 2, $value + 3];
}

// Funktion minMax
function minMax(array $numbers): array
{
    // gibt ein assoziatives Array zurück
    return ["min" => min($numbers), "max" => max($numbers)];
}

// Funktion f2
function f2(int $value): object
{
    // gibt ein Objekt ($value+1,$value+2,$value+3) zurück
    // durch Umwandlung eines assoziativen Arrays in ein Objekt gewonnen
    return (object) ["res1" => $value + 1, "res2" => $value + 2, "res3" => $value + 3];
}

// Funktion f3 - macht dasselbe wie die Funktion f2
function f3(int $value): object
{
    // gibt ein Objekt ($value+1,$value+2,$value+3) zurück
    $res = new stdClass();
    $res->res1 = $value + 1;
    $res->res2 = $value + 2;
    $res->res3 = $value + 3;
    // gibt das Objekt zurück
    return $res;
}

// Funktion f4 - gibt ein Objekt zurück, wenn $value positiv ist, sonst null
function f4(int $value): ?object
{
    return $value >= 0 ? f3($value) : null;
}

Ergebnisse:

> php basics-15.php
[11,12,13]
f1: res[0]=11
f1: res[1]=12
f1: res[2]=13
minMax: [min=-2,max=17]
f2: [11,12,13]
kind of object: object(stdClass)#1 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f3: [11,12,13]
kind of object: object(stdClass)#2 (3) {
  ["res1"]=>
  int(11)
  ["res2"]=>
  int(12)
  ["res3"]=>
  int(13)
}
f4(10): res1=11
f4(-10): res1=none

Kommentare:

  • Das vorige Programm zeigt, dass eine PHP-Funktion statt eines einzelnen Ergebnisses eine Menge von Ergebnissen zurückgeben kann, in Form eines Arrays oder eines Objekts. Das Konzept des Objekts wird in einem späteren Kapitel erläutert;
  • Zeilen 43–47: Die Funktion [f1] gibt mehrere Werte in Form eines Arrays zurück ([array]);
  • Zeile 8: Das zurückgegebene Array wird in drei Variablen entpackt;
  • Zeile 15: Die Destrukturierung funktioniert auch mit einem assoziativen Array: Für jede Variable wird der Schlüssel des abzurufenden Werts angegeben. Die Funktion [minMax] gibt ein Dictionary zurück (Zeile 53). Die vordefinierten Funktionen [min] und [max] liefern das kleinste bzw. größte Element eines Arrays;
  • Zeilen 57–62: Die Funktion [f2] gibt mehrere Werte in Form eines Objekts zurück ([object]). Dazu wandelt sie mit dem Operator [(object)] ein assoziatives Array in ein Objekt um: Jeder Schlüssel des Arrays wird zu einer Eigenschaft des Objekts;
  • Zeilen 65–74: Die Funktion [f3] tut dasselbe wie die Funktion [f2], erzeugt aber explizit ein Objekt vom Typ [stdClass] (Zeile 68) und fügt ihm dann Eigenschaften hinzu. Das Attribut A eines Objekts O wird als [$O->A] notiert;
  • Zeile 23: Die Funktion [var_dump] gibt Zugriff auf den Typ und den Inhalt des Objekts. In den Ergebnissen sehen wir, dass das Objekt vom Typ [stdClass] ist, dass seine Eigenschaft [res1] vom Typ Integer ist und den Wert 11 hat usw. Die auf den Typ folgende Nummer #1 oder #2 ist eine interne Objektnummer;
  • Zeile 77: Der Ergebnistyp [?object] gibt an, dass die Funktion [f4] ein Objekt oder [null] zurückgibt;
  • Zeilen 35–37: der Null-Safe-Operator [?->] (PHP 8.0). Wenn [$res] gleich [null] ist, ergibt der Ausdruck [$res?->res1] den Wert [null] , anstatt einen Fehler zu verursachen; der Operator [??] ersetzt dann [null] durch „none“. Hier würde der Operator [??] allein genügen, da er das Fehlen der Eigenschaft nicht meldet. Der Operator [?->] wird sich bei Objekten und ihren Methoden als besonders nützlich erweisen: [$client?->getAddress()?->getCity()].

Hinweis: Im PHP-7-Kurs gab es eine Funktion, die [$res->res1 = ...] schrieb, ohne das Objekt [$res] erzeugt zu haben. PHP 7 erzeugte dann standardmäßig ein [stdClass]-Objekt, begleitet von einer einfachen Warnung. Ab PHP 8.0 ist dies ein schwerwiegender Fehler (Attempt to assign property on null): Ein Objekt muss immer erzeugt werden, bevor es verwendet wird.

3.8.4. Funktionen sind auch Werte

In PHP kann eine Funktion in einer Variablen gespeichert, als Parameter an eine andere Funktion übergeben oder als Ergebnis zurückgegeben werden. Das Skript [basics-17.php] zeigt die verschiedenen Möglichkeiten, solche Funktionen zu schreiben und zu verwenden:

<?php

// Funktionen sind ebenfalls Werte
declare(strict_types=1);

$numbers = [4, -2, 17, 8, -5];

// 1 - eine anonyme Funktion, die einer Variablen zugewiesen wird
$square = function (int $x): int {
    return $x * $x;
};
print "square(5)=" . $square(5) . "\n";

// 2 - eine anonyme Funktion, die als Parameter an eine vordefinierte Funktion übergeben wird
// array_map wendet die Funktion auf jedes Element des Arrays an
$squares = array_map($square, $numbers);
print "squares=[" . implode(",", $squares) . "]\n";

// 3 - eine anonyme Funktion, die eine äußere Variable verwendet: das Schlüsselwort use
$threshold = 5;
$large = array_filter($numbers, function (int $x) use ($threshold): bool {
    return $x > $threshold;
});
print "numbers > $threshold: [" . implode(",", $large) . "]\n";

// 4 - die Pfeilfunktion (PHP 7.4): ein einziger Ausdruck, äußere Variablen werden automatisch erfasst
$positives = array_filter($numbers, fn(int $x): bool => $x >= 0);
print "positives=[" . implode(",", $positives) . "]\n";
// Sortieren mit einer Vergleichsfunktion: der Operator <=> gibt -1, 0 oder 1 zurück
$sorted = $numbers;
usort($sorted, fn(int $a, int $b): int => $b <=> $a);
print "descending sort=[" . implode(",", $sorted) . "]\n";

// 5 - Suche in einem Array (PHP 8.4)
print "first negative: " . array_find($numbers, fn(int $x): bool => $x < 0) . "\n";
print "at least one > 10: " . var_export(array_any($numbers, fn(int $x): bool => $x > 10), true) . "\n";
print "all > -10: " . var_export(array_all($numbers, fn(int $x): bool => $x > -10), true) . "\n";

// 6 - die First-Class-Callable-Syntax (PHP 8.1): functionName(...)
$uppercase = strtoupper(...);
print $uppercase("hello") . "\n";
$names = ["dupont", "durand", "martin"];
print "names=[" . implode(",", array_map(ucfirst(...), $names)) . "]\n";

// 7 - der Pipe-Operator |> (PHP 8.5): das Ergebnis links wird an die Funktion rechts übergeben
$result = "  Hello everybody out there  "
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $s): string => str_replace(" ", "-", $s));
print "result=[$result]\n";
// Äquivalent ohne den Pipe-Operator
$result = str_replace(" ", "-", strtolower(trim("  Hello everybody out there  ")));
print "result=[$result]\n";

Ergebnisse:

> php basics-17.php
square(5)=25
squares=[16,4,289,64,25]
numbers > 5: [17,8]
positives=[4,17,8]
descending sort=[17,8,4,-2,-5]
first negative: -2
at least one > 10: true
all > -10: true
HELLO
names=[Dupont,Durand,Martin]
result=[hello-everybody-out-there]
result=[hello-everybody-out-there]

Kommentare:

  • Zeilen 9–11: Eine anonyme (namenlose) Funktion wird der Variablen [$square] zugewiesen. Beachten Sie das Semikolon am Ende: Es handelt sich um eine Zuweisung;
  • Zeile 12: Die Funktion wird über die Variable aufgerufen;
  • Zeile 16: Die vordefinierte Funktion [array_map] wendet die als ersten Parameter übergebene Funktion auf jedes Element des als zweiten Parameter übergebenen Arrays an und gibt das Array der Ergebnisse zurück;
  • Zeilen 21–23: Die vordefinierte Funktion [array_filter] gibt die Elemente des Arrays zurück, für die die als zweiter Parameter übergebene Funktion [true] liefert. Eine anonyme Funktion kennt die Variablen des umgebenden Codes nicht: Das Schlüsselwort [use ($threshold)] gibt ihr Zugriff auf die Variable [$threshold]. Beachten Sie, dass [array_filter] die Schlüssel der ausgewählten Elemente beibehält; das hat hier keine Auswirkung, da [implode] nur die Werte verwendet;
  • Zeile 27: eine Pfeilfunktion (PHP 7.4): [fn(parameters) => expression]. Sie enthält nur einen Ausdruck, dessen Wert das Ergebnis der Funktion ist. Sie hat automatisch Lesezugriff auf die Variablen des umgebenden Codes: [use] ist nicht nötig. Das ist die knappste Schreibweise für kleine Funktionen, die als Parameter übergeben werden;
  • Zeile 31: Die Funktion [usort] sortiert ein Array mithilfe einer Vergleichsfunktion, die zwei Elemente [$a] und [$b] erhält und je nachdem, ob [$a] vor, auf demselben Rang wie oder nach [$b] eingeordnet werden soll, eine negative Zahl, null oder eine positive Zahl zurückgibt. Der Operator [<=>] („Spaceship“) liefert genau -1, 0 oder 1. Schreibt man [$b <=> $a] statt [$a <=> $b], erhält man eine absteigende Sortierung. Beachten Sie, dass [usort] das übergebene Array verändert (Übergabe per Referenz): Wir haben daher eine Kopie ([$sorted]) des Arrays [$numbers] sortiert;
  • Zeile 35: Die Funktionen [array_find], [array_any], und [array_all] wurden mit PHP 8.4 eingeführt. [array_find] gibt das erste Element zurück, für das die Funktion [true] liefert (oder [null] , falls es keines gibt), [array_any] gibt [true] zurück, wenn mindestens ein Element die Bedingung erfüllt, und [array_all] , wenn alle sie erfüllen;
  • Zeile 40: die First-Class-Callable-Syntax (PHP 8.1): [functionName(...)] mit drei Punkten zwischen den Klammern ruft die Funktion nicht auf, sondern gibt die Funktion selbst als [Closure]-Objekt zurück. Sie kann dann wie eine anonyme Funktion verwendet werden;
  • Zeile 43: Die vordefinierte Funktion [ucfirst] (erster Buchstabe groß) wird an [array_map] übergeben;
  • Zeilen 46–49: der Pipe-Operator [|>] (PHP 8.5). Der Ausdruck [value |> function] ruft die Funktion mit dem Wert als einzigem Parameter auf. Die Aufrufe werden von links nach rechts verkettet, in der Reihenfolge, in der sie gelesen werden: Führende und nachfolgende Leerzeichen werden mit [trim] entfernt, der Text wird mit [strtolower] in Kleinbuchstaben umgewandelt, und anschließend werden Leerzeichen durch Bindestriche ersetzt. Eine Pfeilfunktion, die mit [|>] verwendet wird, muss in Klammern stehen;
  • Zeile 52: dasselbe ohne den Pipe-Operator. Die Funktionen sind ineinander verschachtelt und werden von innen nach außen gelesen, also in umgekehrter Reihenfolge der Ausführung.

3.9. Textdateien

Das Skript [basics-16.php] lautet wie folgt:

<?php

// strikte Einhaltung der Typen der Funktionsparameter
declare(strict_types=1);

// sequenzielle Verarbeitung einer Textdatei
// sie besteht aus Zeilen der Form login:pwd:uid:gid:info:dir:shell
// jede Zeile wird in ein Dictionary der Form login => [uid, gid, info, dir, shell] übernommen
// wir legen den Dateinamen fest
$INFO = "info.txt";
// wir öffnen sie zum Erstellen
$file = fopen($INFO, "w");
if ($file === false) {
    print "Error opening the file $INFO for writing\n";
    exit;
}
// wir erzeugen beliebigen Inhalt
for ($i = 0; $i < 100; $i++) {
    fputs($file, "login$i:pwd$i:uid$i:gid$i:info$i:dir$i:shell$i\n");
}
// wir schließen die Datei
fclose($file);

// wir verarbeiten sie - fgets behält das Zeilenende-Zeichen
// so erhält man beim Lesen einer Leerzeile keine leere Zeichenkette
// wir öffnen sie zum Lesen
$file = fopen($INFO, "r");
if ($file === false) {
    print "Error opening the file $INFO for reading\n";
    exit;
}

// das Dictionary der Informationen
$dict = [];
// die Zeilen sind kürzer als 1000 Zeichen
// das Lesen einer Zeile endet am Zeilenende-Zeichen
// oder am Dateiende-Zeichen
while (($line = fgets($file, 1000)) !== false) {
    // wir entfernen das Zeilenende-Zeichen, falls vorhanden
    $line = cutNewLineChar($line);
    // wir legen die Zeile in einem Array ab
    $info = explode(":", $line);
    // wir rufen das Login ab
    $login = array_shift($info);
    // wir ignorieren das Passwort
    array_shift($info);
    // wir erzeugen einen Eintrag im Dictionary
    $dict[$login] = $info;
}
// wir schließen sie
fclose($file);

// Verwendung des Dictionarys
displayInfo($dict, "login10");
displayInfo($dict, "X");

// eine andere Möglichkeit, eine Textdatei zu lesen: die Funktion file
$lines = file($INFO, FILE_IGNORE_NEW_LINES);
print "the file $INFO has " . count($lines) . " lines, the last one is [" . array_last($lines) . "]\n";

// Ende
exit;

// --------------------------------------------------------------------------
function displayInfo(array $dict, string $key): void
{
    // zeigt den dem Schlüssel zugeordneten Wert im Dictionary $dict an, falls er existiert
    if (isset($dict[$key])) {
        // Wert existiert - ist es ein Array?
        $value = $dict[$key];
        if (is_array($value)) {
            print "[$key," . implode(":", $value) . "]\n";
        } else {
            // $value ist kein Array
            print "[$key,$value]\n";
        }
    } else {
        // $key ist kein Schlüssel des Dictionarys $dict
        print "the key [$key] does not exist\n";
    }
}

// --------------------------------------------------------------------------
function cutNewLineChar(string $line): string
{
    // wir entfernen das Zeilenende-Zeichen aus $line, falls vorhanden
    // (\n unter Unix, \r\n unter Windows)
    return rtrim($line, "\r\n");
}

Die vom Skript erzeugte Datei [info.txt]:

1
2
3
4
5
6
login0:pwd0:uid0:gid0:info0:dir0:shell0
login1:pwd1:uid1:gid1:info1:dir1:shell1
login2:pwd2:uid2:gid2:info2:dir2:shell2
…
login98:pwd98:uid98:gid98:info98:dir98:shell98
login99:pwd99:uid99:gid99:info99:dir99:shell99

Die Ergebnisse:

1
2
3
4
> php basics-16.php
[login10,uid10:gid10:info10:dir10:shell10]
the key [X] does not exist
the file info.txt has 100 lines, the last one is [login99:pwd99:uid99:gid99:info99:dir99:shell99]

Kommentare:

  • Zeile 12: [fopen(file_name, "w")] öffnet die Datei [file_name] im Schreibmodus (w=write). Existiert die Datei nicht, wird sie angelegt. Existiert sie, wird ihr Inhalt gelöscht. Die Datei wird im aktuellen Verzeichnis angelegt, also in dem, aus dem das Skript gestartet wurde. Schlägt das Anlegen fehl, gibt [fopen] eine Warnung aus und liefert den Wert [false];
  • Zeile 13: Das Ergebnis von [fopen] wird getestet, indem es streng mit [false] verglichen wird;
  • Zeile 19: [fputs($file, $string)] schreibt [$string] in die Datei [$file]. Hier endet der String mit dem Zeilenendezeichen [\n];
  • Zeile 22: [fclose($file)] schließt die Datei [$file];
  • Zeile 27: [fopen(file_name, "r")] öffnet die Datei [file_name] im Lesemodus (r=read). Schlägt das Öffnen der Datei fehl (zum Beispiel, weil die Datei nicht existiert), liefert [fopen] den Wert [false];
  • Zeile 34: Das Dictionary wird leer initialisiert, bevor es gefüllt wird. PHP würde das Array bei der ersten Zuweisung von [$dict[$login] = ...] selbst anlegen; wäre die Datei aber leer, würde die Variable nicht existieren, und ihre Verwendung würde eine Warnung auslösen;
  • Zeile 38: [fgets($file, 1000)] liest die nächste Zeile der Datei, begrenzt auf 1.000 Zeichen. Die Operation [while (($line = fgets($file, 1000)) !== false) {...}] besteht aus zwei aufeinanderfolgenden Operationen: 1) [$line = fgets(...)] und 2) [while ($line !== false)]. Nachdem das letzte Zeichen der Datei gelesen wurde, liefert die Funktion [fgets] den Wert [false], und die Schleife [while] endet. Hier versucht die Funktion [fgets] , bis zu 1.000 Zeichen zu lesen, hält aber an, sobald sie ein Zeilenendezeichen findet. Da alle Zeilen hier weniger als 1.000 Zeichen haben, liest [fgets] eine Textzeile einschließlich des Zeilenendezeichens. Der PHP-7-Kurs schrieb [while ($line = fgets($file, 1000))]: Die Schleife wäre bei einer letzten Zeile, die nur aus „0“ ohne Zeilenendezeichen besteht, vorzeitig beendet worden, weil der String „0“ in [false] umgewandelt wird. Der strikte Vergleich [!== false] vermeidet diese Falle;
  • Zeile 40: Die Funktion [cutNewLineChar] entfernt etwaige Zeilenendezeichen;
  • Zeile 44: Die Funktion [array_shift($array)] entfernt das erste Element von [$array] und gibt es als Ergebnis zurück;
  • Zeile 46: Hier ignorieren wir das von [array_shift] zurückgegebene Ergebnis;
  • Zeile 58: eine weitere Möglichkeit, eine Textdatei zu lesen. Die Funktion [file] gibt ein Array zurück, das alle Zeilen der Datei enthält. Mit der Option [FILE_IGNORE_NEW_LINES] werden die Zeilenendezeichen entfernt. Das ist einfacher als die Schleife mit [fgets], aber die gesamte Datei wird in den Speicher geladen: Bei einer sehr großen Datei ist das zeilenweise Lesen weiterhin vorzuziehen;
  • Zeile 71: Die Funktion [is_array($variable)] liefert [true], wenn [$variable] ein Array ist, andernfalls [false];
  • Zeile 84: Das Zeilenendezeichen ist auf Windows-Systemen der String „\r\n“ und auf Unix-Systemen „\n“. Die Funktion [rtrim($string, $characters)] entfernt alle in [$characters] enthaltenen Zeichen – hier \r und \n – vom Ende von [$string]. Ohne zweiten Parameter entfernt [rtrim] alle „Leerzeichen“ (Whitespace, Tabulatoren, Zeilenumbrüche usw.); die Funktion [trim] tut dasselbe an beiden Enden des Strings.

3.10. JSON codieren und decodieren

Der Ordner [scripts-console/json] enthält die Skripte dieses Abschnitts:

1
2
3
4
5
json
├── family.json
├── json-01.php
├── json-02.php
└── json-03.php

Die JSON-Codierung und -Decodierung (JavaScript Object Notation) werden wir in der Übung, die den roten Faden dieses Dokuments bildet, intensiv nutzen. Die Skripte [json-01.php, json-02.php, json-03.php] erklären, was Sie für den Rest des Dokuments wissen müssen.

Das Skript [json-01.php] lautet wie folgt:

<?php

declare(strict_types=1);

$array1 = ["lastName" => "séléné", "firstName" => "bénédicte", "age" => 34];
// JSON-Kodierung des Arrays array1 mit maskierten Unicode-Zeichen
print "JSON encoding of the array array1 with escaped Unicode characters\n";
$json1 = json_encode($array1);
print "json1=$json1\n";
// JSON-Kodierung des Arrays array1 mit nicht maskierten Unicode-Zeichen
print "JSON encoding of the array array1 with unescaped Unicode characters\n";
$json2 = json_encode($array1, JSON_UNESCAPED_UNICODE);
print "json2=$json2\n";
// JSON-Dekodierung in ein assoziatives Array
print "JSON decoding of json2 into an associative array\n";
$array2 = json_decode($json2, true);
var_dump($array2);
foreach ($array2 as $key => $value) {
    print "$key:$value\n";
}
// JSON-Dekodierung in ein Objekt
print "JSON decoding of json2 into a stdClass object\n";
$object2 = json_decode($json2);
var_dump($object2);
print "firstName=$object2->firstName\n";
print "lastName=$object2->lastName\n";
print "age=$object2->age\n";

Ergebnisse:

> php json-01.php
JSON encoding of the array array1 with escaped Unicode characters
json1={"lastName":"s\u00e9l\u00e9n\u00e9","firstName":"b\u00e9n\u00e9dicte","age":34}
JSON encoding of the array array1 with unescaped Unicode characters
json2={"lastName":"séléné","firstName":"bénédicte","age":34}
JSON decoding of json2 into an associative array
array(3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
lastName:séléné
firstName:bénédicte
age:34
JSON decoding of json2 into a stdClass object
object(stdClass)#1 (3) {
  ["lastName"]=>
  string(9) "séléné"
  ["firstName"]=>
  string(11) "bénédicte"
  ["age"]=>
  int(34)
}
firstName=bénédicte
lastName=séléné
age=34

Kommentare:

  • Zeile 8: Die Funktion [json_encode] wandelt ihren Parameter in den JSON-String um. Im resultierenden String wurde das akzentuierte Zeichen é durch seinen Unicode-Code ersetzt, der mit \u beginnt;
  • Zeile 12: Wir wiederholen denselben Vorgang, diesmal mit der Angabe, dass die Unicode-Zeichen unverändert erhalten bleiben sollen. Der resultierende JSON-String ist deutlich lesbarer;
  • Zeilen 16–20: Wir führen die umgekehrte Operation durch. Wir wandeln den JSON-String in ein assoziatives Array um: Dafür sorgt der zweite Parameter [true], von [json_decode]. Die Ergebnisse zeigen, dass wir tatsächlich ein assoziatives Array erhalten haben;
  • Zeilen 23–27: Ohne den Parameter [true] wandelt [json_decode] den JSON-String in ein Objekt vom Typ [stdClass] um. Das Attribut A eines Objekts O wird als [$O->A] notiert.

Mehrstufige Arrays lassen sich als JSON codieren, wie das folgende Skript [json-02.php] zeigt:

<?php

declare(strict_types=1);

$array = [
    "lastName" => "séléné", "firstName" => "bénédicte", "age" => 34,
    "husband" => ["lastName" => "icariù", "firstName" => "ignacio", "age" => 35],
    "children" => [
        ["firstName" => "angèle", "age" => 8],
        ["firstName" => "andré", "age" => 2],
    ],
];
// JSON-Kodierung des mehrstufigen Arrays
print "JSON encoding of a multi-level array\n";
$json = json_encode($array, JSON_UNESCAPED_UNICODE);
print "json=$json\n";
// dieselbe Kodierung, lesbar dargestellt
print "JSON encoding with the JSON_PRETTY_PRINT option\n";
print json_encode($array["husband"], JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT) . "\n";

Ergebnisse:

1
2
3
4
5
6
7
8
9
> php json-02.php
JSON encoding of a multi-level array
json={"lastName":"séléné","firstName":"bénédicte","age":34,"husband":{"lastName":"icariù","firstName":"ignacio","age":35},"children":[{"firstName":"angèle","age":8},{"firstName":"andré","age":2}]}
JSON encoding with the JSON_PRETTY_PRINT option
{
    "lastName": "icariù",
    "firstName": "ignacio",
    "age": 35
}

Kommentare:

Im JSON-String gilt:

  • nicht assoziative Arrays (Listen) stehen in eckigen Klammern [] ;
  • assoziative Arrays stehen in geschweiften Klammern {} .

Zeile 19: Die Optionen von [json_encode] werden mit dem Operator | (binäres ODER) kombiniert. Die Option [JSON_PRETTY_PRINT] erzeugt einen über mehrere Zeilen eingerückten JSON-String, der besser lesbar ist.

Das Skript [json-03.php] zeigt, wie die folgende JSON-Datei [family.json] verarbeitet wird:

{
    "wife": {
        "lastName": "séléné",
        "firstName": "bénédicte",
        "age": 34
    },
    "husband": {
        "lastName": "icariù",
        "firstName": "ignacio",
        "age": 35
    },
    "children": [
        {
            "firstName": "angèle",
            "age": 8
        },
        {
            "firstName": "andré",
            "age": 2
        }
    ]
}

Das Skript [json-03.php] lautet wie folgt:

<?php

declare(strict_types=1);

// Lesen der JSON-Datei
$json = file_get_contents("family.json");
// ist der gelesene Inhalt gültiges JSON? (PHP 8.3)
if ($json === false || !json_validate($json)) {
    print "The file [family.json] is missing or does not contain valid JSON\n";
    exit;
}
// JSON-Dekodierung in ein Objekt
$family1 = json_decode($json);
print "----family1\n";
var_dump($family1);
// JSON-Dekodierung in ein assoziatives Array
print "----family2\n";
$family2 = json_decode($json, true);
var_dump($family2);

Kommentare:

  • Zeile 6: Die Funktion [file_get_contents] liest den Inhalt der Datei mit dem Namen [family.json] und speichert ihn in der Variablen [$json]. Sie gibt [false] zurück, wenn der Lesevorgang fehlschlägt;
  • Zeile 8: Die Funktion [json_validate] (PHP 8.3) liefert [true] , wenn der als Parameter übergebene String gültiges JSON ist. Früher musste man den String decodieren und anschließend die Funktion [json_last_error] aufrufen;
  • Zeilen 13–19: Der String wird anschließend in ein Objekt und dann in ein assoziatives Array decodiert.

Ergebnisse:

> php json-03.php
----family1
object(stdClass)#2 (3) {
  ["wife"]=>
  object(stdClass)#1 (3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  object(stdClass)#3 (3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    object(stdClass)#4 (2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    object(stdClass)#5 (2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
----family2
array(3) {
  ["wife"]=>
  array(3) {
    ["lastName"]=>
    string(9) "séléné"
    ["firstName"]=>
    string(11) "bénédicte"
    ["age"]=>
    int(34)
  }
  ["husband"]=>
  array(3) {
    ["lastName"]=>
    string(7) "icariù"
    ["firstName"]=>
    string(7) "ignacio"
    ["age"]=>
    int(35)
  }
  ["children"]=>
  array(2) {
    [0]=>
    array(2) {
      ["firstName"]=>
      string(7) "angèle"
      ["age"]=>
      int(8)
    }
    [1]=>
    array(2) {
      ["firstName"]=>
      string(6) "andré"
      ["age"]=>
      int(2)
    }
  }
}
  • Der erste Teil der Ergebnisse zeigt das Objekt, das aus der Decodierung der JSON-Datei [family.json] hervorgeht: Die JSON-Objekte sind zu [stdClass]-Objekten geworden, und die JSON-Liste der Kinder ist zu einem PHP-Array geworden;
  • der zweite Teil zeigt das assoziative Array, das aus derselben Decodierung hervorgeht: Alle JSON-Objekte sind zu assoziativen Arrays geworden.