Déstaurer le jonglage du type de PHP: un guide de `==` contre `===`

== effectue une comparaison lâche avec le jonglage de type, === vérifie la valeur et le type strictement; 1. "PHP" == 0 est vrai car les chaînes non numériques se convertissent en 0, 2. Les chaînes vides, nuls, fausses et 0 sont égales, 3. La notation scientifique comme "0e123" == "0e456" peut causer des problèmes de sécurité; Utilisez toujours === pour des comparaisons prévisibles et sécurisées, en particulier avec l'entrée ou l'authentification de l'utilisateur, pour éviter les bogues et les vulnérabilités de coercition.

Lorsque vous comparez des valeurs en PHP, la différence entre == et === peut sembler subtile au début - mais c'est l'une des sources les plus courantes de bugs pour les débutants et les développeurs expérimentés. Comprendre le comportement de jonglage de type PHP est la clé de l'écriture de code prévisible et sécurisé.

Quelle est la différence entre == et === ?

La réponse courte:

• == est l' opérateur de comparaison lâche (ou égal) - il vérifie si deux valeurs sont égales après la jonglerie de type .
• === est l' opérateur de comparaison strict (ou identique) - il vérifie si deux valeurs sont égales et du même type .

Cela signifie:

 0 == "php" // true? Oui, et voici pourquoi - plus à ce sujet ci-dessous
0 === "PHP" // FAUX - différents types et valeurs

Cette première ligne semble bizarre - comment 0 peut-on égaler "php" ? Bienvenue dans le jonglage de type de PHP.

Comment le jonglage du type de PHP fonctionne avec ==

Lorsque vous utilisez == , PHP essaie d'être utile en convertissant les valeurs en un type commun avant de les comparer. C'est ce qu'on appelle la jonglerie de type . Bien que pratique dans certains cas, cela peut conduire à des résultats surprenants.

Voici quelques gatchas communs:

1. Crises en commençant par des caractères non nucères convertis en 0

 "php" == 0 // vrai
"123ABC" == 123 // Vrai
"ABC123" == 0 // Vrai

Pourquoi? Lorsque PHP convertit une chaîne en un nombre et qu'il ne commence pas par un nombre valide, il devient 0 .

Ainsi, "php" devient 0 et 0 == 0 → true .

2. Les chaînes vides, null , false et 0 sont toutes "fausses" et interchangeables avec ==

 "" == 0 // Vrai
"" == faux // vrai
null == false // vrai
[] == false // faux (les tableaux ne sont pas vaguement égaux à false)
0 == false // vrai

Ceci est particulièrement dangereux lors de la vérification des valeurs de retour des fonctions ou des entrées de formulaire.

3 .

 "0e12345" == "0e67890" // Vrai - tous deux traités comme 0 en notation scientifique
"1E3" == 1000 // Vrai - "1E3" Convertit en 1000

Cela a été exploité dans les vulnérabilités de sécurité (par exemple, les attaques de comparaison de hachage si vous n'utilisez pas === ).

Pourquoi === est plus sûr et plus prévisible

La comparaison stricte === n'effectue aucune conversion de type. Il vérifie à la fois la valeur et le type .

 0 == "0" // true - php convertit la chaîne "0" à int 0
0 === "0" // FAUX - L'un est entier, l'un est une chaîne

false == 0 // vrai
false === 0 // faux

"" == null // Vrai
"" === null // faux

L'utilisation === élimine l'ambiguïté. Vous savez toujours ce que vous comparez.

Conseils pratiques pour éviter les bogues de jonglerie de type

Voici comment protéger votre code:

• ✅ Use === et !== Par défaut , sauf si vous voulez spécifiquement la coercition de type.
• ✅ Valider et désinfecter les types d'entrée tôt - ne comptez pas sur des comparaisons lâches pour gérer les types mixtes.
• ✅ Soyez prudent lorsque vous comparez les données d'entrée ou d'API , vérifiez toujours le type si le contexte est important.
• ✅ Utiliser is_int() , is_string() , is_bool() lorsque vous devez confirmer les types.
• ✅ Utilisez strcmp() ou hash_equals() pour les comparaisons de chaînes sécurisées (en particulier avec les hachages / jetons).

Exemple: comparaison de hachage de mot de passe sûr

 // ne fais pas ça
if (mot de passe_hash ("pass", mot de passe_default) == $ userInputhash)

// fais ça
if (hash_equals ($ stockagehash, $ inputhash)))

hash_equals() empêche les attaques de synchronisation et utilise une comparaison stricte.

Exemple du monde réel: Connexion de connexion via une comparaison lâche

Imaginez ce code erroné:

 fonction isadmin ($ userrole) {
    retourner $ userrole == "admin";
}

Isadmin (1); // pourrait retourner vrai si "admin" se convertit en quelque sorte en 1?

Attendez - en fait, "admin" se convertit en 0 , donc 1 == "admin" est false . Mais considérez:

 $ userInput = "1";
if ($ userInput == true) {// true - String "1" == bool true
    // accorder l'accès?
}

Ou pire:

 if ($ _get ['id'] == "123") {
    // Afficher les données utilisateur
}

Si id est passé comme 123abc , PHP le convertit en 123 lors de la comparaison numériquement - donc 123abc == 123 pourrait être true . Mais 123abc === 123 est false .

Résumé: Tenez-vous à === à moins que vous ne sachiez ce que vous faites

• == Effectue un jonglage de type - peut conduire à des résultats inattendus.
• === Compare la valeur et le type - prévisibles et sûrs.
• Utilisez toujours === pour les comparaisons impliquant des entrées, de l'authentification ou des vérifications d'état des utilisateurs.
• Comprenez que le typage lâche de PHP est une fonctionnalité - mais qui nécessite de la prudence.

Fondamentalement, si vous ne comptez pas intentionnellement sur la coercition de type, === devrait être votre choix par défaut. Il ne s'agit pas seulement de l'exactitude - il s'agit d'éviter les bogues subtils et les problèmes de sécurité.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!