Как проверить неопределенную или нулевую переменную в JavaScript?

Question

Мы часто используем следующий код в нашем коде JavaScript

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

Есть ли менее подробный способ проверки с таким же эффектом?

Согласно некоторым форумам и литературе, просто следующее должно иметь такой же эффект.

if (some_variable)
{
    // Do something with some_variable
}

К сожалению, Firebug оценивает такой оператор как ошибку во время выполнения, когда some_variable не определен, тогда как первый из них просто подходит Это только (нежелательное) поведение Firebug или действительно есть какая-то разница между этими двумя способами?

Answer 1

Я думаю, что самый эффективный способ проверить, что "значение - это null или undefined" - это

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Итак, эти две строки эквивалентны:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Примечание 1

Как упоминалось в вопросе, короткий вариант требует, чтобы было объявлено some_variable, в противном случае будет выдано ReferenceError. Однако во многих случаях вы можете предположить, что это безопасно:

проверка необязательных аргументов:

function(foo){
    if( foo == null ) {...}

проверка свойств существующего объекта

if(my_obj.foo == null) {...}

С другой стороны, typeof может работать с необъявленными глобальными переменными (просто возвращает undefined). Тем не менее, по понятным причинам, эти случаи должны быть сведены к минимуму, как объяснил Альсиенде.

Примечание 2

Это - еще короче - вариант не эквивалент:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

так

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Примечание 3

Обычно рекомендуется использовать === вместо ==. Предлагаемое решение является исключением из этого правила. Синтаксическая проверка JSHint даже предоставляет опцию eqnull по этой причине.

Из руководства по стилю jQuery :

В пользу == следует использовать строгие проверки на равенство (===). Единственный исключение - при проверке неопределенности и нуля посредством нуля.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Answer 2

Вы должны различать случаи:

1. Переменные могут быть undefined или необъявленными . Вы получите ошибку, если получите доступ к необъявленной переменной в любом контексте, кроме typeof.

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

Переменная, которая была объявлена, но не инициализирована, является undefined.

let foo;
if (foo) //evaluates to false because foo === undefined

2. Не определено свойства , например someExistingObj.someUndefProperty. Неопределенное свойство не приводит к ошибке и просто возвращает undefined, которое при преобразовании в логическое значение оценивается как false. Так что, если вы не заботитесь о 0 и false, использование if(obj.undefProp) нормально. Есть общая идиома, основанная на этом факте:

   value = obj.prop || defaultValue
   

   , что означает "если obj имеет свойство prop, присвойте его value, в противном случае присвойте значение по умолчанию defautValue".

   Некоторые люди считают, что это поведение сбивает с толку, утверждая, что это приводит к трудно обнаруживаемым ошибкам, и рекомендуют вместо этого использовать оператор in

   value = ('prop' in obj) ? obj.prop : defaultValue
   

Answer 3

Проверка нулевого значения с нормальным равенством также вернет true для неопределенного.

Answer 4

В новых стандартах JavaScript, таких как ES5 и ES6, вы можете просто сказать

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

all возвращает false, что похоже на проверку пустых переменных в Python. Поэтому, если вы хотите написать условную логику вокруг переменной, просто скажите

if (Boolean(myvar)){
   // Do something
}

здесь «null», «пустая строка» или «undefined» будут обрабатываться эффективно.

Answer 5

Если вы попытаетесь сослаться на необъявленную переменную, во всех реализациях JavaScript будет выдана ошибка.

Свойства объектов не подчиняются тем же условиям. Если свойство объекта не было определено, ошибка не будет выдана, если вы попытаетесь получить к нему доступ. Таким образом, в этой ситуации вы можете сократить:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

до

if (myObj.some_property != null)

Имея это в виду и тот факт, что глобальные переменные доступны как свойства глобального объекта (window в случае браузера), вы можете использовать следующее для глобальных переменных:

if (window.some_variable != null) {
    // Do something with some_variable
}

В локальных областях всегда полезно убедиться, что переменные объявлены в верхней части блока кода, это сэкономит при повторяющемся использовании typeof.

Answer 6

Во-первых, вы должны четко понимать, что вы тестируете. В JavaScript есть все виды неявных преобразований, которые могут вас удивить, и два разных типа компараторов равенства: == и ===.

Функция test(val), которая проверяет null или undefined, должна иметь следующие характеристики:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Давайте посмотрим, какие из идей здесь действительно проходят наше испытание.

Эти работы:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

Это не работает:

typeof(val) === 'undefined'
!!val

Я создал запись jsperf, чтобы сравнить правильность и производительность этих подходов. Результаты пока неубедительны, так как не было достаточно прогонов на разных браузерах / платформах. Пожалуйста, уделите минуту, чтобы запустить тест на вашем компьютере!

В настоящее время кажется, что простой тест val == null дает наилучшую производительность. Это также в значительной степени самый короткий. Тест может быть отменен до val != null, если вы хотите дополнения.

Answer 7

Вы можете просто проверить, имеет ли переменная значение или нет.Значение,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

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

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Answer 8

Поскольку нет единого полного и правильного ответа, я постараюсь подвести итог:

В общем, выражение:

if (typeof(variable) != "undefined" && variable != null)

нельзя упростить, поскольку variable может быть необъявленным, поэтому пропуск typeof(variable) != "undefined" приведет к ReferenceError. Но, вы можете упростить выражение в соответствии с контекстом :

Если variable равен global , вы можете упростить до:

if (window.variable != null)

Если это local , вы, вероятно, можете избежать ситуаций, когда эта переменная не объявлена, а также упростить до:

if (variable != null)

Если это свойство объекта , вам не нужно беспокоиться об ReferenceError:

if (obj.property != null)

Answer 9

Я сделал это, используя этот метод

сохранить идентификатор в некоторой переменной

var someVariable = document.getElementById("someId");

, а затем использовать, если условие

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Answer 10

это единственный случай, в котором следует использовать ==:

if (val == null) console.log('val is null or undefined')