Как определить, является ли переменная "undefined" или "null"?

Как определить, является ли переменная undefined или null? Мой код выглядит следующим образом:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  //DO SOMETHING
};
<div id="esd-names">
  <div id="name"></div>
</div>

Но если я это сделаю, интерпретатор JavaScript останавливает выполнение.

+1957
источник поделиться
30 ответов

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

if (variable == null){
    // your code here.
}

Поскольку null == undefined истинно, приведенный выше код будет захватывать как null, так и undefined.

+2661
источник

Стандартный способ обхода null и undefined одновременно:

if (variable == null) {
     // do something 
}

--which на 100% эквивалентен более явным, но менее кратким:

if (variable === undefined || variable === null) {
     // do something 
}

При написании профессионального JS, само собой === что понимается равенство типа и поведение == vs ===. Поэтому мы используем == и сравниваем только с null.


Изменить снова

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

У вас не должно быть ссылок на необъявленные переменные в вашем коде.

+1055
источник

Объединив вышеупомянутые ответы, кажется, наиболее полным ответом будет:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

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

+205
источник
if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}
+184
источник
if (typeof EmpName != 'undefined' && EmpName) {

будет оцениваться как true, если значение не указано:

  • ноль

  • не определено

  • NaN

  • пустая строка ("")

  • 0

  • ложный

+89
источник
Функция

jQuery attr() возвращает либо пустую строку, либо фактическое значение (и никогда null или undefined). Единственный раз, когда он возвращает undefined, - это когда ваш селектор не возвратил какой-либо элемент.

Итак, вы можете протестировать пустую строку. Альтернативно, поскольку пустые строки, null и undefined являются false-y, вы можете просто сделать это:

if (!EmpName) { //do something }
+23
источник

Я пришел написать свою собственную функцию для этого. JavaScript странный

Можно использовать буквально что угодно. (Обратите внимание, что это также проверяет, содержит ли переменная какие-либо используемые значения. Но так как эта информация обычно также необходима, я думаю, что это стоит опубликовать). Пожалуйста, оставьте записку.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Машинопись-совместимый.


Редактировать. эта функция должна делать то же самое, что и функция PHP empty() (см. RETURN VALUES)

Считает undefined, null, false, 0, 0.0, "0" {}, [] пустыми.

"0.0", NaN, " ", true считаются непустыми.

+16
источник

Если переменная, которую вы хотите проверить, является глобальной, do

if (window.yourVarName) {
    // Your code here
}

Этот способ проверки не будет вызывать ошибку, даже если переменная yourVarName не существует.

Пример: я хочу знать, поддерживает ли мой браузер API истории

if (window.history) {
    history.back();
}

Как это работает:

window - это объект, который содержит все глобальные переменные в качестве своих свойств, а в JavaScript законно пытаться получить доступ к несуществующему объекту. Если history не существует, то window.history возвращает undefined. undefined false, поэтому код в блоке if(undefined){} не будет запущен.

+11
источник

Мне нравится использовать это:

if (!!variable) {
   //do something
}

Он ловит как null, так и undefined

+11
источник

У меня только что была эта проблема, т.е. проверка, является ли объект нулевым.
Я просто использую это:

if (object) {
    // Your code
}

Например:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}
+7
источник

Поскольку вы используете jQuery, вы можете определить, является ли переменная undefined, или ее значение равно null, используя одну функцию.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;
+7
источник

Элемент проверки jQuery не равен null

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    //do something
}
else{
    //else do something else
}
+4
источник

Самый короткий и простой:

if(!EmpName ){
 // DO SOMETHING
}

это будет иметь значение true, если EmpName:

  • нуль
  • неопределенные
  • NaN
  • пустой
  • строка ("")
  • 0
  • ложный
+3
источник

С приведенным ниже решением:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Я могу проверить следующее:

  • ноль
  • не определено
  • NaN
  • пустой
  • string ("")
  • 0
  • ложный
+2
источник

Я запускаю этот тест на консоли хром, используя (void 0), вы можете проверить undefined

var c;
undefined
if(c === void 0)alert();
// output =  undefined
var c = 1;
// output =  undefined
if(c === void 0)alert();
// output =   undefined
// check c value  c
// output =  1
if(c === void 0)alert();
// output =  undefined
c = undefined;
// output =  undefined
if(c === void 0)alert();
// output =   undefined
+1
источник
var i;

if(i === null || typeof i === 'undefined'){
console.log(i,'i is undefined or null')
}else{
console.log(i,'i has some value')
}
+1
источник
(null == undefined)  // true

(null === undefined) // false

Потому что === проверяет как тип, так и значение. Тип обоих отличается, но значение одно и то же.

+1
источник

Самый простой способ проверить это:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}
+1
источник

Лучший способ:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}
0
источник

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

if (x === null || x === undefined) {
 // add your response code here etc.

}

0
источник

Вызов typeof null возвращает значение "object", так как специальное значение null считается пустой ссылкой на объект. Safari через версию 5 и Chrome через версию 7 имеет quirk, где вызов typeof в регулярном выражении возвращает "function", а все другие браузеры возвращают "объект".

-1
источник
var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

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

-1
источник

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

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }
-1
источник

Это очень старый вопрос, но я все же считаю, что лучший/безопасный способ протестировать эти 2 условия - передать значение в строку:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // do something with your code
}
-1
источник

Вы можете проверить, имеет ли значение undefined или null, просто используя typeof:

if(typeof value == 'undefined'){
-1
источник

Я вижу, что исходный пост использовал JQuery. Поэтому я добавляю то, что я использовал в прошлом через JQuery. Обычно, когда я выполняю такую проверку, я не обязательно проверяю, чтобы значение было null или undefined только для этой цели. Больше похоже на "Значение там, поэтому я могу выполнять действия над ним". Поэтому для этого я использую следующее. Я не пробовал каждый тип, но я знаю, что он работает как для null, так и для undefined. Кроме того, объекты и массивы (пустая версия этих объектов вернет true). Кроме того, конечно, если переменная не существует, вы получите исключение, но я честно стараюсь избежать этого любой ценой. Поэтому я согласен с Aerovistae. Я хочу знать об этом в своем коде и не хочу просто пропустить его.

if ($.trim(value) != '') {
   //Do Something
}
-1
источник

В некоторых случаях можно изменить значение undefined. Хотя они обычно редки, иногда бывает лучше избегать фактического использования undefined значения.

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

Эта проверка будет работать для поиска как undefined и null.

Вот пример:

(function(undefined){
    var foo = { baz: null };
    console.log(foo.bar === undefined); //false
    console.log(foo.bar == [][0]); //true
    console.log(foo.baz == [][0]); //true
}(50))
-1
источник

Вы можете проверить это на method-

if(['object','undefined'].indexOf(typeof(variable)) != -1){
    console.log("variable is null or undefined.");
}
-1
источник

Мой вклад в 5 центов за конкретный случай:

var bUndef = ($('#' + selectedNodeID).position() === undefined)
if (bUndef)
....

Свойство не определено не элементом!

-2
источник

if(x==null) - плохая идея в javascript, судья с "==" может вызвать непредвиденное принуждение типа и не может быть прочитан кофе script,   никогда не использовать "==" или "! =" при условии суждения!

if(x) будет лучше. но при этом 0 и "" это будет считаться false, а не равным методом с "!= null" является true.

введите описание изображения здесь

https://www.w3schools.com/js/js_best_practices.asp

-4
источник

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