Les 3 différents égaux

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.

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 .

• = 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).

= 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

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

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