Encore un problème avec les classes php quand je fais :

throw new Exception($this->query_error($req));

avec comme fonction query_error :

 public function query_error($req) {
 
 return "Erreur sql n°".mysql_errno()." : ".mysql_error()." <br /><br /> ".$req ;
 
 }

Il me retourne :
j'ai donc regarder le manuel

http://fr3.php.net/exceptions

qui me dis :

PHP 5 a une gestion des exceptions similaire à ce qu'offrent les autres langages de programmation. Une exception peut être lancée ("throw") et attrapée ("catch") dans PHP. Le code devra être entouré d'un bloc try pour faciliter la saisie d'une exception potentielle. Chaque try doit avoir au moins un bloc catch correspondant. Plusieurs blocs catch peuvent être utilisés pour attraper différentes classes d'exceptions. L'exécution normal (lorsque aucune exception n'est lancée dans le bloc try ou lorsqu'un catch correspondant à l'exception lancée n'est pas présent) continue après le dernier bloc catch défini dans la séquence. Les exceptions peuvent être lancées (ou relancées) dans un bloc catch.

et donc throw dans mon code est en noir et non en vert comme il devrait l'être (avec l'affichage des couleurs pour le code).

Et donc j'ai regarder ma version de php (histoire d'être sur) : 5.2.5

donc je ne comprends pas pourquoi il me retourne cette erreur...

As tu entouré ton code d'un try/catch ?

en effet il n'y a pas de try et catch mais je ne vois pas comment les implanter dans ma fonction

 // Fonction requete select sur la bdd
 public function aquery($select,$table,$join,$where) {

	$req = "SELECT $select FROM $table $join $where";

	if(!mysql_query($req)){ 
		
		throw new Exception($this->query_error($req));
	
	}else{
	
		$new_req = @mysql_query ($req);
	
		return mysql_fetch_array($new_req);
 	}

je fais un if / else tout basique mais il faudrait remplacer par try et catch ?

et je ne comprends pas pourquoi il met quand même la couleur grise au lieu de vert dans la coloration syntaxique.

En gros, pour attraper une exeption, au lieu de vérifier si la fonction s'est déroulé correctement après l'avoir effectué, tu utilise

try {
  mafonction(mesparamettres);
}
catch(Exception e) {
};

Dans ton cas,

ca deviendrait

try{
       $new_req=mysql_query($req);  
         
     
    }catch(Exception e){ 
        $e->query_error($req)
     }

Ensuite, continue ton code comme d'habitude. En gros, dans une classe, tu utilises throw new Exception et dans ton code, tu utilise try/catch

Ok donc c'est bien dans mon appel de classe qu'il faut verrifier si elle passe et ce a chaque fois que je fais appel a un objet de la classe contenant un throw new excpetion ?


j'ai remis ca dans la classe :

 // Fonction requete select sur la bdd
 public function aquery($select,$table,$join,$where) {

	$req = "SELECT $select FROM $table $join $where";

	if(!mysql_query($req)){ 
		
		throw new Exception($this->query_error($req));
	
	}else{
	
		$new_req = @mysql_query ($req);
	
		return $new_req;
 	}
 }

et ca dans l'appel de la fonction ::

	include("../_includes/php/classes/dbfactory.php");
	
	$connect = new dbquery();
	
	try{
		$connect->aquery('*','menu_titre','','');
	}
	catch(Exception $e)
	{
		$e->query_error($array);
	}
	
	while($arrayMenu = mysql_fetch_array($connect->aquery('*','menu_titre','','')))
	{
	?>
	<tr>			
	<td valign="top" class="menutitre"><? echo $arrayMenu['Titre']; ?><br>
		<?
		while($arraySmenu = $connect->aquery('*','menu_element','',"WHER Id_titre = '".$arrayMenu['Id']."' "))
		{
		?>
		<a href="<? echo $arraySmenu['Url']; ?>" target="principal" class="menu"><? echo $arraySmenu['Nom']; ?></a><br />
		<?
		}
		?>
	</td>
	</tr>
	<?
	}	

toujours la même erreur ...

Hey ,

Une exception est comme une bulle (ou un objet dans une bulle) qui remonte le code jusqu'à ce qu'on l'attrape. Faire directement :

try {
    throw new Exception('Message');
}
catch ( Exception $e ) {
    // quelque avec $e->getMessage()
}

n'a pas de sens.

Tu as un block try, c'est à dire : on essaye un code. Si ce code échoue, on a une erreur. Les erreurs sont des objets, c'est encore plus sympa car on peut construire nos propres exceptions et les capturer. Bien, mais comment est-ce qu'on doit s'en servir ? En gros, si tu as une classe, les exceptions doivent s'échapper de ton objet et tu les captures (via le block catch) à l'extérieur de ta classe. C'est un peu la manière générale de s'en servir. Quand tu soulèves (ou jettes) une exception, tu n'as pas à te soucier de sa capture : ni par qui, ni quand, ni où.

Avantage donc d'avoir des objets comme erreur : on peut les distinguer facilement. Un exemple :

// Soit :
class Requete_Ratee_Exception extends Exception {

    public function __construct ( $message, $code ) {

        parent::__construct($message, $code);
    }
}

// Alors, si on jette l'exception Requete_Ratee_Exception :
try {
    // code …
}
catch ( Requete_Ratee_Exception $e ) {
    // On est sûr que notre requête est ratée.
}
catch ( Exception $e ) {
    // Ici, notre requête n'a pas échoué, c'est donc autre chose ;
    // on a alors un autre traitement.
}

Si tu viens du monde Java, le mot-clé finally n'existe pas. En Java il désigne le dernier catch qui prendra toutes les exceptions. En PHP, on peut le remplacer par catch ( Exception $e ) car Exception est la classe la haute (le plus haut parent) de la famille des exceptions.

Ensuite, continue ton code comme d'habitude. En gros, dans une classe, tu utilises throw new Exception et dans ton code, tu utilise try/catch

Tout le code est à mettre dans le try et tu attrape les exceptions dans le catch, et ton try/catch, mets le directement dans ta fonction...tout simplement.

Donc je peux utliser le try / catch directement dans mes fonctions ou je dois l'utiliser dans le code uniquement ?

j'ai tenter, avec l'aide d'un tuto de faire :

 // Fonction requete select sur la bdd
 public function req_query($req) {
 
 	try {
 		$reponse = parent::query($req);
	}
	catch (query_report $e) {
			$e -> getError();
	}
 }	
}

et pour les exception de faire un rapport complet :

class query_report extends Exception {

	public function __contruct( $message, $code)
	{
		parent::__construct($message, $code );
	}
	
	 // Méthode retournant un message d'erreur complet et formaté.
    public function getError() {

        // On retourne un message d'erreur complet pour nos besoins.
        $return  = 'Une exception a été gérée :<br/>';
        $return .= '<strong>Message : ' . $this->getMessage() . '</strong><br/>';
        $return .= 'A la ligne : ' . $this->getLine() . '<br/>';
        
        return $return;
    }

}

et je ne comprends pas ton explication, sur la plupart des sites ou je regardes les exception ils disent essayer un code avec try et retourner l'erreur avec catch mais je ne comprends pas pourquoi tu met un 2ème catch dans le code, c'est le "s'il n'y a pas d'erreur, cela viens d'ailleurs" qui me gène.

Ce que je veux faire c'est d'avoir pour le moment (en pré prod) avoir les retour complet des messages d'erreurs, avec les lignes et message d'erreur sans avoir a interompre le reste du script, me rapporter clairement chaque erreur.

Une fois en prod de ne plus afficher les erreurs, seulement les reporter dans un fichier de log et ne pas afficher quoi que ce soit pour l'utilisateur (question de sécurité).

Pour l'instant j'en suis a la première partie et donc retourner un message d'erreur complet pour les erreurs ...