typeof! == “undefined” vs.! = null

Vedo spesso il codice JavaScript che controlla i parametri non definiti ecc. In questo modo:

if (typeof input !== "undefined") {
    // do stuff
}

Questo sembra un po 'dispendioso, dal momento che comporta sia una ricerca del tipo che un confronto di stringhe, per non parlare della sua verbosità. È necessario perché undefinedpotrebbe essere rinominato, però.

La mia domanda è: in che
modo questo codice è migliore di questo approccio:

if (null != input) {
    // do stuff
}

Per quanto ne so, non puoi ridefinire null, quindi non si romperà inaspettatamente. E, a causa della coercizione del tipo !=dell'operatore, questo verifica sia per undefinede null... che spesso è esattamente ciò che si desidera (ad es. Per parametri di funzione opzionali).

Tuttavia, questo modulo non sembra molto diffuso e fa persino gridare a JSLint per aver usato l' !=operatore malvagio .

Perché questo è considerato un cattivo stile?

typeof è più sicuro in quanto consente all'identificatore di non essere mai stato dichiarato prima:

if(typeof neverDeclared === "undefined") // no errors

if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined

Se la variabile viene dichiarata (o con la varparola chiave, come argomento di funzione o come variabile globale), penso che il modo migliore per farlo sia:

if (my_variable === undefined)

jQuery lo fa, quindi è abbastanza buono per me :-)

Altrimenti, dovrai usare typeofper evitare a ReferenceError.

Se prevedi di ridefinire undefined, puoi racchiudere il codice in questo modo:

(function(undefined){
    // undefined is now what it's supposed to be
})();

O ottenerlo tramite l' voidoperatore:

const undefined = void 0;
// also safe

buon modo:

if(typeof neverDeclared == "undefined") //no errors

Ma il modo migliore è controllare tramite:

if(typeof neverDeclared === typeof undefined) //also no errors and no strings

Non dovresti davvero preoccuparti di essere rinominato indefinito. Se qualcuno rinomina indefinito, avrai molti più problemi di pochi se i controlli falliscono. Se vuoi davvero proteggere il tuo codice, avvolgilo in un IFFE (espressione di funzione immediatamente invocata) in questo modo:

(function($, Backbone, _, undefined) {
    //undefined is undefined here.
})(jQuery, Backbone, _);

Se stai lavorando con variabili globali (che sono già sbagliate) in un ambiente browser, verificherei che non siano definite in questo modo:

if(window.neverDefined === undefined) {
    //Code works
}

Dato che le variabili globali fanno parte dell'oggetto Window, puoi semplicemente controllare contro indefinito invece di eseguire il casting su una stringa e confrontarne le stringhe.

Inoltre, perché le variabili non sono definite? Ho visto un sacco di codice in cui controllano l'esistenza di una variabile ed eseguono un'azione basata su quella. Non ho visto una volta dove questo approccio è stato corretto.

Se sei davvero preoccupato per la ridefinizione di undefined, puoi proteggerti da questo con un metodo di supporto come questo:

function is_undefined(value) {
   var undefined_check; // instantiate a new variable which gets initialized to the real undefined value
   return value === undefined_check;
}

Questo funziona perché quando qualcuno scrive undefined = "foo"lascia solo il nome undefined riferimento a un nuovo valore, ma non cambia il valore effettivo di undefined.

È inoltre possibile utilizzare l'operatore void per ottenere un valore indefinito:

if (input !== void 0) {
    // do stuff    
}

(E sì, come notato in un'altra risposta, questo genererà un errore se la variabile non è stata dichiarata, ma questo caso può spesso essere escluso dall'ispezione del codice o dal refactoring del codice, ad esempio utilizzando window.input !== void 0per testare variabili globali o aggiungere var input.)

In realtà mi sono imbattuto (typeof input !== 'undefined')in questo scenario in cui viene utilizzato per fornire parametri di funzione predefiniti:

function greet(name, greeting) {
  name = (typeof name !== 'undefined') ?  name : 'Student';
  greeting = (typeof greeting !== 'undefined') ?  greeting : 'Welcome';

  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

ES6 offre nuovi modi per introdurre i parametri delle funzioni predefinite in questo modo:

function greet(name = 'Student', greeting = 'Welcome') {
  return `${greeting} ${name}!`;
}

greet(); // Welcome Student!
greet('James'); // Welcome James!
greet('Richard', 'Howdy'); // Howdy Richard!

Questo è meno dettagliato e più pulito della prima opzione.

if (input == undefined) { ... }

funziona benissimo. Ovviamente non è un nullconfronto, ma di solito trovo che se ho bisogno di distinguere tra undefinede null, in realtà ho piuttosto bisogno di distinguere tra undefinede solo qualsiasi valore falso, quindi

else if (input) { ... }

lo fa.

Se un programma lo ridefinisce undefined, è comunque davvero braindead.

L'unica ragione che mi viene in mente era per la compatibilità con IE4, non capiva la undefinedparola chiave (che non è in realtà una parola chiave, sfortunatamente), ma ovviamente i valori potevano essere undefined , quindi dovevi avere questo:

var undefined;

e il confronto sopra funzionerebbe perfettamente.

Nel tuo secondo esempio, probabilmente hai bisogno di doppie parentesi per rendere felice la lanugine?