Bir nesnenin JavaScript'te belirli bir özelliği olup olmadığını nasıl kontrol edebilirim?

Bir nesnenin JavaScript'te belirli bir özelliği olup olmadığını nasıl kontrol edebilirim?

Düşünmek:

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

Bunu yapmanın en iyi yolu bu mu?

Verilen cevaplarla gerçekten kafam karıştı - çoğu sadece yanlış. Elbette tanımlanmamış, boş veya yanlış değerlere sahip nesne özelliklerine sahip olabilirsiniz. Bu nedenle, özellik kontrolünü basitleştirmek typeof this[property]veya daha da kötüsü, x.keytamamen yanıltıcı sonuçlar verecektir.

Aradığın şeye bağlı. Bir nesnenin fiziksel olarak bir özellik içerip içermediğini bilmek istiyorsanız (ve prototip zincirinde bir yerden gelmiyorsa) o zaman object.hasOwnPropertygitmek için yoldur. Tüm modern tarayıcılar bunu destekler. (Safari'nin eski sürümlerinde - 2.0.1 ve daha eski - eksikti, ancak tarayıcının bu sürümleri artık nadiren kullanılıyor.)

Eğer aradığınız şey, bir nesnenin üzerinde yinelenebilir bir özelliğe sahipse (nesnenin özellikleri üzerinde yinelediğinizde görünecektir) o zaman yapmak: prop in objectsize istediğiniz efekti verecektir.

Kullanmak hasOwnPropertymuhtemelen istediğiniz gibi olduğundan ve bir geri dönüş yöntemi isteyebileceğinizden dolayı, size aşağıdaki çözümü sunuyoruz:

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

Yukarıdaki, hasOwnPropertytek bir uyarı ile çalışan, çapraz tarayıcılı bir çözümdür : Prototipte ve örnekte aynı özelliğin olduğu durumlar arasında ayrım yapamaz - sadece prototipten geldiğini varsayar. Durumunuza bağlı olarak daha yumuşak veya katı olacak şekilde değiştirebilirsiniz, ancak en azından bu daha yararlı olacaktır.

İle Underscore.jsya da ( daha da iyi ) lodash:

_.has(x, 'key');

Hangi çağrılar Object.prototype.hasOwnProperty, ancak (a) yazmak daha kısadır ve (b) "güvenli bir referans" kullanır hasOwnProperty(yani hasOwnPropertyüzerine yazılsa bile çalışır ).

Özellikle, lodash şöyle tanımlar _.has:

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

Ne dersin?

var x = {'key': 1};

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

Not : Aşağıdaki, sıkı mod sayesinde günümüzde büyük ölçüde geçersizdir ve hasOwnProperty. Doğru çözüm, katı modu kullanmak ve kullanarak bir özelliğin varlığını kontrol etmektir obj.hasOwnProperty. Bu cevap eskidir , hem bunlar, yaygın uygulanan en azından olarak (evet, o eski). Aşağıdakileri tarihsel bir not olarak alın.

Akılda Ayı undefined(maalesef) 'dir değil katı mod kullanmıyorsanız JavaScript ayrılmış bir sözcük. Bu nedenle, birisinin (bir başkası, açıkçası) onu yeniden tanımlama, kodunuzu kırma fikri olabilir.

Bu nedenle daha sağlam bir yöntem şöyledir:

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

Kapak tarafında, bu yöntem çok daha ayrıntılı ve daha yavaştır. : - /

Ortak bir alternatif sağlamaktır undefinedolup , aslında adı verilen ek bir parametre kabul eden bir fonksiyonu olarak kodu koyarak, tanımsız örneğin undefinedbir değer geçmedi. Bir değerin geçmediğinden emin olmak için, hemen kendiniz diyebilirsiniz, örneğin:

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

if (x.key !== undefined)

Armin Ronacher beni zaten yenmiş gibi görünüyor , ama:

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 ve Armin Ronacher'in işaret ettiği gibi daha güvenli, ancak daha yavaş bir çözüm :

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

inÖzelliğin bir nesne üzerinde olup olmadığını kontrol etmek için operatörü kullanabilirsiniz :

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

Ayrıca for - in, bir döngü kullanarak nesnenin tüm özellikleri arasında döngü yapabilir ve ardından belirli özelliği kontrol edebilirsiniz:

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

Numaralandırılamayan özellikler bir for-indöngüde görünmeyeceğinden, bu nesne özelliğinin numaralandırılıp sayılmayacağını düşünmelisiniz . Ayrıca, enumerable özelliği prototipin numaralandırılamayan bir özelliğini gölgeliyorsa, Internet Explorer 8 ve önceki sürümlerinde görünmez.

Numaralandırılabilir olsun veya olmasın, tüm örnek özelliklerin bir listesini istiyorsanız,

Object.getOwnPropertyNames(x);

Bu, bir nesnede var olan tüm özelliklerin bir ad dizisini döndürür.

Son olarak, object özelliğinin veri türünü doğrudan kontrol etmek için typeof operatörünü kullanabilirsiniz:

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

Özellik nesnede yoksa, dizeyi tanımsız olarak döndürür. Aksi takdirde uygun özellik türünü döndürür. Bununla birlikte, bunun her zaman bir nesnenin bir özelliği olup olmadığını kontrol etmek için geçerli bir yol olmadığını unutmayın, çünkü tanımsız olarak ayarlanmış bir özelliğiniz olabilir, bu durumdatypeof x.key (anahtar hala olsa bile) nesnede).

Güncelleme: Tanımlanmamış javascript özelliğiyle karşılaştırarak bir özelliğin olup olmadığını kontrol edebilirsiniz

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

Anahtar özellikle undefinedx nesnesinde ayarlanmadığı sürece bu çalışmalıdır

Burada biraz kafa karışıklığı yaşayalım. İlk olarak, varsayalımhasOwnProperty zaten var olduğunu ; bu, kullanılmakta olan tarayıcıların büyük çoğunluğu için geçerlidir.

hasOwnPropertynesneye iletilen öznitelik adı nesneye eklenmişse true değerini döndürür. Kendisine atanan gerçek değerden tamamen bağımsızdır. undefined .

Dolayısıyla:

var o = {}
o.x = undefined

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

Ancak:

var o = {}

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

Sorun, prototip zincirindeki bir nesnenin tanımsız değerine sahip bir niteliği olduğunda ne olur? hasOwnPropertyonun için yanlış olacak ve öyle olacak !== undefined. Hala,for..in yine de numaralandırmada listeleyecektir.

Sonuç __prototype__olarak, belirli bir tanımlayıcının bir nesneye veya prototip zincirindeki herhangi bir şeye eklenmediğini belirlemek için çapraz tarayıcı yolu yoktur (Internet Explorer açığa çıkmadığından ).

Bir mülk arıyorsanız, "HAYIR". İstediğiniz:

if ('prop' in obj) { }

Genel olarak, mülkün prototip veya nesneden gelip gelmediğine dikkat etmemelisiniz.

Ancak, örnek kodunuzda 'anahtar' kullandığınızdan, nesneyi bir karma olarak ele aldığınız anlaşılıyor, bu durumda cevabınız mantıklı olacaktır. Tüm hashes anahtarları nesnedeki özellikler olacaktır ve prototipin katkıda bulunduğu ekstra özelliklerden kaçınırsınız.

John Resig'in cevabı çok kapsamlıydı, ama bunun net olmadığını düşündüm. Özellikle "obj 'in obj" ne zaman kullanılacağı ile.

Basit nesneleri test etmek için şunları kullanın: if (obj[x] !== undefined)

Hangi nesne türünün kullanıldığını bilmiyorsanız: if (obj.hasOwnProperty(x))

Diğer tüm seçenekler daha yavaştır ..

ayrıntılar

Nodejs altında 100.000.000 çevrimin burada başkaları tarafından önerilen 5 seçeneğe göre performans değerlendirmesi:

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

Değerlendirme, özellikle nesnenin prototip zincirini ve nesnenin kendisini kontrol etmek istemedikçe, ortak formu kullanmamamız gerektiğini söyler: if (X in Obj)... Kullanım durumuna bağlı olarak 2 ila 6 kat daha yavaştır

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

Alt satırda, Obj'niz mutlaka basit bir nesne değilse ve nesnenin prototip zincirini kontrol etmekten kaçınmak ve x'in doğrudan Obj'a ait olmasını sağlamak istiyorsanız, 'if (obj.hasOwnProperty (x)) ...' kullanın.

Aksi takdirde, basit bir nesne kullanırken ve nesnenin prototip zinciri hakkında endişelenmiyorsanız, kullanmak if (typeof(obj[x]) !== 'undefined')...en güvenli ve en hızlı yoldur.

Karma bir tablo olarak basit bir nesne kullanırsanız ve asla garip bir şey yapmazsanız, if (obj[x])...çok daha okunabilir bulduğum için kullanırım .

İyi eğlenceler.

Evet öyle :) Ben de yapabilirsiniz denilen bir özelliği Object.prototype.hasOwnProperty.call(x, 'key')varsa da çalışması gereken de yapabilirsiniz :)xhasOwnProperty

Ancak bu kendi özelliklerini test eder. Devralınabilecek bir özelliğe sahip olup olmadığını kontrol etmek isterseniz kullanabilirsiniz typeof x.foo != 'undefined'.

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

}

Çünkü

if (x.key)

x.keyçözümlenirse başarısız olur false(örneğin, x.key = "").

ES6 Reflectnesnesini de kullanabilirsiniz :

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

İçin MDN'yi üzerinde Belgeler Reflect.hasbulunabilir burada .

Statik Reflect.has()yöntem, işlev olarak in operatörü gibi çalışır.

Tamam, devralınan özellikleri istemiyorsanız doğru cevaba sahip gibi görünüyor:

if (x.hasOwnProperty('key'))

Devralınan özellikleri eklemek için diğer bazı seçenekler şunlardır:

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

if (x.key !== undefined)

Bunu yapmayın object.hasOwnProperty(key)), bu gerçekten kötüdür, çünkü bu yöntemler söz konusu nesne üzerindeki özellikler tarafından gölgelenebilir - düşünün { hasOwnProperty: false }- veya nesne boş bir nesne olabilir (Object.create(null)).

En iyi yol yapmak Object.prototype.hasOwnProperty.call(object, key)veya:

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

Başka bir nispeten basit yol kullanmaktır Object.keys. Bu arraybir dizinin tüm özelliklerini alacağınız anlamına gelir.

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

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

Her ne kadar harika tarayıcı desteğine sahip bir dünyada olsak da. Bu soru çok eski olduğu için bunu eklemek düşündüm: Bu JS v1.8.5 olarak kullanmak güvenlidir

hasOwnProperty ", bir işlevin aksine, bir nesnenin o nesnenin doğrudan özelliği olarak belirtilen özelliğe sahip olup olmadığını belirlemek için kullanılabilir. , bu yöntem nesnenin prototip zincirini kontrol etmez."

Büyük olasılıkla, sorunuzun neye benzediği için, özelliğin doğrudan nesnenin kendisine bağlı olarak var olup olmadığını belirleyen hasOwnProperty'yi kullanmak istemezsiniz. .

Özelliğin, kullanmak istediğiniz ana prototip zincirinde olup olmadığını belirlemek istiyorsanız, örneğin:

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

Umarım bu yardımcı olur.

Büyük indirgeme riski ile, burada belirli bir vaka için başka bir seçenek var. :)

Bir nesnedeki bir üyeyi test etmek ve üyeden başka bir şeye ayarlanıp ayarlanmadığını bilmek istiyorsanız:

• ''
• yanlış
• boş
• Tanımsız
• 0 ...

o zaman kullanabilirsiniz:

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

ECMA Script 6 ile yansıma çözümü. Şunun gibi sarıcı oluşturun:

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

Nesnede "hasOwnProperty" yöntemi vardır, ancak bazen nesne null olabileceği veya nesne üzerinde bazı özellikler olabileceği için bu yöntemi doğrudan çağırmanız önerilmez: { hasOwnProperty: false }

Yani daha iyi bir yol olurdu:

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

Aşağıdaki yaklaşımları kullanabilirsiniz.

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

Aşağıdaki yaklaşımlar arasındaki fark aşağıdaki gibidir.

1. 1. ve 3. yaklaşımda sadece nesnede değil, prototip zincirinde de arama yapıyoruz. Nesne özelliğe sahip değilse, ancak özellik kendi prototip zincirinde mevcutsa, doğru olur.

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

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

2. 2. yaklaşım sadece kendi özelliklerini kontrol edecektir. Eski -

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

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

3. 1. ve üçüncü arasındaki fark, tanımlanmamış değeri olan bir özellik olması durumunda, 3. yaklaşım yanlış verirken, birinci doğru olur.

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

Yöntemi kullanmanız gerekir object.hasOwnProperty(property). Nesnenin özelliği varsa true değerini, nesne yoksa false değerini döndürür.

Kontrol ettiğiniz anahtar bir değişkende saklanıyorsa , bunu şu şekilde kontrol edebilirsiniz:

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

Yapabildiğinizde neden işleri aşırı karmaşıklaştırıyorsunuz:

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

Çoğu durumda basit ve anlaşılır ...