Sobes.tech
Junior

Comment fonctionne la typification dynamique en PHP?

sobes.tech IA

Réponse de l'IA

PHP est un langage avec une typification dynamique et faible.

  • Typage dynamique : Le type d'une variable est déterminé lors de l'exécution en fonction de la valeur qui lui est assignée, et n'est pas déclaré explicitement à l'avance.
  • Typage faible : PHP peut effectuer des conversions de type implicites (conversion contextuelle), ce qui peut parfois conduire à des comportements inattendus lors de comparaisons ou d'opérations entre des valeurs de types différents.

Exemples :

  1. Changement de type de variable :
    <?php
    $variable = 123;    // int
    $variable = "bonjour"; // string
    $variable = [1, 2]; // tableau
    ?>
    
  2. Conversion implicite de types lors de la comparaison :
    <?php
    var_dump(10 == "10"); // bool(true) - la chaîne "10" est convertie en nombre 10
    var_dump(0 == false); // bool(true) - false est converti en nombre 0
    var_dump("abc" == 0); // bool(true) - la chaîne "abc" est convertie en nombre 0, car elle ne commence pas par un chiffre
    ?>
    
  3. Utilisation de la comparaison stricte pour éviter la conversion implicite :
    <?php
    var_dump(10 === "10"); // bool(false) - comparé à la fois en valeur et en type
    var_dump(0 === false); // bool(false)
    var_dump("abc" === 0); // bool(false)
    ?>
    

Bien que la typification dynamique offre flexibilité et accélère le développement aux premiers stades, elle peut conduire à des erreurs qui ne sont détectées qu'en cours d'exécution. Pour améliorer la fiabilité du code, PHP 7+ a introduit des déclarations de types (type declarations) et le mode strict de types (strict types).

<?php
declare(strict_types=1); // Active le mode strict de types pour le fichier actuel

function sum(int $a, int $b): int { // Déclaration des types pour les arguments et la valeur de retour
    return $a + $b;
}

// sum(1, "2"); // Cela provoquera une erreur de type (TypeError) en mode strict

?>

Les déclarations de types et le mode strict permettent de faire des vérifications de types lors de l'analyse statique ou en temps d'exécution avant l'appel de la fonction, ce qui contribue à écrire un code plus prévisible et maintenable.