Indatavalidering med Joi/Express-Validator
Validera inkommande förfrågningsdata med kraftfulla bibliotek som Joi eller express-validator för att säkerställa dataintegriteten.
Indatavalidering med Joi/Express-Validator är en gratis lektion i Bootcamp i backendutveckling med Node.js på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Bootcamp i backendutveckling med Node.js, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.
Varför validera indata?
Validering av indata är en viktig säkerhetsåtgärd och metod för att säkerställa dataintegritet. Den säkerställer att data som tas emot av applikationen är rena, korrekta och säkra att behandla.
Utan korrekt validering blir applikationen sårbar för:
- Säkerhetsintrång: Till exempel SQL-injektion eller Cross-Site Scripting (XSS).
- Datakorruption: Felaktigt formaterade data kan skada applikationen eller databasen.
- Bristande användarupplevelse: Inkonsekventa data leder till buggar och oväntat beteende.
Ovaliderade data: en säkerhetsrisk
Föreställ Er att en användare skickar in ett formulär utan validering. Användaren skulle kunna skicka:
- Tomma fält: Obligatorisk information saknas.
- Felaktiga datatyper: Ett numeriskt fält får text som värde.
- Skadliga skript: Kod som är utformad för att utnyttja systemet.
Validering fungerar som en grindvakt och förhindrar att felaktiga data når applikationens kärna.
Joi: Definiera datastrukturen
Joi är ett kraftfullt språk för schemabeskrivningar och en datavaliderare för JavaScript. Det gör det möjligt att definiera datastruktur, typ och begränsningar med hjälp av ett tydligt, kedjande API.
Tänk på ett Joi-schema som en ritning för de data Ni förväntar Er. Alla data som inte följer denna ritning markeras som ogiltiga.
Joi-schema i praktiken
Här är ett enkelt Joi-schema för en användares namn och ålder. Försök köra det för att se hur valideringen fungerar. Kom ihåg att installera 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-route
För att använda Joi i en Express.js-applikation skapar Ni vanligtvis en middleware-funktion som utför valideringen innan route-hanteraren körs. På så sätt hålls route-hanterarna rena och fokuserade på affärslogik.
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 är en uppsättning Express.js-middleware-funktioner som kapslar in det kraftfulla biblioteket validator.js. Fokus ligger på att validera och rensa data direkt i Express request-cykel.
Det används ofta eftersom det integreras smidigt med Express-routes och gör det möjligt att kedja flera valideringsregler direkt i route-definitionerna.
Express-Validator i praktiken
Så här använder Ni express-validator för att validera en e-postadress och ett lösenord direkt i en Express-route. Lägg märke till funktionerna check() och validationResult(). Kom ihåg att installera 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\"}');
});Svara på valideringsfel
När valideringen misslyckas bör API:t returnera ett tydligt och informativt felmeddelande till klienten. Både Joi och Express-Validator erbjuder sätt att hämta dessa fel.
- Joi: Objektet
errorinnehållerdetailsmed specifika meddelanden. - Express-Validator:
validationResult(req)samlar alla fel i en array, som ofta innehåller fältnamn och meddelanden.
Returnera alltid en lämplig HTTP-statuskod, till exempel 400 Bad Request, för att visa att problemet gäller indata från klienten.
Joi kontra Express-Validator: välj med omsorg
Båda biblioteken är utmärkta, men lämpar sig bäst i olika situationer:
- Joi: Idealisk för komplexa, nästlade datastrukturer. Utmärkt för att definiera ett strikt schema för hela datamodellen, ofta vid validering av DTO (Data Transfer Object).
- Express-Validator: Perfekt för snabb, inline-validering av förfrågningsparametrar (body, query, params) direkt i Era Express-routes. Middleware-metoden integreras smidigt.
Ni kan till och med använda båda! Joi för centrala datamodeller och Express-Validator för enklare, route-specifika kontroller.
Valideringskontroll
Betrakta följande påståenden om validering av indata med Joi och Express-Validator:
Sammanfattning: skydda Er indata
Grattis! Ni har lärt Er hur viktigt det är att validera indata och hur det kan implementeras med två populära Node.js-bibliotek:
- Joi: För att definiera robusta, schemabaserade valideringsregler för komplexa data.
- Express-Validator: För lättviktig, middleware-baserad validering direkt i Era Express-routes.
Validera alltid inkommande data för att skydda applikationen mot sårbarheter och säkerställa dataintegriteten. Fortsätt bygga säkra och tillförlitliga API:er!
Lär dig JavaScript med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 22
- Lektioner
- 92
Vanliga frågor
Är lektionen ”Indatavalidering med Joi/Express-Validator” gratis?
Ja – hela texten till ”Indatavalidering med Joi/Express-Validator” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Bootcamp i backendutveckling med Node.js, kan Ni uppgradera till CoddyKit PRO. Kursen i Bootcamp i backendutveckling med Node.js innehåller totalt 4 lektioner.
Vad lär jag mig i ”Indatavalidering med Joi/Express-Validator”?
Validera inkommande förfrågningsdata med kraftfulla bibliotek som Joi eller express-validator för att säkerställa dataintegriteten. Ni övar på Bootcamp i backendutveckling med Node.js med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Bootcamp i backendutveckling med Node.js?
Du behöver inga förkunskaper. Utbildningen i Bootcamp i backendutveckling med Node.js på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Indatavalidering med Joi/Express-Validator”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Bootcamp i backendutveckling med Node.js-lektionen?
Ja. Varje Bootcamp i backendutveckling med Node.js-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Utveckla anpassad Express-middleware
- Strategier för global felhantering
- Indatavalidering med Joi/Express-Validator
- Autentiseringsmiddleware med JWT