Dans ce tutoriel, nous verrons les aspects de limitations et de fonctions liés au hasOwnProperty() méthode en JavaScript. Nous découvrirons également ses implémentations et son utilisation dans les sections.

Introduction

Dans Javascript , la méthode hasOwnProperty() est définie comme une propriété pour garantir si l'objet appartient ou non au projet mentionné. S'il s'avère que la propriété appartient à un objet reconnu, elle doit alors renvoyer une sortie basée sur une instruction booléenne, c'est-à-dire vrai ou faux.

Syntaxe

 object.hasOwnProperty(propname) 

Argument

Enregistrement:

Ici, nous devons passer le symbole ou le nom de la chaîne car c'est l'endroit de prop où il est vérifié si le symbole ou la chaîne appartient à l'objet. Cela se fait en utilisant la méthode indiquée ci-dessous.

 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 

Un aspect important à noter ici est que la méthode hasOwnProperty() ignore généralement les propriétés héritées. Cela signifie que cette méthode doit renvoyer la valeur true si l'objet possède une propriété non héritée et que le nom est spécifié par propname. S'il renvoie false, cela signifie que l'objet n'a aucune propriété avec un nom spécifié ou qu'il a hérité de la propriété de l'objet du 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 

Un autre avantage supplémentaire de l'utilisation de la méthode hasOwnProperty() est qu'elle peut initialiser un objet en suivant le concept de transmission d'une chaîne comme argument par défaut. Il doit répondre rapidement avec true si la valeur s'avère disponible pour l'objet. Sinon, il retournera false s'il n'est pas trouvé. Cela peut être démontré à l’aide de l’extrait de code ci-dessous.

 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 

Dans l'extrait de code donné ci-dessus, la variable crée un nouvel objet, Voiture . On peut maintenant affirmer que la voiture est lancée avec ses propriétés et son nom définis sous le constructeur. Bien que la couleur puisse ne pas être mentionnée dans l'objet au moment de son lancement, elle sera toujours disponible sur le prototype. hiérarchie . Par conséquent, hasOwnProperty() renverra toujours true pour le nom, mais pour la couleur, il renverra false.

En ce qui concerne les performances, hasOwnProperty() fonctionne correctement tout en parcourant l'objet avec des boucles. A présent, nous pouvons dire que si les propriétés appartiennent spécifiquement à l’objet. Ils n'ont aucune corrélation avec le prototype. La démonstration de ceci peut être montrée à l’aide de l’extrait de code ci-dessous.

cours de mathématiques java

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

Lors de l'utilisation de la méthode hasOwnProperty(), elle peut s'avérer inutile car le rendu de l'objet se produit lors de la définition d'une propriété nommée hasOwnProperty. Pour prendre en charge cela, essayez de comprendre l’extrait de code ci-dessous.

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

Dans l'extrait de code ci-dessus, il est évident que Harrypotter possède déjà hasOwnProperty. Ainsi, il n’appellera jamais object.prototype.hasOwnProperty. On suppose que cela pourrait rencontrer des cas où cela permettrait de passer un appel, mais cela pourrait éventuellement échouer. Il est donc toujours recommandé d’être conscient de la possibilité d’appels. L'extrait de code ci-dessous montre sa solution de contournement.

amrita rao acteur

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

Dans l'extrait de code ci-dessus, il est clair qu'Harrypotter définit son propre hasOwnProperty . Il n'appellera jamais Object.prototype.hasOwnProperty car il est possible qu'il renvoie false s'il rencontre des cas où la valeur est fausse et qu'il devient difficile de faire fonctionner les choses au coin de la rue. Pour étayer cette déclaration, consultez l’extrait de code ci-dessous.

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

Semblable à hasOwnProperty, il existe une autre méthode appelée méthode « in ». Il permet également de vérifier si la clé est présente ou non pour l'objet. Cependant, il est important de noter que la principale différence entre hasOwnProperty et la méthode in réside dans le fait que la méthode in ne suivra pas l'ordre de distinction entre les propriétés héritées et celles héritées qui sont spécialement créées pour l'objet. Cela peut être montré à l’aide de l’extrait de code ci-dessous.

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

Dans l'extrait de code ci-dessus, il est évident que la méthode « in » suit la propriété constructeur de Object.prototype d'où tous les objets sont hérités.

Pour ajouter quelques points, les deux méthodes présentent un inconvénient. Les deux méthodes peuvent facilement nous donner des informations sur une propriété déjà déclarée mais elles ne peuvent pas nous renseigner sur la propriété contenant une valeur réelle.

Considérez l'extrait de code suivant qui montre comment les deux méthodes appliquent cette solution de contournement.

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

Conclusion

Dans ce didacticiel, nous avons discuté de la méthode hasOwnProperty() en JavaScript. En général, cette méthode est un excellent choix pour la plupart des développeurs qui souhaitent se renseigner et éviter les problèmes liés à certaines clés spéciales comme le constructeur. Il est recommandé que si nous trouvons un objet ayant une propriété, il utilise hasOwnProperty() par défaut. En cas de présence d'une fonction destinée à effectuer un appel en vérifiant l'objet pour la méthode toString(), il faut utiliser in.