In diesem Tutorial werden wir die Aspekte der Einschränkungen und Funktionen im Zusammenhang mit dem sehen hasOwnProperty() Methode in JavaScript. In den Abschnitten erfahren Sie auch mehr über seine Implementierungen und Verwendung.

Einführung

In JavaScript , wird die Methode hasOwnProperty() als Eigenschaft definiert, um sicherzustellen, ob das Objekt zum genannten Projekt gehört oder nicht. Wenn festgestellt wird, dass die Eigenschaft zu einem erkannten Objekt gehört, wird eine auf einer booleschen Anweisung basierende Ausgabe zurückgegeben, d. h. wahr oder falsch.

Syntax

 object.hasOwnProperty(propname) 

Streit

Aufzeichnung:

Hier müssen wir das Symbol oder den String-Namen übergeben, da dies die Stelle von prop ist, an der geprüft wird, ob das Symbol oder der String zum Objekt gehört. Dies geschieht mit der unten angegebenen Methode.

 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 

Ein wichtiger Aspekt hierbei ist, dass die Methode hasOwnProperty() im Allgemeinen geerbte Eigenschaften ignoriert. Dies bedeutet, dass die Methode ihren Wert „true“ zurückgibt, wenn festgestellt wird, dass das Objekt eine nicht geerbte Eigenschaft hat und der Name durch propname angegeben wird. Wenn es „false“ zurückgibt, bedeutet dies, dass das Objekt keine Eigenschaft mit einem angegebenen Namen hat oder die Eigenschaft vom Objekt des Proptypes geerbt hat.

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

Ein weiterer zusätzlicher Vorteil der Verwendung der Methode hasOwnProperty() besteht darin, dass sie ein Objekt initialisieren kann, indem sie dem Konzept der Übergabe einer Zeichenfolge als Standardargument folgt. Es muss schnell mit „true“ antworten, wenn festgestellt wird, dass der Wert für das Objekt verfügbar ist. Andernfalls wird false zurückgegeben, wenn es nicht gefunden wird. Dies kann anhand des unten angegebenen Codeausschnitts demonstriert werden.

 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 

Im oben angegebenen Codeausschnitt erstellt die Variable ein neues Objekt. Auto . Es kann nun angegeben werden, dass das Auto initiiert wird und seine Eigenschaften und sein Name im Konstruktor definiert werden. Obwohl die Farbe bei der Initiierung möglicherweise nicht im Objekt erwähnt wird, ist sie beim Prototypen immer verfügbar Hierarchie . Daher gibt hasOwnProperty() für den Namen immer true zurück, für die Farbe jedoch false.

Wenn es um die Leistung geht, funktioniert hasOwnProperty() reibungslos, während es sich mit Schleifen durch das Objekt bewegt. Mittlerweile können wir das sagen, wenn die Eigenschaften spezifisch zum Objekt gehören. Sie haben keine Korrelation mit dem Prototyp. Die Demonstration hierfür kann anhand des unten angegebenen Codeausschnitts gezeigt werden.

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

Bei Verwendung der Methode hasOwnProperty() kann es sein, dass sie unbrauchbar wird, da die Darstellung des Objekts beim Definieren einer Eigenschaft namens hasOwnProperty erfolgt. Um dies zu unterstützen, versuchen Sie, den unten angegebenen Codeausschnitt zu verstehen.

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

Im obigen Codeausschnitt ist ersichtlich, dass Harry Potter bereits über hasOwnProperty verfügt. Daher wird niemals die object.prototype.hasOwnProperty aufgerufen. Es wird davon ausgegangen, dass es dabei zu Fällen kommen kann, in denen zwar ein Anruf möglich ist, dies aber letztendlich fehlschlägt. Es wird daher immer empfohlen, sich der Möglichkeit von Anrufen bewusst zu sein. Der folgende Codeausschnitt zeigt die Problemumgehung.

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

Im obigen Codeausschnitt ist klar, dass Harry Potter seinen eigenen Code definiert hasOwnProperty . Es werden niemals Aufrufe an Object.prototype.hasOwnProperty durchgeführt, da die Möglichkeit besteht, dass es „false“ zurückgibt, wenn es auf einige Fälle stößt, in denen der Wert „false“ ist, und es schwierig wird, die Dinge sofort zum Laufen zu bringen. Zur Unterstützung dieser Aussage sehen Sie sich den unten angegebenen Codeausschnitt an.

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

Ähnlich wie hasOwnProperty gibt es eine weitere Methode namens „in“-Methode. Es wird auch verwendet, um zu überprüfen, ob der Schlüssel für das Objekt vorhanden ist oder nicht. Es ist jedoch wichtig zu beachten, dass der Hauptunterschied zwischen hasOwnProperty und der in-Methode darin besteht, dass die in-Methode nicht der Reihenfolge folgt, in der zwischen den Eigenschaften, die geerbt werden, und den geerbten Eigenschaften, die speziell für das Objekt erstellt werden, unterschieden wird. Dies kann anhand des unten angegebenen Codeausschnitts gezeigt werden.

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

Im obigen Codeausschnitt ist ersichtlich, dass die Methode „in“ der Konstruktoreigenschaft von Object.prototype folgt, von der alle Objekte geerbt werden.

Um ein paar Punkte hinzuzufügen: Beide Methoden haben einen Nachteil. Beide Methoden können uns problemlos Informationen über eine bereits deklarierte Immobilie liefern, aber sie können uns nicht sagen, ob die Immobilie einen tatsächlichen Wert enthält.

Betrachten Sie den folgenden Codeausschnitt, der zeigt, wie beide Methoden diese Problemumgehung ermöglichen.

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

Abschluss

In diesem Tutorial haben wir die Methode hasOwnProperty() in JavaScript besprochen. Im Allgemeinen ist diese Methode für die meisten Entwickler eine gute Wahl, um Probleme im Zusammenhang mit einigen Sonderschlüsseln wie dem Konstruktor abzufragen und zu vermeiden. Wenn wir ein Objekt mit einer Eigenschaft finden, wird empfohlen, standardmäßig hasOwnProperty() zu verwenden. Falls eine Funktion vorhanden ist, die einen Aufruf durchführen soll, indem das Objekt auf die toString()-Methode überprüft wird, müssen wir in verwenden.