3. Die Grundlagen von PHP
3.1. Ein erstes Beispiel
Im Folgenden finden Sie ein Programm, das die ersten Funktionen von PHP veranschaulicht.
3.1.1. Das Programm (exemple_01)
<?php
// Dies ist ein Kommentar
// Variable wird verwendet, ohne deklariert worden zu sein
$nom = "dupont";
// eine Bildschirmausgabe
print "nom=$nom\n";
// ein Array mit Elementen unterschiedlichen Typs
$tableau = array("un", "deux", 3, 4);
// die Anzahl der Elemente
$n = count($tableau);
// eine Schleife
for ($i = 0; $i < $n; $i++)
print "tableau[$i]=$tableau[$i]\n";
// Initialisierung von 2 Variablen mit dem Inhalt eines Arrays
list($chaine1, $chaine2) = array("chaine1", "chaine2");
// Verkettung der beiden Zeichenfolgen
$chaine3 = $chaine1 . $chaine2;
// Anzeige des Ergebnisses
print "[$chaine1,$chaine2,$chaine3]\n";
// Verwendung einer Funktion
affiche($chaine1);
// Der Typ einer Variablen kann bekannt sein
afficheType($n);
afficheType($chaine1);
afficheType($tableau);
// Der Typ einer Variablen kann sich während der Ausführung ändern
$n = "a changé";
afficheType($n);
// Eine Funktion kann ein Ergebnis zurückgeben
$res1 = f1(4);
print "res1=$res1\n";
// Eine Funktion kann ein Array von Werten zurückgeben
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// Man hätte diese Werte in einem Array abrufen können
$t = f2();
for ($i = 0; $i < count($t); $i++)
print "t[$i]=$t[$i]\n";
// Tests
for ($i = 0; $i < count($t); $i++)
// zeigt nur die Kanäle
if (getType($t[$i]) == "string")
print "t[$i]=$t[$i]\n";
// weitere Tests
for ($i = 0; $i < count($t); $i++){
// zeigt nur ganze Zahlen >10 an
if (getType($t[$i]) == "integer" and $t[$i] > 10)
print "t[$i]=$t[$i]\n";
}
// eine while-Schleife
$t = array(8, 5, 0, -2, 3, 4);
$i = 0;
$somme = 0;
while ($i < count($t) and $t[$i] > 0) {
print "t[$i]=$t[$i]\n";
$somme+=$t[$i]; //$somme=$somme+$t[$i]
$i++; //$i=$i+1
}
print "somme=$somme\n";
// Programmende
exit;
//----------------------------------
function affiche($chaine) {
// zeigt $chaine an
print "chaine=$chaine\n";
}
//----------------------------------
function afficheType($variable) {
// zeigt den Typ von $variable an
print "type[$variable]=" . getType($variable) . "\n";
}
//----------------------------------
function f1($param) {
// addiert 10 zu $param
return $param + 10;
}
//----------------------------------
function f2() {
// gibt 3 Werte zurück
return array("un", 0, 100);
}
?>
Die Ergebnisse:
Anmerkungen
- Zeile 5: In PHP wird der Typ der Variablen nicht deklariert. Diese haben einen dynamischen Typ, der sich im Laufe der Zeit ändern kann
- $nom steht für die Variable mit der Kennung nom
- Zeile 8: Um etwas auf den Bildschirm zu schreiben, kann man die Anweisung print oder die Anweisung echo verwenden
- Zeile 11: Mit dem Schlüsselwort array lässt sich ein Array definieren. Die Variable $nom[$i] steht für das Element $i des Arrays $tableau.
- Zeile 14: Die Funktion count($tableau) gibt die Anzahl der Elemente des Arrays $tableau zurück
- Zeile 18: Zeichenfolgen werden in Anführungszeichen „“ oder Apostrophe ' gesetzt. Innerhalb von Anführungszeichen werden die Variablen $variable ausgewertet, innerhalb von Apostrophen jedoch nicht.
- Zeile 21: Mit der Funktion list können Variablen in einer Liste zusammengefasst und ihnen mit einem einzigen Zuweisungsvorgang ein Wert zugewiesen werden. Hier gilt $chaine1="Zeichenfolge1" und $chaine2="Zeichenfolge2".
- Zeile 24: Der Operator „.“ ist der Operator zur Verkettung von Zeichenketten.
- Zeile 88: Das Schlüsselwort function definiert eine Funktion. Ob eine Funktion Werte zurückgibt oder nicht, wird durch die Anweisung return festgelegt. Der aufrufende Code kann die Ergebnisse einer Funktion ignorieren oder abrufen. Eine Funktion kann an beliebiger Stelle im Code definiert werden.
- Zeile 90: Die vordefinierte Funktion getType($variable) gibt eine Zeichenkette zurück, die den Typ von $variable darstellt. Dieser Typ kann sich im Laufe der Zeit ändern.
- Zeile 79: Die vordefinierte Funktion exit beendet das Skript.
3.2. Der Gültigkeitsbereich der Variablen
3.2.1. Programm 1 (exemple_02)
<?php
// Gültigkeitsbereich der Variablen
function f1() {
// Es wird die globale Variable $i verwendet
$i = &$GLOBALS["i"];
$i++;
$j = 10;
print "f1[i,j]=[$i,$j]\n";
}
function f2() {
// Es wird die globale Variable $i verwendet
$i = &$GLOBALS["i"];
$i++;
$j = 20;
print "f2[i,j]=[$i,$j]\n";
}
function f3() {
// Es wird eine lokale Variable $i verwendet
$i = 4;
$j = 30;
print "f3[i,j]=[$i,$j]\n";
}
// Tests
$i = 0;
$j = 0; // Diese beiden Variablen sind einer Funktion f über das Array $GLOBALS bekannt
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
?>
Die Ergebnisse:
Kommentare
- Zeilen 29–30: Definieren die beiden Variablen $i und $j des Hauptprogramms. Diese Variablen sind innerhalb der Funktionen nicht bekannt. So ist beispielsweise in Zeile 9 die Variable $j der Funktion f1 eine lokale Variable der Funktion f1 und unterscheidet sich von der Variable $j des Hauptprogramms. Eine Funktion kann über ein Array globaler Variablen namens $GLOBALS auf eine Variable $variable des Hauptprogramms zugreifen. In Zeile 7 bezeichnet die Schreibweise $GLOBALS["i"] die globale Variable $i des Hauptprogramms. Wenn wir schreiben
Einer lokalen Variablen $i wird der Wert der globalen Variablen $i zugewiesen. Es handelt sich hierbei um zwei verschiedene Variablen, und eine Änderung der lokalen Variablen $i hat keine Auswirkungen auf die globale Variable $i. Die Schreibweise
bedeutet, dass die lokale Variable $i dieselbe Speicheradresse hat wie die globale Variable $i. Eine Änderung an der lokalen Variable $i entspricht somit einer Änderung an der globalen Variable $i.
3.2.2. Programm 2 (exemple_03)
<?php
// Der Geltungsbereich einer Variablen erstreckt sich über alle Codeblöcke
$i = 0; {
$i = 4;
$i++;
}
print "i=$i\n";
?>
Die Ergebnisse:
Kommentare
In manchen Programmiersprachen hat eine innerhalb von geschweiften Klammern definierte Variable den Geltungsbereich dieser Klammern: Außerhalb dieser Klammern ist sie nicht bekannt. Die obigen Ergebnisse zeigen, dass dies in PHP nicht der Fall ist. Die in Zeile 5 innerhalb der geschweiften Klammern definierte Variable $i ist dieselbe wie die in den Zeilen 4 und 8 außerhalb der geschweiften Klammern verwendete.
3.3. Die Tabellen
3.3.1. Klassische eindimensionale Arrays (exemple_04)
<?php
// klassische Arrays
// Initialisierung
$tab1 = array(0, 1, 2, 3, 4, 5);
// Durchlauf – 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// Durchlauf – 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1))
print "tab1[$clé]=$valeur\n";
// Hinzufügen von Elementen
$tab1[] = $i++;
$tab1[] = $i++;
// Durchlauf – 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
print "tab1[$i]=$élément\n";
$i++;
}
// Letztes Element löschen
array_pop($tab1);
// Durchlauf – 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// erstes Element löschen
array_shift($tab1);
// Durchlauf – 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// am Ende der Tabelle hinzufügen
array_push($tab1, -2);
// Durchlauf – 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// Hinzufügen am Anfang des Arrays
array_unshift($tab1, -1);
// Durchlauf – 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
?>
Die Ergebnisse:
Kommentare
Das obige Programm zeigt Operationen zur Bearbeitung eines Wert-Arrays. In PHP gibt es zwei Notationen für Arrays:
Das Array 1 wird als Array bezeichnet, das Array 2 als Dictionary, bei dem die Elemente als Schlüssel => Wert notiert werden. Die Notation $contraires["beau"] bezeichnet den Wert, der dem Schlüssel „schön“ zugeordnet ist. Hier ist dies also die Zeichenkette „hässlich“. Das Array 1 ist lediglich eine Variante des Wörterbuchs und könnte wie folgt notiert werden:
So ergibt sich $tableau[2] = „drei“. Letztendlich gibt es nur Wörterbücher. Bei einem klassischen Array mit n Elementen sind die Schlüssel die ganzen Zahlen aus dem Intervall [0,n-1].
- Zeile 15: Mit der Funktion each($tableau) lässt sich ein Wörterbuch durchlaufen. Bei jedem Aufruf gibt sie ein (Schlüssel, Wert)-Paar daraus zurück.
- Zeile 14: Die Funktion reset($dictionnaire) setzt die Funktion each auf das erste (Schlüssel, Wert)-Paar des Wörterbuchs.
- Zeile 15: Die Schleife while endet, wenn die Funktion each am Ende des Wörterbuchs ein leeres Paar zurückgibt.
- Zeile 19: Die Schreibweise $tableau[]=Wert fügt das Element valeur als letztes Element von $tableau hinzu.
- Zeile 25: Das Array wird mit einem foreach durchlaufen. Dieses Syntaxelement ermöglicht es, ein Wörterbuch – also ein Array – nach zwei Syntaxen zu durchlaufen:
Die erste Syntax liefert bei jeder Iteration ein Paar (clé,valeur), während die zweite Syntax nur das Element valeur aus dem Wörterbuch zurückgibt.
- Zeile 31: Die Funktion array_pop($tableau) entfernt das letzte Element aus $tableau
- Zeile 39: Die Funktion array_shift($tableau) entfernt das erste Element aus $tableau
- Zeile 47: Die Funktion array_push($tableau,Wert) fügt valeur als letztes Element von $tableau hinzu
- Zeile 39: Die Funktion array_unshift($tableau,Wert) fügt valeur als erstes Element von $tableau hinzu
3.3.2. Das Wörterbuch (exemple_05)
<?php
// Wörterbücher
$conjoints = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");
// Durchlauf – 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
print "conjoints[$clé]=$valeur\n";
// Sortierung des Wörterbuchs nach dem Schlüssel
ksort($conjoints);
// Durchlauf – 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
print "conjoints[$clé]=$valeur\n";
// Liste der Schlüssel des Wörterbuchs
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++)
print "clés[$i]=$clés[$i]\n";
// Liste der Werte des Wörterbuchs
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++)
print "valeurs[$i]=$valeurs[$i]\n";
// Suche nach einem Schlüssel
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");
// Löschen eines Schlüssel-Wert-Paares
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
print "conjoints[$clé]=$valeur\n";
}
// Ende
exit;
function existe($conjoints, $mari) {
// Prüft, ob der Schlüssel $mari im Wörterbuch $conjoints vorhanden ist
if (isset($conjoints[$mari]))
print "La clé [$mari] existe associée à la valeur [$conjoints[$mari]]\n";
else
print "La clé [$mari] n'existe pas\n";
}
?>
Die Ergebnisse:
Anmerkungen
Der obige Code wendet das zuvor für ein einfaches Array Gesehene auf ein Wörterbuch an. Wir gehen hier nur auf die Neuerungen ein:
- Zeile 13: Mit der Funktion „ksort“ (Key Sort) lässt sich ein Wörterbuch in der natürlichen Reihenfolge der Schlüssel sortieren.
- Zeile 21: Die Funktion array_keys($dictionnaire) gibt die Liste der Schlüssel des Wörterbuchs in Form einer Tabelle aus
- Zeile 26: Die Funktion array_values($dictionnaire) gibt die Liste der Werte des Wörterbuchs als Tabelle aus
- Zeile 47: Die Funktion isset($variable) gibt „true“ zurück, wenn die Variable $variable definiert wurde, andernfalls „false“.
- Zeile 36: Die Funktion unset($variable) löscht die Variable $variable.
3.3.3. Mehrdimensionale Arrays (exemple_06)
<?php
// klassische mehrdimensionale Tabellen
// Initialisierung
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// Durchlauf
for ($i1 = 0; $i1 < count($multi); $i1++)
for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
// mehrdimensionale Wörterbücher
// Initialisierung
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// Durchlauf
foreach ($multi as $clé => $valeur)
for ($i2 = 0; $i2 < count($valeur); $i2++)
print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
?>
Ergebnisse:
Anmerkungen
- Zeile 5: Die Elemente des Arrays $multi sind selbst Arrays
- Zeile 12: Das Array $multi wird zu einem Wörterbuch (clé,valeur), in dem jedes valeur ein Array ist
3.3.4. Verknüpfungen zwischen Zeichenketten und Arrays (exemple_07)
<?php
// Zeichenkette in Array
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);
// Durchlauf durch ein Array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n";
// Array in Zeichenkette
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";
// Fügen wir ein leeres Feld hinzu
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// Durchlauf durch das Array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n"; // Wir haben nun 5 Elemente, wobei das letzte leer ist
// Fügen wir erneut ein leeres Feld hinzu
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// Durchlauf durch das Array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n"; // Wir haben nun 6 Elemente, wobei die letzten beiden leer sind
?>
Ergebnisse:
Anmerkungen
- Zeile 5: Mit der Funktion
*explode($séparateur,$chaine)*lassen sich die durch$séparateurgetrennten Felder aus$chaineextrahieren. So ermöglicht „explode(":",$chaine)“, die Elemente von $chaine, die durch die Zeichenfolge „:“ getrennt sind, als Array abzurufen. - Die Funktion implode($séparateur, $tableau) führt die umgekehrte Operation der Funktion explode durch. Sie gibt eine Zeichenkette zurück, die aus den Elementen von $tableau besteht, die durch $séparateur getrennt sind.
3.4. Zeichenketten
3.4.1. Notation (exemple_08)
<?php
// Zeichenfolgenvergleiche
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>
Ergebnisse:
3.4.2. Vergleich (exemple_09)
<?php
// Tests zum Vergleich von Zeichenketten
compare("abcd", "abcd");
compare("", "");
compare("1", "");
exit;
function compare($chaine1, $chaine2) {
// Vergleich von Zeichenkette1 und Zeichenkette2
if ($chaine1 == $chaine2)
print "[$chaine1] est égal à [$chaine2]\n";
else
print "[$chaine1] est différent de [$chaine2]\n";
}
?>
Ergebnisse:
3.5. Reguläre Ausdrücke (exemple_10)
<?php
// Reguläre Ausdrücke in PHP
// Die verschiedenen Felder einer Zeichenkette extrahieren
// Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
// Es soll nur die Ziffernfolge extrahiert werden
$modèle = "/(\d+)/";
// Die Zeichenfolge wird mit dem Muster abgeglichen
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
// Das Muster: eine Ziffernfolge, die von beliebigen Zeichen umgeben ist
// Wir möchten die Ziffernfolge sowie die vorangehenden und nachfolgenden Felder
$modèle = "/^(.*?)(\d+)(.*?)$/";
// Die Zeichenfolge wird mit dem Muster abgeglichen
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
// das Muster – ein Datum im Format TT/MM/JJ
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
compare($modèle, "10/05/97");
compare($modèle, " 04/04/01 ");
compare($modèle, "5/1/01");
// das Muster – eine Dezimalzahl
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
compare($modèle, "187.8");
compare($modèle, "-0.6");
compare($modèle, "4");
compare($modèle, ".6");
compare($modèle, "4.");
compare($modèle, " + 4");
// Ende
exit;
// --------------------------------------------------------------------------
function compare($modèle, $chaîne) {
// vergleicht die Zeichenfolge $chaîne mit dem Muster $modèle
// Die Zeichenfolge wird mit dem Muster abgeglichen
$correspond = preg_match($modèle, $chaîne, $champs);
// Anzeige der Ergebnisse
print "\nRésultats($modèle,$chaîne)\n";
if ($correspond) {
for ($i = 0; $i < count($champs); $i++)
print "champs[$i]=$champs[$i]\n";
} else
print "La chaîne [$chaîne] ne correspond pas au modèle [$modèle]\n";
}
?>
Ergebnisse:
Kommentare
- Zeilen 3–4: Hier verwenden wir reguläre Ausdrücke, um die verschiedenen Felder einer Zeichenkette zu extrahieren. Mit regulären Ausdrücken lassen sich die Einschränkungen der Funktion implode umgehen. Das Prinzip besteht darin, eine Zeichenkette mit einer anderen Zeichenkette namens modèle mithilfe der Funktion preg_match zu vergleichen:
$correspond = preg_match($modèle, $chaîne, $champs);
Die Funktion preg_match gibt einen booleschen Wert zurück, wenn modèle in chaîne gefunden werden kann. Wenn ja, stellt $champs[0] die dem Muster entsprechende Teilzeichenfolge dar. Enthält das Modell zudem in Klammern gesetzte Untermodelle, so ist $champs[1] der Teil von $chaîne, der dem ersten Untermodell entspricht, $champs[2] ist der Teil von $chaîne, der dem zweiten Untermuster entspricht, usw.
Betrachten wir das erste Beispiel. Das Muster wird in Zeile 8 definiert: Es bezeichnet eine Folge von einer oder mehreren (+) Ziffern (\d), die an beliebiger Stelle in einer Zeichenkette stehen können. Außerdem definiert das Muster ein in Klammern gesetztes Untermuster.
- Zeile 10: Das Muster /(\d+)/ (eine Folge von einer oder mehreren Ziffern an beliebiger Stelle in der Zeichenkette) wird mit der Zeichenkette „xyz1234abcd“ verglichen. Man sieht, dass die Teilzeichenkette 1234 dem Muster entspricht. Man erhält also $champs[0], was „1234“ entspricht. Außerdem enthält das Muster Teilmuster in Klammern. Man erhält $champs[1] = „1234“.
- Zeile 11: Das Muster /(\d+)/ wird mit der Zeichenkette „12 34“ verglichen. Es zeigt sich, dass die Teilzeichenfolgen 12 und 34 dem Muster entsprechen. Der Vergleich wird bei der ersten Teilzeichenfolge beendet, die dem Muster entspricht. Man erhält also $champs[0]=12 und $champs[1]=12.
- Zeile 12: Das Muster /(\d+)/ wird mit der Zeichenkette „abcd“ verglichen. Es wird keine Übereinstimmung gefunden.
Lassen Sie uns die im weiteren Verlauf des Codes verwendeten Muster näher erläutern:
$modèle = "/^(.*?)(\d+)(.*?)$/";
Anfang der Zeichenkette (^), dann 0 oder mehrere (*) beliebige Zeichen (.), dann 1 oder mehrere (+) Ziffern, dann erneut 0 oder mehrere (*) beliebige Zeichen (.). Das Muster (.*) steht für 0 oder mehrere beliebige Zeichen. Ein solches Muster passt auf jede beliebige Zeichenkette. Daher wird das Muster /^(.*)(\d+)(.*)$/ niemals gefunden, da das erste Untermuster (.*) die gesamte Zeichenkette aufnimmt. Das Muster (.*?)(\d+) bezeichnet hingegen 0 oder mehrere beliebige Zeichen bis zum nächsten Untermuster (?), hier \d+. Somit werden die Ziffern nun nicht mehr vom Muster (.*) aufgefangen. Das obige Muster passt daher zu [début de chaîne (^), une suite de caractères quelconques (.*?), une suite d'un ou plusieurs chiffres (\d+), une suite de caractères quelconques (.*?), la fin de la chaîne ($)].
$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";
entspricht [début de chaîne (^), 2 chiffres (\d\d), le caractère / (\/), 2 chiffres, /, 2 chiffres, une suite de 0 ou plusieurs espaces (\s*), la fin de chaîne ($)]
$modèle = "/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/";
[début de chaîne (^), 0 ou plusieurs espaces (\s*), un signe + ou - [+|-] présent 0 ou 1 fois (?), une suite de 0 ou plusieurs espaces (\s*), 1 ou plusieurs chiffres suivis d'un point décimal suivi de zéro ou plusieurs chiffres (\d+\.\d*) ou (|) un point décimal (\.) suivi d'un ou plusieurs chiffres (\d+) ou (|) un ou plusieurs chiffres (\d+), une suite de 0 ou plusieurs espaces (\s*)].
3.6. Art der Parameterübergabe an Funktionen (exemple_11)
<?php
// Parameterübergabe
function f(&$i, $j) {
// $i wird durch Referenzierung erhalten
// $j wird per Wert übergeben
$i++;
$j++;
print "f[i,j]=[$i,$j]\n";
}
// ----------------------------------------Tests
$i = 0;
$j = 0;
// $i und $j werden als Wert übergeben
f($i, $j);
print "test[i,j]=[$i,$j]\n";
?>
Ergebnisse:
Kommentare
Der obige Code zeigt die beiden Arten der Parameterübergabe an eine Funktion. Nehmen wir folgendes Beispiel:
- Zeile 1: Definiert die formalen Parameter $a und $b der Funktion f. Diese verarbeitet diese beiden formalen Parameter und gibt ein Ergebnis zurück.
- Zeile 7: Aufruf der Funktion f mit den beiden effektiven Parametern $i und $j. Die Zuordnungen zwischen den formalen Parametern ($a, $b) und den tatsächlichen Parametern ($i, $j) werden in Zeile 7 definiert
- &$a: Das Zeichen & gibt an, dass der formale Parameter $a den Wert der Adresse des effektiven Parameters $i annimmt. Anders ausgedrückt: $a und $i sind zwei Verweise auf denselben Speicherplatz. Die Bearbeitung des formalen Parameters $a entspricht der Bearbeitung des effektiven Parameters $i. Dies zeigt die Ausführung des Codes. Diese Art der Übergabe eignet sich für Ausgabeparameter und umfangreiche Daten wie Arrays und Dictionaries. Diese Art der Übergabe wird als Referenzübergabe bezeichnet.
- $b: Der formale Parameter $b erhält den Wert des effektiven Parameters $j. Dies ist eine Wertübergabe. Formale und effektive Parameter sind zwei verschiedene Variablen. Die Bearbeitung des formalen Parameters $b hat keinerlei Auswirkungen auf den effektiven Parameter $j. Dies zeigt die Ausführung des Codes. Diese Übergabemethode eignet sich für Eingabeparameter.
- Nehmen wir die Funktion échange, die zwei formale Parameter $a und $b akzeptiert. Die Funktion vertauscht die Werte dieser beiden Parameter. Bei einem Aufruf mit Parametervertauschung ($i,$j) erwartet der aufrufende Code also, dass die Werte der beiden tatsächlichen Parameter vertauscht werden. Es handelt sich also um Ausgabeparameter (sie werden verändert). Man schreibt daher:
3.7. Von einer Funktion zurückgegebene Ergebnisse (exemple_12)
<?php
// von einer Funktion zurückgegebene Ergebnisse
// Eine Funktion kann mehrere Werte in einem Array zurückgeben
list($res1, $res2, $res3) = f1(10);
print "[$res1,$res2,$res3]\n";
$res = f1(10);
for ($i = 0; $i < count($res); $i++)
print "res[$i]=$res[$i]\n";
// Eine Funktion kann ein Pseudo-Objekt zurückgeben
$res = f2(10);
print "[$res->res1,$res->res2,$res->res3]\n";
// Ende
exit;
// Funktion f1
function f1($valeur) {
// gibt ein Array zurück ($valeur+1,$aleur+2,$baleur+3)
return array($valeur + 1, $valeur + 2, $valeur + 3);
}
// Funktion f2
function f2($valeur) {
// gibt ein Pseudo-Objekt zurück ($valeur+1,$aleur+2,$baleur+3)
$res->res1 = $valeur + 1;
;
$res->res2 = $valeur + 2;
$res->res3 = $valeur + 3;
// gibt das Objekt zurück
return $res;
}
?>
Ergebnisse
Kommentare
- Das vorherige Programm zeigt, dass eine Funktion PHP mehrere Ergebnisse und nicht nur ein einziges in Form eines Arrays oder eines Objekts zurückgeben kann. Der Begriff „Objekt“ wird etwas weiter unten näher erläutert
- Zeilen 19–22: Die Funktion f1 gibt mehrere Werte in Form eines Arrays zurück
- Zeilen 25–33: Die Funktion f2 gibt mehrere Werte in Form eines Objekts zurück
3.8. Textdateien (exemple_13)
<?php
// sequenzielle Verarbeitung einer Textdatei
// Diese besteht aus einer Reihe von Zeilen der Form login:pwd:uid:gid:infos:dir:shell
// Jede Zeile wird in Form von „login => uid:gid:infos:dir:shell“ in ein Wörterbuch aufgenommen
// Der Dateiname wird festgelegt
$INFOS = "infos.txt";
// Die Datei wird zum Erstellen geöffnet
if (!$fic = fopen($INFOS, "w")) {
print "Erreur d'ouverture du fichier $INFOS en écriture\n";
exit;
}
// Es wird ein beliebiger Inhalt generiert
for ($i = 0; $i < 100; $i++)
fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
// Die Datei wird geschlossen
fclose($fic);
// die Datei wird ausgewertet – fgets behält die Zeilenende-Markierung bei
// Dadurch wird verhindert, dass beim Lesen einer Leerzeile eine leere Zeichenkette abgerufen wird
// Die Datei wird zum Schreiben geöffnet
if (!$fic = fopen($INFOS, "r")) {
print "Erreur d'ouverture du fichier $INFOS en lecture\n";
exit;
}
while ($ligne = fgets($fic, 1000)) {
// Das Zeilenendezeichen wird entfernt, falls vorhanden
$ligne = cutNewLineChar($ligne);
// Die Zeile wird in ein Array gespeichert
$infos = explode(":", $ligne);
// Das Login wird abgerufen
$login = array_shift($infos);
// Das Passwort wird ignoriert
array_shift($infos);
// Es wird ein Eintrag im Wörterbuch angelegt
$dico[$login] = $infos;
}
// man schließt es
fclose($fic);
// Auswertung des Wörterbuchs
afficheInfos($dico, "login10");
afficheInfos($dico, "X");
// Ende
exit;
// --------------------------------------------------------------------------
function afficheInfos($dico, $clé) {
// Zeigt den Wert an, der dem Schlüssel im Wörterbuch $dico zugeordnet ist, sofern er existiert
if (isset($dico[$clé])) {
// Wert vorhanden – handelt es sich um ein Array?
$valeur = $dico[$clé];
if (is_array($valeur)) {
print "[$clé," . join(":", $valeur) . "]\n";
} else {
// $valeur ist kein Array
print "[$clé,$valeur]\n";
}
} else {
// $clé ist kein Schlüssel im Wörterbuch $dico
print "la clé [$clé] n'existe pas\n";
}
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// Das Zeilenendezeichen von $ligne wird entfernt, falls vorhanden
$L = strlen($ligne); // Zeilenlänge
while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
$ligne = substr($ligne, 0, $L - 1);
$L--;
}
// Ende
return($ligne);
}
?>
Die Datei infos.txt:
login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99
Die Ergebnisse:
Kommentare
- Zeile 11: fopen(nom_fichier, „w“) öffnet die Datei nom_fichier im Schreibmodus (w=write). Wenn die Datei nicht existiert, wird sie angelegt. Wenn sie existiert, wird sie geleert. Wenn das Anlegen fehlschlägt, gibt fopen den Wert false zurück. In der Anweisung if (!$fic = fopen($INFOS, "w")) {…} finden zwei aufeinanderfolgende Operationen statt: 1) $fic = fopen(..) 2) if (!$fic) {...}
- Zeile 18: fputs($fic, $chaîne) schreibt chaîne in die Datei $fic.
- Zeile 20: fclose($fic) schließt die Datei $fic.
- Zeile 25: fopen(nom_fichier, „r“) öffnet die Datei nom_fichier zum Lesen (r=read). Wenn das Öffnen fehlschlägt (die Datei existiert nicht), gibt fopen den Wert false zurück.
- Zeile 29: fgets($fic, 1000) liest die nächste Zeile der Datei mit einer Begrenzung auf 1000 Zeichen. In der Schleife while ($ligne = fgets($fic, 1000)) {…} finden zwei aufeinanderfolgende Operationen statt: 1) $ligne = fgets(...) 2) while ( ! $ligne). Nachdem das letzte Zeichen der Datei gelesen wurde, gibt die Funktion fgets die leere Zeichenkette zurück und die Schleife while wird beendet.
- Zeile 31: Die Funktion fgets liest eine Textzeile, einschließlich des Zeilenendezeichens. Die Funktion cutNewLineChar in den Zeilen 70–79 entfernt das eventuelle Zeilenendezeichen.
- Zeile 72: Die Funktion strlen($chaîne) gibt die Anzahl der Zeichen in $chaîne zurück.
- Zeile 73: Die Funktion substr($ligne, $position, $taille) gibt $taille Zeichen aus $ligne zurück, beginnend ab dem Zeichen mit der Nummer $position, wobei das erste Zeichen die Nummer 0 hat. Auf Windows-Rechnern lautet das Zeilenendezeichen „\r\n“. Auf Unix-Rechnern ist es die Zeichenkette „\n“.
- Zeile 35: Die Funktion array_shift($tableau) entfernt das erste Element aus $tableau und gibt es als Ergebnis zurück.
- Zeile 37: Die Funktion array_shift($tableau) wird aufgerufen, ihr Ergebnis wird jedoch ignoriert
- Zeile 57: Die Funktion is_array($variable) gibt true zurück, wenn $variable ein Array ist, andernfalls false.
- Zeile 58: Die Funktion join verhält sich genauso wie die bereits behandelte Funktion implode