Enum no PHP 8.1 - para que serve o enum e como ele é implementado no PHP

Poucos dias depois, a votação na primeira iteração da implementação enum no PHP 8.1 termina . Já está claro que há muito mais votos “a favor”, então vamos passar rapidamente e ver o que os autores da língua prepararam para nós.

Por que precisamos enum?

Por que precisamos enum afinal? Em essência, eles servem ao propósito de declarações de tipo aprimoradas. Vejamos um exemplo sem e com enums. Digamos que vendamos carros em três cores: vermelho, preto e branco. Como descrever a cor, que tipo escolher?

class Car {
    private string $color;

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

Se descrevermos a cor do carro como uma string simples, então, em primeiro lugar, ao chamar $ myCar-> setColor (..), não é claro que tipo de string escrever ali. “Vermelho” ou “VERMELHO” ou “# ff0000” e, em segundo lugar, é fácil cometer um erro ao deslizar acidentalmente algo errado (uma string vazia, por exemplo). O mesmo acontecerá se você usar números em vez de strings, por exemplo.

Isso leva ao fato de que muitos programadores php criam constantes e as combinam em uma classe para ver claramente todas as opções.

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

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

e definindo a cor, escreva $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 (-)

Existem RFCs que levam a ideia de enums mais longe para que você possa armazenar valores de diferentes tipos em um enum. Como Rust, por exemplo. Então será possível fazer, digamos, o resultado enum com dois casos Result :: Ok e Result :: Err, e esses objetos irão armazenar os dados: Ok irá armazenar o resultado, e Err irá armazenar um erro, cada um desses valores Terá seu próprio tipo.

E tudo isso não está em Rust ou Haskell, mas em PHP!

Falaremos mais sobre isso nas próximas postagens do canal de telegramas Cross Join , não se esqueça de se inscrever.