typeof! == "undefined" vs.! = null

Ich sehe oft JavaScript-Code, der auf folgende Weise nach undefinierten Parametern usw. sucht:

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

Dies scheint etwas verschwenderisch zu sein, da es sowohl eine Typensuche als auch einen Zeichenfolgenvergleich beinhaltet, ganz zu schweigen von seiner Ausführlichkeit. Es wird benötigt, weil undefinedes jedoch umbenannt werden könnte.

Meine Frage ist:
Wie ist dieser Code besser als dieser Ansatz:

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

Soweit ich weiß, können Sie nicht neu definieren null, damit es nicht unerwartet kaputt geht. Und aufgrund des Typzwangs des !=Operators wird sowohl nach undefinedals auch nach null... gesucht, was häufig genau das ist, was Sie möchten (z. B. für optionale Funktionsparameter).

Diese Form scheint jedoch nicht weit verbreitet zu sein, und JSLint schreit Sie sogar an, weil Sie den bösen !=Operator verwendet haben.

Warum wird das als schlechter Stil angesehen?

typeof ist sicherer, da der Bezeichner noch nie deklariert wurde:

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

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

Wenn die Variable deklariert ist (entweder mit dem varSchlüsselwort, als Funktionsargument oder als globale Variable), ist der beste Weg, dies zu tun, meiner Meinung nach:

if (my_variable === undefined)

jQuery macht es, also ist es gut genug für mich :-)

Andernfalls müssen Sie verwenden typeof, um a zu vermeiden ReferenceError.

Wenn Sie erwarten, dass undefiniert neu definiert wird, können Sie Ihren Code wie folgt umbrechen:

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

Oder erhalten Sie es über den voidBetreiber:

const undefined = void 0;
// also safe

gute Möglichkeit:

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

Am besten sehen Sie jedoch nach:

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

Sie sollten sich nicht wirklich Sorgen machen, dass undefiniert umbenannt wird. Wenn jemand undefiniert umbenennt, haben Sie viel mehr Probleme als nur ein paar, wenn die Prüfung fehlschlägt. Wenn Sie Ihren Code wirklich schützen möchten, verpacken Sie ihn wie folgt in ein IFFE (sofort aufgerufener Funktionsausdruck):

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

Wenn Sie mit globalen Variablen (die bereits falsch sind) in einer Browserumgebung arbeiten, würde ich nach Undefiniertem wie folgt suchen:

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

Da globale Variablen Teil des Fensterobjekts sind, können Sie einfach gegen undefiniert prüfen, anstatt sie in eine Zeichenfolge umzuwandeln und Zeichenfolgen zu vergleichen.

Warum sind Ihre Variablen nicht definiert? Ich habe viel Code gesehen, in dem sie die Existenz einer Variablen überprüfen und darauf basierend eine Aktion ausführen. Ich habe nicht ein einziges Mal gesehen, wo dieser Ansatz richtig war.

Wenn Sie sich wirklich Sorgen darüber machen, dass undefiniert neu definiert wird, können Sie sich mit einer Hilfsmethode wie dieser davor schützen:

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

Dies funktioniert, weil jemand beim Schreiben undefined = "foo"nur den Namen undefined auf einen neuen Wert verweisen lässt , aber den tatsächlichen Wert von nicht ändert undefined.

Sie können auch den void-Operator verwenden, um einen undefinierten Wert zu erhalten:

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

(Und ja, wie in einer anderen Antwort angegeben, wird dies einen Fehler auslösen, wenn die Variable nicht deklariert wurde. Dieser Fall kann jedoch häufig entweder durch Code-Inspektion oder durch Code-Refactoring ausgeschlossen werden, z. B. window.input !== void 0zum Testen globaler Variablen oder zum Hinzufügen var input.)

Ich bin tatsächlich auf etwas gestoßen, wenn es (typeof input !== 'undefined')in diesem Szenario verwendet wird, um Standardfunktionsparameter bereitzustellen:

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 bietet neue Möglichkeiten zur Einführung von Standardfunktionsparametern auf folgende Weise:

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

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

Dies ist weniger ausführlich und sauberer als die erste Option.

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

funktioniert gut. Es ist natürlich kein nullVergleich, aber ich finde normalerweise, dass ich, wenn ich zwischen undefinedund unterscheiden muss null, eigentlich eher zwischen undefinedund nur irgendeinen falschen Wert unterscheiden muss, also

else if (input) { ... }

macht es.

Wenn ein Programm neu definiert undefined, ist es sowieso wirklich geisteskrank.

Der einzige Grund, an den ich denken kann, war die IE4-Kompatibilität. Es hat das undefinedSchlüsselwort nicht verstanden (was leider eigentlich kein Schlüsselwort ist), aber natürlich könnten Werte sein undefined , also musste man folgendes haben:

var undefined;

und der obige Vergleich würde gut funktionieren.

In Ihrem zweiten Beispiel benötigen Sie wahrscheinlich doppelte Klammern, um Flusen glücklich zu machen?