Questions d'entretien pour Développeur Backend Junior (Node.js) : Guide Complet

Introduction

Ce guide complet contient 35 questions d'entretien soigneusement sélectionnées, couvrant les fondamentaux du développement backend Node.js. Ce sont les questions que les développeurs backend juniors rencontrent réellement lors des entretiens. Chaque question comprend une réponse approfondie, une évaluation de la rareté et une note de difficulté basées sur l'analyse de centaines d'entretiens réels provenant de grandes entreprises technologiques et de startups.

Que vous vous prépariez pour votre premier rôle backend ou que vous passiez du développement frontend, ce guide couvre tout, des fondamentaux de JavaScript à la conception d'API, en passant par la gestion de bases de données, les meilleures pratiques de sécurité et les stratégies de déploiement.

Fondamentaux de JavaScript (8 Questions)

1. Expliquez la différence entre var, let et const en JavaScript

Réponse :

• var : Portée de fonction, hissée et initialisée avec undefined, peut être redéclarée dans la même portée, largement obsolète dans le code moderne
• let : Portée de bloc, hissée mais reste dans la Temporal Dead Zone (TDZ) jusqu'à la déclaration, ne peut pas être redéclarée dans la même portée, peut être réassignée
• const : Portée de bloc, hissée mais dans la TDZ, doit être initialisée lors de la déclaration, ne peut pas être réassignée (mais le contenu des objets/tableaux peut être muté)

Exemple :

// var - portée de fonction
function example() {
  if (true) {
    var x = 1;
  }
  console.log(x); // 1 (accessible en dehors du bloc)
}

// let - portée de bloc
if (true) {
  let y = 2;
}
console.log(y); // ReferenceError

// const - ne peut pas être réassignée
const z = 3;
z = 4; // TypeError

const obj = { name: 'John' };
obj.name = 'Jane'; // OK - mutation de la propriété
obj = {}; // TypeError - ne peut pas être réassignée

Bonne pratique : Utilisez const par défaut, let lorsque vous devez réassigner, n'utilisez jamais var dans le JavaScript moderne.

Rareté : Courant Difficulté : Facile

2. Que sont les closures et fournissez un exemple pratique en Node.js ?

Réponse : Une closure se produit lorsqu'une fonction interne a accès aux variables de la portée de sa fonction externe (englobante), même après que la fonction externe est revenue. La fonction interne "se ferme sur" ces variables.

Exemple Node.js pratique :

// Modèle de fabrique de middleware
function createAuthMiddleware(secretKey) {
  // secretKey est "fermée sur" par la fonction renvoyée
  return function(req, res, next) {
    const token = req.headers.authorization;
    if (validateToken(token, secretKey)) {
      next();
    } else {
      res.status(401).json({ error: 'Unauthorized' });
    }
  };
}

// Utilisation
const authMiddleware = createAuthMiddleware(process.env.JWT_SECRET);
app.use('/api/protected', authMiddleware);

Avantages :

• Confidentialité des données (secretKey ne peut pas être accédée directement)
• Fabriques de fonctions
• Implémentation du modèle de module
• Maintien de l'état dans les opérations asynchrones

Rareté : Courant Difficulté : Moyen

3. Expliquez le mot-clé this et comment il diffère dans les fonctions fléchées

Réponse : this fait référence au contexte d'exécution. Sa valeur dépend de la FAÇON dont la fonction est appelée.

Fonctions régulières :

const obj = {
  name: "Server",
  greet: function() {
    console.log(this.name); // "Server"
  }
};
obj.greet(); // this = obj

const greet = obj.greet;
greet(); // this = undefined (mode strict) ou global

Fonctions fléchées :

const obj = {
  name: "Server",
  greet: () => {
    console.log(this.name); // undefined (portée lexicale)
  }
};
obj.greet(); // this = portée lexicale (portée du module dans Node.js)

Différence clé : Les fonctions fléchées n'ont pas leur propre this - elles l'héritent de la portée englobante.

Rareté : Courant Difficulté : Moyen

4. Que sont les Promises et en quoi diffèrent-elles des callbacks ?

Réponse : Une Promise représente l'achèvement éventuel (ou l'échec) d'une opération asynchrone.

Modèle de callback (callback hell) :

getUser(userId, (err, user) => {
  if (err) return handleError(err);
  getPosts(user.id, (err, posts) => {
    if (err) return handleError(err);
    getComments(posts[0].id, (err, comments) => {
      if (err) return handleError(err);
      // Callbacks imbriqués - difficile à lire
    });
  });
});

Modèle de Promise :

getUser(userId)
  .then(user => getPosts(user.id))
  .then(posts => getComments(posts[0].id))
  .then(comments => console.log(comments))
  .catch(err => handleError(err));

Avantages :

• Évite le callback hell
• Meilleure gestion des erreurs avec .catch()
• Opérations chaînables
• Peut utiliser Promise.all() pour les opérations parallèles

Rareté : Courant Difficulté : Facile-Moyen

5. Que sont async/await et comment améliorent-ils la lisibilité du code ?

Réponse : async/await est un sucre syntaxique construit sur les Promises qui rend le code asynchrone plus semblable et se comporte davantage comme du code synchrone.

Exemple :

// Avec les Promises
function fetchUserData(userId) {
  return fetchUser(userId)
    .then(user => {
      return fetchPosts(user.id)
        .then(posts => {
          return { user, posts };
        });
    })
    .catch(error => console.error(error));
}

// Avec async/await (plus propre)
async function fetchUserData(userId) {
  try {
    const user = await fetchUser(userId);
    const posts = await fetchPosts(user.id);
    return { user, posts };
  } catch (error) {
    console.error(error);
  }
}

Points clés :

• La fonction async renvoie toujours une Promise
• await met en pause l'exécution jusqu'à ce que la Promise soit résolue
• Utilisez try/catch pour la gestion des erreurs
• Rend les opérations séquentielles plus claires

Rareté : Courant Difficulté : Moyen

6. Expliquez la déstructuration pour les objets et les tableaux

Réponse : La déstructuration extrait les valeurs des tableaux ou les propriétés des objets dans des variables distinctes.

Déstructuration de tableaux :

const [first, second, ...rest] = [1, 2, 3, 4, 5];
// first = 1, second = 2, rest = [3, 4, 5]

// Ignorer les éléments
const [primary, , tertiary] = ['red', 'green', 'blue'];
// primary = 'red', tertiary = 'blue'

Déstructuration d'objets :

const user = { name: 'Alice', age: 25, email: '[email protected]' };

const { name, age, city = 'NYC' } = user;
// name = 'Alice', age = 25, city = 'NYC' (valeur par défaut)

// Renommer les variables
const { name: userName, age: userAge } = user;

// Déstructuration imbriquée
const { address: { street, zip } } = person;

Paramètres de fonction :

function createUser({ name, email, role = 'user' }) {
  // Utiliser les paramètres déstructurés
}

Rareté : Courant Difficulté : Facile-Moyen

7. Que sont l'opérateur de spread et les paramètres rest ?

Réponse :

Opérateur de spread (...) - Développe les itérables :

// Tableaux
const arr1 = [1, 2, 3];
const arr2 = [...arr1, 4, 5]; // [1, 2, 3, 4, 5]

// Objets (copie superficielle)
const user = { name: 'Alice', age: 25 };
const updatedUser = { ...user, age: 26 }; // Mise à jour immuable

// Arguments de fonction
const numbers = [1, 2, 3];
Math.max(...numbers); // 3

Paramètres rest (...) - Collecte plusieurs éléments :

// Paramètres de fonction
function sum(...numbers) {
  return numbers.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4); // 10

// Déstructuration de tableaux
const [first, ...remaining] = [1, 2, 3, 4];
// first = 1, remaining = [2, 3, 4]

Différence clé : Spread développe, rest collecte.

Rareté : Courant Difficulté : Facile-Moyen

8. Expliquez les méthodes de tableau courantes : map, filter, reduce, forEach

Réponse :

map - Transforme chaque élément, renvoie un nouveau tableau :

const doubled = [1, 2, 3].map(x => x * 2); // [2, 4, 6]

filter - Conserve les éléments correspondant à la condition :

const evens = [1, 2, 3, 4].filter(x => x % 2 === 0); // [2, 4]

reduce - Réduit à une seule valeur :

const sum = [1, 2, 3].reduce((acc, val) => acc + val, 0); // 6
const grouped = users.reduce((acc, user) => {
  acc[user.role] = acc[user.role] || [];
  acc[user.role].push(user);
  return acc;
}, {});

forEach - Itère sans renvoyer de nouveau tableau :

[1, 2, 3].forEach(item => console.log(item));

Rareté : Courant Difficulté : Facile

Fondamentaux de Node.js (7 Questions)

9. Qu'est-ce que Node.js et en quoi diffère-t-il des langages côté serveur traditionnels ?

Réponse : Node.js est un environnement d'exécution JavaScript construit sur le moteur JavaScript V8 de Chrome qui permet à JavaScript de s'exécuter côté serveur.

Différences clés :

• Boucle d'événement à thread unique : Utilise un modèle d'E/S non bloquant par rapport à un modèle d'E/S bloquant à plusieurs threads
• Asynchrone par défaut : Les opérations ne bloquent pas le thread principal
• JavaScript partout : Même langage pour le frontend et le backend
• Écosystème NPM : Le plus grand registre de packages au monde
• Exécution rapide : Le moteur V8 compile le JavaScript en code machine natif

Quand utiliser Node.js :

• Applications en temps réel (chat, jeux)
• Serveurs API
• Microservices
• Applications de streaming de données
• Applications à forte intensité d'E/S

Quand NE PAS utiliser :

• Tâches à forte intensité de calcul (traitement d'images, encodage vidéo)
• Applications nécessitant des calculs complexes

Rareté : Courant Difficulté : Facile-Moyen

10. Expliquez la boucle d'événement dans Node.js

Réponse : La boucle d'événement est le mécanisme qui permet à Node.js d'effectuer des opérations d'E/S non bloquantes bien qu'il soit à thread unique.

Comment ça marche :

1. Pile d'appels : Exécute le code synchrone (LIFO)
2. API Node : Gère les opérations asynchrones (fs, http, timers)
3. File d'attente de callbacks (Macrotâches) : Contient les callbacks des API Node
4. File d'attente de microtâches : Contient les callbacks de Promise (priorité plus élevée)
5. Boucle d'événement : Déplace les tâches des files d'attente vers la pile d'appels lorsque la pile est vide

Ordre d'exécution :

console.log('1');

setTimeout(() => console.log('2'), 0);

Promise.resolve().then(() => console.log('3'));

console.log('4');

// Sortie : 1, 4, 3, 2
// Explication :
// - Le code synchrone (1, 4) s'exécute en premier
// - Les microtâches (Promise) s'exécutent avant les macrotâches
// - Les macrotâches (setTimeout) s'exécutent en dernier

Phases de la boucle d'événement :

1. Minuteurs (setTimeout, setInterval)
2. Callbacks en attente
3. Inactif, préparer
4. Sondage (récupérer de nouveaux événements d'E/S)
5. Vérifier (callbacks setImmediate)
6. Callbacks de fermeture

Rareté : Courant Difficulté : Difficile

11. Quelle est la différence entre le code bloquant et non bloquant ?

Réponse :

Code bloquant - Arrête l'exécution jusqu'à ce que l'opération soit terminée :

// Lecture de fichier synchrone (bloque)
const fs = require('fs');
const data = fs.readFileSync('file.txt', 'utf8');
console.log(data); // Attend la lecture du fichier
console.log('Done'); // S'exécute après la lecture du fichier

Code non bloquant - Continue l'exécution, gère le résultat via un callback :

// Lecture de fichier asynchrone (non bloquante)
const fs = require('fs');
fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});
console.log('Done'); // S'exécute immédiatement, avant que la lecture du fichier ne soit terminée

Pourquoi le non-blocage est important :

• Le serveur peut gérer plusieurs requêtes simultanément
• Meilleure utilisation des ressources
• Amélioration des performances pour les opérations d'E/S
• Évolutivité

Rareté : Courant Difficulté : Facile-Moyen

12. Que sont les modules Node.js et comment fonctionne le système de modules ?

Réponse : Node.js utilise le système de modules CommonJS (bien que les modules ES soient également pris en charge).

CommonJS (require/module.exports) :

// math.js
function add(a, b) {
  return a + b;
}

module.exports = { add };
// ou
exports.add = add;

// app.js
const { add } = require('./math');
const result = add(2, 3);

Modules ES (import/export) :

// math.js
export function add(a, b) {
  return a + b;
}

// app.js
import { add } from './math.js';

Types de modules :

• Modules principaux : Intégrés (fs, http, path)
• Modules locaux : Vos propres fichiers
• Modules tiers : Installés via npm

Mise en cache des modules : Les modules sont mis en cache après la première require, de sorte que les requires suivantes renvoient la même instance.

Rareté : Courant Difficulté : Facile

13. Expliquez la différence entre process.nextTick() et setImmediate()

Réponse :

process.nextTick() - Exécute le callback dans la phase actuelle, avant toute autre opération asynchrone :

console.log('1');

process.nextTick(() => {
  console.log('2');
});

Promise.resolve().then(() => {
  console.log('3');
});

console.log('4');

// Sortie : 1, 4, 2, 3
// nextTick a la priorité la plus élevée, même au-dessus des Promises

setImmediate() - Exécute le callback lors de la prochaine itération de la boucle d'événement :

console.log('1');

setImmediate(() => {
  console.log('2');
});

setTimeout(() => {
  console.log('3');
}, 0);

console.log('4');

// Sortie : 1, 4, 3, 2 (ou 1, 4, 2, 3 selon le contexte)

Ordre de priorité :

1. Code synchrone
2. Callbacks process.nextTick()
3. Callbacks Promise (microtâches)
4. setTimeout(0) / setImmediate() (macrotâches)

Cas d'utilisation :

• nextTick : S'assurer que le callback s'exécute avant les autres opérations asynchrones
• setImmediate : Différer l'exécution à la prochaine itération de la boucle d'événement

Rareté : Peu courant Difficulté : Moyen-Difficile

14. Qu'est-ce que l'objet Global dans Node.js ?

Réponse : L'objet global dans Node.js est similaire à l'objet window dans les navigateurs, mais il est appelé global.

Propriétés globales :

// Disponible partout sans require
console.log(__dirname); // Chemin du répertoire actuel
console.log(__filename); // Chemin du fichier actuel
console.log(process); // Objet process
console.log(global); // Objet global lui-même

Globaux courants :

• process - Informations et contrôle du processus
• Buffer - Gérer les données binaires
• setTimeout, setInterval, clearTimeout, clearInterval
• setImmediate, clearImmediate
• console - Sortie de la console

Remarque : Dans les modules ES, __dirname et __filename ne sont pas disponibles par défaut. Utilisez import.meta.url à la place.

Rareté : Courant Difficulté : Facile

15. Comment gérez-vous les erreurs dans les applications Node.js ?

Réponse : La gestion des erreurs dans Node.js peut être gérée par plusieurs approches :

1. Try-catch pour le code synchrone :

try {
  const data = fs.readFileSync('file.txt', 'utf8');
} catch (error) {
  console.error('Erreur lors de la lecture du fichier :', error.message);
}

2. Modèle d'erreur de callback :

fs.readFile('file.txt', 'utf8', (err, data) => {
  if (err) {
    return console.error('Erreur :', err);
  }
  console.log(data);
});

3. Gestion des erreurs de Promise :

fetchData()
  .then(data => processData(data))
  .catch(error => console.error('Erreur :', error));

4. Async/await avec try-catch :

async function handleRequest() {
  try {
    const data = await fetchData();
    return data;
  } catch (error) {
    console.error('Erreur :', error);
    throw error; // Relancer si nécessaire
  }
}

5. Gestionnaires d'erreurs globaux :

// Exceptions non capturées
process.on('uncaughtException', (error) => {
  console.error('Exception non capturée :', error);
  process.exit(1);
});

// Rejets de promise non gérés
process.on('unhandledRejection', (reason, promise) => {
  console.error('Rejet non géré :', reason);
});

6. Middleware d'erreur Express :

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Quelque chose s'est mal passé !' });
});

Rareté : Courant Difficulté : Moyen

Express.js et Frameworks Web (6 Questions)

16. Qu'est-ce qu'Express.js et quelles sont ses principales caractéristiques ?

Réponse : Express.js est un framework d'application web Node.js minimal et flexible qui fournit un ensemble robuste de fonctionnalités pour la construction d'applications web et mobiles.

Principales caractéristiques :

• Routage : Définir les points de terminaison et les méthodes HTTP
• Middleware : Fonctions qui s'exécutent pendant le cycle requête-réponse
• Moteurs de template : Rendre du HTML dynamique (EJS, Pug, Handlebars)
• Gestion des erreurs : Middleware de gestion des erreurs centralisé
• Fichiers statiques : Servir des ressources statiques
• Analyse JSON : Analyse du corps intégrée pour les données JSON et URL-encoded

Exemple de base :

const express = require('express');
const app = express();

app.use(express.json());

app.get('/', (req, res) => {
  res.json({ message: 'Hello World' });
});

app.listen(3000, () => {
  console.log('Serveur en cours d'exécution sur le port 3000');
});

Pourquoi Express :

• Minimal et non directif
• Grand écosystème
• Facile à apprendre
• Système de middleware flexible

Rareté : Courant Difficulté : Facile

17. Qu'est-ce qu'un middleware dans Express.js ? Fournissez des exemples.

Réponse : Les fonctions de middleware sont des fonctions qui ont accès à l'objet requête (req), à l'objet réponse (res) et à la fonction next dans le cycle requête-réponse de l'application.

Types de middleware :

1. Middleware au niveau de l'application :

app.use((req, res, next) => {
  console.log('Requête reçue :', req.method, req.path);
  next(); // Transmettre le contrôle au middleware suivant
});

2. Middleware au niveau de la route :

app.get('/users', authenticateUser, (req, res) => {
  res.json({ users: [] });
});

3. Middleware de gestion des erreurs :

app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: err.message });
});

4. Middleware intégré :

app.use(express.json()); // Analyser les corps JSON
app.use(express.urlencoded({ extended: true })); // Analyser les données URL-encoded
app.use(express.static('public')); // Servir des fichiers statiques

5. Middleware tiers :

const cors = require('cors');
const helmet = require('helmet');

app.use(cors());
app.use(helmet());

Exemple de middleware d'authentification personnalisé :

function authenticateUser(req, res, next) {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Aucun token fourni' });
  }
  // Vérifier le token
  req.user = decodedToken;
  next();
}

Rareté : Courant Difficulté : Moyen

18. Expliquez le routage Express et comment organiser les routes

Réponse : Le routage fait référence à la manière dont les points de terminaison (URI) d'une application répondent aux requêtes du client.

Routage de base :

app.get('/users', (req, res) => {
  res.json({ users: [] });
});

app.post('/users', (req, res) => {
  const newUser = req.body;
  res.status(201).json(newUser);
});

app.get('/users/:id', (req, res) => {
  const userId = req.params.id;
  res.json({ user: { id: userId } });
});

app.put('/users/:id', (req, res) => {
  // Mettre à jour l'utilisateur
});

app.delete('/users/:id', (req, res) => {
  // Supprimer l'utilisateur
});

Paramètres de route :

app.get('/users/:userId/posts/:postId', (req, res) => {
  const { userId, postId } = req.params;
  // Accéder aux paramètres de la route
});

Paramètres de requête :

app.get('/search', (req, res) => {
  const { q, page, limit } = req.query;
  // ?q=nodejs&page=1&limit=10
});

Organiser les routes avec Express Router :

// routes/users.js
const express = require('express');
const router = express.Router();

router.get('/', (req, res) => {
  res.json({ users: [] });
});

router.get('/:id', (req, res) => {
  res.json({ user: { id: req.params.id } });
});

module.exports = router;

// app.js
const userRoutes = require('./routes/users');
app.use('/api/users', userRoutes);

Rareté : Courant Difficulté : Facile-Moyen

19. Comment gérez-vous les téléchargements de fichiers dans Express ?

Réponse : Les téléchargements de fichiers peuvent être gérés à l'aide de middleware comme multer.

Téléchargement de fichier de base :

const multer = require('multer');
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  // req.file contient des informations sur le fichier
  res.json({ 
    filename: req.file.filename,
    originalname: req.file.originalname,
    size: req.file.size
  });
});

Plusieurs fichiers :

app.post('/upload-multiple', upload.array('files', 10), (req, res) => {
  // req.files est un tableau de fichiers
  res.json({ uploaded: req.files.length });
});

Configuration de stockage personnalisée :

const storage = multer.diskStorage({
  destination: (req, file, cb) => {
    cb(null, 'uploads/');
  },
  filename: (req, file, cb) => {
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix);
  }
});

const upload = multer({ 
  storage: storage,
  limits: { fileSize: 5 * 1024 * 1024 }, // Limite de 5MB
  fileFilter: (req, file, cb) => {
    if (file.mimetype === 'image/jpeg' || file.mimetype === 'image/png') {
      cb(null, true);
    } else {
      cb(new Error('Seuls JPEG et PNG sont autorisés'));
    }
  }
});

Rareté : Courant Difficulté : Moyen

20. Qu'est-ce que CORS et comment le gérez-vous dans Express ?

Réponse : CORS (Cross-Origin Resource Sharing) est une fonctionnalité de sécurité qui autorise ou restreint les pages web à effectuer des requêtes vers un domaine différent de celui qui sert la page web.

Problème : Les navigateurs bloquent par défaut les requêtes de http://localhost:3000 vers http://localhost:4000 (origines différentes).

Solution avec le middleware cors :

const cors = require('cors');

// Autoriser toutes les origines (développement uniquement)
app.use(cors());

// Configurer des origines spécifiques
app.use(cors({
  origin: 'https://example.com',
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization']
}));

// Plusieurs origines
app.use(cors({
  origin: ['https://example.com', 'https://app.example.com']
}));

En-têtes CORS manuelles :

app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', 'https://example.com');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
  
  if (req.method === 'OPTIONS') {
    return res.sendStatus(200);
  }
  next();
});

Rareté : Courant Difficulté : Facile-Moyen

21. Comment structurez-vous une grande application Express.js ?

Réponse : Organisez le code en modules et dossiers logiques pour la maintenabilité.

Structure recommandée :

project/
├── src/
│   ├── controllers/
│   │   └── userController.js
│   ├── models/
│   │   └── User.js
│   ├── routes/
│   │   └── userRoutes.js
│   ├── middleware/
│   │   └── auth.js
│   ├── services/
│   │   └── userService.js
│   ├── utils/
│   │   └── helpers.js
│   ├── config/
│   │   └── database.js
│   └── app.js
├── tests/
├── .env
└── package.json

Exemple de séparation des préoccupations :

Contrôleur (gère HTTP) :

// controllers/userController.js
const userService = require('../services/userService');

exports.getUsers = async (req, res, next) => {
  try {
    const users = await userService.getAllUsers();
    res.json(users);
  } catch (error) {
    next(error);
  }
};

Service (logique métier) :

// services/userService.js
const User = require('../models/User');

exports.getAllUsers = async () => {
  return await User.find();
};

Routes :

// routes/userRoutes.js
const express = require('express');
const router = express.Router();
const userController = require('../controllers/userController');

router.get('/', userController.getUsers);
router.post('/', userController.createUser);

module.exports = router;

Configuration de l'application :

// app.js
const express = require('express');
const userRoutes = require('./routes/userRoutes');

const app = express();
app.use(express.json());
app.use('/api/users', userRoutes);

Rareté : Courant Difficulté : Moyen

Concepts de base de données (5 Questions)

22. Quelle est la différence entre les bases de données SQL et NoSQL ?

Réponse :

Bases de données SQL (relationnelles) :

• Données structurées avec des tables, des lignes, des colonnes
• Le schéma doit être défini avant l'utilisation
• Conformité ACID (Atomicité, Cohérence, Isolation, Durabilité)
• Exemples : PostgreSQL, MySQL, SQLite
• Idéal pour : Requêtes complexes, transactions, données structurées

Bases de données NoSQL :

• Schéma flexible ou sans schéma
• Divers modèles de données (document, clé-valeur, graphe, colonne)
• Échelle horizontale
• Exemples : MongoDB, Redis, Cassandra
• Idéal pour : Applications à grande échelle, schémas flexibles, développement rapide

Comparaison :

Quand utiliser SQL :

• Requêtes et relations complexes
• Conformité ACID requise
• Données structurées
• Transactions financières

Quand utiliser NoSQL :

• Développement rapide
• Données à grande échelle
• Besoins de schéma flexibles
• Requêtes simples

Rareté : Courant Difficulté : Facile-Moyen

23