Как я могу определить, является ли переменная «неопределенной» или «нулевой»?

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

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

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

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

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

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

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

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

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

Редактировать снова

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

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

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

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

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

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

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

• значение NULL

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

• NaN

• пустой строкой ("")

• 0

• ложный

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

Таким образом, вы можете проверить на пустую строку. В качестве альтернативы, поскольку пустые строки, null и undefined имеют значение false-y, вы можете просто сделать это:

if (!EmpName) { //do something }

Я пришел написать свою собственную функцию для этого. 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Считаются не пусто.

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

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

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

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

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

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

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

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

if(!EmpName ){
 // DO SOMETHING
}

это оценит как true, если EmpName:

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

Вероятно, самый короткий способ сделать это:

if(EmpName == null) { /* DO SOMETHING */ };

Вот доказательство:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

А вот более подробная информация о ==(источник здесь )

БОНУС : причина, почему ===яснее ==(см. Ответ agc )

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

if (object) {
    // Your code
}

Например:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

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

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;

Элемент проверки jQuery не нулевой:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

В JavaScript, насколько мне известно, мы можем проверить неопределенную, нулевую или пустую переменную, как показано ниже.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Проверьте все условия:

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

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

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

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

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

С решением ниже:

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...

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

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

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

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Я запускаю этот тест в консоли Chrome. Используя (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.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   Выше переменная объявляется только как apple. В этом случае, если мы вызовем метод, alertон будет отображаться как неопределенный.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

Во втором он отображает ноль, потому что переменная appleзначения равна нулю.

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

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

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

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

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

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

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

foo == nullЧек должен сделать трюк и решить «неопределенный или нулевой» случай в кратчайшему. (Не учитывая случай «foo не объявлен».) Но люди, которые привыкли иметь 3 равных (как лучшая практика), могут не принять это. Просто посмотрите на правила eqeqeq или triple-equals в eslint и tslint ...

Явный подход, когда мы проверяем, является ли переменная undefinedили nullотдельно, должен применяться в этом случае, и мой вклад в тему (27 неотрицательных ответов на данный момент!) Заключается в использовании void 0как короткого, так и безопасного способа выполнения проверки для undefined.

Использование foo === undefinedнебезопасно, поскольку undefined не является зарезервированным словом и может быть скрыт ( MDN ). Использование typeof === 'undefined'check безопасно, но если мы не собираемся заботиться о случае foo-is-undeclared, можно использовать следующий подход:

if (foo === void 0 || foo === null) { ... }

если вы создаете функцию для проверки:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

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

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

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

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

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
}

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

if(typeof value == 'undefined'){

if(x==null)плохая идея в JavaScript. Судите по "=="- это может вызвать неожиданное приведение типов, и оно не может быть прочитано CoffeeScript, никогда не используйте "==" или "! =" При оценке условий!

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

См. Лучшие практики JavaScript .