1) Confusões de tipos, comparação e valores vazios

• Evite usar == para comparar valores entre tipos. Prefira === para evitar coerção implícita indesejada.
• Entenda a diferença entre null, undefined e false. Valores falsy (inclui 0, “”, null, undefined, NaN) podem levar a caminhos lógicos não intencionais.
• Quando precisar de valores padrão, utilize ?? (nullish coalescing) em vez de ||, para não substituir falsy válidos como 0 ou “”.
• Se usar a negação lógica (!valor) em variáveis, lembre-se de que alguns valores podem se comportar de forma inesperada dependendo do contexto.

2) Escopo, hoisting e variáveis

• Var é function-scoped e sofre hoisting. Pode levar a vazamentos de escopo e bugs sutis em blocos.
• Let e const são block-scoped e entram em TDZ (temporal dead zone) até a linha de inicialização, o que evita muitas armadilhas.
• Evite padrões de IIFE desnecessários. Use blocos com let/const e mantenha o código legível.
• Prefira declarar variáveis sempre no topo do bloco onde serão usadas para clareza mental do fluxo.

3) Assincronia: promises, async/await e tratamento de erros

Erros ao lidar com promises costumam surgir de ausência de try/catch em funções assíncronas, rejection handlers não configurados ou loops assíncronos mal planejados.

// Problema comum com var em loops assíncronos
for (var i = 0; i < 3; i++) {
  setTimeout(function() {
    console.log('valor com var:', i);
  }, 0);
}

// Correção com let (captura de cada iteração)
for (let j = 0; j < 3; j++) {
  setTimeout(function() {
    console.log('valor com let:', j);
  }, 0);
}

Boas práticas para assincronia:

• Use try/catch com async/await para capturar erros de operações assíncronas.
• Trate rejeições de promises com .catch() ou com bloqueio central de erros.
• Quando executar múltiplas chamadas, prefira Promise.all para paralelismo sincronizado, e Promise.allSettled quando não puder falhar o conjunto.
• Esteja atento a concorrência: operações independentes podem ser executadas em paralelo, mas dependências precisam de controle de fluxo (await, encadeamento, etc.).

4) Mutabilidade e cópia de objetos/arrays

• Copiar por referência é a norma em objetos e arrays. Evite mutar estruturas originais inadvertidamente.
• Use o spread operator (…) ou Object.assign para cópias rasas. Cuidado com propriedades aninhadas que permanecem como referência.
• Para estruturas profundas, considere soluções de deep clone com cuidado (JSON.stringify/parse perde funções, Dates, etc.; bibliotecas podem oferecer deepClone com preservação de tipos).
• Imutabilidade facilita reuso, testes e previsibilidade. Em frameworks, adote padrões que promovam estados imutáveis sempre que possível.