Parce que l'opérateur d'égalité == convertit ou convertit temporairement le type de données pour voir s'il est égal à l'autre opérande, alors que === (opérateur d'identité) n'a pas besoin de convertir le fichier de sorte que le travail soit moins fastidieux.
=== n'effectue pas de conversion de type, donc 0 == '0' est évalué à true, mais 0 === '0' - à false.
Tout d'abord, === vérifie si les deux arguments sont identiques type - afin que le nombre 1 et la chaîne '1' échouent lors de la vérification du type avant toute comparaison. D'un autre côté, == ne vérifie pas le type en premier, continue et convertit les deux arguments en un même type, puis effectue la comparaison.
Par conséquent, === vérifie plus rapidement une condition d'échec
Il y a deux choses à considérer:
Si les types d'opérandes sont différents,
==et===produisent résultats différents. Dans ce cas, la vitesse des opérateurs n'a pas d'importance; ce qui compte, c'est lequel produit le résultat souhaité.Si les types d'opérandes sont identiques, vous pouvez utiliser soit
==, soit===, car les deux produiront résultats identiques. Dans ce cas, la vitesse des deux opérateurs est presque identique. En effet, aucune conversion de type n'est effectuée par les opérateurs.
J'ai comparé la vitesse de:
$a == $bvs$a === $b- où
$aet$bétaient des entiers aléatoires [1, 100] - les deux variables ont été générées et comparées un million de fois
- les tests ont été effectués 10 fois
Et voici les résultats:
$a == $b $a === $b
--------- ---------
0.765770 0.762020
0.753041 0.825965
0.770631 0.783696
0.787824 0.781129
0.757506 0.796142
0.773537 0.796734
0.768171 0.767894
0.747850 0.777244
0.836462 0.826406
0.759361 0.773971
--------- ---------
0.772015 0.789120
Vous pouvez voir que la vitesse est presque identique.
Je ne sais pas vraiment si c'est beaucoup plus rapide, mais === dans la plupart des langues, il s'agit d'une comparaison directe de types, tandis que == essayera de forcer les types si nécessaire/possible pour obtenir une correspondance.
Parce que ===n'a pas besoin de forcer les opérandes à être du même type avant de les comparer.
Je doute cependant que la différence de vitesse soit très grande. Dans des circonstances normales, vous devez utiliser l'opérateur qui vous convient le mieux.
Le == implique une surcharge de conversion de type plus importante avant la comparaison. === vérifie d'abord le type, puis procède sans aucune conversion de type.
En conclusion === est plus rapide car ne convertit pas le type de données pour voir si deux variables ont la même valeur, mais lorsque vous devez voir si deux variables ont la même valeur, vous utiliserez == si le type utilisé n'est pas quel type sont des variables , ou === si est également important le type de variables.
Plus rapide ne devrait pas simplement être mesuré en temps d'exécution directe (les tests de performance directs sont presque négligeables dans ce cas). Cela dit, il me faudrait un test impliquant une itération, ou une récursivité, pour vraiment voir s’il existe une différence cumulative significative (dans un contexte réaliste). Le temps de test et de débogage que vous gagnerez lorsque vous traiterez des cas Edge doit avoir un sens pour vous, également