typeof! == «undefined» против! = null

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

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

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

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

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

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

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

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

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

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

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

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

if (my_variable === undefined)

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

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

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

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

Или получить его через voidоператора:

const undefined = void 0;
// also safe

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

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

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

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

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

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

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

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

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

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

Если вы действительно беспокоитесь о переопределении 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"он только позволяет имени undefined ссылаться на новое значение, но он не меняет фактическое значение undefined.

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

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

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

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

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

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

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

else if (input) { ... }

Является ли.

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

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

var undefined;

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

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