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

https://stackoverflow.com/questions/27509

09-06-2019
|

Вопрос

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

Решение

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

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

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

if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}

Другие советы

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

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

var foo = …;

if (foo === undefined) {
    ⋮
}

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

это чтение "неинициализированной” переменной (var foo) или параметр (function bar(foo) { … }, называемый как bar()) потерпит неудачу.Это просто неверно – переменные без явной инициализации и параметры, которым не были заданы значения, всегда становятся undefined, и всегда находятся в поле зрения.
это undefined может быть перезаписан.За этим кроется гораздо больше. undefined это не ключевое слово в JavaScript.Вместо этого это свойство глобального объекта с неопределенным значением.Однако, начиная с ES5, это свойство было доступно только для чтения и не настраиваемый.Ни один современный браузер не позволит undefined собственность должна быть изменена, и по состоянию на 2017 год это происходило в течение длительного времени.Отсутствие строгого режима не влияет undefinedлибо поведение – оно просто делает заявления типа undefined = 5 ничего не делай вместо того, чтобы бросать.Однако, поскольку это не ключевое слово, вы можете объявлять переменные с именем undefined, и эти переменные можно было бы изменить, создав этот некогда распространенный шаблон:
```
(function (undefined) {
    // …
})()
```
Еще опаснее, чем использование глобального undefined.Если вы должны быть совместимы с ES3, замените undefined с void 0 – не прибегайте к typeof. (void всегда был унарным оператором, который принимает неопределенное значение для любого операнда.)

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

Это:

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

является всегда точно эквивалентный к этому 3:

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

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

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

_{1 необычный выбор имени переменной в качестве примера?это настоящий мертвый код из расширения NoScript для Firefox.}
_{2 однако не думайте, что незнание того, что находится в области видимости, в целом нормально.дополнительная уязвимость, вызванная злоупотреблением динамической областью видимости: Проект Ноль 1225}
_{3 еще раз предполагаем, что среда ES5 + и что undefined относится к undefined свойство глобального объекта.заменитель void 0 в противном случае.}

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

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

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

Существует также аналогичное значение, null, значение которого равно "это значение определено, но у него нет значения".Разница в значении между undefined и 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

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

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

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 только для чтения.Так что в современных браузерах этого не может быть переопределено на true как любят пугать нас многие авторы, но это все еще актуально для старых браузеров.

Финальный бой: `obj.prop === undefined` против `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.

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

Объект обладает свойством, а его значение не является undefined.
Объект обладает свойством, и его значение равно undefined.
Объект не обладает этим свойством.

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

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

Но , к несчастью 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 ( typeof( something ) == "undefined")

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

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

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

Перекрестный постинг моего ответ из связанного вопроса Как проверить наличие "undefined" в 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.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

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

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

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

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

Например:

var myvar = 'test';

Глобальная переменная мивар это то же самое , что окно.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');
}

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

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

(y)

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

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

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

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

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

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

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

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

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

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

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

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

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

Никогда Не определяемый

Если значение объекта никогда не было определено, это предотвратит возврат 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");

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

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

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

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

 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 Ссылка

Просто все, что не определено в 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 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, такие как underscore, имеют аналогичную проверку определения, но я рекомендую вам использовать typeof если вы уже не используете какие-либо фреймворки.

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

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

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

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

Оператор Typeof и неопределенный
В качестве альтернативы можно использовать 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 и undefined

Оператор 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`)
}

Еще> здесь

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

if (foo !== void 0)

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

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

null == undefined

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

if (something === undefined)

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

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

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

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

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

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

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

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

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

var a = obj.prop || defaultValue;

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

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

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

Итак, для любого, кто пройдет мимо, я дам вам неопределенные значения бесплатно!!

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;

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

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

Underscore.js:

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

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

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

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

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

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

Также те же самые вещи могут быть написаны короче:

if (!variable){
    //do it if variable is Undefined
}

или

if (variable){
    //do it if variable is Defined
}

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

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

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

От lodash.js.

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

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

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

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.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

Не определено 1:

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

Не определено 2:

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

Не определено 3:

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

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow