NestJS-backend-API'er til virksomheder · Lektion

Routes og requesthåndtering

Definér API-routes, håndtér forskellige HTTP-metoder, og udtræk data fra request bodies, parametre og queries.

Lektion 1 af 312 trin

Routes og requesthåndtering er en gratis NestJS-backend-API'er til virksomheder-lektion på CoddyKit. Dette er lektion 1 af 3. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i NestJS-backend-API'er til virksomheder, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. NestJS-backend-API'er til virksomheder-kurset indeholder 3 lektioner i alt.

Forståelse af API-ruter

Når du bygger et web-API, har du brug for en måde, hvorpå klienter (f.eks. en browser eller mobilapp) kan sende forespørgsler til bestemte funktioner på din server. Det er her, ruter kommer ind i billedet!

En rute definerer, hvordan en klients URL til en forespørgsel (f.eks. /users eller /products/1) knyttes til en bestemt handling i din applikationskode. Det er som en gadeadresse for dit API's funktioner.

HTTP-metoder: Handlingsverberne

Ud over URL'en bruger hver forespørgsel også en HTTP-metode, som fortæller serveren, hvilken type handling klienten vil udføre. Almindelige metoder omfatter:

GET: Hent data (f.eks. hent en liste over brugere).
POST: Opret nye data (f.eks. opret en ny bruger).
PUT: Opdater eksisterende data fuldstændigt.
PATCH: Opdater eksisterende data delvist.
DELETE: Fjern data.

NestJS bruger dekoratorer som @Get() eller @Post() til at knytte disse metoder til dine controllerfunktioner.

Din første GET-rute

Lad os definere en simpel rute til at hente nogle data. I NestJS bruger du controllere til at håndtere indkommende forespørgsler og definere ruter.

Dekoratoren @Controller() definerer en grundsti for alle ruter i den pågældende controller. Derefter definerer metoder som @Get() specifikke slutpunkter og deres HTTP-metoder.

Eksempel på en simpel GET-rute

Her er en grundlæggende NestJS-app med slutpunktet /greet. Kør dette eksempel, og prøv derefter at åbne http://localhost:3000/greet i din browser eller et værktøj som Postman.

Du bør se: 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();

Dynamiske ruter med parametre

Ofte har du brug for ruter, der indeholder dynamiske data, f.eks. når du henter en bestemt bruger efter vedkommendes ID (f.eks. /users/123). Disse kaldes sti-parametre.

I NestJS definerer du sti-parametre ved hjælp af et kolon (:) efterfulgt af parameternavnet i din @Get()-dekorator (f.eks. @Get(':id')). Derefter udtrækker du værdien ved hjælp af dekoratoren @Param() i metodens signatur.

Eksempel på sti-parametre

Dette eksempel viser, hvordan du henter et bruger-ID fra URL-stien. Hvis du kører dette og derefter besøger http://localhost:3000/users/123, bliver resultatet:

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();

Filtrering med forespørgselsparametre

Forespørgselsparametre er en anden måde at sende data til dine ruter på. De bruges ofte til valgfri filtrering, sortering eller sideinddeling (f.eks. /items?category=books&limit=5).

Disse parametre står efter et spørgsmålstegn (?) i URL'en som nøgleværdi-par, der er adskilt af ampersand-tegn (&). NestJS giver dig nem adgang til dem ved hjælp af dekoratoren @Query().

Eksempel på forespørgselsparametre

Denne rute bruger forespørgselsparametre til at filtrere elementer. Hvis du kører dette og derefter besøger http://localhost:3000/items?category=books&limit=5, ser du:

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();

Håndtering af forespørgselsbrødtekst (POST/PUT)

Ved handlinger, der sender mange data, f.eks. oprettelse af en ny ressource (POST) eller opdatering af en eksisterende (PUT), sendes dataene typisk i forespørgselsbrødteksten.

Forespørgselsbrødteksten kan indeholde strukturerede data, ofte JSON. NestJS tilbyder dekoratoren @Body(), som nemt fortolker og udtrækker disse data direkte til argumenterne i din controllermetode.

Eksempel på forespørgselsbrødtekst (POST)

Dette eksempel viser, hvordan du modtager data i anmodningens brødtekst for en POST-anmodning. Hvis du sender en POST-anmodning til http://localhost:3000/products med en JSON-brødtekst som {"name": "Laptop", "price": 1200}, bliver resultatet:

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();

Kontrol af rutebehandling

Se på følgende NestJS-controllerudsnit:

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'}`;
  }
}

Hvilken URL vil hente en artikel med id'et "123"?

Besvar den i den interaktive lektion

Opsummering: Ruter og anmodninger

Godt klaret! Du har gennemgået det grundlæggende i at definere API-ruter og håndtere forskellige typer indgående data i NestJS:

Ruter knytter URL'er til controllerhandlinger.
HTTP-metoder (GET, POST, PUT, DELETE) definerer handlingstypen.
Stiparametre (@Param()) opfanger dynamiske dele af URL-stien.
Forespørgselsparametre (@Query()) udtrækker valgfri nøgleværdi-par fra URL-strengen.
Anmodningens brødtekst (@Body()) håndterer data, der sendes med POST-/PUT-anmodninger.

Dette er afgørende byggesten i enhver robust RESTful API!

Gratis at komme i gang

Lær TypeScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 20
Lektioner: 76

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Routes og requesthåndtering” gratis?

Ja — hele teksten til “Routes og requesthåndtering” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af NestJS-backend-API'er til virksomheder-kurset, skal du opgradere til CoddyKit PRO. NestJS-backend-API'er til virksomheder-kurset indeholder 3 lektioner i alt.

Hvad lærer jeg i “Routes og requesthåndtering”?

Definér API-routes, håndtér forskellige HTTP-metoder, og udtræk data fra request bodies, parametre og queries. Du øver dig i NestJS-backend-API'er til virksomheder med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på NestJS-backend-API'er til virksomheder?

Der kræves ingen tidligere erfaring. NestJS-backend-API'er til virksomheder på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 3.

Hvor lang tid tager lektionen “Routes og requesthåndtering”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne NestJS-backend-API'er til virksomheder-lektion?

Ja. Alle NestJS-backend-API'er til virksomheder-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til NestJS-backend-API'er til virksomheder