V tomto tutoriálu uvidíme aspekty omezení a funkcí souvisejících s hasOwnProperty() metoda v JavaScriptu. V sekcích se také dozvíme o jeho implementacích a použití.

Úvod

v JavaScript , metoda hasOwnProperty() je definována jako vlastnost, která zajišťuje, zda objekt patří do zmíněného projektu či nikoli. Pokud se zjistí, že vlastnost patří k rozpoznanému objektu, vrátí výstup založený na booleovských příkazech, tj. true nebo false.

Syntax

 object.hasOwnProperty(propname) 

Argument

Záznam:

Zde musíme předat symbol nebo název řetězce, protože to je místo prop, kde se kontroluje, zda symbol nebo řetězec patří k objektu. To se provádí pomocí níže uvedené metody.

 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 aspektem, který je zde třeba poznamenat, je, že metoda hasOwnProperty() obecně ignoruje zděděné vlastnosti. To znamená, že metoda vrátí hodnotu true, pokud se zjistí, že objekt má nezděděnou vlastnost a jméno je určeno propname. Pokud vrátí hodnotu false, znamená to, že objekt nemá žádnou vlastnost se zadaným názvem, nebo vlastnost zdědil 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 

Další výhodou použití metody hasOwnProperty() je to, že dokáže inicializovat objekt na základě konceptu předání řetězce jako výchozího argumentu. Pokud se zjistí, že hodnota je pro objekt dostupná, musí rychle reagovat s true. V opačném případě vrátí hodnotu false, pokud nebude nalezen. Lze to demonstrovat pomocí úryvku kódu uvedeného níže.

 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 

Ve výše uvedeném úryvku kódu vytvoří proměnná nový objekt, Auto . Nyní lze konstatovat, že auto je iniciováno a má své vlastnosti a jméno definované pod konstruktorem. Přestože barva nemusí být v objektu při spuštění uvedena, bude vždy k dispozici na prototypu hierarchie . Proto hasOwnProperty() vrátí hodnotu true vždy pro název, ale pro barvu vrátí hodnotu false.

Pokud jde o výkon, hasOwnProperty() funguje hladce, zatímco prochází objektem pomocí smyček. Nyní můžeme říci, že pokud vlastnosti konkrétně patří k objektu. Nemají žádnou korelaci s prototypem. Demonstraci toho lze ukázat pomocí úryvku kódu uvedeného níže.

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

Při použití metody hasOwnProperty() se může stát zbytečnou, protože k vykreslení objektu dochází při definování vlastnosti s názvem hasOwnProperty. Chcete-li to podpořit, zkuste porozumět níže uvedenému fragmentu kódu.

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

Ve výše uvedeném úryvku kódu je zřejmé, že harrypotter již má hasOwnProperty. Nikdy tedy nezavolá objekt object.prototype.hasOwnProperty. Předpokládá se, že to může nastat v případech, kdy to umožní uskutečnit hovor, ale nakonec to může selhat. Vždy se tedy doporučuje být si vědom možnosti volání. Níže uvedený fragment kódu ukazuje jeho řešení.

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

Ve výše uvedeném úryvku kódu je zřejmé, že harrypotter definuje své vlastní hasOwnProperty . Nikdy neprovede volání Object.prototype.hasOwnProperty, protože existuje možnost, že může vrátit hodnotu false, pokud narazí na případy, kdy je hodnota nepravdivá a bude obtížné zajistit, aby věci fungovaly za rohem. Chcete-li toto tvrzení podpořit, podívejte se na níže uvedený fragment kódu.

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

Podobně jako hasOwnProperty existuje další metoda nazvaná metoda „in“. Používá se také ke kontrole, zda je pro objekt přítomen klíč nebo ne. Je však důležité poznamenat, že klíčový rozdíl mezi metodou hasOwnProperty a in spočívá ve skutečnosti, že metoda in nebude dodržovat pořadí rozlišování mezi vlastnostmi, které se zdědí, a zděděnými vlastnostmi, které jsou speciálně vytvořeny pro objekt. To lze zobrazit pomocí fragmentu kódu uvedeného níže.

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

Ve výše uvedeném úryvku kódu je zřejmé, že metoda 'in' následuje vlastnost konstruktoru Object.prototype, odkud se dědí všechny objekty.

Abychom přidali pár bodů, oba způsoby mají nevýhodu. Obě metody nám mohou snadno poskytnout informace o nemovitosti, která již byla deklarována, ale nemohou nám říci o nemovitosti obsahující skutečnou hodnotu.

Zvažte následující fragment kódu, který ukazuje, jak obě metody nesou toto zástupné řešení.

 // 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ávěr

V tomto tutoriálu jsme diskutovali o metodě hasOwnProperty() v JavaScriptu. Obecně je tato metoda skvělou volbou pro většinu vývojářů, aby se zeptali a vyhnuli se problémům souvisejícím s některými speciálními klíči, jako je konstruktor. Doporučuje se, že pokud najdeme nějaký objekt s nějakou vlastností, použije ve výchozím nastavení hasOwnProperty(). V případě přítomnosti funkce určené k provedení volání kontrolou objektu pro metodu toString(), musíme použít in.