Tipo de sugerencias para propiedades en PHP 7?

PHP 7.4 apoyará escribió propiedades así:

class Person
{
    public string $name;
    public DateTimeImmutable $dateOfBirth;
}

PHP 7.3 y versiones anteriores no son compatibles con este, pero hay algunas alternativas.

Puede hacer que una propiedad privada, que es accesible sólo a través de getters y setters que han declaraciones de tipo:

class Person
{
    private $name;
    public function getName(): string {
        return $this->name;
    }
    public function setName(string $newName) {
        $this->name = $newName;
    }
}

Usted también puede hacer un público de la propiedad y el uso de un bloque de documentación para proporcionar el tipo de información a la gente que lee el código y el uso de un IDE, pero esto no proporciona ningún tipo en tiempo de ejecución-verificación:

class Person
{
    /**
      * @var string
      */
    public $name;
}

Y, de hecho, se pueden combinar los getters y los setters y un bloque de documentación.

Si eres más aventurero, usted podría hacer un fake de la propiedad con el __get, __set, __isset y __unset la magia de los métodos de, y de verificación de los tipos a ti mismo. No estoy seguro de si yo la recomendaría, aunque.

7.4+:

Buena noticia de que será implementado en las nuevas versiones, como @Andrea señaló.
Voy a dejar esta solución aquí en caso de que alguien quiera usarlo antes de 7.4

7.3 o menos

Basadas en las notificaciones me sigue recibiendo de este hilo, creo que mucha gente ahí fuera que tenía/tiene el mismo problema que yo tenía. Mi solución para este caso fue la combinación de incubadoras + __set método mágico en el interior de un rasgo con el fin de simular este comportamiento.
Aquí está:

trait SettersTrait
{
    /**
     * @param $name
     * @param $value
     */
    public function __set($name, $value)
    {
        $setter = 'set'.$name;
        if (method_exists($this, $setter)) {
            $this->$setter($value);
        } else {
            $this->$name = $value;
        }
    }
}

Y aquí está la demostración:

class Bar {}
class NotBar {}

class Foo
{
    use SettersTrait; //It could be implemented within this class but I used it as a trait for more flexibility

    /**
     *
     * @var Bar
     */
    private $bar;

    /**
     * @param Bar $bar
     */
    protected function setBar(Bar $bar)
    {
        //(optional) Protected so it wont be called directly by external 'entities'
        $this->bar = $bar;
    }
}

$foo = new Foo();
$foo->bar = new NotBar(); //Error
//$foo->bar = new Bar(); //Success

Explicación

Primero de todo, definir bar como una propiedad privada para PHP elenco __set automágicamente.

__set comprobará si hay algunos setter declarado en el objeto actual (method_exists($this, $setter)). De lo contrario es sólo establecer su valor como lo haría normalmente.

Declarar un método setter (setBar) que recibe un tipo-insinuó argumento (setBar(Bar $bar)).

Tan largo como PHP detecta que hay algo que no es Bar instancia se pasa a la incubadora, será automáticamente desencadenar un Error Fatal: Uncaught TypeError: Argumento 1 pasa a Foo::setBar() debe ser una instancia de Bar, instancia de NotBar dado

En realidad no es posible y sólo tiene 4 formas de simular :

• Valores predeterminados
• Decoradores en bloques de comentario
• Valores predeterminados en el constructor
• Getters y setters

Me combinado de todos ellos aquí

class Foo
{
    /**
     * @var Bar
     */
    protected $bar = null;

    /** 
    * Foo constructor
    * @param Bar $bar
    **/
    public function __construct(Bar $bar = null){
        $this->bar = $bar;
    }

    /**
    * @return Bar
    */
    public function getBar() : ?Bar{
        return $this->bar;
    }

    /**
    * @param Bar $bar
    */
    public function setBar(Bar $bar) {
        $this->bar = $bar;
    }
}

Nota de que en realidad se puede escribir la devolución ?Bar desde php 7.1 (que acepta valores null), ya que podría ser null (no disponible en php7.0.)

También puede escribir el retorno nula desde php7.1

Puede utilizar setter

class Bar {
    public $val;
}

class Foo {
    /**
     *
     * @var Bar
     */
    private $bar;

    /**
     * @return Bar
     */
    public function getBar()
    {
        return $this->bar;
    }

    /**
     * @param Bar $bar
     */
    public function setBar(Bar $bar)
    {
        $this->bar = $bar;
    }

}

$fooInstance = new Foo();
//$fooInstance->bar = new NotBar(); //Error
$fooInstance->setBar($fooInstance);

De salida:

TypeError: Argument 1 passed to Foo::setBar() must be an instance of Bar, instance of Foo given, called in ...