Adapter pattern คืออะไร?

Question

Accepted Answer

**Adapter** pattern ช่วยให้อ็อบเจ็กต์ที่มี **interface เข้ากันไม่ได้** ทำงานร่วมกันได้ด้วยการห่อหุ้มตัวหนึ่งด้วย interface ที่อีกตัวคาดหวัง มันทำหน้าที่เป็นตัวแปลภาษาระหว่างสอง interface ช่วยให้รวม integrate ได้โดยไม่ต้องแก้ไขโค้ดที่มีอยู่

## Adapter pattern ทำอะไร

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

## ตัวอย่าง

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

## การใช้งานและประโยชน์

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

## ทำไมจึงสำคัญ

การเข้าใจ Adapter pattern มีคุณค่า เพราะมันเป็น **structural pattern ที่พบบ่อยและใช้งานได้จริงมาก** สำหรับการรวม integrate โค้ดที่เข้ากันไม่ได้ จึงเป็นความรู้การออกแบบที่เกี่ยวข้อง

Adapter pattern ช่วยให้อ็อบเจ็กต์ที่มี **interface เข้ากันไม่ได้ทำงานร่วมกันได้** ด้วยการห่อหุ้มตัวหนึ่งด้วย interface ที่อีกตัวคาดหวัง โดยทำหน้าที่เป็นตัวแปลภาษาระหว่าง interface

การเข้าใจว่ามันทำอะไร (การห่อหุ้มอ็อบเจ็กต์ที่มี interface เข้ากันไม่ได้เพื่อเปิดเผย interface ที่ client ต้องการ โดยแปลระหว่างทั้งสอง) เป็นความรู้แกนหลัก

การเข้าใจ**การใช้งาน**มีคุณค่าเป็นพิเศษเพราะเป็นความต้องการจริงที่พบบ่อย ได้แก่ **การรวม integrate library ของบุคคลที่สาม**ที่มี interface เข้ากันไม่ได้ (สถานการณ์ที่พบบ่อย คือคุณต้องใช้ library แต่ interface ของมันไม่ตรงกับโค้ดของคุณ), การทำให้**โค้ดเก่าทำงานกับโค้ดใหม่ได้**, การรวม API ต่าง ๆ ให้เป็นหนึ่งหลัง interface ร่วมกัน และการสลับ implementation

ความต้องการในการ integrate เหล่านี้เกิดขึ้นตลอดเวลาในการพัฒนาจริง

การเข้าใจ**ประโยชน์** ได้แก่ **การ integrate** (ทำให้ interface ที่เข้ากันไม่ได้ทำงานร่วมกันได้โดยไม่ต้องแก้ไขทั้งสองฝ่าย ซึ่งมักจำเป็นเมื่อคุณไม่สามารถเปลี่ยนโค้ดของบุคคลที่สามหรือโค้ดเก่าได้) และ**การลด coupling** (โค้ดของคุณพึ่งพา interface ของคุณเองขณะที่ adapter แยกโค้ดภายนอกหรือที่เข้ากันไม่ได้ออกไป ดังนั้นคุณสามารถสลับหรืออัปเกรด dependency หลัง adapter ได้ ซึ่งเป็นประโยชน์เชิงสถาปัตยกรรมที่มีคุณค่า) ทำให้ชัดเจนว่าทำไม Adapter จึงสำคัญในเชิงปฏิบัติ

Adapter pattern เป็นหนึ่งใน pattern ที่ใช้งานได้จริงมากที่สุดเพราะการรวม integrate โค้ดที่เข้ากันไม่ได้ (library ของบุคคลที่สาม ระบบเก่า API ที่ต่างกัน) เป็นความต้องการจริงที่เกิดขึ้นตลอดเวลาในการพัฒนา

เนื่องจาก Adapter pattern เป็น pattern ที่พบบ่อยและใช้งานได้จริงมากสำหรับการรวม integrate interface ที่เข้ากันไม่ได้ (library ของบุคคลที่สาม โค้ดเก่า API ที่ต่างกัน) โดยไม่ต้องแก้ไขทั้งสองฝ่าย ซึ่งเป็นความต้องการจริงที่เกิดขึ้นตลอดเวลา และให้การลด coupling ที่มีคุณค่า และเนื่องจากการเข้าใจว่ามันทำอะไร การใช้งานของมัน และประโยชน์ของมันเกี่ยวข้องกับงาน integrate จริง การเข้าใจ Adapter pattern จึงเป็นความรู้การออกแบบที่มีคุณค่าและเกี่ยวข้องในเชิงปฏิบัติ เป็น pattern ที่ต้องการบ่อยสำหรับงานที่พบบ่อยคือการรวม integrate โค้ดที่เข้ากันไม่ได้ ให้การ integrate และการลด coupling และเป็นความรู้การออกแบบที่สำคัญสำหรับความท้าทายจริงที่เกิดซ้ำคือการทำให้โค้ดคนละชิ้นทำงานร่วมกันได้