This is a PHP Enum Solution using classes and type hinting. Also you can build a taxonomies of enums!
An enumeration type, "enum" for short, is a data type to categorise named values. Enums can be used instead of hard coded strings to represent, for example, the status of a blog post in a structured and typed way.
In July 2019, I wrote a gist searching a solution for this.
https://gist.github.com/rafageist/aef9825b7c935cdeb0c6187a2d363909/revisions
Then I convert the gist in a real project. https://www.phpclasses.org/package/11366-PHP-Implement-enumerated-values-using-classes.html
Before 8.1, PHP didn't have a native enum type, only a very basic SPL implementation (https://www.php.net/manual/en/class.splenum.php), but this really doesn't cut the mustard. Some solutions using constants, but not resolve the problem. How to validate HOT or COLD ?
From 8.1, PHP have a enums implementation (https://www.php.net/manual/en/language.types.enumerations.php).
And now you can combine this solution with the new features of PHP.
<?php
const HOT = 1;
const COLD = 2;
const FIRE = 1;
const ICE = 2;
function doSomething(int $temperature) { /* ... */}
doSomething(FIRE);There's a popular package called myclabs/php-enum. It's really awesome, but have a problem because we lose static analysis benefits like auto completion and refactoring.
Use PHP!
The class divengine\enum help you, but remember: the most important solution is the concept of this library.
With this class, you can solves the following problems:
- Constants with different names and equal value can be used as function arguments
- Lose static analysis benefits like auto completion and refactoring
- Maintaining duplicated code when use docblock type hints to solve the second problem
We need have built-in enums in PHP ! But, for now, this is a solution.
composer require divengine\enum;
Clone the repo:
git clone https://github.com/divengine/enum
Include the lib:
include "/path/to/divengine/enum/src/folder/enum.php";First, define your enums. You can build a taxonomy !!!:
Enums.php
<?php
namespace MyEnums;
use divengine\enum;
class Temperature extends enum {/* Father of all types of temperatures */}
class ExtremeTemperature extends Temperature {/* Father of all types of extreme temperatures */}
class FIRE extends ExtremeTemperature {}
class ICE extends ExtremeTemperature {}
class NormalTemperature extends Temperature {/* Father of all types of normal temperatures */}
class HOT extends NormalTemperature {}
class COOL extends NormalTemperature {}
class COLD extends NormalTemperature {}Second, use your enums:
<?php
use MyEnums;
// Constants are good tricks, but optional
const COOL = COOL::class;
class AllTemperatures {
const COOL = COOL::class; // maybe better
const HOT = 'Enums\\HOT'; // ugly !!!
//...
}
// Define some function with type hinting
function WhatShouldIdo(Temperature $temperature)
{
switch (true) {
case $temperature instanceof ExtremeTemperature:
switch (true) {
case $temperature instanceof FIRE:
return "Call the fire department";
case $temperature instanceof ICE:
return "Warm up";
}
break;
case $temperature instanceof NormalTemperature:
switch ($temperature) {
case HOT::class: // compare using classname
return "Drink a beer :D";
case COOL or AllTemperatures::COOL: // compare using constants
return "Just go away !";
case 'Enums\\COLD': // compare using string, ugly !!!
return "Wear a coat";
}
break;
}
return "I don't know";
}
// Call to function with a instance of any Temperature
echo WhatShouldIdo(new HOT()) . PHP_EOL;You actually can switch on enums, but you can't switch on Strings until Java 7. You might consider using polymorphic method dispatch with Java enums rather than an explicit switch. Note that enums are objects in Java, not just symbols for ints like they are in C/C++. You can have a method on an enum type, then instead of writing a switch, just call the method - one line of code: done!
public enum Temperature {
HOT {
@Override
public void whatShouldIdo() {
System.out.println("Drink a bear!");
}
},
COLD {
@Override
public void whatShouldIdo() {
System.out.println("Wear a coat!");
}
};
public abstract void whatShouldIdo();
}
// ...
void aMethodSomewhere(final Temperature temperature) {
doSomeStuff();
temperature.whatShouldIdo(); // here is where the switch would be, now it's one line of code!
doSomeOtherStuff();
}One of the nice things about this approach is that it is simply impossible to get certain types of errors. You can't miss a switch case (you can incorrectly implement a method for a particular constant, but there's nothing that will ever totally prevent that from happening!). There's no switch "default" to worry about. Also, I've seen code that puts enum constants into arrays and then indexes into the arrays - this opens the possibility of array index out of bounds exceptions - just use the enum! Java enums are very, very powerful. Learn all that you can about them to use them effectively.
Also note if you have several enum constants that all have the same behavior for a particular method (like days of the week, in which weekend days have the same behavior and the weekdays Tuesday through Thursday also share the same behavior), you can simply gather that shared code in an enum method that is not overridden by every constant (final protected) and then call that method from the appropriate methods. So, add "final protected void commonMethod() { ... }" and then the implementation of method() in each constant would just call commonMethod().
And.... what about PHP ? This is a similar solution ...
<?php
abstract class Temperature extends divengine\enum {
public function whatShouldIdo() {}
}
class HOT extends Temperature {
public function whatShouldIdo() {
echo "Drink a bear!";
}
}
class COLD extends Temperature {
public function whatShouldIdo() {
echo "Wear a coat!";
}
}
// ....
function someStuff(Temperature $t) {
$t->whatShouldIdo();
}
someStuff( new HOT() );Enjoy!
Documentation: https://divengine.org
--
@rafageist
Eng. Rafa Rodriguez