Métodos del tipo Object en JavaScript

Crea un nuevo objeto con un prototipo específico.

const proto = { greet: function() { return "Hello"; } };
const obj = Object.create(proto);
console.log(obj.greet()); // "Hello"

Copia todas las propiedades enumerables de uno o más objetos fuente a un objeto destino.

const target = { a: 1 };
const source = { b: 2, c: 3 };
const result = Object.assign(target, source);
console.log(result); // { a: 1, b: 2, c: 3 }

Convierte una lista de pares clave-valor en un objeto.

const entries = [['name', 'Alice'], ['age', 30]];
const obj = Object.fromEntries(entries);
console.log(obj); // { name: 'Alice', age: 30 }

Devuelve un array con los nombres de las propiedades enumerables de un objeto.

const obj = { a: 1, b: 2, c: 3 };
const keys = Object.keys(obj);
console.log(keys); // ["a", "b", "c"]

Devuelve un array con los valores de las propiedades enumerables de un objeto.

const obj = { a: 1, b: 2, c: 3 };
const values = Object.values(obj);
console.log(values); // [1, 2, 3]

Devuelve un array de pares [clave, valor] de las propiedades enumerables de un objeto.

const obj = { a: 1, b: 2, c: 3 };
const entries = Object.entries(obj);
console.log(entries); // [["a", 1], ["b", 2], ["c", 3]]

Devuelve un booleano indicando si el objeto tiene la propiedad especificada como propia (no heredada).

const obj = { a: 1 };
console.log(obj.hasOwnProperty('a')); // true
console.log(obj.hasOwnProperty('b')); // false

Devuelve un array con los nombres de todas las propiedades (enumerables y no enumerables) de un objeto.

const obj = { a: 1, b: 2, c: 3 };
const propNames = Object.getOwnPropertyNames(obj);
console.log(propNames); // ["a", "b", "c"]

Devuelve un descriptor de la propiedad para una propiedad específica de un objeto.

const obj = { a: 1 };
const descriptor = Object.getOwnPropertyDescriptor(obj, 'a');
console.log(descriptor);
// { value: 1, writable: true, enumerable: true, configurable: true }

Define una nueva propiedad o modifica una existente en un objeto, controlando su configuración.

const obj = {};
Object.defineProperty(obj, 'name', { value: 'Alice', writable: false });
console.log(obj.name); // "Alice"
obj.name = 'Bob'; // No cambia porque writable es false
console.log(obj.name); // "Alice"

Define varias propiedades nuevas o modifica las existentes en un objeto, controlando sus configuraciones.

const obj = {};
Object.defineProperties(obj, {
name: { value: 'Alice', writable: true },
age: { value: 30, writable: false }
});
console.log(obj.name); // "Alice"
console.log(obj.age); // 30

Devuelve el prototipo (es decir, el valor de [[Prototype]]) del objeto especificado.

const proto = {};
const obj = Object.create(proto);
const prototype = Object.getPrototypeOf(obj);
console.log(prototype === proto); // true

Establece el prototipo (es decir, el valor de [[Prototype]]) de un objeto específico.

const proto = { greet: function() { return "Hello"; } };
const obj = {};
Object.setPrototypeOf(obj, proto);
console.log(obj.greet()); // "Hello"

Devuelve un booleano que indica si el objeto especificado está en la cadena de prototipos del objeto.

const proto = {};
const obj = Object.create(proto);
console.log(proto.isPrototypeOf(obj)); // true

Determina si dos valores son iguales (más preciso que === para NaN y +0 vs -0).

console.log(Object.is(NaN, NaN)); // true
console.log(Object.is(0, -0)); // false

Determina si las nuevas propiedades pueden ser añadidas a un objeto.

const obj = {};
console.log(Object.isExtensible(obj)); // true
Object.preventExtensions(obj);
console.log(Object.isExtensible(obj)); // false

Determina si un objeto está sellado (no se pueden añadir o eliminar propiedades, pero las existentes pueden modificarse).

const obj = { a: 1 };
console.log(Object.isSealed(obj)); // false
Object.seal(obj);
console.log(Object.isSealed(obj)); // true

Determina si un objeto está congelado (no se pueden añadir, eliminar o modificar propiedades).

const obj = { a: 1 };
console.log(Object.isFrozen(obj)); // false
Object.freeze(obj);
console.log(Object.isFrozen(obj)); // true

Congela un objeto, evitando que se añadan, eliminen o modifiquen propiedades.

const obj = { a: 1 };
Object.freeze(obj);
obj.a = 2; // No se puede modificar, se ignora en modo estricto.
obj.b = 2; // No se puede añadir, se ignora en modo estricto.
console.log(obj); // { a: 1 }

Sella un objeto, evitando que nuevas propiedades sean añadidas y marcando todas las propiedades existentes como no configurables.

const obj = { a: 1 };
Object.seal(obj);
obj.b = 2; // No se puede añadir, se ignora en modo estricto.
delete obj.a; // No se puede eliminar, se ignora en modo estricto.
console.log(obj); // { a: 1 }

Evita que nuevas propiedades sean añadidas a un objeto.

const obj = { a: 1 };
Object.preventExtensions(obj);
obj.b = 2; // No se puede añadir, se ignora en modo estricto.
console.log(obj); // { a: 1 }

Devuelve una cadena representando el objeto, útil para la depuración.

const obj = {};
console.log(obj.toString()); // "[object Object]"

Devuelve el valor primitivo del objeto especificado (normalmente devuelve el propio objeto, pero puede ser sobreescrito).

const obj = {};
console.log(obj.valueOf() === obj); // true