Bonjour à tous,

J'essaye actuellement de simplifier l'appel de méthodes/classes/fonctions au niveau du passage d'arguments.
Lorsque l'on commence comme ceci:

function foo ($arg1, $arg2, $arg3=null)

Et que l'on souhaite modifier le prototype de la fonction, il faut bien souvent retrouver tout les appels à la fonction afin de les modifier.
Du coup je souhaiterais passer mes arguments en tableau associatif, tout en gardant la notion de paramètres obligatoires et de valeurs par défauts.

Pour l'instant mon code donne ceci:

<?php

class a extends parameters {
	
	public function __construct($args = array()){
		
		// test sur les paramètres obligatoires à l'instanciation d'un classes
		// existance + typage, etc...
		if(!isset($args['mandatory_param1'])){
			throw new Exception('You have to give "mandatory_param1"');
		}
		elseif(!isset($args['mandatory_param2']) || !is_numeric($args['mandatory_param2']) || $args['mandatory_param2'] < 1){
			throw new Exception('You have to give "mandatory_param2" (a number greater than 0)');
		}
		// si les prérequis sont remplis
		else {
		
			// on initialize les paramètres
			$this->initializeParameters(
				array( 'a'=>'default_value_a', 'b'=>'default_value_b', 'c'=>null ),
				$args
			);
		}
	}
	
	public function basic_function($args = array()){
		
		// test sur les paramètres obligatoires pour une méthode donnée
		// existance + typage, etc...
		if(!isset($args['mandatory_param1'])){
			throw new Exception('You have to give "mandatory_param1"');
		}
		elseif(!isset($args['mandatory_param2']) || !is_numeric($args['mandatory_param2']) || $args['mandatory_param2'] < 1){
			throw new Exception('You have to give "mandatory_param2" (a number greater than 0)');
		}
		// si les prérequis sont remplis
		else {
		
			// on initialize les paramètres
			$params = new parameters(
				array( 'a'=>'default_value_a', 'b'=>'default_value_b', 'c'=>null ),
				$args
			);
		}
		
		
		var_dump($params->getParameters());
	}	
}


function basic_function($args = array()){
	
	// test sur les paramètres obligatoires pour une fonciton lambda
	// existance + typage, etc...
	if(!isset($args['mandatory_param1'])){
		throw new Exception('You have to give "mandatory_param1"');
	}
	elseif(!isset($args['mandatory_param2']) || !is_numeric($args['mandatory_param2']) || $args['mandatory_param2'] < 1){
		throw new Exception('You have to give "mandatory_param2" (a number greater than 0)');
	}
	// si les prérequis sont remplis
	else {
	
		// on initialize les paramètres
		$params = new parameters(
			array( 'a'=>'default_value_a', 'b'=>'default_value_b', 'c'=>null ),
			$args
		);
	}
	
	
	var_dump($params->getParameters());
}


class parameters {
	
	// contiendra les paramètres
	private $_parameters = array();
	
	public function __construct($default,$params = array()){
		$this->initializeParameters($default,$params);
	}
	
	// initialize les paramètres en "mergeant" les paramètres par défaut
	// et ceux spécifiés par l'utilisateur
	public function initializeParameters($default,$params = array()){
		$this->setParameters(array_merge($default,$params));
	}
	
	// défini un paramètre
	public function setParameter($key,$value){
		$this->_parameters[$key]=$value;
	}	
	
	// défini plusieurs paramètres
	public function setParameters($params){
		foreach($params as $key => $value){
			$this->setParameter($key,$value);
		}
	}
	
	// retourne la valeur d'un paramètre
	public function getParameter($key){
		return $this->_parameters[$key];
	}
	
	// retourne la valeur d'un paramètre
	public function getParameters($a_keys = null){
		if(is_array($a_keys)){
			return array_intersect_key($a_keys, $this->_parameters);
		}
		else {
			return $this->_parameters;
		}
	}
}



// utilisation sur un constructeur
$a = new a(
	array(
		'mandatory_param1'=>0,
		'mandatory_param2'=>2,
		'c'=>'overwrited!'
	)
);

var_dump( $a->getParameters() );


// utilisation au sein d'un classe sur une méthode précise
$a->basic_function(
	array(
		'mandatory_param1'=>456,
		'mandatory_param2'=>666,
		'c'=>'overwrited 2!',
		'z'=>'new 1'
	)
);

// utilisation sur une fonction basique
basic_function(
	array(
		'mandatory_param1'=>45,
		'mandatory_param2'=>78,
		'c'=>'overwrited 3!',
		'z'=>'new 2'
	)
);

Le résultat est celui attendu: Est-ce que cette méthode vous parait bonne? est-ce que l'héritage est une bonne méthode pour l'utilisation lors de l'instanciation d'une autre classe?
Merci d'avance pour vos conseils sur la manière de faire!

Bonne soirée!

Hello,

D'un point de vue personnel, je ne pense pas que se soit une bonne méthode. Après tout dépends du cadre dans lequel tu fais cette implémentation. Si c'est dans le cadre d'un projet personnel, pourquoi pas. Mais si tu es dans un cadre professionnel où d'autres développeurs vont être amener à utiliser ce que tu as fait c'est une autre histoire.
Le problème de ce genre d'architecture, c'est que souvent il n'y a que la personne qui l'a conçue qui est capable de l'utiliser de manière efficace. En plus dans ton archi actuelle tu enfreins la règle d'encapsulation de la conception objet. Concrètement je suis obligé d'ouvrir le code de ta classe A pour pour connaître les clés que je dois utiliser dans le tableau que je passe à la fonction.
Du côté maintenance, je te recommande d'utiliser des méthodes avec des arguments explicites pour la personne qui passe derrière toi ça sera plus simple de comprendre ce que tu as fait et pourquoi est ce que tu l'as fait comme ça...
Pour finir tu évoques la modification de prototype qui te demande de repasser sur tous les appels pour les mettre à jour. Je vois que tu es certifié Zend donc j'imagine que tu utilise un IDE autrement plus évolué que notepad++, un IDE qui te permet certainement de faire la chasse à ces appels.

Mais encore une fois, c'est un avis...

Bonjour,

J'essaye d'utiliser des objets comme paramètre. Lorsque j'ajoute une propriété, c'est transparent hors gestion de la propriété. Ces objets représentent des entités gérées par l'application (personnes...).

J'utilise aussi des tableaux associatif pour des cas particuliers comme les attributs des balises html. Ca me semble acceptable dans la mesure ou c'est l'appelant qui décide des attributs.