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

Мы часто используем следующий шаблон кода в нашем коде 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 или действительно есть какая-то разница между этими двумя способами?

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

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

Я думаю, что самый эффективный способ проверить на «значение есть 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;

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

if (window.variable == null) alert('variable is null or undefined');

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

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

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

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

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

Если вы попытаетесь сослаться на необъявленную переменную, во всех реализациях 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.

Во-первых, вы должны четко понимать, что вы тестируете. В 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если вы хотите дополнения.

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

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

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

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

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

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

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

if (window.variable != null)

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

if (variable != null)

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

if (obj.property != null)

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

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
}

Я сделал это с помощью этого метода

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

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

тогда используйте условие if

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

Это пример очень редкого случая, когда его рекомендуется использовать ==вместо ===. Выражение somevar == nullвернет true для undefinedи null, но false для всего остального (ошибка, если переменная не объявлена).

Использование !=перевернет результат, как и ожидалось.

Современные редакторы не будут предупреждать об использовании ==или работе !=с ними null, так как это почти всегда желаемое поведение.

Наиболее распространенные сравнения:

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

Попробуй сам:

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

Как упоминалось в одном из ответов, вам может повезти, если вы говорите о переменной, имеющей глобальную область видимости. Как вы, возможно, знаете, переменные, которые вы определяете глобально, как правило, добавляются к объекту windows. Вы можете воспользоваться этим фактом, поэтому допустим, что вы обращаетесь к переменной с именем bleh, просто используйте оператор с двойным инвертированием (!!)

!!window['bleh'];

Это вернет false, пока bleh не был объявлен и ему не присвоено значение.

Вот еще один способ использования метода Array include () :

[undefined, null].includes(value)

независимо от того, что yyy не определено или равно нулю, оно вернет true

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

да

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

нет

Откройте инструменты разработчика в вашем браузере и просто попробуйте код, показанный на рисунке ниже.

Чтобы понять, давайте проанализируем, какое будет значение, возвращаемое Javascript Engine при преобразовании undefined, null и '' (также пустая строка). Вы можете непосредственно проверить то же самое на своей консоли разработчика.

Вы можете видеть, что все преобразуются в ложные, то есть все эти три предполагают «отсутствие существования» в javascript. Так что вам не нужно явно проверять все три в вашем коде, как показано ниже.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Также я хочу отметить еще одну вещь.

Что будет результатом логического (0)?

Конечно ложно. Это создаст ошибку в вашем коде, когда 0 является допустимым значением ожидаемого результата. Поэтому, пожалуйста, убедитесь, что вы проверили это при написании кода.

Подобно тому, что у вас есть, вы могли бы сделать что-то вроде

if (some_variable === undefined || some_variable === null) { do stuff }

Тестирование nullity ( if (value == null)) или non-nullity ( if (value != null)) менее многословно, чем тестирование статуса определения переменной.

Более того, тестирование if (value)(или if( obj.property)) для обеспечения существования вашей переменной (или свойства объекта) завершается неудачей, если оно определено с помощью логического falseзначения. Пусть покупатель будет бдителен :)

Оба значения можно легко различить с помощью оператора строгого сравнения:

Рабочий пример на:

http://www.thesstech.com/tryme?filename=nullandundefined

Образец кода:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Если целью оператора if является проверка nullили undefinedзначения перед присвоением значения переменной, вы можете использовать оператор Nullish Coalescing Operator , который наконец-то доступен в JavaScript, хотя поддержка браузера ограничена. По данным caniuse , поддерживается только 48,34% браузеров (по состоянию на апрель 2020 года).

const a = some_variable ?? '';

Это гарантирует, что переменная будет присвоена пустой строке (или любому другому значению по умолчанию), если some_variableесть nullили undefined.

Этот оператор больше всего подходит для вашего случая использования, так как он не возвращает значение по умолчанию для других типов ложных значений, таких как 0и ''.

Вы должны определить функцию этой формы:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

В ES5 или ES6, если вам нужно проверить это несколько раз, вы делаете следующее:

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

С Ramda вы можете просто сделать так, чтобы R.isNil(yourValue) Lodash и другие вспомогательные библиотеки выполняли ту же функцию.