Pour illustrer ce que je voulais pouvoir faire en PHP, je me suis inspiré du langage Java où on rencontre parfois ce genre d'appel :

// en Java
new Application(login, pwd).start();

La particularité est qu'on peut utiliser un objet sans avoir forcément besoin de le déclarer dans une variable. Ceci est souvent utilisé dans le cas où cet objet n'est nécessaire qu'à un unique endroit du programme. Malheureusement, PHP n'autorise pas cette syntaxe, ce qui nous contraint de scinder l'opération et de s'encombrer d'une variable intermédiaire qui nous est inutile.

// en PHP
$app = new Application($login, $pwd);
$app->start();
unset($app);

L'avantage de la première solution, outre le fait apprécié qu'elle offre une écriture plus concise, réside dans la mise en évidence de l'inutilité de l'instance en dehors de cet unique appel, ce qui peut s'avérer d'une grande utilité pour une compréhension rapide du code par un tierce développeur.

Pour pouvoir reproduire cette écriture en PHP, j'ai créé la petite classe suivante (qui aurait très bien pu n'être qu'une simple fonction) :

class ClassLoader {
    public static function load($className, $arg=null) {
        $c = new ReflectionClass($className);
        return ($c->hasMethod('__construct') || $c->hasMethod($className)) ?
            $c->newInstanceArgs(array_splice(func_get_args(), 1)) :
            $c->newInstance();
    }
}

On peut alors écrire :

ClassLoader::load('Application', $login, $pwd)->start();

Le principe devient intéressant, mais la clarté du code en a pris un sacré coup ! Pour simplifier, j'ai pensé à une nouveauté très attendue de PHP 5.3 : la nouvelle méthode magique __callStatic, dont le comportement est identique à la méthode __call bien connue, mais adaptée aux méthodes statiques.

// à partir de PHP 5.3
class ClassLoader {
    public static function __callStatic($method, $args) {
        $c = new ReflectionClass($method);
        return ($c->hasMethod('__construct') || $c->hasMethod($method)) ?
            $c->newInstanceArgs($args) :
            $c->newInstance();
    }
}

L'écriture gagne ainsi nettement en simplicité :

ClassLoader::Application($login, $pwd)->start();

Il ne reste plus qu'à finaliser la classe pour la rendre compatible PHP 5 et 6, ce qui ne pose pas de problème. Il sera juste laissé au développeur le soin de réaliser les appels adéquats selon la version de PHP utilisée, avec la seule petite restriction qu'en PHP 6, le chargement d'une éventuelle classe nommée "Load" devra inévitablement se faire via l'écriture PHP 5.

class ClassLoader {
    public static function load($className, $arg=null) {
        $c = new ReflectionClass($className);
        return ($c->hasMethod('__construct') || $c->hasMethod($className)) ?
            $c->newInstanceArgs(array_splice(func_get_args(), 1)) :
            $c->newInstance();
    }
    
    public static function __callStatic($className, $args) {
        return call_user_func_array(
            array(self, 'load'), array_merge(array($className),$args)
        );
    }
}

<<< Retour

16/06/2009 18:56Posté par Matthieu

Je propose tout simplement de cr�er une methode statique dans ta classe qui retourne une instance de la classe. ex :

<?php
// La class
class MaClass
{
private function __construct()
{

}

public static function init()
{
return new MaClass();
}

public function start()
{

}
}

// Utilisation
MaClass::init()->start();
?>

Non ?

05/02/2009 22:04Posté par Geoffray

Tout � fait d'accord pour dire que la R�flexion ne soit pas une solution des plus performantes et que le b�n�fice apport� par tout ce m�canisme ne soit pas des plus utiles. La d�marche �tait plut�t destin�e � explorer les possibilit�s pour �viter l'affectation de variable... sans grand succ�s.

03/02/2009 15:44Posté par John

Et pourquoi ne pas d�clarer ta m�thode start() comme static dans ta classe ?

Si son comportement est tel qu'elle peut �tre utilis�e hors de l'instanciation de la classe � laquelle elle appartient, elle n'a pas de raison d'�tre d�clar�e autrement.

La solution qui consiste �utiliser la Reflexion est tellement lourde d'un point de vue compr�hension du code et utilisation m�moire.

Appeller et utiliser tout une gestion de classe pour �viter une affection de variable...

Comment utiliser un objet PHP sans le d�clarer ?

Vos commentaires

Réagir à cet article