Come funziona la tipizzazione dinamica in PHP?

PHP è un linguaggio con tipizzazione dinamica e debole.

• Tipizzazione dinamica: Il tipo di una variabile viene determinato durante l'esecuzione in base al valore assegnato, e non viene dichiarato esplicitamente in anticipo.
• Tipizzazione debole: PHP può eseguire conversioni di tipo implicite (conversione contestuale), che a volte possono portare a comportamenti inattesi durante confronti o operazioni tra valori di tipi diversi.

Esempi:

1. Cambio di tipo della variabile:

   <?php
   $variable = 123;    // int
   $variable = "ciao"; // string
   $variable = [1, 2]; // array
   ?>
   

2. Conversione implicita di tipi nel confronto:

   <?php
   var_dump(10 == "10"); // bool(true) - la stringa "10" viene convertita in numero 10
   var_dump(0 == false); // bool(true) - false viene convertito in numero 0
   var_dump("abc" == 0); // bool(true) - la stringa "abc" viene convertita in numero 0, poiché non inizia con un numero
   ?>
   

3. Uso del confronto rigoroso per evitare conversioni implicite:

   <?php
   var_dump(10 === "10"); // bool(false) - confronta sia in valore che in tipo
   var_dump(0 === false); // bool(false)
   var_dump("abc" === 0); // bool(false)
   ?>
   

Sebbene la tipizzazione dinamica offra flessibilità e acceleri lo sviluppo nelle prime fasi, può portare a errori che vengono rilevati solo durante l'esecuzione. Per migliorare l'affidabilità del codice, in PHP 7+ sono state introdotte dichiarazioni di tipo (type declarations) e modalità rigorosa di tipizzazione (strict types).

<?php
declare(strict_types=1); // Attiva la modalità rigorosa di tipizzazione per il file corrente

function sum(int $a, int $b): int { // Dichiarazione dei tipi degli argomenti e del valore di ritorno
    return $a + $b;
}

// sum(1, "2"); // Questo causerà un errore di tipo (TypeError) in modalità rigorosa

?>

Le dichiarazioni di tipo e la modalità rigorosa consentono di eseguire controlli sui tipi durante l'analisi statica o in fase di esecuzione prima di chiamare la funzione, contribuendo a scrivere codice più prevedibile e manutenibile.