NestJS Enterprise Backend APIs · Lekcja

Trasy i obsługa żądań

Definiuj trasy API, obsługuj różne metody HTTP i pobieraj dane z treści żądań, parametrów oraz zapytań.

Lekcja 1 z 312 kroki

Trasy i obsługa żądań to bezpłatna lekcja NestJS Enterprise Backend APIs na CoddyKit. To lekcja 1 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej NestJS Enterprise Backend APIs, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Understanding API Routes

When you build a web API, you need a way for clients (like a browser or mobile app) to send requests to specific functions on your server. This is where routes come in!

A route defines how a client's request URL (like /users or /products/1) maps to a particular action in your application code. It's like a street address for your API's functionalities.

HTTP Methods: The Action Verbs

Besides the URL, every request also uses an HTTP method, which tells the server what kind of action the client wants to perform. Common methods include:

GET: Retrieve data (e.g., get a list of users).
POST: Create new data (e.g., create a new user).
PUT: Update existing data completely.
PATCH: Partially update existing data.
DELETE: Remove data.

NestJS uses decorators like @Get() or @Post() to link these methods to your controller functions.

Your First GET Route

Let's define a simple route to fetch some data. In NestJS, you use controllers to handle incoming requests and define routes.

The @Controller() decorator defines a base path for all routes within that controller. Then, methods like @Get() define specific endpoints and their HTTP methods.

Simple GET Route Example

Here's a basic NestJS app with a /greet endpoint. Run this example, then try accessing http://localhost:3000/greet in your browser or a tool like Postman.

You should see: Hello from NestJS!

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get } from '@nestjs/common';

@Controller('greet')
class GreetController {
  @Get()
  getGreeting(): string {
    return 'Hello from NestJS!';
  }
}

@Module({
  controllers: [GreetController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Dynamic Routes with Parameters

Often, you need routes that include dynamic data, like fetching a specific user by their ID (e.g., /users/123). These are called path parameters.

In NestJS, you define path parameters using a colon (:) followed by the parameter name in your @Get() decorator (e.g., @Get(':id')). You then extract its value using the @Param() decorator in your method signature.

Path Parameters Example

This example shows how to get a user ID from the URL path. If you run this, then visit http://localhost:3000/users/123, the output will be:

User ID: 123

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Param } from '@nestjs/common';

@Controller('users')
class UsersController {
  @Get(':id')
  findUser(@Param('id') id: string): string {
    return `User ID: ${id}`;
  }
}

@Module({
  controllers: [UsersController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Filtering with Query Parameters

Query parameters are another way to pass data to your routes, often used for optional filtering, sorting, or pagination (e.g., /items?category=books&limit=5).

These parameters appear after a question mark (?) in the URL, as key-value pairs separated by ampersands (&). NestJS lets you easily access them using the @Query() decorator.

Query Parameters Example

This route uses query parameters to filter items. If you run this, then visit http://localhost:3000/items?category=books&limit=5, you'll see:

Category: books, Limit: 5

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Get, Query } from '@nestjs/common';

@Controller('items')
class ItemsController {
  @Get()
  findItems(
    @Query('category') category: string,
    @Query('limit') limit: string,
  ): string {
    return `Category: ${category || 'all'}, Limit: ${limit || '10'}`;
  }
}

@Module({
  controllers: [ItemsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Handling Request Body (POST/PUT)

For operations that send a lot of data, like creating a new resource (POST) or updating an existing one (PUT), the data is typically sent in the request body.

The request body can contain structured data, often JSON. NestJS provides the @Body() decorator to easily parse and extract this data directly into your controller method's arguments.

Request Body Example (POST)

This example shows how to accept data in the request body for a POST request. If you send a POST request to http://localhost:3000/products with a JSON body like {"name": "Laptop", "price": 1200}, the output will be:

Product created: {"name":"Laptop","price":1200}

// main.ts - Minimal NestJS app setup
import { NestFactory } from '@nestjs/core';
import { Module, Controller, Post, Body } from '@nestjs/common';

interface Product {
  name: string;
  price: number;
}

@Controller('products')
class ProductsController {
  @Post()
  createProduct(@Body() product: Product): string {
    return `Product created: ${JSON.stringify(product)}`;
  }
}

@Module({
  controllers: [ProductsController],
})
class AppModule {}

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
  console.log('Server running on http://localhost:3000');
}
bootstrap();

Route Handling Check

Consider the following NestJS controller snippet:

import { Controller, Get, Param, Query } from '@nestjs/common';

@Controller('articles')
class ArticlesController {
  @Get(':id')
  getArticleById(@Param('id') id: string): string {
    return `Article ID: ${id}`;
  }

  @Get()
  searchArticles(@Query('keyword') keyword: string): string {
    return `Searching for: ${keyword || 'all articles'}`;
  }
}

Which URL would successfully retrieve an article with ID "123"?

Odpowiedz w interaktywnej lekcji

Recap: Routes & Requests

Great job! You've covered the fundamentals of defining API routes and handling different types of incoming data in NestJS:

Routes map URLs to controller actions.
HTTP methods (GET, POST, PUT, DELETE) define the action type.
Path parameters (@Param()) capture dynamic segments from the URL path.
Query parameters (@Query()) extract optional key-value pairs from the URL string.
Request body (@Body()) handles data sent with POST/PUT requests.

These are crucial building blocks for any robust RESTful API!

Bezpłatny start

Ucz się TypeScript dzięki korepetycjom AI — za darmo

Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.

Kursy: 20
Lekcje: 76

Zacznij naukę bezpłatnie Wyświetl pełny kurs

Często zadawane pytania

Czy lekcja „Trasy i obsługa żądań” jest bezpłatna?

Tak — pełny tekst „Trasy i obsługa żądań” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu NestJS Enterprise Backend APIs, przejdź na CoddyKit PRO. Kurs NestJS Enterprise Backend APIs zawiera 3 lekcji w sumie.

Co nauczysz się w „Trasy i obsługa żądań”?

Definiuj trasy API, obsługuj różne metody HTTP i pobieraj dane z treści żądań, parametrów oraz zapytań. Ćwiczysz NestJS Enterprise Backend APIs z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć NestJS Enterprise Backend APIs?

Nie wymagamy żadnego doświadczenia. NestJS Enterprise Backend APIs w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 3.

Ile czasu zajmuje lekcja „Trasy i obsługa żądań”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji NestJS Enterprise Backend APIs?

Tak. Każda lekcja NestJS Enterprise Backend APIs zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do NestJS Enterprise Backend APIs