Bagaimana cara saya memeriksa apakah suatu objek memiliki properti spesifik dalam JavaScript?

Bagaimana cara saya memeriksa apakah suatu objek memiliki properti spesifik dalam JavaScript?

Mempertimbangkan:

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

Apakah itu cara terbaik untuk melakukannya?

Saya benar-benar bingung dengan jawaban yang telah diberikan - kebanyakan dari mereka benar-benar salah. Tentu saja Anda dapat memiliki properti objek yang memiliki nilai undefined, null, atau false. Jadi hanya dengan mengurangi pemeriksaan properti ke typeof this[property]atau, lebih buruk lagi, x.keyakan memberi Anda hasil yang sepenuhnya menyesatkan.

Tergantung pada apa yang Anda cari. Jika Anda ingin tahu apakah suatu objek secara fisik mengandung properti (dan itu tidak datang dari suatu tempat di atas rantai prototipe) maka object.hasOwnPropertyadalah cara untuk pergi. Semua browser modern mendukungnya. (Versi ini hilang di versi Safari yang lebih lama - 2.0.1 dan lebih lama - tetapi versi browser tersebut jarang digunakan lagi.)

Jika yang Anda cari adalah jika sebuah objek memiliki properti di atasnya yang dapat diubah (ketika Anda beralih pada properti objek, itu akan muncul) kemudian melakukan: prop in objectakan memberikan efek yang Anda inginkan.

Karena menggunakan hasOwnPropertymungkin apa yang Anda inginkan, dan mempertimbangkan bahwa Anda mungkin menginginkan metode mundur, saya berikan kepada Anda solusi berikut:

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

Di atas adalah solusi lintas-browser yang berfungsi, hasOwnPropertydengan satu peringatan: Tidak dapat membedakan antara kasus di mana properti yang identik berada pada prototipe dan pada contoh - hanya mengasumsikan bahwa itu berasal dari prototipe. Anda bisa mengubahnya menjadi lebih lunak atau ketat, berdasarkan situasi Anda, tetapi setidaknya ini seharusnya lebih bermanfaat.

Dengan Underscore.jsatau ( bahkan lebih baik ) lodash:

_.has(x, 'key');

Yang panggilan Object.prototype.hasOwnProperty, tetapi (a) lebih pendek untuk mengetik, dan (b) menggunakan "referensi aman untuk hasOwnProperty" (yaitu itu berfungsi bahkan jika hasOwnPropertyditimpa).

Secara khusus, lodash didefinisikan _.hassebagai:

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

Bagaimana dengan?

var x = {'key': 1};

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

Catatan : yang berikut ini sebagian besar sudah usang karena mode yang ketat, dan hasOwnProperty. Solusi yang benar adalah dengan menggunakan mode ketat dan untuk memeriksa keberadaan properti menggunakan obj.hasOwnProperty. Jawaban ini mendahului kedua hal ini, setidaknya diimplementasikan secara luas (ya, sudah setua itu). Ambil yang berikut sebagai catatan sejarah.

Ingatlah bahwa undefined(sayangnya) bukan kata yang dilindungi undang-undang dalam JavaScript jika Anda tidak menggunakan mode ketat. Oleh karena itu, seseorang (orang lain, jelas) dapat memiliki ide besar mendefinisikannya kembali, melanggar kode Anda.

Metode yang lebih kuat adalah sebagai berikut:

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

Di sisi lain, metode ini jauh lebih verbose dan juga lebih lambat. : - /

Alternatif umum adalah untuk memastikan bahwa undefinedyang benar-benar terdefinisi, misalnya dengan menempatkan kode ke fungsi yang menerima parameter tambahan, yang disebut undefined, yang tidak lulus nilai. Untuk memastikan itu tidak melewati nilai, Anda bisa langsung menyebutnya sendiri, mis:

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

if (x.key !== undefined)

Armin Ronacher tampaknya sudah mengalahkan saya untuk itu , tetapi:

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

Solusi yang lebih aman, tetapi lebih lambat, seperti ditunjukkan oleh Konrad Rudolph dan Armin Ronacher adalah:

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

Anda dapat menggunakan inoperator untuk memeriksa apakah properti ada pada objek:

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

Anda juga dapat mengulangi semua properti objek menggunakan for - inloop, dan kemudian memeriksa properti spesifik:

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

Anda harus mempertimbangkan apakah properti objek ini enumerable atau tidak, karena properti non-enumerable tidak akan muncul dalam satu for-inlingkaran. Juga, jika properti enumerable membayangi properti non-enumerable dari prototipe, itu tidak akan muncul di Internet Explorer 8 dan sebelumnya.

Jika Anda ingin daftar semua properti instan, apakah dapat dihitung atau tidak, Anda dapat menggunakan

Object.getOwnPropertyNames(x);

Ini akan mengembalikan array nama semua properti yang ada pada suatu objek.

Akhirnya, Anda bisa menggunakan typeof operator untuk secara langsung memeriksa tipe data dari properti objek:

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

Jika properti tidak ada pada objek, itu akan mengembalikan string yang tidak ditentukan. Jika tidak maka akan mengembalikan jenis properti yang sesuai. Namun, perhatikan bahwa ini tidak selalu merupakan cara yang valid untuk memeriksa apakah suatu objek memiliki properti atau tidak, karena Anda bisa memiliki properti yang diatur ke tidak terdefinisi, dalam hal ini, menggunakan typeof x.keymasih akan mengembalikan true (meskipun kuncinya masih di objek).

Pembaruan: Anda dapat memeriksa apakah ada properti dengan membandingkan dengan properti javascript yang tidak ditentukan

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

Ini akan berfungsi kecuali kunci secara khusus diatur undefinedpada objek x

Mari kita memotong beberapa kebingungan di sini. Pertama, mari kita sederhanakan dengan menganggap hasOwnPropertysudah ada; ini berlaku untuk sebagian besar browser saat ini yang digunakan.

hasOwnPropertymengembalikan true jika nama atribut yang diteruskan ke itu telah ditambahkan ke objek. Ini sepenuhnya independen dari nilai aktual yang diberikan kepadanya yang mungkin tepat undefined.

Karenanya:

var o = {}
o.x = undefined

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

Namun:

var o = {}

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

Masalahnya adalah apa yang terjadi ketika sebuah objek dalam rantai prototipe memiliki atribut dengan nilai undefined? hasOwnPropertyakan salah untuk itu, dan juga akan !== undefined. Namun, for..inmasih akan mencantumkannya dalam enumerasi.

Intinya adalah tidak ada cara lintas-browser (karena Internet Explorer tidak mengekspos __prototype__) untuk menentukan bahwa pengidentifikasi tertentu belum dilampirkan ke objek atau apa pun dalam rantai prototipe.

Jika Anda mencari properti, maka "TIDAK". Kamu ingin:

if ('prop' in obj) { }

Secara umum Anda tidak perlu peduli apakah properti itu berasal dari prototipe atau objek.

Namun, karena Anda menggunakan 'kunci' dalam kode sampel, sepertinya Anda memperlakukan objek sebagai hash, dalam hal ini jawaban Anda akan masuk akal. Semua kunci hash akan menjadi properti di objek, dan Anda menghindari properti tambahan yang dikontribusikan oleh prototipe.

Jawaban John Resig sangat komprehensif, tetapi saya pikir itu tidak jelas. Apalagi dengan kapan menggunakan "'prop' in obj".

Untuk menguji objek sederhana gunakan: if (obj[x] !== undefined)

Jika Anda tidak tahu jenis objek apa yang digunakan: if (obj.hasOwnProperty(x))

Semua opsi lain lebih lambat ..

Detail

Evaluasi kinerja 100.000.000 siklus di bawah Nodejs ke 5 opsi yang disarankan oleh orang lain di sini:

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

Evaluasi memberi tahu kita bahwa kecuali kita secara khusus ingin memeriksa rantai prototipe objek dan juga objek itu sendiri, kita tidak boleh menggunakan bentuk umum: if (X in Obj)... Itu antara 2 hingga 6 kali lebih lambat tergantung pada kasus penggunaan

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

Intinya, jika Obj Anda tidak harus berupa objek sederhana dan Anda ingin menghindari memeriksa rantai prototipe objek dan untuk memastikan x dimiliki oleh Obj secara langsung, gunakan 'if (obj.hasOwnProperty (x)) ...'.

Kalau tidak, ketika menggunakan objek sederhana dan tidak khawatir tentang rantai prototipe objek, menggunakan if (typeof(obj[x]) !== 'undefined')...adalah cara teraman dan tercepat.

Jika Anda menggunakan objek sederhana sebagai tabel hash dan tidak pernah melakukan apa pun keriting, saya akan menggunakan if (obj[x])...karena saya merasa jauh lebih mudah dibaca.

Selamat bersenang-senang.

Ya itu :) Saya pikir Anda juga bisa melakukan Object.prototype.hasOwnProperty.call(x, 'key')yang juga berfungsi jika xmemiliki properti bernama hasOwnProperty:)

Tapi itu menguji properti sendiri. Jika Anda ingin memeriksa apakah memiliki properti yang mungkin juga diturunkan, Anda dapat menggunakannya typeof x.foo != 'undefined'.

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

}

Karena

if (x.key)

gagal jika x.keymemutuskan untuk false(misalnya, x.key = "").

Anda juga dapat menggunakan objek ES6Reflect :

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

Dokumentasi tentang MDN untuk Reflect.hasdapat ditemukan di sini .

Reflect.has()Metode statis berfungsi seperti operator in sebagai suatu fungsi.

OK, sepertinya saya punya jawaban yang tepat kecuali jika Anda tidak ingin properti yang diwarisi:

if (x.hasOwnProperty('key'))

Berikut adalah beberapa opsi lain untuk menyertakan properti yang diwarisi:

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

if (x.key !== undefined)

Jangan lakukan ini object.hasOwnProperty(key)), itu benar-benar buruk karena metode ini dapat dibayangi oleh properti pada objek yang bersangkutan - pertimbangkan { hasOwnProperty: false }- atau, objek tersebut mungkin objek nol (Object.create(null)).

Cara terbaik adalah dengan melakukan Object.prototype.hasOwnProperty.call(object, key)atau:

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

Cara lain yang relatif sederhana adalah menggunakan Object.keys. Ini mengembalikan arrayyang berarti Anda mendapatkan semua fitur array.

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

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

Meskipun kami berada di dunia dengan dukungan browser yang bagus. Karena pertanyaan ini sudah sangat lama saya pikir saya akan menambahkan ini: Ini aman untuk digunakan pada JS v1.8.5

hasOwnProperty "dapat digunakan untuk menentukan apakah suatu objek memiliki properti yang ditentukan sebagai properti langsung dari objek itu; tidak seperti dalam operator , metode ini tidak memeriksa rantai prototipe objek."

Jadi yang paling mungkin, untuk apa yang tampak oleh pertanyaan Anda, Anda tidak ingin menggunakan hasOwnProperty, yang menentukan apakah properti itu ada sebagai terlampir langsung ke objek itu sendiri ,.

Jika Anda ingin menentukan apakah properti ada di rantai prototipe tempat Anda ingin menggunakannya, seperti:

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

Saya harap ini membantu.

Dengan risiko downvoting besar-besaran, berikut adalah opsi lain untuk kasus tertentu. :)

Jika Anda ingin menguji untuk anggota pada suatu objek dan ingin tahu apakah itu telah ditetapkan untuk sesuatu selain:

• ''
• Salah
• batal
• tidak terdefinisi
• 0 ...

maka Anda dapat menggunakan:

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

Solusi ECMA Script 6 dengan refleksi. Buat pembungkus seperti:

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

Ada metode "hasOwnProperty" ada pada objek, tetapi tidak disarankan untuk memanggil metode ini secara langsung karena mungkin terkadang objek tersebut null atau beberapa properti ada pada objek seperti: { hasOwnProperty: false }

Jadi cara yang lebih baik adalah:

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

Anda dapat menggunakan pendekatan berikut-

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

Perbedaan antara pendekatan berikut adalah sebagai berikut-

1. Dalam pendekatan 1 dan 3 kita tidak hanya mencari di objek tetapi rantai prototipalnya juga. Jika objek tidak memiliki properti, tetapi properti tersebut hadir dalam rantai prototipe, ia akan memberikan yang benar.

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

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

2. Pendekatan 2 akan memeriksa hanya untuk propertinya sendiri. Mis -

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

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

3. Perbedaan antara 1 dan ketiga adalah jika ada properti yang nilainya tidak terdefinisi, pendekatan ke-3 akan memberikan false sementara yang pertama akan memberikan true.

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

Anda perlu menggunakan metode ini object.hasOwnProperty(property). Ini mengembalikan true jika objek memiliki properti dan false jika objek tidak.

Jika kunci yang Anda periksa disimpan dalam variabel , Anda dapat memeriksanya seperti ini:

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

Mengapa terlalu rumit hal yang bisa Anda lakukan:

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

Sederhana dan jelas untuk sebagian besar kasus ...