I den här handledningen kommer vi att se aspekterna av begränsningar och funktioner relaterade till hasOwnProperty() metod i JavaScript. Vi kommer också att lära oss om dess implementeringar och användning i avsnitten.

Introduktion

I JavaScript , definieras hasOwnProperty()-metoden som en egenskap för att säkerställa om objektet tillhör det nämnda projektet eller inte. Om det upptäcks att egenskapen tillhör ett igenkänt objekt, ska den returnera en boolesk satsbaserad utdata, d.v.s. sant eller falskt.

Syntax

 object.hasOwnProperty(propname) 

Argument

Inspelning:

Här måste vi skicka symbolen eller strängnamnet eftersom det är platsen för rekvisitan där det kontrolleras om symbolen eller strängen tillhör objektet. Detta görs med den metod som anges nedan.

 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 

En viktig aspekt att notera här är att metoden hasOwnProperty() i allmänhet ignorerar ärvda egenskaper. Detta betyder att metoden ska returnera sin true om objektet visar sig ha en icke-ärvd egenskap och namnet specificeras av propname. Om det returnerar false betyder det att objektet inte har någon egenskap med ett specificerat namn, eller så har det ärvt egenskapen från objektet i proptypen.

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

En annan extra fördel med att använda metoden hasOwnProperty() är att den kan initiera ett objekt genom att följa upp konceptet att skicka en sträng som standardargument. Den ska snabbt svara med true om värdet visar sig vara tillgängligt för objektet. Annars kommer det att returnera falskt om det inte hittas. Det kan demonstreras med hjälp av kodavsnittet nedan.

 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 

I kodavsnittet ovan skapar variabeln ett nytt objekt, Bil . Det kan nu konstateras att Bilen är initierad med dess egenskaper och namn definierade under konstruktören. Även om färgen kanske inte nämns i objektet när den initieras, kommer den alltid att vara tillgänglig på prototyp hierarki . Därför returnerar hasOwnProperty() alltid sant för namnet, men för färg kommer det att returnera falskt.

När det kommer till prestanda fungerar hasOwnProperty() smidigt samtidigt som den tar sig igenom objektet med loopar. Vid det här laget kan vi säga att om egenskaperna specifikt tillhör objektet. De har ingen korrelation med prototypen. Demonstrationen av detta kan visas med hjälp av kodavsnittet nedan.

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

När du använder metoden hasOwnProperty() kan den bli värdelös eftersom renderingen av objektet sker när en egenskap med namnet hasOwnProperty definieras. För att stödja detta, försök att förstå kodavsnittet nedan.

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

I ovanstående kodavsnitt är det uppenbart att harrypotter redan har hasOwnProperty. Således kommer den aldrig att göra ett anrop till object.prototype.hasOwnProperty. Det antas att detta kan stöta på fall där det kan tillåta att ringa ett samtal, men det kan så småningom misslyckas. Så det rekommenderas alltid att vara medveten om möjligheten till samtal. Nedanstående kodavsnitt visar dess lösning.

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

I ovanstående kodavsnitt är det tydligt att harrypotter definierar sin egen hasOwnProperty . Det kommer aldrig att göra anrop till Object.prototype.hasOwnProperty eftersom det finns en möjlighet att det kan returnera false om det stöter på några fall där värdet är falskt och det blir svårt att få saker att fungera runt hörnet. För att stödja detta påstående, se kodavsnittet nedan.

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

I likhet med hasOwnProperty finns det en annan metod som kallas 'in'-metoden. Den används också för att kontrollera om nyckeln finns för objektet eller inte. Det är dock viktigt att notera att den viktigaste skillnaden mellan hasOwnProperty och in-metoden ligger i det faktum att in-metoden inte kommer att följa ordningen för att skilja mellan de egenskaper som ärvs och de ärvda egenskaperna är speciellt skapade för objektet. Detta kan visas med hjälp av kodavsnittet nedan.

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

I ovanstående kodavsnitt är det uppenbart att 'in'-metoden följer konstruktoregenskapen för Object.prototype varifrån alla objekt ärvs.

För att lägga till några punkter finns det en nackdel för båda metoderna. Båda metoderna kan enkelt ge oss information om en fastighet som redan har deklarerats men de kan inte berätta om fastigheten innehåller ett verkligt värde.

Tänk på följande kodavsnitt som visar hur båda metoderna utför denna lösning.

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

Slutsats

I den här handledningen diskuterade vi hasOwnProperty()-metoden i JavaScript. I allmänhet är den här metoden ett utmärkt val för de flesta utvecklare för att fråga och undvika problem som rör vissa speciella nycklar som konstruktor. Det rekommenderas att om vi hittar något objekt som har någon egenskap, kommer det att använda hasOwnProperty() som standard. Om det finns en funktion som är avsedd att göra ett anrop genom att kontrollera objektet för metoden toString(), måste vi använda in.