Accés variable d'une classe

Version imprimable

Au niveau de la maintenabilité, propreté de codage, temps d'execution, habitude de codage, ... quelle est la meilleur solution ?

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
25
class A {
  private $_var ;
 
    function meth1(){
      $this->_var = 1;
      $this->meth2($this->_var);
    }
 
    function meth2($param){
      if( $param ) ...
    }
}
 
class B {
  private $_var ;
 
  function meth1(){
    $this->_var = 1 ;
    $this->meth2();
  }
 
  function meth2(){
    if( $this->_var ) ...
  }
}

J'ai envie de dire que ça dépend.

J'aurais plus tendance à opter pour :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class C { private $_var ; function meth1(){ $this->_var = 1; $this->_var = $this->meth2($this->_var); } function meth2($param){ return param } }
Car de cette manière meth2 est plus généraliste et pourra être utiliser pour d'autres chose. Mais encore une fois ca dépend beaucoup de ce que doit faire la méthode.
Si c'est juste modifier une variable membre de la classe bien précise , ca sert à rien de s'embeter avec des arguments et des return
Après niveau performance , argument ou pas c'est pareil (a quelque µs près)

17/08/2011, 16h11
Général03

Je trouve qu'utiliser la classe B est plus brouillon quand celle ci devient importante. Et puis avec la classe A, dans ta méthode tu sais de quoi elle dépend et se qu'elle a besoin pour fonctionner.

Je rejoins l'avis général : ça dépend surtout de ce que doivent faire les méthodes. Par exemple, si ta méthode meth2 est spécifique à une variable donnée, il vaut mieux utiliser la variable directement dedans. En revanche, si on peut l'appliquer à plusieurs variables, il faut lui donner un paramètre et éventuellement faire des méthode spécifiques qui appellent cette méthode générale.

Exemple :
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 25 26 27 28 class Armoire { // nombre de pantalons private $_pantalons; // nombre de chemises private $_chemises; // nombre de chaussettes private $_chaussettes; // fonction d'incrémentation générale function incrementer($param) { return $param + 1; } // on incremente le nombre de chemises function incrementerChemises() { $this->_chemises = $this->incrementer($this->_chemises); } // on incrémente le nombre de pantalons function incrementerPantalons() { $this->_pantalons = $this->incrementer($this->_pantalons); } // les chaussettes vont par paires, donc on en ajoute toujours 2 function incrementerChaussettes() { $this->_chaussettes = $this->_chaussettes + 2; } }
ok, c'est pas très intellectuel comme fonctions, mais ça donne une idée assez claire du truc

Ce qui est bien aussi, c'est de passer par des get-setters pour accéder aux variables de classe...

18/08/2011, 12h19
Thes32

salut,

si meth2 est private et en dois être utiliser que dans la classe je ne vois pas pourquoi passer _var en argument sinon comme le dit grunk ça dépend.
18/08/2011, 18h04
Bovino

[HS]

Citation:

Envoyé par grunk

J'ai envie de dire que ça dépend.

Ca dépasse... forcément :aie:
[/HS]
19/08/2011, 09h25
Général03

De manière générale en fonction de vos dires, il faut utiliser une méthode avec argument dans le cas où cette dernière est public ou qu'elle est utilisée pour faire un traitement (merci pour l'exemple Celira)
Dans mon cas j'ai mon constructeur qui initialise ma variable $this->_var, et celle-ci est utilisé dans plusieurs méthodes à des fins de test