Mickael Wolff
2007-10-22 12:47:18 UTC
Bonjour,
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe. Je m'explique en prenant un
exemple simple (écrit en PHP5). J'ignore volontairement les tests pour
éviter d'alourdir les exemples. En fait, j'hésite toujours entre les
trois philosophies suivantes, sans pouvoir trancher réellement.
La première approche me semble être la plus proche de la philosophie
PHP5. On utilises que des méthodes magiques. Le problème ici est que si
on a plus d'une donnée à protéger dans sa classe, les méthodes __get et
__set deviennent rapidement illisibles. Et surtout, lors d'un héritage
on a des problèmes assurés avec le polymorphisme.
class directAccess
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function __get($aname)
{
// Travail de vérification
return clone $this->$aname ;
}
public function __set($aname, $avalue)
{
// Travail de vériication
$this->$aname = $avalue ;
}
protected $attribute ;
}
La seconde approche serait plus proche du C++, mais avec la surcharge
des méthodes en moins. Le seul inconvénient qu'on peut y trouver, c'est
l'imposibilité d'assigner la valeur null sans devoir recourir à une
méthode supplémentaire.
class allInOne
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function attribute($avalue=null)
{
if(is_null($avalue))
{
// Travail de vérification
return clone $this->attribute ;
}
else
{
// Travail de vériication
$this->attribute = $avalue ;
}
}
public function del($aname)
{
$this->$name = null ;
}
protected $attribute ;
}
La troisième méthode est certainement la plus propre d'un point de vue
de la conception. Le désavantage est la lourdeur d'écriture.
class javaStyle
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function getAttribute()
{
// Travail de vérification
return clone $this->attribute ;
}
public function setAttribute($avalue)
{
// Travail de vériication
$this->attribute = $avalue ;
}
protected $attribute ;
}
Laquelle de ces méthodes utilisez-vous ? Peut-être un mélange ? Ou
encore en fonction de la situation rencontrée ? J'ai conscience que
c'est un concentré de troll, car personne n'est d'accord sur la façon de
développer. Mais ça m'intéresse d'avoir vos avis.
Merci !
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe. Je m'explique en prenant un
exemple simple (écrit en PHP5). J'ignore volontairement les tests pour
éviter d'alourdir les exemples. En fait, j'hésite toujours entre les
trois philosophies suivantes, sans pouvoir trancher réellement.
La première approche me semble être la plus proche de la philosophie
PHP5. On utilises que des méthodes magiques. Le problème ici est que si
on a plus d'une donnée à protéger dans sa classe, les méthodes __get et
__set deviennent rapidement illisibles. Et surtout, lors d'un héritage
on a des problèmes assurés avec le polymorphisme.
class directAccess
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function __get($aname)
{
// Travail de vérification
return clone $this->$aname ;
}
public function __set($aname, $avalue)
{
// Travail de vériication
$this->$aname = $avalue ;
}
protected $attribute ;
}
La seconde approche serait plus proche du C++, mais avec la surcharge
des méthodes en moins. Le seul inconvénient qu'on peut y trouver, c'est
l'imposibilité d'assigner la valeur null sans devoir recourir à une
méthode supplémentaire.
class allInOne
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function attribute($avalue=null)
{
if(is_null($avalue))
{
// Travail de vérification
return clone $this->attribute ;
}
else
{
// Travail de vériication
$this->attribute = $avalue ;
}
}
public function del($aname)
{
$this->$name = null ;
}
protected $attribute ;
}
La troisième méthode est certainement la plus propre d'un point de vue
de la conception. Le désavantage est la lourdeur d'écriture.
class javaStyle
{
public function __construct($value)
{
$this->attribute = $value ;
}
public function getAttribute()
{
// Travail de vérification
return clone $this->attribute ;
}
public function setAttribute($avalue)
{
// Travail de vériication
$this->attribute = $avalue ;
}
protected $attribute ;
}
Laquelle de ces méthodes utilisez-vous ? Peut-être un mélange ? Ou
encore en fonction de la situation rencontrée ? J'ai conscience que
c'est un concentré de troll, car personne n'est d'accord sur la façon de
développer. Mais ça m'intéresse d'avoir vos avis.
Merci !
--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org