Quelle est la difference entre ==
et ===
?
- Comment fonctionne exactement la
==
comparaison lâche ? - Comment fonctionne exactement la
===
comparaison stricte ?
Quels seraient des exemples utiles?
Quelle est la difference entre ==
et ===
?
==
comparaison lâche ?===
comparaison stricte ?Quels seraient des exemples utiles?
==
et===
La différence entre l' ==
opérateur vaguement égal et l' ===
opérateur strictement identique est expliquée exactement dans le manuel :
Opérateurs de comparaison
┌──────────┬───────────┬────────────────────────── ──────────────────────────────────┐ │ Exemple │ Nom │ Résultat │ ├──────────┼───────────┼────────────────────────── ──────────────────────────────────┤ │ $ a == $ b │ Égal │ VRAI si $ a est égal à $ b après avoir jonglé avec le type. │ │ $ a === $ b │ Identique │ VRAI si $ a est égal à $ b et qu'ils sont du même type. │ └──────────┴───────────┴────────────────────────── ──────────────────────────────────┘
==
Comparaison égaleSi vous utilisez l' ==
opérateur, ou tout autre opérateur de comparaison qui utilise une comparaison lâche comme !=
, <>
ou ==
, vous devez toujours regarder le contexte pour voir quoi, où et pourquoi quelque chose est converti pour comprendre ce qui se passe.
Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le manuel :
Comparaisons lâches avec
==
┌─────────┬───────┬───────┬───────┬────────┬─────── ┬───────┬───────┬───────┬───────┬──────────┬─────── ┬───────┐ │ │ VRAI │ FAUX │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ tableau () │ "php" │ "" │ ├─────────┼───────┼───────┼───────┼────────┼─────── ┼───────┼───────┼───────┼───────┼──────────┼─────── ┼───────┤ │ VRAI │ VRAI │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ │ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │ │ 1 │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ 0 │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ VRAI │ VRAI │ │ -1 │ VRAI │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ │ "1" │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ "0" │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ "-1" │ VRAI │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ │ NULL │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ VRAI │ FAUX │ VRAI │ │ array () │ FALSE │ TRUE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE │ TRUE │ FALSE │ FALSE │ │ "php" │ VRAI │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ │ "" │ FAUX │ VRAI │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ VRAI │ └─────────┴───────┴───────┴───────┴────────┴─────── ┴───────┴───────┴───────┴───────┴──────────┴─────── ┴───────┘
===
Comparaison strictement identiqueSi vous utilisez l' ===
opérateur, ou tout autre opérateur de comparaison qui utilise une comparaison stricte comme !==
ou ===
, alors vous pouvez toujours être sûr que les types ne changeront pas comme par magie , car il n'y aura pas de conversion en cours. Donc, avec une comparaison stricte, le type et la valeur doivent être les mêmes, pas seulement la valeur.
Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le manuel :
Comparaisons strictes avec
===
┌─────────┬───────┬───────┬───────┬────────┬─────── ┬───────┬───────┬───────┬───────┬──────────┬─────── ┬───────┐ │ │ VRAI │ FAUX │ 1 │ 0 │ -1 │ "1" │ "0" │ "-1" │ NULL │ tableau () │ "php" │ "" │ ├─────────┼───────┼───────┼───────┼────────┼─────── ┼───────┼───────┼───────┼───────┼──────────┼─────── ┼───────┤ │ VRAI │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ 1 │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ 0 │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ -1 │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ "1" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ "0" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ │ "-1" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ FAUX │ │ NULL │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ FAUX │ │ array () │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ FAUX │ │ "php" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ FAUX │ │ "" │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ FAUX │ VRAI │ └─────────┴───────┴───────┴───────┴────────┴─────── ┴───────┴───────┴───────┴───────┴──────────┴─────── ┴───────┘
true
oufalse
. C'est facile à lancer. Toutes les autres valeurs ont cependant, à toutes fins pratiques, des combinaisons pratiquement illimitées. Est-ce"five" == 5
?array(0) == 0
?array(0,0,0) == 0
?0.0000000000000000000000000000000000000000000000000001 == array()
?false
pour différents tableaux en javascript, maistrue
pour PHP tant que leurs valeurs sont égales ."000" != "00"
,"000" == null
,"000" == false
,"0x0" == false
,array() == 0
,false != null
,array() != null
,false == "0x0"
,false == "000"
. En PHP, il est un comportement contraire:"000" == "00"
,"000" != null
,"000" != false
,"0x0" != false
,array() != 0
,false == null
,array() == null
,false != "0x0"
,false != "000"
.L'opérateur == effectue une conversion entre deux types différents s'ils sont différents, tandis que l'opérateur === effectue une «comparaison sécurisée des types». Cela signifie qu'il ne retournera true que si les deux opérandes ont le même type et la même valeur.
Exemples:
Avertissement : deux instances de la même classe avec des membres équivalents NE correspondent PAS à l'
===
opérateur. Exemple:la source
Une image vaut mieux que mille mots:
==
Tableau d'égalité PHP Double Equals :===
Graphique d'égalité triple PHP :Code source pour créer ces images:
https://github.com/sentientmachine/php_equality_charts
Guru Meditation
Ceux qui souhaitent garder leur raison, ne lisent pas plus loin car rien de tout cela n'aura de sens, sauf pour dire que c'est ainsi que la folie fractale de PHP a été conçue.
NAN != NAN
maisNAN == true
.==
convertira les opérandes gauche et droite en nombres si gauche est un nombre. Alors123 == "123foo"
, mais"123" != "123foo"
Une chaîne hexadécimale entre guillemets est parfois un flottant, et sera lancée par surprise pour flotter contre votre volonté, provoquant une erreur d'exécution.
==
n'est pas transitif parce que"0"== 0
,0 == ""
mais"0" != ""
==
."6" == " 6"
,,"4.2" == "4.20"
et"133" == "0133"
mais133 != 0133
. Mais"0x10" == "16"
et"1e3" == "1000"
exposer cette conversion de chaîne surprise en octal se produira sans votre instruction ou votre consentement, provoquant une erreur d'exécution.False == 0
,""
,[]
Et"0"
.Lorsque les nombres sont assez grands, ils sont == Infinity.
Une nouvelle classe est == à 1.
Espérer:
Si vous utilisez PHP, vous n'utiliserez pas l'opérateur double égal car si vous utilisez triple égal, les seuls cas marginaux à craindre sont NAN et les nombres si proches de l'infini qu'ils sont convertis à l'infini. Avec un double égal, tout peut être une surprise
==
pour n'importe quoi ou, ou peut être lancé par surprise contre votre volonté et!=
pour quelque chose dont il devrait évidemment être égal.Partout où vous utilisez
==
en PHP est une mauvaise odeur de code en raison des 85 bogues qui y sont exposés par des règles de casting implicites qui semblent conçues par des millions de programmeurs programmant par mouvement brownien.la source
En ce qui concerne JavaScript:
L'opérateur === fonctionne de la même manière que l'opérateur ==, mais il requiert que ses opérandes aient non seulement la même valeur, mais également le même type de données.
Par exemple, l'exemple ci-dessous affichera «x et y sont égaux», mais pas «x et y sont identiques».
la source
Un complément aux autres réponses concernant la comparaison d'objets:
== compare les objets en utilisant le nom de l'objet et leurs valeurs. Si deux objets sont du même type et ont les mêmes valeurs de membre,
$a == $b
renvoie true.=== compare l'ID d'objet interne des objets. Même si les membres sont égaux,
$a !== $b
s'ils ne sont pas exactement le même objet.la source
En termes simples:
== vérifie s'il est équivalent (valeur uniquement)
=== vérifie si le même (valeur et type)
équivalent ou identique: une analogie
1 + 1 = 2 + 0 (équivalent)
1 + 1 = 1 + 1 (même)
En PHP:
true == 1 (true - valeur équivalente)
true === 1 (false - pas la même valeur & type)
la source
Tout dépend des types de données. Prenez un
BOOL
(vrai ou faux) par exemple:true
est également égal à1
etfalse
également égal à0
Le
==
ne se soucie pas des types de données lors de la comparaison: Donc, si vous aviez une variable qui est 1 (qui pourrait également êtretrue
):$var=1;
Et puis comparez avec
==
:Mais ce
$var
n'est pas vraiment égaltrue
, n'est-ce pas? Il a la valeur int de1
au lieu de cela, qui à son tour, est égale à true.Avec
===
, les types de données sont vérifiés pour s'assurer que les deux variables / objets / quoi que ce soit utilisent le même type.Donc si je le faisais
cette condition ne serait pas vraie, car
$var !== true
elle seule== true
(si vous voyez ce que je veux dire).Pourquoi en auriez-vous besoin?
Simple - jetons un œil à l'une des fonctions de PHP
array_search()
::La
array_search()
fonction recherche simplement une valeur dans un tableau et renvoie la clé de l'élément dans lequel la valeur a été trouvée. Si la valeur est introuvable dans le tableau, elle renvoie false . Mais que se passe-t-il si vous faites unearray_search()
sur une valeur stockée dans le premier élément du tableau (qui aurait la clé du tableau de0
) .... laarray_search()
fonction retournera 0 ... ce qui est égal à false ..Donc si vous l'avez fait:
Alors, voyez-vous comment cela pourrait être un problème maintenant?
La plupart des gens ne l'utilisent pas
== false
pour vérifier si une fonction retourne false. Au lieu de cela, ils utilisent le!
. Mais en fait, c'est exactement la même chose que l'utilisation==false
, donc si vous l'avez fait:Donc, pour des choses comme ça, vous utiliseriez à la
===
place, afin que le type de données soit vérifié.la source
Un exemple est qu'un attribut de base de données peut être nul ou "":
la source
php == est un opérateur de comparaison qui compare la valeur des variables. Mais === compare la valeur et le type de données.
Par exemple,
Dans ce cas, la sortie sera «Les variables sont égales», même si leurs types de données sont différents.
Mais si nous utilisons === au lieu de ==, la sortie sera «Les variables ne sont pas égales». Le php compare d'abord la valeur de la variable puis le type de données. Ici, les valeurs sont identiques, mais les types de données sont différents.
la source
Donné
x = 5
1) Opérateur: == est "égal à".
x == 8
est faux2) Opérateur: === est "exactement égal à" (valeur et type)
x === 5
est vrai,x === "5"
est fauxla source
Soyez prudent cependant. Voici un problème notoire.
contre.
la source
En bref, === fonctionne de la même manière que == dans la plupart des autres langages de programmation.
PHP vous permet de faire des comparaisons qui n'ont pas vraiment de sens. Exemple:
Bien que cela permette des "raccourcis" intéressants, vous devez vous méfier car une fonction qui renvoie quelque chose qu'il ne devrait pas (comme "erreur" au lieu d'un nombre) ne sera pas interceptée, et vous vous demanderez ce qui s'est passé.
En PHP, == compare les valeurs et effectue une conversion de type si nécessaire (par exemple, la chaîne "12343sdfjskfjds" deviendra "12343" dans une comparaison entière). === comparera la valeur AND type et retournera false si le type n'est pas le même.
Si vous regardez dans le manuel PHP, vous verrez que beaucoup de fonctions retournent "false" si la fonction échoue, mais elles peuvent retourner 0 dans un scénario réussi, c'est pourquoi elles recommandent de faire "if (function ()! == false) "pour éviter les erreurs.
la source
Quelques exemples
PS
contre.
la source
Vous utiliseriez === pour tester si une fonction ou une variable est fausse plutôt que de simplement assimiler false (zéro ou une chaîne vide).
Dans ce cas, strpos renverrait 0, ce qui équivaudrait à faux dans le test
ou
ce n'est pas ce que vous voulez ici.
la source
Quant à savoir quand utiliser l'un sur l'autre, prenez par exemple la
fwrite()
fonction en PHP.Cette fonction écrit du contenu dans un flux de fichiers. Selon PHP, "
fwrite()
renvoie le nombre d'octets écrits, ou FAUX en cas d'erreur.". Si vous souhaitez tester si l'appel de fonction a réussi, cette méthode est défectueuse:Il peut retourner zéro (et est considéré comme réussi) et votre condition est toujours déclenchée. La bonne façon serait:
la source
PHP est un langage peu typé. L'utilisation de l'opérateur double égal permet une vérification lâche d'une variable.
Une vérification lâche d'une valeur permettrait à certaines valeurs similaires, mais pas égales, d'être égales comme les mêmes:
Toutes ces valeurs seraient égales comme égales en utilisant l'opérateur double égal.
la source
Les variables ont un type et une valeur.
Lorsque vous utilisez ces variables (en PHP), parfois vous n'avez pas le bon type. Par exemple, si vous le faites
PHP doit convertir ("to cast") $ var en entier. Dans ce cas, "$ var == 1" est vrai car toute chaîne non vide est convertie en 1.
Lorsque vous utilisez ===, vous vérifiez que la valeur ET LE TYPE sont égaux, donc "$ var === 1" est faux.
Ceci est utile, par exemple, lorsque vous avez une fonction qui peut retourner false (en cas d'erreur) et 0 (résultat):
Ce code est incorrect car s'il
myFunction()
renvoie 0, il est converti en false et vous semblez avoir une erreur. Le bon code est:car le test est que la valeur de retour "est un booléen et est faux" et non "peut être convertie en faux".
la source
L'
===
opérateur est censé comparer l' égalité de contenu exacte tandis que l'==
opérateur comparerait l'égalité sémantique. En particulier, il contraindra les chaînes aux nombres.L'égalité est un vaste sujet. Voir l'article Wikipedia sur l'égalité .
la source
la source
Jusqu'à présent, toutes les réponses ignorent un problème dangereux avec ===. Il a été noté au passage, mais non souligné, que entier et double sont de types différents, donc le code suivant:
donne:
Notez qu'il ne s'agit PAS d'une "erreur d'arrondi". Les deux nombres sont exactement égaux jusqu'au dernier bit, mais ils ont des types différents.
Il s'agit d'un problème désagréable car un programme utilisant === peut fonctionner correctement pendant des années si tous les nombres sont suffisamment petits (où "assez petit" dépend du matériel et du système d'exploitation sur lesquels vous exécutez). Cependant, si par hasard, un entier se trouve être suffisamment grand pour être converti en double, son type est changé "pour toujours" même si une opération ultérieure, ou de nombreuses opérations, pourrait le ramener à un petit entier en valeur. Et ça empire. Elle peut se propager - une infection à double nesse peut être transmise à tout ce qu'elle touche, un calcul à la fois.
Dans le monde réel, cela risque d'être un problème dans les programmes qui gèrent des dates au-delà de l'année 2038, par exemple. À l'heure actuelle, les horodatages UNIX (nombre de secondes depuis 1970-01-01 00:00:00 UTC) nécessiteront plus de 32 bits, de sorte que leur représentation passera "comme par magie" pour doubler sur certains systèmes. Par conséquent, si vous calculez la différence entre deux fois, vous pourriez vous retrouver avec quelques secondes, mais en double, plutôt que le résultat entier qui se produit en 2017.
Je pense que c'est bien pire que les conversions entre chaînes et nombres car c'est subtil. Je trouve facile de garder une trace de ce qu'est une chaîne et ce qui est un nombre, mais garder une trace du nombre de bits dans un nombre me dépasse.
Ainsi, dans les réponses ci-dessus, il y a de belles tables, mais aucune distinction entre 1 (comme un entier) et 1 (double subtil) et 1.0 (double évident). De plus, les conseils que vous devez toujours utiliser === et jamais == ne sont pas excellents car === échouera parfois là où == fonctionne correctement. De plus, JavaScript n'est pas équivalent à cet égard car il n'a qu'un seul type de nombre (en interne, il peut avoir différentes représentations bit à bit, mais il ne pose pas de problème pour ===).
Mon conseil - n'utilisez ni l'un ni l'autre. Vous devez écrire votre propre fonction de comparaison pour vraiment corriger ce gâchis.
la source
Il y a deux différences entre
==
et===
dans les tableaux et objets PHP que je ne pense pas mentionner ici; deux tableaux avec différents types de clés et objets.Deux tableaux avec différents types de clés
Si vous avez un tableau avec un tri de clé et un autre tableau avec un tri de clé différent, ils sont strictement différents (c'est-à-dire en utilisant
===
). Cela peut provoquer si vous triez un tableau par clé et essayez de comparer le tableau trié avec le tableau d'origine.Par exemple, considérez un tableau vide. Tout d'abord, nous essayons de pousser de nouveaux index vers le tableau sans aucun tri spécial. Un bon exemple serait un tableau avec des chaînes comme clés. Maintenant profondément dans un exemple:
Maintenant, nous avons un tableau de clés non triées (par exemple, «il» est venu après «vous»). Considérez le même tableau, mais nous avons trié ses clés par ordre alphabétique:
Astuce : vous pouvez trier un tableau par clé à l'aide de ksort () .
Vous avez maintenant un autre tableau avec un tri de clé différent du premier. Nous allons donc les comparer:
Remarque : Cela peut être évident, mais la comparaison de deux tableaux différents en utilisant une comparaison stricte entraîne toujours
false
. Cependant, deux tableaux arbitraires peuvent être égaux en utilisant===
ou non.Vous diriez: "Cette différence est négligeable". Ensuite, je dis que c'est une différence et doit être considérée et peut se produire à tout moment. Comme mentionné ci-dessus, le tri des clés dans un tableau en est un bon exemple.
Objets
Gardez à l'esprit que deux objets différents ne sont jamais strictement égaux . Ces exemples pourraient aider:
Remarque : L'affectation d'un objet à une autre variable ne crée pas de copie - elle crée plutôt une référence au même emplacement mémoire que l'objet. Voyez ici .
Remarque : Depuis PHP7, des classes anonymes ont été ajoutées. D'après les résultats, il n'y a aucune différence entre
new class {}
etnew stdClass()
dans les tests ci-dessus.la source