Best practices for static constructors

Question

I want to create an instance of a class and call a method on that instance, in a single line of code.

PHP won\'t allow calling a method on a regular constructor:

Answer 1

Static constructors (or "named constructors") are only beneficial to prove an intention, as @koen says.

Since 5.4 though, someting called "dereferencing" appeared, which permits you to inline class instantiation directly with a method call.

(new MyClass($arg1))->doSomething(); // works with newer versions of php

So, static constructors are only useful if you have multiple ways to instantiate your objects. If you have only one (always the same type of arguments and number of args), there is no need for static constructors.

But if you have multiple ways of instantiations, then static constructors are very useful, as it avoids to pollute your main constructor with useless argument checking, weakening languages constraints.

Example:

<?php

class Duration
{
private $start;
private $end;

// or public depending if you still want to allow direct instantiation
private function __construct($startTimeStamp = null, $endTimestamp = null)
{
   $this->start = $startTimestamp;
   $this->end   = $endTimestamp;
}

public static function fromDateTime(\DateTime $start, \DateTime $end)
{
    return new self($start->format('U'), $end->format('U'));
}

public static function oneDayStartingToday()
{
    $day = new self;
    $day->start = time();
    $day->end = (new \DateTimeImmutable)->modify('+1 day')->format('U');

    return $day;
}

}

As you can see in oneDayStartingToday, the static method can access private fields of the instance! Crazy isn't it ? :)

For a better explanation, see http://verraes.net/2014/06/named-constructors-in-php/

Answer 2

These are called creation methods, and I typically name them createXXX() such as createById() or createEmptyCatalog(). Not only do they provide a nice way to reveal the different intentions of an object's constructors, but they enable immediate method chaining in a fluent interface.

echo Html_Img::createStatic('/images/missing-image.jpg')
        ->setSize(60, 90)
        ->setTitle('No image for this article')
        ->setClass('article-thumbnail');

Answer 3

The naming of any method should be with intention revealing names. I can't tell what 'Foo::factory' does. Try to build to a higher level language:

User::with100StartingPoints();

This would be the same as:

$user = new User();
$user->setPointsTo(100);

You could also easily test whether User::with100StartingPoints() is equal to this.

Answer 4

Propel uses a static method "create". I'd go with that. This method makes the code easier to test rather than just using static methods to perform business logic.

<?php 
class MyClass
{
  public static function create()
  {
    return new MyClass();
  }
  public function myMethod()
  {
  }
}

Besides, you can also pass parameters to the constructor. For instance:

<?php 
class MyClass
{
  public function __construct($param1, $param2)
  {
   //initialization using params
  }

  public static function create($param1, $param2)
  {
    return new MyClass($param1, $param2); // return new self($param1, $param2); alternative ;)
  }

  public function myMethod()
  {
  }
}

In either case, you'd be able to invoke myMethod right after the create method

<?php
MyClass::create()->myMethod();
// or
MyClass::create($param1, $param2)->myMethod();

Answer 5

Addition to Jon's answer: To allow constructor arguments use the following:

function create($type) {
    $args = func_get_args();
    $reflect = new ReflectionClass(array_shift($args));
    return $reflect->newInstanceArgs($args);
}
create('Foo', 'some', 'args')->bar();

Documentation: ReflectionClass->newInstanceArgs

Answer 6

It's probably not quite a best practice, but you could use the fact that functions and classes have two different namespaces : you can have a function that have the same name as a class.

This allows one to write this kind of code, for example :

function MyClass() {
    return new MyClass();
}

class MyClass {
    public function __construct() {
        $this->a = "plop";
    }
    public function test() {
        echo $this->a;
    }
    protected $a;
}

Note that I have defined a function called MyClass, and a class with the same name.

Then, you can write this :

MyClass()->test();

Which will work perfectly, and not get you any error -- here, you'll get the following output :

plop