ok, merci moogli...
pour les ereurs, j'i compris comment faire en revanche pour la factorisation je ne m'en sort pas, je vois bien le code qui se repete mais je ne comprend pas comment faire, peut tu me montrer un exemple ou un tuto, tous ce que je trouve sur google ne correspond pas a ce que je cherche...
je commence par corriger mon annerie précédente
<?php
$save = null;
while( $req){
if($save !== null && $req-> blog !== $save){ // on affiche le nouveau blog seulement le nouveau est différent de l'ancien et pas s'il est égale ;)
$save = $req->blog;
// affichage de la séparation
echo 'affichage du nouveau blog';
}
echo 'affichage du commentaire quelque soit le blog';
}
?>
quand à la factorisation :
tu a dans classe un bout de code qu se répète dans toutes tes méthodes
if ($critere !== null)
$critere = array_values($critere);
$select = $this->pdo->prepare($requete);
$select->execute($critere);
tu peux très bien partir du principe que ceci est "autonome" et qu'il peux être utiliser dans une méthode privée qui est appelée dans chaqu'une des autres méthodes.
Sur le même principe update et insert sont identiques (elles font exactement la même, même si les variables n'ont pas les mêmes nom
) on peux donc réduire l'utilisation de ces méthodes à une seule.
En regardant de plus pret on se rend compte que cette méthode peux être utilisée dans les autres.
ça peux donner ceci
<?php
class connexion {
private $host;
private $user;
private $pass;
private $conn;
private $pdo;
public function __construct($bdd = "genea_bdd") {
$this->host = "localhost";
$this->user = "root";
$this->pass = "";
$this->conn = "host={$this->host};dbname={$bdd}";
try {
$this->pdo = new PDO('mysql:'.$this->conn, $this->user, $this->pass);
$this->pdo->setAttribute(PDO :: ATTR_ERRMODE, PDO :: ERRMODE_EXCEPTION);
} catch (PDOException $e) {
// on lève une exception avec un message perso on affiche pas l'erreur à la barbare :)
throw new Exception('Connexion au serveur MySQL impossible : '. $e->getMessage());
}
}
// on fait les tests + requete et on retourne l'objet $select
// vérifie le comportement avec les update / insert
public function execQuery($critere, $requete){
if ($critere !== null)
$critere = array_values($critere);
else
throw new Exception('critère null normal ?');
if($requete === null)
throw new Exception('La requete ne peux être nul');
$select = $this->pdo->prepare($requete);
$ret = $select->execute($critere);
if ($ret === false){
$err = $this->pdo->errorInfo();
throw new PDOException('Erreur SQL : '.$errr[2]);
}
return $select;
}
// fonction pour rechercher un resultat unique
public function unique($critere, $requete) {
$select = $this->execQuery($critere, $requete);
$select->setFetchMode(PDO :: FETCH_OBJ);
$objet = $select->fetch();
return $objet;
}
// fonction pour faire une boucle
public function boucle($critere, $requete) {
$select = $this->execQuery($critere, $requete);
$select->setFetchMode(PDO :: FETCH_OBJ);
// retour les résultat dans un table et non l'objet car la vue ou autre n'a pas connaitre la "sauce" que tu utilise ;)
return $select->fetchAll();
}
// fonction pour comptre des champs
// Attention ça foncitonne pas tout le temps ça, il est préférable de faire un select count(*) si tu veux un truc plus universel
// ou un fetchAll + un count php
//
function compte($critere, $requete) {
$count = $this->execQuery($critere, $requete);
$nombre = $count->rowCount();
return $nombre;
}
/*
* // on supprime au profit de la méthode execQuery, on se fiche de savoir s'il s'agit d'un insert ou d'un update c'est pareil (à la limite idem pour un select / delete ;) )
public function insert($critere, $requete) {
$insert = $this->execQuery($critere, $requete);
}
public function update($critere, $requete) {
$update = $this->execQuery($critere, $requete);
}
*/
}
?>
au final tu n'a plus que
- ExecQuery : qui permet d’exécuter une requête (si si) a utiliser pour tous ce que tu veux
- Boucle : toujours la même chose, hors mis le fait que je lui fait retourner un tableau (d'objet) et non plus l'objet pdoStatement, cela permet de séparer completement la couche DAO (accès aux données) des autres (affichage ou métier) et donc tu pourra changer comme tu veux ta façon de faire pour les requêtes tant qu'elle retourne un tableau c'est pas un problème
- Unique : pareil, mais la j'airien fait, hors mis la factorisation
tu a 2 méthodes inutile en moins et une générique en plus
la factorisation c'est ça, ni plus ni moins. Dès que tu a un bout de code qui se répete tu le déporte dans une fonction, ou une méthode suivant le cas.
Tu peux même créer un objet pour cela si besoin, vois même, avec php 5.4, un trait qui va te permettre de faire des bibliothèque de fonction générique
(j'ai vue un article où le gars créer un trait permettant de créer un singleton générique pour les classes, tu a juste a passer ton constructeur en privé et utiliser le traits.
etc etc.
@+
[quote="juliette"]ok, merci moogli...
pour les ereurs, j'i compris comment faire en revanche pour la factorisation je ne m'en sort pas, je vois bien le code qui se repete mais je ne comprend pas comment faire, peut tu me montrer un exemple ou un tuto, tous ce que je trouve sur google ne correspond pas a ce que je cherche...[/quote]
je commence par corriger mon annerie précédente ;)
[php]<?php
$save = null;
while( $req){
if($save !== null && $req-> blog !== $save){ // on affiche le nouveau blog seulement le nouveau est différent de l'ancien et pas s'il est égale ;)
$save = $req->blog;
// affichage de la séparation
echo 'affichage du nouveau blog';
}
echo 'affichage du commentaire quelque soit le blog';
}
?>[/php]
quand à la factorisation :
tu a dans classe un bout de code qu se répète dans toutes tes méthodes
[php]if ($critere !== null)
$critere = array_values($critere);
$select = $this->pdo->prepare($requete);
$select->execute($critere);[/php]
tu peux très bien partir du principe que ceci est "autonome" et qu'il peux être utiliser dans une méthode privée qui est appelée dans chaqu'une des autres méthodes.
Sur le même principe update et insert sont identiques (elles font exactement la même, même si les variables n'ont pas les mêmes nom ;)) on peux donc réduire l'utilisation de ces méthodes à une seule.
En regardant de plus pret on se rend compte que cette méthode peux être utilisée dans les autres.
ça peux donner ceci
[php]<?php
class connexion {
private $host;
private $user;
private $pass;
private $conn;
private $pdo;
public function __construct($bdd = "genea_bdd") {
$this->host = "localhost";
$this->user = "root";
$this->pass = "";
$this->conn = "host={$this->host};dbname={$bdd}";
try {
$this->pdo = new PDO('mysql:'.$this->conn, $this->user, $this->pass);
$this->pdo->setAttribute(PDO :: ATTR_ERRMODE, PDO :: ERRMODE_EXCEPTION);
} catch (PDOException $e) {
// on lève une exception avec un message perso on affiche pas l'erreur à la barbare :)
throw new Exception('Connexion au serveur MySQL impossible : '. $e->getMessage());
}
}
// on fait les tests + requete et on retourne l'objet $select
// vérifie le comportement avec les update / insert
public function execQuery($critere, $requete){
if ($critere !== null)
$critere = array_values($critere);
else
throw new Exception('critère null normal ?');
if($requete === null)
throw new Exception('La requete ne peux être nul');
$select = $this->pdo->prepare($requete);
$ret = $select->execute($critere);
if ($ret === false){
$err = $this->pdo->errorInfo();
throw new PDOException('Erreur SQL : '.$errr[2]);
}
return $select;
}
// fonction pour rechercher un resultat unique
public function unique($critere, $requete) {
$select = $this->execQuery($critere, $requete);
$select->setFetchMode(PDO :: FETCH_OBJ);
$objet = $select->fetch();
return $objet;
}
// fonction pour faire une boucle
public function boucle($critere, $requete) {
$select = $this->execQuery($critere, $requete);
$select->setFetchMode(PDO :: FETCH_OBJ);
// retour les résultat dans un table et non l'objet car la vue ou autre n'a pas connaitre la "sauce" que tu utilise ;)
return $select->fetchAll();
}
// fonction pour comptre des champs
// Attention ça foncitonne pas tout le temps ça, il est préférable de faire un select count(*) si tu veux un truc plus universel
// ou un fetchAll + un count php
//
function compte($critere, $requete) {
$count = $this->execQuery($critere, $requete);
$nombre = $count->rowCount();
return $nombre;
}
/*
* // on supprime au profit de la méthode execQuery, on se fiche de savoir s'il s'agit d'un insert ou d'un update c'est pareil (à la limite idem pour un select / delete ;) )
public function insert($critere, $requete) {
$insert = $this->execQuery($critere, $requete);
}
public function update($critere, $requete) {
$update = $this->execQuery($critere, $requete);
}
*/
}
?>
[/php]
au final tu n'a plus que
[list=méthode restante]
[*] ExecQuery : qui permet d’exécuter une requête (si si) a utiliser pour tous ce que tu veux :)
[*] Boucle : toujours la même chose, hors mis le fait que je lui fait retourner un tableau (d'objet) et non plus l'objet pdoStatement, cela permet de séparer completement la couche DAO (accès aux données) des autres (affichage ou métier) et donc tu pourra changer comme tu veux ta façon de faire pour les requêtes tant qu'elle retourne un tableau c'est pas un problème :)
[*] Unique : pareil, mais la j'airien fait, hors mis la factorisation
[/list]
tu a 2 méthodes inutile en moins et une générique en plus :)
la factorisation c'est ça, ni plus ni moins. Dès que tu a un bout de code qui se répete tu le déporte dans une fonction, ou une méthode suivant le cas.
Tu peux même créer un objet pour cela si besoin, vois même, avec php 5.4, un trait qui va te permettre de faire des bibliothèque de fonction générique ;) (j'ai vue un article où le gars créer un trait permettant de créer un singleton générique pour les classes, tu a juste a passer ton constructeur en privé et utiliser le traits.
etc etc.
@+
