Pourquoi est-il ===
plus rapide qu'en ==
PHP?
=== vs ==
, mais en JAVASCRIPT, peut lire ici: stackoverflow.com/questions/359494/…
Pourquoi est-il ===
plus rapide qu'en ==
PHP?
=== vs ==
, mais en JAVASCRIPT, peut lire ici: stackoverflow.com/questions/359494/…
Réponses:
Parce que l'opérateur d'égalité ==
contraint, ou convertit, le type de données temporairement pour voir s'il est égal à l'autre opérande, alors que ===
(l'opérateur d'identité) n'a pas besoin de faire de conversion et donc moins de travail est effectué, ce qui le rend plus rapide.
Tout d'abord, === vérifie si les deux arguments sont du même type - donc le nombre 1 et la chaîne «1» échouent lors de la vérification de type avant que toute comparaison ne soit réellement effectuée. D'un autre côté, == ne vérifie pas le type d'abord et continue et convertit les deux arguments dans le même type, puis effectue la comparaison.
Par conséquent, === est plus rapide pour vérifier une condition d'échec
==
vérifie également le type en premier pour voir si une conversion de type doit être effectuée. Le fait que ===
cela n'effectue aucune conversion à l'étape suivante est ce qui le rend plus rapide.
Il y a deux choses à considérer:
Si les types d'opérande sont différents alors ==
et ===
produisent des résultats différents . Dans ce cas, la vitesse des opérateurs n'a pas d'importance; ce qui compte, c'est celui qui produit le résultat souhaité.
Si les types d'opérande sont identiques, vous pouvez utiliser l'un ==
ou l' autre ou ===
les deux produiront les mêmes résultats . Dans ce cas, la vitesse des deux opérateurs est presque identique. En effet, aucune conversion de type n'est effectuée par l'un ou l'autre des opérateurs.
J'ai comparé la vitesse de:
$a == $b
contre $a === $b
$a
et $b
étaient des entiers aléatoires [1, 100]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 est une comparaison directe de type, tandis que == essaiera de faire de la coercition de type si nécessaire / possible pour obtenir une correspondance.
Car il ===
n'est pas nécessaire de forcer les opérandes à être du même type avant de les comparer.
Je doute que la différence de vitesse soit très importante. Dans des circonstances normales, vous devez utiliser l'opérateur qui a le plus de sens.
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 avez besoin de voir si deux variables ont la même valeur, vous utiliserez == si ne correspond pas à quel type sont des variables , ou === si est important aussi le type de variables.
Plus rapide ne doit pas être mesuré uniquement en temps d'exécution directe (les tests de performance directs sont presque négligeables dans ce cas). Cela dit, j'aurais besoin de voir un test impliquant une itération, ou récursivité, pour vraiment voir s'il existe une différence cumulative significative (lorsqu'elle est utilisée dans un contexte réaliste). Le temps de test et de débogage que vous économiserez lors de la gestion des cas extrêmes devrait également être significatif pour vous
En php (code c), la valeur est une "classe" comme:
class value
{
$int_;
$float_;
$string_;
$array_;
$object_;
}
Lorsque vous êtes comparaient $a == $b
et $a
est le int
type, il y aura quelque chose comme:
if ($a->int_ == $b->int_ || $a->int_ == (int) $b->float_ || $a->int_ == (int) $b->string_ || ...)
mais string
'1'
ne sera pas converti en code ascii 49
, il sera1
.
Lorsque vous comparez $a === $b
et $a
est le int
type, il y aura someting comme:
if ($a->int_ == $b->int_)
Si les résultats du test sont corrects, il doit s'agir d'un problème de compilation,
Le processeur fera tout ce qu'on lui dit de faire sur un cycle d'horloge
S'il a moins à faire, ce sera plus rapide à faire
Une addition:
Ah bon en fait si le compilateur a déjà créé des charges de code machine à traiter, alors s'il a déjà ajouté des millions de trucs pour faire face au type de données à comparer, alors la suppression d'un IF "mineur" ne changera pas beaucoup la vitesse du tout.
Si quelqu'un lit encore ceci, alors je suis intéressé par plus de discussion.
Phil