I denne tutorial vil vi se aspekterne af begrænsninger og funktioner relateret til hasOwnProperty() metode i JavaScript. Vi vil også lære om dets implementeringer og brug i sektionerne.

Introduktion

I JavaScript , er hasOwnProperty()-metoden defineret som en egenskab for at sikre, om objektet tilhører det nævnte projekt eller ej. Hvis det konstateres, at egenskaben tilhører et genkendt objekt, skal den returnere et boolesk sætningsbaseret output, dvs. sandt eller falsk.

Syntaks

 object.hasOwnProperty(propname) 

Argument

Indspilning:

Her skal vi videregive symbolet eller strengnavnet, fordi dette er stedet for prop, hvor det kontrolleres, om symbolet eller strengen tilhører objektet. Dette gøres ved hjælp af nedenstående metode.

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 vigtigt aspekt at bemærke her er, at metoden hasOwnProperty() generelt ignorerer nedarvede egenskaber. Dette betyder, at metoden skal returnere sin sande, hvis objektet viser sig at have en ikke-nedarvet egenskab, og navnet er angivet med propnavn. Hvis det returnerer falsk, betyder det, at objektet ikke har nogen egenskab med et specificeret navn, eller det har arvet egenskaben fra 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 anden ekstra fordel ved at bruge metoden hasOwnProperty() er, at den kan initialisere et objekt ved at følge op på konceptet med at sende en streng som standardargument. Den skal reagere hurtigt med sand, hvis værdien findes at være tilgængelig for objektet. Ellers vil den returnere falsk, hvis den ikke findes. Det kan demonstreres ved hjælp af kodestykket 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 kodestykket ovenfor opretter variablen et nyt objekt, Bil . Det kan nu konstateres, at Bilen er initieret med dens egenskaber og navn defineret under konstruktøren. Selvom farven muligvis ikke er nævnt i objektet, når den startes, vil den altid være tilgængelig på prototypikken hierarki . Derfor vil hasOwnProperty() altid returnere sand for navnet, men for farve vil den returnere falsk.

Når det kommer til ydeevne, fungerer hasOwnProperty() gnidningsløst, mens den går gennem objektet med loops. Efterhånden kan vi sige, at hvis egenskaberne specifikt tilhører objektet. De har ikke nogen sammenhæng med prototypen. Demonstrationen af ​​dette kan vises ved hjælp af kodestykket 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 bruger hasOwnProperty()-metoden, kan den blive ubrugelig, fordi gengivelsen af ​​objektet sker, når du definerer en egenskab ved navn hasOwnProperty. For at understøtte dette, prøv at forstå kodestykket nedenfor.

relationssammensætning

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

I ovenstående kodestykke er det tydeligt, at harrypotter allerede har hasOwnProperty. Den vil således aldrig foretage et opkald til object.prototype.hasOwnProperty. Det antages, at dette kan støde på tilfælde, hvor det kan tillade at foretage et opkald, men det kan i sidste ende mislykkes. Så det anbefales altid at være opmærksom på muligheden for opkald. Nedenstående kodestykke viser dens løsning.

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

I ovenstående kodestykke er det tydeligt, at harrypotter definerer sin egen hasOwnProperty . Den vil aldrig foretage opkald til Object.prototype.hasOwnProperty, fordi der er en mulighed for, at den kan returnere falsk, hvis den støder på nogle tilfælde, hvor værdien er falsk, og det bliver svært at få tingene til at fungere rundt om hjørnet. For at understøtte denne erklæring, se kodestykket nedenfor.

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

I lighed med hasOwnProperty er der en anden metode kaldet 'in' metode. Det bruges også til at kontrollere, om nøglen er til stede for objektet eller ej. Det er dog vigtigt at bemærke, at den vigtigste forskel mellem hasOwnProperty og in-metoden ligger i det faktum, at in-metoden ikke følger rækkefølgen for at skelne mellem de egenskaber, der bliver nedarvet, og de nedarvede egenskaber, der er specielt skabt til objektet. Dette kan vises ved hjælp af kodestykket 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 ovenstående kodestykke er det tydeligt, at 'in'-metoden følger constructor-egenskaben for Object.prototype, hvorfra alle objekterne bliver nedarvet.

For at tilføje et par punkter er der en ulempe ved begge metoder. Begge metoder kan nemt give os oplysninger om en ejendom, der allerede er anmeldt, men de kan ikke fortælle os, om ejendommen indeholder en reel værdi.

Overvej følgende kodestykke, der viser, hvordan begge metoder udfører denne løsning.

undtagelseshåndtering java

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

Konklusion

I denne øvelse diskuterede vi hasOwnProperty()-metoden i JavaScript. Generelt er denne metode et godt valg for de fleste udviklere til at spørge og undgå problemer relateret til nogle specielle nøgler som konstruktør. Det anbefales, at hvis vi finder et objekt med en egenskab, vil det bruge hasOwnProperty() som standard. I tilfælde af tilstedeværelsen af ​​en funktion beregnet til at foretage et opkald ved at kontrollere objektet for toString()-metoden, skal vi bruge in.