Amostras de flashcards de JavaScript do nosso aplicativo

Baixe nosso aplicativo na App Store ou Google Play para obter mais flashcards gratuitos ou assine para ter acesso a todos os flashcards.

O que é escopo lexical em JavaScript?

O escopo lexical em JavaScript é um princípio onde o alcance de visibilidade de uma variável é determinado pela sua localização no código. Isso significa que as variáveis são acessíveis dentro do bloco em que foram definidas, bem como em quaisquer blocos aninhados. Isso permite a criação de fechamentos (closures) e controle sobre o acesso à variável. Exemplo de uso do escopo lexical no código JavaScript:

function outerFunction() {
  let outerVariable = `Estou fora!`;

  function innerFunction() {
    console.log(outerVariable); // Tem acesso à 'outerVariable'
  }

  innerFunction();
}
outerFunction(); // Exibe `Estou fora!`

O escopo lexical permite que uma função interna acesse variáveis definidas em uma função externa, mesmo após a função externa ter terminado. Este é um elemento chave na criação de closures em JavaScript, permitindo uma gestão de estado mais flexível nas aplicações.

O que é hoisting?

"Içamento" (Hoisting) é um mecanismo em linguagens JavaScript onde variáveis e funções são movidas para o topo de seu escopo antes que o código seja executado. Na prática, isso significa que podemos usar funções ou variáveis antes que elas sejam realmente declaradas.

No entanto, deve-se notar que o içamento funciona de maneira um pouco diferente para variáveis e funções.

Para variáveis declaradas com as palavras-chave "var", apenas a declaração é içada, não a inicialização. Variáveis inicializadas antes da declaração serão retornadas como "undefined".

Um exemplo de código de içamento para variáveis:

console.log(myVar); // undefined
var myVar = 5;
console.log(myVar); // 5

Para funções, o içamento move tanto a declaração quanto a definição da função para o topo, o que permite o uso da função antes de ser declarada.

Um exemplo de código de içamento para funções:

console.log(myFunction()); // "Olá Mundo"

function myFunction() {
  return "Olá Mundo";
}

O içamento não ocorre para variáveis declaradas com let e const.

O que é uma função de seta e quais são suas vantagens?

Uma função de seta, também conhecida como função de seta, é um tipo de função introduzida no ECMAScript 6 (ES6). Eles são chamados de funções de seta porque usam uma sintaxe especial com uma seta ( => ) para definir a função.

Para comparação, uma função tradicional pode ser assim:

function sum(a, b) {
  return a + b;
}

Seu equivalente como função de seta é:

const sum = (a, b) => a + b;

O principal benefício de uma função de seta é que ela não cria seu próprio contexto de execução (ligando a this), que é frequentemente uma fonte de erros no JavaScript. Nas funções de seta, o this é herdado do contexto ao redor. Outra vantagem é a brevidade da sintaxe, especialmente útil quando as funções são utilizadas como argumentos para outras funções, por exemplo, em funções de ordem superior.

Por outro lado, devido à falta de seu próprio this, as funções de seta não são adequadas para definir objetos construtor (criativo) ou para criar métodos em objetos protótipo.

O que é um objeto Promise e como pode ser usado?

O objeto Promise no JavaScript é usado para lidar com operações assíncronas. Uma Promise representa um valor que pode não estar disponível no momento em que a Promise é criada, mas pode estar disponível no futuro, ou nunca.

Um objeto Promise pode estar em um de três estados:
1. Pendente - a operação ainda está em andamento, não terminou nem com sucesso nem com erros.
2. Cumprida - a operação foi concluída com sucesso, a Promise retornou um valor.
3. Rejeitada - a operação foi concluída com um erro, a Promise retornou o motivo do erro.

Uma Promise que foi cumprida ou rejeitada é considerada "resolvida" e seu estado nunca muda.

Criando um objeto Promise:

const promise = new Promise((resolve, reject) => {
  const success = true;
  if (success) {
    resolve('Operação bem sucedida.');
  } else {
    reject('Operação falhou.');
  }
});

Usando um objeto Promise:

promise
  .then(result => {
    console.log(result); // Vai imprimir: 'Operação bem sucedida.'
  })
  .catch(error => {
    console.log(error);
  });

O método .then() é executado quando a Promise é cumprida, e .catch() quando é rejeitada. Em ambos os casos, o resultado da operação ou o motivo da rejeição da Promise é passado como um argumento.

O que é um callback?

Um callback, também referido como uma função callback, é uma função que é passada como um argumento para outra função e é então executada (chamada de volta) após a conclusão dessa função. As funções callback são comumente usadas em JavaScript, particularmente em operações assíncronas, como solicitações AJAX ou manipulação de eventos.

As funções callback geralmente recebem os resultados de uma determinada operação como argumentos, para que possam ser usados para processar ou analisar esses resultados.

A utilização de tal função na prática pode ser assim:

function executeAfterTimeout(callback, timeout) {
  setTimeout(() => {
    console.log('Tempo passou!');
    callback();
  }, timeout);
}

executeAfterTimeout(() => {
  console.log('Isso é um callback!');
}, 2000);

Neste caso, a função `executeAfterTimeout` recebe uma função `callback` como um parâmetro, que será executada depois de um determinado período de tempo. As funções callback são extremamente úteis para gerenciar o fluxo de controle assíncrono em JavaScript.

O que é o operador de coalescência nula e como funciona?

O Operador de Coalescência Nula (??) é um operador lógico que retorna o lado direito da operação quando o lado esquerdo é nulo ou indefinido. Em outras palavras, quando uma variável está vazia, o operador de coalescência nula retorna o valor definido como resultado.

A notação básica é:

let value = null ?? 'valor padrão';

Neste caso, como o lado esquerdo (value) é nulo, o resultado é 'valor padrão'. Além disso, este operador difere do operador OR (||), pois a função OR retorna o lado direito quando o lado esquerdo é falso (falso, 0, '', null, indefinido, NaN), enquanto o operador de coalescência nula apenas retorna o lado direito quando o lado esquerdo é nulo ou indefinido.

Exemplo com OR:

let valor1 = 0 || 'padrão';
console.log(valor1); // saída: 'padrão' porque 0 é um valor falso

Exemplo com a coalescência nula:

let valor2 = 0 ?? 'padrão';
console.log(valor2); // saída: 0 porque 0 não é nulo ou indefinido

Portanto, ao contrário de OR, o operador de coalescência nula não trata 0, '' e NaN como valores "vazios".

O que é Symbol e quando deve ser usado?

Um Símbolo em JavaScript é um tipo de dados único e imutável que é frequentemente usado para identificar propriedades únicas de objetos.

Você pode criar um Símbolo chamando o construtor Symbol(), que cria um símbolo único cada vez que é chamado. Mesmo se chamarmos o construtor Symbol() com o mesmo argumento, cada símbolo criado será diferente.

const symbol1 = Symbol('mySymbol');
const symbol2 = Symbol('mySymbol');
console.log(symbol1 === symbol2); // retorna false

O Símbolo é frequentemente usado para definir propriedades (únicas) de objetos, especialmente quando queremos que esta propriedade esteja oculta ou privada. Ele também cobre propriedades que não são consideradas ao iterar sobre objetos usando for...in ou for...of e não são devolvidas pelo método Object.keys(). Além disso, os símbolos permitem a criação de propriedades "pseudo" privadas.

let obj = {};
let privateProperty = Symbol('private');

obj[privateProperty] = 'Isto é privado';

console.log(obj[privateProperty]); // 'Isto é privado'
console.log(Object.keys(obj)); // []

Não há uma regra definitiva sobre quando usar o Símbolo. Eles são tipicamente usados quando queremos criar uma propriedade única em um objeto que não pode ser facilmente vista ou alterada, ou quando queremos definir métodos que afetam o comportamento dos objetos a um nível baixo.

O que são WeakMap e WeakSet?

WeakMap e WeakSet são versões especiais dos objetos Map e Set do JavaScript que não impedem a liberação automática de memória pelo Garbage Collector.

WeakMap é uma coleção de pares chave-valor onde as chaves devem ser objetos e os valores podem ser qualquer coisa. A principal diferença entre Map e WeakMap é que as chaves no WeakMap são mantidas de modo "fraco", ou seja, se não houver outras referências ao objeto chave, ele será coletado como lixo (garbage-collected) e sua entrada no WeakMap será automaticamente removida.

Aqui está um exemplo de uso do WeakMap:

let john = { name: "John" };

let weakMap = new WeakMap();
weakMap.set(john, "...");

john = null; // sobrescrever a referência

// john é removido da memória!

WeakSet é similar ao que WeakMap é para o Map. É um conjunto de objetos, mas não impede a coleta de lixo se o objeto não estiver visível em outro lugar. Não possui métodos Set típicos como `size` e `clear`, e o método `add` só aceita objetos.

Exemplo de uso do WeakSet:

let john = { name: "John" };

let weakSet = new WeakSet();
weakSet.add(john);

john = null; // sobrescrever a referência

// john é removido da memória!

Ambos, WeakMap e WeakSet, são usados principalmente em situações em que queremos armazenar informações adicionais sobre objetos que devem ser removidos quando o próprio objeto for removido.

Flashcards de JavaScript