U ovom vodiču vidjet ćemo aspekte ograničenja i funkcije povezane s hasOwnProperty() metoda u JavaScriptu. Također ćemo naučiti o njegovim implementacijama i upotrebi u odjeljcima.

vuk ili lisica

Uvod

U JavaScript , metoda hasOwnProperty() definirana je kao svojstvo kojim se osigurava pripada li objekt spomenutom projektu ili ne. Ako se utvrdi da svojstvo pripada prepoznatom objektu, tada će vratiti izlaz temeljen na Booleovom iskazu, tj. istinito ili lažno.

Sintaksa

 object.hasOwnProperty(propname) 

Argument

Snimanje:

Ovdje trebamo proslijediti simbol ili ime niza jer je to mjesto prop-a gdje se provjerava pripada li simbol ili niz objektu. To se radi pomoću dolje navedene metode.

 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 

Jedan važan aspekt koji ovdje treba imati na umu je da metoda hasOwnProperty() općenito zanemaruje naslijeđena svojstva. To znači da će metoda vratiti svoj true ako se ustanovi da objekt ima svojstvo koje nije naslijeđeno, a ime je specificirano propname-om. Ako vrati false, to znači da objekt nema svojstvo s navedenim imenom ili je naslijedio svojstvo od objekta proptype-a.

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

Još jedna dodatna prednost korištenja metode hasOwnProperty() jest ta da može inicijalizirati objekt prateći koncept prosljeđivanja niza kao zadanog argumenta. Brzo će odgovoriti s true ako se ustanovi da je vrijednost dostupna objektu. U protivnom, vratit će false ako nije pronađen. Može se demonstrirati korištenjem isječka koda danog u nastavku.

 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 

U gore navedenom isječku koda, varijabla stvara novi objekt, Automobil . Sada se može reći da je automobil pokrenut sa svojim svojstvima i imenom definiranim pod konstruktorom. Iako boja možda neće biti spomenuta unutar objekta kada se pokrene, uvijek će biti dostupna na prototipu hijerarhija . Stoga će hasOwnProperty() uvijek vratiti true za ime, ali će za boju vratiti false.

Kada je u pitanju izvedba, hasOwnProperty() radi glatko dok se probija kroz objekt s petljama. Do sada možemo reći da ako svojstva konkretno pripadaju objektu. Oni nemaju nikakve veze s prototipom. Demonstracija ovoga može se prikazati pomoću isječka koda danog u nastavku.

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

Dok koristite metodu hasOwnProperty(), ona može postati beskorisna jer se renderiranje objekta događa prilikom definiranja svojstva pod nazivom hasOwnProperty. Da biste to podržali, pokušajte razumjeti isječak koda dat u nastavku.

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

U gornjem isječku koda vidljivo je da harrypotter već ima hasOwnProperty. Stoga nikada neće uputiti poziv object.prototype.hasOwnProperty. Pretpostavlja se da bi ovo moglo naići na slučajeve u kojima bi moglo dopustiti upućivanje poziva, ali na kraju može biti neuspješno. Stoga je uvijek preporučljivo biti svjestan mogućnosti poziva. Donji isječak koda pokazuje njegovo zaobilazno rješenje.

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

U gornjem isječku koda jasno je da harrypotter definira svoje hasOwnProperty . Nikada neće pozivati ​​Object.prototype.hasOwnProperty jer postoji mogućnost da može vratiti false ako naiđe na neke slučajeve u kojima je vrijednost false i postaje teško učiniti da stvari rade iza ugla. Kako biste potvrdili ovu izjavu, pogledajte donji isječak koda.

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

Slično hasOwnProperty, postoji još jedna metoda koja se zove 'in' metoda. Također se koristi za provjeru postoji li ključ za objekt ili ne. Međutim, važno je napomenuti da je ključna razlika između hasOwnProperty i metode in leži u činjenici da metoda in neće slijediti redoslijed razlikovanja između svojstava koja se nasljeđuju i onih koja su naslijeđena svojstva posebno stvorena za objekt. To se može prikazati pomoću isječka koda danog u nastavku.

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

U gornjem isječku koda vidljivo je da metoda 'in' slijedi svojstvo konstruktora Object.prototype odakle se nasljeđuju svi objekti.

Da dodamo nekoliko točaka, obje metode imaju nedostatak. Obje nam metode mogu lako dati informacije o svojstvu koje je već deklarirano, ali nam ne mogu reći o svojstvu koje sadrži stvarnu vrijednost.

Razmotrite sljedeći isječak koda koji pokazuje kako obje metode nose ovo zaobilazno rješenje.

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

U ovom vodiču raspravljali smo o metodi hasOwnProperty() u JavaScriptu. Općenito, ova je metoda izvrstan izbor za većinu programera da se raspitaju i izbjegnu probleme koji se odnose na neke posebne tipke poput konstruktora. Preporuča se da, ako nađemo bilo koji objekt s bilo kojim svojstvom, koristi hasOwnProperty() prema zadanim postavkama. U slučaju prisutnosti funkcije namijenjene upućivanju poziva provjerom objekta za metodu toString(), moramo koristiti in.