Perché è una cattiva idea consentire questi in JavaScript ==,! =, ++, -

Question

Stavo verificando JSLint, e alcune delle regole hanno suscitato il mio interesse. In particolare questo:

Disallow == e =

Disallow ++ e -

Perché è una cattiva idea per non consentire questi!? Capisco la prima parte, in pratica mi vuole fare === anziché ==. Non capisco perché però. Capisco la differenza tra i due, voglio solo sapere perché è una cattiva pratica. Alcune volte voglio davvero fare == per esempio in modo da valutare true per undefined == null

Il secondo, beh, non capisco affatto. Vuole che io faccia myInt + = 1 invece di myInt ++?

Grazie!

Answer 1

Douglas Crockford (il ragazzo che ha scritto JSLint) si spiega in questo video:

http://www.youtube.com/watch?v=hQVTIJBZook#t=14m45s

ma in fondo (come è già stato detto) E 'a causa del tipo coercian.

Vale la pena guardare il video di chi è onesto - molto interessante e utile.

Answer 2

Doug Crockford ha le sue idee su ciò che è "buono" e "cattivo" in Javascript. Di conseguenza, JSLint implementa questi controlli, ma li rende facoltativi se non si è completamente d'accordo con lui.

L'eliminazione di == impedisce di commettere errori quando si intende realmente ===. Ovviamente questo presuppone che tu non voglia mai veramente usare ==.

Impedire ++ e -- è una cosa stile, alcune persone credono che sono più difficili da leggere rispetto += 1 e -= 1.

Answer 3

Il comportamento degli operatori di uguaglianza standard (== e! =) Dipende dalla versione JavaScript. Quindi questa è una ragione per non usarli.

Un'altra ragione è che il comportamento del = tende a essere molto vago.

Vedi https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Operators/Comparison_Operators

Answer 4

Dal instructions:!

Il == e = gli operatori non di tipo coercizione prima di confrontare. Questo è male perché causa '\ t \ r \ n' == 0 per essere vero. Questo può mascherare errori di tipo.

e

L'++ (incremento) e - (decremento) gli operatori sono stati conosciuti per contribuire al codice cattivo incoraggiando accorgimenti eccessivo. Sono seconde solo all'architettura difettosa nel consentire virus e altre minacce di sicurezza. C'è un'opzione plusplus che vieta l'uso di questi operatori.

Answer 5

non sono d'accordo troppo con queste regole, invece di scoraggiare l'uso di ==, mi sento di raccomandare a imparare sul tipo di coercizione.

La ragione principale sul perché Crockford vuole evitare == è che le regole di confronto a seconda dei tipi di operandi può fare questo operatore non transitive, per esempio, se:

A == B AND 
B == C 

doesn' t garantisce che:

A == C 

Un esempio reale:

'0' == 0; // true 
0 == ''; // true 
'0' == ''; // false 

La stretta === operatore non è davvero necessario quando si confrontano i valori dello stesso tipo, ad esempio:

if (typeof foo == "function") { } 

Confrontiamo il risultato della typeof dell'operatore, che è sempre una stringa, con una stringa letterale ...

Un altro esempio, quando si confrontano qualcosa contro null, == confronta anche contro undefined, ad esempio:

if (something == null) {} 

VS

if (something === null || typeof something === "undefined") {} 

Quanto sopra due condizioni sono alla fine equivalente, ma il primo molto più leggibile, naturalmente, se si conoscono il tipo di coercizione e di come si comporta ==.

Imparare come funziona l'operatore ==, vi aiuterà a decidere con saggezza quale utilizzare.

articoli consigliati:

• ECMAScript. Equality operators (Grande suggerimenti per ricordare come == opere)
• typeof, == and ===

Answer 6

capisco ==. (La cosa undefined == null è un'eccezione)

("0" == false) === true 
("0" === false) === false 

Non ho mai capito la cosa ++ e -- però. Non mi piace fare i+=1 in tutto il mio codice (è più lento di ++i).

Answer 7

Gli operatori == e != eseguono il conversone implicito degli operatori se necessario, mentre gli operatori === e !== no. Ad esempio, l'espressione sarà vera, mentre l'espressione 4 === '4' sarà falsa.

Preferibilmente dovresti conoscere i tipi di dati con cui hai a che fare, in modo da poter fare i confronti appropriati nel codice.

Il ++ e -- operatori non causa alcun problema se utilizzati da soli in una dichiarazione, ma sono spesso utilizzati per fare una dichiarazione che fa più di una cosa in un modo non così ovvio, come:

arr[++idx] = 42; 

che sarebbe più chiaro come: "JSLint farà male i tuoi sentimenti"

idx += 1; 
arr[idx] = 42;