Tässä opetusohjelmassa näemme rajoituksiin ja toimintoihin liittyvät näkökohdat hasOwnProperty() menetelmä JavaScriptissä. Osioissa opimme myös sen toteutuksista ja käytöstä.
Johdanto
Sisään JavaScript , hasOwnProperty()-metodi määritellään ominaisuudeksi, jolla varmistetaan, kuuluuko objekti mainittuun projektiin vai ei. Jos havaitaan, että ominaisuus kuuluu tunnistetulle objektille, sen tulee palauttaa Boolen lauseeseen perustuva tulos, eli tosi tai epätosi.
Syntaksi
object.hasOwnProperty(propname)
Perustelu
Äänite:
Tässä meidän on välitettävä symboli tai merkkijonon nimi, koska tämä on tukikohta, jossa tarkistetaan, kuuluuko symboli tai merkkijono objektiin. Tämä tehdään alla olevalla menetelmällä.
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 Yksi tärkeä näkökohta tässä on se, että menetelmä hasOwnProperty() jättää yleensä huomiotta perityt ominaisuudet. Tämä tarkoittaa, että menetelmä palauttaa sen tosi, jos objektilla havaitaan olevan ei-peritty ominaisuus ja nimi on määritelty propnamella. Jos se palauttaa false, se tarkoittaa, että objektilla ei ole mitään ominaisuutta määritetyllä nimellä tai se on perinyt ominaisuuden proptypen objektilta.
// 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
Toinen hasOwnProperty()-menetelmän käytön lisäetu on, että se voi alustaa objektin noudattamalla merkkijonon välittämistä oletusargumenttina. Sen tulee vastata nopeasti tosi, jos arvo on kohteen käytettävissä. Muussa tapauksessa se palauttaa epätosi, jos sitä ei löydy. Se voidaan osoittaa alla olevan koodinpätkän avulla.
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 Yllä annetussa koodinpätkässä muuttuja luo uuden objektin, Auto . Nyt voidaan todeta, että Auto on käynnistetty ja sen ominaisuudet ja nimi on määritelty rakentajan alla. Vaikka väriä ei ehkä mainita objektissa aloitettaessa, se on aina saatavilla prototyyppissä hierarkia . Siksi hasOwnProperty() palauttaa aina arvon tosi nimelle, mutta värille se palauttaa epätosi.
Mitä tulee suorituskykyyn, hasOwnProperty() toimii sujuvasti ja kulkee objektin läpi silmukoiden avulla. Tähän mennessä voidaan sanoa, että jos ominaisuudet kuuluvat nimenomaan objektiin. Niillä ei ole mitään korrelaatiota prototyypin kanssa. Tämä voidaan osoittaa käyttämällä alla olevaa koodinpätkää.
// 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: Käytettäessä hasOwnProperty()-metodia se voi muuttua hyödyttömäksi, koska objektin renderöinti tapahtuu määritettäessä ominaisuutta nimeltä hasOwnProperty. Tukeaksesi tätä yritä ymmärtää alla oleva koodinpätkä.
var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); Yllä olevassa koodinpätkässä on selvää, että harrypotterilla on jo hasOwnProperty. Siten se ei koskaan soita objektiin object.prototype.hasOwnProperty. Oletetaan, että tämä saattaa kohdata tapauksia, joissa se voi sallia puhelun soittamisen, mutta se voi lopulta epäonnistua. Joten on aina suositeltavaa olla tietoinen puhelujen mahdollisuudesta. Alla oleva koodinpätkä näyttää sen kiertotavan.
// Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Yllä olevassa koodinpätkässä on selvää, että harrypotter määrittelee omansa onOma Property . Se ei koskaan soita Object.prototype.hasOwnPropertylle, koska on mahdollista, että se voi palauttaa epätosi, jos se kohtaa joissakin tapauksissa, joissa arvo on epätosi ja asioiden saaminen toimimaan nurkan takana on vaikeaa. Tämän väitteen tueksi katso alla oleva koodinpätkä.
// Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
HasOwnPropertyn tapaan on olemassa toinen menetelmä, jota kutsutaan 'in'-menetelmäksi. Sitä käytetään myös tarkistamaan, onko objektin avain olemassa vai ei. On kuitenkin tärkeää huomata, että avainero hasOwnProperty- ja in-metodin välillä piilee siinä, että in-menetelmä ei seuraa järjestystä, jossa erotetaan toisistaan perittävät ominaisuudet ja ne, jotka on erityisesti luotu objektille. Tämä voidaan näyttää alla olevan koodinpätkän avulla.
ubuntu build välttämätön
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); Yllä olevassa koodinpätkässä on selvää, että 'in'-metodi seuraa Object.prototypen konstruktoriominaisuutta, josta kaikki objektit peritään.
Muutaman pisteen lisäämiseksi molemmilla menetelmillä on haitta. Molemmat menetelmät voivat helposti antaa meille tiedon jo ilmoitetusta omaisuudesta, mutta ne eivät voi kertoa meille todellista arvoa sisältävästä omaisuudesta.
Harkitse seuraavaa koodinpätkää, joka näyttää, kuinka molemmat menetelmät suorittavat tämän kiertotavan.
// 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); Johtopäätös
Tässä opetusohjelmassa keskustelimme JavaScriptin hasOwnProperty()-menetelmästä. Yleensä tämä menetelmä on loistava valinta useimmille kehittäjille tiedustellakseen ja välttääkseen ongelmia, jotka liittyvät joihinkin erikoisavaimiin, kuten rakentaja. On suositeltavaa, että jos löydämme objektin, jolla on jokin ominaisuus, se käyttää oletuksena hasOwnProperty():tä. Jos käytössä on funktio, joka on tarkoitettu kutsumaan tarkistamalla objekti toString()-metodille, meidän on käytettävä in.