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

Was ist die richtige Verwendung / Erklärung hasOwnProperty('someProperty')?

Warum können wir nicht einfach someVar.somePropertyüberprüfen, ob ein Objekt someVareine Eigenschaft mit Namen enthält someProperty?

Was ist in diesem Fall eine Immobilie?

Welche Eigenschaft prüft dieses Javascript?

hasOwnPropertyGibt einen booleschen Wert zurück, der angibt, ob das Objekt, für das Sie es aufrufen, eine Eigenschaft mit dem Namen des Arguments hat. Beispielsweise:

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

Es wird jedoch nicht die Prototypkette des Objekts betrachtet.

Es ist nützlich, es zu verwenden, wenn Sie die Eigenschaften eines Objekts mit dem for...inKonstrukt auflisten.

Wenn Sie alle Details sehen möchten, ist die ES5-Spezifikation wie immer ein guter Ort, um nachzuschauen .

Hier ist eine kurze und präzise Antwort:

In Javascript verfügt jedes Objekt über eine Reihe integrierter Schlüssel-Wert-Paare, die Metainformationen zum Objekt enthalten. Wenn Sie alle Schlüssel-Wert-Paare mit for...inKonstrukt / Schleife für ein Objekt durchlaufen, durchlaufen Sie auch diese Meta-Informationen-Schlüssel-Wert-Paare (was Sie definitiv nicht wollen).

Durch hasOwnPropery(property) Herausfiltern dieser unnötigen Schleifen durch Metainformationen und direktes Überprüfen, ob der Parameter propertyeine vom Benutzer angegebene Eigenschaft im Objekt ist oder nicht. Mit Herausfiltern meine ich, das hasOwnProperty(property)sieht nicht so aus, als ob propertyes in der Prototypenkette von Object, auch bekannt als Meta-Information, existiert.

Darauf true/falsebasierend wird ein Boolescher Wert zurückgegeben .

Hier ist ein Beispiel:

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

Ich hoffe es ist klar!

es prüft:

Gibt einen booleschen Wert zurück, der angibt, ob ein Objekt eine Eigenschaft mit dem angegebenen Namen hat

Die hasOwnProperty- Methode gibt true zurück, wenn das Objekt eine Eigenschaft mit dem angegebenen Namen hat, false, wenn dies nicht der Fall ist. Diese Methode überprüft nicht, ob die Eigenschaft in der Prototypenkette des Objekts vorhanden ist. Die Eigenschaft muss Mitglied des Objekts selbst sein.

Beispiel:

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

Zusammenfassung:

hasOwnProperty()ist eine Funktion, die für jedes Objekt aufgerufen werden kann und eine Zeichenfolge als Eingabe verwendet. Es wird ein Boolescher Wert zurückgegeben, dh truewenn sich die Eigenschaft im Objekt befindet, andernfalls wird false zurückgegeben. hasOwnProperty()befindet sich auf Object.prototypeund ist somit für jedes Objekt verfügbar.

Beispiel:

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

In diesem Beispiel wird ein neues Personenobjekt erstellt. Jede Person hat ihren eigenen Namen, der im Konstruktor initialisiert wird. Das Alter befindet sich jedoch nicht auf dem Objekt, sondern auf dem Prototyp des Objekts. Daher hasOwnProperty()kehrt truefür Name und falseAlter zurück.

Praktische Anwendungen:

hasOwnProperty()kann sehr nützlich sein, wenn Sie ein Objekt mit einer for inSchleife durchlaufen. Sie können damit überprüfen, ob die Eigenschaften vom Objekt selbst stammen und nicht vom Prototyp. Beispielsweise:

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

Mit object.hasOwnProperty ( p ) bestimmen Sie, ob das Objekt eine aufzählbare Eigenschaft p - hat.

Das Objekt kann einen eigenen Prototyp haben, bei dem jeder Instanz des Objekts Standardmethoden und -attribute zugewiesen werden. hasOwnProperty gibt true nur für die Eigenschaften zurück, die speziell im Konstruktor festgelegt oder später zur Instanz hinzugefügt wurden.

Um festzustellen, ob p für das Objekt überhaupt irgendwo definiert ist, verwenden Sie if ( p Instanz des Objekts), wobei p zu einer Eigenschaftsnamenzeichenfolge ausgewertet wird.

Beispielsweise haben standardmäßig alle Objekte eine 'toString'-Methode, die jedoch nicht in hasOwnProperty angezeigt wird.

hasOwnProperty ist eine normale Javascript-Funktion, die ein String-Argument akzeptiert.

In Ihrem Fall überprüft somevar.hasOwnProperty ('someProperty'), ob die Funktion somevar eine Eigenschaft hat oder nicht, und gibt true und false zurück

Sagen

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

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

hasOwnPropertyist eine richtige Art zu überprüfen, object hat eine propertyoder nicht. someVar.somePropertykann nicht alternativ zu dieser Situation verwendet werden. Die folgende Bedingung zeigt einen guten Unterschied:

const someVar = { isFirst: false };


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


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

Daher someVar.isFirstkann nicht alternativ zu verwendet werden someVar.hasOwnProperty('isFirst').

Es wird geprüft, ob ein Objekt eine Eigenschaft hat . if(obj.prop)Soweit ich weiß, funktioniert es genauso .

Szene A:

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

  output
  1
  2

Szene B:

const objB = { 
  a: 1, 
  b: 2,
  hasOwnProperty() {
    return false
  }
}
for (const key in objB) {
  if (objB.hasOwnProperty(key)) {
    console.log(objB[key])
  }
}
  output nothing

Da JS die Eigenschaft von hasOwnProperty nicht schützt
, können Sie diese verwenden

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