处理PHP中常量的最佳方法

Question

Say I have a class with some methods that take a true/false value. For example:

class MyClass
{
    public function hasSomething($value)
    {
        $something = $value;
    }
}

Where $something can be true/false. If I call that in code somewhere, it isn't very nice:

$MyClass->hasSomething(true);

It can be a bit hard from the method name and the value true to determine what the code is doing. So I like to use constants to make it nicer.

I've been doing it like this:

abstract class MY_CLASS_CONSTANTS
{
    const HAS_THING_ONE = true;
    const NO_THING_ONE = false;
}

Now when I call MyClass->hasSomething I can go MyClass->hasSomething(MY_CLASS_CONSTANTS::HAS_THING_ONE) which imo is far more expressive and should make the code easier to understand.

I like the idea of putting the const in a class because it then becomes more obvious what those consts are supposed to be used with.

Is this a bad idea? Is there a better way to do it? How do other people deal with this?

Answer 1

Why not creating a method, which would be ... less verbose and more explicit:

MyClass->hasOneThing();
MyClass->hasNothing();

And in your class, you are free to delegate:

class MyClass
{
    private function hasSomething($value) {$something = $value;}
    public function hasOneThing() {$this->hasSomething(true);}
    public function hasNothing() {$this->hasSomething(false);}
}

I don't use the constants; they are useless if that small case especially when the parameter's type is boolean.

Beside, your method design is wrong. If its name is has or is , it should return something like a boolean, and not update the value.

Answer 2

It's good idea to use php class constants.

I'll give some example that would make your code more understandable and readable,

Example 1: (inside the class itself)

class Exam
{
    /**
     * available grades
     */
    const GRADE_EXCELLENT   = 'A';
    const GRADE_VERY_GOOD   = 'B';
    const GRADE_MIN_PASS    = 'C';
    const GRADE_CLOSE_FAIL  = 'D';
    const GRADE_FAIL        = 'E';

    private $finalGrade;

    /**
     * one of const - Exam::GRADE_...
     * 
     * @param char $grade
     */
    public function setGrade($grade)
    {
        $this->finalGrade = $grade;
    }
}


$exam = new Exam();
$exam->setGrade(Exam::GRADE_VERY_GOOD);

Example 2: (having separate class)

class Exam_Grades
{
    /**
     * available grades
     */
    const EXCELLENT   = 'A';
    const VERY_GOOD   = 'B';
    const MIN_PASS    = 'C';
    const CLOSE_FAIL  = 'D';
    const FAIL        = 'E';
}

$exam->setGrade(Exam_Grades::FAIL);

Example 3: (define constants)

define('EXAM_GRADE_EXCELLENT',  'A');
define('EXAM_GRADE_VERY_GOOD',  'B');
define('EXAM_GRADE_MIN_PASS',   'C');
define('EXAM_GRADE_CLOSE_FAIL', 'D');
define('EXAM_GRADE_FAIL',       'E');

$exam->setGrade(EXAM_GRADE_MIN_PASS);

This way also code completion is available and is good practice to use constants.

Most cases I prefer first example style, for me it does make much more sense, it's your choice, do whatever is better for you...