V tomto návode uvidíme aspekty obmedzení a funkcií súvisiacich s hasOwnProperty() metóda v JavaScripte. V sekciách sa tiež dozvieme o jeho implementáciách a použití.
Úvod
In JavaScript , metóda hasOwnProperty() je definovaná ako vlastnosť na zabezpečenie toho, či objekt patrí do spomínaného projektu alebo nie. Ak sa zistí, že vlastnosť patrí rozpoznanému objektu, vráti výstup založený na booleovskom príkaze, t. j. pravda alebo nepravda.
np nuly
Syntax
object.hasOwnProperty(propname)
Argument
Nahrávanie:
Tu musíme zadať názov symbolu alebo reťazca, pretože toto je miesto podpery, kde sa kontroluje, či symbol alebo reťazec patrí objektu. To sa vykonáva pomocou metódy uvedenej nižšie.
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 Jedným dôležitým aspektom, ktorý je potrebné poznamenať, je, že metóda hasOwnProperty() vo všeobecnosti ignoruje zdedené vlastnosti. To znamená, že metóda vráti svoju hodnotu true, ak sa zistí, že objekt má nezdedenú vlastnosť a názov je špecifikovaný názvom propname. Ak vráti false, znamená to, že objekt nemá žiadnu vlastnosť so zadaným názvom, alebo danú vlastnosť zdedil z objektu 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
Ďalšou ďalšou výhodou použitia metódy hasOwnProperty() je to, že dokáže inicializovať objekt na základe konceptu odovzdania reťazca ako predvoleného argumentu. Ak sa zistí, že hodnota je pre objekt dostupná, musí rýchlo odpovedať hodnotou true. V opačnom prípade vráti hodnotu false, ak sa nenájde. Dá sa to demonštrovať pomocou útržku kódu uvedeného nižšie.
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 Vo vyššie uvedenom úryvku kódu vytvára premenná nový objekt, Auto . Teraz je možné konštatovať, že auto je iniciované a má svoje vlastnosti a meno definované pod konštruktorom. Hoci farba nemusí byť uvedená v objekte pri spustení, bude vždy k dispozícii na prototype hierarchia . Preto hasOwnProperty() vráti hodnotu true vždy pre názov, ale pre farbu vráti hodnotu false.
Pokiaľ ide o výkon, hasOwnProperty() funguje hladko, zatiaľ čo prechádza cez objekt pomocou slučiek. Teraz môžeme povedať, že ak vlastnosti konkrétne patria objektu. Nemajú žiadnu koreláciu s prototypom. Demonštrácia tohto môže byť ukázaná pomocou úryvku kódu uvedeného nižšie.
// 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: Pri používaní metódy hasOwnProperty() sa môže stať zbytočnou, pretože k vykresleniu objektu dôjde pri definovaní vlastnosti s názvom hasOwnProperty. Aby ste to podporili, skúste porozumieť útržku kódu uvedenému nižšie.
var harrypotter = { hasOwnProperty: function() { return true; } }; // Outputs: true console.log(harrypotter.hasOwnProperty('ridikulus')); Vo vyššie uvedenom úryvku kódu je zrejmé, že harrypotter už má hasOwnProperty. Preto nikdy nezavolá objekt object.prototype.hasOwnProperty. Predpokladá sa, že to môže nastať v prípadoch, keď to umožní uskutočniť hovor, ale nakoniec to môže zlyhať. Preto sa vždy odporúča byť si vedomý možnosti hovorov. Nižšie uvedený útržok kódu ukazuje jeho riešenie.
// Returns false Object.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Vo vyššie uvedenom úryvku kódu je jasné, že harrypotter definuje svoje vlastné hasOwnProperty . Nikdy nevykoná volania Object.prototype.hasOwnProperty, pretože existuje možnosť, že sa môže vrátiť false, ak narazí na prípady, keď je hodnota nepravdivá a bude ťažké zabezpečiť, aby veci fungovali za rohom. Na podporu tohto tvrdenia si pozrite úryvok kódu uvedený nižšie.
// Returns false Obje ct.prototype.hasOwnProperty.call(harrypotter, 'ridikulus');
Podobne ako pri hasOwnProperty existuje aj iná metóda nazývaná metóda „in“. Používa sa tiež na kontrolu, či je kľúč k objektu prítomný alebo nie. Je však dôležité poznamenať, že kľúčový rozdiel medzi metódou hasOwnProperty a in spočíva v tom, že metóda in nebude dodržiavať poradie rozlišovania medzi vlastnosťami, ktoré sa zdedia, a zdedenými vlastnosťami, ktoré sú špeciálne vytvorené pre objekt. Dá sa to zobraziť pomocou útržku kódu uvedeného nižšie.
jarné sv
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); Vo vyššie uvedenom úryvku kódu je zrejmé, že metóda 'in' nasleduje po vlastnosti konštruktora Object.prototype, odkiaľ sa dedia všetky objekty.
Aby sme pridali niekoľko bodov, oba spôsoby majú nevýhodu. Obe metódy nám môžu ľahko poskytnúť informácie o nehnuteľnosti, ktorá už bola deklarovaná, ale nemôžu nám povedať o nehnuteľnosti, ktorá obsahuje skutočnú hodnotu.
Zvážte nasledujúci útržok kódu, ktorý ukazuje, ako obe metódy prinášajú toto riešenie.
// 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); Záver
V tomto návode sme diskutovali o metóde hasOwnProperty() v JavaScripte. Vo všeobecnosti je táto metóda skvelou voľbou pre väčšinu vývojárov, aby sa spýtali a vyhli sa problémom súvisiacim s niektorými špeciálnymi kľúčmi, ako je konštruktor. Odporúča sa, že ak nájdeme akýkoľvek objekt s nejakou vlastnosťou, štandardne použije hasOwnProperty(). V prípade prítomnosti funkcie určenej na uskutočnenie volania kontrolou objektu na metódu toString(), musíme použiť in.