Design Pattern ใน Python

ดีไซน์แพตเทิร์น Decorator ใน Python

ในบทเรียนนี้ คุณจะใช้แพตเทิร์น Decorator เพิ่มความสามารถให้ออบเจกต์โดยไม่แก้คลาสของมัน

  • ระดับสูง
  • อ่าน 2 นาที
  • ตัวอย่างที่รันได้ 1 ตัวอย่าง

บทนำ

ปัญหาที่ต้องแก้

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

ลองนึกภาพแบบนี้

แพตเทิร์น Decorator เหมือนการห่อของขวัญ ตัวของขวัญยังเหมือนเดิม แต่การห่อแต่ละชั้นเพิ่มอะไรบางอย่าง เช่น กระดาษห่อ ตามด้วยริบบิ้น แล้วก็การ์ด จะห่อชั้นไหนก่อนหลังก็ได้ สุดท้ายก็ยังเป็นของขวัญที่ยื่นให้กันแบบเดิม

จากการห่อของขวัญสู่โค้ด
Message()🎁 ของขวัญต้นฉบับ
Uppercase(...)🧻 ชั้นที่เปลี่ยนหน้าตา
Logger(...)🎀 อีกชั้นหนึ่งด้านบน
.render()🤲 ยื่นให้แบบเดิม: LOG: HELLO
ตัวห่อแต่ละชั้นมีเมธอดเดียวกันและเพิ่มพฤติกรรมของตัวเอง
สรุปในประโยคเดียว

แพตเทิร์น Decorator ห่ออ็อบเจกต์ไว้ในอีกอ็อบเจกต์หนึ่งที่มี interface เดียวกัน ตัวห่อจะเรียกอ็อบเจกต์ข้างใน แล้วเพิ่มพฤติกรรมของตัวเองไว้ก่อนหรือหลังการเรียกนั้น

ประเด็นสำคัญ

  1. Message.render() ส่งกลับ "hello"
  2. Uppercase เก็บอ็อบเจกต์ที่ถูกห่อไว้ และส่งกลับผลลัพธ์ของอ็อบเจกต์นั้นเป็นตัวพิมพ์ใหญ่
  3. Logger เพิ่ม "LOG: " ไว้หน้าผลลัพธ์ของอ็อบเจกต์ที่ถูกห่อ
  4. Logger(Uppercase(Message())).render() ซ้อนตัวห่อทั้งสอง ได้ "LOG: HELLO"

ใช้เมื่อไร?

  • เพิ่มการบันทึก log แคช การตรวจสอบ หรือการจัดรูปแบบรอบอ็อบเจกต์ที่มีอยู่
  • ผสมส่วนเสริมที่เลือกได้โดยไม่ต้องมี subclass สำหรับแต่ละการผสม
  • เข้าใจไวยากรณ์ @decorator ของ Python ซึ่งใช้แนวคิดเดียวกันกับฟังก์ชัน

เมื่อไรยังไม่จำเป็น

  • ต้องการพฤติกรรมเสริมตายตัวแค่อย่างเดียว: เปลี่ยนคลาสหรือเพิ่มเมธอด
  • มีหลายชั้นที่ต้องเรียงลำดับให้ถูก: ตัวห่อที่ซ้อนกันจะเข้าใจยาก

โค้ดตัวอย่าง

รันโค้ด →
main.py
class Message:
    # Decorator: wrap an object to add behavior dynamically.
    def render(self): return "hello"


class Uppercase:
    def __init__(self, wrapped): self.wrapped = wrapped
    def render(self): return self.wrapped.render().upper()


class Logger:
    def __init__(self, wrapped): self.wrapped = wrapped

    def render(self):
        # Add behavior while preserving the render interface.
        return "LOG: " + self.wrapped.render()


print(Logger(Uppercase(Message())).render())
สร้างปุ่ม Run สำหรับตัวอย่างนี้

ผลลัพธ์จากการรัน

LOG: HELLO

อธิบายโค้ด

Uppercase ห่อออบเจกต์ Message และเปลี่ยนผลเป็นตัวพิมพ์ใหญ่ แล้ว Logger ห่อ Uppercase และเติมคำนำหน้า LOG: ทั้งสามคลาสมีเมธอด render() จึงห่อกันได้ในลำดับใดก็ได้ ผลลัพธ์สุดท้ายคือ LOG: HELLO

เปลี่ยนค่าและรันโปรแกรมด้วย คอมไพเลอร์ Python ออนไลน์ของ CodeUtility โดยไม่ต้องติดตั้ง Python

แบบฝึกหัดเพิ่มเติม

ลองแก้โค้ดตามคำแนะนำด้านล่าง การเปลี่ยนโค้ดแล้วดูผลลัพธ์จะช่วยให้เข้าใจบทเรียนได้ดีกว่าการอ่านอย่างเดียวมาก

  1. เปลี่ยนโดเมนของตัวอย่างโดยยังคงโครงสร้างของแพตเทิร์นไว้
  2. เปรียบเทียบแพตเทิร์นกับการเขียนแบบที่ง่ายกว่าและอธิบายข้อแลกเปลี่ยน
  3. เขียนการทดสอบให้ผู้มีส่วนร่วมแต่ละส่วนก่อนเพิ่มการเขียนแบบอื่น
รันในคอมไพเลอร์ Python →

ข้อผิดพลาดที่พบบ่อย

ทำลาย interface ร่วม

ถ้าตัวห่อใช้ชื่อเมธอดต่างไป ก็จะเอาไปห่อต่อหรือใช้แทนต้นฉบับไม่ได้

ปัญหา
class Uppercase:
    def show(self): ...
วิธีแก้
class Uppercase:
    def render(self): ...

เรียนบทนี้จบแล้วใช่ไหม

ทำเครื่องหมายว่าเรียนแล้วเพื่อติดตามความคืบหน้า

ถัดไป: ดีไซน์แพตเทิร์น Facade ใน Python →

ฝึกด้วยโจทย์

ใช้สิ่งที่เรียนในบทนี้แก้ปัญหาจริง ทุกโจทย์รันในเบราว์เซอร์ พร้อมการทดสอบทันทีและรีวิวจาก AI

โจทย์ทั้งหมด