Bootcamp i backendudvikling med Node.js · Lektion

Inputvalidering med Joi/Express-Validator

Validér indkommende requestdata med effektive biblioteker som Joi eller express-validator for at sikre dataintegriteten.

Lektion 3 af 411 trin

Inputvalidering med Joi/Express-Validator er en gratis Bootcamp i backendudvikling med Node.js-lektion på CoddyKit. Dette er lektion 3 af 4. 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 Bootcamp i backendudvikling med Node.js, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvorfor validere input?

Inputvalidering er en vigtig praksis for sikkerhed og dataintegritet. Den sikrer, at de data, din applikation modtager, er rene, korrekte og sikre at behandle.

Uden ordentlig validering bliver din applikation sårbar over for:

Sikkerhedsbrud: F.eks. SQL-injektion eller Cross-Site Scripting (XSS).
Datakorruption: Forkert formaterede data kan ødelægge din applikation eller database.
Dårlig brugeroplevelse: Inkonsekvente data fører til fejl og uventet adfærd.

Uvaliderede data: En sikkerhedsrisiko

Forestil dig, at en bruger sender en formular uden validering. Brugeren kan sende:

Tomme felter: Obligatoriske oplysninger mangler.
Forkerte datatyper: Et numerisk felt modtager tekst.
Ondsindede scripts: Kode, der er designet til at udnytte dit system.

Validering fungerer som en dørvogter, der forhindrer dårlige data i at trænge ind i kernen af din applikation.

Joi: Definér formen på dine data

Joi er et kraftfuldt sprog til skemabeskrivelse og en datavalidator til JavaScript. Det giver dig mulighed for at definere strukturen, typen og begrænsningerne for dine data ved hjælp af en tydelig API, som kan kædes sammen.

Opfat et Joi-skema som en plan for de data, du forventer. Alle data, der ikke passer til planen, markeres som ugyldige.

Joi-skema i praksis

Her er et enkelt Joi-skema for en brugers navn og alder. Prøv at køre det for at se, hvordan validering fungerer. Husk at installere Joi først (npm install joi).

const Joi = require('joi');

const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  age: Joi.number().integer().min(0).max(120).required()
});

async function runValidation() {
  const validUser = { username: 'john_doe', age: 30 };
  const invalidUser = { username: 'ab', age: 'twenty' };

  console.log('--- Valid User Test ---');
  try {
    const value = await userSchema.validateAsync(validUser);
    console.log('Validation successful for validUser!');
  } catch (err) {
    console.error('Validation failed for validUser:', err.details[0].message);
  }

  console.log('\n--- Invalid User Test ---');
  try {
    const value = await userSchema.validateAsync(invalidUser);
    console.log('Validation successful for invalidUser!');
  } catch (err) {
    console.error('Validation failed for invalidUser:', err.details[0].message);
  }
}

runValidation();

Joi i en Express-rute

For at bruge Joi i en Express.js-applikation opretter du typisk en middleware-funktion, der udfører valideringen, før rutehandleren køres. Det holder dine rutehandlere rene og fokuserede på forretningslogikken.

const express = require('express');
const Joi = require('joi');
const app = express();
const port = 3000;

app.use(express.json()); // For parsing application/json

const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  email: Joi.string().email().required(),
  password: Joi.string().min(6).required()
});

// Middleware to validate request body using Joi
const validateUser = (req, res, next) => {
  const { error } = userSchema.validate(req.body);
  if (error) {
    return res.status(400).send(error.details[0].message);
  }
  next(); // If validation passes, proceed to the route handler
};

app.post('/register', validateUser, (req, res) => {
  // If we reach here, req.body is valid
  res.status(201).send('User registered successfully!');
});

app.get('/', (req, res) => {
  res.send('Server is running. Try POST to /register with JSON data.');
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
  console.log('Try: POST http://localhost:3000/register with {\"username\":\"testuser\", \"email\":\"a@b.com\", \"password\":\"password123\"}');
  console.log('Or with invalid data: {\"username\":\"ab\", \"email\":\"a@b.com\"}');
});

Express-Validator: Middleware-kraft

Express-Validator er et sæt Express.js-middleware-funktioner, der indpakker det kraftfulde bibliotek validator.js. Fokus er på at validere og rense data direkte i Express' anmodningscyklus.

Det foretrækkes ofte på grund af den problemfri integration med Express-ruter, som giver dig mulighed for at kæde flere valideringsregler direkte sammen i dine rutedefinitioner.

Express-Validator i praksis

Sådan bruger du express-validator til at validere en e-mailadresse og en adgangskode direkte i en Express-rute. Bemærk funktionerne check() og validationResult(). Husk at installere Express-Validator (npm install express-validator).

const express = require('express');
const { check, validationResult } = require('express-validator');
const app = express();
const port = 3000;

app.use(express.json());

app.post('/login', [
  check('email', 'Email is required').notEmpty(),
  check('email', 'Please include a valid email').isEmail(),
  check('password', 'Password must be 6 or more characters').isLength({ min: 6 })
], (req, res) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  // If we reach here, req.body is valid
  res.send('User logged in successfully!');
});

app.get('/', (req, res) => {
  res.send('Server is running. Try POST to /login with JSON data.');
});

app.listen(port, () => {
  console.log(`Server listening at http://localhost:${port}`);
  console.log('Try: POST http://localhost:3000/login with {\"email\":\"user@example.com\", \"password\":\"password123\"}');
  console.log('Or with invalid data: {\"email\":\"bademail\", \"password\":\"123\"}');
});

Svar på valideringsfejl

Når valideringen mislykkes, bør din API returnere en tydelig og informativ fejlmeddelelse til klienten. Både Joi og Express-Validator giver mulighed for at udtrække disse fejl.

Joi: error-objektet indeholder details med specifikke meddelelser.
Express-Validator: validationResult(req) samler alle fejl i et array, som ofte indeholder feltnavne og meddelelser.

Returnér altid en passende HTTP-statuskode, f.eks. 400 Bad Request, for at angive problemer med input fra klienten.

Joi kontra Express-Validator: Vælg med omtanke

Begge biblioteker er fremragende, men de er bedst egnede i forskellige situationer:

Joi: Ideelt til komplekse, indlejrede datastrukturer. Velegnet til at definere et strengt skema for hele din datamodel, ofte brugt til DTO-validering (Data Transfer Object).
Express-Validator: Perfekt til hurtig, indlejret validering af anmodningsparametre (body, query, params) direkte i dine Express-ruter. Middleware-tilgangen integreres problemfrit.

Du kan endda bruge begge! Joi til centrale datamodeller og Express-Validator til enklere, rutespecifikke kontroller.

Valideringskontrol

Overvej følgende påstande om inputvalidering med Joi og Express-Validator:

Besvar den i den interaktive lektion

Opsamling: Beskyt dine input

Tillykke! Du har lært, hvor vigtig inputvalidering er, og hvordan du implementerer den ved hjælp af to populære Node.js-biblioteker:

Joi: Til at definere robuste, skemabaserede valideringsregler for komplekse data.
Express-Validator: Til letvægtsvalidering baseret på middleware direkte i dine Express-ruter.

Validér altid indgående data for at beskytte din applikation mod sårbarheder og sikre dataintegriteten. Fortsæt med at opbygge sikre og pålidelige API'er!

Gratis at komme i gang

Lær JavaScript 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: 22
Lektioner: 92

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Inputvalidering med Joi/Express-Validator” gratis?

Ja — hele teksten til “Inputvalidering med Joi/Express-Validator” 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 Bootcamp i backendudvikling med Node.js-kurset, skal du opgradere til CoddyKit PRO. Bootcamp i backendudvikling med Node.js-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Inputvalidering med Joi/Express-Validator”?

Validér indkommende requestdata med effektive biblioteker som Joi eller express-validator for at sikre dataintegriteten. Du øver dig i Bootcamp i backendudvikling med Node.js 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å Bootcamp i backendudvikling med Node.js?

Der kræves ingen tidligere erfaring. Bootcamp i backendudvikling med Node.js 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 3 af 4.

Hvor lang tid tager lektionen “Inputvalidering med Joi/Express-Validator”?

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 Bootcamp i backendudvikling med Node.js-lektion?

Ja. Alle Bootcamp i backendudvikling med Node.js-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

Udvikling af brugerdefineret Express-middleware
Strategier til global fejlhåndtering
Inputvalidering med Joi/Express-Validator
Authentication-middleware med JWT

← Tilbage til Bootcamp i backendudvikling med Node.js