Os objetos são uma parte fundamental do JavaScript, servindo como espinha dorsal para armazenar e gerenciar dados. Um objeto é uma coleção de propriedades e cada propriedade é uma associação entre uma chave (ou nome) e um valor. Compreender como criar, manipular e utilizar objetos é crucial para qualquer desenvolvedor JavaScript. Neste artigo, exploraremos as várias funções de objeto em JavaScript, fornecendo explicações detalhadas, exemplos e comentários para ajudá-lo a dominá-los.

Introdução aos objetos em JavaScript

Em JavaScript, objetos são usados ​​para armazenar coleções de dados e entidades mais complexas. Eles são criados usando objetos literais ou o construtor Object.

// Using object literals
let person = {
    name: "John",
    age: 30,
    city: "New York"
};

// Using the Object constructor
let person = new Object();
person.name = "John";
person.age = 30;
person.city = "New York";

Propriedades do objeto

• Object.prototype: Todo objeto JavaScript herda propriedades e métodos de seu protótipo.

let obj = {};
console.log(obj.__proto__ === Object.prototype); // Output: true

Métodos de objeto

1. Object.assign()

Copia os valores de todas as propriedades próprias enumeráveis ​​de um ou mais objetos de origem para um objeto de destino. Ele retorna o objeto de destino.

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

2. Object.create()

Cria um novo objeto com o objeto protótipo e as propriedades especificadas.

let person = {
    isHuman: false,
    printIntroduction: function() {
        console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
    }
};

let me = Object.create(person);
me.name = "Matthew";
me.isHuman = true;
me.printIntroduction(); // Output: My name is Matthew. Am I human? true

3. Object.defineProperties()

Define novas propriedades ou modifica propriedades existentes diretamente em um objeto, retornando o objeto.

let obj = {};
Object.defineProperties(obj, {
    property1: {
        value: true,
        writable: true
    },
    property2: {
        value: "Hello",
        writable: false
    }
});
console.log(obj); // Output: { property1: true, property2: 'Hello' }

4. Object.defineProperty()

Define uma nova propriedade diretamente em um objeto ou modifica uma propriedade existente e retorna o objeto.

let obj = {};
Object.defineProperty(obj, 'property1', {
    value: 42,
    writable: false
});
console.log(obj.property1); // Output: 42
obj.property1 = 77; // No error thrown, but the property is not writable
console.log(obj.property1); // Output: 42

5. Objeto.entradas()

Retorna uma matriz de pares de propriedades [chave, valor] enumeráveis ​​com chave de string do próprio objeto.

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

6. Object.freeze()

Congela um objeto. Um objeto congelado não pode mais ser alterado; congelar um objeto evita que novas propriedades sejam adicionadas a ele, propriedades existentes sejam removidas e evita que os valores das propriedades existentes sejam alterados.

let obj = {prop: 42};
Object.freeze(obj);
obj.prop = 33; // Fails silently in non-strict mode
console.log(obj.prop); // Output: 42

7. Object.fromEntries()

Transforma uma lista de pares de valores-chave em um objeto.

let entries = new Map([['foo', 'bar'], ['baz', 42]]);
let obj = Object.fromEntries(entries);
console.log(obj); // Output: { foo: 'bar', baz: 42 }

8. Object.getOwnPropertyDescriptor()

Retorna um descritor de propriedade para uma propriedade própria (ou seja, uma propriedade diretamente presente em um objeto e não na cadeia de protótipos do objeto) de um determinado objeto.

let obj = {property1: 42};
let descriptor = Object.getOwnPropertyDescriptor(obj, 'property1');
console.log(descriptor);
// Output: { value: 42, writable: true, enumerable: true, configurable: true }

9. Object.getOwnPropertyDescriptors()

Retorna um objeto contendo todos os descritores de propriedade próprios de um objeto.

let obj = {property1: 42};
let descriptors = Object.getOwnPropertyDescriptors(obj);
console.log(descriptors);
/* Output:
{
  property1: {
    value: 42,
    writable: true,
    enumerable: true,
    configurable: true
  }
}
*/

10.Object.getOwnPropertyNames()

Retorna uma matriz de todas as propriedades (incluindo propriedades não enumeráveis, exceto aquelas que usam Símbolo) encontradas diretamente em um determinado objeto.

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

11. Object.getOwnPropertySymbols()

Retorna uma matriz de todas as propriedades de símbolos encontradas diretamente em um determinado objeto.

let obj = {};
let sym = Symbol('foo');
obj[sym] = 'bar';
let symbols = Object.getOwnPropertySymbols(obj);
console.log(symbols); // Output: [Symbol(foo)]

12.Object.getPrototypeOf()

Retorna o protótipo (ou seja, o valor da propriedade interna [[Prototype]]) do objeto especificado.

let proto = {};
let obj = Object.create(proto);
console.log(Object.getPrototypeOf(obj) === proto); // Output: true

13. Objeto.é()

Determina se dois valores são iguais.

console.log(Object.is('foo', 'foo')); // Output: true
console.log(Object.is({}, {})); // Output: false

14. Object.isExtensible()

Determina se a extensão de um objeto é permitida.

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

15. Object.isFrozen()

Determina se um objeto está congelado.

let obj = {};
console.log(Object.isFrozen(obj)); // Output: false
Object.freeze(obj);
console.log(Object.isFrozen(obj)); // Output: true

16. Object.isSealed()

Determina se um objeto está selado.

let obj = {};
console.log(Object.isSealed(obj)); // Output: false
Object.seal(obj);
console.log(Object.isSealed(obj)); // Output: true

17. Object.keys()

Retorna uma matriz de nomes de propriedades enumeráveis ​​do próprio objeto, iterados na mesma ordem que um loop normal faria.

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

18. Object.preventExtensions()

Impede quaisquer extensões de um objeto.

let obj = {};
Object.preventExtensions(obj);
obj.newProp = 'test'; // Throws an error in strict mode
console.log(obj.newProp); // Output: undefined

19. Objeto.selo()

Sela um objeto, evitando que novas propriedades sejam adicionadas a ele e marcando todas as propriedades existentes como não configuráveis. Os valores das propriedades atuais ainda podem ser alterados, desde que sejam graváveis.

let obj = {property1: 42};
Object.seal(obj);
obj.property1 = 33;
delete obj.property1; // Throws an error in strict mode
console.log(obj.property1); // Output: 33

20.Object.setPrototypeOf()

Define o protótipo (ou seja, a propriedade [[Prototype]] interna) de um objeto especificado para outro objeto ou nulo.

let proto = {};
let obj = {};
Object.setPrototypeOf(obj, proto);
console.log(Object.getPrototypeOf(obj) === proto); // Output: true

21. Object.valores()

Retorna uma matriz de valores de propriedades enumeráveis ​​do próprio objeto, na mesma ordem fornecida por um loop for...in.

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

Exemplos práticos

Exemplo 1: clonando um objeto

Usando Object.assign() para clonar um objeto.

let obj = {a: 1, b: 2};
let clone = Object.assign({}, obj);
console.log(clone); // Output: {a: 1, b: 2}

Exemplo 2: Mesclando Objetos

Usando Object.assign() para mesclar objetos.

let obj1 = {a: 1, b: 2};
let obj2 = {b: 3, c: 4};
let merged = Object.assign({},

 obj1, obj2);
console.log(merged); // Output: {a: 1, b: 3, c: 4}

Exemplo 3: Criando um Objeto com um Protótipo Especificado

Usando Object.create() para criar um objeto com um protótipo especificado.

let proto = {greet: function() { console.log("Hello!"); }};
let obj = Object.create(proto);
obj.greet(); // Output: Hello!

Exemplo 4: Definindo Propriedades Imutáveis

Usando Object.defineProperty() para definir propriedades imutáveis.

let obj = {};
Object.defineProperty(obj, 'immutableProp', {
    value: 42,
    writable: false
});
console.log(obj.immutableProp); // Output: 42
obj.immutableProp = 77; // Throws an error in strict mode
console.log(obj.immutableProp); // Output: 42

Exemplo 5: Convertendo um Objeto em um Array

Usando Object.entries() para converter um objeto em uma matriz de pares de valores-chave.

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

Conclusão

Os objetos são um componente central do JavaScript, oferecendo uma maneira flexível de gerenciar e manipular dados. Ao dominar as funções dos objetos, você pode executar operações complexas com facilidade e escrever códigos mais eficientes e de fácil manutenção. Este guia abrangente cobriu as funções de objeto mais importantes em JavaScript, completo com exemplos e explicações detalhadas. Pratique o uso dessas funções e experimente diferentes casos de uso para aprofundar sua compreensão e aprimorar suas habilidades de codificação.