3. De basisprincipes van PHP
3.1. Een eerste voorbeeld
Hieronder vindt u een programma dat de eerste kenmerken van PHP laat zien.
3.1.1. Het programma (exemple_01)
<?php
// dit is een opmerking
// variabele gebruikt zonder te zijn gedeclareerd
$nom = "dupont";
// een schermweergave
print "nom=$nom\n";
// een array met elementen van verschillende typen
$tableau = array("un", "deux", 3, 4);
// het aantal elementen
$n = count($tableau);
// een lus
for ($i = 0; $i < $n; $i++)
print "tableau[$i]=$tableau[$i]\n";
// initialisatie van 2 variabelen met de inhoud van een array
list($chaine1, $chaine2) = array("chaine1", "chaine2");
// samenvoeging van de 2 tekenreeksen
$chaine3 = $chaine1 . $chaine2;
// weergave van het resultaat
print "[$chaine1,$chaine2,$chaine3]\n";
// gebruik van een functie
affiche($chaine1);
// het type van een variabele kan bekend zijn
afficheType($n);
afficheType($chaine1);
afficheType($tableau);
// het type van een variabele kan tijdens de uitvoering veranderen
$n = "a changé";
afficheType($n);
// een functie kan een resultaat retourneren
$res1 = f1(4);
print "res1=$res1\n";
// een functie kan een array met waarden retourneren
list($res1, $res2, $res3) = f2();
print "(res1,res2,res3)=[$res1,$res2,$res3]\n";
// deze waarden hadden in een array kunnen worden opgeslagen
$t = f2();
for ($i = 0; $i < count($t); $i++)
print "t[$i]=$t[$i]\n";
// tests
for ($i = 0; $i < count($t); $i++)
// geeft alleen de zenders weer
if (getType($t[$i]) == "string")
print "t[$i]=$t[$i]\n";
// andere tests
for ($i = 0; $i < count($t); $i++){
// geeft alleen gehele getallen >10 weer
if (getType($t[$i]) == "integer" and $t[$i] > 10)
print "t[$i]=$t[$i]\n";
}
// een while-lus
$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";
// einde programma
exit;
//----------------------------------
function affiche($chaine) {
// geeft $chaine weer
print "chaine=$chaine\n";
}
//----------------------------------
function afficheType($variable) {
// toont het type van $variable
print "type[$variable]=" . getType($variable) . "\n";
}
//----------------------------------
function f1($param) {
// voegt 10 toe aan $param
return $param + 10;
}
//----------------------------------
function f2() {
// geeft 3 waarden weer
return array("un", 0, 100);
}
?>
De resultaten:
Opmerkingen
- regel 5: in PHP wordt het type van de variabelen niet gedeclareerd. Deze hebben een dynamisch type dat in de loop van de tijd kan variëren
- $nom vertegenwoordigt de variabele met de identificatiecode nom
- regel 8: om iets op het scherm weer te geven, kan men de instructie print of de instructie echo gebruiken
- regel 11: met het sleutelwoord array kan een array worden gedefinieerd. De variabele $nom[$i] vertegenwoordigt het element $i van de array $tableau.
- regel 14: de functie count($tableau) geeft het aantal elementen van de array $tableau weer
- regel 18: tekenreeksen worden omsloten door aanhalingstekens " of apostrofs '. Binnen aanhalingstekens worden de variabelen $variable geëvalueerd, maar niet binnen apostrofs.
- regel 21: met de functie list kunnen variabelen in een lijst worden verzameld en met één enkele toewijzingsbewerking een waarde krijgen. Hier is $chaine1="string1" en $chaine2="string2".
- regel 24: de operator . is de operator voor het samenvoegen van tekenreeksen.
- regel 88: het sleutelwoord function definieert een functie. Een functie retourneert al dan niet waarden via de instructie return. De aanroepende code kan de resultaten van een functie negeren of ophalen. Een functie kan overal in de code worden gedefinieerd.
- regel 90: de vooraf gedefinieerde functie getType($variable) retourneert een tekenreeks die het type van $variable weergeeft. Dit type kan in de loop van de tijd veranderen.
- regel 79: de vooraf gedefinieerde functie exit beëindigt het script.
3.2. Het bereik van de variabelen
3.2.1. Programma 1 (exemple_02)
<?php
// bereik van de variabelen
function f1() {
// we gebruiken de globale variabele $i
$i = &$GLOBALS["i"];
$i++;
$j = 10;
print "f1[i,j]=[$i,$j]\n";
}
function f2() {
// er wordt gebruikgemaakt van de globale variabele $i
$i = &$GLOBALS["i"];
$i++;
$j = 20;
print "f2[i,j]=[$i,$j]\n";
}
function f3() {
// er wordt een lokale variabele $i gebruikt
$i = 4;
$j = 30;
print "f3[i,j]=[$i,$j]\n";
}
// tests
$i = 0;
$j = 0; // deze twee variabelen zijn bekend bij een functie f via de array $GLOBALS
f1();
f2();
f3();
print "test[i,j]=[$i,$j]\n";
?>
De resultaten:
Opmerkingen
- regels 29-30: definiëren twee variabelen, $i en $j, van het hoofdprogramma. Deze variabelen zijn niet bekend binnen de functies. Zo is in regel 9 de variabele $j van de functie f1 een lokale variabele van de functie f1 en verschilt deze van de variabele $j van het hoofdprogramma. Een functie kan toegang krijgen tot een variabele $variable van het hoofdprogramma via een array van globale variabelen met de naam $GLOBALS. In regel 7 verwijst de notatie $GLOBALS["i"] naar de globale variabele $i van het hoofdprogramma. Als we schrijven
aan de lokale variabele $i wordt de waarde van de globale variabele $i toegewezen. Het gaat hier om twee verschillende variabelen en het wijzigen van de lokale variabele $i heeft geen invloed op de globale variabele $i. De notatie
betekent dat de lokale variabele $i hetzelfde geheugenadres heeft als de globale variabele $i. Het bewerken van de lokale variabele $i komt dan neer op het bewerken van de globale variabele $i.
3.2.2. Programma 2 (exemple_03)
<?php
// het bereik van een variabele is globaal voor de codeblokken
$i = 0; {
$i = 4;
$i++;
}
print "i=$i\n";
?>
De resultaten:
Opmerkingen
In sommige programmeertalen heeft een variabele die binnen accolades is gedefinieerd, het bereik van die accolades: buiten die accolades is de variabele niet bekend. Uit bovenstaande resultaten blijkt dat dit in PHP niet het geval is. De variabele $i, die in regel 5 binnen de accolades is gedefinieerd, is dezelfde als die welke in de regels 4 en 8 buiten de accolades wordt gebruikt.
3.3. De tabellen
3.3.1. Klassieke eendimensionale tabellen (exemple_04)
<?php
// klassieke tabellen
// initialisatie
$tab1 = array(0, 1, 2, 3, 4, 5);
// doorlopen - 1
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// doorlopen - 2
print "tab1 a " . count($tab1) . " éléments\n";
reset($tab1);
while (list($clé, $valeur) = each($tab1))
print "tab1[$clé]=$valeur\n";
// elementen toevoegen
$tab1[] = $i++;
$tab1[] = $i++;
// doorlopen - 3
print "tab1 a " . count($tab1) . " éléments\n";
$i = 0;
foreach ($tab1 as $élément) {
print "tab1[$i]=$élément\n";
$i++;
}
// laatste element verwijderen
array_pop($tab1);
// doorloop - 4
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// eerste element verwijderen
array_shift($tab1);
// doorlopen - 5
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// toevoegen aan het einde van de tabel
array_push($tab1, -2);
// doorloop - 6
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
// toevoegen aan het begin van de tabel
array_unshift($tab1, -1);
// doorloop - 7
print "tab1 a " . count($tab1) . " éléments\n";
for ($i = 0; $i < count($tab1); $i++)
print "tab1[$i]=$tab1[$i]\n";
?>
De resultaten:
Opmerkingen
Het bovenstaande programma toont bewerkingen op een array met waarden. Er zijn twee notaties voor arrays in PHP:
Tabel 1 wordt een array genoemd en tabel 2 een woordenboek, waarbij de elementen worden genoteerd als sleutel => waarde. De notatie $contraires["beau"] verwijst naar de waarde die bij de sleutel "mooi" hoort. Dat is hier dus de tekenreeks "lelijk". Tabel 1 is slechts een variant van het woordenboek en zou als volgt kunnen worden weergegeven:
Zo hebben we $tableau[2]="drie". Uiteindelijk zijn het allemaal woordenboeken. In het geval van een klassieke array met n elementen zijn de sleutels de gehele getallen uit het interval [0,n-1].
- regel 15: met de functie each($tableau) kun je door een woordenboek lopen. Bij elke aanroep retourneert deze functie een (sleutel, waarde)-paar uit het woordenboek.
- regel 14: de functie reset($dictionnaire) zet de functie each op het eerste (sleutel,waarde)-paar van het woordenboek.
- regel 15: de lus while stopt wanneer de functie each een leeg paar retourneert aan het einde van het woordenboek.
- regel 19: de notatie $tableau[]=waarde voegt het element valeur toe als laatste element van $tableau.
- regel 25: de array wordt doorlopen met een foreach. Met dit syntactische element kan een woordenboek, en dus een array, op twee manieren worden doorlopen:
De eerste syntaxis retourneert bij elke iteratie een paar (clé,valeur), terwijl de tweede syntaxis alleen het element valeur uit het woordenboek retourneert.
- regel 31: de functie array_pop($tableau) verwijdert het laatste element uit $tableau
- regel 39: de functie array_shift($tableau) verwijdert het eerste element uit $tableau
- regel 47: de functie array_push($tableau,waarde) voegt valeur toe als laatste element van $tableau
- regel 39: de functie array_unshift($tableau,waarde) voegt valeur toe als eerste element van $tableau
3.3.2. Het woordenboek (exemple_05)
<?php
// woordenboeken
$conjoints = array("Pierre" => "Gisèle", "Paul" => "Virginie", "Jacques" => "Lucette", "Jean" => "");
// doorloop - 1
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
print "conjoints[$clé]=$valeur\n";
// sorteren van het woordenboek op de sleutel
ksort($conjoints);
// doorloop - 2
reset($conjoints);
while (list($clé, $valeur) = each($conjoints))
print "conjoints[$clé]=$valeur\n";
// lijst met sleutels van het woordenboek
$clés = array_keys($conjoints);
for ($i = 0; $i < count($clés); $i++)
print "clés[$i]=$clés[$i]\n";
// lijst met waarden van het woordenboek
$valeurs = array_values($conjoints);
for ($i = 0; $i < count($valeurs); $i++)
print "valeurs[$i]=$valeurs[$i]\n";
// zoeken naar een sleutel
existe($conjoints, "Jacques");
existe($conjoints, "Lucette");
existe($conjoints, "Jean");
// een sleutel-waarde verwijderen
unset($conjoints["Jean"]);
print "Nombre d'éléments du dictionnaire : " . count($conjoints) . "\n";
foreach ($conjoints as $clé => $valeur) {
print "conjoints[$clé]=$valeur\n";
}
// einde
exit;
function existe($conjoints, $mari) {
// controleert of de sleutel $mari voorkomt in het woordenboek $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";
}
?>
De resultaten:
Opmerkingen
De bovenstaande code past op een woordenboek toe wat eerder is besproken voor een eenvoudige tabel. We geven alleen uitleg bij de nieuwe elementen:
- regel 13: met de functie ksort (key sort) kan een woordenboek worden gesorteerd in de natuurlijke volgorde van de sleutels.
- regel 21: de functie array_keys($dictionnaire) geeft de lijst met sleutels van het woordenboek weer in de vorm van een tabel
- regel 26: de functie array_values($dictionnaire) geeft de lijst met waarden van het woordenboek weer in de vorm van een tabel
- regel 47: de functie isset($variable) retourneert true als de variabele $variable is gedefinieerd, anders false.
- regel 36: de functie unset($variable) verwijdert de variabele $variable.
3.3.3. Meerdimensionale tabellen (exemple_06)
<?php
// klassieke multidimensionale tabellen
// initialisatie
$multi = array(array(0, 1, 2), array(10, 11, 12, 13), array(20, 21, 22, 23, 24));
// doorloop
for ($i1 = 0; $i1 < count($multi); $i1++)
for ($i2 = 0; $i2 < count($multi[$i1]); $i2++)
print "multi[$i1][$i2]=" . $multi[$i1][$i2] . "\n";
// multidimensionale woordenboeken
// initialisatie
$multi = array("zéro" => array(0, 1, 2), "un" => array(10, 11, 12, 13), "deux" => array(20, 21, 22, 23, 24));
// doorlopen
foreach ($multi as $clé => $valeur)
for ($i2 = 0; $i2 < count($valeur); $i2++)
print "multi[$clé][$i2]=" . $multi[$clé][$i2] . "\n";
?>
Resultaten:
Opmerkingen
- regel 5: de elementen van de tabel $multi zijn zelf tabellen
- regel 12: de tabel $multi wordt een woordenboek (clé,valeur) waarin elke valeur een tabel is
3.3.4. Koppelingen tussen tekenreeksen en tabellen (exemple_07)
<?php
// string naar array
$chaine = "1:2:3:4";
$tab = explode(":", $chaine);
// doorlopen van een array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n";
// van array naar tekenreeks
$chaine2 = implode(":", $tab);
print "chaine2=$chaine2\n";
// een leeg veld toevoegen
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// doorlopen van array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n"; // we hebben nu 5 elementen, waarvan het laatste leeg is
// laten we opnieuw een leeg veld toevoegen
$chaine.=":";
print "chaîne=$chaine\n";
$tab = explode(":", $chaine);
// doorloop de array
print "tab a " . count($tab) . " éléments\n";
for ($i = 0; $i < count($tab); $i++)
print "tab[$i]=$tab[$i]\n"; // we hebben nu 6 elementen, waarvan de laatste twee leeg zijn
?>
Resultaten:
Opmerkingen
- regel 5: met de functie explode($séparateur,$chaine) kunnen de velden van $chaine worden opgehaald, gescheiden door $séparateur. Zo haalt explode(":",$chaine) de elementen van $chaine die gescheiden zijn door de tekenreeks ":" op in de vorm van een array.
- De functie implode($séparateur,$tableau) voert de omgekeerde bewerking uit van de functie explode. Deze functie retourneert een tekenreeks die bestaat uit de elementen van $tableau, gescheiden door $séparateur.
3.4. De tekenreeksen
3.4.1. Notatie (exemple_08)
<?php
// notatie van tekenreeksen
$chaine1 = "un";
$chaine2 = 'un';
print "[$chaine1,$chaine2]\n";
?>
Resultaten:
3.4.2. Vergelijking (exemple_09)
<?php
// tests voor het vergelijken van tekenreeksen
compare("abcd", "abcd");
compare("", "");
compare("1", "");
exit;
function compare($chaine1, $chaine2) {
// vergelijkt string1 en string2
if ($chaine1 == $chaine2)
print "[$chaine1] est égal à [$chaine2]\n";
else
print "[$chaine1] est différent de [$chaine2]\n";
}
?>
Resultaten:
3.5. Reguliere expressies (exemple_10)
<?php
// reguliere expressies in PHP
// de verschillende velden van een tekenreeks ophalen
// het patroon: een reeks cijfers omgeven door willekeurige tekens
// we willen alleen de reeks cijfers ophalen
$modèle = "/(\d+)/";
// we vergelijken de tekenreeks met het patroon
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
// het patroon: een reeks cijfers omgeven door willekeurige tekens
// we willen de reeks cijfers en de velden ervoor en erna
$modèle = "/^(.*?)(\d+)(.*?)$/";
// we vergelijken de tekenreeks met het patroon
compare($modèle, "xyz1234abcd");
compare($modèle, "12 34");
compare($modèle, "abcd");
// het patroon: een datum in de notatie dd/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");
// het patroon – een decimaal getal
$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");
// einde
exit;
// --------------------------------------------------------------------------
function compare($modèle, $chaîne) {
// vergelijkt de tekenreeks $chaîne met het sjabloon $modèle
// de tekenreeks wordt vergeleken met het patroon
$correspond = preg_match($modèle, $chaîne, $champs);
// weergave van de resultaten
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";
}
?>
Resultaten:
Opmerkingen
- regels 3-4: hier gebruiken we reguliere expressies om de verschillende velden uit een tekenreeks te halen. Met reguliere expressies kunnen we de beperkingen van de functie implode omzeilen. Het principe is om een tekenreeks te vergelijken met een andere tekenreeks, genaamd modèle, met behulp van de functie preg_match:
$correspond = preg_match($modèle, $chaîne, $champs);
De functie preg_match retourneert een booleaanse waarde als modèle in chaîne kan worden gevonden. Zo ja, dan vertegenwoordigt $champs[0] de subreeks die overeenkomt met het sjabloon. Als het model bovendien submodellen tussen haakjes bevat, is $champs[1] het deel van $chaîne dat overeenkomt met het eerste submodel, $champs[2] is het deel van $chaîne dat overeenkomt met het tweede subpatroon, enzovoort...
Laten we het eerste voorbeeld eens bekijken. Het patroon wordt gedefinieerd in regel 8: het verwijst naar een reeks van één of meer (+) cijfers (\d) die op een willekeurige plaats in een tekenreeks voorkomen. Daarnaast definieert het patroon een subpatroon dat tussen haakjes staat.
- regel 10: het patroon /(\d+)/ (reeks van één of meer cijfers op willekeurige plaatsen in de tekenreeks) wordt vergeleken met de tekenreeks "xyz1234abcd". We zien dat de subreeks 1234 overeenkomt met het patroon. We krijgen dus $champs[0] gelijk aan "1234". Bovendien bevat het patroon subpatronen tussen haakjes. We krijgen dan $champs[1] = "1234".
- regel 11: het patroon /(\d+)/ wordt vergeleken met de tekenreeks "12 34". We zien dat de deelreeksen 12 en 34 aan het patroon voldoen. De vergelijking stopt bij de eerste deelreeks die aan het patroon voldoet. We krijgen dus $champs[0]=12 en $champs[1]=12.
- regel 12: het patroon /(\d+)/ wordt vergeleken met de tekenreeks "abcd". Er wordt geen overeenkomst gevonden.
Laten we de patronen die verderop in de code worden gebruikt eens toelichten:
$modèle = "/^(.*?)(\d+)(.*?)$/";
begin van de tekenreeks (^), gevolgd door 0 of meer (*) willekeurige tekens (.), gevolgd door 1 of meer (+) cijfers, en vervolgens opnieuw 0 of meer (*) willekeurige tekens (.). Het patroon (.*) staat voor 0 of meer willekeurige tekens. Zo’n patroon komt overeen met elke willekeurige tekenreeks. Het patroon /^(.*)(\d+)(.*)$/ zal dus nooit worden gevonden, omdat het eerste subpatroon (.*) de hele tekenreeks opneemt. Het patroon (.*?)(\d+) duidt daarentegen 0 of meer willekeurige tekens aan tot aan het volgende subpatroon (?), in dit geval \d+. De cijfers worden dus nu niet meer door het patroon (.*) opgeslokt. Het bovenstaande patroon komt dus overeen met [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*$/";
komt overeen met [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. Wijze van doorgeven van functieparameters (exemple_11)
<?php
// wijze van parameteroverdracht
function f(&$i, $j) {
// $i wordt verkregen via verwijzing
// $j wordt verkregen via de waarde
$i++;
$j++;
print "f[i,j]=[$i,$j]\n";
}
// ----------------------------------------tests
$i = 0;
$j = 0;
// $i en $j doorgegeven als waarden
f($i, $j);
print "test[i,j]=[$i,$j]\n";
?>
Resultaten:
Opmerkingen
De bovenstaande code toont de twee manieren waarop parameters aan een functie kunnen worden doorgegeven. Laten we het volgende voorbeeld nemen:
- regel 1: definieert de formele parameters $a en $b van de functie f. Deze functie verwerkt deze twee formele parameters en retourneert een resultaat.
- regel 7: aanroep van de functie f met twee effectieve parameters $i en $j. De koppelingen tussen de formele parameters ($a, $b) en de effectieve parameters ($i, $j) worden gedefinieerd door regel 7
- &$a: het teken & geeft aan dat de formele parameter $a de waarde krijgt van het adres van de effectieve parameter $i. Met andere woorden: $a en $i zijn twee verwijzingen naar dezelfde geheugenlocatie. Het bewerken van de formele parameter $a komt neer op het bewerken van de effectieve parameter $i. Dit blijkt uit de uitvoering van de code. Deze overdrachtswijze is geschikt voor uitvoerparameters en omvangrijke gegevens, zoals arrays en woordenboeken. Deze overdrachtswijze wordt ‘overdracht via verwijzing’ genoemd.
- $b: de formele parameter $b krijgt de waarde van de effectieve parameter $j. Dit is een overdracht per waarde. De formele en effectieve parameters zijn twee verschillende variabelen. Het bewerken van de formele parameter $b heeft geen invloed op de effectieve parameter $j. Dit blijkt uit de uitvoering van de code. Deze overdrachtswijze is geschikt voor invoerparameters.
- Neem bijvoorbeeld de functie échange, die twee formele parameters $a en $b accepteert. De functie verwisselt de waarden van deze twee parameters. Bij een aanroep met parameteruitwisseling ($i,$j) verwacht de aanroepende code dus dat de waarden van de twee daadwerkelijke parameters worden verwisseld. Het zijn dus uitgangsparameters (ze worden gewijzigd). We schrijven dan:
3.7. Resultaten die door een functie worden geretourneerd (exemple_12)
<?php
// resultaten die door een functie worden geretourneerd
// een functie kan meerdere waarden in een array retourneren
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";
// een functie kan een pseudo-object retourneren
$res = f2(10);
print "[$res->res1,$res->res2,$res->res3]\n";
// einde
exit;
// functie f1
function f1($valeur) {
// geeft een array terug ($valeur+1,$aleur+2,$baleur+3)
return array($valeur + 1, $valeur + 2, $valeur + 3);
}
// functie f2
function f2($valeur) {
// geeft een pseudo-object terug ($valeur+1,$aleur+2,$baleur+3)
$res->res1 = $valeur + 1;
;
$res->res2 = $valeur + 2;
$res->res3 = $valeur + 3;
// geeft het object terug
return $res;
}
?>
Resultaten
Opmerkingen
- Het vorige programma laat zien dat een functie PHP een reeks resultaten kan retourneren in plaats van één enkel resultaat, in de vorm van een array of een object. Het begrip 'object' wordt iets verderop toegelicht
- regels 19-22: de functie f1 retourneert meerdere waarden in de vorm van een array
- regels 25-33: de functie f2 retourneert meerdere waarden in de vorm van een object
3.8. Tekstbestanden (exemple_13)
<?php
// sequentiële verwerking van een tekstbestand
// dit is een verzameling regels in de vorm login:pwd:uid:gid:infos:dir:shell
// elke regel wordt in een woordenboek geplaatst in de vorm login => uid:gid:infos:dir:shell
// de bestandsnaam wordt vastgelegd
$INFOS = "infos.txt";
// het bestand wordt geopend om te worden aangemaakt
if (!$fic = fopen($INFOS, "w")) {
print "Erreur d'ouverture du fichier $INFOS en écriture\n";
exit;
}
// er wordt willekeurige inhoud gegenereerd
for ($i = 0; $i < 100; $i++)
fputs($fic, "login$i:pwd$i:uid$i:gid$i:infos$i:dir$i:shell$i\n");
// het bestand wordt gesloten
fclose($fic);
// we maken er gebruik van – fgets behoudt de regeleinde-markering
// hierdoor wordt voorkomen dat er een lege tekenreeks wordt opgehaald bij het lezen van een lege regel
// het bestand wordt geopend in de modus 'aanmaken'
if (!$fic = fopen($INFOS, "r")) {
print "Erreur d'ouverture du fichier $INFOS en lecture\n";
exit;
}
while ($ligne = fgets($fic, 1000)) {
// het einde-van-regel-teken wordt verwijderd, indien aanwezig
$ligne = cutNewLineChar($ligne);
// we plaatsen de regel in een array
$infos = explode(":", $ligne);
// de login wordt opgehaald
$login = array_shift($infos);
// het wachtwoord wordt genegeerd
array_shift($infos);
// er wordt een vermelding in het woordenboek aangemaakt
$dico[$login] = $infos;
}
// we sluiten het
fclose($fic);
// het woordenboek wordt gebruikt
afficheInfos($dico, "login10");
afficheInfos($dico, "X");
// einde
exit;
// --------------------------------------------------------------------------
function afficheInfos($dico, $clé) {
// de waarde weergeven die bij de sleutel in het woordenboek hoort $dico, indien deze bestaat
if (isset($dico[$clé])) {
// waarde bestaat – is het een array?
$valeur = $dico[$clé];
if (is_array($valeur)) {
print "[$clé," . join(":", $valeur) . "]\n";
} else {
// $valeur is geen array
print "[$clé,$valeur]\n";
}
} else {
// $clé is geen sleutel in het woordenboek $dico
print "la clé [$clé] n'existe pas\n";
}
}
// --------------------------------------------------------------------------
function cutNewLinechar($ligne) {
// de regeleinde-markering van $ligne wordt verwijderd, indien deze bestaat
$L = strlen($ligne); // regellengte
while (substr($ligne, $L - 1, 1) == "\n" or substr($ligne, $L - 1, 1) == "\r") {
$ligne = substr($ligne, 0, $L - 1);
$L--;
}
// einde
return($ligne);
}
?>
Het bestand 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
De resultaten:
Opmerkingen
- regel 11: fopen(nom_fichier,"w") opent het bestand nom_fichier in schrijfmodus (w=write). Als het bestand niet bestaat, wordt het aangemaakt. Als het bestaat, wordt het leeggemaakt. Als het aanmaken mislukt, retourneert fopen de waarde false. In de instructie if (!$fic = fopen($INFOS, "w")) {…} vinden twee opeenvolgende bewerkingen plaats: 1) $fic = fopen(..) 2) if( ! $fic) {...}
- regel 18: fputs($fic, $chaîne) schrijft chaîne naar het bestand $fic.
- regel 20: fclose($fic) sluit het bestand $fic.
- regel 25: fopen(nom_fichier,"r") opent het bestand nom_fichier in leesmodus (r=read). Als het openen mislukt (het bestand bestaat niet), retourneert fopen de waarde false.
- regel 29: fgets($fic,1000) leest de volgende regel uit het bestand, met een limiet van 1000 tekens. In de while-constructie ($ligne = fgets($fic, 1000)) {…} vinden twee opeenvolgende bewerkingen plaats: 1) $ligne = fgets(...) 2) while ( ! $ligne). Nadat het laatste teken van het bestand is gelezen, retourneert de functie fgets de lege tekenreeks en stopt de lus while.
- regel 31: de functie fgets leest een tekstregel, inclusief het einde-van-regel-teken. De functie cutNewLineChar in de regels 70-79 verwijdert het eventuele einde-van-regel-teken.
- regel 72: de functie strlen($chaîne) geeft het aantal tekens van $chaîne weer.
- regel 73: de functie substr($ligne, $position, $taille) levert $taille tekens op uit $ligne, beginnend bij teken nr. $position, waarbij het eerste teken nummer 0 heeft. Op Windows-computers is het teken voor het einde van een regel "\r\n". Op Unix-computers is dit de tekenreeks "\n".
- regel 35: de functie array_shift($tableau) verwijdert het eerste element uit $tableau en geeft dit als resultaat weer.
- regel 37: de functie array_shift($tableau) wordt gebruikt, maar het resultaat ervan wordt genegeerd
- regel 57: de functie is_array($variable) retourneert true als $variable een array is, en anders false.
- regel 58: de functie join doet hetzelfde als de functie implode die we al eerder zijn tegengekomen