Object.hasOwn()

instance

A instância do objeto javascript para o teste.

prop

O nome String ou Symbol da propriedade para teste.

true se o objeto especificado definiu diretamente a propriedade especificada. Por outro lado false.

O método Object.hasOwn() retorna true se a propriedade especificada é uma propriedade direta do objeto - mesmo se o valor da propriedade é null ou undefined.

O método retorna false se a propriedade é herdada, ou não foi declarada. Diferente do operador in, este método não verifica pela propriedade específica na cadeia do objeto.

Ele é mais recomendado do que Object.hasOwnProperty() porque ele funciona para objetos criados utilizando Object.create(null) e com objetos que sobescreveram o método herdado hasOwnProperty(). É possível contornar esse problema chamando o Object.prototype.hasOwnProperty() em um objeto externo, Object.hasOwn() é mais intuítivo.

O seguinte código mostra como determinar se o seguinte objeto example contém a propriedade prop.

const example = {};
Object.hasOwn(example, "prop"); // false = 'prop' ela não foi definida

example.prop = "exists";
Object.hasOwn(example, "prop"); // true - 'prop' ela foi definida

example.prop = null;
Object.hasOwn(example, "prop"); // true - a propriedade existe com o valor null

example.prop = undefined;
Object.hasOwn(example, "prop"); // true - a propriedade existe com o valor undefined

O seguinte exemplo diferencia entre propriedade direta e proprietade errada através do prototype chain:

const example = {};
example.prop = "exists";

// `hasOwn` Só retornará true para propriedades diretas will:
Object.hasOwn(example, "prop"); // returns true
Object.hasOwn(example, "toString"); // returns false
Object.hasOwn(example, "hasOwnProperty"); // returns false

// O operador `in` só retornara tru para propriedades diretas ou herdadas:
"prop" in example; // returns true
"toString" in example; // returns true
"hasOwnProperty" in example; // returns true

Para itererar sobre inúmeras propriedades de um objeto, você deve usar:

const example = { foo: true, bar: true };
for (const name of Object.keys(example)) {
  // …
}

Mas se você precisa utilizar for...in, você pode utilziar Object.hasOwn() para pular as propriedades herdadas.

const example = { foo: true, bar: true };
for (const name in example) {
  if (Object.hasOwn(example, name)) {
    // …
  }
}

Os elementos de um Array são definidos como propriedades diretas, você pode utilizar o método hasOwn() para verificar se existe um index específico:

const fruits = ["Apple", "Banana", "Watermelon", "Orange"];
Object.hasOwn(fruits, 3); // true ('Orange')
Object.hasOwn(fruits, 4); // false - not defined

Essa seção demonstra hasOwn() é imune aos problemas que afetam hasOwnProperty. Primeiramente, ele pode ser uasdos em objetos que foram reimplementados hasOwnProperty():

const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "The dragons be out of office",
};

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar); //true - reimplementação do hasOwnProperty() não afetara o objeto
}

Ele pode ser usado para testar objetos criados utilizando Object.create(null). Esses não são herdados de Object.prototype, e assim o hasOwnProperty() é inacessível

const foo = Object.create(null);
foo.prop = "exists";
if (Object.hasOwn(foo, "prop")) {
  console.log(foo.prop); //true - Funciona independente de como o objeto é criado.
}

• Polyfill of Object.hasOwn in core-js
• Object.hasOwnProperty()
• Enumerability and ownership of properties
• Object.getOwnPropertyNames()
• for...in
• in
• JavaScript Guide: Inheritance revisited