V tej vadnici si bomo ogledali vidike omejitev in funkcij, povezanih z hasOwnProperty() metoda v JavaScriptu. Spoznali bomo tudi njegove izvedbe in uporabo v razdelkih.

Uvod

notri JavaScript , je metoda hasOwnProperty() definirana kot lastnost, ki zagotavlja, ali predmet pripada omenjenemu projektu ali ne. Če je ugotovljeno, da lastnost pripada prepoznanemu objektu, mora vrniti izhod, ki temelji na logični izjavi, tj. resnično ali napačno.

Sintaksa

 object.hasOwnProperty(propname) 

Prepir

snemanje:

Tukaj moramo posredovati simbol ali ime niza, ker je to mesto prop, kjer se preveri, ali simbol ali niz pripada objektu. To naredite s spodaj navedeno metodo.

 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 

Pomemben vidik, ki ga je treba upoštevati, je, da metoda hasOwnProperty() na splošno ignorira podedovane lastnosti. To pomeni, da mora metoda vrniti vrednost true, če je ugotovljeno, da ima objekt nepodedovano lastnost in je ime podano s propname. Če vrne false, potem to pomeni, da objekt nima nobene lastnosti z določenim imenom ali pa je lastnost podedoval od objekta 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 

Druga dodatna prednost uporabe metode hasOwnProperty() je, da lahko inicializira objekt tako, da sledi konceptu posredovanja niza kot privzetega argumenta. Hitro se odzove z resnico, če se ugotovi, da je vrednost na voljo objektu. V nasprotnem primeru bo vrnil false, če ne bo najden. To je mogoče prikazati s spodnjim delčkom kode.

 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 

V zgornjem delčku kode spremenljivka ustvari nov predmet, avto . Zdaj je mogoče trditi, da je avto iniciiran s svojimi lastnostmi in imenom, definiranim pod konstruktorjem. Čeprav barva ob zagonu morda ne bo omenjena znotraj predmeta, bo vedno na voljo na prototipu hierarhija . Zato bo hasOwnProperty() vedno vrnil true za ime, za barvo pa bo vrnil false.

Ko gre za zmogljivost, hasOwnProperty() deluje gladko, medtem ko se prebija skozi objekt z zankami. Do zdaj lahko rečemo, da če lastnosti posebej pripadajo predmetu. Nimajo nobene korelacije s prototipom. Predstavitev tega je mogoče prikazati s spodnjim delčkom kode.

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

Med uporabo metode hasOwnProperty() lahko postane neuporabna, ker se upodabljanje predmeta zgodi pri definiranju lastnosti z imenom hasOwnProperty. Če želite to podpreti, poskusite razumeti spodnji delček kode.

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

V zgornjem delčku kode je očitno, da harrypotter že ima hasOwnProperty. Tako ne bo nikoli poklical object.prototype.hasOwnProperty. Predvideva se, da bi to lahko naletelo na primere, ko bi lahko omogočilo klicanje, vendar lahko sčasoma ne uspe. Zato je vedno priporočljivo, da se zavedate možnosti klicev. Spodnji delček kode prikazuje njeno rešitev.

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

V zgornjem delčku kode je jasno, da harrypotter definira svoje hasOwnProperty . Nikoli ne bo klical Object.prototype.hasOwnProperty, ker obstaja možnost, da lahko vrne false, če naleti na nekaj primerov, ko je vrednost false in postane težko narediti stvari za vogalom. Za podporo te izjave si oglejte spodnji delček kode.

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

Podobno kot hasOwnProperty, obstaja še ena metoda, imenovana metoda 'in'. Uporablja se tudi za preverjanje, ali je ključ prisoten za predmet ali ne. Vendar je pomembno opozoriti, da je ključna razlika med hasOwnProperty in metodo in v tem, da metoda in ne bo sledila vrstnemu redu razlikovanja med lastnostmi, ki se podedujejo, in tistimi, ki so podedovane lastnosti, ustvarjene posebej za objekt. To je mogoče prikazati s spodnjim delčkom kode.

funkcija podniza java

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

V zgornjem delčku kode je očitno, da metoda 'in' sledi lastnosti konstruktorja Object.prototype, od koder se dedujejo vsi objekti.

Če dodam nekaj točk, imata obe metodi pomanjkljivost. Obe metodi nam zlahka data informacije o lastnosti, ki je že deklarirana, ne moreta pa nam povedati o lastnosti, ki vsebuje resnično vrednost.

Razmislite o naslednjem izrezku kode, ki prikazuje, kako obe metodi izvajata to rešitev.

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

Zaključek

V tej vadnici smo razpravljali o metodi hasOwnProperty() v JavaScriptu. Na splošno je ta metoda odlična izbira za večino razvijalcev, da se pozanimajo in se izognejo težavam v zvezi z nekaterimi posebnimi ključi, kot je konstruktor. Priporočljivo je, da če najdemo kateri koli predmet s katero koli lastnostjo, privzeto uporabi hasOwnProperty(). V primeru prisotnosti funkcije, namenjene klicu s preverjanjem predmeta za metodo toString(), moramo uporabiti in.