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

Я'м очень смущают ответы, которые были даны - большинство из них просто откровенно неверны. Конечно, вы можете иметь свойства объекта, которые имеют значение undefined, null или ложные ценности. Так что просто сократить проверки в <код>typeof на это[свойство]</код> или, еще хуже, но <код>У Х.ключ</код>, который подарит вам совершенно ошибочным результатам.

Это зависит от того, что вы'вновь ищу. Если вы хотите знать, если объект физически содержит свойство (и это не идет от куда-то вверх по цепочке прототипов), то в <код>В объект.метод hasOwnProperty</код> Есть Путь. Все современные браузеры поддерживают его. (Он отсутствует в старых версиях Safari - 2.0.1 и старше, но те версии браузера используются редко больше.)

Если то, что вы'вновь ищу, если объект имеет свойство, что является итерируемым (когда вы выполните итерации по свойствам объекта, он появится), то делаем: <код>опора на объект в< код>, который даст вам желаемый эффект.

С использованием <код>метод hasOwnProperty в< код> Есть, наверное, то, что вы хотите, и учитывая, что вам может понадобиться резервный метод, представляю вам следующее решение:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

Выше рабочей, кросс-браузер решение в <код>метод hasOwnProperty в< код>, который, с одной оговоркой: он не способен различать случаи, когда идентичные свойства по прототипу и по примеру - это просто предполагает, что это'ушли от прототипа. Вы могли перекладывать ее, чтобы быть более мягким или строгим, исходя из вашей ситуации, но по крайней мере это должно быть более полезным.

С Underscore.js (илиеще лучше) лодашь:

_.has(x, 'key');

Который называет объект.прототип.метод hasOwnProperty, но (а) это короче типа, и (Б) использует "а безопасная ссылка наметод hasOwnProperty в" (т. е. это работает, даже еслиметод hasOwnProperty` перезаписывается).

В частности, лодашь определяет `_.и как:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Примечание: следующие в настоящее время во многом устарели благодаря строгому режиму, и метод hasOwnProperty. Правильное решение-использовать строгий режим и проверка на наличие свойства с помощью параметра obj.метод hasOwnProperty. Этот ответ до обе эти вещи, по крайней мере, широко реализована (да, это тот старый). Принять следующие как историческая справка.

Имейте в виду, что не определено - это (к сожалению) ** не является зарезервированным словом в JavaScript, если вы не используете строгий режим. Поэтому кто-то (кто-то другой, очевидно) может есть грандиозная идея переопределив его, нарушая ваш код.

Поэтому более надежный способ заключается в следующем:

if (typeof(x.attribute) !== 'undefined')

С другой стороны, этот метод гораздо более многословен и также медленнее. :-/

Обычная альтернатива сводится к тому, что не определено - это вообще не определено, например, поместив этот код в функцию, которая принимает дополнительный параметр, называется "неопределенным", что не передается значение. Чтобы убедиться, что это не передается значение, вы могли бы просто немедленно позвонить сами, например:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

О чем?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

if (x.key !== undefined)

Armin Ronacher, похоже, уже опередил меня, но..:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

Более безопасным, но медленным решением, на которое указывали Конрад Рудольф и Армин Ронахер, было бы:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

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

x = {'key': 1};
alert("key" in x);

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

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

Вы должны учитывать, если этот объект недвижимости является перечислимым или нет, потому что не перечисли свойства не будут отображаться в -в петлю. Кроме того, если перечислимое свойство затенение не перечисляемое свойство прототипа, он не будет отображаться в интернет&усилителя;усилитель; nbsp;Обозреватель&ампер;усилитель; nbsp;8 и ранее.

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

Object.getOwnPropertyNames(x);

Это возвращает массив имен всех свойств, которые существуют на объекте.

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

if (typeof x.key == "undefined") {
    alert("undefined");
}

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

Обновление: вы можете проверить, если свойство существует, по сравнению с неопределенным свойство JavaScript

if (x.key === undefined) {
    alert("undefined");
}

Это должно работать, если ключ был специально настроен на "неопределенным" на объект X

Позвольте'ы прорубить какая-то путаница. Во-первых, позвольте'ов упростить, предположив, метод hasOwnProperty уже существует; это справедливо для подавляющего большинства современных браузеров в использовании.

метод hasOwnProperty возвращает true, если имя атрибута, который передается к нему была добавлена к объекту. Это совершенно не зависит от фактического значения, которое может быть точно "неопределенным".

Отсюда:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

Правда:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

Проблема в том, что происходит, когда объект в цепочке прототипов имеет атрибут со значением неопределено? метод hasOwnProperty будет false, и так будет!== неопределенные. Однако на..В все равно он в списке перечисления.

В сухом остатке нет кросс-браузер способ (с интернета&ампер;усилитель; nbsp;обозреватель не'т подвергайте __прототип__) для определения того, что идентификатор не был прикреплен к объекту или что-то в его цепочке прототипов.

Если вы ищете недвижимость, то "нет". Вы хотите:

if ('prop' in obj) { }

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

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

Джон Резиг'ы ответ был очень исчерпывающим, но я думал, что это была'т ясно. Особенно, когда в использовании и" 'пропеллер' в OBJ и".

Для тестирования простых объектов использовать: если (объект[х] !== неопределено)

Если вы Don'т знаю, что тип объекта это использовать: если (объект.метод hasOwnProperty(х))

Все остальные варианты работают медленнее..

Подробности

Оценка эффективности 100 000 000 циклов под Nodejs на 5 вариантов, предложенных другими здесь:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

Оценка говорит нам, что если мы конкретно хотите проверить объект's в цепи прототипов, а также сам объект, мы не должны пользоваться общей форме: если (Х в obj)...` это от 2 до 6 раз медленнее, в зависимости от использования

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

Нижняя линия, если obj не обязательно простой объект и вы хотите, чтобы избежать проверки объекта'цепочке прототипов и гарантировать то, что X принадлежит объект obj напрямую, использовать 'если (объект.метод hasOwnProperty(х))...'.

В противном случае, при использовании простой объект и не беспокоясь о том, что объект's в цепи прототипов, используя `если (typeof на(параметр obj[х]) !== 'не определено')... является самым безопасным и быстрым способом.

Если вы используете простой объект, как хэш-таблицы, и никогда не странный, я хотел бы использовать `если (параметр obj[х])... как я нахожу его гораздо более читаемым.

Получайте удовольствие.

Да, это так :) Я думаю, вы также можете сделать Object.prototype.hasOwnProperty.call(x, 'key'), что также должно сработать, если у x есть свойство hasOwnProperty :)

Но это проверяет собственные свойства. Если вы хотите проверить, есть ли у него свойство, которое также может быть вложенным, вы можете использовать typeof x.foo != 'undefined'.

Вы также можете использовать объект ЕС6 отражать:

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

Документацию на MDN для размышлений.и` может быть найден здесь.

статические отражают.есть метод работает()` как [в] оператор3 в качестве функции.

if (typeof x.key != "undefined") {

}

Потому что

if (x.key)

не выполняется, если Х.ключ решает ложные (например, х.ключ = " и"в).

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

if (x.hasOwnProperty('key'))

Вот некоторые другие варианты включения наследуемых свойств:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Не делайте этого объекта.метод hasOwnProperty(ключ)), его очень плохо, потому что эти методы могут быть омрачены свойства объекта в вопрос - считать { метод hasOwnProperty: ложные } - или объект может быть нулевой объект(объект.создать(нуль))`.

Лучший способ сделать объект.прототип.метод hasOwnProperty.вызов(объект, ключ) или:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

метод hasOwnProperty "могут быть использованы для определения того, является ли объект указанное свойство как прямые свойства объекта; в отличие от оператора, этот метод не проверяет работу объекта'ы прототипа цепь&.и"

Так что, скорее всего, за то, что кажется на ваш вопрос, вы Дон'т хотите использовать метод hasOwnProperty, который определяет, является ли свойство существует как прилагается непосредственно к самому объекту,.

Если вы хотите определить, если свойство существует в цепочке прототипов главного вы хотите использовать в, как:

if( prop in object ){ // do something }

Я надеюсь, что это помогает.

Еще один относительно простой способ-использовать объект .ключи. Это возвращает массив, который означает, что вы получаете все функции массива.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Хотя мы живем в мире с большой поддержкой браузера. Потому что этот вопрос настолько старый, я думал, что я'd-добавить это: Это безопасно для использования, как в Яш В1.8.5

С риском массивной downvoting, вот еще один вариант для конкретного случая. :)

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

• ''
• ложные
• нуль
• не определено
• 0 ...

затем вы можете использовать:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

Можно использовать следующие подходы:

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

Разница между следующие подходы таковы:

1. В 1-й и 3-й подход мы не просто поиск в объект, но его прототипная сеть тоже. Если объект не обладает свойством, но недвижимость находится на его цепочке прототипов, которые она собирается дать правда.

в

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

в

2. 2-й подход будет проверить только за собственные свойства. Экс -

в

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

в

3. Разница между 1-ой и третий-если есть свойство, которое имеет значение undefined 3-й подход будет давать ложные пока первая будет давать истинный.

в

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

в

Есть способ "и метод hasOwnProperty", которая существует на объект, но его не рекомендуется вызывать этот метод непосредственно, потому что может быть иногда объект имеет значение null или какое-то свойство существовать на объект: { метод hasOwnProperty: ложные }

Так лучше будет:

в

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

в

Сценарий ЕСМА 6 решение с отражением. Создать оболочку, как:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg