Ebben az oktatóanyagban a korlátozások és funkciók vonatkozásait fogjuk látni hasonOwnProperty() módszer JavaScriptben. Megvalósításait és használatát is megismerjük a részekben.

Bevezetés

Ban ben JavaScript , a hasOwnProperty() metódus olyan tulajdonságként van definiálva, amely biztosítja, hogy az objektum az említett projekthez tartozik-e vagy sem. Ha azt találja, hogy a tulajdonság egy felismert objektumhoz tartozik, akkor Boole-féle utasítás alapú kimenetet kell visszaadnia, azaz igaz vagy hamis.

Szintaxis

 object.hasOwnProperty(propname) 

Érv

Felvétel:

Itt át kell adnunk a szimbólumot vagy a karakterlánc nevét, mert ez az a hely, ahol ellenőrizni kell, hogy a szimbólum vagy karakterlánc az objektumhoz tartozik-e. Ez az alábbiakban megadott módszerrel történik.

 var movie = { name: 'iron man', genre: 'super hit', } var song = { name: 'cardigan', } movie.hasOwnProperty('name'); // returns true movie.hasOwnProperty('type'); // returns false song.hasOwnProperty('name'); // returns true song.hasOwnProperty('status'); // returns false 

Fontos megjegyezni, hogy a hasOwnProperty() metódus általában figyelmen kívül hagyja az örökölt tulajdonságokat. Ez azt jelenti, hogy a metódus igaz értékét adja vissza, ha az objektumról kiderül, hogy nem öröklött tulajdonsággal rendelkezik, és a nevet propname határozza meg. Ha false értéket ad vissza, akkor az azt jelenti, hogy az objektumnak nincs meghatározott nevű tulajdonsága, vagy a tulajdonságot a proptype objektumától örökölte.

 // Create an object var o = new Object(); // Define a noninherited local property o.x = 3.14; o.hasOwnProperty('x'); // Returns true: x is a local property of o o.hasOwnProperty('y'); // Returns false: o doesn't have a property y o.hasOwnProperty('toString'); // Returns false: toString property is inherited hasOwnProperty() will return true even if you define the undefined or null value. let a = new Object(); a.propertyOne = null; a.hasOwnProperty('propertyOne') // output: true a.propertyTwo = undefined; a.hasOwnProperty('propertyTwo') //Output: true 

A hasOwnProperty() metódus használatának másik előnye, hogy képes inicializálni egy objektumot azáltal, hogy követi a karakterlánc alapértelmezett argumentumként való átadásának koncepcióját. Gyorsan igaz szóval válaszol, ha az érték elérhető az objektum számára. Ellenkező esetben hamis értéket ad vissza, ha nem található. Az alább megadott kódrészlettel demonstrálható.

 function Car(name) { this.name = name; } Car.prototype.color = 'red'; const bmw = new Car('x1'); console.log(bmw.name); // property found on object console.log(bmw.color); // color property found on prototype console.log(bmw.hasOwnProperty('name')); // name is found on the object itself console.log(bmw.hasOwnProperty('color')); // color property is not found on the object itself 

A fent megadott kódrészletben a változó egy új objektumot hoz létre, Autó . Most már kijelenthető, hogy az Autót úgy indítják el, hogy tulajdonságai és neve a kivitelező alatt van megadva. Bár lehet, hogy a szín nem szerepel az objektumon belül kezdeményezésekor, a prototipikuson mindig elérhető lesz hierarchia . Ezért a hasOwnProperty() mindig igaz értéket ad vissza a névhez, de szín esetén false értéket ad vissza.

Ha teljesítményről van szó, a hasOwnProperty() zökkenőmentesen működik, miközben hurkokkal áthalad az objektumon. Mára már azt mondhatjuk, hogy ha a tulajdonságok kifejezetten az objektumhoz tartoznak. Nincs összefüggésük a prototípussal. Ennek demonstrációja az alább megadott kódrészlet segítségével mutatható be.

 // declaring a Car function function Car(name) { this.name = name; } // setting up new prop with prototype Car.prototype.color = 'red'; // creating a new Car object const BMW = new Car('x1'); // looping through every car prop including prototype as well for (let car in BMW) { car + ':', BMW[car]; } /* output: name: x1 output: color: red */ /**************************************/ /*will loop through only self properties of the object, excludes property generated through prototype method */ for (let car in BMW) { if (BMW.hasOwnProperty(car)) { console.log(car + ':', BMW[car]); } } // output: name: 

A hasOwnProperty() metódus használata közben haszontalanná válhat, mert az objektum megjelenítése a hasOwnProperty nevű tulajdonság definiálásakor történik. Ennek alátámasztására próbálja megérteni az alábbi kódrészletet.

 var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); 

A fenti kódrészletben nyilvánvaló, hogy a harrypotter már rendelkezik hasOwnProperty-vel. Így soha nem hívja meg az object.prototype.hasOwnProperty fájlt. Feltételezhető, hogy ez előfordulhat olyan esetekben, amikor lehetővé teszi a hívás kezdeményezését, de végül meghiúsulhat. Ezért mindig ajánlott tisztában lenni a hívások lehetőségével. Az alábbi kódrészlet bemutatja a megoldást.

 // Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

A fenti kódrészletben jól látható, hogy a harrypotter meghatározza a sajátját rendelkezik saját tulajdonnal . Soha nem hívja meg az Object.prototype.hasOwnProperty fájlt, mert fennáll annak a lehetősége, hogy false értéket ad vissza, ha találkozik néhány olyan esettel, amikor az érték false, és nehéz lesz a dolgokat a sarkon túl működni. Az állítás alátámasztásához tekintse meg az alábbi kódrészletet.

 // Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus'); 

A hasOwnPropertyhez hasonlóan létezik egy másik módszer is, az úgynevezett „in” metódus. Arra is használható, hogy ellenőrizze, hogy az objektum kulcsa megvan-e vagy sem. Fontos azonban megjegyezni, hogy a hasOwnProperty és az in metódus közötti kulcsfontosságú különbség abban rejlik, hogy az in metódus nem követi az öröklődő tulajdonságok megkülönböztetésének sorrendjét, és a speciálisan az objektum számára létrehozott öröklött tulajdonságokat. Ezt az alább megadott kódrészlettel lehet megjeleníteni.

 var fantasyLit = { tolkien: 'The Lord of the Rings', lewis: 'The Chronicles of Narnia' }; // Outputs: true console.log('tolkien' in fantasyLit); // Outputs: false console.log('asimov' in fantasyLit); // Outputs: true console.log('constructor' in fantasyLit); 

A fenti kódrészletben nyilvánvaló, hogy az 'in' metódus az Object.prototype konstruktor tulajdonságát követi, ahonnan az összes objektum öröklődik.

Néhány pontot hozzáfűzve mindkét módszernek van egy hátránya. Mindkét módszer könnyen tud információt adni egy már bejelentett ingatlanról, de a valós értéket tartalmazó ingatlanról nem.

Tekintsük a következő kódrészletet, amely bemutatja, hogy mindkét módszer hogyan alkalmazza ezt a megoldást.

 // Puts a 'declared' property on the global object // (window in browsers) var declared; // Outputs: true console.log('declared' in window); // Outputs: true console.log(window.hasOwnProperty('declared')); // Outputs: undefined console.log(declared); var obj = { myUndefined: undefined }; // Outputs: true console.log('myUndefined' in obj); // Outputs: true console.log(obj.hasOwnProperty('myUndefined')); // Outputs: undefined console.log(obj.myUndefined); 

Következtetés

Ebben az oktatóanyagban a hasOwnProperty() metódusról beszéltünk a JavaScriptben. Általánosságban elmondható, hogy ez a módszer nagyszerű választás a legtöbb fejlesztő számára, hogy érdeklődjön, és elkerülje bizonyos speciális kulcsokkal, például a konstruktorral kapcsolatos problémákat. Javasoljuk, hogy ha olyan objektumokat találunk, amelyeknek bármilyen tulajdonsága van, akkor alapértelmezés szerint a hasOwnProperty() függvényt használja. Olyan függvény jelenléte esetén, amely az objektum toString() metódusának ellenőrzésével hívást kezdeményez, az in-t kell használnunk.