typeof!= = "undefined" vs.= null

Jeśli zmienna jest zadeklarowana (albo za pomocą słowa kluczowego var, jako argument funkcji, albo jako zmienna globalna), myślę, że najlepszym sposobem na to jest:

if (my_variable === undefined)

JQuery to robi, więc mi wystarczy: -)

W przeciwnym razie będziesz musiał użyć typeof, aby uniknąć ReferenceError.

Jeśli spodziewasz się przedefiniowania undefined, możesz zawinąć swój kod w następujący sposób:

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

Dobry Sposób:

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

Ale najlepiej wygląda to sprawdzić przez:

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

Nie powinieneś się martwić o nazwę undefined. Jeśli ktoś zmieni nazwę undefined, będziesz miał o wiele więcej kłopotów niż tylko kilka, jeśli kontrole zawiodą. Jeśli naprawdę chcesz chronić swój kod, zawiń go w IFFE (natychmiast wywołane wyrażenie funkcji) w następujący sposób:

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

Jeśli pracujesz ze zmiennymi globalnymi (co jest już błędne) w środowisku przeglądarki, sprawdziłbym, czy nie jest niezdefiniowany TAK:

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

Ponieważ zmienne globalne są częścią obiektu window, można można po prostu sprawdzić przed undefined zamiast rzucać na ciąg i porównywanie ciągów.

Poza tym, dlaczego twoje zmienne nie są zdefiniowane? Widziałem dużo kodu, w którym sprawdzają istnienie zmiennych i wykonują pewne działania na tej podstawie. Ani razu nie widziałem, gdzie to podejście jest poprawne.

Jeśli naprawdę martwisz się, że undefined zostanie przedefiniowane, możesz Przed tym chronić za pomocą metody pomocniczej takiej jak Ta:

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

To działa, bo jak ktoś pisze undefined = "foo" to pozwala tylko na nazwę undefined odniesienie do nowej wartości, ale nie zmienia rzeczywistej wartości undefined.

Możesz również użyć operatora void, aby uzyskać wartość niezdefiniowaną:

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

(i tak, jak zauważono w innej odpowiedzi, spowoduje to błąd, jeśli zmienna nie została zadeklarowana, ale ten przypadek często można wykluczyć albo przez Inspekcję kodu, albo przez refaktoryzację kodu, np. używając {[1] } do testowania zmiennych globalnych lub dodając var input.)

Natknąłem się na if (typeof input !== 'undefined') w tym scenariuszu, gdzie jest używany do podania domyślnych parametrów funkcji:

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 udostępnia nowe sposoby wprowadzania domyślnych parametrów funkcji w ten sposób:

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

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

Jest to mniej gadatliwe i czystsze niż pierwsza opcja.

(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

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!

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

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

Działa dobrze. Oczywiście nie jest to porównanie null, ale zwykle stwierdzam, że jeśli muszę rozróżnić undefined i null, właściwie raczej muszę rozróżnić undefined i dowolną fałszywą wartość, więc

else if (input) { ... }

Robi to.

Jeśli program redefiniuje undefined to i tak jest naprawdę braindead.

Jedyny powód, dla którego mogę myśleć o zgodności IE4, nie zrozumiał undefined słowo kluczowe (które Niestety nie jest słowem kluczowym), ale z wartości kursu mogą być undefined, więc trzeba było mieć to:

var undefined;

I powyższe porównanie będzie działać dobrze.

W twoim drugim przykładzie, prawdopodobnie potrzebujesz podwójnego nawiasu, aby uszczęśliwić lint?