ממשקים ב-PHP: implements, קבועים ודוגמאות

ממשק ב-PHP מצהיר על מתודות שמחלקה מבטיחה לספק, בלי שום קוד: interface Shape { public function area(): float; }. מחלקה שכותבת implements Shape חייבת להגדיר את area(), וכל פונקציה שמשתמשת ברמז הטיפוס Shape תקבל את המחלקה הזו.

<?php
interface Shape
{
    public function area(): float;
}

class Square implements Shape
{
    public function __construct(private float $side) {}

    public function area(): float
    {
        return $this->side ** 2;
    }
}

class Circle implements Shape
{
    public function __construct(private float $r) {}

    public function area(): float
    {
        return round(M_PI * $this->r ** 2, 2);
    }
}

function describe(Shape $s): string
{
    return get_class($s) . ' with area ' . $s->area();
}

echo describe(new Square(3)), "\n";
echo describe(new Circle(2)), "\n";
var_dump(new Circle(1) instanceof Shape);

describe() לא יודעת ולא אכפת לה איזו מחלקה היא מקבלת. היא מסתמכת רק על ההבטחה שהממשק נותן, ולכן Triangle implements Shape חדשה עובדת איתה בלי לשנות שורה.

תכנות מול ממשק

הסיבה הרגילה לכתוב ממשק היא לאפשר לקוד להיות תלוי ביכולת ולא במחלקה מסוימת. כאן שירות הזמנות מקבל כל Notifier, כך שאותו קוד יכול לשלוח אימייל בפרודקשן ולאסוף הודעות בבדיקה:

<?php
interface Notifier
{
    public function send(string $to, string $message): bool;
}

class EmailNotifier implements Notifier
{
    public function send(string $to, string $message): bool
    {
        echo "Email to $to: $message\n";
        return true;
    }
}

class FakeNotifier implements Notifier
{
    public array $sent = [];

    public function send(string $to, string $message): bool
    {
        $this->sent[] = [$to, $message];
        return true;
    }
}

class OrderService
{
    public function __construct(private Notifier $notifier) {}

    public function place(string $customer, int $orderId): void
    {
        $this->notifier->send($customer, "Order #$orderId confirmed");
    }
}

(new OrderService(new EmailNotifier()))->place('ada@example.com', 1001);

$fake = new FakeNotifier();
(new OrderService($fake))->place('linus@example.com', 1002);
print_r($fake->sent);

מימוש של כמה ממשקים

מחלקה מרחיבה לכל היותר אב אחד, אבל היא יכולה לממש כמה ממשקים שהיא צריכה. רשמו אותם אחרי implements, מופרדים בפסיקים, והגדירו את המתודות של כולם:

<?php
interface HasName
{
    public function name(): string;
}

interface Exportable
{
    public function toArray(): array;
}

class Product implements HasName, Exportable, JsonSerializable
{
    public function __construct(private string $title, private int $priceCents) {}

    public function name(): string
    {
        return $this->title;
    }

    public function toArray(): array
    {
        return ['title' => $this->title, 'price' => $this->priceCents / 100];
    }

    public function jsonSerialize(): array
    {
        return $this->toArray();
    }
}

$p = new Product('Desk lamp', 3490);
echo $p->name(), "\n";
print_r($p->toArray());
echo json_encode($p), "\n";
print_r(class_implements($p));

JsonSerializable הוא אחד הממשקים המובנים של PHP: מימוש שלו קובע מה json_encode() מפיקה עבור האובייקט.

קבועי ממשק

ממשק יכול להצהיר על קבועים. כל מחלקה שמממשת אותו יורשת אותם, ואפשר לקרוא אותם דרך שם הממשק או שם המחלקה:

<?php
interface HttpStatus
{
    const OK = 200;
    const NOT_FOUND = 404;
}

class Response implements HttpStatus
{
    public function __construct(public int $status = self::OK) {}

    public function isError(): bool
    {
        return $this->status >= 400;
    }
}

echo HttpStatus::NOT_FOUND, "\n";
echo Response::OK, "\n";

$r = new Response(Response::NOT_FOUND);
var_dump($r->isError());

לממשקים לא יכולים להיות מאפיינים ב-PHP 8.3, רק מתודות וקבועים. המתודות יכולות להיות סטטיות: public static function fromArray(array $data): static; בממשק מחייבת כל מחלקה להגדיר את המתודה הסטטית הזו. לקבוצה קבועה של ערכים קשורים, enum מתאים לעיתים קרובות יותר מרשימה של קבועי ממשק.

ממשק יכול להרחיב ממשקים אחרים

גם ממשקים משתמשים ב-extends, ובניגוד למחלקות הם יכולים להרחיב כמה בבת אחת. מחלקה שמממשת את ממשק הבת חייבת להגדיר את המתודות של כל השרשרת:

<?php
interface Readable
{
    public function read(): string;
}

interface Writable
{
    public function write(string $data): void;
}

interface Stream extends Readable, Writable
{
    public function close(): void;
}

class MemoryStream implements Stream
{
    private string $buffer = '';

    public function read(): string { return $this->buffer; }
    public function write(string $data): void { $this->buffer .= $data; }
    public function close(): void { $this->buffer = ''; }
}

$s = new MemoryStream();
$s->write('Hello, ');
$s->write('stream');
echo $s->read(), "\n";
var_dump($s instanceof Readable, $s instanceof Writable);

ממשקים מובנים: Countable, IteratorAggregate, Stringable

PHP מגיעה עם ממשקים שמחברים אובייקטים לשפה. Countable גורם ל-count($obj) לעבוד, IteratorAggregate גורם ל-foreach לעבוד, ו-Stringable ממומש אוטומטית על ידי כל מחלקה עם מתודת __toString():

<?php
class Playlist implements Countable, IteratorAggregate
{
    private array $songs = [];

    public function add(string $song): static
    {
        $this->songs[] = $song;
        return $this;
    }

    public function count(): int
    {
        return count($this->songs);
    }

    public function getIterator(): Iterator
    {
        return new ArrayIterator($this->songs);
    }

    public function __toString(): string
    {
        return implode(' / ', $this->songs);
    }
}

$list = (new Playlist())->add('Intro')->add('Blue')->add('Outro');

echo count($list), " songs\n";
foreach ($list as $i => $song) {
    echo "$i: $song\n";
}
var_dump($list instanceof Stringable);
echo "$list\n";

שכחה של מתודה

אם מחלקה מצהירה שהיא מממשת ממשק אבל מחסירה מתודה, PHP נעצרת עם שגיאה קטלנית שמציינת את המתודה החסרה:

<?php
// This fails on purpose: Invoice does not define total()
interface Billable
{
    public function total(): float;
    public function currency(): string;
}

class Invoice implements Billable
{
    public function currency(): string
    {
        return 'EUR';
    }
}

echo (new Invoice())->currency();

הוסיפו מתודת total() והסקריפט ירוץ. מחלקה מופשטת רשאית להשאיר מתודות של ממשק לא מוגדרות, וזה פתח המילוט שהודעת השגיאה מציעה.

ממשק מול מחלקה מופשטת

שניהם מגדירים מתודות שמחלקה חייבת שיהיו לה, ובשניהם אפשר להשתמש כרמז טיפוס. ההבדל הוא מה עוד הם יכולים להכיל וכמה מהם מחלקה יכולה להשתמש:

הם משתלבים היטב: הגדירו את הממשק בשביל רמז הטיפוס, והציעו מחלקת בסיס מופשטת שמממשת אותו עם הקוד המשותף. מחלקות שצריכות בסיס אחר עדיין יכולות לממש את הממשק ישירות.