如何在类构造函数中定义常量？

Question

Can I define a class constant inside the class constructor function ?

(based on certain conditions)

Answer 1

That goes against the idea of class constants - they should not be dependent on a specific instance. You should use a variable instead.

However, if you insist on doing this, are very adventurous and can install PHP extensions, you can have a look at the runkit extension that allows to modify classes and their constants at runtime. See this doc: http://www.php.net/manual/en/function.runkit-constant-add.php

Answer 2

I don't think you can.

It wouldn't make sense, either - a class constant can be used in a static context, where there is no constructor in the first place.

You'll have to use a variable instead - that's what they're there for.

Answer 3

As far as standard instance constructors go, there is no way to do this, and as others have pointed out, it wouldn't make sense. These constructors are called per created object instance, at the point they are created. There is no guarantee this constructor would get called before some code tried to access the constant. It also doesn't make sense in that the code would get called over and over again each time a new instance was constructed, whereas a const should only get set once.

It would be nice if PHP either offered some kind of static constructor that let you set the value one time for uninitialized constants, or allowed more types of expressions when defining constants. But these are not currently features of PHP. In 2015 an RFC was made that proposed adding static class constructors, but it is, at the time of me writing this answer, still in the draft status, and has not been modified since 2017.

I think the best alternative for now is to not use constants in this kind of scenario, and instead use static methods that return the value you want. This is very simple in that it only uses the PHP language features as is (not requiring any special extensions), these static methods can be called in the standard way, and you don't need to hack the autoloading process to call some kind of initializer function that sets static variables. The method might need to rely on private static variables in order to make sure the same instance is returned every time, if an object instance is being returned. You would need to write the implementation of this method to be constant like in the sense that it will always return the same thing, but takes advantage of being able to do things you can't do with a constant, like return on object instance or rely on complex expressions or function calls. Here is an example:

final class User
{
    /** @var DefinitelyPositiveInt|null */ private static $usernameMaxLength;
    public static function getUsernameMaxLengthConst(): DefinitelyPositiveInt
    {
        if ($usernameMaxLength === null) {
            $usernameMaxLength = new DefinitelyPositiveInt(40);
        }
        return $usernameMaxLength;
    }
}

$usernameInput.maxLength = User::getUsernameMaxLengthConst();

This is still not a perfect solution because it relies on the programmer to write these in a constant like way when that is desired (always returning the same value). Also, I don't like that the best place to document the fact that it is a const is in the method name, thus making it even longer to call. I also don't like that you now have to call it as a method instead of just accessing a property, which would be syntactically nicer.

This example is essentially an implementation of a singleton, but sometimes the purpose of a singleton is to be a constant rather than just a singleton. What I mean is, you might want the instance to always exist, and it might be an immutable type (none of the properties are public or mutable, only having methods that return new objects/values).

Answer 4

Try look here:

http://php.net/manual/en/language.oop5.constants.php

http://php.net/manual/en/language.oop5.static.php

Hope this helps.

Answer 5

I am sorry to break it to you but it is not possible in vanilla PHP. I am not very sure about frameworks or extensions but I am sure that it is not possible in vanilla PHP. I recommend you to use variables instead.

Answer 6

You still can't , but maybe some of these (progressively weirder) ideas (just ideas, not true solutions) will work for you:

(1) You could use a private property , with a public getter method . The property cannot be modified outside the class, such as constants, but unfortunately it is accessed as a method, not as a constant, so the syntax is not the same.

class aClass{
  private $const;
  function __construct($const){
    $this->const=$const;      
  }
  function const(){
    return $this->const;
  }
}
    
$var1=new aClass(1);
echo $var1->const(); //Prints 1

(2) If you really want this value to be accessed as constant from outside, you can use define () inside the constructor . Unfortunately it doesn't get tied to the class or object name (as it do when you use const , using for example myClass::myConst ). Furthermore, it only works if you create a single instance of the class. The second object you create is going to throw an error for redefining the constant, because is untied.

class otherClass{  
  function __construct($const){
    define('_CONST',$const);
  }
  function const(){
    return _CONST;
  }
}

$var2=new otherClass('2');
echo $var2->const(); //Prints 2
echo _CONST; //Prints 2

@$var3=new aClass('3'); //Notice: Constant _CONST already defined
echo _CONST; //Still prints 2!

(3) Perhaps that last problem can be solved by giving variable names to the constants , related to the object to which they belong. This may be a bit weird... but maybe it works for someone.

class onemoreClass{
  private $name;
  function __construct($const,$name){
    $this->name=$name;
    $constname=$this->name."_CONST";
    define($constname,$const);    
  }
  function const(){
    return constant($this->name.'_CONST');
  }
}

$name='var4';
$$name=new onemoreClass(4,$name);

echo $var4->const(); //Prints 4
echo var4_CONST; //Prints 4

$name='var5';
$$name=new onemoreClass(5,$name);

echo $var5->const(); //Prints 5
echo var5_CONST; //Prints 5