javascript - свойство - свойства объекта js




Обнаружение свойства неопределенного объекта (20)

Каков наилучший способ проверить, не определено ли свойство объекта в JavaScript?


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

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

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

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

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

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


В JavaScript есть null и не определено . Они имеют разные значения.

  • undefined означает, что значение переменной не определено; неизвестно, что это за значение.
  • null означает, что значение переменной определено и установлено в null (не имеет значения).

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

Существует также аналогичное значение, null, значение которого «это значение определено, но оно не имеет значения». Разница в значении между неопределенным и нулевым является в основном академической и обычно не очень интересной. В практических программах часто необходимо проверить, имеет ли что-то «значение». В этих случаях может использоваться выражение something == undefined, потому что, хотя они не являются точно таким же значением, null == undefined будет выдавать true.

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

if (something == undefined)

Надеюсь это поможет!

Изменить. В ответ на ваше редактирование свойства объекта должны работать одинаково.

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

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

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

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

он будет терпеть неудачу, если переменная myvar не существует, потому что myvar не определен, поэтому скрипт сломан и тест не имеет никакого эффекта.

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

Например:

var myvar = 'test';

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

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

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

Вопрос о том, действительно ли переменная существует, не имеет значения, ее значение неверно. В противном случае глупо инициализировать переменные с неопределенным, и лучше использовать значение 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');
}

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

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

(У)


Использование:

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

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

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

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

Несмотря на то, что я настоятельно рекомендую многие другие ответы здесь, 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 не является ключевым словом в JavaScript. Вместо этого это свойство для глобального объекта с неопределенным значением. Однако, поскольку ES5, это свойство было доступно только для чтения и не настраивалось . Ни один современный браузер undefined сможет изменить undefined свойство, и с 2017 года это происходит в течение длительного времени. Отсутствие строгого режима также не влияет на поведение undefined - он просто делает такие выражения, как undefined = 5 , ничего не делает, а не бросает. Однако, поскольку это не ключевое слово, вы можете объявлять переменные с undefined именем, и эти переменные можно изменить, сделав этот один раз-общий шаблон:

    (function (undefined) {
        // …
    })()
    

    более опасным, чем использование глобального undefined . Если вы должны быть совместимы с ES3, замените undefined на void 0 - не прибегайте к typeof . ( void всегда был унарным оператором, который вычисляет значение Undefined для любого операнда.)

С тем, как переменные работают в стороне, пришло время обратиться к актуальному вопросу: свойства объекта. Нет никакой причины когда-либо использовать 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 для большего!

¹ необычный выбор имени переменной? это настоящий мертвый код из расширения NoScript для Firefox.
² не предполагают, что не зная, что в сфере охвата, в общем, все в порядке. бонусная уязвимость, вызванная злоупотреблением динамической областью: Project Zero 1225
³ еще раз, предполагая среду ES5 +, и что undefined ссылается на undefined свойство глобального объекта. замените void 0 противном случае.


Перекрестный перенос моего answer из связанного вопроса Как проверить «неопределенный» в JavaScript?

Специфично для этого вопроса, см. Тестовые примеры с someObject.<whatever> .

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

(Обратите внимание, что использование var for 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.log(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

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

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

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

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

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

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

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

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

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

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

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

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

var o = { a: undefined }

Не определено? Да! Его значение не определено. Не определено? Конечно! Нет никакого свойства '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

Заметки:

  • Вы не можете одновременно проверять объект и его свойство. Например, этот xa === undefined или этот typeof xa == '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 предоставит вам сообщение об ошибке, если у вас есть неправильная орфографическая ошибка

Недостатки obj.prop === undefined :

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

Плюсы типа typeof obj.prop == 'undefined' :

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

Недостатки typeof obj.prop == 'undefined' :

  • 'undefned'ошибкой ) здесь - только строковая константа, поэтому механизм JavaScript не может помочь вам, если у вас есть с ошибкой, как будто я только что сделал.

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

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


Я не знаю, откуда === начало использования === с 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

Я считаю, что есть ряд неправильных ответов на эту тему. Вопреки распространенному мнению, «неопределенный» не является ключевым словом в 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 не объявлен.


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

 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 link


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

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

Underscore.js:

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

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

null == undefined

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

if (something === undefined)

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


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

var a = obj.prop || defaultValue;

Это удобно, если у вас есть функция, которая получает дополнительное свойство config:

var yourFunction = function(config){

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

}

Теперь выполнение

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

yourFunction();
//=> 1

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

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

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

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

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

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

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

JavaScript имеет typeofочень легко обнаружить неопределенную переменную.

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

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

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

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

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

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

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

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

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

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

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

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

Строгое равенство и неопределенность
Вы можете использовать неопределенные и строгие операторы равенства и неравенства, чтобы определить, имеет ли переменная значение. В следующем коде переменная x не определена, а оператор if равен true.

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

Примечание. Здесь должен использоваться оператор строгого равенства, а не стандартный оператор равенства, поскольку x == undefined также проверяет, является ли x равным null, а строгое равенство - нет. null не эквивалентен неопределенному. Для получения более подробной информации обратитесь к операторам сравнения.

Оператор Typeof и undefined
Альтернативно, typeof может использоваться:

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

Одна из причин использования typeof заключается в том, что он не выдает ошибку, если переменная не была объявлена.

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

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

}

Однако такого типа техники следует избегать. JavaScript - это язык с фиксированным охватом, поэтому, зная, объявлена ​​ли переменная, можно прочитать, увидев, объявлено ли оно в окружающем контексте. Единственным исключением является глобальная область видимости, но глобальная область привязана к глобальному объекту, поэтому проверка существования переменной в глобальном контексте может быть выполнена путем проверки существования свойства на глобальном объекте (с использованием оператора in, например).

Оператор Void и неопределенный

Оператор void является третьей альтернативой.

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`)
}

подробнее> here


Я использую 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не определена и определена после инициализации.


Я удивлен, что еще не видел этого предложения, но он становится еще более специфичным, чем тестирование 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
}

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

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

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

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

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




undefined