it-swarm.com.de

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

Ich sehe oft JavaScript-Code, der auf undefinierte Parameter usw. prüft:

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

Dies scheint ein wenig verschwenderisch zu sein, da es sowohl eine Typensuche als auch einen Zeichenkettenvergleich beinhaltet, ganz zu schweigen von der Ausführlichkeit. Dies ist erforderlich, da "undefined" jedoch umbenannt werden könnte. Meine Frage ist: Wie ist der Code besser als dieser Ansatz?

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

Soweit ich weiß, können Sie null nicht neu definieren, sodass es nicht unerwartet brechen wird. Und aufgrund der Typ-Koerzierung des Operators! = Wird sowohl nach undefined als auch nach Null gesucht ... was oft 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 ist das ein schlechter Stil?

446
Derek Thurn

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
651
seanmonstar

Wenn die Variable deklariert ist (entweder mit dem Schlüsselwort var, als Funktionsargument oder als globale Variable), denke ich, dass dies am besten ist:

if (my_variable === undefined)

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

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

Wenn Sie erwarten, dass undefined neu definiert wird, können Sie Ihren Code folgendermaßen umbrechen:

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

gute Möglichkeit:

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

Am besten schaust du aber über:

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

Sie sollten sich nicht wirklich sorgen, dass undefined umbenannt wird. Wenn jemand undefined umbenennt, werden Sie viel mehr Probleme haben als nur ein paar, wenn die Überprüfung fehlschlägt. Wenn Sie Ihren Code wirklich schützen möchten, wickeln Sie ihn wie folgt in einen IFFE (sofort aufgerufenen Funktionsausdruck) ein:

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

Wenn Sie in einer Browser-Umgebung mit globalen Variablen arbeiten (was bereits falsch ist), würde ich Folgendes auf Folgendes prüfen:

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

Da globale Variablen Teil des Fensterobjekts sind, können Sie einfach auf undefined prüfen, anstatt in einen String zu konvertieren und Strings zu vergleichen. 

Warum werden Ihre Variablen darüber hinaus 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. 

12
Peeter

Wenn Sie wirklich besorgt sind, dass undefiniert neu definiert wird, können Sie sich mit einer Hilfsmethode wie der folgenden 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, wenn jemand undefined = "foo" schreibt, er nur den name undefined-Verweis auf einen neuen Wert lässt, den tatsächlichen Wert von undefined jedoch nicht ändert.

5
Ivo Wetzel

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

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

(Ja, in einer anderen Antwort wird darauf hingewiesen, dass dies zu einem Fehler führt, wenn die Variable nicht deklariert wurde. Dieser Fall kann jedoch häufig durch Code-Inspektion oder durch Code-Refactoring ausgeschlossen werden, z. B. window.input !== void 0 zum Testen globaler Variablen oder Hinzufügen von var input .)

4
Claude

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

  console.log(greeting,name);
}

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

//ES6 provides new ways of introducing default function parameters this way:

function greet2(name = 'Student', greeting = 'Welcome') {
//  return '${greeting} ${name}!';
console.log(greeting,name);
}

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

1
Avinash Maurya

Ich bin tatsächlich auf (typeof input !== 'undefined') gestoßen, wenn in diesem Szenario Standard-Funktionsparameter angegeben werden: 

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, Standardfunktionsparameter auf diese Weise einzuführen:

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.

1
JSpecs

var bar = null;
console.log(typeof bar === "object"); //true yes 
//because null a datatype of object

var barf = "dff";
console.log(typeof barf.constructor);//function


console.log(Array.isArray(bar));//falsss


console.log((bar !== null) && (bar.constructor === Object)); //false

console.log((bar !== null) && (typeof bar === "object"));  // logs false
//because bar!==null, bar is a object


console.log((bar !== null) && ((typeof bar === "object") || (typeof bar === "function"))); //false

console.log(typeof bar === typeof object); //false
console.log(typeof bar2 === typeof undefined); //true
console.log(typeof bar3 === typeof undefinedff); //true
console.log(typeof bar2 == typeof undefined); //true

console.log((bar !== null) && (typeof bar === "object") && (toString.call(bar) !== "[object Array]")); //false

0
Avinash Maurya

(function(){

  var a= b = 3;
  var ed = 103;
  
})();



//console.log(ed); //ed is not defined

console.log("a defined? " + (typeof a !== 'undefined')); //no define
console.log("b defined? " + (typeof b !== 'undefined')); //yes define
console.log(typeof(b)); //number
console.log(typeof(4+7));   //number
console.log(b); //3
console.log(typeof("4"+"7")); //string
var e= "ggg";
console.log(typeof(e)); //string
 var ty=typeof(b);
console.log(ty); //number
console.log(typeof false); //boolean
console.log(typeof 1); //number
console.log(typeof 0); //number
console.log(typeof true); //boolean


console.log(typeof Math.tan);  //function
console.log(typeof function(){}); //function 

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

//if(neverDeclared == null) //showing error 


console.log(typeof {a:1}); //object
console.log(typeof null); //object
console.log(typeof JSON); //object
console.log(typeof Math); //object
console.log(typeof /a-z/); //object
console.log(typeof new Date()); //object

console.log(typeof afbc); //undefined
//console.log(typeof new);//error

document.write("<br> * oprator as math ");
var r=14*"4";
document.write(r);

document.write("<br> + oprator as string ");
var r=14+"44";
document.write(r);

document.write("<br> Minus Operator work as mathematic ");
var r=64-"44";
document.write(r);


document.write("<br>");
console.log(typeof(4*"7")); //returns number
console.log(typeof(4+"7")); //returns string




 
Interview Question in JavaScript

0
Avinash Maurya