Як перевірити, чи об’єкт має певну властивість у 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, але (a) коротший на тип, і (b) використовує "безпечне посилання на 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циклі. Крім того, якщо властивість перелічуваної тіні відтіняє нечислиме властивість прототипу, воно не відображатиметься в Internet Explorer 8 і раніше.

Якщо вам потрібен перелік усіх властивостей екземпляра, чисельний чи ні, ви можете використовувати

Object.getOwnPropertyNames(x);

Це поверне масив імен усіх властивостей, які існують на об'єкті.

Нарешті, ви можете використовувати оператор typeof, щоб безпосередньо перевірити тип даних властивості об'єкта:

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

Якщо властивості не існує на об'єкті, він поверне рядок не визначеним. В іншому випадку він поверне відповідний тип властивості. Однак зауважте, що це не завжди є правильним способом перевірити, чи має об’єкт властивість чи ні, тому що у вас може бути властивість, встановлене як невизначене; у цьому випадку використання typeof x.keyвсе одно поверне справжнє значення (навіть якщо ключ все ще є в об’єкті).

Оновлення: Ви можете перевірити, чи існує властивість, порівнявши з невизначеним властивістю 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 "може використовуватися для визначення того, чи має об'єкт вказану властивість як безпосередню властивість цього об'єкта; на відміну від оператора в цьому методі не перевіряється ланцюг прототипу об'єкта."

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

Якщо ви хочете визначити, чи існує властивість у ланцюзі прототипу, який ви головне хочете використовувати, наприклад:

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

Я сподіваюся, що це допомагає.

Загрожує масовим захопленням, ось ще один варіант для конкретного випадку. :)

Якщо ви хочете протестувати учасника на об'єкті і хочете знати, чи встановлено він щось інше, ніж:

• ''
• помилковий
• нуль
• невизначений
• 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", що існує на об'єкті, але його не рекомендується викликати безпосередньо цим методом, оскільки іноді об'єкт може бути нульовим або деяка властивість існує на об'єкті, наприклад: { 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. У першому та третьому підходах ми не просто шукаємо об’єкт, а й його прототипний ланцюг. Якщо об’єкт не має властивості, але властивість присутня в ланцюзі прототипу, він збирається надати істину.

 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-ою і третьою полягає в тому, що якщо є властивість, значення якої не визначено, 3-й підхід дасть помилковий, а перший - істинний.

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;

Проста і зрозуміла для більшості випадків ...