Enum en PHP 8.1 - à quoi sert enum et comment est-il implémenté en PHP

Quelques jours plus tard, le vote sur la première itération de l'implémentation enum en PHP 8.1 se termine . Il est déjà clair qu'il y a beaucoup plus de votes «pour», alors passons en revue brièvement et voyons ce que les auteurs de la langue ont préparé pour nous.

Pourquoi avons-nous besoin d'énumération?

Pourquoi avons-nous besoin d'énumération? Essentiellement, ils servent à des déclarations de type améliorées. Regardons un exemple sans et avec des énumérations. Disons que nous vendons des voitures en trois couleurs: rouge, noir et blanc. Comment décrire la couleur, quel type choisir?

class Car {
    private string $color;

    function setColor(string $color): void {
        $this->color = $color;
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Si nous décrivons la couleur de la voiture comme une simple chaîne, alors, tout d'abord, lors de l'appel de $ myCar-> setColor (..), le type de chaîne à écrire n'est pas clair. «Rouge» ou «ROUGE» ou «# ff0000», et deuxièmement, il est facile de se tromper en glissant accidentellement quelque chose de mal (une chaîne vide, par exemple). La même chose se produira si vous utilisez des nombres au lieu de chaînes, par exemple.

Cela conduit au fait que de nombreux programmeurs php créent des constantes et les combinent dans une classe pour voir clairement toutes les options.

class Color {
    public const RED   = "red";
    public const BLACK = "black";
    public const WHITE = "white";
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

et définir la couleur, écrire $myCar->setColor(Color::RED);

. $myCar->setColor(...), , - . - .

, . enum

Pure enum

(pure enum), enum :

enum Color {
    case Red;
    case Black;
    case White;
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, :

class Car {
    private Color $color;

    function setColor(Color $color): void {
        $this->color = $color;
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, . setColor : $myCar->setColor(Color::White), . . .

case- (Color::Red, Color::Black, Color::White) Color ( instanseof ). .. 0,1,2 , . >, . $name:

print Color::Red->name; //   “Red”
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Enum

, . enum , string. . , .

enum Color: string {
    case Red = "R";
    case Black = "B";
    case White = "W";
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

:

Color::Red->value  //  “R”
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

, .. case , :

Color::from("R") //   Color::Red
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

"case" enum . . , .

RFC.

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

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

enum Suit implements Colorful {
  use Rectangle;

  case Hearts;
  case Diamonds;
  case Clubs;
  case Spades;

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

$this case, .

, match. , match .

enum PHP, , , - , enum (, Go).

— . Tagged Unions (-)

Il existe des RFC qui poussent l'idée des énumérations plus loin afin que vous puissiez stocker des valeurs de différents types dans une énumération. Comme Rust, par exemple. Ensuite, il sera possible de faire, disons, enum Result avec deux cas Result :: Ok et Result :: Err, et ces objets vont stocker des données: Ok stockera le résultat, et Err stockera une erreur, chacune de ces valeurs Aura son propre type.

Et tout cela n'est pas en Rust ou Haskell, mais en PHP!

Nous vous en parlerons en détail dans les prochains articles de la chaîne de télégramme Cross Join , n'oubliez pas de vous abonner.