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

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

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

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

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

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

---

изменить опять

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

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

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

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

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

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

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

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

• null

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

• Нэн

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

• 0

• ложные

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

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

if (!EmpName) { //do something }

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

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

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

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

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

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

window - это объект, который содержит все глобальные переменные в качестве своих свойств, и в JavaScript законно пытаться получить доступ к несуществующему свойству объекта. Если history не существует тогда window.history возвращает undefined. undefined является ложным, поэтому код в 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;
    }

Typescript-совместимый.

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

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

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

Если вы используете jQuery, вы можете определить, является ли переменная не определена или ее значение равно 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;

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

if (object) { Somecode}

т. е.

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

элемент проверки jQuery not null

var dvElement = $('#dvElement');

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

лучшим образом:

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

/* do your stuff */
}

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

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
• неопределено
• Нэн
• пустой
• строка ("")
• 0
• ложные

Я запускаю этот тест на консоли 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

var i;

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

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

if(typeof value == 'undefined'){

(null == undefined)  // true

(null === undefined) // false

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

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

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

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

вы можете проверить это с помощью этого метода-

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

вызов 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.")
};

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

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

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

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

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

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

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