__construct() vs SameAsClassName() for constructor in PHP

Question

Is there any advantage to using __construct() instead of the class's name for a constructor in PHP?

Example (__construct):

class Foo {
    function __construct(){
        //do stuff
    }
}

Example (named):

class Foo {
    function Foo(){
        //do stuff
    }
}

Having the __construct method (first example) is possible since PHP 5.

---

_{Moderator note: The question relates to functionality that was available in PHP 5. Since PHP 7.0, named constructors have been deprecated and removed in PHP 8.0.}

Answer 1

The advantage is that you don't have to rename it if you rename your class. DRY.

Similarly, if you have a child class, you can call the parent constructor:

parent::__construct()

If further down the track you change the class the child class inherits from, you don't have to change the construct call to the parent.

It seems like a small thing, but missing changing the constructor call name to your parents' classes could create subtle (and not so subtle) bugs.

For example, if you inserted a class into your hierarchy, but forgot to change the constructor calls, you could start calling constructors of grandparents instead of parents. This could often cause undesirable results which might be difficult to notice.

Answer 2

__construct was introduced in PHP5. It is the way you are supposed to do it now. I am not aware of any advantages per se, though.

From the PHP manual:

For backwards compatibility, if PHP 5 cannot find a __construct() function for a given class, it will search for the old-style constructor function, by the name of the class. Effectively, it means that the only case that would have compatibility issues is if the class had a method named __construct() which was used for different semantics

If you're on PHP5 I would recommend using __construct to avoid making PHP look elsewhere.

Answer 3

The reasoning in the accepted answer is wrong.

I find renaming classes to be a bad practice: things can get tangled when using Reflection or complex dependence structure like PHP frameworks often do. It also break dependencies regardless of the constructor syntax. As a rule of thumb:

• if the class name conflicts, use namespaces
• if the class name sucks, use Decorator pattern or inheritance
• if the class has to be adapted to the project, use Adapter pattern

Java, C++ or C# don't use __construct, they use named constructor and there's no issue with them. PHP is, however, a different story:

1. PHP 5.3.3 removed named constructors in namespaces

2. PHP 7.0 deprecated all named constructors

3. PHP 8.0 removed all named constructors

So named constructors are no longer an option. But to answer your question: the reason for the deprecation/removal named constructors is probably that PHP functions/methods are case insensitive, so in legacy PHP code there was this problem:

class Filter {
  function filter() {
    echo "this is a constructor, not a method!";
  }
}

// so you could never write
// $filter = new Filter;
// $filter->filter();

This is the official PHP RFC reasoning behind the removal of named constructors.

---

^{Funnily, PHP variables are case sensitive, there's little reasoning in PHP development, see this funny legacy official PHP 4.0 release announcement.}

Answer 4

The main advantage I see for __construct, is that you don't have to rename your constructor if you change your class name.

Answer 5

The best advantage of using __contruct() instead of ClassName() is when extending classes. It is much easier to call parent::__construct() instead of parent::ClassName(), as it is reusable among classes and the parent can be changed easily.

Answer 6

In your example Foo::Foo is sometimes called a PHP 4 or old-style constructor because it comes from the days of PHP 4:

class Foo {
    // PHP 4 constructor
    function Foo(){
        //do stuff
    }
}

PHP 4 constructors will be deprecated but not removed in PHP 7. They will be no longer be considered as constructors in any situation in PHP 8. Future compatibility is definitely a big reason to not use this feature.

Answer 7

In PHP 7, the option to create the constructor as a function with the same name as the class will be removed. If you still do it, you will get a E_DEPRECATED.

You can read more about this proposal (the proposal is accepted) here: https://wiki.php.net/rfc/remove_php4_constructors

And a quote from there:

PHP 7 will emit E_DEPRECATED whenever a PHP 4 constructor is defined. When the method name matches the class name, the class is not in a namespace, and a PHP 5 constructor (__construct) is not present then an E_DEPRECATED will be emitted. PHP 8 will stop emitting E_DEPRECATED and the methods will not be recognized as constructors.

Also, you won't get a E_STRICT in PHP 7 if you define a method with the same name as the class AND a __construct().

You can see this also here:

PHP 7 will also stop emitting E_STRICT when a method with the same name as the class is present as well as __construct.

So I would recommend you to use __construct(), since you will have less issues with this in the future.

Answer 8

In PHP 5 the advantage would be that performance would be better. It will look for a constructor by the name of __construct first and if it doesn't find that, it will look for constructors by the name of className. So if it finds a constructor by the name __construct it does not need to search for a constructor by the name className.

Answer 9

Forward compatibility. There's always a chance that legacy code that's left in the language for backwards compatibility's sake will be removed in a future version.

Answer 10

I think that the main reason is that is the language convention. You don't need to force a language to act like someone else.

I mean, in Objective-C you prefix the constructors with -init, for example. You can make your own constructor using your class name but why? Are ther some reason to use this schema instead of the language convention?