Er is veel mysterie en verkeerde informatie over dit fundamentele gebied van PHP. Elke PHP ontwikkelaar leert hoe je tekst op een pagina kunt laten verschijnen. Meestal is dat met behulp van echo. Later moeten ze uitzoeken wat er eigenlijk in een variabele zit, en ze leren/ontdekken of print_r() of var_dump().
Vannacht heb ik een workshop bijgewoond, waar sommige aspecten van PHP werden geleerd aan mensen die nieuw zijn met de taal. Dit soort workshops zijn moeilijk te geven, omdat mensen vragen zullen stellen die alleen nieuwe mensen zouden stellen, en vaak gaan ze over gebieden van de taal die al lang vergeten of genegeerd zijn door ervaren PHP ontwikkelaars.
Een van de aanwezigen vroeg wat het verschil was tussen echo en print, en meteen dacht ik vrij zeker te zijn van hun functie. Toen dacht ik aan de subtiele verschillen tussen alle variabele printfuncties, en hoe die nooit echt in detail worden uitgelegd. Laten we daar eens verandering in brengen!
echo is een taalconstructie die op een functie lijkt, maar het niet is. Volgens de documentatie, voert het meerdere (string) parameters uit, maar wanneer ik dit probeer, genereert het een syntaxis fout:
php > echo("foo", "bar", "baz");
PHP Parse error: syntax error, unexpected ',' in php shell code on line 1
Hoe het ook zij, de haakjes zijn optioneel:
php > echo "foo"; echo("bar");
foobar
echo geeft geen waarde terug. De enige taak is het uitvoeren van een string.
Het lijkt erop dat ik meerdere strings had moeten proberen zonder de haakjes. Dank aan degenen die mij hierop hebben gewezen. ☺
In tegenstelling tot echo staat in de documentatie voor print correct vermeld dat het een enkele tekenreeks zal uitvoeren. Het is ook strikt genomen geen functie, maar zal bizar genoeg altijd 1 teruggeven. Het resultaat is dat de volgende dingen gebeuren:
php > print "foo"; print("bar"); print print print "baz";
foobarbaz11
Strange. Absoluut vreemd.
print_r
Na deze praktisch gelijkende constructies, begint print_r het idee van het uitvoeren van een variabele te ontwikkelen. Het idee achter print_r is om een menselijk leesbare representatie van een enkele variabele uit te voeren/terug te geven:
php > print_r("foo"); print_r(2); print_r(true);
foo21
De tweede (booleaanse) parameter van print_r vertelt PHP of de waarde moet worden teruggegeven of uitgevoerd. true betekent teruggeven, false betekent uitvoeren. De standaardwaarde is false.
php > echo print_r(, true);
Array
(
=> bar
)
print_r zal veel informatie teruggeven voor diep-nested objecten. Als het recursieve verwijzingen ziet, zal het die weglaten, en *RECURSION* weergeven. Het is je misschien ook opgevallen dat er witruimte rond delen van de uitvoer staat, wat de uitvoer leesbaarder maakt.
var_dump
Ook var_dump() geeft een representatie van een of meer variabelen. Net als echo zegt de documentatie voor var_dump() dat het meerdere variabelen kan verwerken. In tegenstelling tot echo lijkt dit waar te zijn:
php > var_dump("foo", "bar");
string(3) "foo"
string(3) "bar"php > var_dump(new StdClass);
class stdClass#1 (0) {
}
var_dump() toont ook geneste gegevens, maar het installeren van de XDebug-extensie zal dit beperken tot drie niveaus diep, en een configuratiewijziging vereisen om weer meer te tonen.
Deze XDebug-configuratiewijziging die u moet maken is xdebug.var_display_max_depth=n.
var_dump() voert geen extra witruimte uit, dus dit maakt het moeilijk om de uitvoer te lezen. Bovendien wikkelt de XDebug-extensie alles in HTML-elementen (voor syntax highlighting), dus het lezen van var_dump() uitvoer is een nachtmerrie op de commandoregel.
var_export
var_export() is vergelijkbaar met print_r(), in die zin dat het direct kan uitvoeren, of een string kan teruggeven. De uitvoer/teruggave is echter geldige PHP syntaxis:
php > var_export();
array (
'foo' => 'bar',
)
Je zult niet vaak een goed gebruik voor deze methode vinden, en als je dat doet zul je waarschijnlijk de representatie teruggeven (in plaats van uitvoer). Als je er een instantie aan doorgeeft, krijg je een nogal vreemde representatie:
php > $instance = new Thing();
php > $instance->foo = "bar";
php > var_export($instance);
Thing::__set_state(array(
'foo' => 'bar',
))
Als die code werd geparsed; de __set_state() methode zou worden aangeroepen op de Thing klasse. Hier is een voorbeeld van wat je dan zou kunnen doen:
class Thing
{
public $foo;
public static function __set_state($state)
{
$thing = new Thing();
$thing->foo = $state;
return $thing;
}
}
Je moet ook opmerken dat resource variabelen niet kunnen worden geëxporteerd:
php > var_export(fopen("http://google.com", "r"));
NULL
Dit is geweldig voor het oplossen van een heel specifiek probleem; het lezen, bijwerken en schrijven van PHP configuratiebestanden:
return ;
Dit is van config.php
$config = file_get_contents("config.php");
$config = "world";
file_put_contents(
"config.php",
"return " . var_export($config, true) . ";"
);
Dit komt uit update.php
return array (
'foo' => 'bar',
'hello' => 'world',
);
Dit komt uit config.php