Considerar:

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

¿Cuál es el uso / explicación correcto de hasOwnProperty('someProperty')?

¿Por qué no podemos simplemente usar someVar.somePropertypara verificar si un objeto someVarcontiene una propiedad con nombre someProperty?

¿Qué es una propiedad en este caso?

¿Qué propiedad comprueba este JavaScript?

hasOwnPropertydevuelve un valor booleano que indica si el objeto al que lo está llamando tiene una propiedad con el nombre del argumento. Por ejemplo:

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

Sin embargo, no mira la cadena de prototipos del objeto.

Es útil usarlo cuando enumera las propiedades de un objeto con la for...inconstrucción.

Si desea ver todos los detalles, la especificación ES5 es, como siempre, un buen lugar para buscar.

Aquí hay una respuesta breve y precisa:

En JavaScript, cada objeto tiene un montón de pares clave-valor integrados que tienen metainformación sobre el objeto. Cuando recorre todos los pares clave-valor usando for...inconstruct / loop para un objeto, también está recorriendo estos pares clave-valor de metainformación (lo que definitivamente no desea).

El uso de hasOwnPropery(property) filtros elimina estos bucles innecesarios a través de la metainformación y comprueba directamente si el parámetro propertyes una propiedad dada por el usuario en el objeto o no. Por filtros de salida , quiero decir, que hasOwnProperty(property)no se ve si propertyexiste en la cadena de prototipos de Object, también conocida como metainformación.

Devuelve booleano true/falsebasado en eso.

Aquí hay un ejemplo:

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

¡Espero que esté claro!

Comprueba:

Devuelve un valor booleano que indica si un objeto tiene una propiedad con el nombre especificado

El método hasOwnProperty devuelve verdadero si el objeto tiene una propiedad del nombre especificado, falso si no la tiene. Este método no comprueba si la propiedad existe en la cadena de prototipos del objeto; la propiedad debe ser miembro del propio objeto.

Ejemplo:

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

Resumen:

hasOwnProperty()es una función que se puede llamar en cualquier objeto y toma una cadena como entrada. Devuelve un booleano que es truesi la propiedad está ubicada en el objeto, de lo contrario, devuelve falso. hasOwnProperty()está ubicado Object.prototypey, por lo tanto, disponible para cualquier objeto.

Ejemplo:

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

En este ejemplo, se crea un nuevo objeto Persona. Cada persona tiene su propio nombre que se inicializa en el constructor. Sin embargo, la edad no se ubica en el objeto sino en el prototipo del objeto. Por tanto hasOwnProperty(), vuelve truepor nombre y falsepor edad.

Aplicaciones prácticas:

hasOwnProperty()puede ser muy útil cuando se realiza un bucle sobre un objeto mediante un for inbucle. Puede verificar con él si las propiedades son del objeto en sí y no del prototipo. Por ejemplo:

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

Utiliza object.hasOwnProperty ( p ) para determinar si un objeto tiene una propiedad enumerable p -

Un objeto puede tener su propio prototipo, donde los métodos y atributos "predeterminados" se asignan a cada instancia del objeto. hasOwnProperty devuelve verdadero solo para las propiedades que se establecieron específicamente en el constructor o que se agregaron a la instancia más tarde.

Para determinar si p está definido en absoluto, en cualquier lugar, para el objeto, use if ( p instancia del objeto), donde p se evalúa como una cadena de nombre de propiedad.

Por ejemplo, de forma predeterminada, todos los objetos tienen un método 'toString', pero no aparecerá en hasOwnProperty.

hasOwnProperty es una función JavaScript normal que toma un argumento de cadena.

En su caso, somevar.hasOwnProperty('someProperty')comprueba si la somevarfunción tiene someproperyo no, devuelve verdadero y falso.

Decir

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

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

hasOwnPropertyes una forma adecuada de comprobar que un objeto tiene una propiedad o no. someVar.somePropertyno se puede utilizar como alternativa a esta situación. La siguiente condición mostrará una buena diferencia:

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
}

Por someVar.isFirstlo tanto , no se puede utilizar como alternativa a someVar.hasOwnProperty('isFirst').

Escena A:

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

    Output

    1
    2

Escena 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

Porque JavaScript no protege la propiedad de hasOwnProperty. Entonces puedes usarlo así:

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

Se comprueba si un objeto tiene una propiedad . Funciona igual que if(obj.prop), hasta donde yo sé.