I denne opplæringen vil vi se aspektene ved begrensninger og funksjoner knyttet til hasOwnProperty() metode i JavaScript. Vi vil også lære om implementeringene og bruken i seksjonene.

Introduksjon

I JavaScript , er hasOwnProperty()-metoden definert som en egenskap for å sikre om objektet tilhører det nevnte prosjektet eller ikke. Hvis det blir funnet at egenskapen tilhører et gjenkjent objekt, skal den returnere en boolsk setningsbasert utgang, dvs. sant eller usant.

Syntaks

 object.hasOwnProperty(propname) 

Argument

Innspilling:

Her må vi sende symbolet eller strengnavnet fordi dette er stedet for rekvisitten der det sjekkes om symbolet eller strengen tilhører objektet. Dette gjøres ved å bruke metoden gitt nedenfor.

kruskals algoritme

 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 

Et viktig aspekt å merke seg her er at metoden hasOwnProperty() generelt ignorerer arvede egenskaper. Dette betyr at metoden skal returnere sin true hvis objektet er funnet å ha en ikke-arvet egenskap og navnet er spesifisert av propname. Hvis det returnerer false, betyr det at objektet ikke har noen egenskap med et spesifisert navn, eller det har arvet egenskapen fra objektet til 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 

En annen ekstra fordel med å bruke hasOwnProperty()-metoden er at den kan initialisere et objekt ved å følge opp konseptet med å sende en streng som standardargument. Den skal svare raskt med sann hvis verdien er funnet å være tilgjengelig for objektet. Ellers vil den returnere falsk hvis den ikke blir funnet. Det kan demonstreres ved hjelp av kodebiten gitt nedenfor.

 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 kodebiten gitt ovenfor oppretter variabelen et nytt objekt, Bil . Det kan nå slås fast at Bilen er initiert med sine egenskaper og navn definert under konstruktøren. Selv om fargen kanskje ikke er nevnt i objektet når den initieres, vil den alltid være tilgjengelig på prototypisk hierarki . Derfor vil hasOwnProperty() alltid returnere sant for navnet, men for farge vil det returnere usant.

Når det kommer til ytelse, fungerer hasOwnProperty() jevnt mens de går gjennom objektet med looper. Nå kan vi si at hvis egenskapene spesifikt tilhører objektet. De har ingen sammenheng med prototypen. Demonstrasjonen av dette kan vises ved hjelp av kodebiten gitt nedenfor.

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

Mens du bruker hasOwnProperty()-metoden, kan den bli ubrukelig fordi gjengivelsen av objektet skjer når du definerer en egenskap kalt hasOwnProperty. For å støtte dette, prøv å forstå kodebiten gitt nedenfor.

innstillingsmeny for Android-telefoner

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

I kodebiten ovenfor er det tydelig at harrypotter allerede har hasOwnProperty. Dermed vil den aldri kalle objektet.prototype.hasOwnProperty. Det antas at dette kan støte på tilfeller der det kan tillate å ringe, men det kan til slutt mislykkes. Så det anbefales alltid å være oppmerksom på muligheten for samtaler. Kodebiten nedenfor viser løsningen.

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

I kodebiten ovenfor er det tydelig at harrypotter definerer sin egen hasOwnProperty . Den vil aldri ringe til Object.prototype.hasOwnProperty fordi det er en mulighet for at den kan returnere falsk hvis den støter på noen tilfeller der verdien er falsk og det blir vanskelig å få ting til å fungere rundt hjørnet. For å støtte denne uttalelsen, se kodebiten nedenfor.

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

I likhet med hasOwnProperty, er det en annen metode som kalles 'in'-metoden. Den brukes også til å sjekke om nøkkelen er til stede for objektet eller ikke. Det er imidlertid viktig å merke seg at hovedforskjellen mellom hasOwnProperty og in-metoden ligger i det faktum at in-metoden ikke vil følge rekkefølgen for å skille mellom egenskapene som blir arvet og de arvede egenskapene som er spesielt laget for objektet. Dette kan vises ved hjelp av kodebiten gitt nedenfor.

 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 kodebiten ovenfor er det tydelig at 'in'-metoden følger konstruktøregenskapen til Object.prototype hvorfra alle objektene blir arvet.

For å legge til noen få punkter, er det en ulempe for begge metodene. Begge metodene kan enkelt gi oss informasjon om en eiendom som allerede er deklarert, men de kan ikke fortelle oss om eiendommen som inneholder en reell verdi.

Tenk på følgende kodebit som viser hvordan begge metodene utfører denne løsningen.

lage tabeller i lateks

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

Konklusjon

I denne opplæringen diskuterte vi hasOwnProperty()-metoden i JavaScript. Generelt er denne metoden et godt valg for de fleste utviklere for å spørre og unngå problemer knyttet til noen spesielle nøkler som konstruktør. Det anbefales at hvis vi finner et objekt som har en egenskap, vil det bruke hasOwnProperty() som standard. I tilfelle tilstedeværelse av funksjon som er ment å foreta et anrop ved å sjekke objektet for toString()-metoden, må vi bruke in.