Slutsky 3 сен 2020 в 20:29

Перечисления в PHP

8 мин

11K

PHP*Программирование*

Из песочницы

+25

Комментарии 51

matasar 3 сен 2020 в 22:26

Тема не раскрыта полностью, к примеру, никакой информации по поводу готовых решений в этом направлении, допустим github.com/myclabs/php-enum

В пером примере страшно неопримизированный код, от условия в 4 строки текут кровавые слезы. Дальше, честно, читал по диагонали. Можно было сделать проще: массивом или методом, который возвращает все доступные варианты. Можно было так же реализовать некий интерфейс или абстрактный класс, который бы описал основные возможности такого «Enum» класса.

Slutsky 3 сен 2020 в 23:03

Эта реализация так-же опирается на механизм рефлексии. В методе toArray() происходит поиск и сохранение всех констант класса. Впоследствии эти значения используются как варианты перечисления.

Оптимизация всегда имеет цель. Примеры оптимизированы не с целью уменьшения количества строк кода, а с целью увеличения очевидности.

matasar 4 сен 2020 в 00:48

Очевидность? Если вы имеете в виду совсем неопытных ребят, то ваш пример плох еще и тем, что учит писать некрасиво. Если же брать более опытных людей, то они, как правило, вычитывают куда более сложный код на ревью.

Прям не хотелось это писать, но вырвалось, извините.

Schrodingers_Kater 4 сен 2020 в 11:11

Вся эта реализация просто бессмысленна. А главное преследует цель эстетизации, а не оптимизации. И чем вам помешали массивы? Учитывая, что набор функций для их обработки уже собран. Напоминает типичную ооп'о'фагию…

pbatanov 7 сен 2020 в 00:51

Мы когда то дошли до вот такого решения. github.com/paillechat/php-enum/blob/master/src/Enum.php

Работают строгие сравнения (===, in_array($value, [MyEnum::NAME1(), MyEnum::NAME2()], true) и пр.)

Косяка из комента ниже нет habr.com/ru/post/517752/#comment_22031208
Food::BEER() === Waste::BEER() не пройдет (это разные инстансы)

Обращения к рефлексии кэшируются в памяти класса и повторно используется мемори кэш вместо рефлексии при обращении к инстансам.

В целом можно было бы сделать и без рефлексии (похожий пример ниже в коментах), но первая версия этой либы работала на текстовых константах (new MyEnum(MyEnum::NAME1) ) и было решено оставить работу со списком значений через константы, а не через массив допустимых значений

Iv38 3 сен 2020 в 23:50

Ну, кстати, об всём этом написано в статье.
И с какой точки зрения неоптимизирован код первого примера? Он с точки зрения читабельности не очень, но зачастую перечисления никогда не меняются, вероятно, там никогда не станет сто элементов вместо четырёх. Зато он очень лёгкий. Перечисления это сахарок, хотелось бы, чтобы они (раз уж не реализованы на уровне языка), не тратили зря ресурсы. Впрочем, первый пример вообще неудобен в применении и мало что даёт. Дальше лучше.

VolCh 4 сен 2020 в 00:24

Массив из констант можно было сделать. Или даже ассоциативный self::SUMMER => true и проверять в конструкторе как if (self::VALUES[*value]?? false)

matasar 4 сен 2020 в 00:45

С точки зрения читабельности, даже, заменить 8 строк 2мя имеет смысл еще какой. Эллементарно, все константы оборачиваются в массив и дальше через in_array и implode. Такой варинт будет работать так же быстро как и тот, что представлен в примере.

Iv38 4 сен 2020 в 01:23

Да я бы тоже скорее всего написал именно так. Тем более, что преждевременные оптимизации вредны. Просто в данном случае это не слишком важно. И речь в примере не об этом, а об одной из простейших реализаций перечислений.

VolCh 4 сен 2020 в 08:24

Это не оптимизация же в привычном понимании, а улучшение читаемости

Iv38 4 сен 2020 в 13:34

Я имел ввиду под оптимизацией то что написано в статье и то что я пытался оправдать.

VolCh 4 сен 2020 в 01:20

А вообще тема, кажется, вечная. Как PHP4 вышел, так началось.

granvi 4 сен 2020 в 01:36

Зачем это?
Ради чего? Этот жуткий колхоз. Использовать объект со всеми вытеуающими для эмуляции человеко ориентированного описания числовых констант.
Я полагаю, что если суммировать занимаемую памть всеми перечислениями в каком нибудь огромном проекте, то она будет меньше занимаемой памяти одним этим классом.
Как дети. Ей богу.

VolCh 4 сен 2020 в 08:26

Контроль типов в значениях. Чтобы по сигнатуры метода какого-то другого объекта сразу было видно, что он не просто строку или число применяет, а узко ограниченный набор значений.

granvi 4 сен 2020 в 16:16

В php? Контроль типов? Если нужен ЯП умеюший в нормалтный ООП надо выбирать подходящий инструмент, а не городить огород.
Используйте массивы или константы

pbatanov 7 сен 2020 в 00:44

Весь проект переписать на другой ЯП в тот момент когда понадобились перечисления — такая себе затея. Давайте будем честны, иногда работаем с чем есть, проекты не только создают, но и развивают существующие.

batyrmastyr 9 сен 2020 в 20:34

Php 7 вышел почти 5 лет назад и в нём с контролем типов ситуация значительно улучшилась, осталась только проблема с контролем содержимого массивов.
Чем вам ООП не угодило не понимаю — если вы про обобщения, так они к ООП отношения не имеют, а перекрёстное наследование «как в Си++» только мазохистам нужно, в остальном же ООП в пыхе стандартное.

elCreator 4 сен 2020 в 02:34

class Season extends Enum {
    public const WINTER = 'winter';
    public const SPRING = 'spring';
    public const SUMMER = 'summer';
    public const AUTUMN = 'autumn';
}


$now = Season::AUTUMN(); // Autocomplete works as Season::AUTUMN exists
var_export($now->is(Season::AUTUMN)); // true
var_export("$now" === Season::AUTUMN); // true
var_export($now == Season::AUTUMN); // true
var_export($now == Season::SPRING); // false
echo "$now"; // autumn


class Enum {
    protected string $_value;

    protected function __construct(string $value) {
        $this->_value = $value;
    }

    public function is($key)
    {
        return $this->_value === $key;
    }

    public static function __callStatic($name, $params) {
        $value = constant("static::$name");
        if (!$value) {
            throw new \InvalidArgumentException(static::class . " can't be $name");
        }
        return new static($value);
    }

    public function __toString() {
        return $this->_value;
    }
}

Можно еще таким примером продолжить ряд. IDE это нравится (начав писать Season видим список возможных значений), стринговые ключи можно придумать те, которые нужны (например, чтобы согласовать Snake case и Camel case в стиле кода и там, где используется строковая составляющая), плюс макросы IDE позволяют писать одновременно имя и значение константы. Плюс этим можно пользоваться без создания объекта там, где он не нужен и достаточно лишь строковой константы.

a-tk 4 сен 2020 в 08:39

class Food {
  public const BEER = 'beer';
}
class Waste {
  public const BEER = 'beer';
}
 
// ...

$this->assertTrue(Waste::BEER === Food::BEER);

Т — типизация

В решении выше Вы получаете enum-ы в стиле си, когда они есть просто псевдонимы для констант примитивного типа, и отбрасываете типизацию.

savostin 4 сен 2020 в 09:24

Это скорее приведение типов :)
Вроде бы в том же C[++] они тоже будут равны, т.к. по сути int, нет?

a-tk 7 сен 2020 в 08:25

В С++ enum class не равны, если для них не определён пользовательский operator==
Простой enum — это такой же кривой дизайн, как и строки выше.

Rajken 4 сен 2020 в 16:52

class Food {
  public const BEER = 'Food::BEER';
}
class Waste {
  public const BEER = 'Waste::BEER';
}

poniyur 4 сен 2020 в 03:18

Помню, баловался с перечислениями в php, если кратко, то получилось что-то типо такого:

<?php

    function createEnum(...$vals) {
        $enum = [];
        $i = 0;
        foreach( $vals as $v ) {
            $enum[$v] = ++$i;
        }
        
        return (object) $enum;
    }
    $eAction = createEnum('jump', 'run', 'kick', 'die');
    
    /*
        много кода,в котором выясняется, что будет прыжок
    */
    
    $action = $eAction->jump;
    
    switch($action) {
        case $eAction->jump: // 1
            echo "You jump!\n";
            break;
        
        case $eAction->run: // 2
            echo "You run!\n";
            break;
        
        case $eAction->kick: // 3
            echo "You kicked enemy!\n";
            break;
        
        case $eAction->die: //4
            echo "Game over!\n";
            break;
    }

poniyur 4 сен 2020 в 04:27

Что-то туплю с утра, было без каста массива в объект

<?php
    function createEnum(...$vals) {
        $enum = new stdClass();
        $i = 1;
        foreach( $vals as $v ) {
            $enum->$v = $i++;
        }        
        return $enum;
    }

Для себя этим кодом и пользовался, можно развить/улучшить, но лично мне и лично для меня — хватало.

a-tk 4 сен 2020 в 08:47

Автокомплитик бы ещё к этому делу.

poniyur 4 сен 2020 в 10:18

Это да, но автокомплит std объектов можно устроить в ide'шках. Но я так не заморачивался никогда)

pbatanov 7 сен 2020 в 01:03

понимаю, что пример наколеночный, но вижу два недостатка:
* Нет контроля типов (т.е если унести свитч в отедльный метод\набор методов, то там будет таки (string $action) в сигнатуре.
* Енам либо придется делать глобальным, либо инстанциировать в каждом месте, где его надо обработать, т.е. опять же если унести этот свитч в отдельный метод, то для проверки значений придется инстанциировать енам заново, что будет плодить этот набор значений по кодовой базе

poniyur 7 сен 2020 в 02:48

Да, я понимал это, но мне нравилась такая простая и (как мне кажется) элегантные реализация/использование, что с этими двумя недостатками я уживался.
С контролем типов вообще проблем не было, а enum'ы хранил в глобальном объекте приложения

pbatanov 7 сен 2020 в 10:19

Если не нужен контроль типов, то кажется лучше просто набор констант тогда?

poniyur 7 сен 2020 в 14:19

define("ACTION_JUMP ", 1);
define("ACTION_RUN", 2);
define("ACTION_WALK", 3);

Типо такого?
Думаю, что если бы я не хотел сделать подобие перечислений, которых увидел в Gamemaker Studio 2, то да — заюзал бы константы, а в качестве группировки была бы часть до первого символа подчеркивания.

pbatanov 7 сен 2020 в 14:33

Если нужна группировка, то можно раскошелиться и на класс

final class Action {
  public const JUMP = 1;
  public const RUN = 2;
  public const WALK = 3;
}

a-tk 7 сен 2020 в 14:41

(Злая шутка)
А если у него на хостинге только PHP4?

poniyur 8 сен 2020 в 02:41

Эх, как же не хочется использовать класс, но это реально в пхп самый лучший способ имитировать перечисления. В проде такое и юзал бы

a-tk 8 сен 2020 в 08:56

Не обязательно. Можно заюзать пространства имён.
Когда в С++ не было enum class, я извращался примерно так:

namespace EnumName
{
  enum Value {A, B, C};
}

void foo(EnumName::Value value);

foo(EnumName::A);

Можно так:

struct EnumName
{
  enum Value {A, B, C};
  EnumName(Value value) : value(value){}
  operator Value() const { return value; }
private:
  Value value;
}

void foo(EnumName value);

foo(EnumName::A);

VolCh 8 сен 2020 в 09:09

Увы, в PHP нельзя указать тайпхинт "все константы нэймспэйса A\B\C"

pbatanov 8 сен 2020 в 11:03

Чести ради и «все константы класса» тоже нельзя, только через рефлексию. Поправьте, если ошибаюсь. Но эту ветку мы обсуждаем исходя из того что контроль типов не нужен человеку, только группировка значений

habr.com/ru/post/517752/#comment_22041126

VolCh 8 сен 2020 в 12:18

Не ошибаетесь. Просто у вас в примерах вроде как объявления foo с типизацией…

А группировку констант с нэймспэйсами можно на PHP, типа

namespace A\B {
    const TYPE1 = 'TYPE1';
    const TYPE2 = 'TYPE2';
    const TYPE3 = 'TYPE3';
}

namespace C {
    use A\B;

    echo B\TYPE1;
}

Но, думаю, многим очень непонятно будет и IDE и статанализаторы не столько помогать будут работать с этим, сколько мешать.

a-tk 8 сен 2020 в 13:40

Да, действительно, не подумал об этом.

Volodar 4 сен 2020 в 10:52

Посоветуйте что делать с этим enum на PHP, когда необходимо его использовать как ключ в массиве?

Size из статьи и его применение

<?php

class Size
{
    public const SIZES = ['xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl'];

    private string $value;

    private function __construct(string $value)
    {
        $this->value = $value;
    }

    public function __toString(): string
    {
        return $this->value;
    }

    public static function __callStatic($name, $arguments)
    {
        $value = strtolower($name);
        if (!in_array($value, self::SIZES)) {
            throw new BadMethodCallException("Method '$name' not found.");
        }

        if (count($arguments) > 0) {
            throw new InvalidArgumentException("Method '$name' expected no arguments.");
        }

        return new self($value);
    }
};

$ar = array(Size::xxs()=>1);
var_dump($ar);
?>

Понятно, что можно взять enum из первого примера, когда это строковые константы. но есть необходимость в подобном классе

Vitaly48 4 сен 2020 в 13:04

Так

/**
 * Class Size
 * @method static Size xxs()
 * @method static Size xs()
 * @method static Size s()
 * @method static Size m()
 * @method static Size l()
 * @method static Size xl()
 */
class Size
{
    public const SIZES = ['xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl'];

    private $value;

    private function __construct(string $value)
    {
        $this->value = $value;
    }

    public function getValue(): string
    {
        return $this->value;
    }

    public function __toString(): string
    {
        return $this->value;
    }

    public static function __callStatic($name, $arguments)
    {
        $value = strtolower($name);
        if (!in_array($value, self::SIZES)) {
            throw new BadMethodCallException("Method '$name' not found.");
        }

        if (count($arguments) > 0) {
            throw new InvalidArgumentException("Method '$name' expected no arguments.");
        }

        return new self($value);
    }
};

$ar = [Size::xxs()->getValue() => 1];

Или так

/**
 * Class Size
 * @method static Size xxs()
 * @method static Size xs()
 * @method static Size s()
 * @method static Size m()
 * @method static Size l()
 * @method static Size xl()
 */
class Size
{
    public const SIZES = ['xxs', 'xs', 's', 'm', 'l', 'xl', 'xxl'];

    private $value;

    private function __construct(string $value)
    {
        $this->value = $value;
    }

    public function __toString(): string
    {
        return $this->value;
    }

    public static function __callStatic($name, $arguments)
    {
        $value = strtolower($name);
        if (!in_array($value, self::SIZES)) {
            throw new BadMethodCallException("Method '$name' not found.");
        }

        if (count($arguments) > 0) {
            throw new InvalidArgumentException("Method '$name' expected no arguments.");
        }

        return new self($value);
    }
};

$ar = [(string)Size::xxs() => 1];

Но по мне всё это выглядит костыльно. Почему нельзя просто сделать так?

$ar = ['xxs' => 1];

Slutsky 4 сен 2020 в 20:09

Ничего. Дробные числа тоже нельзя применять как ключи. В рамках PHP это не является какой-то из ряда вон выходящей вещью. Другой вопрос зачем вам это надо?

pbatanov 7 сен 2020 в 00:57

Массив пхп не позволяет держать в ключах ничего кроме строк и интов. Для того, чтобы использовать в качестве объектов нужен некий Map, например такой.

www.php.net/manual/ru/class.ds-map.php

rjhdby 4 сен 2020 в 11:05

Я бы наверное в какую-то такую сторону смотрел

class Seasons{
    private static array $mapping = [];

    private string $name;

    private function __construct(string $name){
        $this->name = $name;
        self::$mapping[$name] = $this;
    }

     public static function SUMMER(): Seasons
     {
         if(isset(self:$mapping['summer']){
               return self:$mapping['summer'];
         }

         return new self('summer');
     }
}

Slutsky 4 сен 2020 в 20:29

Позвольте мне немного улучшить ваш код:

class Seasons {
    private static array $mapping = [];

    private string $name;

    private function __construct(string $name) {
        $this->name = $name;
    }

     public static function SUMMER(): Seasons
     {
         if (!isset(self:$mapping['summer']) {
               self:$mapping['summer'] = new self('summer');
         }

         return self:$mapping['summer'];
     }
}

Как результат получается перечисление как одиночка. С той лишь разницей, что конкретные экземпляры хранятся не в отдельных статических полях, а в массиве $mapping.

pbatanov 7 сен 2020 в 01:15

Пойдем еще дальше и добавим контроль допустимых значений через массив, а не через наличие метода. После этого можно вынести все кроме static $values в базовый родительский класс и у нас получился неплохой переиспользуемый енам

/**
 * @method static static SUMMER()
 * @method static static AUTUMN()
 * @method static static WINTER()
 * @method static static SPRING()
 */
final class Seasons
{
    private static array $mapping = [];

    private static array $values = [
        'SUMMER',
        'AUTUMN',
        'WINTER',
        'SPRING',
    ];

    private string $name;

    private function __construct(string $name)
    {
        $this->name = $name;
    }

    public static function __callStatic(string $name, array $args): self
    {
        if (!in_array($name, self::$values, true)) {
            throw new \BadMethodCallException("Value $name is not allowed");
        }

        if (!isset(self::$mapping[$name])) {
            self::$mapping[$name] = new self($name);
        }

        return self::$mapping[$name];
    }
}

LarexSetch 4 сен 2020 в 12:49

К сожалению PHP не имеет нормального инструмента для реализации перечислений и приходилось выкручиваться, а использовать в таком виде

  public function someFunc(TheEnum $enum): void {}

куда безопасней, наглядней и понятней, чем в таком

  public function someFunc(string $enum): void {}

Мы пришли к тому что бы использовать одиночку (при строгом и не строгом сравнивании был один результат) при этом реализация одиночки была положена в абстрактный класс Enum, а вот наследники должны были реализовать определенный метод, в котором весь пул доступных значений.
К сожалению приходилось перечислять все статические методы, но без этого ни куда.

Правда мы не учитывали кейсы где мы используем serialize или unserialize т.к. мы используем JMS сериалайзер и сериализуем в JSON, с кастомными handler-ами.

zoryamba 4 сен 2020 в 14:32

Я просто оставлю это здесь
https://www.php.net/manual/ru/class.splenum.php

somurzakov 5 сен 2020 в 23:07

в таком виде, в каком приведены были примеры — перечисления нафиг не нужны в РНР. Сила РНР в динамичности всего и вся, а наворачивая перечисления, вы попросту хардкодите часть логики в коде.
Я бы наоборот, держал бы все инстансы перечисления в базе и подгружал бы.
Вместо хардкода Season::autum, просто буду работать с объектом класса Season, и пусть он сам решает что ему положено делать.

Перечисления имеют смысл только в компилируемых языках, имхо

topuserman 7 сен 2020 в 12:47

Не понимаю, почему до сих пор в pho нет типа перечисления, очень нужная вещь…
Про дженерики уже молчу..

Slutsky 7 сен 2020 в 12:47

Я извиняюсь, но я не совсем понял, что такое дженерик.

Iv38 7 сен 2020 в 16:36

Они же обобщённые типы. Типы параметризуемые другими типами. Если вы не знакомы с парадигмой обобщённого программирования, то лучше погуглить, в двух словах объяснить непросто. (Не советую читать Википедию об этом!)

Зарегистрируйтесь на Хабре, чтобы оставить комментарий

Перечисления в PHP

Комментарии 51

Публикации

Истории