Considerar:

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

Qual é o uso / explicação correta de hasOwnProperty('someProperty')?

Por que não podemos simplesmente someVar.somePropertyverificar se um objeto someVarcontém uma propriedade com nome someProperty?

O que é uma propriedade neste caso?

Que propriedade esse JavaScript verifica?

hasOwnPropertyretorna um valor booleano indicando se o objeto no qual você o está chamando tem uma propriedade com o nome do argumento. Por exemplo:

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

No entanto, ele não olha para a cadeia de protótipo do objeto.

É útil usá-lo quando você enumera as propriedades de um objeto com a for...inconstrução.

Se você quiser ver todos os detalhes, a especificação ES5 é, como sempre, um bom lugar para procurar.

Aqui está uma resposta curta e precisa:

Em JavaScript, cada objeto tem um monte de pares de valores-chave integrados que contêm metainformações sobre o objeto. Quando você percorre todos os pares de valor-chave usando for...inconstrução / loop para um objeto, você também percorre esses pares de valor-chave de meta-informação (o que você definitivamente não quer).

O uso de hasOwnPropery(property) filtros elimina esses loopings desnecessários por meio de metainformações e verifica diretamente se o parâmetro propertyé uma propriedade fornecida pelo usuário no objeto ou não. Por filtros de saída , quero dizer, que hasOwnProperty(property)não parece se propertyexiste na cadeia de protótipos do Objeto, também conhecida como meta informação.

Ele retorna booleano com true/falsebase nisso.

Aqui está um exemplo:

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 esteja claro!

Ele verifica:

Retorna um valor booleano indicando se um objeto tem uma propriedade com o nome especificado

O método hasOwnProperty retorna true se o objeto tiver uma propriedade do nome especificado, false se não tiver. Este método não verifica se a propriedade existe na cadeia de protótipo do objeto; a propriedade deve ser membro do próprio objeto.

Exemplo:

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

Resumo:

hasOwnProperty()é uma função que pode ser chamada em qualquer objeto e recebe uma string como entrada. Ele retorna um booleano que é truese a propriedade está localizada no objeto, caso contrário, retorna falso. hasOwnProperty()está localizado Object.prototypee, portanto, disponível para qualquer objeto.

Exemplo:

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

Neste exemplo, um novo objeto Person é criado. Cada pessoa tem seu próprio nome, que é inicializado no construtor. No entanto, a idade não está localizada no objeto, mas no protótipo do objeto. Portanto hasOwnProperty(), retorna truepor nome e falsepor idade.

Aplicações práticas:

hasOwnProperty()pode ser muito útil ao fazer um loop sobre um objeto usando um for inloop. Você pode verificar com ele se as propriedades são do próprio objeto e não do protótipo. Por exemplo:

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

Use object.hasOwnProperty ( p ) para determinar se um objeto tem uma propriedade enumerável p -

Um objeto pode ter seu próprio protótipo, onde métodos e atributos 'padrão' são atribuídos a cada instância do objeto. hasOwnProperty retorna true apenas para as propriedades que foram definidas especificamente no construtor ou adicionadas à instância posteriormente.

Para determinar se p é definido de alguma forma, em qualquer lugar, para o objeto, use if ( p instanceof object), onde p avalia como uma string de nome de propriedade.

Por exemplo, por padrão, todos os objetos têm um método 'toString', mas ele não aparecerá em hasOwnProperty.

hasOwnProperty é uma função JavaScript normal que recebe um argumento de string.

No seu caso, somevar.hasOwnProperty('someProperty')ele verifica se a somevarfunção tem someproperyou não - retorna verdadeiro e falso.

Dizer

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

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

hasOwnPropertyé uma maneira adequada de verificar se um objeto tem uma propriedade ou não. someVar.somePropertynão pode ser usado como uma alternativa para esta situação. A seguinte condição mostrará uma boa diferença:

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
}

Portanto, someVar.isFirstnão pode ser usado como alternativa para someVar.hasOwnProperty('isFirst').

Cena A:

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

    Output

    1
    2

Cena 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 não protege a propriedade de hasOwnProperty. Então você pode usá-lo assim:

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

Ele verifica se um objeto possui uma propriedade . if(obj.prop)Pelo que eu sei, funciona da mesma forma .