Pourquoi === est-il plus rapide que == en PHP?

Pourquoi est-il ===plus rapide qu'en ==PHP?

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.

===n'effectue pas de transtypage, donc 0 == '0'évalue vers true, mais 0 === '0'- vers false.

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

Il y a deux choses à considérer:

1. 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é.

2. 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
• 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é exécuté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 est une comparaison directe de type, tandis que == essaiera de faire de la coercition de type si nécessaire / possible pour obtenir une correspondance.

Le == entraîne une surcharge de conversion de type plus importante avant la comparaison. === vérifie d'abord le type, puis continue sans avoir à faire de conversion de type.

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 == $bet $aest le inttype, 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 === $bet $aest le inttype, 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