Question 1

Qual é a regra de ouro para nomes de variáveis?

Accepted Answer

Use nomes descritivos que expliquem o propósito da variável.

Question 2

Como devem ser as funções?

Accepted Answer

Funções devem ser pequenas e fazer apenas uma coisa.

Question 3

Qual é a importância de comentários?

Accepted Answer

Comentários devem explicar “por que”, não “o que” o código faz.

Question 4

Como organizar constantes?

Accepted Answer

Coloque valores constantes em variáveis com nomes claros.

Question 5

Qual é a recomendação sobre complexidade de função?

Accepted Answer

Funções devem ter complexidade baixa (poucos if/else, loops simples).

Question 6

Qual é a prática recomendada para valores booleanos?

Accepted Answer

vite nomes genéricos; seja explícito sobre o que o booleano representa. 

// ruim
let flag = true;

// bom
let isUserLoggedIn = true;

Question 7

Como lidar com números mágicos?

Accepted Answer

// ruim
if(score > 10){ ... }

// bom
const MIN_SCORE = 10;
if(score > MIN_SCORE){ ... }

Question 8

Qual é a recomendação para funções com muitos parâmetros?

Accepted Answer

Evite funções com muitos parâmetros; prefira objetos para agrupar dados.

// ruim
function createUser(name, age, email, address){ ... }

// bom
function createUser({name, age, email, address}) { ... }

Question 9

O que é importante sobre tratamento de erros?

Accepted Answer

Evite capturar erros silenciosamente; sempre trate ou repasse.

// ruim
try { riskyOperation(); } catch(e){}

// bom
try { riskyOperation(); } catch(e){
  console.error('Falha na operação:', e);
  throw e;
}

Question 10

Como melhorar legibilidade de expressões booleanas complexas?

Accepted Answer

Quebre expressões em variáveis com nomes significativos.

// ruim
if(user.isAdmin && user.isActive && !user.isBanned){ ... }

// bom
const isEligibleUser = user.isAdmin && user.isActive && !user.isBanned;
if(isEligibleUser){ ... }

Question 11

Qual é a regra sobre indentação?

Accepted Answer

Mantenha indentação consistente para legibilidade.

if(user.isActive){
  console.log('Usuário ativo');
}

Question 12

Qual a prática para classes?

Accepted Answer

Cada classe deve ter uma única responsabilidade.

class UserValidator { ... }
class UserRepository { ... }

Question 13

Como escrever loops legíveis?

Accepted Answer

refira métodos de array (map, filter, forEach) em vez de loops complexos.

Question 14

Como lidar com funções longas?

Accepted Answer

Quebre em funções menores ou helpers.

function processOrder(order){
  validate(order);
  calculateTotal(order);
  sendInvoice(order);
}

Question 15

Como nomear funções?

Accepted Answer

Use verbos claros que descrevam a ação.

function getUserName(){ ... }
function sendEmail(){ ... }

Question 16

O que evitar em funções?

Accepted Answer

Evite funções que dependem de variáveis externas (side effects).

// ruim
let total = 0;
function add(value){ total += value; }

// bom
function add(total, value){ return total + value; }

Question 17

Como organizar arquivos?

Accepted Answer

Um arquivo = uma responsabilidade / módulo.

user.js → funções de usuário
order.js → funções de pedido

Question 18

Qual é a prática com strings?

Accepted Answer

const STATUS_ACTIVE = 'active';
if(user.status === STATUS_ACTIVE){ ... }

Question 19

Como lidar com if/else complexos?

Accepted Answer

Prefira early return para reduzir aninhamento.

function checkUser(user){
  if(!user) return;
  if(user.isBanned) return;
  // resto do código
}

Question 20

Como organizar funções utilitárias?

Accepted Answer

Agrupe em módulos e dê nomes claros.

// utils/math.js
export function sum(a, b){ return a + b; }
export function multiply(a, b){ return a * b; }

Question 21

Como nomear funções de evento?

Accepted Answer

Use prefixo que indica ação, ex: onClick, handle.

button.addEventListener('click', handleSubmit);
function handleSubmit() { ... }

Question 22

Como tratar funções com efeito colateral?

Accepted Answer

Evite efeitos colaterais dentro de funções; prefira retorno explícito.

// ruim
function incrementGlobal(){ counter++; }
// bom
function increment(value){ return value + 1; }

Question 23

Como escrever testes unitários simples?

Accepted Answer

function sum(a, b){ return a + b; }
// teste
console.assert(sum(2,3) === 5);

Question 24

Como organizar imports em JavaScript?

Accepted Answer

Importe por módulo e agrupe por tipo (libs externas / internas).

import React from 'react';
import { sum } from './utils/math.js';

Question 25

Como melhorar código repetitivo?

Accepted Answer

Extraia funções reutilizáveis.

function showMessage(msg){ console.log(msg); }
showMessage('Hello');
showMessage('Bye');

Question 26

Qual é a regra sobre variáveis temporárias?

Accepted Answer

Use nomes claros, evite abreviações inúteis.

const maxRetries = 3;

Question 27

Como lidar com valores nulos?

Accepted Answer

Use checagem explícita e retorno antecipado.

if(!user) return;

Question 28

Como melhorar legibilidade de objetos?

Accepted Answer

const user = { name: 'Claudio', age: 48, role: 'dev' };

Question 29

Como escrever funções puras?

Accepted Answer

Função pura depende só dos parâmetros e retorna valor previsível.

function square(x){ return x * x; }

Question 30

Como lidar com variáveis globais?

Accepted Answer

Evite, prefira passar como parâmetro ou encapsular em módulo.

// ruim
let counter = 0;
// bom
function increment(value){ return value + 1; }

Question 31

Como organizar arquivos JS grandes?

Accepted Answer

Separe por responsabilidade: serviços, utilidades, componentes.

services/userService.js
components/UserCard.js
utils/format.js

Question 32

Qual é a prática com callbacks?

Accepted Answer

Use nomes descritivos e evite callbacks aninhados demais.

function fetchData(callback){ ... }
fetchData(handleResponse);

Question 33

Como lidar com funções assíncronas?

Accepted Answer

Prefira async/await em vez de callbacks aninhados.

async function getData(){
  const data = await fetch(url);
  return data.json();
}

Question 34

Como evitar código morto?

Accepted Answer

Remova funções, variáveis e imports que não são usados.

Question 35

Qual é a regra sobre try/catch?

Accepted Answer

Use apenas onde necessário e trate o erro adequadamente.

try { readFile(); } catch(e){ console.error(e); }

Question 36

Como escrever loops legíveis em JS moderno?

Accepted Answer

Prefira métodos de array ao invés de for clássico.

users.forEach(u => console.log(u.name));

Question 37

Como nomear classes?

Accepted Answer

Nome substantivo, singular, claro sobre responsabilidade.

class UserRepository { ... }

Question 38

Como lidar com funções muito parecidas?

Accepted Answer

Evite duplicação; extraia helpers reutilizáveis.

function formatDate(date){ ... }
function formatTime(date){ ... }

Question 39

Como evitar funções com muitos if/else?

Accepted Answer

Prefira early return ou objetos para mapear comportamento.

const actions = {
  admin: () => console.log('admin'),
  user: () => console.log('user')
};
actions[role]();

Question 40

O que significa SRP (Single Responsibility Principle)?

Accepted Answer

Uma função ou classe deve ter apenas uma responsabilidade.

function processUser(user){
  validateUser(user);
  saveUser(user);
  sendEmail(user);
}

Question 41

O que significa OCP (Open Closed Principle)?

Accepted Answer

Código deve ser aberto para extensão e fechado para modificação. 

function calculateDiscount(user){
  if(user.type === "premium") return 0.2;
  if(user.type === "normal") return 0.1;
}

Question 42

O que significa DRY (Don't Repeat Yourself)?

Accepted Answer

Não repita código, reutilize funções.

// ruim
price = price * 0.9
total = total * 0.9

// bom
function applyDiscount(value){
  return value * 0.9
}

Question 43

Como evitar duplicação de lógica?

Accepted Answer

Extraindo funções reutilizáveis.

function formatPrice(price){
  return `$${price.toFixed(2)}`
}

Question 44

O que é KISS (Keep It Simple, Stupid)?

Accepted Answer

Prefira soluções simples ao invés de complexas.

// ruim
let result = numbers.reduce((a,b)=>a+b,0)

// simples
let result = 0
for(let n of numbers){
  result += n
}

Question 45

Como evitar aninhamento profundo?

Accepted Answer

Como evitar aninhamento profundo?

function process(user){

  if(!user) return
  if(!user.active) return

  console.log("processando")
}

Question 46

Qual é a boa prática com parâmetros booleanos?

Accepted Answer

Evitar, pois tornam funções ambíguas.

// ruim
function createUser(name, isAdmin){}

// melhor
function createAdmin(name){}
function createNormalUser(name){}

Question 47

Como melhorar legibilidade de condições?

Accepted Answer

Extraindo para variáveis.

const isEligible =
  user.age > 18 &&
  user.active &&
  !user.banned

if(isEligible){ ... }

Question 48

Como evitar switch muito grande?

Accepted Answer

Usar objetos de mapeamento.

const handlers = {
  admin: () => console.log("admin"),
  user: () => console.log("user")
}

handlers[type]()

Question 49

Como evitar números mágicos em loops?

Accepted Answer

Usar constantes.

const MAX_RETRIES = 3

for(let i = 0; i < MAX_RETRIES; i++){
  retry()
}

Question 50

Como melhorar leitura de transformações de array?

Accepted Answer

Como melhorar leitura de transformações de array?

const names = users.map(u => u.name)

Question 51

Como filtrar dados de forma limpa?

Accepted Answer

Como filtrar dados de forma limpa?

const activeUsers = users.filter(u => u.active)

Question 52

Como evitar loops complexos?

Accepted Answer

Encadeando métodos.

const names =
  users
  .filter(u => u.active)
  .map(u => u.name)

Question 53

Como melhorar clareza ao procurar item em array?

Accepted Answer

Usando find.

const user = users.find(u => u.id === 10)

Question 54

Como verificar existência em array?

Accepted Answer

Como verificar existência em array?

const hasAdmin =
  users.some(u => u.role === "admin")

Question 55

Como verificar se todos elementos atendem condição?

Accepted Answer

Usando every.

const allActive =
  users.every(u => u.active)

Question 56

Como reduzir array em valor único?

Accepted Answer

Como reduzir array em valor único?

const total =
  prices.reduce((sum,p)=>sum+p,0)

Question 57

Como evitar mutação de arrays?

Accepted Answer

Criar novo array.

const newArray = [...oldArray, 5]

Question 58

Como remover duplicatas de forma limpa?

Accepted Answer

Como remover duplicatas de forma limpa?

const unique =
  [...new Set(numbers)]

Question 59

Como melhorar legibilidade em objetos complexos?

Accepted Answer

Usar destructuring.

const {name, age} = user

Question 60

O que é refatoração?

Accepted Answer

Melhorar o código sem mudar o comportamento.

// antes
function calc(a,b){return a+b}

// depois
function sum(a,b){
  return a + b
}

Question 61

Quando refatorar código?

Accepted Answer

Sempre que ele estiver difícil de entender ou duplicado.

Question 62

Como melhorar nomes de função durante refatoração?

Accepted Answer

Usar nomes que expliquem claramente a intenção.

// ruim
function run()

// bom
function processPayment()

Question 63

Como reduzir tamanho de funções?

Accepted Answer

Extraindo partes em funções auxiliares.

function createOrder(order){
  validate(order)
  save(order)
}

Question 64

O que é código legível?

Accepted Answer

Código que outro desenvolvedor entende sem precisar de explicação.

"Know" box contains:
Time elapsed:
Retries:

Clean Code