I 3 diversi uguali

Qual è la differenza tra =, ==e ===?

Penso che usare un segno uguale sia dichiarare una variabile mentre due segni uguali servono per una condizione di confronto e infine tre segni uguali servono per confrontare i valori delle variabili dichiarate.

Hai =l' operatore di assegnazione , ==l' operatore di confronto "uguale" e ===l' operatore di confronto "identico" .

$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)

Per ulteriori informazioni sulla necessità di ==e ===, e le situazioni per usarli, guarda i documenti .

• = è l'operatore di assegnazione
• == è l'operatore di confronto (controlla se due variabili hanno valori uguali)
• === è l'operatore di confronto identico (controlla se due variabili hanno valori uguali e sono dello stesso tipo).

= operatore di assegnazione

== controlla se due variabili hanno lo stesso valore

=== controlla se due variabili hanno lo stesso valore E se i loro tipi sono uguali

L'operatore = assegna il valore a una variabile $ six = 6; il valore 6 è assegnato alla variabile $ six

== l'operatore controlla se il valore di entrambe le variabili è uguale e utilizzato principalmente in condizioni come se le istruzioni

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

Operatore === simile a == (controlla se il valore è uguale) e controlla anche se entrambi dello stesso tipo di dati

$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';
}

// qui $ a è di tipo int mentre $ b è di tipo stringa. Quindi ecco l'output

Per gli utenti esperti di PHP, conoscendo la differenza tra ==e ===e chiedendosi "è più veloce confrontare con ==o con ===quando sono sicuro che entrambi gli operandi sono dello stesso tipo?"

La risposta breve e generale è: in questo caso non vi è alcun vantaggio in termini di prestazioni ===, quindi è consigliabile utilizzarlo ==.

Per coloro che sono interessati al benchmark stesso, è possibile utilizzare il seguente codice che ho scritto ad hoc e provare diversi valori per $ae $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";
?>

NOTA: il confronto è valido solo quando ogni "PRIMA PROVA" è molto vicino alla sua "SECONDA PROVA". Se sono significativamente diversi, significa che il processore era impegnato a fare qualcos'altro durante l'esecuzione dei confronti e quindi i risultati non sono affidabili e il benchmark dovrebbe essere eseguito di nuovo.