0Pricing
PHP Academy · บทเรียน

รูปแบบพฤติกรรม: Strategy, Observer, Command

จำลองพฤติกรรมและการสื่อสารด้วยรูปแบบพฤติกรรม

รูปแบบพฤติกรรม: Strategy, Observer, Command เป็นบทเรียน PHP Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน PHP Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส PHP Academy มีบทเรียนทั้งหมด 4 บทเรียน

การสร้างแบบจำลองพฤติกรรม

รูปแบบพฤติกรรมกำกับวิธีที่อ็อบเจกต์ทำงานร่วมกันและกระจายความรับผิดชอบ เราจะมุ่งเน้นสามรูปแบบที่พบอยู่เสมอในระบบ PHP จริง:

  • กลยุทธ์ — สลับอัลกอริทึมขณะทำงาน
  • Observer — กระจายเหตุการณ์ไปยังตัวรับฟังที่สนใจ
  • Command — เปลี่ยนคำขอให้เป็นอ็อบเจกต์ที่คุณเข้าคิว บันทึก หรือเลิกทำได้

กลยุทธ์: แนวคิด

รูปแบบกลยุทธ์กำหนดกลุ่มอัลกอริทึมที่สับเปลี่ยนกันได้ไว้เบื้องหลังอินเทอร์เฟซเดียว และเปิดให้ผู้เรียกเลือกขณะทำงาน รูปแบบนี้แทนที่ switch ที่ขยายตัวไม่สิ้นสุดด้านล่างด้วยภาวะพหุรูปแบบ โดยบริบทจะส่งต่องานให้กลยุทธ์ที่ถือครองอยู่

<?php
// The smell Strategy removes: branching on a type code
function price(string $type, float $base): float {
    switch ($type) {
        case 'standard': return $base + 5;
        case 'express':  return $base + 15;
        default: throw new InvalidArgumentException($type);
    }
}
echo price('express', 10), PHP_EOL; // 25

กลยุทธ์ในโค้ด

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

<?php
interface ShippingStrategy { public function cost(float $weight): float; }
final class Standard implements ShippingStrategy {
    public function cost(float $w): float { return 5 + $w * 0.5; }
}
final class Express implements ShippingStrategy {
    public function cost(float $w): float { return 15 + $w * 1.2; }
}

final class Cart {
    public function __construct(private ShippingStrategy $strategy) {}
    public function setStrategy(ShippingStrategy $s): void { $this->strategy = $s; }
    public function quote(float $weight): float { return $this->strategy->cost($weight); }
}

$cart = new Cart(new Standard());
echo $cart->quote(10), PHP_EOL;     // 10
$cart->setStrategy(new Express());
echo $cart->quote(10), PHP_EOL;     // 27

กลยุทธ์กับคลอเชอร์

ใน PHP กลยุทธ์ไม่จำเป็นต้องเป็นคลาสเสมอไป สำหรับกรณีที่ไม่ซับซ้อน callable หรือรูปแบบไวยากรณ์ callable ชั้นหนึ่งก็เป็นกลยุทธ์ที่ถูกต้องอย่างสมบูรณ์ ใช้คลาสเต็มรูปแบบเมื่ออัลกอริทึมมีสถานะหรือการพึ่งพาของตัวเอง และใช้คลอเชอร์สำหรับตัวเลือกที่เรียบง่ายและไม่มีสถานะ

<?php
$strategies = [
    'asc'  => fn(array $a) => sort($a) ? $a : $a,
    'desc' => fn(array $a) => rsort($a) ? $a : $a,
];
$data = [3, 1, 2];
print_r($strategies['desc']($data)); // [3,2,1]

Observer: แนวคิด

รูปแบบObserverช่วยให้อ็อบเจกต์ต้นทางแจ้งตัวผู้สังเกตการณ์หลายตัวเมื่อสถานะของมันเปลี่ยนแปลง โดยไม่จำเป็นต้องรู้ว่าผู้สังเกตการณ์เหล่านั้นคือใคร วิธีนี้แยกแหล่งที่มาของเหตุการณ์ออกจากตัวจัดการ และเป็นรากฐานของระบบเหตุการณ์ ฮุก และการอัปเดตแบบรีแอกทีฟ

Observer ในโค้ด

อ็อบเจกต์ต้นทางเก็บรายการผู้สังเกตการณ์ไว้และเรียกใช้ update() กับแต่ละตัว ตัวรับฟังรายใหม่สามารถเชื่อมต่อได้โดยไม่ต้องเปลี่ยนตรรกะของอ็อบเจกต์ต้นทาง

<?php
interface Observer { public function update(string $event): void; }

final class OrderSubject {
    private array $observers = [];
    public function subscribe(Observer $o): void { $this->observers[] = $o; }
    public function placed(string $id): void {
        foreach ($this->observers as $o) { $o->update("order $id placed"); }
    }
}
final class EmailObserver implements Observer {
    public function update(string $e): void { echo "email: $e" . PHP_EOL; }
}
final class AuditObserver implements Observer {
    public function update(string $e): void { echo "audit: $e" . PHP_EOL; }
}

$subject = new OrderSubject();
$subject->subscribe(new EmailObserver());
$subject->subscribe(new AuditObserver());
$subject->placed('42');

Observer กับ PSR-14

PHP สมัยใหม่มักแสดงแนวคิด Observer ผ่านตัวกระจายเหตุการณ์ PSR-14 โดยตัวกระจายจะส่งอ็อบเจกต์เหตุการณ์ไปยังตัวรับฟังที่ลงทะเบียนไว้ แบบจำลองทางความคิดยังเหมือนเดิม (อ็อบเจกต์ต้นทาง = เหตุการณ์ ผู้สังเกตการณ์ = ตัวรับฟัง) แต่ตัวกระจายจะแยกทั้งสองส่วนออกจากกันมากขึ้นและรองรับเหตุการณ์ที่หยุดได้ SplObserver/SplSubject มีอยู่ใน SPL แต่ปัจจุบันไม่ค่อยได้ใช้งานแล้ว

Command: แนวคิด

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

<?php
final class SendEmail {
    public function __construct(
        public readonly string $to,
        public readonly string $subject
    ) {}
}
// The request is now data you can store, serialize, or enqueue
$cmd = new SendEmail('user@example.com', 'Welcome');
echo json_encode($cmd), PHP_EOL;

Command ในโค้ด

คำสั่งแต่ละคำสั่งใช้งาน execute() ผู้เรียกใช้คำสั่งจะถือครองและเรียกใช้คำสั่งเหล่านั้น โดยไม่ผูกติดกับสิ่งที่คำสั่งทำ การเพิ่ม undo() จะเปลี่ยนสิ่งนี้ให้เป็นสแตกเลิกทำเต็มรูปแบบ

<?php
interface Command { public function execute(): string; }

final class Light { public bool $on = false; }
final class TurnOn implements Command {
    public function __construct(private Light $light) {}
    public function execute(): string { $this->light->on = true; return 'light on'; }
}
final class TurnOff implements Command {
    public function __construct(private Light $light) {}
    public function execute(): string { $this->light->on = false; return 'light off'; }
}

final class Invoker {
    private array $queue = [];
    public function add(Command $c): void { $this->queue[] = $c; }
    public function run(): void {
        foreach ($this->queue as $c) { echo $c->execute(), PHP_EOL; }
    }
}

$light = new Light();
$inv = new Invoker();
$inv->add(new TurnOn($light));
$inv->add(new TurnOff($light));
$inv->run();

บัสคำสั่ง

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

การเลือกใช้ระหว่างรูปแบบเหล่านี้

  • กลยุทธ์: การดำเนินการหนึ่งอย่างที่มีอัลกอริทึมสับเปลี่ยนกันได้หลายแบบ โดยผู้เรียกเป็นผู้เลือก
  • Observer: เหตุการณ์หนึ่งเหตุการณ์ที่มีการตอบสนองอิสระหลายแบบ โดยต้นทางไม่รู้จักตัวจัดการ
  • Command: เปลี่ยนคำขอให้เป็นอ็อบเจกต์ เพื่อให้เข้าคิว บันทึก ทำซ้ำ หรือเลิกทำได้

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

ตรวจสอบอย่างรวดเร็ว

จับคู่ข้อกำหนดกับรูปแบบที่เหมาะสม

สรุป

คุณสร้างแบบจำลองพฤติกรรมด้วยสามรูปแบบ ได้แก่ กลยุทธ์เพื่อสลับอัลกอริทึมขณะทำงาน (คลาสหรือคลอเชอร์) Observerเพื่อกระจายการเปลี่ยนแปลงสถานะไปยังตัวรับฟังที่แยกจากกัน (เป็นพื้นฐานของตัวกระจาย PSR-14) และCommandเพื่อเปลี่ยนคำขอให้เป็นอ็อบเจกต์ที่คุณเข้าคิว บันทึก และเลิกทำได้ (เป็นพื้นฐานของบัสคำสั่ง) เมื่อใช้ร่วมกัน รูปแบบเหล่านี้ช่วยให้การทำงานร่วมกันมีความยืดหยุ่นและความรับผิดชอบชัดเจน

คำถามที่พบบ่อย

บทเรียน “รูปแบบพฤติกรรม: Strategy, Observer, Command” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “รูปแบบพฤติกรรม: Strategy, Observer, Command” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส PHP Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส PHP Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “รูปแบบพฤติกรรม: Strategy, Observer, Command”

จำลองพฤติกรรมและการสื่อสารด้วยรูปแบบพฤติกรรม คุณปฏิบัติ PHP Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน PHP Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน PHP Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “รูปแบบพฤติกรรม: Strategy, Observer, Command” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน PHP Academy นี้ได้ไหม

ได้ บทเรียน PHP Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

  1. หลักการ SOLID ในการใช้งานจริง
  2. รูปแบบการสร้าง: Factory, Builder, Singleton
  3. รูปแบบโครงสร้าง: Adapter, Decorator, Facade
  4. รูปแบบพฤติกรรม: Strategy, Observer, Command
← กลับไปที่ PHP Academy