Objeto de JavaScript viene con una serie de métodos útiles que ayudan a los desarrolladores a manipular objetos con facilidad. Repasemos algunos de los más importantes, con breves explicaciones y ejemplos

1. Objeto.create()
2. Objeto.asignar()
3. Objeto.claves()
4. Valores.objeto()
5. Entradas.objeto()
6. Objeto.congelar()
7. Objeto.sello()
8. Objeto.preventExtensions()
9. Objeto.getPrototypeOf()
10. Objeto.setPrototypeOf()
11. Objeto.definirPropiedad()
12. Objeto.definirPropiedades()
13. Objeto.getOwnPropertyDescriptor()
14. Object.getOwnPropertyDescriptors()
15. Object.getOwnPropertyNames()
16. Objeto.es()
17. Objeto.isFrozen()
18. Objeto.isSealed()
19. Objeto.isExtensible()
20. Objeto.deEntries()
21. Objeto.hasOwnProperty()
22. Objeto.tieneOwn()
23. Object.groupBy() (función propuesta, puede que no esté completamente disponible)

Objeto.create()
Object.create() es un método en JavaScript que se utiliza para crear un nuevo objeto con un objeto prototipo específico y propiedades opcionales. Permite un control más detallado sobre el prototipo y las propiedades de un objeto en comparación con el uso de constructores o literales de objetos.

const personPrototype = {
  greet() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

const john = Object.create(personPrototype);
john.name = "John";
john.greet();  // Output: Hello, my name is John

Objeto.asignar()
Object.assign() es un método JavaScript integrado que se utiliza para copiar los valores de todas las propiedades propias enumerables de uno o más objetos de origen a un objeto de destino. Realiza una copia superficial y devuelve el objeto de destino modificado.

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

Objeto.claves()
Devuelve una matriz de los nombres de propiedades enumerables (claves) del propio objeto

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

Valores.objeto()
Devuelve una matriz de los valores de propiedad enumerables propios del objeto

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

Entradas.objeto()
Devuelve una matriz de pares de propiedad enumerable [clave, valor] propios del objeto

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

Objeto.freeze()
Congela el objeto, evitando que se agreguen nuevas propiedades o que se cambien o eliminen propiedades existentes

const obj = { a: 1 };
Object.freeze(obj);
obj.a = 2;  // No effect, because the object is frozen
console.log(obj.a);  // Output: 1

Objeto.sello()
Sella el objeto, evitando que se agreguen nuevas propiedades, pero permite modificar las propiedades existentes.

const obj = { a: 1 };
Object.seal(obj);
obj.a = 2;  // Allowed
delete obj.a;  // Not allowed
console.log(obj.a);  // Output: 2

Object.preventExtensions()
Evita que se agreguen nuevas propiedades al objeto, pero permite modificar y eliminar propiedades existentes

const obj = { a: 1 };
Object.preventExtensions(obj);
obj.b = 2;  // Not allowed
console.log(obj.b);  // Output: undefined

Object.getPrototypeOf()
Devuelve el prototipo (es decir, el [[Prototipo]] interno) del objeto especificado

const obj = {};
const proto = Object.getPrototypeOf(obj);
console.log(proto);  // Output: {} (the default Object prototype)

Object.setPrototypeOf()
Establece el prototipo de un objeto específico.

const proto = { greet() { console.log('Hello!'); } };
const obj = {};
Object.setPrototypeOf(obj, proto);
obj.greet();  // Output: 'Hello!'

Objeto.defineProperty()
Define una nueva propiedad en un objeto o modifica una existente, con opciones adicionales para descriptores de propiedad (por ejemplo, escribibles, configurables).

const obj = {};
Object.defineProperty(obj, 'a', {
  value: 42,
  writable: false,  // Cannot modify the value
});
obj.a = 100;  // No effect because writable is false
console.log(obj.a);  // Output: 42

Objeto.defineProperties()
Define múltiples propiedades en un objeto con descriptores de propiedad.

const obj = {};
Object.defineProperties(obj, {
  a: { value: 42, writable: false },
  b: { value: 100, writable: true }
});
console.log(obj.a);  // Output: 42
console.log(obj.b);  // Output: 100

Object.getOwnPropertyDescriptor()
Devuelve el descriptor de una propiedad de un objeto.

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

Object.getOwnPropertyDescriptors()
Devuelve un objeto que contiene todos los descriptores de propiedad de las propiedades propias de un objeto

const obj = { a: 1 };
const descriptors = Object.getOwnPropertyDescriptors(obj);
console.log(descriptors);
// Output: { a: { value: 1, writable: true, enumerable: true, configurable: true } }

Object.getOwnPropertyNames()
Devuelve una matriz de todas las propiedades (incluidas las no enumerables) que se encuentran directamente en un objeto.

const obj = { a: 1 };
Object.defineProperty(obj, 'b', { value: 2, enumerable: false });
console.log(Object.getOwnPropertyNames(obj));  // Output: ['a', 'b']

Objeto.es()
Compara si dos valores son iguales (como === pero maneja casos especiales como NaN)

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

Objeto.isFrozen()
Comprueba si un objeto está congelado

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

Objeto.isSealed()
Comprueba si un objeto está sellado.

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

Objeto.isExtensible()
Comprueba si se pueden agregar nuevas propiedades a un objeto.

const obj = { a: 1 };
Object.preventExtensions(obj);
console.log(Object.isExtensible(obj));  // Output: false

Objeto.deEntries()
Convierte una matriz de pares clave-valor en un objeto

const entries = [['a', 1], ['b', 2]];
const obj = Object.fromEntries(entries);
console.log(obj);  // Output: { a: 1, b: 2 }

Objeto.hasOwnProperty()
Comprueba si un objeto tiene la propiedad especificada como propia (no heredada)

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

Objeto.hasOwn()
Object.hasOwn() es un método más nuevo introducido en ES2022 como alternativa a Object.hasOwnProperty(). Comprueba si un objeto tiene una propiedad directa (propia) con una clave especificada, sin buscar la cadena del prototipo.

const obj = {
  name: 'Alice',
  age: 25
};

console.log(Object.hasOwn(obj, 'name'));  // true
console.log(Object.hasOwn(obj, 'gender'));  // false

Objeto.grupoPor
Object.groupBy es una característica relativamente nueva propuesta para JavaScript en ECMAScript 2024 que le permite agrupar objetos según un criterio común. Aún no está ampliamente disponible en todos los entornos, por lo que es posible que no funcione en muchos navegadores o motores de JavaScript hasta que se implemente por completo.

const array = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 },
  { name: 'Charlie', age: 25 },
  { name: 'David', age: 30 },
];

// Group objects by age
const groupedByAge = Object.groupBy(array, item => item.age);

console.log(groupedByAge);

/*
Expected Output:
{
  25: [
    { name: 'Alice', age: 25 },
    { name: 'Charlie', age: 25 }
  ],
  30: [
    { name: 'Bob', age: 30 },
    { name: 'David', age: 30 }
  ]
}
*/