uguaglianza in javascript

Question

Quando si lavora in javascript qualcuno può fornirmi un buon riferimento o spiegazione sui test per l'uguaglianza/diseguaglianza e la coercizione di tipo?

Da quello che ho letto vedo dove ci sono due principi di pensiero sull'uso di eqeq (==) rispetto a eqeqeq (===) alcuni ritengono che non si dovrebbe usare eqeq e sempre come usare eqeqeq così com'è più sicuro da usare.

Ho giocato in giro con alcuni campioni di base e sto avendo difficoltà a discernere la differenza o quando meglio usare uno sopra l'altro:

Per esempio: ecco alcune script di base che stavo scrivendo fuori. Quando provo usando eqeq o eqeqeq ottengo lo stesso risultato. Non ho ancora visto un esempio in cui otterrei risultati diversi (ad esempio utilizzando eqeq restituisce true dove eqeqeq restituisce false).

function write(message){ 

    document.getElementById('message').innerHTML += message +'<br/>'; 
} 


var tim = { name: "tim" }; 
var tim2 = { name: "tim" }; 
//objects are equal to themselves (== vs ==== eqeq or eqeqeq) 
write("tim eq tim: " + (tim == tim)); //returns true 

//objects are only equal to themselves regardless of containing value got that 
write("tim eq tim2: " + (tim === tim2)); //returns false 

//access the primative type to test true or false 
write("tim value eq tim2 value: " + (tim.name === tim2.name)); //returns true 
//how does this differ in efficency over the eqeq operator? is one safer to use over the other? 
//write("tim value eq tim2 value: " + (tim.name == tim2.name)); //also returns true 

//testing primatives 

write("apple eqeqeq apple: " + ("apple" === "apple")); //true 
write("apple eqeqeq apple: " + ("apple" == "apple")); //true 

Qualcuno può fornire una spiegazione o riferimento posso leggere che aiuta a chiarire questo un po 'di più.

acclamazioni,

Answer 1

La differenza tra == e === è abbastanza semplice: == è un confronto tra il valore. === è un confronto tra valore e tipo. L'uso di === impedisce a JavaScript di determinare dinamicamente il tipo e confronta i valori esattamente come sono.

5 == "5"  //true - JS compares the number 5 to a string of "5" and determines the contents are the same 
5 === "5" //false - A character is not a number, they can't be the same. 

0 == false //true - false is a bool, 0 is numerical, but JS determines that 0 evaluates to false 
0 === false //false - numeric is not boolean, they can't be exactly the same thing 

5 == 5.0  //true - need I say more? 
5 === 5.0 //true - one is a float and one is an int, but JS treats them all as numerical 

Trovo che sia fondamentale per i test con funzioni che possono restituire sia false (per errore) che 0 (come risultato legittimo).

JS ha un totale di 5 tipi primitivi = numerico, stringa, booleano, nullo e non definito. === richiede che entrambi gli argomenti siano dello stesso tipo e uguale valore per restituire true. Non ci sono float, int, long, short, ecc. - qualsiasi tipo di numero è raggruppato insieme come numerico.

Answer 2

=== è l'operatore di uguaglianza rigorosa che restituisce vero solo se le variabili hanno lo stesso tipo e valore.

a = 1; 
b = "1"; 

a == b tornerà vero, a === b restituirà falso

Answer 3

La regola di == non è facile da ricordare, si può ottenere tutto la risposta giusta di esempi qui sotto?

"" == "0" // false 
0 == "" // true 
0 == "0" // true 
false == "false" // false 
false == "0" // true 
false == undefined // false 
false == null // false 
null == undefined // true 
" \t\r\n" == 0 // true 

Quindi è meglio usare solo ===, e non usare mai ==.

Answer 4

È semplice.
== esegue una conversione del tipo e quindi confronta i valori convertiti al valore desiderato
=== non esegue la conversione del tipo e confronta direttamente i valori.
Ovviamente === è migliore in termini di prestazioni e precisione ma == è anche conveniente in alcuni casi, quindi è possibile utilizzarli entrambi se si adattano alle proprie esigenze.

comparisons

Cheers!

Answer 5

È necessario aver sentito qualcuno che javascript è un linguaggio molto generico.

Quindi, come detto sopra surreale L'operatore (==) viene utilizzato quando si desidera solo per confrontare i valori degli argomenti e non si preoccupano di loro tipo come 5 == "5" restituirà true. Questo è il caso quando vuoi vedere (per esempio quale tasto l'utente ha premuto e non ti importa del tipo di esso può essere una stringa, un carattere o un intero).

Ma ci sono casi in cui anche il tipo di argomenti è importante. In questi casi si desidera confrontare i tipi di operatori. Quindi in quei casi usi l'operatore di triplice uguaglianza. Ad esempio se si stanno eseguendo alcune operazioni di addizione o moltiplicazione, si desidera assicurarsi che gli operandi siano del tipo compatibile. Quindi usi l'operatore triplo (===).

Answer 6

Ecco un elenco molto completo di cose che non si aspetta quando si utilizzano operatori di uguaglianza

Tutti i seguenti sono vere:

0    ==   "" 
0    ==   " " 
0    ==   [] 
false   ==   "" 
false   ==   " " 
false   ==   [] 
[]    ==   "" 
null   ==   undefined 
"str"   ==   ["str"] 

"1"    ==   true 
"0"    ==   false 

"null"   !=   null 
"false"   !=   false 
"true"   !=   true 
"undefined"  !=   undefined 
"NaN"   !=   NaN 

NaN    !=   NaN   //exception: NO exception 
{}    !=   {}   //exception: same reference 
[]    !=   []   //exception: same reference 

-------------------------------------- 

new Number(10)  !==   10 
new String("str") !==   "str" 
NaN     !==   NaN  //exception: NO exception 
{}     !==   {}  //exception: same reference 
[]     !==   []  //exception: same reference 

_{(Alcuni di loro provenivano da this source)}

In conclusione, non utilizzare mai ==. Nemmeno quando si desidera:.

"Si consiglia vivamente di utilizzare solo l'operatore di uguaglianza rigorosa In casi in cui hanno bisogno di essere costretto tipi, dovrebbe essere fatto in modo esplicito e non lasciata alla coercizione complicato del linguaggio regole."

_(source)