PHP analizzare il contenuto delle variabili con var_dump()

Funzione var_dump in PHP: leggere meglio il contenuto delle variabili

di

Quando si scrive un programma è fondamentale poter analizzare tutti i dati che vengono processati durante la sua esecuzione: stringhe, numeri interi, numeri decimali, valori booleani, funzioni, classi e array.

Scrivendo del codice ci ritroveremo di fronte a due casi:

  • otteniamo un dato o una serie di dati da un database, API, funzione ecc.
  • dobbiamo inviare dati specifici a un programma, funzione, classe ecc.

In questo caso è fondamentale avere uno strumento per poter:

  • sapere la tipologia di dato
  • la sua dimensione
  • la sua organizzazione

In PHP abbiamo una funzione, non è un costrutto, molto utile per fare ciò ovvero: var_dump().

Al suo interno possiamo passare tutti i parametri che vogliamo per analizzarli successivamente.

Questa funzione non ritornerà nulla, ma stamperà direttamente su schermo tutte le informazioni principali di una variabile o di un set di dati che abbiamo inserito come parametro.

Le informazioni che ci darà questa funzione dopo la sua esecuzione sono:

  • il tipo di dato (string, int, float, bool, object, array, object ecc.)
  • la lunghezza dei caratteri per le stringhe e il loro contenuto o il numero stesso tra parentesi per numeri interi (int), decimali (float) o booleani (bool)
  • le funzioni come closure
  • le classi come oggetti

Ora vediamo caso per caso l’utilizzo della funzione var_dump con varie tipologie di dati e vari esempi.

Stringhe (string)

Analizziamo una stringa con la funzione var_dump.

Per prima cosa inseriamo una stringa in una variabile (poteva anche provenire dal database o da una funzione) e poi passiamola dentro var_dump:

<?php

$stringa = "Mi chiamo Michele";

var_dump($stringa);

?>

Visitando la pagina otterrai questo risultato:

string(17) "Mi chiamo Michele"

La parola string sta a indicare il tipo di dato che in questo caso è una stringa di testo.

Poi tra parentesi tonde abbiamo la lunghezza in termini di caratteri della stringa, che in questo caso è di 17 caratteri in totale (compresi gli spazi).

Subito dopo, tra doppi apici, abbiamo la stringa di testo contenuta nella variabile.

Considera che puoi inserire anche più variabili all’interno della funzione var_dump() come se avesse argomenti infiniti. Facciamo finta di avere più stringhe in più variabili:

<?php
$str1 = "Michele";
$str2 = "Mincone";
$professione = "Sviluppatore web";
$eta = "21";
$linguaggio_preferito = "Javascript";

var_dump($str1, $str2, $professione, $eta, $linguaggio_preferito);

?>

Otterrai questo:

string(7) "Michele" string(7) "Mincone" string(16) "Sviluppatore web" string(2) "21" string(10) "Javascript"

Sembrerà difficile leggere questo risultato, ma focalizzandoci capiamo che la funzione ha riportato i dati di ogni singola variabile che abbiamo passato in var_dump().

All’inizio abbiamo la prima variabile ($str1) e ci dice che è una stringa con 7 caratteri e poi il valore, poi abbiamo un’altra stringa ($str2) da 7 caratteri con il contenuto e poi ancora una volta abbiamo una stringa ($professione) da 16 caratteri con il relativo contenuto.

Questo viene ripetuto fino alla stringa $linguaggio_preferito.

Numeri interi (int)

Analizziamo un numero intero contenuto in una variabile $numero:

<?php

$numero = 573;

var_dump($numero);

?>

Il risultato sarà questo:

int(573)

Int indica il tipo di dato, cioè un numero intero, e tra parentesi abbiamo il numero che abbiamo inserito nella variabile ovvero 573.

Quando analizzerai un numero intero o decimale il numero verrà sempre messo tra parentesi tonde indicandoti il suo valore, quello della variabile, direttamente.

Numeri decimali (float)

Possiamo fare lo stesso con i numeri decimali:

<?php

$numero_decimale = 59.93;

var_dump($numero_decimale);

?>

Risultato:

float(59.93)

Seguendo la stessa logica, float sta a indicare che il tipo di dato è un numero decimale e, come per i numeri interi, abbiamo il valore tra parentesi tonde.

Valori booleani (bool)

Analizzare variabili con valori booleani è semplice tanto quanto gli esempi precedenti:

<?php
$bool1 = TRUE;
$bool2 = FALSE;

var_dump($bool1, $bool2);

?>

Risultato:

bool(true) bool(false)

Essendo che abbiamo analizzato due variabili abbiamo due risultati uno dopo l’altro.

La parola bool indica il tipo di dato (valore booleano) e abbiamo tra parentesi tonde il valore stesso (true o false).

Valore nullo (NULL)

Definiamo un valore nullo in una variabile e poi analizziamola con la funzione var_dump:

<?php

$valore_nullo = null;

var_dump($valore_nullo);

?>

Otteniamo questo:

NULL

Per ogni valore nullo otteniamo la parola NULL, cioè un valore nullo, inesistente.

Array semplice

La funzione var_dump() è molto utile per analizzare array semplici ottenendo maggiori informazioni sul contenuto di ogni indice.

Però questa volta mettiamo dei tag <pre></pre> con echo avvolgendo la funzione var_dump(), questo per ottenere una migliore leggibilità

<?php

$array = [1, 'Ciao', TRUE, FALSE, "Stringa di esempio", 5835, 24, 0, "Esempio", "Bla bla bla"];

echo "<pre>";
var_dump($array);
echo "</pre>";

?>

Nota bene: i tag <pre></pre> ci permettono di migliorare la leggibilità di un testo da analizzare specie in questi casi in cui il contenuto può risultare difficile da scansionare a prima vista. Questi tag portano a capo ogni parola.

Risultato:

array(10) {
  [0]=>
  int(1)
  [1]=>
  string(4) "Ciao"
  [2]=>
  bool(true)
  [3]=>
  bool(false)
  [4]=>
  string(18) "Stringa di esempio"
  [5]=>
  int(5835)
  [6]=>
  int(24)
  [7]=>
  int(0)
  [8]=>
  string(7) "Esempio"
  [9]=>
  string(11) "Bla bla bla"
}

Sulla prima riga abbiamo la parola array, quindi la funzione ha riconosciuto che stiamo lavorando con questa tipologia di dato.

Subito dopo, tra parentesi tonde abbiamo un numero che sta a indicare il numero di elementi trovati nell’array. In questo caso è 10.

Poi tra le parentesi graffe abbiamo ogni singolo elemento dell’array. Tra parentesi quadre abbiamo il numero dell’indice ([0], [1], [2] ecc.) per accedere a un esatto valore e poi, dopo la freccia “=>“, abbiamo il valore che abbiamo inserito per quell’indice.

Quindi per ogni valore abbiamo il tipo di dato, il conteggio dei caratteri e il valore.

Ad esempio, all’indice [0] abbiamo int(1), quindi un numero intero con valore 1.

Oppure all’indice [4] abbiamo string(18) "Stringa di esempio", quindi una stringa con 18 caratteri in totale.

Oppure ancora all’indice [3] abbiamo bool(false): un valore booleano falso.

Array associativo

Lo stesso esempio per gli array semplici vale per gli array associativi:

<?php 
$array_associativo = [
    'nome' => 'Michele',
    'cognome' => 'Mincone',
    'eta' => '21',
    'professione' => 'Sviluppatore web',
    'hobby' => 'robotica, elettronica, chimica, meccanica e faidate',
    'social' => 'instagram, youtube, tiktok, linkedin',
    'linguaggi' => 'php, js, html, css, python, sql, c++'
    ];
    
echo "<pre>";
var_dump($array_associativo);
echo "</pre>";

?>

Risultato ottenuto:

array(7) {
  ["nome"]=>
  string(7) "Michele"
  ["cognome"]=>
  string(7) "Mincone"
  ["eta"]=>
  string(2) "21"
  ["professione"]=>
  string(16) "Sviluppatore web"
  ["hobby"]=>
  string(51) "robotica, elettronica, chimica, meccanica e faidate"
  ["social"]=>
  string(36) "instagram, youtube, tiktok, linkedin"
  ["linguaggi"]=>
  string(36) "php, js, html, css, python, sql, c++"
}

Nella prima riga abbiamo il tipo di dato (array) e il numero di elementi definiti dentro questo array. In questo caso 7 elementi.

Come vedi tra parentesi quadre [] troviamo gli indici o le chiavi di ogni elemento, questo perché si tratta di un array associativo in cui abbiamo definito noi le chiavi e non sono autogenerate con dei numeri in senso crescente.

Ad esempio, per la chiave ["linguaggi"] abbiamo una stringa da 36 caratteri, per la chiave ["cognome"] abbiamo una stringa da 7 caratteri e così via.

Array multidimensionali

Esistono anche array multidimensionali ovvero array con al suo interno array (dove possono esserci altri array e altri ancora).

Analizzare array multidimensionali con la funzione var_dump rende la loro lettura molto facile perché possiamo apprezzarne la struttura e la tipologia dei dati nelle varie gerarchie.

Ecco un esempio, si tratta di un array multidimensionale un po’ complesso, prenditi del tempo per analizzarlo:

<?php
$array_multidimensionale = [
    'nome' => 'Michele',
    'cognome' => 'Mincone',
    'eta' => '21',
    'professione' => 'Sviluppatore web',
    'hobby' => ['robotica', 'elettronica', 'chimica', 'fai da te', 'meccanica'],
    'social' => ['instagram', 'youtube', 'tiktok', 'linkedin'],
    'linguaggi' => ['php', 'js', 'html', 'css', 'python', 'sql', 'c++'],
    [
        'github' => 'https://github.com/mikeisadev',
        'sito_web' => 'https://michelemincone.com',
        'linguaggio_preferito' => 'Javascript',
        [
            'numeri_preferiti' => [3, 6, 9, 12, 15, 17, 18, 21],
            [
                'generi_preferiti_libri' => [
                    'fantasy',
                    'scienza',
                    'meccanica',
                    'chimica',
                    'robotica',
                    'avventura',
                    'narrativa'
                ],
                'libri_letti' => 27
            ]
        ]
    ]
    ];

echo "<pre>";
var_dump($array_multidimensionale);
echo "</pre>";

?>

Risultato:

array(8) {
  ["nome"]=>
  string(7) "Michele"
  ["cognome"]=>
  string(7) "Mincone"
  ["eta"]=>
  string(2) "21"
  ["professione"]=>
  string(16) "Sviluppatore web"
  ["hobby"]=>
  array(5) {
    [0]=>
    string(8) "robotica"
    [1]=>
    string(11) "elettronica"
    [2]=>
    string(7) "chimica"
    [3]=>
    string(9) "fai da te"
    [4]=>
    string(9) "meccanica"
  }
  ["social"]=>
  array(4) {
    [0]=>
    string(9) "instagram"
    [1]=>
    string(7) "youtube"
    [2]=>
    string(6) "tiktok"
    [3]=>
    string(8) "linkedin"
  }
  ["linguaggi"]=>
  array(7) {
    [0]=>
    string(3) "php"
    [1]=>
    string(2) "js"
    [2]=>
    string(4) "html"
    [3]=>
    string(3) "css"
    [4]=>
    string(6) "python"
    [5]=>
    string(3) "sql"
    [6]=>
    string(3) "c++"
  }
  [0]=>
  array(4) {
    ["github"]=>
    string(29) "https://github.com/mikeisadev"
    ["sito_web"]=>
    string(26) "https://michelemincone.com"
    ["linguaggio_preferito"]=>
    string(10) "Javascript"
    [0]=>
    array(2) {
      ["numeri_preferiti"]=>
      array(8) {
        [0]=>
        int(3)
        [1]=>
        int(6)
        [2]=>
        int(9)
        [3]=>
        int(12)
        [4]=>
        int(15)
        [5]=>
        int(17)
        [6]=>
        int(18)
        [7]=>
        int(21)
      }
      [0]=>
      array(2) {
        ["generi_preferiti_libri"]=>
        array(7) {
          [0]=>
          string(7) "fantasy"
          [1]=>
          string(7) "scienza"
          [2]=>
          string(9) "meccanica"
          [3]=>
          string(7) "chimica"
          [4]=>
          string(8) "robotica"
          [5]=>
          string(9) "avventura"
          [6]=>
          string(9) "narrativa"
        }
        ["libri_letti"]=>
        int(27)
      }
    }
  }
}

Con questo esempio emerge chiaramente l’utilità della funzione var_dump con l’ausilio dei tag <pre></pre>.

Possiamo leggere chiaramente la struttura di questo array multidimensionale riconoscendo ogni tipologia di dato: stringhe, valori booleani, array, numeri interi e decimali.

Funzioni (function)

Ho realizzato nella variabile $function1 una funzione anonima. Attenzione, è fondamentale aggiungere un punto e virgola ; dopo la parentesi graffa. Senza questo carattere avremmo un errore.

Subito dopo inseriamo la variabile nella funzione var_dump:

<?php

$function1 = function() { 
    echo "Ciao"; 
};

echo "<pre>";
var_dump($function1);
echo "</pre>";

?>

Come risultato otteniamo:

object(Closure)#1 (0) {
}

La stringa “object(Closure)” sta a indicare la funzione stessa mentre #1 indica il numero della funzione dichiarata dall’utente. In questo caso abbiamo dichiarato una sola funzione. Se avessimo dichiarato 10 funzioni, ad esempio, passando la decima funzione avremmo ottenuto #10.

Poi abbiamo tra parentesi tonde (0) un numero che indica i parametri della funzione. In questo caso non c’è alcun parametro quindi indica 0.

Adesso focalizziamoci sul numero della funzione indicato con #1, quindi proviamo a dichiarare più di una funzione:

<?php

$f1 = function() {
    echo "Funzione 1";
};

$f2 = function() {
    echo "Funzione 2";
};

$f3 = function() {
    echo "Funzione 3";
};

echo "<pre>";
    var_dump($f1);
    echo "<br>";
    var_dump($f2);
    echo "<br>";
    var_dump($f3);
echo "</pre>";

?>

Il risultato sarà il seguente:

object(Closure)#1 (0) {
}

object(Closure)#2 (0) {
}

object(Closure)#3 (0) {
}

Come vedi dopo il simbolo # abbiamo il numero della funzione dichiarata in ordine di interpretazione.

L’interprete PHP esegue il codice dall’alto verso il basso, quindi assegna un numero alle funzioni che incontra durante l’interpretazione o esecuzione del programma riga per riga.

Nel prossimo esempio vediamo una funzione con parametri.

Funzioni con parametri

In questo esempio ho realizzato una funzione anonima con due parametri, è possibile inserirne altri naturalmente. Poi ho inserito la variabile che contiene la funzione dentro la funzione var_dump:

<?php

$function2 = function($str = '', $int = 20) { 
    if (!empty($str)) {
        echo $str . ' ' . $int;
    } else {
       echo "Ciao {$int}";  
    }
};

echo "<pre>";
var_dump($function2);
echo "</pre>";

?>

Quello che ottengo è questo:

object(Closure)#1 (1) {
  ["parameter"]=>
  array(2) {
    ["$str"]=>
    string(10) ""
    ["$int"]=>
    string(10) ""
  }
}

Ho la stringa object(Closure) che indica l’entità di una funzione e il cancelletto con un numero che ci dice il numero della funzione.

Questa volta tra parentesi tonde ho il numero due (2), ovvero il numero di parametri che è pari a due.

In seguito, tra parentesi graffe ho questa struttura qui:

  ["parameter"]=>
  array(2) {
    ["$str"]=>
    string(10) ""
    ["$int"]=>
    string(10) ""
  }

Non è altro che un array associativo che ci da informazioni sui parametri della funzione.

Infatti, tutto inizia con la chiave ["parameter"] che contiene appunto i dati su tutti i parametri della funzione.

Sotto ho l’entità array(2), cioè un array che contiene due elementi.

Quindi poi ho ["$str"] e ["$int"] ovvero il nome dei parametri che posso passare in questa funzione.

Classi

Con la funzione var_dump possiamo analizzare anche una classe.

Nell’esempio di codice qui sotto ho realizzato una semplice e banale classe App. Subito dopo la istanzio nella variabile $class e passo quest’ultima nella funzione var_dump:

<?php

class App {
    private $app = null;
    
    public function __construct() {
        $this->start_app();
    }
    
    private function start_app() : bool {
        $this->app = "Avviamento app in corso...";
        
        if (!is_null($this->app)) {
            return true;
        }
        
        return false;
    }
} // Ho creato questa classe App

$class = new App(); // Istanzio la classe App

echo "<pre>";
var_dump($class); // Eseguo il var dump della classe istanziata nella variabile
echo "</pre>";

?>

Sulla pagina web avremo questo risultato:

object(App)#1 (1) {
  ["app":"App":private]=>
  string(26) "Avviamento app in corso..."
}

La prima cosa che notiamo è la stringa object(App). Questo sta a indicare che ci troviamo di fronte a una classe, quindi un oggetto, denominata con il nome “App“.

Poi con #1 possiamo capire il numero di questa classe che gli è stato assegnato in ordine di esecuzione del programma, quindi vale lo stesso discorso che abbiamo fatto per le funzioni.

Tra parentesi tonde abbiamo il numero delle proprietà dichiarate all’interno della classe. Infatti, nella classe App abbiamo solo $app come unica proprietà dichiarata.

Tra parentesi graffe abbiamo la struttura dati della classe per le proprietà.

Per prima cosa abbiamo ["app":"App":private]. Questa dicitura sta a indicare che app (quindi $app, tutto in minuscolo) è una proprietà della classe App ed è privata (leggi “private“).

Dopo la freccia “=>” abbiamo il tipo di dato, che è una stringa “(string)“, il numero di caratteri tra parentesi “(26)” e il valore della proprietà $app.

Se hai notato bene ho dichiarato la proprietà $app nella classe App con un valore nullo, ma ciò che ci ritroviamo una stringa. Questo perché istanziando la classe abbiamo eseguito la funzione __construct() che a sua volta richiama la funzione start_app() che modifica il valore della proprietà $app.

Migliorare la leggibilità con i tag <pre>

Per poter avere una migliore leggibilità utilizza i tag <pre></pre> prima e dopo la funzione var_dump();

<?php

echo "<pre>";
var_dump( /* Variabile o variabili da analizzare */ );
echo "</pre>";

?>

Conclusioni

L’utilizzo della funzione var_dump() è molto utile per familiarizzare di più con le tipologie di dati.

Negli esempi che ti ho portato sono stato io a definire il contenuto delle variabili da analizzare.

Ma quando scriverai un programma più complesso ti capiterà sicuramente di dover analizzare dati provenienti da fonti esterne o che non hai scritto tu come ad esempio database, librerie, framework, API eccetera.

La funzione var_dump ti sarà molto utile per capire quali sono i tipi di dati, il loro contenuto e la loro organizzazione (fondamentale nel caso degli array, specie quelli più complessi e strutturati).