รูปแบบพฤติกรรม: 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- หลักการ SOLID ในการใช้งานจริง
- รูปแบบการสร้าง: Factory, Builder, Singleton
- รูปแบบโครงสร้าง: Adapter, Decorator, Facade
- รูปแบบพฤติกรรม: Strategy, Observer, Command