Bonsoir à tous,


Voici certainement une réponse qui trouvera je pense une réponse très rapidement auprès des personnes plus confirmée.

Dans tout les exemples de gestion d'exception en PHP, on crée une class "MyException".
Nos class hérite ensuite de "MyException"..

Moi, j'aimerais en plus d'une gestion des exceptions (que je ne maitrise pas encore) implémenter une gestion centralisée des messages.

Par exemple, une class utilisateurs à une méthode inscription.
La méthode inscription peut renvoyer plusieurs erreur ( Date de naissance incorrecte, Pseudo non conforme, Adresse e-mail invalide, etc !! )

Ce ne sont donc pas des erreurs générée par un code mais plutôt des erreurs que je gère moi même via des test.

Dans mon esprit j'avais une class "erreur" avec des méthodes du style "getError", "errDescription", "lastError" etc...

Le but étant de séparer code et exécution et donc utiliser des codes erreur.

Mais j'imagine que ce n'est pas une bonne solution que dois-je faire dans mon cas ?

Utiliser des exceptions ?

Merci beaucoup et désolé si la question vous parait simple

Lorsque ton programme commet une erreur (par exemple erreur de validation d'un formulaire soit tu renvoi un erreur au test de validation soit tu génères une exception. Celle-ci sera ensuite attrapée par ton programme via les différents catch.

A noter dans php tu as exception et errorException (cf http://be.php.net/manual/en/reserved.exceptions.php )


pour différencier erreur et exception, moi je voix cela comme cela :
un exception s'attrape, se traite et éventuellement affiche un message, une erreur s'affiche et stop le programme ou en tout cas en bloque une partie.
Les exceptions étant de type différents, et traiter dans le catch de ton try, tu peux facilement faire le tri!

Rien ne t'empêche de créer une classe exception avec un code, un message, etc ....
Tout comme rien ne t'empêche de généré des messages d'erreurs (trigger_error) et d'utiliser un error_handler pour les gérés .... ou encore une classe erreurs ...

Merci pour votre réponse.

J'ai beau chercher sur internet je n'arrive pas trop à comprendre l'idée..

J'ai créer une class myException qui hérite d'exception et je fais ceci :

try {
	$traduction = new traduction("fr");
	
	$trad = $traduction->getTrad("FORUM");

}
catch (MyException $e) { 
            echo $e -> getError(); 
} 

Et dans ma class traduction :

if(is_file(dirname(__FILE__)."/../languages/".$lng."/common.php")) {
	require_once(dirname(__FILE__)."/../languages/".$lng."/common.php");
} else {
	throw new myException ('Le dossier de langue ' . $lng . ' n\'existe pas');
}

Mais la j'utilise juste les exceptions..

Y'a mieux avec : trigger_error et set_error_handler ou alors avec les ErrorException ?

Merci encore

Exception et errorException = même mécanisme (regarder du côté de java peut aider)

en gros l'idée est souvent ceci :
une partie du programme génère une exception d'un type défini, cette exception est attrapée et géré mais peut-être pas directement à l'endroit appeler parfois on remontre de méthode en méthode... et finalement on le traite

try
{
//code générant potentiellement une exception
}
catch (typeException1 e)
{
}
catch (typeException2 e)
{
}
catch (typeException3 e)
{
}
catch (Exception e)
{
//toute exception est traitée ...
}

trigger_error et set_error_handler est différents. trigger_error génère une erreur php et set_error_handler sert à l'attraper.

Dans ton cas, de ce que je voix, la seul chose que tu désires c'est afficher le message d'erreur.... donc je dirait que ce que tu fais est suffisant ...

Pour répondre au titre du sujet, l'héritage multiple est impossible en PHP. Il y a moins d'utiliser des ruses de sioux à base de méthodes magiques (__call, __sey, __get), mais elles ne permettront pas de gérer les surcharges de propriétés / méthodes.

En suivant les conseils promulgué ici même voici ou j'en suis :

J'ai une classe myException qui hérite de exception.
J'ai une classe user ou j'ai le méthode connect (Vérifie si l'utilisateur et le mot de passe sont correcte)

	public function connect($pseudo,$password) {
	
		global $site_config;
		
		$login_attempt	= (isset($_SESSION['login_attempt']))? $_SESSION['login_attempt']: 0;
	
		if($login_attempt	>=	$site_config['max_log_attempt']) {
			return "ERR_MAX_LOGIN_ATTEMPT";
		}
		
		if(empty($pseudo) || empty($password)) {
			return "ERR_COMPLETE_FORM";
		}
		
		$password	= md5($password);
		
		if($this->loadProfil(0,true,$pseudo,$password)) {
			if($this->actif == 0) {
				return "ERR_ACCOUNT_DISABLE";
			} elseif($this->actif != 1) {
				return "ERR_ACCOUNT_ACTIF";
			} else {
				$_SESSION['login_attempt'] = 0;
				return $this->id;
			}
		
		} else {
			$_SESSION['login_attempt']++;
			return "ERR_UNABLE_TO_LOGIN";
		}
		
	}

Pour l'instant je retourne un string ( un code d'erreur, qui correspond en faite à une clef de traduction )

Je pourrais remplacer ces retour par :

throw new myException ("L'utilisateur n'a pas été trouvé",12);

Et gérer l'exception comme ceci :

	try {
		$user_id = $user->connect("Admin","12SD3456");
		$session->create($user_id,true);
	}
	catch ( MyException $e) {
	

Mais, je trouve ça moins pratique que le string de retour que je n'ai plus qu'a envoyé à ma class "Traduction"

Ai-je mal compris ?
Ou est, ici l'avantage d'utiliser une exception ? Code ne pouvant être que numérique.

Merci à vous

vu que c'est toi qui étends la class exception rien ne t'empêche d'ajouter des paramètres ...

sinon si ta méthode actuel te convient, pourquoi changer?

vu que c'est toi qui étends la class exception rien ne t'empêche d'ajouter des paramètres ...

Oui, en effet,

sinon si ta méthode actuel te convient, pourquoi changer?

Pour apprendre et faire ça bien !