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

if (foo !== void 0)

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

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

 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

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

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

Все ответы неполные. Это правильный способ узнать, что существует свойство, «определенное как 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

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

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

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

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

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

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

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

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

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

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

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

isUndefined1:

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

isUndefined2:

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

isUndefined3:

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

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

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

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

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

or

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

Я использую 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
}

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

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

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

Из 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;
}

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

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.log(resolveUnknownProps(user, 'isUndefined').personalInfo.name.something.else); // { isUndefined: true }

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

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

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

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

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

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

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

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

myVar == null

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

Это фактический исходный код для _ 13_.

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

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

or

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

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

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

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

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

console.log(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

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

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

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

const hasZero = 0 in obj

console.log(hasZero) // true

Представленный в 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.log('Name: ' +p.name, ', Age: '+p.age, ', Gender: '+p.gender)

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

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

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

isUndefined - чтобы проверить, равно ли value undefined.

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

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

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

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

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

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

var boo ='lala';

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

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

check();

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

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

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

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

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

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

var ojb ={
    age: 12
}

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

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

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

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

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

Не будет ложных срабатываний, таких как пустые или пустые строки, нули, нули или пустые массивы и тому подобное. Это именно так. Проверяет, т. Е. Проверяет, существует ли имя свойства (в противном случае это было бы ложным срабатыванием), чем явно проверяет, равно ли его значение undefined, например. неопределенного типа JavaScript в форме строкового представления (буквально не определено), поэтому == вместо ===, потому что дальнейшее преобразование невозможно. И это выражение вернет истину только в том случае, если оба, то есть все условия, выполнены. Например. если имя-свойства не существует, оно вернет 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

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

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

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

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

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

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

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

2. Используя === undefined, проверьте состояние if

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

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

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

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

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

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

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

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

Предупреждение: Убедитесь, что значение свойства не содержит ложных значений, иначе условие if вернет false. В таком случае вы можете использовать hasOwnProperty метод

обрабатывать undefined

function isUndefined(variable,defaultvalue=''){

    if (variable == undefined )
    { 
        return defaultvalue;
    }
    return variable

}

var obj={
und:undefined,
notundefined:'hi i am not undefined'
}


function isUndefined(variable,defaultvalue=''){

    if (variable == undefined )
    { 
        return defaultvalue;
    }
    return variable

}

console.log(isUndefined(obj.und,'i am print'))
console.log(isUndefined(obj.notundefined,'i am print'))

Object.hasOwnProperty(o, 'propertyname');

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

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

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

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