JavaScript é uma linguagem de programação amplamente utilizada para desenvolvimento web. Uma das características mais poderosas do JavaScript é o suporte a objetos, permitindo que os desenvolvedores criem estruturas de dados complexas e reutilizáveis. Neste artigo, vamos explorar em detalhes como trabalhar com objetos em JavaScript. Abordaremos desde a criação de objetos até a manipulação de propriedades e métodos.
Criação de Objetos
Em JavaScript, existem várias formas de criar objetos. Vamos explorar três métodos comuns de criação de objetos: objetos literais, construtores de objetos e protótipos.
Objetos Literais
A forma mais simples e direta de criar um objeto em JavaScript é usando a notação de objetos literais. Um objeto literal é delimitado por chaves ({}) e contém pares de chave-valor para representar suas propriedades.
Exemplo de criação de um objeto literal:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro'
};Neste exemplo, criamos um objeto chamado “pessoa” com três propriedades: “nome”, “idade” e “profissao”.
Construtores de Objetos
Outra forma comum de criar objetos em JavaScript é usando construtores de objetos. Os construtores são funções que servem como modelos para a criação de novos objetos com características semelhantes.
Exemplo de criação de um construtor de objetos:
function Pessoa(nome, idade, profissao) {
this.nome = nome;
this.idade = idade;
this.profissao = profissao;
}
const pessoa1 = new Pessoa('Maria', 25, 'Advogada');
const pessoa2 = new Pessoa('Pedro', 35, 'Professor');Nesse exemplo, criamos um construtor de objetos chamado “Pessoa” que recebe três parâmetros: “nome”, “idade” e “profissao”. Usando a palavra-chave “new”, podemos criar instâncias desse objeto e definir os valores das propriedades para cada instância.
Protótipos
Os protótipos são um mecanismo fundamental em JavaScript para compartilhar propriedades e métodos entre objetos. Cada objeto em JavaScript tem um protótipo, que pode ser usado para herdar propriedades e métodos de outros objetos.
Exemplo de criação de um objeto com protótipo:
const animalPrototype = {
tipo: 'Desconhecido',
som: function() {
console.log('Som desconhecido');
}
};
const gato = Object.create(animalPrototype);
gato.tipo = 'Gato';
gato.som = function() {
console.log('Miau');
};
gato.som(); // Saída: "Miau"Neste exemplo, criamos um objeto chamado “animalPrototype” com duas propriedades: “tipo” e “som”. Em seguida, usamos o método “Object.create()” para criar um novo objeto chamado “gato” com base no protótipo “animalPrototype”. O objeto “gato” possui sua própria implementação do método “som” e sobrescreve a propriedade “tipo” do protótipo.
Propriedades e Métodos
Os objetos em JavaScript possuem propriedades, que são valores associados a uma chave, e métodos, que são funções associadas a um objeto. Vamos explorar a manipulação de propriedades e a definição de métodos em objetos.
Propriedades
As propriedades em um objeto podem ser acessadas e manipuladas de diferentes maneiras.
Acesso a Propriedades
Para acessar o valor de uma propriedade
em um objeto, podemos usar a notação de ponto (.) ou a notação de colchetes ([]).
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro'
};
console.log(pessoa.nome); // Saída: "João"
console.log(pessoa['idade']); // Saída: 30Ambas as formas de acesso retornam o valor da propriedade correspondente.
Definição de Propriedades
Para definir ou modificar o valor de uma propriedade em um objeto, podemos usar a mesma notação de ponto (.) ou colchetes ([]).
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro'
};
pessoa.nome = 'Carlos';
pessoa['idade'] = 35;
console.log(pessoa.nome); // Saída: "Carlos"
console.log(pessoa['idade']); // Saída: 35Nesse exemplo, modificamos os valores das propriedades “nome” e “idade” do objeto “pessoa”.
Enumerando Propriedades
Para percorrer todas as propriedades de um objeto, podemos usar a estrutura de repetição “for…in” ou os métodos “Object.keys()”, “Object.values()” e “Object.entries()”.
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro'
};
for (let prop in pessoa) {
console.log(prop + ': ' + pessoa[prop]);
}
// Saída:
// nome: João
// idade: 30
// profissao: Engenheiro
const chaves = Object.keys(pessoa);
console.log(chaves); // Saída: ["nome", "idade", "profissao"]
const valores = Object.values(pessoa);
console.log(valores); // Saída: ["João", 30, "Engenheiro"]
const entradas = Object.entries(pessoa);
console.log(entradas);
// Saída:
// [["nome", "João"], ["idade", 30], ["profissao", "Engenheiro"]]Essas são algumas formas de percorrer e manipular as propriedades de um objeto em JavaScript.
Métodos
Os métodos são funções associadas a um objeto. Eles podem ser definidos diretamente em um objeto ou herdados de um protótipo.
Definição de Métodos
Para adicionar um método a um objeto, basta atribuir uma função a uma propriedade.
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro',
saudacao: function() {
console.log('Olá, meu nome é ' + this.nome);
}
};
pessoa.saudacao(); // Saída: "Olá, meu nome é João"Nesse exemplo, definimos o método “saudacao” no objeto “pessoa”. A função do método imprime uma saudação com base no valor da propriedade “nome”.
Invocação de Métodos
Para invocar um método em um objeto, usamos a notação de ponto (.) após o nome do objeto, seguido pelo nome do método e parênteses.
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro',
saudacao: function() {
console.log('Olá, meu nome é ' + this.nome);
}
};
pessoa.saudacao(); // Saída: "Olá, meu nome é João"Neste exemplo, invocamos o método “saudacao()” no objeto “pessoa”.
Contexto de Execução (this)
Dentro de um método, a palavra-chave “this” se refere ao objeto em que o método está sendo invocado. O “this” permite acessar outras propriedades do objeto dentro do método.
Exemplo:
const pessoa = {
nome: 'João',
idade: 30,
profissao: 'Engenheiro',
saudacao: function() {
console.log('Olá, meu nome é ' + this.nome + ' e eu tenho ' + this.idade + ' anos.');
}
};
pessoa.saudacao(); // Saída: "Olá, meu nome é João e eu tenho 30 anos."Neste exemplo, o “this.nome” e o “this.idade” referem-se às propriedades do objeto “pessoa”.
A criação e manipulação de objetos em JavaScript são fundamentais para o desenvolvimento de aplicações robustas e interativas. Neste artigo, exploramos a criação de objetos usando objetos literais, construtores de objetos e protótipos. Também vimos como trabalhar com propriedades e métodos em objetos, incluindo o acesso, definição, enumeração e invocação.
Dominar esses conceitos permitirá que você crie e manipule objetos com facilidade em JavaScript, expandindo suas capacidades como desenvolvedor.
Herança e Prototipagem
Herança Baseada em Protótipos
Conceito de Protótipo
No contexto da programação orientada a objetos, o conceito de protótipo refere-se a um objeto que serve como base para a criação de novos objetos. Um protótipo contém propriedades e métodos que podem ser compartilhados por múltiplos objetos. Em JavaScript, por exemplo, a herança é baseada em protótipos.
Exemplo:
function Animal(nome) {
this.nome = nome;
}
Animal.prototype.dizerNome = function() {
console.log("Meu nome é " + this.nome);
};
var gato = new Animal("Tom");
gato.dizerNome(); // Saída: "Meu nome é Tom"Nesse exemplo, temos um construtor Animal que recebe um parâmetro nome. A função dizerNome é adicionada ao protótipo de Animal, permitindo que todos os objetos criados a partir do construtor Animal possam acessar esse método.
Criando uma Cadeia de Protótipos
Uma cadeia de protótipos, também conhecida como cadeia de herança, é uma estrutura na qual um objeto herda propriedades e métodos de outro objeto, que por sua vez pode herdar de outro objeto e assim por diante. Essa estrutura permite a reutilização de código e a organização hierárquica de objetos.
Exemplo:
function Animal(nome) {
this.nome = nome;
}
Animal.prototype.dizerNome = function() {
console.log("Meu nome é " + this.nome);
};
function Gato(nome) {
Animal.call(this, nome);
}
Gato.prototype = Object.create(Animal.prototype);
Gato.prototype.constructor = Gato;
var gato = new Gato("Tom");
gato.dizerNome(); // Saída: "Meu nome é Tom"Nesse exemplo, temos um construtor Gato que herda de Animal. A função Object.create é utilizada para criar um novo objeto que possui o protótipo de Animal. Dessa forma, os objetos criados a partir do construtor Gato podem acessar as propriedades e métodos definidos no protótipo de Animal, como o método dizerNome.
Herança de Propriedades e Métodos
Na herança baseada em protótipos, os objetos podem herdar tanto propriedades quanto métodos do protótipo. Isso significa que, ao criar um novo objeto a partir de um construtor, o objeto terá acesso tanto às propriedades quanto aos métodos definidos no protótipo.
Exemplo:
function Animal(nome) {
this.nome = nome;
}
Animal.prototype.dizerNome = function() {
console.log("Meu nome é " + this.nome);
};
function Gato(nome, cor) {
Animal.call(this, nome);
this.cor = cor;
}
Gato.prototype = Object.create(Animal.prototype);
Gato.prototype.constructor = Gato;
Gato.prototype.dizerCor = function() {
console.log("Minha cor é " + this.cor);
};
var gato = new Gato("Tom", "preto");
gato.dizerNome(); // Saída: "Meu nome é Tom"
gato.dizerCor(); // Saída: "Minha cor é preto"Nesse exemplo, além de herdar o método dizerNome do protótipo de Animal, o objeto gato criado a partir do construtor Gato também possui a propriedade cor. O método dizerCor é adicionado ao protótipo de Gato para que todos os objetos criados a partir desse construtor possam acessar esse método.
Construtores e Protótipos
Funções Construtoras
Uma função construtora é uma função que é usada para criar novos objetos a partir de um molde ou modelo. Ela define as propriedades e métodos que cada novo objeto criado a partir dela terá. Em JavaScript, as funções construtoras são comumente utilizadas em conjunto com a palavra-chave new.
Exemplo:
function Pessoa(nome, idade) {
this.nome = nome;
this.idade = idade;
}
var pessoa1 = new Pessoa("João", 25);
var pessoa2 = new Pessoa("Maria", 30);
console.log(pessoa1.nome); // Saída: "João"
console.log(pessoa2.idade); // Saída: 30Nesse exemplo, a função Pessoa é uma função construtora que recebe os parâmetros nome e idade. Ao utilizar a palavra-chave new junto com a função construtora, é criado um novo objeto com as propriedades definidas na função.
Modificando o Protótipo
É possível modificar o protótipo de um objeto ou função construtora para adicionar novas propriedades e métodos. Essa modificação afetará todos os objetos criados a partir daquele protótipo.
Exemplo:
function Pessoa(nome) {
this.nome = nome;
}
Pessoa.prototype.dizerOla = function() {
console.log("Olá, meu nome é " + this.nome);
};
var pessoa = new Pessoa("João");
pessoa.dizerOla(); // Saída: "Olá, meu nome é João"Nesse exemplo, a função dizerOla é adicionada ao protótipo da função construtora Pessoa. Dessa forma, todos os objetos criados a partir de Pessoa terão acesso a esse método.
Herança de Construtores
É possível estabelecer uma relação de herança entre duas funções construtoras, permitindo que um objeto herde propriedades e métodos da outra função construtora. Isso é feito por meio da manipulação dos protótipos.
Exemplo:
function Animal(nome) {
this.nome = nome;
}
Animal.prototype.dizerNome = function() {
console.log("Meu nome é " + this.nome);
};
function Cachorro(nome, raca) {
Animal.call(this, nome);
this.raca = raca;
}
Cachorro.prototype = Object.create(Animal.prototype);
Cachorro.prototype.constructor = Cachorro;
Cachorro.prototype.dizerRaca = function() {
console.log("Minha raça é " + this.raca);
};
var cachorro = new Cachorro("Max", "Labrador");
cachorro.dizerNome(); // Saída: "Meu nome é Max"
cachorro.dizerRaca(); // Saída: "Minha raça é Labrador"Nesse exemplo, a função construtora Cachorro herda tanto as propriedades quanto os métodos da função construtora Animal. A função Animal.call(this, nome) é utilizada para chamar o construtor de Animal dentro de Cachorro e garantir que as propriedades sejam corretamente definidas para os objetos criados a partir de Cachorro. O protótipo de Cachorro é configurado para ser um novo objeto que possui o protótipo de Animal, permitindo a herança dos métodos.
Encapsulamento e Abstração
Encapsulamento de Propriedades e Métodos
Atributos Privados
No contexto da programação orientada a objetos, o encapsulamento é um princípio que permite controlar o acesso aos atributos e métodos de um objeto, definindo quais são públicos e quais são privados. Atributos privados são aqueles que só podem ser acessados internamente pela própria classe ou objeto.
Exemplo:
class Pessoa {
#nome; // Atributo privado
constructor(nome) {
this.#nome = nome;
}
getNome() {
return this.#nome;
}
}
const pessoa = new Pessoa("João");
console.log(pessoa.getNome()); // Saída: "João"
console.log(pessoa.#nome); // Erro: Atributo privado não acessível externamenteNesse exemplo, a classe Pessoa possui um atributo privado #nome, que só pode ser acessado internamente pela classe. O método getNome() é um método público que permite obter o valor do atributo privado.
Atributos Públicos
Atributos públicos são aqueles que podem ser acessados e modificados externamente à classe ou objeto. Eles são acessíveis por qualquer parte do programa que tenha acesso à instância do objeto.
Exemplo:
class Pessoa {
nome; // Atributo público
constructor(nome) {
this.nome = nome;
}
}
const pessoa = new Pessoa("Maria");
console.log(pessoa.nome); // Saída: "Maria"
pessoa.nome = "Ana";
console.log(pessoa.nome); // Saída: "Ana"Nesse exemplo, a classe Pessoa possui um atributo público nome, que pode ser acessado e modificado diretamente pelo código externo à classe.
Acesso aos Atributos
O acesso aos atributos pode ser controlado por meio de métodos públicos, permitindo a leitura e/ou modificação dos valores dos atributos de forma segura e controlada. Esses métodos são chamados de “métodos getters” e “métodos setters”.
Exemplo:
class Pessoa {
#nome; // Atributo privado
constructor(nome) {
this.#nome = nome;
}
get nome() {
return this.#nome;
}
set nome(novoNome) {
this.#nome = novoNome;
}
}
const pessoa = new Pessoa("Carlos");
console.log(pessoa.nome); // Saída: "Carlos"
pessoa.nome = "Pedro";
console.log(pessoa.nome); // Saída: "Pedro"Nesse exemplo, a classe Pessoa define os métodos getters e setters para o atributo privado #nome. Dessa forma, o acesso ao atributo é controlado por meio desses métodos.
Abstração de Objetos
Definindo Interfaces
A abstração é um princípio fundamental da programação orientada a objetos que permite representar
objetos do mundo real por meio de modelos simplificados, definindo suas características essenciais. Através da abstração, é possível criar interfaces que especificam os comportamentos e propriedades relevantes de um objeto, ocultando os detalhes de implementação.
Exemplo:
interface Animal {
nome: string;
emitirSom(): void;
}
class Cachorro implements Animal {
nome: string;
constructor(nome: string) {
this.nome = nome;
}
emitirSom(): void {
console.log("Au au!");
}
}
const cachorro = new Cachorro("Max");
console.log(cachorro.nome); // Saída: "Max"
cachorro.emitirSom(); // Saída: "Au au!"Nesse exemplo, a interface Animal define a estrutura que um objeto do tipo Animal deve ter, especificando as propriedades e o método emitirSom(). A classe Cachorro implementa a interface Animal, garantindo que ela possua as propriedades e o método especificados pela interface.
Ocultando Detalhes de Implementação
A abstração também permite ocultar os detalhes de implementação de um objeto, fornecendo apenas a interface necessária para interagir com ele. Isso significa que o código externo só precisa conhecer as operações disponíveis e não precisa saber como essas operações são realizadas internamente.
Exemplo:
class Retangulo {
#largura: number;
#altura: number;
constructor(largura: number, altura: number) {
this.#largura = largura;
this.#altura = altura;
}
getArea(): number {
return this.#largura * this.#altura;
}
}
const retangulo = new Retangulo(5, 3);
console.log(retangulo.getArea()); // Saída: 15
console.log(retangulo.#largura); // Erro: Atributo privado não acessível externamenteNesse exemplo, a classe Retangulo possui atributos privados #largura e #altura, que não são acessíveis externamente. O método getArea() permite obter a área do retângulo, sem expor os detalhes de implementação. Dessa forma, o código externo só precisa saber como utilizar a interface pública da classe, sem precisar conhecer os detalhes internos.
Manipulação de Objetos
Clonagem de Objetos
Clonagem Superficial
A clonagem de objetos é o processo de criar uma cópia de um objeto existente. Na clonagem superficial, apenas as propriedades de nível superior são copiadas para o novo objeto, enquanto as propriedades internas são referenciadas ao objeto original.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
endereco: {
rua: "Rua A",
cidade: "Cidade X"
}
};
const clone = { ...pessoa };
console.log(clone === pessoa); // Saída: false
console.log(clone.endereco === pessoa.endereco); // Saída: true (referência ao objeto original)Nesse exemplo, o operador spread (...) é utilizado para realizar a clonagem superficial do objeto pessoa para o objeto clone. Embora as propriedades de nível superior sejam copiadas, a propriedade endereco mantém a referência ao objeto original.
Clonagem Profunda
Ao contrário da clonagem superficial, a clonagem profunda cria uma cópia completa do objeto, incluindo as propriedades internas. Isso significa que os objetos internos também são clonados, garantindo que não haja referências ao objeto original.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
endereco: {
rua: "Rua A",
cidade: "Cidade X"
}
};
const clone = JSON.parse(JSON.stringify(pessoa));
console.log(clone === pessoa); // Saída: false
console.log(clone.endereco === pessoa.endereco); // Saída: false (clonagem profunda)Nesse exemplo, a clonagem profunda é realizada convertendo o objeto pessoa para uma string JSON por meio de JSON.stringify(), e então convertendo a string JSON de volta para um objeto por meio de JSON.parse(). Isso cria um novo objeto, eliminando as referências ao objeto original.
Iteração de Propriedades
For…in Loop
O loop for...in é uma forma de iterar sobre as propriedades enumeráveis de um objeto. Ele percorre todas as propriedades enumeráveis, incluindo as propriedades herdadas.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
cidade: "Cidade X"
};
for (let prop in pessoa) {
console.log(prop + ": " + pessoa[prop]);
}Nesse exemplo, o loop for...in é utilizado para iterar sobre as propriedades do objeto pessoa. A cada iteração, o nome da propriedade é armazenado na variável prop e o valor da propriedade é acessado por pessoa[prop].
Object.keys()
O método Object.keys() retorna um array contendo as chaves das propriedades enumeráveis de um objeto. Ele permite iterar apenas
sobre as chaves do objeto, excluindo as propriedades herdadas.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
cidade: "Cidade X"
};
const chaves = Object.keys(pessoa);
for (let chave of chaves) {
console.log(chave + ": " + pessoa[chave]);
}Nesse exemplo, Object.keys() é utilizado para obter um array com as chaves do objeto pessoa. O loop for...of é utilizado para iterar sobre as chaves e acessar os valores correspondentes no objeto.
Object.values()
O método Object.values() retorna um array contendo os valores das propriedades enumeráveis de um objeto. Ele permite iterar apenas sobre os valores do objeto, excluindo as chaves.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
cidade: "Cidade X"
};
const valores = Object.values(pessoa);
for (let valor of valores) {
console.log(valor);
}Nesse exemplo, Object.values() é utilizado para obter um array com os valores do objeto pessoa. O loop for...of é utilizado para iterar sobre os valores e exibi-los.
Object.entries()
O método Object.entries() retorna um array contendo arrays de pares chave-valor das propriedades enumeráveis de um objeto. Ele permite iterar tanto sobre as chaves quanto sobre os valores do objeto.
Exemplo:
const pessoa = {
nome: "João",
idade: 25,
cidade: "Cidade X"
};
const entradas = Object.entries(pessoa);
for (let [chave, valor] of entradas) {
console.log(chave + ": " + valor);
}Nesse exemplo, Object.entries() é utilizado para obter um array contendo arrays de pares chave-valor do objeto pessoa. O loop for...of é utilizado para iterar sobre esses pares e exibi-los.
Manipulação de Protótipos
Modificando Protótipos Existente
Adicionando Propriedades
É possível adicionar novas propriedades a um protótipo existente em JavaScript. As novas propriedades serão compartilhadas por todos os objetos que herdam desse protótipo.
Exemplo:
function Pessoa(nome) {
this.nome = nome;
}
Pessoa.prototype.falar = function() {
console.log("Olá, meu nome é " + this.nome);
};
var pessoa = new Pessoa("João");
pessoa.falar(); // Saída: "Olá, meu nome é João"
Pessoa.prototype.idade = 25;
console.log(pessoa.idade); // Saída: 25Nesse exemplo, a função construtora Pessoa define um método falar() no protótipo. Em seguida, uma nova propriedade idade é adicionada ao protótipo. O objeto pessoa, que foi criado antes da adição da propriedade, agora tem acesso à propriedade idade.
Removendo Propriedades
Em JavaScript, é possível remover propriedades de um protótipo existente utilizando o operador delete. No entanto, é importante notar que isso afetará todos os objetos que herdam do protótipo.
Exemplo:
function Pessoa(nome) {
this.nome = nome;
}
Pessoa.prototype.falar = function() {
console.log("Olá, meu nome é " + this.nome);
};
var pessoa = new Pessoa("João");
pessoa.falar(); // Saída: "Olá, meu nome é João"
delete Pessoa.prototype.falar;
pessoa.falar(); // Erro: falar is not a functionNesse exemplo, a propriedade falar é removida do protótipo da função construtora Pessoa. Após a remoção, a chamada do método pessoa.falar() resultará em um erro, pois o método não está mais disponível no protótipo.
Modificando Métodos
Os métodos existentes em um protótipo podem ser modificados atribuindo-se uma nova função a eles. Essa alteração afetará todos os objetos que herdam desse protótipo.
Exemplo:
function Pessoa(nome) {
this.nome = nome;
}
Pessoa.prototype.falar = function() {
console.log("Olá, meu nome é " + this.nome);
};
var pessoa = new Pessoa("João");
pessoa.falar(); // Saída: "Olá, meu nome é João"
Pessoa.prototype.falar = function() {
console.log("Oi, eu sou o " + this.nome);
};
pessoa.falar(); // Saída: "Oi, eu sou o João"Nesse exemplo, o método falar() do protótipo é inicialmente definido para exibir “Olá, meu nome é [nome]”. Em seguida, o método é modificado para exibir “Oi, eu sou o [nome]”. Todas as instâncias de Pessoa, incl
uindo pessoa, refletem a alteração no método.
Criando Novos Objetos a partir de Protótipos
Object.create()
O método Object.create() permite criar um novo objeto utilizando um protótipo existente. O novo objeto será um protótipo do objeto pai, herdando suas propriedades e métodos.
Exemplo:
var pessoa = {
nome: "João",
falar: function() {
console.log("Olá, meu nome é " + this.nome);
}
};
var pessoaNova = Object.create(pessoa);
pessoaNova.falar(); // Saída: "Olá, meu nome é João"Nesse exemplo, o objeto pessoa é definido com uma propriedade nome e um método falar(). Em seguida, o método Object.create() é utilizado para criar um novo objeto pessoaNova, que herda o protótipo do objeto pessoa. O novo objeto pode acessar as propriedades e métodos do objeto pai.
Mixins
Os mixins são um padrão de design em JavaScript que permite combinar várias funcionalidades de diferentes objetos em um único objeto, por meio da cópia de propriedades e métodos de outros objetos.
Exemplo:
var canSwim = {
nadar: function() {
console.log("Nadando...");
}
};
var canFly = {
voar: function() {
console.log("Voando...");
}
};
function Animal() {}
Object.assign(Animal.prototype, canSwim, canFly);
var pato = new Animal();
pato.nadar(); // Saída: "Nadando..."
pato.voar(); // Saída: "Voando..."Nesse exemplo, dois objetos (canSwim e canFly) são criados, cada um contendo funcionalidades específicas. Em seguida, as propriedades e métodos desses objetos são copiados para o protótipo da função construtora Animal por meio do Object.assign(). O objeto pato é criado a partir de Animal e herda as funcionalidades dos mixins canSwim e canFly, permitindo que ele nade e voe.
Conclusão
Dominar o trabalho com objetos em JavaScript é fundamental para se tornar um desenvolvedor web completo. Neste artigo, abordamos os principais aspectos do uso de objetos em JavaScript, desde a criação e manipulação até a herança e prototipagem. Esperamos que este guia detalhado tenha fornecido uma compreensão sólida sobre como trabalhar com objetos em JavaScript, permitindo que você crie aplicações mais complexas e reutilizáveis.
Lembre-se de praticar e explorar ainda mais os conceitos apresentados aqui. Aprofundar seu conhecimento em JavaScript e objetos certamente abrirá portas para a criação de projetos ainda mais poderosos e sofisticados.
Leia também: 5 plataformas de criação de logotipos online e gratuitas
Material de apoio: https://www.freecodecamp.org/news/objects-in-javascript-for-beginners/
