Qu'est-ce que le pattern Adapter ?

Question

Accepted Answer

Le pattern **Adapter** permet aux objets ayant des **interfaces incompatibles** de fonctionner ensemble en enveloppant l'un d'eux avec l'interface que l'autre attend. Il agit comme un traducteur entre deux interfaces, permettant l'intégration sans modifier le code existant.

## Ce que fait le pattern Adapter

```text
ADAPTER → convert one interface into another that a client expects (a "translator"):
  → wrap an object whose interface is INCOMPATIBLE, exposing the interface the client needs
  → the adapter translates calls/data between the two interfaces
→ makes incompatible things work together WITHOUT changing either's code
```

## Exemple

```js
// a third-party library with an incompatible interface
class ThirdPartyLogger { logMessage(text) { /* ... */ } }

// our code expects a .log(msg) interface → adapt it
class LoggerAdapter {
  constructor(thirdParty) { this.logger = thirdParty; }
  log(msg) { this.logger.logMessage(msg); }   // translate our interface to theirs
}
const logger = new LoggerAdapter(new ThirdPartyLogger());
logger.log('hello');   // our code uses .log; the adapter calls .logMessage
```

## Usages et avantages

```text
USES → integrate THIRD-PARTY libraries with incompatible interfaces; make legacy code work
  with new code; unify different APIs behind a common interface; swap implementations
BENEFITS:
  ✓ INTEGRATION → make incompatible interfaces work together without modifying either
  ✓ DECOUPLING → your code depends on YOUR interface; adapters isolate external/incompatible
    code → swap or upgrade dependencies behind the adapter
  ✓ Reuse existing code that doesn't quite fit
```

## Pourquoi c'est important

Comprendre le pattern Adapter est précieux car c'est un **pattern structurel très courant et pratique** pour intégrer du code incompatible, ce qui en fait une connaissance de design pertinente.

Le pattern Adapter permet aux objets ayant des **interfaces incompatibles de fonctionner ensemble** en enveloppant l'un d'eux avec l'interface que l'autre attend — agissant comme un traducteur entre les interfaces.

Comprendre ce qu'il fait (envelopper un objet avec une interface incompatible pour exposer l'interface qu'un client a besoin, traduire entre les deux) est la connaissance centrale.

Comprendre les **usages** est particulièrement précieux car ils correspondent à des besoins réels et courants : **intégrer des bibliothèques tierces** avec des interfaces incompatibles (une situation fréquente — vous avez besoin d'utiliser une bibliothèque mais son interface ne correspond pas à votre code), faire **fonctionner le code hérité avec le nouveau code**, unifier différentes API derrière une interface commune, et permettre l'échange d'implémentations.

Ces besoins d'intégration surgissent constamment dans le développement réel.

Comprendre les **avantages** — **l'intégration** (faire fonctionner ensemble des interfaces incompatibles sans modifier l'une ou l'autre, ce qui est souvent nécessaire quand vous ne pouvez pas modifier du code tiers ou hérité), et **le découplage** (votre code dépendant de votre propre interface tandis que les adaptateurs isolent le code externe/incompatible, vous permettant d'échanger ou de mettre à jour les dépendances derrière l'adaptateur — un avantage architectural précieux) — clarifie pourquoi Adapter est pratiquement important.

Le pattern Adapter est l'un des patterns les plus pratiquement utiles car intégrer du code incompatible (bibliothèques tierces, systèmes hérités, différentes API) est un besoin constant et réel dans le développement.

Puisque le pattern Adapter est un pattern très courant et pratique pour intégrer des interfaces incompatibles (bibliothèques tierces, code hérité, différentes API) sans modifier l'une ou l'autre — un besoin réel constant — et fournit un découplage précieux, et puisque comprendre ce qu'il fait, ses usages et ses avantages est pertinent pour les travaux d'intégration réels, comprendre le pattern Adapter est une connaissance de design précieuse et pratiquement pertinente — un pattern fréquemment nécessaire pour la tâche courante d'intégrer du code incompatible, fournissant l'intégration et le découplage, et une connaissance de design importante pour le défi récurrent et réel de faire fonctionner ensemble différents éléments de code.