JSLint prevedeva "===" e invece vedeva "=="

Recentemente stavo eseguendo parte del mio codice tramite JSLint quando ho riscontrato questo errore. La cosa che penso sia divertente di questo errore è che assume automaticamente che tutti i == dovrebbero essere ===.

Ha davvero senso? Ho notato molti casi in cui non vorresti confrontare il tipo e sono preoccupato che questo possa effettivamente causare problemi.

La parola "Previsto" implicherebbe che questo dovrebbe essere fatto OGNI volta ..... Questo è ciò che non ha senso per me.

IMO, usare ciecamente ===, senza cercare di capire come funziona la conversione del tipo non ha molto senso.

Il timore principale dell'operatore Uguale a ==è che le regole di confronto a seconda dei tipi confrontati possano rendere l'operatore non transitivo, ad esempio, se:

A == B AND
B == C

Non garantisce realmente che:

A == C

Per esempio:

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

L'operatore Strict Equals ===non è realmente necessario quando si confrontano valori dello stesso tipo, l'esempio più comune:

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

Confrontiamo il risultato typeofdell'operatore, che è sempre una stringa , con una stringa letterale ...

O quando conosci le regole di coercizione del tipo, ad esempio, controlla se qualcosa è nullo undefinedqualcosa del genere:

if (foo == null) {
  // foo is null or undefined
}

// Vs. the following non-sense version:

if (foo === null || typeof foo === "undefined") {
  // foo is null or undefined
}

JSLint è intrinsecamente più difensivo di quanto consentito dalla sintassi Javascript.

Dalla documentazione di JSLint:

Gli operatori ==e !=digitano la coercizione prima del confronto. Questo è un male perché fa sì ' \t\r\n' == 0che sia vero. Questo può mascherare errori di tipo.

Quando si confronta uno dei seguenti valori, utilizzare gli operatori ===o !==(che non digitano coercizione):0 '' undefined null false true

Se ti interessa solo che un valore sia vero o falso , usa la forma abbreviata. Invece di

(foo != 0)

basta dire

(foo)

e invece di

(foo == 0)

dire

(!foo)

Gli operatori ===e !==sono preferiti.

Tieni presente che JSLint rafforza l'idea di una persona su cosa dovrebbe essere un buon JavaScript. È comunque necessario usare il buon senso quando si implementano le modifiche suggerite.

In generale, il confronto tra tipo e valore renderà il tuo codice più sicuro (non ti imbatterai in un comportamento imprevisto quando la conversione del tipo non fa quello che pensi che dovrebbe).

Triplo uguale è diverso da doppio uguale perché oltre a controllare se i due lati hanno lo stesso valore, triplo uguale controlla anche che siano dello stesso tipo di dati.

Quindi ("4" == 4)è vero, mentre ("4" === 4)è falso.

Triple-equal funziona anche leggermente più velocemente, perché JavaScript non deve perdere tempo a fare conversioni di tipo prima di darti la risposta.

JSLint è deliberatamente mirato a rendere il tuo codice JavaScript il più rigoroso possibile, con l'obiettivo di ridurre i bug oscuri. Evidenzia questo genere di cose per cercare di farti programmare in un modo che ti costringa a rispettare i tipi di dati.

Ma la cosa buona di JSLint è che è solo una guida. Come si dice sul sito, ferirà i tuoi sentimenti, anche se sei un ottimo programmatore JavaScript. Ma non dovresti sentirti obbligato a seguire i suoi consigli. Se hai letto quello che ha da dire e lo capisci, ma sei sicuro che il tuo codice non si romperà, allora non sei costretto a cambiare nulla.

Puoi anche dire a JSLint di ignorare le categorie di controlli se non vuoi essere bombardato da avvisi per i quali non farai nulla.

Una citazione da http://javascript.crockford.com/code.html :

=== e! == Operatori.

È quasi sempre meglio usare gli operatori === e! ==. Gli operatori == e! = Digitano coercizione. In particolare, non utilizzare == per confrontare con valori falsi.

JSLint è molto rigoroso, il loro "webjslint.js" non supera nemmeno la propria convalida.

Se vuoi verificare la falsità. JSLint non consente

if (foo == null)

ma permette

if (!foo)

Per aiutare a spiegare questa domanda e anche a spiegare perché NetBeans (da) 7.3 ha iniziato a mostrare questo avviso, questo è un estratto della risposta sul bug tracker di NetBeans quando qualcuno lo ha segnalato come un bug:

È buona norma utilizzare === anziché == in JavaScript.

Gli operatori == e! = Digitano la coercizione prima del confronto. Questo è negativo perché fa sì che '\ t \ r \ n' == 0 sia vero. Questo può mascherare errori di tipo. JSLint non può determinare in modo affidabile se == viene usato correttamente, quindi è meglio non usare affatto == e! = E usare sempre gli operatori === e! == più affidabili invece.

Riferimento

Beh, non può davvero causare problemi, ti sta solo dando consigli. Prendere o lasciare. Detto questo, non sono sicuro di quanto sia intelligente. Potrebbero esserci contesti in cui non lo presenta come un problema.