Considérer:

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.somePropertypour vérifier si un objet someVarcontient une propriété avec un nom someProperty?

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

Quelle propriété ce JavaScript vérifie-t-il?

hasOwnPropertyrenvoie une valeur booléenne indiquant si l'objet sur lequel vous l'appelez possède 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 prototype de l'objet.

Il est utile de l'utiliser lorsque vous énumérez les propriétés d'un objet avec la for...inconstruction.

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

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 for...inconstruction / boucle pour un objet, vous parcourez également ces paires clé-valeur de méta-informations (ce que vous ne voulez certainement pas).

En utilisant des hasOwnPropery(property) filtres, ces boucles inutiles dans les méta-informations et vérifient directement que le paramètre propertyest une propriété donnée par l'utilisateur dans l'objet ou non. Par filtrage , je veux dire, cela hasOwnProperty(property)ne regarde pas si, propertyexiste dans la chaîne de prototypes d'Object, autrement dit les méta-informations.

Il renvoie un booléen true/falsebasé 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!

Il vérifie:

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

Le hasOwnProperty méthode renvoie true si l'objet a une propriété du nom spécifié, false dans le cas contraire. 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 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

Sommaire:

hasOwnProperty()est une fonction qui peut être appelée sur n'importe quel objet et prend une chaîne comme entrée. Il renvoie un booléen qui est truesi la propriété est située sur l'objet, sinon il retourne false. hasOwnProperty()est situé sur Object.prototypeet 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 ne se situe pas sur l'objet mais sur le prototype de l'objet. Par conséquent hasOwnProperty()revient truepour le nom et falsepour l'âge.

Applications pratiques:

hasOwnProperty()peut être très utile lors d'une boucle sur un objet à l'aide d'une for inboucle. Vous pouvez vérifier avec lui 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 loops 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]);
  }
}

Vous utilisez object.hasOwnProperty ( p ) pour déterminer si un objet a une propriété énumérable p -

Un objet peut avoir son propre prototype, où des méthodes et des attributs «par défaut» sont attribués à chaque instance de l'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 s'évalue en une chaîne de nom de propriété.

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

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

Dans votre cas, somevar.hasOwnProperty('someProperty')il vérifie que la somevarfonction a someproperyou non - il renvoie vrai et faux.

Dire

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

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

hasOwnPropertyest une bonne façon de vérifier qu'un objet a une propriété ou non. someVar.somePropertyne peut pas être utilisé comme alternative à cette situation. La condition suivante montrera une bonne différence:

const someVar = { isFirst: false };


// The condition is true, because 'someVar' has property 'isFirst'
if (someVar.hasOwnProperty('isFirst')) {
  // Code runs
}


// The condition is false, because 'isFirst' is false.
if (someVar.isFirst) {
  // Code does not runs here
}

Par conséquent, someVar.isFirstne peut pas être utilisé comme alternative à someVar.hasOwnProperty('isFirst').

Scène A:

const objA = { a: 1, b: 2 }
for (const key in objA) {
  if (objA.hasOwnProperty(key)) {
    console.log(objA[key])
  }
}

    Output

    1
    2

Scène B:

const objB = {
  a: 1,
  b: 2,
  hasOwnProperty() {
    return false
  }
}

for (const key in objB) {
  if (objB.hasOwnProperty(key)) {
    console.log(objB[key])
  }
}

    Outputs nothing

Parce que JavaScript ne protège pas la propriété de hasOwnProperty. Vous pouvez donc l'utiliser comme ceci:

for (const key in objB) {
  if (Object.prototype.hasOwnProperty.call(obj, key)) {
    console.log(objB[key])
  }
}

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