Discussion :

[comode]

Bonjour,

Voilà, j'ai des librairies contenant des class, et pour des raisons pratiques je voudrait ajouter des méthodes à une de ces class, mais sans toucher à ma librairie et en évitant de déclarer une class dérivée juste pour ça...

Existe t-il donc en PHP un moyen d'ajouter une méthode à une class sans toucher à la librairie qui contient la déclaration de class originale (directement dans le code de ma page donc) ?

En vous remerciant par avance...

[stealth35]

non tu peux pas

[comode]

Bon bha comme ça, c'est clair !

merci !

[Benjamin Delespierre]

En théorie non, c'est impossible contrairement à ce qu'on peut voir en JavaScript notamment.

En pratique il existe des patterns pour faire ça, dont le plus adapté à ce cas est le pattern Decorator.
Le principe est d'encapsuler un objet dans un autre qui va le "décorer", y ajouter de nouvelles fonctionnalités: http://en.wikipedia.org/wiki/Decorator_pattern

Je te recommande fortement l'usage de ce pattern.

S'il s'agit d'une spécialisation, un héritage est envisageable également. Attention à ne pas tomber dans les écueils de l'héritage fonctionnel comme expliqué par ici.

L'héritage de classes est bien souvent mal employé par les développeurs qui lui donnent une signification plus large que nécessaire. L'héritage définit normalement une relation sémantique entre deux classes. Par exemple, un bouton est un composant graphique. Malheureusement, à cette relation sémantique est souvent substituée une relation fonctionnelle. On n'hérite plus alors d'une autre classe pour marquer des qualités intrinsèques mais pour hériter de fonctionnalités qui évitent au programmeur de devoir les implémenter à nouveau. En résumé, sous prétexte de favoriser la réutilisation du code, le développeur se rend coupable d'une grave erreur de conception qui peut avoir des conséquences assez importantes dans des API publiques.

D'autres solutions existent comme l'héritage parasitaire (je vais me faire avoiner la tête pour avoir dit ça mais ça existe) ou l'augmentation de classes.

Exemple d'une classe parfaitement générique en PHP:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
final class GenericObject {
 
  private $_data = array();
  private $_methods = array();
 
  public function __get ($key) {
    return isset($this->_data[$key]) ? $this->_data[$key] : null;
  }
 
  public function __set ($key, $value) {
    $this->_data[$key] = $value;
  }
 
  public function fn ($method, $alpha) {
    $this->_methods[$method] = $alpha;
  }
 
  public function __call ($method, $args) {
    if (isset($this->_methods[$method])) {
      array_unshift($args, $this);
      return call_user_func_array($this->_methods[$method], $args);
    }
    throw new BadMethodCallException('No such $method');
  }
}
 
$any = new GenericObject;
 
$any->fn('setName', create_function('$that,$name','$that->name = $name;'));
$any->fn('displayName', create_function('$that', 'echo $that->name;'));
 
$any->setName('Peter');
$any->displayName();
$any->setName('Joe');
$any->displayName();

Note: toutes les méthodes ajoutées grâce à GenericObject::fn doivent impérativement prendre un premier paramètre $that qui sert à faire passer la référence $this à l'intérieur de la fonction anonyme.

[stealth35]

sinon en marrant t'as

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Test
{
    public function __call($name, $arguments)
    {
        if ($this->$name instanceof \Closure) {
            return call_user_func_array($this->$name, $arguments);
        }
    }
}
 
$test = new Object();
 
$test->func = function($str) {
    return 'hello '.$str;
};
 
echo $test->func('world');

[Benjamin Delespierre]

Y'a ça aussi pour faire de la programmation orientée prototype sous PHP 5.3:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Obj
{
    public function __construct($methods=array())
    {
        $this->methods = $methods;
    }
 
    public function method($name)
    {
        if (!isset($this->methods[$name]))
        throw new BadMethodCallException();
 
        return $this->methods[$name];
    }
 
    public function fn($name, $fn)
    {
        $this->methods[$name] = $fn;
        return $this;
    }
 
    public function __call($name, $args)
    {
        return call_user_func_array(
        $this->method($name),
        array_merge(array($this), $args)
        );
    }
}
 
// Allow chaining method calls off the constructor..
function Obj($methods=array())
{
    return new Obj($methods);
}

https://gist.github.com/591139

Enfin, pour moi le décorateur y'a que ça de vrai