Object.hasOwn()
===============

El método estático **`Object.hasOwn()`** devuelve `true` si el objeto especificado tiene la propiedad indicada como propiedad *propia*. Si la propiedad es heredada, o no existe, el método devuelve `false`.

**Nota:** `Object.hasOwn()` está pensada como un reemplazo de `Object.prototype.hasOwnProperty()`.

Pruébalo
--------

Sintaxis
--------


```js
Object.hasOwn(obj, prop)
```

### Parametros

`obj`

La instancia del objeto JavaScript a probar.

`prop`

El nombre del `String` ó Symbol de la propiedad a probar.

### Valor de retorno del método

`true` si el objeto tiene definido directamente la propiedad especificada. De lo contrario `false`

Descripción
-----------

 El método **`Object.hasOwn()`** devuelve `true` si la propiedad especificada es una propiedad directa del objeto — incluso si el valor de la propiedad es `null` o `undefined`.
 El método devuelve `false` si la propiedad es heredada, o no ha sido declarado en absoluto.
 A diferencia del operador `in`, este método no comprueba la propiedad especificada en la cadena de prototipos del objeto.

Se recomienda sobre `Object.prototype.hasOwnProperty()` porque funciona para objetos creados usando `Object.create(null)` y con objetos que anulan el método `hasOwnProperty()`. Si bien es posible solucionar estos problemas llamando a `Object.prototype.hasOwnProperty()` en un objeto externo, `Object.hasOwn()` es mas intuitivo.

Ejemplos
--------

### Usando hasOwn para probar la existencia de una propiedad

El siguiente código muestra como determinar si el objeto `example` contiene una propiedad llamada `prop`.


```js
const example = {};
Object.hasOwn(example, "prop"); // false - 'prop' no ha sido definido

example.prop = "existe";
Object.hasOwn(example, "prop"); // true - 'prop' ha sido definido

example.prop = null;
Object.hasOwn(example, "prop"); // true - la propiedad existe con valor nulo

example.prop = undefined;
Object.hasOwn(example, "prop"); // true - la propiedad existe con valor de indefinido
```

### Propiedades directas vs. heredadas

El siguiente ejemplo diferencía entre propiedades directas y propiedades heredadas mediante la cadena de prototipos:


```js
const example = {};
example.prop = "existe";

// `hasOwn` solo devolverá verdadero para propiedades directas:
Object.hasOwn(example, "prop"); // Devuelve verdadero
Object.hasOwn(example, "toString"); // Devuelve falso
Object.hasOwn(example, "hasOwnProperty"); // Devuelve falso

// El operador `in` devolverá verdadero para propiedades directas o heredadas:
"prop" in example; // Devuelve verdadero
"toString" in example; // Devuelve verdadero
"hasOwnProperty" in example; // Devuelve verdadero
```

### Iterando sobre las propiedades de un objeto

Para iterar sobre las propiedades enumerables de un objeto, *debe* usar:


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


Pero si necesita usar `for...in`, se puede usar `Object.hasOwn()` para omitir las propiedades heredadas:


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

### Comprobando si el índice de un arreglo existe

Los elementos de un `Array` son definidos como propiedades directas, asi que se puede usar el método `hasOwn()` para comprobar si existe un índice en particular:


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

### Casos problematicos de hasOwnProperty

Esta sección demuestra que `hasOwn()` es inmune a los problemas que afectan `hasOwnProperty`. En primer lugar, puede usarse con objetos que han reimplementado `hasOwnProperty()`:


```js
const foo = {
  hasOwnProperty() {
    return false;
  },
  bar: "Los dragones están fuera de la oficina",
};

if (Object.hasOwn(foo, "bar")) {
  console.log(foo.bar); //true - la reimplementación de hasOwnProperty() no afecta a Object
}
```


 También se puede usar para probar objetos creados usando
 `Object.create(null)`. Estos no heredan de `Object.prototype`, por lo que `hasOwnProperty()` es inaccesible.


```js
const foo = Object.create(null);
foo.prop = "existe";
if (Object.hasOwn(foo, "prop")) {
  console.log(foo.prop); //true - funciona independientemente de cómo se crea el objeto.
}
```

Especificaciones
----------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-object.hasown |

Compatibilidad con navegadores
------------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Véase también
-------------

* Polyfill de `Object.hasOwn` en `core-js`
* `Object.prototype.hasOwnProperty()`
* Enumerabilidad y pertenencia de las propiedades
* `Object.getOwnPropertyNames()`
* `for...in`
* `in`
* Guía de JavaScript: Herencia revisada