var dump en php: Comment utiliser var_dump en PHP ?

Qu’est-ce que var dump en PHP ?

C’est une fonction native de PHP conçue pour inspecter le contenu d’une variable pendant la phase de développement. Elle révèle simultanément le type de donnée, la valeur stockée et, pour les chaînes, leur longueur en octets.

Disponible depuis PHP 4, elle reste aujourd’hui l’un des outils de diagnostic les plus utilisés pour identifier des incohérences de typage ou des valeurs inattendues dans un script. Son principal avantage sur les autres fonctions d’affichage est sa capacité à explorer récursivement les structures imbriquées comme les tableaux multidimensionnels et les objets.

Elle s’adresse aux développeurs qui ont besoin d’une lecture précise de l’état interne d’une variable à un instant précis de l’exécution. Cette transparence sur le type réel de la donnée est indispensable dès que votre code manipule des données provenant d’une API, d’un formulaire HTML ou d’une requête SQL.

Syntaxe et comportement

var_dump() accepte un ou plusieurs arguments de type mixed, ce qui couvre tous les types PHP natifs : entier, flottant, booléen, chaîne, tableau, objet et valeur nulle.

var_dump(mixed $value, mixed ...$values): void

La fonction écrit directement dans le flux de sortie courant et ne retourne aucune valeur utilisable. Elle n’effectue aucun trans-typage sur les données transmises, ce qui garantit que le type affiché est bien le type réel de la variable au moment de l’appel.

Passer une variable non initialisée ne déclenche pas d’erreur fatale, mais génère un avertissement PHP de niveau E_WARNING. Il est donc recommandé de contrôler l’existence d’une variable  avant tout appel à var_dump() dans un contexte de production.

Voici un appel sur quatre types distincts pour observer la précision du diagnostic produit par la fonction.

<?php
$libelle  = "Commande";
$quantite = 12;
$actif    = true;
$taux     = 5.5;

var_dump($libelle, $quantite, $actif, $taux);
?>

La sortie indique pour chaque variable son type entre parenthèses suivi de sa valeur : 

string(8) "Commande", int(12), bool(true), float(5.5)

Le chiffre 8 après string représente la longueur de la chaîne en octets, une information absente de toutes les autres fonctions d’affichage PHP. Vérifiez que chaque type correspond bien à ce que votre logique applicative attend à cet endroit du script.

Quelle est la différence entre echo et var_dump  ?

echo est un constructeur de langage qui produit une représentation textuelle brute d’une valeur, sans aucune métadonnée sur son type ou sa structure interne. Il est conçu pour afficher du contenu à destination de l’utilisateur final, pas pour analyser l’état d’une variable.

var_dump() expose en revanche le type précis de chaque donnée, ce qui devient critique lorsque deux valeurs semblent visuellement identiques mais appartiennent à des types différents. Cette distinction est déterminante lorsque vous utilisez l’opérateur de comparaison stricte === dans vos conditions.

Cet exemple illustre pourquoi echo peut masquer des erreurs de typage difficiles à détecter autrement dans un script PHP.

<?php
$ref_string = "0";
$ref_int    = 0;
$ref_bool   = false;

echo $ref_string; // Affiche : 0
echo $ref_int;    // Affiche : 0
echo $ref_bool;   // N'affiche rien

var_dump($ref_string); // string(1) "0"
var_dump($ref_int);    // int(0)
var_dump($ref_bool);   // bool(false)
?>

Les trois valeurs produisent une sortie identique ou vide avec echo, alors que var_dump() distingue clairement une chaîne, un entier et un booléen. Ce cas est fréquent lors du traitement de données issues d’un formulaire HTML, où toutes les valeurs arrivent initialement sous forme de chaîne. Ignorer cette différence peut provoquer des comportements inattendus dans vos blocs conditionnels.

Quelle est la différence entre print_r et var_dump  ?

print_r() produit une sortie orientée lisibilité humaine : elle affiche la structure d’un tableau ou d’un objet dans un format simplifié, sans préciser les types de données contenus. Son usage est adapté à une lecture rapide d’une structure, pas à un diagnostic de typage.

var_dump() est plus verbeux mais plus rigoureux : chaque valeur scalaire est accompagnée de son type explicite, et chaque chaîne est suivie de sa longueur en octets. Cette précision supplémentaire évite les faux diagnostics sur des valeurs dites falsy comme 0, "", false ou null.

Cet exemple sur un tableau de valeurs ambiguës rend visible la supériorité diagnostique de var_dump() sur print_r().

<?php
$valeurs = [0, false, "", null, "0"];

print_r($valeurs);
/*
Array ( [0] => 0 [1] => [2] => [3] => [4] => 0 )
*/

var_dump($valeurs);
/*
array(5) {
  [0]=> int(0)
  [1]=> bool(false)
  [2]=> string(0) ""
  [3]=> NULL
  [4]=> string(1) "0"
}
*/
?>

Avec print_r(), les index 0 et 4 semblent contenir la même valeur, et les index 1, 2, 3 paraissent tous vides. var_dump() révèle que ces cinq éléments sont de types entièrement distincts. Ce niveau de précision est indispensable pour déboguer des conditions impliquant des comparaisons lâches avec ==.

Quelle est la différence entre var_dump et var_export  ?

var_export() produit une représentation syntaxiquement valide en PHP, directement réexécutable dans un script. Elle est destinée à sérialiser une structure de données sous forme de code PHP natif, pas à diagnostiquer un type inconnu.

var_dump() produit une sortie lisible par un développeur mais non exécutable par PHP, enrichie de métadonnées de débogage. Choisissez var_dump() pour analyser l’état d’une variable et var_export() pour générer une configuration statique ou un jeu de données figé.

<?php
$parametres = ["actif" => true, "limite" => 50];

var_dump($parametres);
/*
array(2) {
  ["actif"]=> bool(true)
  ["limite"]=> int(50)
}
*/

var_export($parametres);
// array ( 'actif' => true, 'limite' => 50, )
?>

La sortie de var_export() peut être copiée et réutilisée directement dans un fichier de configuration PHP, contrairement à celle de var_dump(). Notez que var_export() ne prend pas en charge les références circulaires et génère une erreur fatale dans ce cas. Réservez var_dump() au débogage actif et var_export() à la génération de données statiques.

Comment stocker des valeurs dans une variable ?

var_dump() écrivant directement dans le flux de sortie, il est impossible d’assigner son résultat à une variable avec un simple =. Pour capturer sa sortie, vous devez activer le tampon de sortie PHP avant l’appel, puis le lire après.

Ce besoin est courant pour journaliser l’état d’une variable dans un fichier de log ou inclure un diagnostic dans une réponse JSON pendant le débogage d’une API REST.

<?php
$panier = ["produit" => "Clavier", "prix" => 49.90, "stock" => true];

ob_start();
var_dump($panier);
$diagnostic = ob_get_clean();

file_put_contents("debug.log", $diagnostic, FILE_APPEND);
?>

ob_start() redirige toute la sortie du script vers un tampon mémoire interne au lieu de l’envoyer au navigateur. ob_get_clean() récupère le contenu de ce tampon sous forme de chaîne et le vide simultanément. Vérifiez que la variable $diagnostic n’est pas vide avant de l’écrire dans votre fichier de log pour éviter des entrées inutiles.

Afficher var_dump() lisiblement en HTML

Dans un navigateur, la sortie brute de var_dump() s’affiche sur une seule ligne compressée car le rendu HTML ignore les sauts de ligne du texte ordinaire. Envelopper l’appel dans une balise <pre> préserve l’indentation et la hiérarchie des données imbriquées.

<?php
$commande = [
    "id"       => 1042,
    "client"   => "Alice Dupont",
    "articles" => ["Souris", "Câble USB"],
    "remise"   => false
];

echo "<pre>";
var_dump($commande);
echo "</pre>";
?>

La balise <pre> indique au navigateur de traiter le contenu comme du texte préformaté, en conservant chaque niveau d’indentation produit par var_dump(). La structure du tableau $articles s’affiche alors avec une hiérarchie visuelle claire, reflétant fidèlement la profondeur de l’imbrication. Supprimez systématiquement ces blocs de débogage HTML avant tout déploiement en environnement de production.

Désactiver var_dump() en production

Laisser des appels var_dump() actifs en production expose la structure interne de votre application et constitue une faille de sécurité par divulgation d’informations. Une fonction utilitaire conditionnelle permet de centraliser ce contrôle sans avoir à supprimer chaque appel manuellement avant chaque mise en production.

<?php
define('ENV', 'development'); // Remplacer par 'production' sur le serveur

function inspecter(mixed $valeur, string $etiquette = ''): void {
    if (ENV !== 'development') return;
    if ($etiquette !== '') echo "<strong>{$etiquette}</strong><br>";
    echo "<pre>";
    var_dump($valeur);
    echo "</pre>";
}

$token = bin2hex(random_bytes(8));
inspecter($token, "Token généré");
?>

La constante ENV pilote l’affichage : en la passant à 'production', tous les appels à inspecter() deviennent silencieux sans modifier le reste du code. L’étiquette optionnelle $etiquette permet d’identifier chaque point d’inspection dans un fichier comportant de multiples appels. Préférez une variable d’environnement serveur à une constante codée en dur pour une gestion cohérente entre vos environnements de développement, staging et production.

Sources: PHPnet