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

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

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

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

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

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

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

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

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

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

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, если значение не указано:

• ноль

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

• NaN

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

• 0

• ложный

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

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

if (!EmpName) { //do something }

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

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

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

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

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

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

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

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

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

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

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

Поскольку вы используете 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;

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

if (object) { Somecode}

то есть.

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

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

var dvElement = $('#dvElement');

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

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

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
• ложный

var i;

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

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

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

/* do your stuff */
}

Я запускаю этот тест на консоли хром, используя (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

В некоторых случаях можно изменить значение 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))

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

if ($.trim(value) != '') {
   //Do Something
}

(null == undefined)  // true

(null === undefined) // false

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

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

if(typeof value == 'undefined'){

Это очень старый вопрос, но я все же считаю, что лучший/безопасный способ протестировать эти 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
}

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

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

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

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

if(['object','undefined'].indexOf(typeof(variable)) != -1){
    console.log("variable is null or undefined.");
}

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

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

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

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

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

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

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

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