Uppräkningsmetoder

Enumerationsmetoder

Enums (både Pure Enums och Backed Enums) kan innehålla metoder och kan implementera gränssnitt. Om en Enum implementerar ett gränssnitt, kommer alla type checks för det gränssnittet också att acceptera alla cases av den Enum.

<?php

interface Colorful
{
    public function color(): string;
}

enum Suit implements Colorful
{
    case Hearts;
    case Diamonds;
    case Clubs;
    case Spades;

    // Uppfyller gränssnittets kontrakt.
    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }

    // Ej en del av gränssnittet; det är okej.
    public function shape(): string
    {
        return "Rectangle";
    }
}

function paint(Colorful $c)
{
   /* ... */
}

paint(Suit::Clubs);  // Fungerar

print Suit::Diamonds->shape(); // skriver ut "Rectangle"
?>

I detta exempel har alla fyra instanser av Suit två metoder, `color()` och `shape()`. När det gäller anropskod och type checks, beter de sig precis som vilken annan objektinstans som helst.

På en Backed Enum, går gränssnittsförklaringen efter deklarationen av backing-typen.

<?php

interface Colorful
{
    public function color(): string;
}

enum Suit: string implements Colorful
{
    case Hearts = 'H';
    case Diamonds = 'D';
    case Clubs = 'C';
    case Spades = 'S';

    // Uppfyller gränssnittets kontrakt.
    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }
}
?>

Inuti en metod är variabeln `$this` definierad och refererar till instansen av case.

Metoder kan vara godtyckligt komplexa, men i praktiken kommer de vanligtvis att returnera ett statiskt värde eller matcha på `$this` för att ge olika resultat för olika cases.

Observera att det i detta fall skulle vara en bättre datamodelleringspraxis att också definiera en `SuitColor` Enum Type med värdena `Red` och `Black` och returnera det istället. Men det skulle komplicera detta exempel.

Hierarkin ovan är logiskt likvärdig med följande klassstruktur (även om detta inte är den faktiska koden som körs):

<?php

interface Colorful
{
    public function color(): string;
}

final class Suit implements UnitEnum, Colorful
{
    public const Hearts = new self('Hearts');
    public const Diamonds = new self('Diamonds');
    public const Clubs = new self('Clubs');
    public const Spades = new self('Spades');

    private function __construct(public readonly string $name) {}

    public function color(): string
    {
        return match($this) {
            Suit::Hearts, Suit::Diamonds => 'Red',
            Suit::Clubs, Suit::Spades => 'Black',
        };
    }

    public function shape(): string
    {
        return "Rectangle";
    }

    public static function cases(): array
    {
        // Otillåten metod, eftersom manuell definition av en `cases()`-metod på en Enum är förbjuden.
        // Se också avsnittet "Value listing".
    }
}
?>

Metoder kan vara public, private eller protected, även om private och protected i praktiken är likvärdiga eftersom arv inte är tillåtet.

Sidslut

Orginalhemsidan på Engelska : https://www.php.net/manual/en/language.enumerations.methods.php
PHP
Språkreferens
Språkreferens#Uppräkningar

---

Det här är en maskinöversättning av PHP-manualen till svenska. Om du hittar fel är vi tacksamma om du rapporterar dem via formuläret som finns på https://www.linux.se/kontaka-linux-se/