Typeof! == "undefined" vs.!= null

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

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

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

Мой вопрос:
Чем этот код лучше этого подхода:

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

Насколько я знаю, вы не можете переопределить null, поэтому он не сломается неожиданно. И из-за приведения типов оператора != это проверяет как undefined, так и null... что часто именно то, что вам нужно (например, для необязательных параметров функции).

Тем не менее, эта форма не кажется широко распространенной, и она даже заставляет JSLint кричать на вас за использование оператора зла !=.

Почему это считается плохим стилем?

+467
источник поделиться
11 ответов

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

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

if(neverDeclared === null) // throws ReferenceError: neverDeclared is not defined
+678
источник

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

if (my_variable === undefined)

jQuery это делает, так что мне это достаточно хорошо :-)

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

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

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

Или получите его с помощью оператора void:

const undefined = void 0;
// also safe
+48
источник
другие ответы

Связанные вопросы


Похожие вопросы

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

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

Но лучше всего проверить через:

if(typeof neverDeclared === typeof undefined) //also no errors and no strings
+26
источник

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

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

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

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

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

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

+12
источник

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

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.

+6
источник

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

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

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

+4
источник

Я действительно сталкивался, если (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!

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

+1
источник

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
источник

(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
источник

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
источник
if (input == undefined) { ... }

работает просто отлично. Это, конечно, не сравнение null, но обычно я обнаруживаю, что если мне нужно различать undefined и null, мне действительно нужно различать undefined и просто любое ложное значение, поэтому

else if (input) { ... }

делает это.

Если программа переопределяет undefined, в любом случае, это действительно braindead.

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

var undefined;

и приведенное выше сравнение будет работать нормально.

В вашем втором примере вам, вероятно, нужны двойные круглые скобки, чтобы сделать линт счастливым?

-7
источник

Посмотрите другие вопросы по меткам или Задайте вопрос