Quelle methode pour les getter/setter ?

[untitledoc]

Bonjour à tous,

Je me suis mis à l'apprentissage de le POO en PHP. Je suis en train de construire un site et je me demande quel est la meilleur façon d'accéder et de modifier les valeurs des variables de mes classes.

J'ai commencé à écrire une méthode get() et une méthode set() pour chaque variable, mais j'ai une 20aine de variables et je trouve ça un peu répétitif pour faire finalement toujours la même chose. Alors en continuant mes lectures sur le PHP, je vois qu'il est possible d'utiliser des méthodes magiques qui me font la même chose en quelques lignes, quelque soit le nombre de variable.

Code :

1
2
3
4
5
6
7
public function __set($name, $value) {
    return $this->$name = $value;
}
 
public function __get($name) {
    return $this->$name;
}

Mais avec cette technique, je ne vois pas trop quel serait la différence si je déclarais toutes les variables en public puisque finalement je vais appeler mes objets comme si j'accédais directement à une variable public. Quel est donc l'intérêt de déclarer tout en private ? et quel est la meilleur façon de créer les getter et setter pour un nombre important de variables?

Merci d'avance

[Benjamin Delespierre]

Les membre qui ont vocation à être disponibles sans limitation en dehors de la classe doivent être publiques.

Les méthodes __get et __set sont utiles notamment dans les cas suivants:
1 - on veut forcer un traitement (vérification par exemple) sur les données
2 - la classe doit exposer des attributs dynamiques (contenus dans une collection ou un tableau)
3 - on veut donner un accès à des membres publiques d'un objet décoré au sein de son wrappeur
- etc.

Exemples:
1 - Vérification et validation

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
class TestA {
  protected $_a;
  protected $_b;
  protected $_c;
 
  public function __set ($key, $value) {
    if (!in_array($key, array('a', 'b', 'c') || empty($value)) {
      throw new InvalidArgumentException;
    }
    $key = "_{$key}";
    $this->$key = $value;
  }
}

2 - Attributs dynamiques

Code :

1
2
3
4
5
6
7
8
9
10
11
class TestB {
  protected $_data = array();
 
  public function __get ($key) { 
    return isset($this->_data[$key]) ? $this->_data[$key] : null;
  }
 
  public function __set ($key, $value) {
    $this->_data[$key] = $value;
  }
}

3 - Accéder aux propriétés d'un membre composé

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class TestC {
   public $a;
   public $b;
   public $c;
}
 
class TestD {
  protected $_test_c_inst;  
 
  public function __construct (TestC $test) {
    $this->_test_c_inst = $test;
  }
 
  public function __get ($key) {
    return isset($this->_test_c_inst->$key) ? $this->_test_c_inst->$key : null;
  }
}

Note: Ces deux méthodes magiques font très bon ménage avec __isset

[rawsrc]

Envoyé par Benjamin Delespierre

Les membre qui ont vocation à être disponibles sans limitation en dehors de la classe doivent être publiques.

Alors là sur ce point j'en suis revenu. J'avais pour habitude de respecter cette règle jusqu'au jour (lointain) où j'ai eu à faire d'importantes adaptations dans un vaste programme. Modifications qui m'ont obligé à redéfinir la visibilité d'un paquet d'attributs et là je ne vous raconte pas le bordel.
Du coup je ne mets plus aucun attribut public, c'est private/protected (à la rigueur) et ainsi je suis absolument sûr que tout sera accessible via des setters/getters. Plus à se faire des noeuds si l'on change la visibilité d'un attribut. C'est plus long (pénible) à écrire mais par contre côté évolution c'est total confort. D'ailleurs le rapport temps supplémentaire passé à écrire les setters/getters vaut largement le temps passé à refactoriser tout le code parce qu'on y a fait une modification au niveau de la visibilité d'un attribut.

Puisque on y est et dans la même logique, j'en suis également revenu de la distinction des variables/fonctions selon leur visibilité. Plus aucun _ devant les variables ou fonctions private/protected. Là aussi j'ai bien dégusté : tomber dans une même fonction sur $_variable et un peu plus loin $variable par ce que le type était en panne d'inspiration...
J'ai même eu dans une classe un protected $_variable; et dans la classe dérivée un public $variable; C'est vous dire les maux de tête.
En interdisant ce foutu underscore, vous allez faire des économies d'aspirine, croyez-moi.

[Marc3001]

Envoyé par rawsrc

Alors là sur ce point j'en suis revenu. J'avais pour habitude de respecter cette règle jusqu'au jour (lointain) où j'ai eu à faire d'importantes adaptations dans un vaste programme. Modifications qui m'ont obligé à redéfinir la visibilité d'un paquet d'attributs et là je ne vous raconte pas le bordel.

Je suis d'accord. Je mets aussi systématiquement des getter/setter. Le jour ou tu dois ajouter une vérif t'es moins embêté.

[Benjamin Delespierre]

Envoyé par Marc3001

Je suis d'accord. Je mets aussi systématiquement des getter/setter. Le jour ou tu dois ajouter une vérif t'es moins embêté.

De toute façon, cela revient au même qu'un attribut soit en visibilité publique par implémentation ou non.

[Marc3001]

Envoyé par Benjamin Delespierre

De toute façon, cela revient au même qu'un attribut soit en visibilité publique par implémentation ou non.

Sauf que le jour où tu veux ajouter un traitement au moment du get ou du set, tu dois ajouter tes accesseurs et modifier la portée de tes propriétés mais aussi modifier tous les appels à ces propriétés et là c'est vite la galère.

[Benjamin Delespierre]

C'est à ça que servent les méthodes magiques:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
class FooBar {
 
  public function setX ($x) { 
    if ($x > 0 && $x < 100) 
      $this->x = $x;
    else
      throw new InvalidArgumentException;
  }
 
  public function setY ($y) {
    if ($y > 100 && $y < 200)
      this->y = $y;
    else 
      throw new InvalidArgumentException;
  }
 
  public function __set ($key, $value) {
    if (method_exists($this,  $m = "set{$key}"))
       return $this->$m($value);
    else
       $this->$key = $value;
  }
}