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

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

Рассматривать:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

Это лучший способ сделать это?

Я действительно смущен ответами, которые были даны - большинство из них просто неправильно. Конечно, у вас могут быть свойства объекта с неопределенными, нулевыми или ложными значениями. Таким образом, простое сокращение проверки собственности до typeof this[property]или, что еще хуже, x.keyдаст вам полностью вводящие в заблуждение результаты.

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

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

Поскольку использование 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или ( даже лучше ) lodash:

_.has(x, 'key');

Какие вызовы Object.prototype.hasOwnProperty, но (а) короче, чтобы набрать, и (б) использует «безопасную ссылку на hasOwnProperty» (т.е. он работает, даже если hasOwnPropertyперезаписан).

В частности, lodash определяет _.hasкак:

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

Что о?

var x = {'key': 1};

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

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

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

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

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

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

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

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

if (x.key !== undefined)

Армин Роначер, кажется, уже победил меня , но:

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!');
}

Более безопасный, но медленнее решение, как было указано на Konrad Rudolph и Armin Ronacher будет:

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

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

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

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

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

Вы должны рассмотреть, является ли это свойство объекта перечислимым или нет, потому что не перечисляемые свойства не будут отображаться в for-inцикле. Кроме того, если свойство enumerable скрывает неперечислимое свойство прототипа, оно не будет отображаться в Internet Explorer 8 и более ранних версиях.

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

Object.getOwnPropertyNames(x);

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

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

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

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

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

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

Это должно работать, если ключ не был специально установлен для undefinedобъекта x

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

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

Следовательно:

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

Проблема в том, что происходит, когда объект в цепочке прототипов имеет атрибут со значением undefined? hasOwnPropertyбудет ложным за это, и так будет !== undefined. Пока for..inчто все равно перечислю это в перечислении.

Суть в том, что нет кросс-браузерного способа (поскольку Internet Explorer не предоставляет __prototype__) для определения того, что определенный идентификатор не был прикреплен к объекту или чему-либо в его цепочке прототипов.

Если вы ищете недвижимость, тогда «НЕТ». Ты хочешь:

if ('prop' in obj) { }

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

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

Ответ Джона Резига был очень исчерпывающим, но я подумал, что он не ясен. Особенно, когда использовать «prop» в obj ».

Для тестирования простых объектов используйте: if (obj[x] !== undefined)

Если вы не знаете, какой тип объекта он использует: if (obj.hasOwnProperty(x))

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

подробности

Оценка производительности 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)); }

Оценка говорит нам, что, если мы не хотим специально проверять цепочку прототипов объекта, а также сам объект, мы не должны использовать общую форму: if (X in 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, используйте 'if (obj.hasOwnProperty (x)) ...'.

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

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

Радоваться, веселиться.

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

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

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

}

Потому что

if (x.key)

не удается, если x.keyразрешается false(например, x.key = "").

Вы также можете использовать объект ES6Reflect :

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

Документацию по MDN для Reflect.hasможно найти здесь .

Статический Reflect.has()метод работает как оператор in как функция.

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

if (x.hasOwnProperty('key'))

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

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

if (x.key !== undefined)

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

Лучший способ это сделать Object.prototype.hasOwnProperty.call(object, key)или:

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

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

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

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

Хотя мы находимся в мире с отличной поддержкой браузера. Поскольку этот вопрос настолько старый, я подумал, что добавлю это: Это безопасно для использования с JS v1.8.5

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

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

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

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

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

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

Если вы хотите проверить член на объекте и хотите узнать, было ли для него установлено что-то отличное от:

• «»
• ложный
• значение NULL
• не определено
• 0 ...

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

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

ECMA Script 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

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

Так что лучшим способом будет:

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

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

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

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

1. При первом и третьем подходе мы ищем не только объект, но и его цепочку прототипов. Если объект не имеет свойства, но свойство присутствует в его цепочке прототипов, он собирается дать значение true.

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

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

2. 2-й подход будет проверять только свои свойства. Ex -

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

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

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

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

Вам нужно использовать метод object.hasOwnProperty(property). Возвращает true, если объект имеет свойство, и false, если объект не имеет.

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

x = {'key': 1};
y = 'key';
x[y];

Зачем слишком усложнять вещи, когда вы можете сделать:

var isProperty =  (objectname.keyname || "") ? true : false;

Просто и понятно в большинстве случаев ...