Det finns många mysterier och felaktig information om detta grundläggande område inom PHP. Varje PHP-utvecklare lär sig hur man får text att visas på en sida. Vanligtvis är det med hjälp av echo. Senare måste de ta reda på vad som egentligen finns inuti en variabel, och de får lära sig/upptäcka antingen print_r() eller var_dump().
Ikväll deltog jag i en workshop, där vissa aspekter av PHP lärdes ut till personer som är nya i språket. Den här typen av workshops är svåra att ge, eftersom folk kommer att ställa frågor som bara nya människor skulle kunna ställa, och ofta handlar de om områden av språket som sedan länge är bortglömda eller ignorerade av erfarna PHP-utvecklare.
En av deltagarna frågade vad skillnaden var mellan echo och print, och genast tänkte jag ganska säkert på deras funktion. Sedan tänkte jag på de subtila skillnaderna mellan alla variabla utskriftsfunktioner och hur de aldrig riktigt förklaras i detalj. Låt oss ändra på det!
echo är en språkkonstruktion som ser ut som en funktion, men som inte är det. Enligt dokumentationen; den ger ut flera (sträng)parametrar, men när jag försöker detta genererar den ett syntaxfel:
php > echo("foo", "bar", "baz");
PHP Parse error: syntax error, unexpected ',' in php shell code on line 1
Hursomhelst är parenteserna valfria:
php > echo "foo"; echo("bar");
foobar
echo returnerar inte ett värde. Dess enda uppgift är att ge ut en sträng.
Det verkar som om jag borde ha försökt med flera strängar utan parenteser. Tack till dem som har påpekat detta. ☺
Till skillnad från echo; dokumentationen för print anger korrekt att den ger ut en enda sträng. Det är inte heller strikt en funktion, men kommer bisarrt nog alltid att returnera 1. Som ett resultat av detta händer följande saker:
php > print "foo"; print("bar"); print print print "baz";
foobarbaz11
Strängt. Definitivt konstigt.
print_r
Med utgångspunkt i dessa praktiskt taget likartade konstruktioner börjar print_r utveckla idén om att ge ut en variabel. Tanken bakom print_r är att ge ut/återge en människoläsbar representation av en enda variabel:
php > print_r("foo"); print_r(2); print_r(true);
foo21
Den andra (boolska) parametern i print_r talar om för PHP om värdet ska returneras eller ges ut. true betyder return, false betyder output. Standardvärdet är false.
php > echo print_r(, true);
Array
(
=> bar
)
print_r returnerar mycket information för djupt inbäddade objekt. När den upptäcker rekursiva referenser kommer den att utelämna dem och visa *RECURSION*. Du kanske också har lagt märke till att det finns whitespace som omger delar av utmatningen, vilket gör utmatningen lättare att läsa.
var_dump
Samma sak, var_dump() ger ut en representation av en eller flera variabler. Liksom echo säger dokumentationen för var_dump() att den kan hantera flera variabler. Till skillnad från echo verkar detta vara sant:
php > var_dump("foo", "bar");
string(3) "foo"
string(3) "bar"php > var_dump(new StdClass);
class stdClass#1 (0) {
}
var_dump() visar även inbäddade data, men om XDebug-tillägget installeras begränsas detta till tre nivåer djupt, och det krävs en konfigurationsändring för att visa mer igen.
Denna XDebug-konfigurationsändring du behöver göra är xdebug.var_display_max_depth=n.
var_dump() ger inte ut extra vitrymder, så detta gör det svårt att läsa utdata. Dessutom kommer XDebug-tillägget att slå in allt i HTML-element (för syntaxmarkering), så att läsa var_dump()-utdata är en mardröm på kommandoraden.
var_export
var_export() liknar print_r(), i det avseendet att den kan ge direkt utdata, eller returnera en sträng. Utmatning/retur är dock giltig PHP-syntax:
php > var_export();
array (
'foo' => 'bar',
)
Du kommer inte ofta att hitta ett bra användningsområde för den här metoden, och när du gör det kommer du förmodligen att returnera (snarare än att mata ut) representationen. När du skickar en instans till den får du en ganska märklig representation:
php > $instance = new Thing();
php > $instance->foo = "bar";
php > var_export($instance);
Thing::__set_state(array(
'foo' => 'bar',
))
Om den koden parsades; metoden __set_state() skulle anropas på Thing-klassen. Här är ett exempel på vad du skulle kunna göra då:
class Thing
{
public $foo;
public static function __set_state($state)
{
$thing = new Thing();
$thing->foo = $state;
return $thing;
}
}
Du bör också notera att resursvariabler inte kan exporteras:
php > var_export(fopen("http://google.com", "r"));
NULL
Detta är utmärkt för att lösa ett mycket specifikt problem; att läsa, uppdatera och skriva PHP-konfigurationsfiler:
return ;
Detta är från config.php
$config = file_get_contents("config.php");
$config = "world";
file_put_contents(
"config.php",
"return " . var_export($config, true) . ";"
);
Detta är från update.php
Detta är från config.php