Discussion :

[Général03]

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

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
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 ) ...
  }
}

[grunk]

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

J'aurais plus tendance à opter pour :

Code :

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

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)

[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.

[Celira]

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 :

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
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...

[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.

[Bovino]

[HS]

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

Ca dépasse... forcément
[/HS]

[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