Prendere in considerazione:

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

Qual è il giusto uso / spiegazione di hasOwnProperty('someProperty')?

Perché non possiamo semplicemente usare someVar.somePropertyper verificare se un oggetto someVarcontiene una proprietà con nome someProperty?

Cos'è una proprietà in questo caso?

Quale proprietà controlla questo JavaScript?

hasOwnPropertyrestituisce un valore booleano che indica se l'oggetto su cui lo stai chiamando ha una proprietà con il nome dell'argomento. Per esempio:

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

Tuttavia, non guarda la catena del prototipo dell'oggetto.

È utile usarlo quando si enumerano le proprietà di un oggetto con il for...incostrutto.

Se vuoi vedere tutti i dettagli, la specifica ES5 è, come sempre, un buon posto dove guardare.

Ecco una risposta breve e precisa:

In JavaScript, ogni oggetto ha un gruppo di coppie chiave-valore incorporate che contengono meta informazioni sull'oggetto. Quando esegui il ciclo attraverso tutte le coppie chiave-valore utilizzando for...incostrutto / ciclo per un oggetto, stai eseguendo il ciclo anche attraverso queste coppie chiave-valore di meta-informazione (cosa che sicuramente non vuoi).

L'utilizzo di hasOwnPropery(property) filtri elimina questi cicli non necessari attraverso le meta informazioni e controlla direttamente che il parametro propertysia una proprietà data dall'utente nell'oggetto o meno. Per filtri di uscita , intendo, questo hasOwnProperty(property)non sembra propertyesistere nella catena di prototipi di Object, ovvero le meta informazioni.

Restituisce un valore booleano true/falsebasato su quello.

Ecco un esempio:

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

Spero sia chiaro!

Controlla:

Restituisce un valore booleano che indica se un oggetto ha una proprietà con il nome specificato

Il metodo hasOwnProperty restituisce true se l'oggetto ha una proprietà del nome specificato, false in caso contrario. Questo metodo non controlla se la proprietà esiste nella catena di prototipi dell'oggetto; la proprietà deve essere un membro dell'oggetto stesso.

Esempio:

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

Sommario:

hasOwnProperty()è una funzione che può essere chiamata su qualsiasi oggetto e accetta una stringa come input. Restituisce un booleano che è truese la proprietà si trova sull'oggetto, altrimenti restituisce false. hasOwnProperty()si trova su Object.prototypee quindi disponibile per qualsiasi oggetto.

Esempio:

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 questo esempio viene creato un nuovo oggetto Person. Ogni persona ha il proprio nome che viene inizializzato nel costruttore. Tuttavia, l'età non si trova sull'oggetto ma sul prototipo dell'oggetto. Quindi hasOwnProperty()ritorna trueper nome e falseper età.

Applicazioni pratiche:

hasOwnProperty()può essere molto utile quando si esegue il loop su un oggetto utilizzando un for inloop. Puoi controllare con esso se le proprietà provengono dall'oggetto stesso e non dal prototipo. Per esempio:

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

Si utilizza object.hasOwnProperty ( p ) per determinare se un oggetto ha una proprietà enumerabile p -

Un oggetto può avere il proprio prototipo, in cui i metodi e gli attributi "predefiniti" vengono assegnati a ogni istanza dell'oggetto. hasOwnProperty restituisce true solo per le proprietà specificatamente impostate nel costruttore o aggiunte all'istanza in un secondo momento.

Per determinare se p è definito affatto, ovunque, per l'oggetto, utilizzare if ( p instanceof object), dove p restituisce una stringa del nome della proprietà.

Ad esempio, per impostazione predefinita tutti gli oggetti hanno un metodo "toString", ma non verrà visualizzato in hasOwnProperty.

hasOwnProperty è una normale funzione JavaScript che accetta un argomento stringa.

Nel tuo caso, somevar.hasOwnProperty('someProperty')controlla che la somevarfunzione abbia someproperyo meno - restituisce vero e falso.

Dire

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

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

hasOwnPropertyè un modo corretto per verificare che un oggetto abbia o meno una proprietà . someVar.somePropertynon può essere utilizzato come alternativa a questa situazione. La seguente condizione mostrerà una buona differenza:

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
}

Quindi someVar.isFirstnon può essere utilizzato in alternativa a someVar.hasOwnProperty('isFirst').

Scena A:

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

    Output

    1
    2

Scena 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

Perché JavaScript non protegge la proprietà di hasOwnProperty. Quindi puoi usarlo in questo modo:

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

Si verifica se un oggetto ha una proprietà . Funziona allo stesso modo if(obj.prop), per quanto ne so.