NestJS Enterprise Backend APIs · Lektion

DTOs und Validierungspipes

Implementieren Sie Data Transfer Objects (DTOs) und verwenden Sie Validierungspipes, um sicherzustellen, dass eingehende Anfragedaten festgelegte Kriterien erfüllen.

Lektion 2 von 311 Schritte

DTOs und Validierungspipes ist eine kostenlose NestJS Enterprise Backend APIs-Lektion auf CoddyKit. Dies ist Lektion 2 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des NestJS Enterprise Backend APIs-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 3 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Why Data Transfer Objects?

When building APIs, your application receives data from users. This data needs to be structured and safe.

Data Transfer Objects (DTOs) are plain classes that define the expected shape of the data coming into your application (e.g., from a request body) or going out (e.g., as a response).

Using DTOs helps with:

Clarity: Clearly shows what data is expected.
Consistency: Ensures data adheres to a specific format.
Security: Prevents unexpected or malicious data from being processed.

Defining a Simple DTO

A DTO is essentially a TypeScript class with properties that match the data you expect. It's a blueprint for your data.

Here's a basic example for creating a new product:

export class CreateProductDto {
  name: string;
  description: string;
  price: number;
}

DTOs in NestJS Context

In a NestJS application, you'll typically create DTO files in a dto folder within your module (e.g., src/products/dto/create-product.dto.ts).

These classes are then used in your controllers to type the incoming request body.

import { Body, Controller, Post } from '@nestjs/common';
import { CreateProductDto } from './dto/create-product.dto';

@Controller('products')
export class ProductsController {
  @Post()
  create(@Body() createProductDto: CreateProductDto) {
    // createProductDto will have 'name', 'description', 'price'
    console.log(createProductDto);
    return 'Product created!';
  }
}

Why Validate Input?

Just defining a DTO isn't enough. What if a user sends invalid data?

A name that's too short?
A price that's negative or not a number?
Missing required fields?

Without validation, your application could:

Store bad data.
Crash unexpectedly.
Be vulnerable to security exploits.

This is where NestJS Validation Pipes come in!

Introducing Validation Pipes

A Validation Pipe is a special type of middleware in NestJS that automatically validates incoming request data against your DTO definitions.

If the data doesn't match the rules you've set, the pipe will automatically throw an error, preventing invalid data from reaching your controller logic.

The Validation Duo: `class-validator` & `class-transformer`

NestJS leverages two powerful libraries for DTO validation:

class-validator: Provides decorators (like @IsString(), @IsInt()) to define validation rules directly on your DTO properties.
class-transformer: Helps convert plain JavaScript objects (from the request body) into instances of your DTO classes, which is crucial for class-validator to work correctly.

You'll need to install them:

npm i class-validator class-transformer

Decorating Your DTOs for Validation

Let's add some validation rules to our CreateProductDto using decorators from class-validator.

These decorators ensure that the incoming data meets specific criteria, like being a string, a number, or not empty.

import { IsString, IsNumber, IsNotEmpty, IsPositive } from 'class-validator';

export class CreateProductDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsString()
  @IsNotEmpty()
  description: string;

  @IsNumber()
  @IsPositive()
  price: number;
}

Applying `ValidationPipe` to a Route

Now that our DTO has validation decorators, we need to tell NestJS to use the ValidationPipe for a specific route.

You can apply it using the @UsePipes() decorator on your controller method. This makes the pipe active only for that particular route.

import { Controller, Post, Body, UsePipes, ValidationPipe } from '@nestjs/common';
import { CreateProductDto } from './dto/create-product.dto';

@Controller('products')
export class ProductsController {
  @Post()
  @UsePipes(new ValidationPipe()) // Apply pipe here
  create(@Body() createProductDto: CreateProductDto) {
    // If validation fails, this code won't run
    return `Product '${createProductDto.name}' created!`;
  }
}

Global Validation Pipe

Applying @UsePipes(new ValidationPipe()) to every method can be repetitive. For consistency, you can register the ValidationPipe globally in your main.ts file.

This will apply the validation pipe to all incoming requests across your entire application, simplifying your code and ensuring consistent validation.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe()); // Apply pipe globally
  await app.listen(3000);
}
bootstrap();

Check Your Knowledge

Time to test what you've learned about DTOs and Validation Pipes!

Beantworte es in der interaktiven Lektion

Recap: DTOs & Validation Pipes

You've mastered DTOs and Validation Pipes!

DTOs are TypeScript classes that define the structure of data for your API.
They bring clarity, consistency, and security to your data handling.
Validation Pipes automatically enforce rules defined by class-validator decorators.
class-transformer ensures incoming data is converted to DTO instances for validation.
Pipes can be applied per-route with @UsePipes() or globally in main.ts.

This ensures your NestJS API always receives and processes clean, valid data.

Kostenlos starten

Lerne TypeScript mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 20
Lektionen: 76

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „DTOs und Validierungspipes“ kostenlos?

Ja — der vollständige Text von „DTOs und Validierungspipes“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des NestJS Enterprise Backend APIs-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der NestJS Enterprise Backend APIs-Kurs umfasst insgesamt 3 Lektionen.

Was lerne ich in „DTOs und Validierungspipes“?

Implementieren Sie Data Transfer Objects (DTOs) und verwenden Sie Validierungspipes, um sicherzustellen, dass eingehende Anfragedaten festgelegte Kriterien erfüllen. Du übst NestJS Enterprise Backend APIs mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um NestJS Enterprise Backend APIs zu starten?

Keine Vorkenntnisse erforderlich. NestJS Enterprise Backend APIs auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 3.

Wie lange dauert die Lektion „DTOs und Validierungspipes“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser NestJS Enterprise Backend APIs-Lektion Code schreiben und ausführen?

Ja. Jede NestJS Enterprise Backend APIs-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu NestJS Enterprise Backend APIs