What is the Adapter pattern?

Question

Accepted Answer

The **Adapter** pattern allows objects with **incompatible interfaces** to work together by wrapping one with an interface the other expects. It acts as a translator between two interfaces, enabling integration without modifying existing code.

## What the Adapter pattern does

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

## Example

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

## Uses and benefits

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

## Why it matters

Understanding the Adapter pattern is valuable because it's a **very common, practical structural pattern** for integrating incompatible code, so it's relevant design knowledge.

The Adapter pattern allows objects with **incompatible interfaces to work together** by wrapping one with the interface the other expects — acting as a translator between interfaces.

Understanding what it does (wrapping an object with an incompatible interface to expose the interface a client needs, translating between the two) is the core knowledge.

Understanding the **uses** is especially valuable because they're common, real needs: **integrating third-party libraries** with incompatible interfaces (a frequent situation — you need to use a library but its interface doesn't match your code), making **legacy code work with new code**, unifying different APIs behind a common interface, and enabling swapping implementations.

These integration needs arise constantly in real development.

Understanding the **benefits** — **integration** (making incompatible interfaces work together without modifying either, which is often necessary when you can't change third-party or legacy code), and **decoupling** (your code depending on your own interface while adapters isolate external/incompatible code, so you can swap or upgrade dependencies behind the adapter — a valuable architectural benefit) — clarifies why Adapter is practically important.

The Adapter pattern is one of the most practically useful patterns because integrating incompatible code (third-party libraries, legacy systems, different APIs) is a constant, real need in development.

Since the Adapter pattern is a very common, practical pattern for integrating incompatible interfaces (third-party libraries, legacy code, different APIs) without modifying either — a constant real need — and provides valuable decoupling, and since understanding what it does, its uses, and its benefits is relevant for real integration work, understanding the Adapter pattern is valuable, practically-relevant design knowledge — a frequently-needed pattern for the common task of integrating incompatible code, providing integration and decoupling, and important design knowledge for the real, recurring challenge of making different pieces of code work together.