Quiz de Fundamentos de Node.js

Quiz de Fundamentos de Node.js

Teste seus conhecimentos sobre o event loop, assincronia e arquitetura do Node.js.

1. 1. O Node.js é descrito como 'single-threaded'. O que isso significa principalmente no contexto de execução do JavaScript?

   • Ele só consegue processar uma requisição HTTP por vez
   • O código JavaScript é executado em uma única pilha de chamadas em uma thread
   • Ele usa apenas um núcleo de CPU para todas as operações
   • Não é possível executar múltiplos processos Node.js na mesma máquina

2. 2. O que o `require('fs')` faz em um módulo Node.js?

   • Busca o pacote 'fs' do registro npm em tempo de execução
   • Carrega e armazena em cache o módulo nativo de sistema de arquivos, retornando seu objeto exports
   • Cria uma nova instância de sistema de arquivos exclusiva para o módulo atual
   • Registra um ouvinte de eventos de sistema de arquivos no objeto process

3. 3. Qual campo no `package.json` especifica o arquivo de ponto de entrada que o Node.js carrega quando seu pacote é importado com `require()`?

   • start
   • index
   • main
   • entry

4. 4. Qual é a principal diferença entre `fs.readFileSync()` e `fs.readFile()` no Node.js?

   • O `readFileSync` lê arquivos maiores; o `readFile` é limitado a 1 MB
   • O `readFileSync` bloqueia o event loop até que o arquivo seja lido; o `readFile` é não bloqueante e usa um callback
   • O `readFile` está depreciado; o `readFileSync` é a API moderna
   • Eles são idênticos: o sufixo 'Sync' é puramente estético

5. 5. No Node.js, o que é um callback?

   • Um tipo de erro nativo para falhas assíncronas
   • Uma função passada como argumento para outra função, invocada quando uma operação assíncrona termina
   • Um wrapper síncrono em torno de uma Promise
   • Um método especial na classe EventEmitter

6. 6. Como você lê uma variável de ambiente chamada `PORT` em um processo Node.js?

   • `env.get('PORT')`
   • `process.env.PORT`
   • `os.env('PORT')`
   • `global.PORT`

7. 7. Qual módulo nativo do Node.js você usaria para unir dois segmentos de caminho de forma segura e multiplataforma?

   • `fs`
   • `url`
   • `path`
   • `os`

8. 8. O que o comando `npm run build` executa?

   • Baixa e instala todos os pacotes listados em `dependencies`
   • Executa o script `build` definido sob a chave `scripts` no `package.json`
   • Compila todos os arquivos `.ts` para `.js` usando o compilador nativo do Node
   • Cria um bundle de produção e faz upload para o npm

9. 9. Em um rastreamento de pilha (stack trace) do Node.js, o que a linha `at Object.<anonymous> (app.js:42:15)` indica?

   • Um objeto anônimo foi exportado de `app.js`
   • O erro originou-se na linha 42, coluna 15 de `app.js`
   • O arquivo `app.js` possui 42 exportações
   • O uso de memória do processo no momento do erro

10. 10. Qual dos itens a seguir está disponível no ambiente JavaScript de um navegador, mas NÃO no Node.js por padrão?

    • `setTimeout`
    • `Promise`
    • `window`
    • `Array.prototype.map`

11. 11. Qual é a ordem correta de execução para o código a seguir? ```js setTimeout(() => console.log('A'), 0); setImmediate(() => console.log('B')); process.nextTick(() => console.log('C')); console.log('D'); ```

    • D → A → B → C
    • D → C → A → B
    • D → C → B → A
    • A → B → C → D

12. 12. Em qual fase do event loop do Node.js o `setImmediate()` é disparado?

    • Fase de timers
    • Fase de poll
    • Fase de check
    • Fase de close callbacks

13. 13. Qual das alternativas a seguir possui a maior prioridade de execução no agendamento assíncrono do Node.js?

    • `setTimeout(fn, 0)`
    • `setImmediate(fn)`
    • `process.nextTick(fn)`
    • Callbacks de `.then()` de uma `Promise` resolvida

14. 14. Que tipo de stream do Node.js você usaria para ler e escrever dados E transformar esses dados em trânsito (por exemplo, um compressor gzip)?

    • Stream Readable
    • Stream Writable
    • Stream Duplex
    • Stream Transform

15. 15. Qual é o objetivo principal do módulo `cluster` no Node.js?

    • Distribuir pacotes npm entre várias máquinas
    • Criar múltiplos processos worker que compartilham a mesma porta de servidor, aproveitando múltiplos núcleos de CPU
    • Criar processos filhos que executam scripts independentes sem estado compartilhado
    • Criar pools de threads para tarefas síncronas intensivas de CPU

16. 16. Como o `worker_threads` se diferencia de `child_process` no Node.js?

    • `worker_threads` compartilham memória via `SharedArrayBuffer`; `child_process` gera processos do sistema operacional totalmente isolados
    • `child_process` é mais rápido para tarefas de CPU porque utiliza threads nativas
    • `worker_threads` não conseguem se comunicar com a thread principal
    • Eles são intercambiáveis: os nomes são apenas apelidos

17. 17. Na organização da heap da V8, para que serve o 'New Space' (Geração Jovem)?

    • Armazenar código de máquina compilado para funções compiladas via JIT
    • Objetos de vida curta que devem ser coletados rapidamente
    • Objetos grandes com mais de 1 MB que não cabem em páginas comuns
    • A pilha de chamadas e frames de variáveis locais

18. 18. Quando um módulo Node.js é importado via `require()` uma segunda vez, o que acontece?

    • O arquivo do módulo é lido novamente do disco e reexecutado
    • Um erro é disparado para evitar inicialização duplicada
    • O objeto `exports` em cache da primeira carga é retornado imediatamente
    • Uma nova instância isolada do módulo é criada

19. 19. Qual método do `EventEmitter` registra um listener que dispara apenas uma vez e se remove automaticamente em seguida?

    • `emitter.on(event, listener)`
    • `emitter.once(event, listener)`
    • `emitter.addOnceListener(event, listener)`
    • `emitter.emit(event, { once: true })`

20. 20. Qual é o papel da libuv no Node.js?

    • É a engine JavaScript que compila e executa código JS
    • Fornece o event loop de E/S assíncrona multiplataforma, o pool de threads e a camada de abstração do sistema operacional
    • Gerencia downloads de pacotes npm e cache
    • Implementa o protocolo HTTP/2 para o módulo `http2` do Node

21. 21. Qual algoritmo de coleta de lixo (garbage collection) a V8 utiliza para a Geração Jovem (New Space)?

    • Mark-Sweep
    • Mark-Compact
    • Scavenge (cópia semi-space de Cheney)
    • Contagem de referências

22. 22. Por que um ciclo completo de GC Mark-Compact pode causar picos de latência observáveis em um servidor Node.js?

    • Ele dobra temporariamente o uso de memória ao copiar toda a heap
    • Ele executa pausas Stop-The-World enquanto compacta o Old Space, bloqueando o event loop
    • Ele recompila todas as funções otimizadas por JIT para liberar memória do cache de código
    • Ele esvazia o pool de threads da libuv e reinicia todas as operações de E/S pendentes

23. 23. Você executa `node --prof app.js` e depois `node --prof-process isolate-*.log`. Que tipo de saída isso produz?

    • Um snapshot de heap em formato JSON compatível com o Chrome DevTools
    • Um perfil estatístico de CPU legível por humanos mostrando funções críticas e suas porcentagens de chamada
    • Uma linha do tempo de todas as pausas de GC com suas durações em milissegundos
    • Um diagrama em cascata de rede de todas as requisições HTTP feitas durante a execução

24. 24. Qual dos seguintes padrões é a causa mais comum de vazamentos de memória em servidores Node.js de longa duração?

    • Usar `const` em vez de `let` para variáveis no nível do módulo
    • Acumular listeners em um EventEmitter sem nunca chamar `removeListener`
    • Chamar `JSON.parse` em strings grandes repetidamente
    • Usar `async/await` em vez de callbacks puros

25. 25. O que a flag do Node.js `--max-old-space-size=4096` controla?

    • O número máximo de arquivos que podem ser abertos simultaneamente
    • O tamanho do pool de threads da libuv em megabytes
    • O limite superior da heap Old Space da V8 em megabytes antes que um erro de falta de memória seja lançado
    • O tamanho máximo permitido para uma carga útil JSON analisada com `JSON.parse`

26. 26. Um loop síncrono intensivo de CPU com duração de 2 segundos é inserido acidentalmente em um handler de requisição HTTP. Qual é a descrição mais precisa do impacto?

    • Apenas essa requisição específica sofre atraso; as demais requisições continuam normalmente
    • A fase de poll do event loop fica bloqueada por 2 segundos, paralisando TODAS as outras requisições recebidas e temporizadores
    • O Node descarrega automaticamente o loop para o pool de threads da libuv a fim de evitar o bloqueio
    • O processo master do cluster detecta o travamento e reinicia o worker

27. 27. O que é contrapressão (back-pressure) em streams do Node.js e qual o papel do `highWaterMark`?

    • Contrapressão é um limite de taxa HTTP; `highWaterMark` define o teto de requisições por segundo
    • Contrapressão é o sinal de que o buffer de uma stream gravável está cheio; `highWaterMark` define o limite de tamanho do buffer no qual `write()` retorna `false`
    • Contrapressão é uma pausa de GC da V8; `highWaterMark` dispara o GC antecipado quando a heap ultrapassa essa fração
    • Contrapressão não é utilizada em streams do Node.js; é relevante apenas para sockets TCP

28. 28. Qual é a principal vantagem da N-API (agora Node-API) sobre as interfaces anteriores de addons nativos?

    • Permite escrever addons nativos em Python em vez de C/C++
    • Fornece uma interface estável em termos de ABI, evitando que addons nativos precisem ser recompilados a cada nova versão do Node.js
    • Concede aos addons nativos acesso direto ao coletor de lixo da V8 para gerenciar sua própria memória
    • Paraleliza automaticamente a execução de addons nativos entre todos os núcleos de CPU

29. 29. Como as classes ocultas da V8 ('hidden classes', também chamadas de 'shapes' ou 'maps') melhoram o desempenho de objetos JavaScript?

    • Elas compactam as chaves dos objetos usando um dicionário para reduzir a memória por objeto
    • Elas permitem que a V8 gere código de máquina otimizado rastreando o layout das propriedades dos objetos e reutilizando-o em instâncias com a mesma estrutura
    • Elas escondem campos de classe privados do coletor de lixo para evitar coletas prematuras
    • Elas pré-alocam uma página fixa de heap para cada função construtora

30. 30. Ao utilizar o PM2 para obter reinicializações sem tempo de inatividade (`pm2 reload`), qual mecanismo o PM2 emprega?

    • Ele pausa o balanceador de carga, reinicia todos os workers simultaneamente e depois retoma o tráfego
    • Ele cria um novo worker, aguarda que ele sinalize prontidão, roteia o tráfego para ele e finaliza suavemente o worker antigo: um por vez
    • Ele aplica patches no processo em execução na memória sem iniciar um novo
    • Ele utiliza o recurso de live-patching do kernel do SO para trocar páginas de código atomicamente