typeof! == "undefined" против! = null

Question

Я часто вижу код JavaScript, который проверяет неопределенные параметры и т. Д. Таким образом:

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

Это кажется расточительным, поскольку включает как поиск типов, так и сравнение строк, не говоря уже о его многословности. Это необходимо, потому что «undefined» может быть переименован. Мой вопрос: как этот код лучше, чем этот подход:

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

Насколько я знаю, вы не можете переопределить нуль, поэтому он не сломается неожиданно. И из-за приведения типов оператора! = Это проверяет как неопределенное, так и нулевое ... что часто именно то, что вы хотите (например, для необязательных параметров функции). Тем не менее, эта форма не кажется широко распространенной, и она даже заставляет JSLint кричать на вас за использование оператора evil! =. Почему это считается плохим стилем?

Answer 1

typeof безопаснее, так как позволяет идентификатору никогда не быть объявленным ранее:

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

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

Answer 2

Если переменная объявлена ​​(либо с ключевым словом var, как аргумент функции, либо как глобальная переменная), я думаю, что лучший способ сделать это:

if (my_variable === undefined)

jQuery делает это, так что для меня этого достаточно: -)

В противном случае вам придется использовать typeof, чтобы избежать ReferenceError.

Если вы ожидаете, что undefined будет переопределен, вы можете обернуть ваш код следующим образом:

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

Answer 3

хороший способ:

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

Но лучший способ проверить это:

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

Answer 4

Вам не стоит беспокоиться о том, что undefined будет переименован. Если кто-то переименует undefined, у вас будет гораздо больше проблем, чем с несколькими, если проверки не пройдены. Если вы действительно хотите защитить свой код, оберните его в IFFE (выражение для немедленного вызова функции), например:

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

Если вы работаете с глобальными переменными (что уже неверно) в среде браузера, я бы проверил неопределенность следующим образом:

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

Поскольку глобальные переменные являются частью объекта окна, вы можете просто проверить неопределенность вместо приведения к строке и сравнения строк.

Кроме того, почему ваши переменные не определены? Я видел много кода, где они проверяют существование переменных и выполняют некоторые действия, основанные на этом. Ни разу я не видел, где этот подход был правильным.

Answer 5

Если вы действительно беспокоитесь о переопределении неопределенного, вы можете защитить его с помощью некоторого вспомогательного метода, такого как:

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

Это работает, потому что когда кто-то пишет undefined = "foo", он только позволяет name undefined ссылаться на новое значение, но он не меняет фактическое значение undefined.

Answer 6

Вы также можете использовать оператор void для получения неопределенного значения:

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

(И да, как отмечалось в другом ответе, это приведет к ошибке, если переменная не была объявлена, но этот случай часто может быть исключен либо проверкой кода, либо рефакторингом кода, например, с использованием window.input !== void 0 для тестирования глобальные переменные или добавление var input.)

Answer 7

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!

Answer 8

Я действительно сталкивался, если (typeof input !== 'undefined') в этом сценарии, где он используется для предоставления параметров функции по умолчанию:

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 предоставляет новые способы ввода параметров функции по умолчанию следующим образом:

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

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

Это менее многословно и чище, чем первый вариант.

Answer 9

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

Answer 10

(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