if (somevariable == undefined) {
  alert('the variable is not defined!');
}

Вы также можете превратить его в функцию, как показано здесь:

function isset(varname){
  return(typeof(window[varname]) != 'undefined');
}

В JavaScript есть ноль и неопределенный. У них разные значения.

• неопределенный означает, что значение переменной не было определено; неизвестно, какова стоимость.
• ноль означает, что значение переменной определено и установлено равным нулю (не имеет значения).

Марин Хавербеке утверждает в своей бесплатной онлайн-книге «Красноречивый JavaScript» (выделено мной):

There is also a similar value, null, whose meaning is 'this value is defined, but it does not have a value'. The difference in meaning between undefined and null is mostly academic, and usually not very interesting. In practical programs, it is often necessary to check whether something 'has a value'. In these cases, the expression something == undefined may be used, because, even though they are not exactly the same value, null == undefined will produce true.

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

if (something == undefined)

Свойства объекта должны работать одинаково.

var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

Решение неверное. В JavaScript

null == undefined

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

if (something === undefined)

который является тождественным оператором ...

Обычный способ проверить, является ли значение свойства специальным значением undefined:

if (o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

Чтобы проверить, действительно ли объект не имеет такого свойства и, следовательно, вернет undefined по умолчанию, когда вы попытаетесь получить к нему доступ:

if (!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

Чтобы проверить, является ли значение, связанное с идентификатором, специальным значением undefined, или же, если этот идентификатор не был объявлен. Примечание: этот метод является единственным способом обращения к идентификатору необъявленный (примечание: отличается от идентификатора undefined) без ранней ошибки:

if (typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

В версиях JavaScript до ECMAScript 5 свойство с именем «undefined» глобального объекта было доступно для записи, и поэтому простая проверка foo === undefined могла бы вести себя неожиданно, если бы оно было случайно переопределено. В современном JavaScript это свойство доступно только для чтения.

Однако в современном JavaScript «undefined» не является ключевым словом, поэтому переменные внутри функций могут быть названы «undefined» и затенять глобальное свойство.

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

if (myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

function isUnset(inp) {
  return (typeof inp === 'undefined')
}

Возвращает false, если переменная установлена, и true, если не определена.

Затем используйте:

if (isUnset(var)) {
  // initialize variable here
}

if ( typeof( something ) == "undefined") 

У меня это сработало, а у других - нет.

Я считаю, что на эту тему есть несколько неправильных ответов. Вопреки распространенному мнению, «undefined» - это ключевое слово в JavaScript нет, которому фактически может быть присвоено значение.

Правильный код

Самый надежный способ выполнить этот тест:

if (typeof myVar === "undefined")

Это всегда будет возвращать правильный результат и даже обработает ситуацию, когда myVar не объявлен.

Вырожденный код. НЕ ИСПОЛЬЗОВАТЬ.

var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}

Кроме того, myVar === undefined вызовет ошибку в ситуации, когда myVar не объявлен.

Я не уверен, откуда взялось использование === с typeof, и в качестве соглашения я вижу, что он используется во многих библиотеках, но оператор typeof возвращает строковый литерал, и мы знаем это заранее, так зачем вам также типа проверь тоже?

typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

Проблема сводится к трем случаям:

1. У объекта есть свойство, и его значение не undefined.
2. У объекта есть свойство, и его значение - undefined.
3. У объекта нет собственности.

Это говорит нам о том, что я считаю важным:

Существует разница между неопределенным членом и определенным членом с неопределенным значением.

Но, к сожалению, typeof obj.foo не сообщает нам, какой из трех случаев у нас есть. Однако мы можем комбинировать это с "foo" in obj, чтобы различать случаи.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true

Стоит отметить, что эти тесты одинаковы и для записей null.

                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false

Я бы сказал, что в некоторых случаях имеет больше смысла (и яснее) проверять, есть ли свойство, чем проверять, не определено ли оно, и единственный случай, когда эта проверка будет отличаться, - это случай 2, редкий случай фактическая запись в объекте с неопределенным значением.

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

if ( typeof blob.x != 'undefined' ) {  fn(blob.x); }

Что было яснее при написании без проверки на undefined.

if ( "x" in blob ) { fn(blob.x); }

Но, как уже упоминалось, это не совсем то же самое (но более чем достаточно для моих нужд).

Если вы это сделаете

if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

он завершится ошибкой, если переменная myvar не существует, потому что myvar не определена, поэтому сценарий не работает и тест не действует.

Поскольку объект окна имеет глобальную область видимости (объект по умолчанию) вне функции, объявление будет «прикреплено» к объекту окна.

Например:

var myvar = 'test';

Глобальная переменная Myvar такая же, как window.myvar или окно ['myvar']

Чтобы избежать ошибок при проверке существования глобальной переменной, лучше использовать:

if (window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}

Вопрос, действительно ли переменная существует, не имеет значения, ее значение неверно. В противном случае глупо инициализировать переменные с помощью undefined, и для инициализации лучше использовать значение false. Когда вы знаете, что все переменные, которые вы объявляете, инициализированы с помощью false, вы можете просто проверить его тип или положиться на !window.myvar, чтобы проверить, имеет ли он правильное / допустимое значение. Таким образом, даже если переменная не определена, !window.myvar будет одинаковым для myvar = undefined, myvar = false или myvar = 0.

Если вы ожидаете определенного типа, проверьте тип переменной. Чтобы ускорить проверку состояния, вам лучше сделать:

if ( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}

Когда первое и простое условие выполняется, интерпретатор пропускает следующие тесты.

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

(у)

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

 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }

jsFiddle ссылка

Object.hasOwnProperty(o, 'propertyname');

Однако это не просматривается в цепочке прототипов.

Я не видел (надеюсь, что не пропустил), чтобы кто-то проверял объект перед свойством. Итак, это самый короткий и самый эффективный (хотя и не обязательно самый понятный):

if (obj && obj.prop) {
  // Do something;
}

Если obj или obj.prop имеет значение undefined, null или "ложный", оператор if не выполнит блок кода. Это обычно - желаемое поведение в большинстве операторов блока кода (в JavaScript).

Кросс-постинг мой ответ из связанного вопроса Как я могу проверить наличие "неопределенного" в JavaScript?.

Конкретно для этого вопроса см. Тестовые примеры с someObject.<whatever>.

Некоторые сценарии, иллюстрирующие результаты различных ответов: http://jsfiddle.net/drzaus/UVjM4/

(Обратите внимание, что использование var для тестов in имеет значение при использовании оболочки с ограниченным объемом)

Код для справки:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if ( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.info(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

И результаты:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

Что это значит: "неопределенное свойство объекта"?

На самом деле это может означать две совершенно разные вещи! Во-первых, это может означать собственность, которая никогда не определялась в объекте, а во-вторых, это может означать свойство с неопределенным значением. Посмотрим на этот код:

var o = { a: undefined }

o.a не определен? Да! Его значение не определено. o.b не определен? Конечно! Свойство "b" вообще не существует! Хорошо, теперь посмотрим, как разные подходы ведут себя в обеих ситуациях:

typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false

Мы ясно видим, что typeof obj.prop == 'undefined' и obj.prop === undefined эквивалентны, и они не различают эти разные ситуации. А 'prop' in obj может обнаружить ситуацию, когда свойство вообще не определено, и не обращает внимания на значение свойства, которое может быть неопределенным.

Так что делать?

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

obj.prop === undefined // IMHO, see "final fight" below

2) Вы просто хотите знать, имеет ли объект какое-либо свойство, и не заботитесь о его значении.

'prop' in obj

Примечания:

• Вы не можете одновременно проверить объект и его свойство. Например, этот x.a === undefined или этот typeof x.a == 'undefined' поднимает ReferenceError: x is not defined, если x не определен.
• Переменная undefined - это глобальная переменная (в браузерах это фактически window.undefined). Он поддерживается с ECMAScript 1st Edition, а с ECMAScript 5 - только чтение. Таким образом, в современных браузерах это не может быть переопределено на истину, которым любят нас пугать многие авторы, но это все еще верно для старых браузеров.

Финальный бой: obj.prop === undefined vs typeof obj.prop == 'undefined'

Плюсы obj.prop === undefined:

• Он немного короче и выглядит немного красивее
• Движок JavaScript выдаст ошибку, если вы неправильно написали undefined.

Минусы obj.prop === undefined:

• undefined можно переопределить в старых браузерах

Плюсы typeof obj.prop == 'undefined':

• Это действительно универсально! Работает в новых и старых браузерах.

Минусы typeof obj.prop == 'undefined':

• 'undefned' (неправильно написан) - это просто строковая константа, поэтому движок JavaScript не сможет вам помочь, если вы неправильно написали его, как только что сделал я.

Обновление (для серверного JavaScript):

Node.js поддерживает глобальную переменную undefined как global.undefined (ее также можно использовать без префикса global). Я не знаю других реализаций серверного JavaScript.

Вот моя ситуация:

Я использую результат вызова REST. Результат должен быть преобразован из JSON в объект JavaScript.

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

Используя этот пост, чтобы помочь мне защититься от этого, я попробовал следующее:

if ( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }

В моей ситуации, если restResult.data [0] === "объект", я могу безопасно начать проверку остальных членов. Если не определено, то выдайте ошибку, как указано выше.

Я говорю, что для моей ситуации все предыдущие предложения в этом посте не сработали. Я не говорю, что я прав, а все ошибаются. Я совсем не мастер JavaScript, но надеюсь, это кому-то поможет.

В статье Изучение бездны пустого и неопределенного в JavaScript я читал, что такие фреймворки, как Underscore.js, используют эту функцию:

function isUndefined(obj){
    return obj === void 0;
}

Сравните с void 0, для краткости.

if (foo !== void 0)

Это не так многословно, как if (typeof foo !== 'undefined')

'если (window.x) {}' безопасен от ошибок

Скорее всего вам нужен if (window.x). Эта проверка безопасна, даже если x не был объявлен (var x;) - браузер не выдает ошибку.

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

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

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

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

Несмотря на то, что многие другие ответы здесь настоятельно рекомендуют typeofплохой выбор. Его никогда не следует использовать для проверки того, имеют ли переменные значение undefined, потому что он действует как комбинированная проверка для значения undefined и того, существует ли переменная. В подавляющем большинстве случаев вы знаете, когда существует переменная, и typeof просто представит возможность скрытого сбоя, если вы сделаете опечатку в имени переменной или в строковом литерале 'undefined'.

var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}

var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}

Поэтому, если вы не выполняете обнаружение функций², где есть неопределенность, будет ли заданное имя находиться в области действия (например, проверка typeof module !== 'undefined' как шага в коде, специфичном для среды CommonJS), typeof является опасным выбором при использовании с переменной, и правильный вариант - сравнить значение напрямую:

var foo = …;

if (foo === undefined) {
    ⋮
}

Некоторые распространенные заблуждения по этому поводу включают:

• что чтение «неинициализированной» переменной (var foo) или параметра (function bar(foo) { … }, называемое bar()) завершится ошибкой. Это просто неправда - переменные без явной инициализации и параметры, которым не были присвоены значения, всегда становятся undefined и всегда находятся в области видимости.

• что undefined можно перезаписать. Это правда, что undefined не является ключевым словом, но он является доступен только для чтения и не подлежит настройке. Есть и другие встроенные модули, которых вы, вероятно, не избежите, несмотря на их статус без ключевых слов (Object, Math, NaN ...), и практический код обычно не написан в активно вредоносной среде, поэтому это не хорошая причина для беспокоился о undefined. (Но если вы пишете генератор кода, не стесняйтесь использовать void 0.)

Разобравшись с принципами работы переменных, пришло время обратиться к самому вопросу: свойствам объекта. Нет причин использовать typeof для свойств объекта. Предыдущее исключение, касающееся обнаружения функций, здесь не применяется - typeof имеет особое поведение только для переменных, а выражения, которые ссылаются на свойства объекта, не являются переменными.

Этот:

if (typeof foo.bar === 'undefined') {
    ⋮
}

равно всегда точно эквивалентен к этому³:

if (foo.bar === undefined) {
    ⋮
}

и принимая во внимание приведенный выше совет, чтобы не вводить читателей в заблуждение относительно того, почему вы используете typeof, потому что имеет наибольший смысл использовать === для проверки равенства, потому что его можно было бы реорганизовать для проверки значения переменной позже, и потому что это просто выглядит лучше, вы всегда должны использовать === undefined³ и здесь.

Когда дело доходит до свойств объекта, следует учитывать еще одно: действительно ли вы хотите вообще проверять undefined. Данное имя свойства может отсутствовать в объекте (при чтении дает значение undefined), присутствовать в самом объекте со значением undefined, присутствовать в прототипе объекта со значением undefined или присутствовать на любом из объектов с не-undefined ценить. 'key' in obj сообщит вам, находится ли ключ где-либо в цепочке прототипов объекта, а Object.prototype.hasOwnProperty.call(obj, 'key') сообщит вам, находится ли он непосредственно на объекте. Я не буду вдаваться в подробности в этом ответе о прототипах и использовании объектов в качестве карт со строковыми ключами, поскольку он в основном предназначен для противодействия всем плохим советам в других ответах, независимо от возможных интерпретаций исходного вопроса. Прочтите прототипы объектов на MDN, чтобы узнать больше!

_{¹ unusual choice of example variable name? this is real dead code from the NoScript extension for Firefox.
² don’t assume that not knowing what’s in scope is okay in general, though. bonus vulnerability caused by abuse of dynamic scope: Project Zero 1225
³ once again assuming an ES5+ environment and that undefined refers to the undefined property of the global object.}

"propertyName" in obj //-> true | false

Также то же самое можно написать короче:

if (!variable){
    // Do it if the variable is undefined
}

или же

if (variable){
    // Do it if the variable is defined
}

Все ответы неполные. Это правильный способ узнать, что существует свойство, «определенное как undefined»:

var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined'));
};

Пример:

var a = { b : 1, e : null };
a.c = a.d;

hasUndefinedProperty(a, 'b'); // false: b is defined as 1
hasUndefinedProperty(a, 'c'); // true: c is defined as undefined
hasUndefinedProperty(a, 'd'); // false: d is undefined
hasUndefinedProperty(a, 'e'); // false: e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c'); // false: c is undefined

Жаль, что это был правильный ответ, и он погребен в неправильных ответах> _

Итак, всем, кто проходит мимо, я дам вам undefined бесплатно !!

var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

Просматривая комментарии, для тех, кто хочет проверить и то, и другое, не определено ли оно или его значение равно null:

//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}

Если вы используете библиотеку jQuery, jQuery.isEmptyObject() подойдет для обоих случаев,

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;

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

Object.defineProperty(window, 'undefined', {});

Это запрещает кому-либо изменять значение window.undefined, тем самым уничтожая код, основанный на этой переменной. При использовании "use strict" все попытки изменить его значение завершатся ошибкой, в противном случае они будут игнорироваться.

Если вы используете Angular:

angular.isUndefined(obj)
angular.isUndefined(obj.prop)

Underscore.js:

_.isUndefined(obj) 
_.isUndefined(obj.prop) 

Читая это, я удивлен, что не заметил этого. Я нашел несколько алгоритмов, которые сработают для этого.

Никогда не определялся

Если значение объекта никогда не было определено, это предотвратит возврат true, если он определен как null или undefined. Это полезно, если вы хотите, чтобы значение true возвращалось для значений, установленных как undefined.

if (obj.prop === void 0) console.info("The value has never been defined");

Определено как неопределенное или никогда не определено

Если вы хотите, чтобы результат был true для значений, определенных с помощью значения undefined, или никогда не определенных, вы можете просто использовать === undefined

if (obj.prop === undefined) console.info("The value is defined as undefined, or never defined");

Определяется как ложное значение, неопределенное, нулевое или никогда не определенное.

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

if (obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.info("The value is falsy, null, or undefined");
}

Я использую if (this.variable), чтобы проверить, определено ли оно. Простой if (variable), рекомендовано в предыдущем ответе, мне не подходит.

Оказывается, он работает только тогда, когда переменная является полем некоторого объекта obj.someField, чтобы проверить, определена ли она в словаре. Но мы можем использовать this или window в качестве объекта словаря, поскольку любая переменная является полем в текущем окне, насколько я понимаю. Поэтому вот тест:

if (this.abc) 
    alert("defined"); 
else 
    alert("undefined");

abc = "abc";
if (this.abc) 
    alert("defined"); 
else 
    alert("undefined");

Сначала он обнаруживает, что переменная abc не определена, и она определяется после инициализации.

Использовать:

Чтобы проверить, не определено ли свойство:

if (typeof something === "undefined") {
    alert("undefined");
}

Чтобы проверить, не является ли свойство неопределенным:

if (typeof something !== "undefined") {
    alert("not undefined");
}

Из lodash.js.

var undefined;
function isUndefined(value) {
  return value === undefined;
}

Он создает переменную местный с именем undefined, которая инициализируется значением по умолчанию - реальным undefined, а затем сравнивает value с переменной undefined.

Обновление 09.09.2019

Я обнаружил, что Lodash обновил свою реализацию. См. моя проблема и код.

Чтобы быть пуленепробиваемым, просто используйте:

function isUndefined(value) {
  return value === void 0;
}

Существует красивый и элегантный способ присвоить определенное свойство новой переменной, если она определена, или присвоить ей значение по умолчанию в качестве запасного варианта, если оно не определено.

var a = obj.prop || defaultValue;

Подходит, если у вас есть функция, которая получает дополнительное свойство конфигурации:

var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.info(this.yourConfigValue);
}

Сейчас выполняется

yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

Я удивлен, что еще не видел этого предложения, но оно имеет даже большую конкретность, чем тестирование с typeof. Используйте Object.getOwnPropertyDescriptor(), если вам нужно знать, было ли свойство объекта инициализировано с помощью undefined или оно никогда не инициализировалось:

// to test someObject.someProperty
var descriptor = Object.getOwnPropertyDescriptor(someObject, 'someProperty');

if (typeof descriptor === 'undefined') {
  // was never initialized
} else if (typeof descriptor.value === 'undefined') {
  if (descriptor.get || descriptor.set) {
    // is an accessor property, defined via getter and setter
  } else {
    // is initialized with `undefined`
  }
} else {
  // is initialized with some other value
}

Это, вероятно, единственная явная форма определения того, имеет ли существующее имя свойства явное и предполагаемое значение undefined; который, тем не менее, относится к типу JavaScript.

"propertyName" in containerObject && ""+containerObject["propertyName"] == "undefined";
>> true \ false

Это выражение вернет true только в том случае, если имя свойства данного контекста существует (действительно) и только если его предполагаемое значение явно undefined.

Не будет ложных срабатываний, таких как пустые или пустые строки, нули, нули или пустые массивы и тому подобное. Это именно так. Проверяет, т. Е. Проверяет, существует ли имя свойства (в противном случае это было бы ложным срабатыванием), чем явно проверяет, является ли его значение undefined, например. неопределенного типа JavaScript в форме строкового представления (буквально «undefined»), следовательно, == вместо ===, потому что дальнейшее преобразование невозможно. И это выражение вернет истину только в том случае, если оба, то есть все условия, выполнены. Например. если имя-свойства не существует, оно вернет false. Это единственно правильный результат, поскольку несуществующие свойства не могут иметь значений, даже если они не определены.

Пример:

containerObject = { propertyName: void "anything" }
>> Object { propertyName: undefined }

// Now the testing

"propertyName" in containerObject && ""+containerObject["propertyName"] == "undefined";
>> true

/* Which makes sure that nonexistent property will not return a false positive
 * unless it is previously defined  */

"foo" in containerObject && ""+containerObject["foo"] == "undefined";
>> false

Просто что-либо не определено в JavaScript, это неопределенный, не имеет значения, является ли это свойством внутри Объект / Массив или просто простой переменной ...

В JavaScript есть typeof, что позволяет очень легко обнаружить неопределенную переменную.

Просто проверьте, есть ли typeof whatever === 'undefined', и он вернет логическое значение.

Так написана знаменитая функция isUndefined() в AngularJs v.1x:

function isUndefined(value) {return typeof value === 'undefined';} 

Итак, как вы видите, функция получает значение, если это значение определено, она вернет false, в противном случае для неопределенных значений вернет true.

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

var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;

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

isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true

Как видите, мы можем проверить что угодно, используя что-то вроде этого в нашем коде, как уже упоминалось, вы можете просто использовать typeof в своем коде, но если вы используете его снова и снова, создайте функцию, такую ​​как образец angular, которым я делюсь, и продолжайте повторно использовать как показано в следующем шаблоне кода DRY.

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

Если вы проверите свойство объекта, а объект не существует, выдаст ошибку и остановит работу всего приложения.

isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)

Настолько просто, что вы можете заключить его внутрь оператора if, как показано ниже:

if (typeof x !== 'undefined') {
  //do something
}

Что также равно isDefined в Angular 1.x ...

function isDefined(value) {return typeof value !== 'undefined';}

Также другие фреймворки javascript, такие как подчеркивание, имеют аналогичную проверку определения, но я рекомендую вам использовать typeof, если вы уже не используете какие-либо фреймворки.

Я также добавляю этот раздел из MDN, в котором есть полезная информация о typeof, undefined и void (0).

Strict equality and undefined
You can use undefined and the strict equality and inequality operators to determine whether a variable has a value. In the following code, the variable x is not defined, and the if statement evaluates to true.

var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}

Note: The strict equality operator rather than the standard equality operator must be used here, because x == undefined also checks whether x is null, while strict equality doesn't. null is not equivalent to undefined. See comparison operators for details.

Typeof operator and undefined
Alternatively, typeof can be used:

var x;
if (typeof x === 'undefined') {
   // these statements execute
}

One reason to use typeof is that it does not throw an error if the variable has not been declared.

// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

if (x === undefined) { // throws a ReferenceError

}

However, this kind of technique should be avoided. JavaScript is a statically scoped language, so knowing if a variable is declared can be read by seeing whether it is declared in an enclosing context. The only exception is the global scope, but the global scope is bound to the global object, so checking the existence of a variable in the global context can be done by checking the existence of a property on the global object (using the in operator, for instance).

Void operator and undefined

The void operator is a third alternative.

var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}

подробнее> здесь

Я предполагаю, что вы также захотите проверить, является ли он либоundefined или null. Если да, то предлагаю:

myVar == null

Это один из немногих случаев, когда двойное равенство очень полезен, поскольку он будет оценивать как true, когда myVar является undefined или null, но он будет оценивать как false, когда это другие ложные значения, такие как 0, false, '' и NaN.

Это фактический исходный код для метода Lodash isNil.

Я предлагаю здесь три способа для тех, кто ожидает странных ответов:

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}

function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}

function isUndefined3(val) {
    const defaultVal = {};
    return ((input = defaultVal) => input === defaultVal)(val);
}

function test(func){
    console.group(`test start :`+func.name);
    console.info(func(undefined));
    console.info(func(null));
    console.info(func(1));
    console.info(func("1"));
    console.info(func(0));
    console.info(func({}));
    console.info(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

isUndefined1:

Попробуйте получить свойство входного значения и проверьте сообщение об ошибке, если оно существует. Если входное значение не определено, сообщение об ошибке будет Uncaught TypeError: невозможно прочитать свойство 'b' неопределенного значения.

isUndefined2:

Преобразуйте входное значение в строку для сравнения с "undefined" и убедитесь, что это отрицательное значение.

isUndefined3:

В JavaScript необязательный параметр работает, если входное значение точно undefined.

Вы можете использовать функцию объекта JavaScript следующим образом:

var ojb  = {
    age: 12
}

if (ojb.hasOwnProperty('name')){
    console.info('property exists and is not undefined');
}

Вышеупомянутый метод возвращает true, если он получил это свойство или свойство не определено.

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

function resolveUnknownProps(obj, resolveKey) {
  const handler = {
    get(target, key) {
      if (
        target[key] !== null &&
        typeof target[key] === 'object'
      ) {
        return resolveUnknownProps(target[key], resolveKey);
      } else if (!target[key]) {
        return resolveUnknownProps({ [resolveKey]: true }, resolveKey);
      }

      return target[key];
    },
  };

  return new Proxy(obj, handler);
}

const user = {}

console.info(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

Таким образом, вы будете использовать это как:

const { isUndefined } = resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else;
if (!isUndefined) {
  // Do something
}

В библиотеке Лодаш есть несколько маленьких помощников:

isUndefined - чтобы проверить, является ли ценитьundefined.

_.isUndefined(undefined) // => true
_.isUndefined(null) // => false

имеет - чтобы проверить, содержит ли объект свойство

const object = { 'a': { 'b': 2 } }

_.has(object, 'a.b') // => true
_.has(object, 'a.c') // => false

Представленный в ECMAScript 6, теперь мы можем работать с undefined по-новому, используя прокси. Его можно использовать для установки значения по умолчанию для любых свойств, которые не существуют, чтобы нам не приходилось каждый раз проверять, существует ли оно на самом деле.

var handler = {
  get: function(target, name) {
    return name in target ? target[name] : 'N/A';
  }
};

var p = new Proxy({}, handler);
p.name = 'Kevin';
console.info('Name: ' +p.name, ', Age: '+p.age, ', Gender: '+p.gender)

Будет выводить приведенный ниже текст без получения неопределенного.

Name: Kevin , Age: N/A , Gender: N/A

Простой способ проверить, существует ли ключ, - использовать in:

if (key in obj) {
  // Do something
} else {
  // Create key
}

const obj = {
  0: 'abc',
  1: 'def'
}

const hasZero = 0 in obj

console.info(hasZero) // true

ECMAScript 10 представил новую функцию - необязательная цепочка, которую вы можете использовать для использования свойства объекта, только когда объект определен следующим образом:

const userPhone = user?.contactDetails?.phone;

Он будет ссылаться на свойство phone только тогда, когда определены user и contactDetails.

Ref. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

Я нашел эту статью, 7 советов по работе с undefined в JavaScript, которая показывает действительно интересные вещи о undefined. подобно:

Существование undefined является следствием разрешающей природы JavaScript, которая позволяет использовать:

• неинициализированные переменные
• несуществующие свойства или методы объекта
• индексы вне границ для доступа к элементам массива
• результат вызова функции, которая ничего не возвращает

В JavaScript есть выражения правдивый и фальшивка. Если вы хотите проверить, является ли свойство неопределенным или нет, есть прямой способ использовать данное условие если,

1. Использование концепции правда / ложь.

if (!ob.someProp){
    console.info('someProp is falsy')
}

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

2. Использование проверки === undefined в условии if

if (ob.someProp === undefined){
    console.info('someProp is undefined')
}

3. Использование typeof

typeof действует как комбинированная проверка на неопределенное значение и на наличие переменной.

if (typeof ob.someProp === 'undefined'){
    console.info('someProp is undefined')
}

4. Использование метода hasOwnProperty

В объект JavaScript встроена функция hasOwnProperty в прототипе объекта.

if (!ob.hasOwnProperty('someProp')){
    console.info('someProp is undefined')
}

Не вдаваясь в подробности, но путь 1^st мне кажется укороченным и привлекательным. Вот подробности о значениях правда / ложь в JavaScript, а undefined - это ложное значение, указанное там. Таким образом, состояние if работает нормально, без каких-либо сбоев. Помимо undefined, значения NaN, false (очевидно), '' (пустая строка) и число 0 также являются ложными.

Warning: Make sure the property value does not contain any falsy value, otherwise the if condition will return false. For such a case, you can use the hasOwnProperty method

Есть очень простой и легкий способ.

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

x = {prop:{name:"sajad"}}

console.info(x.prop?.name) // Output is: "sajad"
console.info(x.prop?.lastName) // Output is: undefined

или же

if (x.prop?.lastName) // The result of this 'if' statement is false and is not throwing an error

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

По состоянию на середину 2020 года это реализовано не повсеместно. Проверьте документацию на https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

Рассмотрение

Многие из приведенных ответов дают неправильный результат, потому что они не различают случай, когда свойство объекта не существует, и случай, когда свойство имеет значение undefined. Вот доказательство для наиболее популярных решений:

let obj = {
  a: 666,
  u: undefined // The 'u' property has value 'undefined'
               // The 'x' property does not exist
}

console.info('>>> good results:');
console.info('A', "u" in obj, "x" in obj);
console.info('B', obj.hasOwnProperty("u"),      obj.hasOwnProperty("x"));

console.info('\n>>> bad results:');
console.info('C', obj.u === undefined,          obj.x === undefined);
console.info('D', obj.u == undefined,           obj.x == undefined);
console.info('E', obj["u"] === undefined,       obj["x"] === undefined);
console.info('F', obj["u"] == undefined,        obj["x"] == undefined);
console.info('G', !obj.u,                      !obj.x);
console.info('H', typeof obj.u === 'undefined', typeof obj.x === 'undefined');

В недавнем выпуске JavaScript появился новый оператор цепочки, который, скорее всего, является лучшим способом проверить, существует ли свойство, иначе он даст вам undefined.

см. пример ниже

  const adventurer = {
  name: 'Alice',
  cat: {
    name: 'Dinah'
  }
};

const dogName = adventurer.dog?.name;
console.info(dogName);
// expected output: undefined

console.info(adventurer.someNonExistentMethod?.());
// expected output: undefined

Мы можем заменить этот старый синтаксис

if (response && response.data && response.data.someData && response.data.someData.someMoreData) {}

с этим более аккуратным синтаксисом

if ( response?.data?.someData?.someMoreData) {}

Этот синтаксис не поддерживается в IE, Opera, safari и samsund android.

для более подробной информации вы можете проверить этот URL

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

Версия для использования динамических переменных Вы знали?

var boo ='lala';

function check(){
  if (this['foo']){
        console.info('foo is here');}
  else{
        console.info('have no foo');
      }

  if (this['boo']){
        console.info('boo is here');}
  else{
        console.info('have no boo');
      }
}

check();