JavaScript's Object vem com vários métodos úteis que ajudam os desenvolvedores a manipular objetos com facilidade. Vamos examinar alguns dos mais importantes, com breves explicações e exemplos

1. Object.create()
2. Object.assign()
3. Object.keys()
4. Object.valores()
5. Object.entries()
6. Object.freeze()
7. Object.seal()
8. Object.preventExtensions()
9. Object.getPrototypeOf()
10. Object.setPrototypeOf()
11. Object.defineProperty()
12. Object.defineProperties()
13. Object.getOwnPropertyDescriptor()
14. Object.getOwnPropertyDescriptors()
15. Object.getOwnPropertyNames()
16. Object.is()
17. Object.isFrozen()
18. Object.isSealed()
19. Object.isExtensible()
20. Object.fromEntries()
21. Object.hasOwnProperty()
22. Object.hasOwn()
23. Object.groupBy() (recurso proposto, pode não estar totalmente disponível)

Object.create()
Object.create() é um método em JavaScript usado para criar um novo objeto com um objeto protótipo especificado e propriedades opcionais. Ele permite um controle mais refinado sobre o protótipo e as propriedades de um objeto em comparação ao uso de literais ou construtores de objeto.

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

Object.assign()
Object.assign() é um método JavaScript integrado usado para copiar os valores de todas as propriedades próprias enumeráveis ​​de um ou mais objetos de origem para um objeto de destino. Ele executa uma cópia superficial e retorna o 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)

Object.keys()
Retorna uma matriz de nomes de propriedades enumeráveis ​​do próprio objeto (chaves)

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

Object.values()
Retorna uma matriz de valores de propriedades enumeráveis ​​do próprio objeto

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

Object.entries()
Retorna uma matriz de pares de propriedades enumeráveis ​​[chave, valor] do próprio objeto

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

Object.freeze()
Congela o objeto, evitando que novas propriedades sejam adicionadas ou que propriedades existentes sejam alteradas ou excluídas

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

Object.seal()
Sela o objeto, evitando que novas propriedades sejam adicionadas, mas permite que as propriedades existentes sejam modificadas.

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

Object.preventExtensions()
Impede que quaisquer novas propriedades sejam adicionadas ao objeto, mas permite a modificação e exclusão de propriedades existentes

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

Object.getPrototypeOf()
Retorna o protótipo (ou seja, o [[Protótipo]] interno) do objeto especificado

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

Object.setPrototypeOf()
Define o protótipo de um objeto especificado.

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

Object.defineProperty()
Define uma nova propriedade em um objeto ou modifica uma existente, com opções adicionais para descritores de propriedade (por exemplo, gravável, configurável).

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

Object.defineProperties()
Define múltiplas propriedades em um objeto com descritores de propriedades.

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()
Retorna o descritor de uma propriedade de um 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()
Retorna um objeto contendo todos os descritores de propriedades para as próprias propriedades de um 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()
Retorna uma matriz de todas as propriedades (incluindo as não enumeráveis) encontradas diretamente em um objeto.

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

Object.is()
Compara se dois valores são iguais (como === mas lida com casos especiais como NaN)

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

Object.isFrozen()
Verifica se um objeto está congelado

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

Object.isSealed()
Verifica se um objeto está selado.

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

Object.isExtensible()
Verifica se novas propriedades podem ser adicionadas a um objeto.

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

Object.fromEntries()
Converte uma matriz de pares de valores-chave em um objeto

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

Object.hasOwnProperty()
Verifica se um objeto possui a propriedade especificada como própria (não herdada)

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

Object.hasOwn()
Object.hasOwn() é um método mais recente introduzido no ES2022 como uma alternativa a Object.hasOwnProperty(). Ele verifica se um objeto possui uma propriedade direta (própria) com uma chave especificada, sem consultar a cadeia de protótipos.

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

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

Object.groupBy
Object.groupBy é um recurso relativamente novo proposto para JavaScript no ECMAScript 2024 que permite agrupar objetos com base em um critério comum. Ainda não está amplamente disponível em todos os ambientes, portanto pode não funcionar em muitos navegadores ou mecanismos JavaScript até ser totalmente implementado.

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 }
  ]
}
*/