web-dev-qa-db-fra.com

Javascript ce qui est la propriété de hasOwnProperty?

if (someVar.hasOwnProperty('someProperty') ) {
 // do something();
} else {
 // do somethingElse();
}

Quelle est la bonne utilisation/explication de hasOwnProperty('someProperty')?

Pourquoi ne pouvons-nous pas simplement utiliser someVar.someProperty Pour vérifier si un objet someVar contient une propriété portant le nom someProperty?

Qu'est-ce qu'une propriété dans ce cas?

Quelle propriété est vérifiée par javascript?

javascriptobjecthasownproperty
58
FLY

hasOwnProperty renvoie une valeur booléenne indiquant si l'objet sur lequel vous l'appelez a une propriété avec le nom de l'argument. Par exemple:

var x = {
    y: 10
};
console.log(x.hasOwnProperty("y")); //true
console.log(x.hasOwnProperty("z")); //false

Cependant, il ne regarde pas la chaîne de prototypes de l'objet.

Il est utile de l'utiliser quand vous énumérez les propriétés d'un objet avec le for...in construire.

Si vous voulez voir tous les détails, le spécification ES5 est, comme toujours, un bon endroit pour regarder.

102
James Allardice

Voici une réponse courte et précise:

En javascript, chaque objet possède un ensemble de paires clé-valeur intégrées contenant des méta-informations sur l'objet. Lorsque vous parcourez toutes les paires clé-valeur en utilisant la construction/boucle for...in Pour un objet, vous parcourez également cette paire méta-informations clé-valeur (ce que vous ne voulez absolument pas).

enter image description here

En utilisant hasOwnPropery(property), filtrez ces boucles inutiles à travers des méta-informations et vérifiez directement que le paramètre property est propriété donnée par l'utilisateur dans l'objet ou non. Par filtre-out , je veux dire que hasOwnProperty(property) ne regarde pas si, property existe dans la chaîne de prototypes de Object aka méta-information.

Il retourne un booléen true/false Basé sur cela.

Voici un exemple:

var fruitObject = {"name": "Apple", "shape": "round", "taste": "sweet"};
console.log(fruitObject.hasOwnProperty("name"));  //true
console.log(Object.prototype.hasOwnProperty("toString");) //true because in above snapshot you can see, that there is a function toString in meta-information

J'espère que c'est clair!

16
Om Prakash Sao

il vérifie:

Renvoie une valeur booléenne indiquant si un objet a une propriété avec le nom spécifié.

La méthode hasOwnProperty renvoie true si l'objet a une propriété du nom spécifié, false si ce n'est pas le cas. Cette méthode ne vérifie pas si la propriété existe dans la chaîne de prototypes de l'objet. la propriété doit être un membre de l'objet lui-même.

Exemple: 

var s = new String("Sample");
document.write(s.hasOwnProperty("split"));                        //false 
document.write(String.prototype.hasOwnProperty("split"));         //true
11
Pranay Rana

Sommaire:

hasOwnProperty() est une fonction qui peut être appelée sur n'importe quel objet et prend une chaîne en tant qu'entrée. Il retourne un booléen qui est true si la propriété est située sur l'objet, sinon il retourne false. hasOwnProperty() est situé sur Object.prototype et donc disponible pour tout objet.

Exemple:

function Person(name) {
  this.name = name;
}

Person.prototype.age = 25;

const willem = new Person('willem');

console.log(willem.name); // property found on object
console.log(willem.age); // property found on prototype

console.log(willem.hasOwnProperty('name')); // name is on the object itself
console.log(willem.hasOwnProperty('age')); // age is not on the object itself

Dans cet exemple, un nouvel objet Personne est créé. Chaque personne a son propre nom qui est initialisé dans le constructeur. Cependant, l'âge n'est pas situé sur l'objet mais sur le prototype de l'objet. Par conséquent, hasOwnProperty() renvoie true pour nom et false pour âge.

Applications pratiques:

hasOwnProperty() peut être très utile lorsque vous passez en boucle sur un objet en utilisant une boucle for in. Vous pouvez vérifier si les propriétés proviennent de l'objet lui-même et non du prototype. Par exemple:

function Person(name, city) {
  this.name = name;
  this.city = city;
}

Person.prototype.age = 25;

const willem = new Person('Willem', 'Groningen');

for (let trait in willem) {
  console.log(trait, willem[trait]); // this loop through all properties including the prototype
}

console.log('\n');

for (let trait in willem) {
  if (willem.hasOwnProperty(trait)) { // this loops only through 'own' properties of the object
    console.log(trait, willem[trait]);
  }
}
6
Willem van der Veen

hasOwnProperty est une fonction Javascript normale qui prend un argument de chaîne.

Dans votre cas, somevar.hasOwnProperty ('someProperty') vérifie si la fonction somevar a une propriété ou non, elle renvoie true et false

Dire

function somevar() {
    this.someProperty= "Generic";
  }

function welcomeMessage()
{
    var somevar1= new somevar();
       if(somevar1.hasOwnProperty("name"))
{
alert(somevar1.hasOwnProperty("name"));// it will return true
}
}
2
Kunal Vashist

Vous utilisez object.hasOwnProperty (p) pour déterminer si l'objet a une propriété enumerablep -

object peut avoir son propre prototype, où des méthodes et des attributs "par défaut" sont attribués à chaque instance d'objet. hasOwnProperty renvoie true uniquement pour les propriétés spécifiquement définies dans le constructeur ou ajoutées ultérieurement à l'instance.

pour déterminer si p est défini du tout, n'importe où, pour l'objet, utilisez if (p instanceof object), où p correspond à une chaîne de nom de propriété.

Par exemple, tous les objets ont par défaut une méthode 'toString', mais celle-ci n'apparaîtra pas dans hasOwnProperty.

2
kennebec

Il vérifie si un objet a une propriété . Cela fonctionne de la même manière que if(obj.prop), autant que je sache.

0
visualidiot