Próximos Passos

1. Após a formatura: o próximo passo de Alice

Alice concluiu um tutorial de Node.js com 30 aulas e agora consegue criar APIs RESTful sozinha. Mas ela sabe que isso é apenas o começo. “Quero me tornar uma engenheira full-stack”, diz Alice. “Devo aprender Next.js, Nest.js ou TypeScript agora?”

• O Next.js ajuda desenvolvedores front-end a se tornarem rapidamente engenheiros full-stack
• O NestJS oferece uma arquitetura de back-end de nível empresarial, adequada para projetos de grande escala
• O TypeScript é o padrão do setor para projetos em Node.js
• A escolha das ferramentas de desenvolvimento determina a eficiência do desenvolvimento e a qualidade do projeto
• Os projetos de código aberto são os melhores recursos para o aprendizado avançado

2. Comparação das direções futuras

(1) Comparação de estruturas e abordagens

▶ Exemplo: Comparando os estilos do Express e do Next.js

// Express API Route
app.get('/api/users', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

// Next.js API Route (app/api/users/route.js)
export async function GET() {
  const users = await User.find();
  return Response.json(users);
}

▶ Exemplo: Comparando os estilos do Express e do NestJS

// Express
app.get('/users', async (req, res) => {
  const users = await User.find();
  res.json(users);
});

// NestJS
@Controller('users')
export class UsersController {
  constructor(private usersService: UsersService) {}
  @Get()
  findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }
}

▶ Exemplo: O TypeScript aprimora a segurança de tipos

interface CreateUserDto {
  username: string;
  email: string;
  password: string;
  role?: 'user' | 'admin';
}

async function createUser(dto: CreateUserDto): Promise<User> {
  const user = new User(dto);
  return user.save();
}

▶ Exemplo: Roteamento de alto desempenho com o Fastify

const fastify = require('fastify')({ logger: true });

fastify.get('/users', async (req, reply) => {
  const users = await User.find();
  return users;
});

fastify.listen({ port: 3000 });

▶ Exemplo: Segurança de tipos de ponta a ponta no tRPC

// server
const t = initTRPC.create();
const appRouter = t.router({
  getUsers: t.procedure.query(() => User.find()),
});
export type AppRouter = typeof appRouter;

// client - Automatic Type Inference
const users = await trpc.getUsers.query(); // Automatic Type Inference

3. Mapa do percurso de aprendizagem

graph TD
    A[Node.js Basics] --> B[Express Framework]
    B --> C[Database MongoDB/PostgreSQL]
    C --> D[Certification JWT/OAuth]
    D --> E[Testing and Deployment]
    E --> F{Select a Direction}
    F --> G[Next.js Full-Stack]
    F --> H[NestJS Enterprise Backend]
    F --> I[TypeScript Advanced]
    G --> J[Full-Stack Engineer]
    H --> J
    I --> J

graph TD
    A[Node.js Basics] --> B[Express Framework]
    B --> C[Database MongoDB/PostgreSQL]
    C --> D[Certification JWT/OAuth]
    D --> E[Testing and Deployment]
    E --> F{Select a Direction}
    F --> G[Next.js Full-Stack]
    F --> H[NestJS Enterprise Backend]
    F --> I[TypeScript Advanced]
    G --> J[Full-Stack Engineer]
    H --> J
    I --> J

4. Recursos de aprendizagem recomendados

(1) Recursos de aprendizagem recomendados

(2) Projetos de código aberto recomendados

(3) Quick Reference for Node.js Ecosystem Tools

5. Comprehensive NestJS "Hello World" Example

Implement a "Hello World" example in NestJS that is equivalent to the one in Express, demonstrating the decorator style:

// app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';

@Module({
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

// app.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}

// app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}
  @Get()
  getHello(): string {
    return this.appService.getHello();
  }
}

// main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}
bootstrap();

Compared to Express, which requires only one line of code app.get('/', (req, res) => res.send('Hello')), NestJS’s layered structure of modules, services, and controllers may seem more complex, but in large projects, this structure offers better maintainability and testability.

6. Preparação para entrevistas e contribuições para projetos de código aberto

▶ Exemplo: Perguntas comuns em entrevistas sobre Node.js

• As seis fases do ciclo de eventos
• Os quatro tipos de fluxos e seus casos de uso
• O módulo cluster e o modelo multiprocessos
• Comparando JWT e sessões: qual escolher?
• Princípios do middleware e o modelo da cebola (Koa)
• Solução de problemas de vazamento de memória e otimização de desempenho

▶ Exemplo: Passos para contribuir com um projeto de código aberto

1. Find projects that interest you（GitHub Topics / Good First Issue）
2. Read CONTRIBUTING.md and coding standards
3. Fork Warehouse，Create a feature branch
4. Submit small, clear PR（Document Repair → Bug Fix → New Features）
5. In response to the maintainer's Review Comments
6. Ongoing Contribution，Gradually become Regular Contributor

❓ Perguntas Frequentes

P: O que devo aprender depois de terminar o Node.js? R: Recomendo três caminhos: TypeScript (segurança de tipos), Nest.js (framework de nível empresarial) ou Next.js (desenvolvimento full-stack). Escolha de acordo com seus objetivos.

P: Qual é a diferença entre o NestJS e o Express? R: O NestJS é construído com base no Express (ou no Fastify) e oferece decoradores, injeção de dependências e um sistema de módulos — é como uma versão de back-end do Angular. O Express oferece mais flexibilidade, enquanto o NestJS é mais estruturado.

P: Devo aprender TypeScript? R: É altamente recomendado. O TypeScript oferece segurança de tipos, autocompletar no IDE e suporte à refatoração para projetos em Node.js, além de ser praticamente um padrão para projetos de médio a grande porte.

P: Como posso contribuir para um projeto de código aberto do Node.js? R: Comece melhorando a documentação e corrigindo pequenos bugs. Leia o arquivo CONTRIBUTING.md, abra uma issue para discutir sua proposta antes de enviar um PR e certifique-se de que seu código seja aprovado nos testes e nas verificações de lint.

P: Como são os salários dos desenvolvedores de Node.js? R: O salário médio global dos desenvolvedores de Node.js é superior à média dos desenvolvedores full-stack. Em cidades de primeiro nível, desenvolvedores com 3 a 5 anos de experiência ganham aproximadamente 25–45 mil por mês, e há muitas oportunidades de trabalho remoto no exterior.

• P: Qual é a diferença entre o Next.js e o Nuxt? R: O Next.js é baseado no React, enquanto o Nuxt é baseado no Vue. Ambos são frameworks full-stack de SSR/SSG; seus conceitos centrais são semelhantes, mas seus ecossistemas e sintaxe diferem.
• P: Vale a pena aprender NestJS? R: Se você estiver desenvolvendo back-ends corporativos de grande escala ou microsserviços, a injeção de dependências, os decoradores e a modularidade do NestJS são extremamente valiosos; para projetos pequenos, o Express ou o Fastify são opções mais leves.
• P: O TypeScript é necessário no Node? R: Não é obrigatório, mas tornou-se uma tendência do setor. A segurança de tipos reduz erros, aprimora a experiência no IDE e torna a colaboração em equipe mais eficiente; é altamente recomendado para projetos de médio a grande porte.
• P: Como devo me preparar para uma entrevista sobre Node.js? R: Domine conceitos fundamentais, como o ciclo de eventos, streams e middleware; prepare-se para apresentar 1 ou 2 projetos; pratique problemas de algoritmos do LeetCode; e compreenda os padrões de design mais comuns.
• P: Como posso participar de projetos de código aberto do Node.js? R: Comece com um “Good First Issue” — corrija a documentação e pequenos bugs, leia as diretrizes de contribuição, envie pull requests claros e concisos e continue participando para construir sua reputação.
• P: O Bun vai substituir o Node.js? R: O Bun tem uma vantagem em termos de velocidade, mas o ecossistema do Node.js é vasto demais para que ele o substitua tão cedo. Os dois vão coexistir, e o Bun é mais adequado para novos projetos que buscam experimentar algo diferente.

📖 Resumo

• Após a formatura: conceitos-chave e como aproveitar os próximos passos da Alice
• Conceitos fundamentais e métodos de aplicação para comparar direções futuras
• Conceitos fundamentais e uso dos mapas de trajetória de aprendizagem
• Conceitos-chave e como utilizar os recursos de aprendizagem recomendados
• Conceitos básicos e uso do exemplo abrangente “Hello World” do NestJS
• Conceitos-chave e melhores práticas para a preparação para entrevistas e contribuições em código aberto

📝 Exercícios

1. Escolha entre Next.js ou NestJS, crie um projeto “Hello World” e experimente as diferenças em relação ao Express.
2. Reescreva os modelos User e Task para a API de gerenciamento de tarefas usando TypeScript para aproveitar os benefícios da segurança de tipos.
3. Encontre um projeto Node.js no GitHub marcado com a tag good first issue e analise a estrutura do código-fonte.
4. Elabore seu plano de estudos de três meses: TypeScript no primeiro mês, Next.js/NestJS no segundo mês e um projeto prático abrangente no terceiro mês.
5. Crie um blog técnico ou um portfólio no GitHub para documentar suas anotações de estudo e sua experiência em projetos, e se preparar para entrevistas.

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

Sobre Nós