Les 3 différents égaux

149

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

Je pense que l'utilisation d'un signe égal est de déclarer une variable tandis que deux signes égaux sont pour une condition de comparaison et enfin trois signes égaux sont pour comparer les valeurs des variables déclarées.

fraise
la source
Consultez l'exemple ... J'ai posté cela clarifierait plus de choses ..
InfantPro'Aravind '14
1
Pour les utilisateurs avancés de PHP, connaître la différence entre == et === et se demander "est-il plus rapide de comparer avec == ou avec === quand je suis sûr que les deux opérandes sont du même type?", Veuillez regarder à mon script de référence ci-dessous.
lucaferrario
@Strawberry Je pense que la balise de la question devrait également inclure la balise javascript car elle s'applique également à cette langue.
Funk Forty Niner
(Mise à jour): J'ai ajouté la balise javascript dans une modification, car il y a eu pas mal de questions où les gens utilisaient =en javascript. Cela ne s'applique pas seulement à PHP mais aussi à d'autres langages.
Funk Forty Niner du
Je suis allé de l'avant et j'ai supprimé la balise JavaScript: toutes les réponses ici ne concernent que PHP (sauf la dernière qui est très faible), il y a des différences entre la façon dont les langages le gèrent, et il y a déjà une question JavaScript canonique similaire de facto ( qui équivaut à L'opérateur (== vs ===) doit être utilisé dans les comparaisons JavaScript? ).
JJJ

Réponses:

172

Vous disposez de =l' opérateur d'affectation , de ==l' opérateur de comparaison «égal» et de ===l' opérateur de comparaison «identique» .

$a = $b     Assign      Sets $a to be equal to $b.
$a == $b    Equal       TRUE if $a is equal to $b.
$a === $b   Identical   TRUE if $a is equal to $b, and they are of the same type. (introduced in PHP 4)

Pour plus d'informations sur la nécessité d'utiliser ==et ===, et sur les situations d'utilisation de chacun, consultez la documentation .

gnarf
la source
quand je compare deux datetime identiques, j'ai un faux résultat, pourquoi? exemple: sandbox.onlinephpfunctions.com/code/…
stloc
3
@stloc, ===with objects vous indique s'il s'agit du même objet, pas s'ils ont le même contenu.
Andrea
Introduit en PHP4, drôle en Y2018 ;-)
mvorisek
22
  • = est l'opérateur d'affectation
  • == est l'opérateur de comparaison (vérifie si deux variables ont des valeurs égales)
  • === est l'opérateur de comparaison identique (vérifie si deux variables ont des valeurs égales et sont du même type).
Rich Adams
la source
8

= opérateur d'affectation

== vérifie si deux variables ont la même valeur

=== vérifie si deux variables ont la même valeur ET si leurs types sont les mêmes

Silvio Donnini
la source
1
Connaissez également les versions! = Et! == 'not' des deux opérateurs de comparaison. Certaines langues utilisent: = comme affectation, juste pour éviter ce genre de confusion.
Phil Perry
3

L'opérateur = affecte la valeur à une variable $ six = 6; la valeur 6 est affectée à la variable $ six

== l'opérateur vérifie si la valeur des deux variables est égale et principalement utilisée dans des conditions comme les instructions if

$a = 2;
$b = 2;
if ($a == $b) { 
    echo both variables have the same value; 
}

=== opérateur similaire à == (vérifiez si la valeur est égale à) et vérifiez également si les deux sont du même type de données

$a = 2;
$b = "2";
if ($a === $b) {
    echo "both variable have same value and of same data type";
} else {
    echo 'both variable is either not equal or not of same data type';
}

// ici $ a est de type int alors que $ b est de type string. Alors voici la sortie

Gideon Babu
la source
0

Pour les utilisateurs avancés de PHP, connaître la différence entre ==et ===et se demander "est-il plus rapide de comparer avec ==ou avec=== quand je suis sûr que les deux opérandes sont du même type?"

La réponse courte et générale est: il n'y a pas de gain de performances à utiliser ===dans ce cas, vous devriez donc probablement utiliser ==.

Pour ceux qui sont intéressés à le comparer eux-mêmes, vous pouvez utiliser le code suivant que j'ai écrit ad hoc et essayer différentes valeurs pour $aet $b:

<?php
    // CONFIGURATION
    $cycles = 1000000;
    $a = 'random string 1';
    $b = 'random string 2';

    // FUNCTIONS
    function compare_two_equals($a, $b) {
        if ($a == $b) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

    function compare_three_equals($a, $b) {
        if ($a === $b) {
            return TRUE;
        } else {
            return FALSE;
        }
    }

    // EXECUTION
    $time = microtime(TRUE);
    for ($count_a = 0; $count_a < $cycles; $count_a++) {
        compare_two_equals($a, $b);
    }
    $time_two_a = microtime(TRUE) - $time;
    $time = microtime(TRUE);
    for ($count_a = 0; $count_a < $cycles; $count_a++) {
        compare_three_equals($a, $b);
    }
    $time_three_a = microtime(TRUE) - $time;
    $time = microtime(TRUE);
    for ($count_a = 0; $count_a < $cycles; $count_a++) {
        compare_two_equals($a, $b);
    }
    $time_two_b = microtime(TRUE) - $time;
    $time = microtime(TRUE);
    for ($count_a = 0; $count_a < $cycles; $count_a++) {
        compare_three_equals($a, $b);
    }
    $time_three_b = microtime(TRUE) - $time;
    $time = microtime(TRUE);

    // RESULTS PRINTING
    print "<br />\nCOMPARE == (FIRST TRY): " . number_format($time_two_a, 3) . " seconds";
    print "<br />\nCOMPARE == (SECOND TRY): " . number_format($time_two_b, 3) . " seconds";
    print "<br />\nCOMPARE === (FIRST TRY): " . number_format($time_three_a, 3) . " seconds";
    print "<br />\nCOMPARE === (SECOND TRY): " . number_format($time_three_b, 3) . " seconds";
?>

REMARQUE: la comparaison n'est valide que lorsque chaque "PREMIER ESSAI" est très proche de son "SECOND ESSAI". S'ils sont significativement différents, cela signifie que le processeur était occupé à faire autre chose lors de l'exécution des comparaisons et que les résultats ne sont donc pas fiables et que le benchmark doit être réexécuté.

lucaferrario
la source
9
Les microbenchmarks comme celui-ci ne sont pas très fiables. Il est également très peu probable que vous souhaitiez vous inquiéter ==ou ===être la cause de votre problème de performances. IMO: Il vaut mieux être strict ( ===) à moins que vous ne vouliez explicitement être lâche ( ==) à propos de vos comparaisons. Le nombre de cas de bord étranges, c'est "5 is not a number" == 5-à- dire peut conduire à des bugs farfelus. ===ne souffre jamais de ce problème.
gnarf
Mon test consistait à dire aux programmeurs que s'ils choisissent ===pour des raisons de performances, ils ont tort. Les programmeurs sont donc libres de choisir ===ou en ==fonction de raisons logiques mais pas de raisons de performances: il existe différents cas pour préférer l'un ou l'autre et la performance ne doit pas du tout être prise en compte.
lucaferrario