70 perguntas e respostas para entrevista de emprego JavaScript em 2024

JavaScript é uma linguagem de script orientada a objetos, interpretada e leve. Ela permite adicionar interatividade a páginas HTML estáticas. Os principais navegadores modernos da web, como Google Chrome, Mozilla Firefox, Microsoft Edge e Safari, incluem suporte ao núcleo da linguagem para possibilitar a execução de scripts e a criação de experiências interativas para os usuários.

Ele é uma linguagem de programação que é usada principalmente para criar interatividade em páginas da web. O JavaScript roda no client-side (navegador) e é capaz de alterar o conteúdo de uma página da web sem precisar recarregar a página inteira, melhorando sua performance. Além disso, o JavaScript também é usado em servidores web (por meio de plataformas como o Node.js) e em aplicativos mobile (por meio de ferramentas como React Native).

Estas são as vantagens do JavaScript:

• Melhora Interativa: JavaScript interage com páginas da web estáticas e as faz responder aos inputs dos usuários.
• Feedback Rápido: Com o uso de JavaScript, não há necessidade de recarregar uma página da web ao validar entradas de formulários. Isso proporciona uma resposta rápida e uma melhor experiência para o usuário.
• Interface de Usuário Rica: JavaScript ajuda a tornar a interface do usuário de aplicativos baseados na web mais atraente e com melhor usabilidade.
• Frameworks: JavaScript possui vastas bibliotecas e frameworks que podem ser amplamente usados para desenvolver jogos e aplicativos baseados na web.

Estas são algumas das mais importantes características do JavaScript:

• Compatibilidade com várias plataformas (cross-platform)
• Código aberto (open-source)
• Orientado a objetos
• Integração com diversas tecnologias front-end e back-end

Os geradores no ES6 podem ser usados em dois cenários principais:

Quando se quer sair de uma função, é possível fazê-lo usando geradores, e o código externo determina quando voltar à função.

Com a ajuda de geradores, é possível controlar uma chamada assíncrona fora do código. Mais importante ainda, o próximo valor pode vir apenas quando necessário, ou seja, todos os valores não precisam retornar de uma só vez.

As promises ajudam a gerenciar operações assíncronas, como solicitações de servidor em JavaScript. Anteriormente, os callbacks eram usados ​​para o mesmo propósito. No entanto, os callbacks têm funcionalidade limitada e, portanto, podem tornar o código difícil de gerenciar. Existem quatro estados do objeto promise:

Pending (pendente): Este é o primeiro estado da promise e indica que ela não foi cumprida nem rejeitada.

Fulfilled (cumprida): Este estado representa a conclusão da operação assíncrona. Em outras palavras, a promise foi cumprida.

Rejected (rejeitada): Este estado representa a falha da operação assíncrona devido a algum motivo. Em outras palavras, a promise foi rejeitada.

Settled (resolvida): Este é o último estado da promise, mostrando que ela foi cumprida ou rejeitada.

Um construtor promise usa um callback com dois parâmetros - resolve e reject - para criar uma promessa. A função resolve é chamada quando a operação assíncrona foi concluída com sucesso. A função reject é chamada quando a operação assíncrona falhou.

Existem três tipos principais de dados presentes em JavaScript:

Primitivos

• Números
• Strings
• Booleanos

Compostos

• Objetos
• Funções
• Arrays

Triviais

• Null
• Undefined

As Arrow functions são usadas em quase todos os lugares por conta das seguintes vantagens:

• Segurança de escopo: quando a Arrow function é usada em todos os lugares, ela promove a consistência do escopo porque o mesmo objeto é usado em todos os lugares. Se, por acaso, uma função padrão é usada juntamente com a Arrow function, há chances do escopo ficar confuso.
• Concisão: em comparação com a função padrão, a Arrow function é compacta, pois dispensa a necessidade de palavras-chave, chaves, parênteses, etc. em certos casos. É, portanto, mais fácil de ler e escrever.
• Clareza: quando a Arrow function é usada em todos os lugares, há uma certa consistência de escopo. Assim, sempre que uma função padrão é misturada com ela, ela se destaca distintamente. O desenvolvedor pode, portanto, procurar a próxima função superior para localizar o objeto "this" com mais facilidade.

A vantagem de usar a sintaxe arrow para um método em um construtor em JavaScript é que ela permite que a função mantenha o escopo do “this” do construtor. Isso ocorre porque as funções arrow não têm seu próprio contexto this, mas herdam o contexto this do pai. Isso significa que, se você estiver usando um método de objeto dentro de uma função de seta em um construtor, ele ainda terá acesso ao escopo do objeto em vez do escopo universal. Isso torna o código mais fácil de ler e entender, e evita erros comuns associados ao escopo do this em funções de construtor em JavaScript.

JavaScript é uma linguagem de tipagem dinâmica (dynamic typing).

As Arrow functions são uma funcionalidade introduzida na versão ES6 (ECMAScript 2015) do JavaScript. Elas permitem declarar funções de maneira mais curta e concisa, sem a necessidade de utilizar a palavra-chave function. As Arrow functions só podem ser usadas como expressões de função. Além disso, se a função tiver apenas uma expressão de retorno, a palavra-chave return pode ser omitida. Se o código da função tiver apenas uma linha, as chaves {} também podem ser omitidas. Além disso, se a função tiver apenas um parâmetro, os parênteses () também podem ser omitidos. As Arrow functions são especialmente úteis para funções simples e de curta duração.

Java é uma linguagem de programação de propósito geral baseada em classes, enquanto JavaScript é uma linguagem de script interpretada. Java é usada para criar aplicativos completos que podem ser executados em um único computador ou que podem ser distribuídos entre servidores e clientes em uma rede. Já o JavaScript é usado para criar páginas da web interativas que podem responder a ações do usuário.

Sim, o JavaScript diferencia maiúsculas de minúsculas. Isso significa que variáveis, funções e métodos escritos com letras maiúsculas e minúsculas são tratados como entidades diferentes pelo interpretador do JavaScript. Por exemplo, a variável "nome" é diferente da variável "Nome". Portanto, é importante prestar atenção às maiúsculas e minúsculas ao escrever código JavaScript.

O JavaScript foi criado por Brendan Eich em 1995, enquanto trabalhava na Netscape Communications Corporation.

Os encerramentos (closures) são uma característica importante em JavaScript que permitem que uma função tenha acesso às variáveis e parâmetros de sua função externa, mesmo depois que a função externa tenha retornado. Isso significa que as funções podem manter referência a variáveis que não estão mais em seu escopo atual.

Os encerramentos podem ser úteis para criar funções reutilizáveis que possam ser configuradas com diferentes parâmetros para retornar resultados diferentes. Além disso, eles também podem ajudar a manter o encapsulamento e a privacidade de dados em uma aplicação.

Existem três maneiras de declarar uma variável em JavaScript:

• Usando a palavra-chave var, que define uma variável com escopo de função ou escopo global.
• Usando a palavra-chave let, que define uma variável com escopo de bloco.
• Usando a palavra-chave const, que define uma variável com escopo de bloco, mas cujo valor não pode ser reatribuído.

A partir do ES6, a recomendação é usar let e const em vez de var para evitar problemas relacionados ao escopo de variáveis. Além disso, o uso de const deve ser priorizado sempre que possível, pois isso ajuda a prevenir mutações inesperadas de variáveis.

Navegadores modernos, como Chrome, Firefox, etc., incluem um depurador (debugger) integrado que pode ser aberto a qualquer momento pressionando a tecla apropriada, geralmente a tecla F12.

Em JavaScript, as funções são objetos que podem receber diferentes funções como argumentos e serem retornadas por outras funções. Um callback é uma função JavaScript passada para outra função como um argumento ou parâmetro. Essa função é executada quando a função à qual ela foi passada é executada.

== testa apenas a igualdade de valores; no entanto, '===' é um teste de igualdade mais rigoroso que retorna falso se o valor ou o tipo de duas variáveis forem diferentes.

Uma caixa prompt exibe uma caixa de diálogo interativa que apresenta um prompt opcional para os usuários inserirem algum texto. É normalmente usada quando os usuários querem inserir um número antes de entrar em uma página da web. Isso retorna uma string contendo o texto de entrada do usuário ou um valor nulo (null).

O Negative Infinity (negativo infinito) é um valor constante que representa o valor mais baixo disponível. Isso significa que nenhum número é menor que esse valor. O negativo infinito é calculado dividindo um número negativo por zero.

A desestruturação de objetos é uma funcionalidade do JavaScript para extrair as propriedades de um objeto e vinculá-las a variáveis. Ela pode ser usada para extrair várias propriedades em uma única declaração e pode alcançar propriedades de objetos aninhados. Quando uma propriedade não existe, a desestruturação de objetos pode definir valores padrão.

As seguintes são as convenções para nomear variáveis em JavaScript:

• Os nomes das variáveis não devem ser idênticos às palavras-chave reservadas. Por exemplo, var, let, const, etc.
• Os nomes das variáveis não podem começar com um valor numérico. Eles devem começar apenas com a letra ou o caractere de sublinhado.
• Os nomes das variáveis têm natureza sensível a maiúsculas e minúsculas.

JavaScript oferece suporte a conversão automática de tipos. Este é o método mais comum de conversão de tipos que os desenvolvedores JavaScript usam.

ViewState: É específico para o estado da página dentro do navegador em uma sessão.

SessionState: É específico do usuário, contém os dados da sessão do usuário e permite acesso a todos os dados nas páginas da web.

Os timers, ou temporizadores, podem ser usados para executar o código em um momento exato ou repetir o código dentro de um intervalo. Isso pode ser realizado empregando os métodos setTimeout, setInterval e clearInterval.

Uma variável declarada fora da definição de uma função é chamada de variável global, e seu escopo é em todo o seu programa. Isso significa que seu valor é acessível e pode ser alterado em todo o programa.

As variáveis globais podem apresentar alguns problemas, tais como:

• Colisão de nomes: Quando você tem muitas variáveis globais, pode haver colisão de nomes, o que significa que você pode acabar sobrescrevendo uma variável por engano.
• Dificuldade de debugging (depuração): Como as variáveis globais podem ser acessadas de qualquer lugar do programa, pode ser difícil rastrear onde uma variável foi modificada e por quê.
• Acoplamento de código: Quando você usa muitas variáveis globais, o seu código pode ficar mais acoplado e menos modular, o que pode tornar mais difícil a manutenção e a evolução do código.
• Efeitos colaterais inesperados: Quando uma variável global é modificada em uma parte do programa, pode haver efeitos colaterais inesperados em outras partes do programa, o que pode tornar o código mais difícil de entender e depurar.
• Concorrência: Se vários threads ou processos acessarem a mesma variável global, pode haver problemas de concorrência, como condições de corrida ou deadlock.

O caractere // é usado para comentários de uma única linha, e os caracteres /* */ são usados para comentários de várias linhas.

Em JavaScript, this se refere a um objeto que está executando a linha atual de código. É uma referência ao objeto que executa a função atual. Se a função que está sendo referenciada é regular, this se refere ao objeto global. Se a função é um método do objeto, this se refere ao próprio objeto.

O 4 e o 2, neste caso, comportam-se como inteiros, e "8" comporta-se como uma string. Portanto, 4 + 2 é igual a 6. Este 6 é adicionado na string, resultando em: 6+"8"= 68.

As palavras-chave comumente usadas para lidar com exceções são: try, catch, finally, e throw.

Chamando o método window.print() no navegador, podemos imprimir o conteúdo da janela atual usando JavaScript.

Usando document.form[0].submit(), você pode enviar um formulário usando JavaScript.

• Loop while: um fluxo de controle de loop while que permite que o código seja executado repetidamente em resposta a uma condição Boolean. O loop while é considerado um if statement repetido.
• Loop for: um loop for oferece uma estrutura fácil de escrever. Em contraste com um loop while, a instrução for combina um processo de inicialização, condição e incremento / decremento em uma linha, fornecendo uma estrutura de repetição mais simples e fácil de entender.
• Do-While: Um loop do-while é como um loop while, mas com a exceção de que ele examina a condição após a execução das instruções, por isso é uma instância do Loop de Controle de Saída.

O processo de leitura de um cookie com JavaScript é muito fácil. Podemos usar a string document.cookie para armazenar os cookies que acabamos de criar com a string. Ela armazena uma lista de pares nome-valor separados por ponto e vírgula. O "name" é o nome atribuído ao cookie e o "value" é o seu valor. Você também pode usar o método split() para separar o valor do cookie em valores e keys (chaves).

Se você deseja excluir um cookie para que as tentativas futuras de lê-lo em JavaScript não retornem nada, é necessário alterar a data de expiração para uma data no passado. Definir o caminho do cookie é importante para garantir que você esteja apagando o cookie correto. Alguns navegadores não permitem excluir um cookie se o caminho não estiver especificado.

Para criar cookies usando JavaScript, você deve atribuir um valor de string ao objeto document.cookie.

Attributes: Eles fornecem mais detalhes sobre um elemento, como id, tipo, valor, etc.

Properties: O valor atribuído à propriedade, como type="text" value='Nome'.

Abaixo estão os métodos pelos quais um elemento HTML pode ser usado no código JavaScript:

• getElementById('nomeid'): obtém um elemento pelo seu nome de ID.
• getElementsByClass('nomeclasse'): obtém todos os elementos que possuem o nome de classe fornecido.
• getElementsByTagName('nomedatag'): obtém todos os elementos com o nome da tag fornecida.
• querySelector(): retorna o primeiro elemento selecionado usando um seletor de estilo CSS.

No JavaScript, funções síncronas são aquelas que são executadas em sequência, uma após a outra, e o controle é retornado para o chamador apenas quando a execução da função é concluída. Durante a execução de uma função síncrona, outras partes do código não são executadas, o que pode resultar em bloqueio ou congelamento do aplicativo se a execução da função for longa.

Por outro lado, funções assíncronas são executadas de forma não sequencial e o controle é retornado para o chamador imediatamente após a chamada da função, sem esperar a conclusão da execução da função. Em vez disso, a função assíncrona é executada em segundo plano e, quando a execução é concluída, uma função de retorno de chamada (callback) é chamada para lidar com o resultado. Isso permite que outras partes do código sejam executadas enquanto a função assíncrona é processada em segundo plano, evitando bloqueios e congelamentos do aplicativo.

As funções assíncronas são frequentemente usadas para lidar com operações que exigem tempo, como solicitações de rede, processamento de arquivos e operações de E/S. As funções assíncronas podem ser implementadas em JavaScript usando callbacks, promessas ou async/await.

O loop de eventos (event loop) é uma das características mais importantes do modelo de programação assíncrona em JavaScript. É o mecanismo que permite que o JavaScript execute tarefas assíncronas, como callbacks e promessas, de forma não bloqueante, garantindo que o código seja executado de forma eficiente e sem interrupções.

Basicamente, o loop de eventos gerencia a fila de tarefas que precisam ser executadas pelo JavaScript, verificando constantemente se há alguma tarefa aguardando para ser executada. Quando uma tarefa é adicionada à fila, o loop de eventos verifica se o navegador ou o ambiente de execução estão ocupados com outras tarefas, e se não estiverem, a tarefa é executada imediatamente. Caso contrário, a tarefa é adicionada à fila e será executada assim que as outras tarefas forem concluídas.

Isso melhora significativamente o desempenho e a capacidade de resposta das aplicações, permitindo que elas processem tarefas complexas sem travamentos ou problemas de desempenho.

A função do typeof em JavaScript é retornar o tipo de dado de uma variável ou expressão. Ele pode retornar os seguintes valores de string: "number", "string", "boolean", "object", "function", "undefined", e "symbol".

Por exemplo, se tivermos uma variável chamada x, podemos usar typeof x para descobrir qual é o tipo de dado armazenado em x. Dependendo do tipo de dado, diferentes operações podem ser realizadas nele.

Enquanto o JavaScript é uma linguagem de programação amplamente usada na web e em outros contextos, o ECMAScript é um padrão para a linguagem de programação JavaScript.

ECMAScript é uma especificação de linguagem de programação baseada em scripts, que define as regras e diretrizes que um navegador da web deve seguir para implementar a linguagem JavaScript. A especificação é desenvolvida e mantida pela organização sem fins lucrativos Ecma International, que é composta por representantes de várias empresas de tecnologia. A especificação define a sintaxe, tipos de dados, estruturas de controle, objetos e outras funcionalidades da linguagem.

Template strings, ou template literals, são uma nova funcionalidade introduzida no ECMAScript 6 (ES6) que permitem a criação de strings de forma mais fácil e legível. Elas são delimitadas por acentos graves (backticks) ` e permitem a interpolação de variáveis e expressões diretamente na string.

Elas também podem ser utilizadas para criar strings multi-linha sem a necessidade de usar caracteres de escape ou concatenação de strings. As template strings são especialmente úteis quando você precisa criar strings complexas que dependem de variáveis e expressões dinâmicas.

A declaração debugger em JavaScript é usada para interromper a execução do código e iniciar o debugging em um determinado ponto. Quando o interpretador do JavaScript encontra a declaração debugger, ele interrompe a execução do código e abre o depurador do navegador ou da IDE em que o código está sendo executado, permitindo que o desenvolvedor inspecione o estado atual do programa, examine as variáveis, rastreie a pilha de chamadas e execute o código passo a passo para encontrar e corrigir erros.

A declaração debugger é usada principalmente para depurar o código JavaScript e é útil quando o desenvolvedor deseja interromper a execução do código em um ponto específico para examinar o estado do programa e identificar problemas.

É importante lembrar que a declaração debugger não deve ser deixada no código em produção, pois isso pode resultar em uma diminuição significativa no desempenho do aplicativo. Por isso, é uma boa prática removê-la antes de implantar o código em produção.

A função isNaN() é usada para determinar se o valor fornecido é um número ilegal ou não. Se ela retornar true, o valor é NaN - Não é um número. Caso contrário, retorna false. Isso difere do método Number.isNaN().

innerHTML - innerHTML retorna todo o texto, incluindo as tags HTML, que estão contidas dentro de um elemento.

innerText - innerText retorna todo o texto que está contido dentro de um elemento, bem como seus elementos filhos.

Framework JavaScript é um framework de aplicativo escrito usando JavaScript. Em seu fluxo de controle, é diferente de uma biblioteca JavaScript. Existem muitos frameworks JavaScript, mas os mais populares são: Angular, Node, Bootstrap e Vue, entre outros.

Local Storage: Os dados não são transmitidos diretamente para o servidor com cada requisição HTTP (HTML, imagens, JavaScript, CSS, etc), reduzindo assim o tráfego entre o servidor e o cliente. Os dados permanecem até serem removidos manualmente por meio de configurações ou software.

Session Storage: É idêntico ao Local Storage; a única diferença é que enquanto os dados armazenados localmente não expiram, no Session Storage eles são excluídos quando a sessão é encerrada. O Session Storage é removido assim que o navegador é fechado.

Há três maneiras de usar um código JavaScript no arquivo HTML: embutido, interno e externo.

Inline JavaScript (embutido)

Internal JavaScript (interno)

External JavaScript (externo)

Para produzir um cookie com JavaScript, você pode utilizar o objeto document.cookie. Este objeto armazena o cookie em uma string que pode ser definida com o valor do cookie.

Para revisar um cookie com JavaScript, você pode acessar a propriedade document.cookie. Esta propriedade retorna uma string com todos os cookies associados ao documento atual. Você pode usar métodos de string para pesquisar o cookie que deseja revisar.

Strict Mode, ou Modo Estrito, no JavaScript é uma forma de escolher uma variante restrita da linguagem, que aplica regras mais rigorosas de análise e tratamento de erros. Isso ajuda os desenvolvedores a escreverem um código mais seguro e eficiente, detectando erros comuns e possíveis bugs que poderiam passar despercebidos.

Quando habilitado, o Strict Mode pode gerar erros para códigos que antes funcionavam sem problemas, mas isso é feito para identificar possíveis problemas que poderiam levar a bugs ou vulnerabilidades de segurança. O Modo Estrito também desabilita algumas funcionalidades do JavaScript que poderiam ser problemáticas ou confusas, como a criação automática de variáveis globais.

Em geral, o Modo Estrito é uma ferramenta útil para escrever códigos JavaScript mais seguros e confiáveis, mas requer cuidado e atenção dos desenvolvedores para que seja usado de forma eficaz.

Em JavaScript, let e var são utilizados para declarações de métodos e variáveis. A principal diferença entre eles é o escopo em que essas variáveis são utilizadas. As variáveis declaradas com "let" só podem ser utilizadas dentro do bloco onde foram declaradas, já as declaradas por "var" estão disponíveis em toda a função onde foram declaradas.

Tanto as classes em ES6 quanto os construtores de função em ES5 são usados para criar objetos em JavaScript, mas a sintaxe e a funcionalidade de cada uma delas diferem significativamente. Enquanto as classes em ES6 oferecem uma sintaxe mais clara e uma funcionalidade mais avançada, incluindo herança, os construtores de função em ES5 são mais verbosos e menos intuitivos, mas ainda são amplamente usados em sistemas legados.

O primeiro passo para fazer o debug de um programa JavaScript é identificar o erro. Isso pode ser feito usando o console JavaScript nas ferramentas de desenvolvedor do navegador. O console exibirá quaisquer erros que ocorreram durante a execução do script, como erros de sintaxe, erros de tipo e erros de referência. Depois que o erro for identificado, o código pode ser examinado linha por linha para encontrar a origem do problema para que ele seja corrigido.

Para criar uma função que recebe dois números e os adiciona, você pode usar o seguinte trecho de código:

Podemos recuperar um caractere de um índice específico usando a função charAt().

Um loop for em JavaScript recebe 3 parâmetros (inicialização, condição e incremento/decremento) e contém um bloco de código que é executado até que a condição seja atendida. Por exemplo:

O Design Prototype Pattern é descrito como um padrão de propriedade ou padrão de protótipo que pode ser usado para criar diferentes objetos e protótipos que são clonados de um modelo com valores específicos.

A ideia-chave por trás do Prototype Pattern é usar um objeto existente como modelo e criar novas instâncias copiando suas propriedades. Essa abordagem pode ser mais eficiente do que criar novas instâncias do zero, principalmente se o objeto tiver um processo de inicialização complexo. Ao copiar um objeto existente, podemos evitar ter que repetir o processo de inicialização para cada novo objeto que criamos.

É uma área de bloco onde uma variável não pode ser acessada até que seja completamente inicializada com um valor pelo computador. Caso tente acessá-la antes da inicialização completa, o JavaScript lançará um "ReferenceError". Ela é definida usando as palavras-chave const e let.

Os métodos .map() e .forEach() são usados para iterar sobre um array, mas o método .map() pode ser usado para transformar um array, retornando um novo array com o mesmo número de elementos, mas com valores diferentes. O método .forEach() é usado para executar uma ação em cada elemento do array, sem retornar um novo array. Por exemplo:

Para criar um método que retorna a soma de todos os elementos em um array, você pode usar o método Array.prototype.reduce(). Por exemplo:

O estilo/classe de um elemento pode ser alterado de duas maneiras:

document.getElementById("meuTexto").style.fontSize = "14px";

document.getElementById("meuTexto").className = "anyclass";

Existem duas maneiras de eliminar duplicatas de um array JavaScript:

• Através do método Filter: O método filter() pode usar três argumentos: arrays, elemento atual e o índice do elemento atual.
• Utilizando o loop For: O loop For envolve iterar pelo array original e verificar se cada elemento já foi adicionado a um novo array. Caso não tenha sido, o elemento é adicionado. Se já tiver sido, é ignorado.

Hoisting é um comportamento em JavaScript em que declarações de variáveis e funções são movidas para o topo do seu escopo antes da execução do código. Isso significa que, mesmo que uma variável ou função seja declarada em algum lugar no meio do código, ela pode ser usada em qualquer lugar dentro do escopo em que foi declarada.

No caso das variáveis, apenas a declaração é movida para o topo, não a atribuição de valor. No entanto, se tentarmos acessar uma variável antes de ela ser declarada, receberemos um valor indefinido.

O hoisting pode ser útil em algumas situações, mas pode causar confusão e bugs se não for compreendido corretamente. Portanto, é recomendável sempre declarar as variáveis e funções no início do escopo.

Em JavaScript, objetos mutáveis são aqueles cujo valor pode ser alterado após a criação do objeto, enquanto objetos imutáveis são aqueles cujo valor não pode ser alterado após a criação do objeto.

Por exemplo, uma variável declarada como let ou var pode ter seu valor alterado a qualquer momento, tornando-a mutável. Já uma variável declarada como const é imutável, ou seja, seu valor não pode ser alterado depois de atribuído.

Além disso, objetos mutáveis podem ser alterados diretamente usando métodos como .push() ou .splice(), enquanto objetos imutáveis exigem a criação de um novo objeto com os valores atualizados.

Um exemplo de uso de Template Literals em ES6 seria a geração de uma string com variáveis. Em vez de usar a concatenação de strings com o sinal de "+" ou usar a função concat(), podemos usar o template literal para criar uma string de forma mais fácil e legível:

const nome = 'João';
const idade = 25;
const profissao = 'engenheiro';

const mensagem = 'Meu nome é ${nome}, tenho ${idade} anos e sou ${profissao}.';

console.log(mensagem);
// Saída: "Meu nome é João, tenho 25 anos e sou engenheiro."

No exemplo acima, usamos o template literal para gerar a string "mensagem", que inclui as variáveis nome, idade e profissao. Para isso, utilizamos o símbolo de cifrão dentro de chaves ("${}") para indicar onde as variáveis devem ser inseridas na string. Adicionalmente, há um comentário no final no código para mostrar qual é o output esperado do mesmo.

window.onload é um evento que é disparado quando a página terminou de carregar. Esse evento é frequentemente usado para realizar tarefas que precisam ser feitas após o carregamento da página, como configurar manipuladores de eventos, inicializar componentes ou fazer solicitações AJAX.

Por outro lado, onDocumentReady é um evento que é disparado quando o documento HTML da página está pronto para ser interagido. Esse evento é frequentemente usado para realizar tarefas que precisam ser feitas quando a página está pronta, como configurar manipuladores de eventos, inicializar componentes ou fazer solicitações AJAX.

O borbulhamento de eventos (event bubbling) é um comportamento padrão do DOM (Document Object Model) em que o evento acionado em um elemento se propaga através de seus pais na hierarquia do DOM, até chegar ao elemento raiz do documento. Isso significa que, quando um evento é acionado em um elemento filho, esse evento é transmitido aos seus pais na hierarquia do DOM e, eventualmente, é acionado no elemento pai. O processo de propagar o evento através dos elementos pai é conhecido como borbulhamento de eventos. Esse comportamento permite que os manipuladores de eventos sejam colocados em elementos pai, em vez de serem adicionados a cada elemento filho individualmente.

Os métodos .map() e .forEach() são ambos usados para iterar sobre um array, mas o método .map() pode ser usado para transformar um array, retornando um novo array com o mesmo número de elementos, mas com valores diferentes. O método .forEach() é usado para realizar uma ação em cada elemento do array sem retornar um novo array. Por exemplo: