¿Qué es el patrón Adapter?

Question

Accepted Answer

El patrón **Adapter** permite que objetos con **interfaces incompatibles** trabajen juntos al envolver uno con la interfaz que el otro espera. Actúa como un traductor entre dos interfaces, habilitando la integración sin modificar el código existente.

## Qué hace el patrón 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
```

## Ejemplo

```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
```

## Usos y beneficios

```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
```

## Por qué es importante

Entender el patrón Adapter es valioso porque es un **patrón estructural muy común y práctico** para integrar código incompatible, por lo que es conocimiento de diseño relevante.

El patrón Adapter permite que objetos con **interfaces incompatibles trabajen juntos** al envolver uno con la interfaz que el otro espera — actuando como un traductor entre interfaces.

Entender qué hace (envolver un objeto con una interfaz incompatible para exponer la interfaz que un cliente necesita, traduciendo entre las dos) es el conocimiento central.

Entender los **usos** es especialmente valioso porque son necesidades comunes y reales: **integrar bibliotecas de terceros** con interfaces incompatibles (una situación frecuente — necesitas usar una biblioteca pero su interfaz no coincide con tu código), hacer que **el código heredado funcione con código nuevo**, unificar diferentes APIs detrás de una interfaz común, e habilitar el intercambio de implementaciones.

Estas necesidades de integración surgen constantemente en el desarrollo real.

Entender los **beneficios** — **integración** (hacer que interfaces incompatibles trabajen juntas sin modificar ninguna de las dos, lo que a menudo es necesario cuando no puedes cambiar código de terceros o heredado), y **desacoplamiento** (tu código dependiendo de tu propia interfaz mientras que los adaptadores aíslan código externo/incompatible, por lo que puedes intercambiar o actualizar dependencias detrás del adaptador — un beneficio arquitectónico valioso) — aclara por qué Adapter es prácticamente importante.

El patrón Adapter es uno de los patrones más prácticamente útiles porque integrar código incompatible (bibliotecas de terceros, sistemas heredados, diferentes APIs) es una necesidad constante y real en el desarrollo.

Dado que el patrón Adapter es un patrón muy común y práctico para integrar interfaces incompatibles (bibliotecas de terceros, código heredado, diferentes APIs) sin modificar ninguna de las dos — una necesidad real constante — y proporciona desacoplamiento valioso, y dado que entender qué hace, sus usos y sus beneficios es relevante para el trabajo real de integración, entender el patrón Adapter es conocimiento de diseño valioso y prácticamente relevante — un patrón frecuentemente necesario para la tarea común de integrar código incompatible, proporcionando integración y desacoplamiento, y conocimiento de diseño importante para el desafío real y recurrente de hacer que diferentes piezas de código trabajen juntas.