Как проверить наличие undefined или нулевой переменной в JavaScript?

Ответ 1

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

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
   

Ответ 2

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

Строгие проверки равенства (===) должны использоваться в пользу ==. Единственный Исключение составляет при проверке для undefined и null с помощью null.

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

Ответ 3

Проверка null с нормальным равенством также вернет true для undefined.

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

Ответ 4

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

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

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

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

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

Ответ 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.

Ответ 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, если вы хотите дополнение.

Ответ 7

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

В общем случае выражение:

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

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

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

if (window.variable != null)

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

if (variable != null)

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

if (obj.property != null)

Ответ 8

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

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
}

Ответ 9

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

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

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

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

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

Ответ 10

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

!!window['bleh'];

Это вернет ложь, пока bleh не будет объявлен И назначено значение.

Ответ 11

любой yyy равен undefined или null, он вернет 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');
}

не

Ответ 12

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

Ответ 13

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

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

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

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

Каким будет результат Boolean (0)?

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

Ответ 14

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

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

Ответ 15

здесь другой способ с использованием метода Array includes():

[undefined, null].includes(value)

Ответ 16

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

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

Ответ 17

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

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

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.");
    }   
}

Ответ 18

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

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

Ответ 19

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

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