In che modo differiscono gli operatori di confronto di uguaglianza PHP (== doppio uguale) e identità (=== triplo uguale)?


Answers

L'operatore == esegue il cast tra due diversi tipi se sono diversi, mentre l'operatore === esegue un "confronto typesafe". Ciò significa che restituirà true solo se entrambi gli operandi hanno lo stesso tipo e lo stesso valore.

Esempi:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

Attenzione : due istanze della stessa classe con membri equivalenti NON corrispondono all'operatore === . Esempio:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)
Question

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

  • Come funziona esattamente il confronto approssimativo == ?
  • Come funziona esattamente il confronto rigoroso === ?

Quali sarebbero alcuni esempi utili?




$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

Stai attento però. Ecco un problema famigerato.

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

vs.

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}



L'operatore === dovrebbe confrontare l' esatta uguaglianza dei contenuti mentre l'operatore == confronta l'uguaglianza semantica. In particolare, costringerà le stringhe ai numeri.

L'uguaglianza è un argomento vasto. Vedi l'articolo di Wikipedia sull'uguaglianza .




Un esempio è che un attributo del database può essere nullo o "":

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true



Pochi degli esempi

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

PS

== Confronta solo il valore, non si preoccuperà dei tipi di dati

vs.

=== Confronta i valori e i tipi di dati




Per quanto riguarda quando utilizzare uno sull'altro, prendi ad esempio la funzione fwrite() in PHP.

Questa funzione scrive il contenuto in un flusso di file. Secondo PHP, " fwrite() restituisce il numero di byte scritti, o FALSE in caso di errore.". Se si desidera verificare se la chiamata alla funzione ha avuto esito positivo, questo metodo è difettoso:

if (!fwrite(stuff))
{
    log('error!');
}

Può restituire zero (ed è considerato successo) e la tua condizione viene comunque attivata. La strada giusta sarebbe:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}



In termini più semplici:

== controlla se equivalente (solo valore)

=== controlla se lo stesso (valore e tipo)


Equivalente rispetto a Same: An Analogy

1 + 1 = 2 + 0 (equivalente)

1 + 1 = 1 + 1 (stesso)


In PHP:

true == 1 (true - equivalente in valore)

true === 1 (falso - non uguale in valore e tipo)

  • il vero è booleano
  • 1 è int



Un'immagine vale più di mille parole:

Doppio Equals di PHP == grafico sull'uguaglianza:

PHP Triple Equals === Tabella delle uguaglianze:

Codice sorgente per creare queste immagini:

https://github.com/sentientmachine/php_equality_charts

Meditazione Guru

Coloro che desiderano mantenere la loro sanità mentale, non leggere oltre.

  1. '==' converte gli operandi sinistro e destro in numeri quando possibile (123 == "123foo", ma "123"! = "123foo"
  2. Una stringa esadecimale tra virgolette è occasionalmente un galleggiante e verrà castata contro di essa.
  3. == non è transitivo perché ("0" è == a 0, e 0 è == a "" ma "0"! = "")
  4. "6" == "6", "4.2" == "4.20" e "133" == "0133". Ma 133! = 0133, perché 0133 è ottale. Ma "0x10" == "16" e "1e3" == "1000"
  5. Le variabili PHP che non sono state ancora dichiarate sono false.

  6. False è uguale a 0, stringa vuota e matrice vuota e "0".

  7. Quando i numeri sono abbastanza grandi sono == Infinity.
  8. NAN non == stesso, ma è vero.

  9. Una nuova classe è == a 1.

  10. False è il valore più pericoloso perché False è == alla maggior parte delle altre variabili, per lo più sconfiggendo il suo scopo.

Speranza:

Se stai usando PHP, non usi l'operatore doppio uguale, usa sempre l'equazione tripla.




PHP è un linguaggio vagamente dattiloscritto. L'utilizzo dell'operatore doppio uguale consente di controllare liberamente una variabile.

Il controllo approssimativo di un valore consentirebbe per alcuni valori simili, ma non uguali, di uguagliare come lo stesso:

  • ''
  • nullo
  • falso
  • 0

Tutti questi valori equivarrebbero uguali usando il doppio operatore uguale.