3. Die Grundlagen von PHP

3.1. Ein erstes Beispiel

Nachfolgend finden Sie ein Programm, das die grundlegenden Funktionen von PHP veranschaulicht.

3.1.1. Das Programm (example_01)

<?php
 
// this is a comment
// variable used without being declared
$nom = "dupont";
 
// a screen display
print "nom=$nom\n";
 
// an array with elements of different types
$tableau = array("un", "deux", 3, 4);
 
// its number of elements
$n = count($tableau);
 
// a loop
for ($i = 0; $i < $n; $i++)
  print "tableau[$i]=$tableau[$i]\n";
 
// initialize 2 variables with the contents of an array
list($chaine1, $chaine2) = array("chaine1", "chaine2");
 
// concatenation of the 2 strings
$chaine3 = $chaine1 . $chaine2;
 
// result display
print "[$chaine1,$chaine2,$chaine3]\n";
 
// use function
affiche($chaine1);
 
// the type of a variable can be known
afficheType($n);
afficheType($chaine1);
afficheType($tableau);
 
// the type of a variable can change at runtime
$n = "a changé";
afficheType($n);
 
// a function can return a result
$res1 = f1(4);
print "res1=$res1\n";
 
// a function can return a table of values
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
 
// we could have retrieved these values in a table
$t = f2();
for ($i = 0; $i < count($t); $i++)
  print "t[$i]=$t[$i]\n";
 
// testing
for ($i = 0; $i < count($t); $i++)
// displays only channels
  if (getType($t[$i]) == "string")
    print "t[$i]=$t[$i]\n";
 
// other tests
for ($i = 0; $i < count($t); $i++){
// displays only integers >10
  if (getType($t[$i]) == "integer" and $t[$i] > 10)
    print "t[$i]=$t[$i]\n";
}
 
// a while loop
$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];   //$s//$somme=$somme+$t[$i]
  $i++;             //$i=$i+1
}
print "somme=$somme\n";
 
// end of program
exit;
 
//----------------------------------
function affiche($chaine) {
  // displays $chaine
  print "chaine=$chaine\n";
}
 
//----------------------------------
function afficheType($variable) {
  // displays the type of $variable
  print "type[$variable]=" . getType($variable) . "\n";
}
 
//----------------------------------
function f1($param) {
  // adds 10 to $param
  return $param + 10;
}
 
//----------------------------------
function f2() {
  // returns 3 values
  return array("un", 0, 100);
}
?>

Die Ergebnisse:

nom=dupont
tableau[0]=un
tableau[1]=deux
tableau[2]=3
tableau[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=integer
type[chaine1]=string
type[Array]=array
type[a changé]=string
res1=14
(res1,res2,res3)=[un,0,100]
t[0]=un
t[1]=0
t[2]=100
t[0]=un
t[2]=100
t[0]=8
t[1]=5
somme=13

Kommentare

• Zeile 5: In PHP werden Variablentypen nicht deklariert. Variablen haben einen dynamischen Typ, der sich im Laufe der Zeit ändern kann
• $name steht für die Variable mit dem Bezeichner name
• Zeile 8: Um Text auf dem Bildschirm anzuzeigen, kannst du die Anweisung print oder die Anweisung echo verwenden
• Zeile 11: Das Schlüsselwort *array* wird verwendet, um ein Array zu definieren. Die Variable $name[$i] steht für das $i-te Element des Arrays $array.
• Zeile 14: Die Funktion count($tableau) gibt die Anzahl der Elemente im Array *$tableau* zurück
• Zeile 18: Zeichenfolgen werden in doppelte Anführungszeichen " oder einfache Anführungszeichen ' gesetzt. Innerhalb doppelter Anführungszeichen werden Variablen $variable ausgewertet, innerhalb einfacher Anführungszeichen jedoch nicht.
• Zeile 21: Mit der List-Funktion können Sie Variablen in einer Liste zusammenfassen und ihnen mit einem einzigen Zuweisungsbefehl einen Wert zuweisen. Hier gilt: $string1 = „string1“ und $string2 = „string2“.
• Zeile 24: Der Operator . ist der Operator zur Zeichenfolgenverkettung.
• Zeile 88: Das Schlüsselwort function definiert eine Funktion. Eine Funktion kann mithilfe der return-Anweisung Werte zurückgeben oder auch nicht. 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 angibt. Dieser Typ kann sich im Laufe der Zeit ändern.
• Zeile 79: Die vordefinierte Funktion exit beendet das Skript.

3.2. Variablengültigkeitsbereich

3.2.1. Programm 1 (example_02)

<?php
 
// variable scope
 
function f1() {
  // we use the global variable $i
  $i = &$GLOBALS["i"];
  $i++;
  $j = 10;
  print "f1[i,j]=[$i,$j]\n";
}
 
function f2() {
  // we use the global variable $i
  $i = &$GLOBALS["i"];
  $i++;
  $j = 20;
  print "f2[i,j]=[$i,$j]\n";
}
 
function f3() {
  // we use a local variable $i
  $i = 4;
  $j = 30;
  print "f3[i,j]=[$i,$j]\n";
}
 
// tests
$i = 0;
$j = 0;  /// these two variables are known to a function f via the table $GLOBALS
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
?>

Die Ergebnisse:

f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[4,30]
test[i,j]=[2,0]

Kommentare

• Zeilen 29–30: Definieren Sie zwei Variablen, $i und $j, im Hauptprogramm. Diese Variablen sind innerhalb der Funktionen nicht bekannt. Daher ist in Zeile 9 die Variable $j in der Funktion f1 eine lokale Variable der Funktion f1 und unterscheidet sich von der Variable $j im Hauptprogramm. Eine Funktion kann über ein Array globaler Variablen namens $GLOBALS auf eine Variable $variable aus dem Hauptprogramm zugreifen. In Zeile 7 bezieht sich die Notation $GLOBALS["i"] auf die globale Variable $i des Hauptprogramms. Wenn wir schreiben

$i=$GLOBALS["i"]

schreibt, wird der lokalen Variablen $i der Wert der globalen Variablen $i zugewiesen. Es handelt sich um zwei verschiedene Variablen, und eine Änderung der lokalen Variablen $i hat keine Auswirkungen auf die globale Variable $i. Die Notation

$i=&Globals["i"]

bewirkt, dass die lokale Variable $i dieselbe Speicheradresse hat wie die globale Variable $i. Die Manipulation der lokalen Variable $i entspricht dann der Manipulation der globalen Variable $i.

3.2.2. Programm 2 (example_03)

<?php
 
// the scope of a variable is global to code blocks
$i = 0; {
  $i = 4;
  $i++;
}
print "i=$i\n";
?>

Die Ergebnisse:

i=5

Anmerkungen

In einigen Sprachen ist der Geltungsbereich einer innerhalb von geschweiften Klammern definierten Variablen auf diese Klammern beschränkt: Außerhalb dieser Klammern ist sie nicht zugänglich. 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 Klammern verwendete.

3.3. Arrays

3.3.1. Klassische eindimensionale Arrays (Beispiel_04)

<?php
 
// classic paintings
// initialization
$tab1 = array(0, 1, 2, 3, 4, 5);
 
// routes - 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// routes - 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1))
  print "tab1[$clé]=$valeur\n";
 
// add elements
$tab1[] = $i++;
$tab1[] = $i++;
 
// routes - 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
  print "tab1[$i]=$élément\n";
  $i++;
}
 
// delete last item
array_pop($tab1);
 
// routes - 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// delete first element
array_shift($tab1);
 
// routes - 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// addition at end of table
array_push($tab1, -2);
 
// routes - 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
 
// addition at the beginning of the table
array_unshift($tab1, -1);
 
// routes - 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
  print "tab1[$i]=$tab1[$i]\n";
?>

Die Ergebnisse:

tab1 a 6 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 8 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=7
tab1 a 7 éléments
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1 a 6 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1 a 7 éléments
tab1[0]=1
tab1[1]=2
tab1[2]=3
tab1[3]=4
tab1[4]=5
tab1[5]=6
tab1[6]=-2
tab1 a 8 éléments
tab1[0]=-1
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1[6]=6
tab1[7]=-2

Kommentare

Das obige Programm veranschaulicht Operationen zur Bearbeitung eines Arrays von Werten. In PHP gibt es zwei Notationen für Arrays:

$tableau=array("un",2,"trois")
$contraires=array("petit"=>"grand", "beau"=>"laid", "cher"=>"bon marché")

Array 1 wird als Array bezeichnet, Array 2 als Wörterbuch, wobei Elemente als Schlüssel => Wert dargestellt werden. Die Notation $opposites["beautiful"] bezieht sich auf den Wert, der dem Schlüssel „beautiful“ zugeordnet ist. In diesem Fall ist dieser Wert die Zeichenkette „ugly“. Array 1 ist lediglich eine Variante des Wörterbuchs und könnte wie folgt geschrieben werden:

$tableau=array(0=>"un",1=>2,2=>"trois")

Somit haben wir $array[2]="three". Letztendlich gibt es nur Wörterbücher. Im Fall eines klassischen Arrays mit n Elementen sind die Schlüssel die ganzen Zahlen im Bereich [0,n-1].

• Zeile 15: Mit der Funktion each($array) kannst du ein Wörterbuch durchlaufen. Bei jedem Aufruf gibt sie ein (Schlüssel, Wert)-Paar daraus zurück.
• Zeile 14: Die Funktion reset($dictionary) setzt die Funktion each auf das erste (Schlüssel, Wert)-Paar im Wörterbuch.
• Zeile 15: Die while-Schleife stoppt, wenn die each-Funktion am Ende des Wörterbuchs ein leeres Paar zurückgibt.
• Zeile 19: Die Notation $array[]=value fügt das Element value als letztes Element von $array hinzu.
• Zeile 25: Das Array wird mit einer foreach-Schleife durchlaufen. Diese Syntax ermöglicht es Ihnen, ein Wörterbuch und damit auch ein Array mit zwei Syntaxen zu durchlaufen:

foreach($dictionnaire as $clé=>$valeur)
foreach($tableau as $valeur)

Die erste Syntax gibt bei jeder Iteration ein (Schlüssel,Wert)-Paar zurück, während die zweite Syntax nur das Wertelement des Wörterbuchs zurückgibt.

• Zeile 31: Die Funktion array_pop($array) entfernt das letzte Element aus $array
• Zeile 39: Die Funktion array_shift($array) entfernt das erste Element aus $array
• Zeile 47: Die Funktion array\_push($array, value) fügt value als letztes Element von $array hinzu
• Zeile 39: Die Funktion array_unshift($array, value) fügt value als erstes Element von $array hinzu

3.3.2. Das Wörterbuch (example_05)

<?php
 
// dictionaries
$conjoints = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");
 
// routes - 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";
 
// dictionary sorting on key
ksort($conjoints);
 
// routes - 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
  print "conjoints[$clé]=$valeur\n";
 
// list of dictionary keys
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++)
  print "clés[$i]=$clés[$i]\n";
 
// list of dictionary values
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++)
  print "valeurs[$i]=$valeurs[$i]\n";
 
// key search
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");
 
// deleting a key-value
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
  print "conjoints[$clé]=$valeur\n";
}
 
// end
exit;
 
function existe($conjoints, $mari) {
  // checks whether the key $mari exists in the dictionary $conjoints
  if (isset($conjoints[$mari]))
    print "La clé [$mari] existe associée à la valeur [$conjoints[$mari]]\n";
  else
    print "La clé [$mari] n'existe pas\n";
}
 
?>

Die Ergebnisse:

Nombre d'éléments du dictionnaire : 4
conjoints[Pierre]=Gisèle
conjoints[Paul]=Virginie
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Jacques]=Lucette
conjoints[Jean]=
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle
clés[0]=Jacques
clés[1]=Jean
clés[2]=Paul
clés[3]=Pierre
valeurs[0]=Lucette
valeurs[1]=
valeurs[2]=Virginie
valeurs[3]=Gisèle
La clé [Jacques] existe associée à la valeur [Lucette]
La clé [Lucette] n'existe pas
La clé [Jean] existe associée à la valeur []
Nombre d'éléments du dictionnaire : 3
conjoints[Jacques]=Lucette
conjoints[Paul]=Virginie
conjoints[Pierre]=Gisèle

Kommentare

Der obige Code wendet auf ein Wörterbuch an, was wir zuvor für ein einfaches Array gesehen haben. Wir werden nur auf die neuen Funktionen eingehen:

• Zeile 13: Die Funktion ksort (Key Sort) sortiert ein Wörterbuch in der natürlichen Reihenfolge der Schlüssel.
• Zeile 21: Die Funktion *array\_keys($dictionary)* gibt die Liste der Schlüssel des Wörterbuchs als Array zurück
• Zeile 26: Die Funktion *array\_values($dictionary)* gibt die Liste der Werte des Wörterbuchs als Array zurück
• 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 (Beispiel_06)

<?php
 
// classic multidimensional tables
// initialization
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// route
for ($i1 = 0; $i1 < count($multi); $i1++)
  for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
    print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
// multidimensional dictionaries
// initialization
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// route
foreach ($multi as $clé => $valeur)
  for ($i2 = 0; $i2 < count($valeur); $i2++)
    print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
?>

Ergebnisse:

multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zéro][0]=0
multi[zéro][1]=1
multi[zéro][2]=2
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24

Kommentare

• Zeile 5: Die Elemente des Arrays $multi sind selbst Arrays
• Zeile 12: Das Array $multi wird zu einem Wörterbuch (Schlüssel, Wert), wobei jeder Wert ein Array ist

3.3.4. Verbindungen zwischen Strings und Arrays (Beispiel_07)

<?php
 
// string to array
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n";
 
// table to string
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";
 
// add an empty field
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; //// we now have 5 elements, the last being empty
 
// let's add another empty field
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
 
// parcours tableau
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
  print "tab[$i]=$tab[$i]\n"; //// we now have 6 elements, the last two being empty
?>

Ergebnisse:

tab a 4 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
chaine2=1:2:3:4
chaîne=1:2:3:4:
tab a 5 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
chaîne=1:2:3:4::
tab a 6 éléments
tab[0]=1
tab[1]=2
tab[2]=3
tab[3]=4
tab[4]=
tab[5]=

Kommentare

• Zeile 5: Die Funktion explode($separator,$string) extrahiert die durch $separator getrennten Felder von $string. Somit gibt explode(":",$string) die durch den String ":" getrennten Elemente von $string als Array zurück.
• Die Funktion implode($separator,$array) führt die umgekehrte Operation der Funktion explode aus. Sie gibt eine Zeichenkette zurück, die aus den Elementen von $array besteht, getrennt durch $separator.

3.4. Zeichenketten

3.4.1. Syntax (Beispiel_08)

<?php
 
// string notation
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>

Ergebnisse:

[un,un]

3.4.2. Vergleich (Beispiel_09)

<?php
 
// string comparison tests
compare("abcd", "abcd");
compare("", "");
compare("1", "");
exit;
 
function compare($chaine1, $chaine2) {
  // compare string1 and string2
  if ($chaine1 == $chaine2)
    print "[$chaine1] est égal à [$chaine2]\n";
  else
    print "[$chaine1] est différent de [$chaine2]\n";
}
 
?>

Ergebnisse:

[abcd] est égal à [abcd]
[] est égal à []
[1] est différent de []

3.5. Reguläre Ausdrücke (Beispiel_10)

<?php
 
// regular expression in PHP
// retrieve the various fields of a string
 
// the model: a sequence of numbers surrounded by any characters
// you only want to retrieve the sequence of digits
$modèle = "/(\d+)/";
// the chain is compared with the
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
 
// the model: a sequence of numbers surrounded by any characters
// we want the sequence of numbers and the fields that follow and precede them
$modèle = "/^(.*?)(\d+)(.*?)$/";
// the chain is compared with the
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
 
// the template - a date in dd/mm/yy format
$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");
 
// the model - a decimal number
$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");
 
// end
exit;
 
// --------------------------------------------------------------------------
function compare($modèle, $chaîne) {
  // compares the $chaîne string with the $modèle model
  // the chain is compared with the model
  $correspond = preg_match($modèle, $chaîne, $champs);
  // displaying results
  print "\nRésultats($modèle,$chaîne)\n";
  if ($correspond) {
    for ($i = 0; $i < count($champs); $i++)
      print "champs[$i]=$champs[$i]\n";
  } else
    print "La chaîne [$chaîne] ne correspond pas au modèle [$modèle]\n";
}
?>

Ergebnisse:

Résultats(/(\d+)/,xyz1234abcd)
champs[0]=1234
champs[1]=1234

Résultats(/(\d+)/,12 34)
champs[0]=12
champs[1]=12

Résultats(/(\d+)/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/(\d+)/]

Résultats(/^(.*?)(\d+)(.*?)$/,xyz1234abcd)
champs[0]=xyz1234abcd
champs[1]=xyz
champs[2]=1234
champs[3]=abcd

Résultats(/^(.*?)(\d+)(.*?)$/,12 34)
champs[0]=12 34
champs[1]=
champs[2]=12
champs[3]= 34

Résultats(/^(.*?)(\d+)(.*?)$/,abcd)
La chaîne [abcd] ne correspond pas au modèle [/^(.*?)(\d+)(.*?)$/]

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,10/05/97)
champs[0]=10/05/97
champs[1]=10
champs[2]=05
champs[3]=97

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,  04/04/01  )
champs[0]=  04/04/01  
champs[1]=04
champs[2]=04
champs[3]=01

Résultats(/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/,5/1/01)
La chaîne [5/1/01] ne correspond pas au modèle [/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/]

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,187.8)
champs[0]=187.8
champs[1]=
champs[2]=187.8

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,-0.6)
champs[0]=-0.6
champs[1]=-
champs[2]=0.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4)
champs[0]=4
champs[1]=
champs[2]=4

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,.6)
champs[0]=.6
champs[1]=
champs[2]=.6

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/,4.)
champs[0]=4.
champs[1]=
champs[2]=4.

Résultats(/^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*/, + 4)
champs[0]= + 4
champs[1]=+
champs[2]=4

Kommentare

• Zeilen 3–4: Hier verwenden wir reguläre Ausdrücke, um die verschiedenen Felder aus einer Zeichenkette zu extrahieren. Reguläre Ausdrücke ermöglichen es uns, die Einschränkungen der implode-Funktion zu umgehen. Das Prinzip besteht darin, eine Zeichenkette mit einer anderen Zeichenkette, dem sogenannten Muster, mithilfe der preg_match-Funktion zu vergleichen:

$correspond = preg_match($modèle, $chaîne, $champs);

Die Funktion preg\_match gibt einen booleschen Wert zurück, der angibt, ob das Muster in der Zeichenkette gefunden werden kann. Ist dies der Fall, stellt $fields[0] die Teilzeichenkette dar, die mit dem Muster übereinstimmt. Enthält das Muster zudem in Klammern eingeschlossene Untermuster, ist $champs[1]</span>*<span style="color: #000000"> der Teil von $string, der dem ersten Untermuster entspricht, $champs[2]</span>*<span style="color: #000000"> der Teil von $string, der dem zweiten Untermuster entspricht, und so weiter...

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. Darüber hinaus definiert das Muster ein in Klammern eingeschlossenes 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. Wir sehen, dass die Teilzeichenkette 1234 mit dem Muster übereinstimmt. Daher ist $fields[0] gleich „1234“. Außerdem enthält das Muster in Klammern eingeschlossene Teilmuster. Wir erhalten $champs[1]="1234".
• Zeile 11: Das Muster /(\d+)/ wird mit der Zeichenkette „12 34“ verglichen. Wir sehen, dass die Teilzeichenfolgen 12 und 34 mit dem Muster übereinstimmen. Der Vergleich endet bei der ersten Teilzeichenfolge, die mit dem Muster übereinstimmt. Daher ist $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 restlichen Code verwendeten Muster erläutern:

$modèle = "/^(.*?)(\d+)(.*?)$/";

Anfang der Zeichenkette (^), dann 0 oder mehr (*) beliebige Zeichen (.), dann 1 oder mehr (+) Ziffern, dann wieder 0 oder mehr (*) beliebige Zeichen (.). Das Muster (.*) steht für 0 oder mehr beliebige Zeichen. Ein solches Muster passt auf jede beliebige Zeichenkette. Daher wird das Muster /^(.*)(\d+)(.*)$/ niemals gefunden, da das erste Teilmuster (.*) die gesamte Zeichenkette einnimmt. Das Muster (.*?)(\d+) bezeichnet 0 oder mehr beliebige Zeichen bis zum nächsten Teilmuster (?), in diesem Fall \d+. Daher werden die Ziffern nicht mehr vom Muster (.*). erfasst. Das obige Muster passt somit auf [Anfang der Zeichenkette (^), eine Folge beliebiger Zeichen (.*?), eine Folge von einer oder mehreren Ziffern (\d+), eine Folge beliebiger Zeichen (.*?), Ende der Zeichenkette ($)].

$modèle = "/^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$/";

passt auf [Anfang der Zeichenkette (^), 2 Ziffern (\d\d), das Zeichen / (\/), 2 Ziffern, /, 2 Ziffern, eine Folge von 0 oder mehr Leerzeichen (\s*), Ende der Zeichenkette ($)]

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

[Anfang der Zeichenfolge (^), 0 oder mehr Leerzeichen (\s*), ein +- oder -Zeichen [+|-], das 0 oder 1 Mal vorkommt (?), eine Folge von 0 oder mehr Leerzeichen (\s*), 1 oder mehr Ziffern, gefolgt von einem Dezimalpunkt, gefolgt von null oder mehr Ziffern (\d+\.\d*) oder (|) ein Dezimalpunkt (\.), gefolgt von einer oder mehr Ziffern (\d+) oder (|) eine oder mehr Ziffern (\d+), eine Folge von null oder mehr Leerzeichen (\s*)].

3.6. Modus der Funktionsparameterübergabe (Beispiel_11)

<?php
 
// parameter step mode
 
function f(&$i, $j) {
  // $i will be obtained by reference
  // $j will be obtained by value
  $i++;
  $j++;
  print "f[i,j]=[$i,$j]\n";
}
 
// ----------------------------------------tests
$i = 0;
$j = 0;
// $i and $j passed by values
f($i, $j);
print "test[i,j]=[$i,$j]\n";
?>

Ergebnisse:

f[i,j]=[1,1]
test[i,j]=[1,0]

Kommentare

Der obige Code veranschaulicht die beiden Möglichkeiten, Parameter an eine Funktion zu übergeben. Betrachten wir das folgende Beispiel:

function f(&$a,$b){
…
}

// main program
$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 und gibt ein Ergebnis zurück.
• Zeile 7: ruft die Funktion f mit den beiden tatsächlichen Parametern $i und $j auf. Die Zuordnungen zwischen den formalen Parametern ($a, $b) und den tatsächlichen Parametern ($i, $j) werden durch Zeile 7 definiert
• &$a: Das Symbol & gibt an, dass der formale Parameter $a den Wert der Adresse des tatsächlichen Parameters $i annimmt. Mit anderen Worten: $a und $i sind zwei Verweise auf denselben Speicherort. Die Manipulation des formalen Parameters $a entspricht der Manipulation des tatsächlichen Parameters $i. Dies wird durch die Codeausführung demonstriert. Diese Übergabemethode eignet sich für Ausgabeparameter und große Datensätze wie Arrays und Dictionaries. Diese Übergabemethode wird als Pass-by-Reference bezeichnet.
• $b: Der formale Parameter $b nimmt den Wert des tatsächlichen Parameters $j an. Dies ist die Übergabe nach Wert. Der formale und der tatsächliche Parameter sind zwei verschiedene Variablen. Die Manipulation des formalen Parameters $b hat keine Auswirkungen auf den tatsächlichen Parameter $j. Dies wird durch die Codeausführung veranschaulicht. Dieser Übergabemodus eignet sich für Eingabeparameter.
• Betrachten wir die Funktion swap, die zwei formale Parameter $a und $b annimmt. Die Funktion tauscht die Werte dieser beiden Parameter aus. Bei einem Aufruf von swap($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). Wir schreiben daher:

function échange(&$a,&$b){....}

3.7. Von einer Funktion zurückgegebene Ergebnisse (Beispiel_12)

<?php
 
// results rendered by a function
// a function can return several values in an array
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";
 
// a function can render a pseudo-object
$res = f2(10);
print "[$res->res1,$res->res2,$res->res3]\n";
 
// end
exit;
 
// function f1
function f1($valeur) {
  // returns an array ($valeur+1,$aleur+2,$baleur+3)
  return array($valeur + 1, $valeur + 2, $valeur + 3);
}
 
// function f2
function f2($valeur) {
  // renders a pseudo-object ($valeur+1,$aleur+2,$baleur+3)
  $res->res1 = $valeur + 1;
  ;
  $res->res2 = $valeur + 2;
  $res->res3 = $valeur + 3;
  // makes the object
  return $res;
}
 
?>

Ergebnisse

[11,12,13]
res[0]=11
res[1]=12
res[2]=13
[11,12,13]

Kommentare

• Das vorherige Programm zeigt, dass eine PHP-Funktion statt eines einzelnen Ergebnisses eine Reihe von Ergebnissen in Form eines Arrays oder eines Objekts zurückgeben kann. Das Konzept eines Objekts wird im Folgenden 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 (Beispiel_13)

<?php
 
// sequential operation of a text file
// this is a set of lines of the form login:pwd:uid:gid:infos:dir:shell
// each line is put into a dictionary in the form login => uid:gid:infos:dir:shell
 
// set the file name
$INFOS = "infos.txt";
 
// we open it in creation
if (!$fic = fopen($INFOS, "w")) {
  print "Erreur d'ouverture du fichier $INFOS en écriture\n";
  exit;
}
 
// generate arbitrary content
for ($i = 0; $i < 100; $i++)
  fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
// close the file
fclose($fic);
 
// we use it - fgets keeps the end-of-line marker
// this prevents the retrieval of an empty string when reading a blank line
// we open it in creation
if (!$fic = fopen($INFOS, "r")) {
  print "Erreur d'ouverture du fichier $INFOS en lecture\n";
  exit;
}
while ($ligne = fgets($fic, 1000)) {
  // delete the end-of-line marker if it exists
  $ligne = cutNewLineChar($ligne);
  // put the line in a table
  $infos = explode(":", $ligne);
  // retrieve login
  $login = array_shift($infos);
  // we neglect the pwd
  array_shift($infos);
  // create a dictionary entry
  $dico[$login] = $infos;
}
// close it
fclose($fic);
 
// using the dictionary
afficheInfos($dico, "login10");
afficheInfos($dico, "X");
 
// end
exit;
 
// --------------------------------------------------------------------------
function afficheInfos($dico, $clé) {
  // displays the value associated with key in the $dico dictionary if it exists
  if (isset($dico[$clé])) {
    // value exists - is it a painting?
    $valeur = $dico[$clé];
    if (is_array($valeur)) {
      print "[$clé," . join(":", $valeur) . "]\n";
    } else {
      // $valeur is not an array
      print "[$clé,$valeur]\n";
    }
  } else {
    // $clé is not a key in the $dico dictionary
    print "la clé [$clé] n'existe pas\n";
  }
}
 
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
  // delete the end-of-line mark from $ligne if it exists
  $L = strlen($ligne);  // // line length
  while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
    $ligne = substr($ligne, 0, $L - 1);
    $L--;
  }
  // end
  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:

[login10,uid10:gid10:infos10:dir10:shell10]
la clé [X] n'existe pas

Kommentare

• Zeile 11: fopen(filename, "w") öffnet die Datei filename zum Schreiben (w = write). Wenn die Datei nicht existiert, wird sie angelegt. Wenn sie existiert, wird ihr Inhalt gelöscht. Wenn das Anlegen fehlschlägt, gibt fopen „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,$string) schreibt string in die Datei $fic.
• Zeile 20: fclose($fic) schließt die Datei $fic.
• Zeile 25: fopen(filename, "r") öffnet die Datei filename 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, begrenzt auf 1000 Zeichen. In der Anweisung while ($line = fgets($fic, 1000)) {…} finden zwei aufeinanderfolgende Operationen statt: 1) $line = fgets(...) 2) while ( ! $line). Nachdem das letzte Zeichen der Datei gelesen wurde, gibt die Funktion fgets eine leere Zeichenkette zurück und die while-Schleife wird beendet.
• Zeile 31: Die Funktion fgets liest eine Textzeile, einschließlich des Zeilenumbruchzeichens. Die Funktion cutNewLineChar in den Zeilen 70–79 entfernt alle Zeilenumbruchzeichen.
• Zeile 72: Die Funktion strlen($string) gibt die Anzahl der Zeichen in $string zurück.
• Zeile 73: Die Funktion substr($line, $position, $size) gibt $size Zeichen aus $line zurück, beginnend mit dem Zeichen an Position $position, wobei das erste Zeichen die Position 0 hat. Auf Windows-Rechnern lautet das Zeilenendezeichen „\r\n“. Auf Unix-Rechnern ist es die Zeichenkette „\n“.
• Zeile 35: Die Funktion array_shift($array) entfernt das erste Element aus $array und gibt es als Ergebnis zurück.
• Zeile 37: Die Funktion array_shift($array) wird verwendet, 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 </span>*<span style="color: #000000">join macht dasselbe wie die Funktion </span>*<span style="color: #000000">implode, die wir zuvor kennengelernt haben