In deze tutorial zullen we de aspecten van beperkingen en functies zien die verband houden met de hasOwnProperty() methode in JavaScript. We zullen ook leren over de implementaties en het gebruik ervan in de secties.

Invoering

In JavaScript , wordt de methode hasOwnProperty() gedefinieerd als een eigenschap om te garanderen of het object tot het genoemde project behoort of niet. Als wordt vastgesteld dat de eigenschap bij een herkend object hoort, retourneert het een op een Booleaanse verklaring gebaseerde uitvoer, d.w.z. waar of onwaar.

Syntaxis

 object.hasOwnProperty(propname) 

Argument

Propname:

Hier moeten we het symbool of de stringnaam doorgeven, omdat dit de plaats van prop is waar wordt gecontroleerd of het symbool of de string bij het object hoort. Dit gebeurt met behulp van de onderstaande methode.

 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 

Een belangrijk aspect om op te merken is dat de methode hasOwnProperty() over het algemeen overgeërfde eigenschappen negeert. Dit betekent dat de methode de waarde true retourneert als blijkt dat het object een niet-overgeërfde eigenschap heeft en de naam wordt gespecificeerd door propname. Als het false retourneert, betekent dit dat het object geen enkele eigenschap met een opgegeven naam heeft, of dat het de eigenschap heeft geërfd van het object van het proptype.

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

Een ander bijkomend voordeel van het gebruik van de methode hasOwnProperty() is dat deze een object kan initialiseren door het concept van het doorgeven van een string als standaardargument op te volgen. Het zal snel reageren met true als blijkt dat de waarde beschikbaar is voor het object. Anders zal het false retourneren als het niet wordt gevonden. Het kan worden gedemonstreerd met behulp van het onderstaande codefragment.

 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 

In het hierboven gegeven codefragment creëert de variabele een nieuw object, Auto . Er kan nu worden gesteld dat de auto is geïnitieerd met de eigenschappen en naam gedefinieerd onder de constructeur. Hoewel de kleur bij het starten mogelijk niet in het object wordt vermeld, zal deze altijd beschikbaar zijn op het prototype hiërarchie . Daarom zal hasOwnProperty() altijd true retourneren voor de naam, maar voor kleur zal het false retourneren.

Als het op prestaties aankomt, werkt hasOwnProperty() soepel terwijl het zich met lussen een weg door het object baant. Inmiddels kunnen we dat zeggen als de eigenschappen specifiek bij het object horen. Ze hebben geen enkele correlatie met het prototype. De demonstratie hiervan kan worden getoond met behulp van het onderstaande codefragment.

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

Wanneer u de methode hasOwnProperty() gebruikt, kan deze nutteloos worden omdat de weergave van het object plaatsvindt bij het definiëren van een eigenschap met de naam hasOwnProperty. Om dit te ondersteunen, probeer het onderstaande codefragment te begrijpen.

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

In het bovenstaande codefragment is het duidelijk dat harrypotter al hasOwnProperty heeft. Het zal dus nooit een aanroep doen naar het object.prototype.hasOwnProperty. Aangenomen wordt dat dit gevallen kan tegenkomen waarin het mogelijk is om te bellen, maar uiteindelijk kan dit mislukken. Het is dus altijd aan te raden om op de hoogte te zijn van de mogelijkheid tot bellen. Het onderstaande codefragment toont de oplossing.

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

In het bovenstaande codefragment is het duidelijk dat Harrypotter zijn eigen code definieert heeft eigen eigendom . Het zal nooit Object.prototype.hasOwnProperty aanroepen, omdat er een mogelijkheid bestaat dat het false retourneert als het enkele gevallen tegenkomt waarin de waarde false is en het moeilijk wordt om dingen om de hoek te laten werken. Om deze verklaring te ondersteunen, zie het onderstaande codefragment.

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

Net als bij hasOwnProperty is er nog een methode genaamd 'in'-methode. Het wordt ook gebruikt om te controleren of de sleutel aanwezig is voor het object of niet. Het is echter belangrijk op te merken dat het belangrijkste verschil tussen hasOwnProperty en in method ligt in het feit dat de in methode niet de volgorde zal volgen waarin onderscheid wordt gemaakt tussen de eigenschappen die worden geërfd en de geërfde eigenschappen die speciaal voor het object zijn gemaakt. Dit kan worden weergegeven met behulp van het onderstaande codefragment.

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

In het bovenstaande codefragment is het duidelijk dat de 'in'-methode de constructor-eigenschap van Object.prototype volgt, van waaruit alle objecten worden geërfd.

Om een ​​paar punten toe te voegen: er is een nadeel voor beide methoden. Beide methoden kunnen ons gemakkelijk informatie geven over een onroerend goed dat al is aangegeven, maar ze kunnen ons niet vertellen over het onroerend goed dat een echte waarde bevat.

Bekijk het volgende codefragment dat laat zien hoe beide methoden deze oplossing bieden.

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

Conclusie

In deze tutorial hebben we gesproken over de hasOwnProperty() -methode in JavaScript. Over het algemeen is deze methode voor de meeste ontwikkelaars een goede keuze om problemen met bepaalde speciale sleutels, zoals constructor, te onderzoeken en te voorkomen. Het wordt aanbevolen dat als we een object vinden dat een eigenschap heeft, het standaard hasOwnProperty() gebruikt. In het geval dat er een functie aanwezig is die bedoeld is om een ​​aanroep te doen door het object te controleren op de methode toString(), moeten we de methode in gebruiken.