Serveur HTTP natif avec Node.js

http.createServer(), routage manuel, et pourquoi Express existe

Utilisez les flĂšches, cliquez ou glissez pour naviguer

Objectifs de la leçon

1. Créer un serveur HTTP

Avec le module natif http de Node.js

2. Parser l'URL et la méthode

req.method, req.url — les bases

3. Routage manuel

If/else sur l'URL et la méthode

4. Comprendre Express

Ce qu'il automatise et pourquoi il existe

Plan du cours

1

Node.js peut créer des serveurs

Pas besoin d'Apache ou Nginx — le module http suffit

2

Live coding : http.createServer()

req.method, req.url, res.writeHead, res.end

3

Routage manuel avec if/else

Fonctionnel mais verbeux — on voit les limites

4

Lire le body d'un POST

req.on('data'), req.on('end') — les chunks

5

Pourquoi Express existe

Les limites du natif et ce qu'Express automatise

Node.js n'a pas besoin d'Apache

Le module http est inclus dans Node.js

Pas d'Apache, Nginx, ou autre serveur web. Node.js peut Ă©couter un port et rĂ©pondre aux requĂȘtes HTTP directement.

📩

http

Module natif

🔌

.listen()

Écoute un port

📋

createServer()

Callback par requĂȘte

import http from 'node:http';

 

const server = http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

// Cette fonction est appelĂ©e Ă  chaque requĂȘte

});

 

server.listen(3000);

1ïžâƒŁ Premier serveur HTTP

3 lignes suffisent pour répondre "Hello World"

import http from 'node:http';

 

http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

res.writeHead(200, { 'Content-Type': 'text/plain' });

res.end('Hello World');

}).listen(3000);

💡 Lancez avec node server.js et visitez http://localhost:3000

req.method et req.url

Chaque requĂȘte contient la mĂ©thode et l'URL.

import http from 'node:http';

 

http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

// req.method → 'GET', 'POST', 'PUT', 'DELETE'...

// req.url → '/', '/users', '/api/products?page=2'

 

console.log(req.method, req.url);

});

req.method

GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS...

req.url

Chemin + query string brute (ex: /users?role=admin)

⚠ req.url contient la query string — il faut parser si besoin

Routage manuel avec if/else

Une longue chaĂźne de conditions sur req.method + req.url

import http from 'node:http';

 

http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

if

(req.method === 'GET' && req.url === '/') {

res.writeHead(200, { 'Content-Type': 'text/html' });

res.end('<h1>Accueil</h1>');

} else if

(req.method === 'GET' && req.url === '/users') {

res.writeHead(200);

res.end('Liste des utilisateurs');

} else if

(req.method === 'GET' && req.url === '/contact') {

res.writeHead(200);

res.end('Page contact');

} else {

res.writeHead(404);

res.end('404 Not Found');

}

});

✅ Ça marche — mais imaginez 50 routes...

Lire le body d'une requĂȘte POST

⚠ En natif, req.body n'existe pas !

Le body arrive en chunks (morceaux) — il faut les collecter un par un.

import http from 'node:http';

 

http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

let body: string = '';

 

// À chaque morceau reçu

req.on('data', (chunk: Buffer) => {

body += chunk.toString();

});

 

// Quand tout est reçu

req.on('end', () => {

// body contient le JSON complet

const data: Record<string, unknown> = JSON.parse(body);

res.end('Données reçues !');

});

});

💡 Toujours attendre 'end' avant d'utiliser le body

Route POST complÚte : création d'utilisateur

import http from 'node:http';

 

http.createServer((

req: http.IncomingMessage,

res: http.ServerResponse

) => {

if

(req.method === 'POST' && req.url === '/users') {

let body: string = '';

req.on('data', (chunk: Buffer) => { body += chunk; });

req.on('end', () => {

const user: Record<string, unknown> = JSON.parse(body);

res.writeHead(201);

res.end(JSON.stringify({

message: 'Utilisateur créé',

name: user.name

}));

});

} else {

res.writeHead(404);

res.end('Pas trouvé');

}

});

🔑 3 Ă©tapes : collecter les chunks → parser le JSON → rĂ©pondre

Les limites du serveur natif

❌ Routage verbeux

if/else gĂ©ant — pas de :params, pas de regex faciles

❌ Body à collecter manuellement

Chaque route POST doit réécrire le pattern data/end

❌ Pas de middleware

Logging, CORS, auth — tout à la main

❌ Query string non parsĂ©e

req.url donne /users?page=2 — Ă  dĂ©couper

✅ Express rĂ©sout tout ça

Ce qu'Express automatise

❌ Natif (verbeux)

if (method === 'GET' && url === '/users')

let body = ''

req.on('data', ...)

req.on('end', ...)

✅ Express (concis)

import express from 'express';

 

const app = express();

 

app.get('/users', (

req: express.Request,

res: express.Response

) => {

// req.body déjà parsé

// req.query déjà parsé

// req.params disponible

});

app.get('/users/:id') → req.params.id

app.use(express.json()) → req.body automatique

app.use(logger) → middleware rĂ©utilisable

Comparaison : natif vs Express

❌ Natif (15+ lignes)

http.createServer((

req: IncomingMessage,

res: ServerResponse

) => {

if (req.method === 'GET'

&& req.url === '/') {

res.writeHead(200);

res.end('Home');

} else if (...) {

// ... encore du if/else

}

}).listen(3000);

✅ Express (3 lignes)

import express from 'express';

 

const app = express();

 

app.get('/', (

req: express.Request,

res: express.Response

) => {

res.send('Home');

});

 

app.listen(3000);

🎯 En comprenant le natif, vous apprĂ©ciez ce qu'Express fait pour vous

PiĂšges courants

❌ Oublier res.end()

Le client reste bloquĂ© en attente — la requĂȘte ne termine jamais

❌ Croire que req.body existe en natif

Non — il faut impĂ©rativement Ă©couter 'data' et 'end'

❌ Routage if/else qui devient ingĂ©rable

50 routes = 500 lignes de if/else — illisible et non maintenable

✅ C'est normal — le but est de comprendre pourquoi Express existe

Points clés à retenir

http.createServer((req, res) => {...})

Une fonction appelĂ©e Ă  chaque requĂȘte

req.method et req.url

Pour savoir ce que le client demande

Le body arrive en chunks

Il faut les collecter avant de parser le JSON

Le serveur natif est verbeux

Express simplifie tout ça — et vous comprenez dĂ©sormais pourquoi

À retenir !

📩 Module http

Inclus dans Node.js — pas besoin de dĂ©pendances pour un premier serveur

🔀 Routage manuel

if/else sur method + url — fonctionnel mais limitĂ©

đŸ“„ Body asynchrone

Écouter data/end — le body n'arrive pas d'un coup

⚡ Express

Routes, middlewares, body parser — tout est automatisĂ©

💡 Vous ne réécrirez pas le natif tous les jours — mais savoir ce que Express fait sous le capot fait de vous un meilleur dĂ©veloppeur

Questions ?

Demain : Express — le routage, les middlewares, et le body parser

Le natif vous appartient maintenant

Vous comprenez ce que Express automatise — c'est la diffĂ©rence entre un utilisateur et un dĂ©veloppeur