salut,
le mot clef return sert à indiquer ce que l'on souhaite retourner.
Tu ne peux l'utiliser qu'une seule fois.
Tu ne peux pas dire je retourne mes variables et elles sont dispo dans le code, cela va a l'encontre du modèle objet et de la séparation des responsabilités.
Je pense que tu devrais revoir les base de l'objet afin de mieux comprendre ce qui ne va pas dans ton code. Par exemple
http://www.lephpfacile.com/cours/24-la- ... ndamentaux
pour affecter quelque chose à une variable ou dans ton cas une propriété de la classe utilise simplement l'opérateur =
Pendant que j'y suis tu n'as pas besoin de boucle étant donnée que tu ne doivant qu'une seule ligne de données correspondant à un id ? (sinon c'est qu'il y a un soucis nan ? ;:)).
je suppose que le "Type" est un entier ? si oui pas besoin de ' en sql un entier n'est pas une chaîne de caractère (oui cela fonctionne dans ce cas mais ce n'est pas toujours le cas donc autant prendre le pli correctement.
vu que que tu es en apprentissage je te conseil ne pas utiliser l’extension mysql qui est vouée à disparaître (regarde dasn la doc ce qu'il en est dit) au profit des extensions mysql
i ou PDO.
Vu que tu lance dans l'objet autant le faire et aborder de suite les motifs de conception.
L'un d'entre, simple, s'appel DAO (data access objet) qui permet de gérer l'accès aux données (fichier, sgbd, stream, pigeon voyageur ou autre).
La dao va fournir des objet ou des listes d'objets correspondant à ta demande.
Dans ton cas tu aurais un objet "fiche" qui ne contient que les données et une class dao réalisant la requête sql.
un exemple que ce cela peux donner
<?php
class Fiche {
private $titre;
private $editeur;
public function __construct(){
}
/**
* @param mixed $editeur
*/
public function setEditeur($editeur) {
$this->editeur = $editeur;
}
/**
* @return mixed
*/
public function getEditeur() {
return $this->editeur;
}
/**
* @param mixed $titre
*/
public function setTitre($titre) {
$this->titre = $titre;
}
/**
* @return mixed
*/
public function getTitre() {
return $this->titre;
}
}
class FicheDao {
private $sgbdConn;
public function __construct( \PDO $sgbdConn) {
if(is_null($sgbdConn)){
throw new InvalidArgumentException('Connexion SGBD obligatoire');
}
$this->sgbdConn = $sgbdConn;
}
public function getFiche($id){
if(is_null($id) || !is_numeric($id)){
throw new InvalidArgumentException('Id null non accepté !');
}
$sql = 'SELECT * FROM Fiche_livre WHERE Type='.$this->sgbdConn->quote($id, PDO::PARAM_INT);
$result = $this->sgbdConn->query($sql);
if($result == false){
$e = $this->sgbdConn->errorInfo ();
throw new \Exception ( 'Erreur SQL : ' . $e [2], $this->sgbdConn->errorCode () );
}
$data = $result->fetchAll ( \PDO::FETCH_CLASS, 'Fiche' );
$result->closeCursor();
return $data[0];
}
}
// utilisation
$pdo = new PDO('mysql:host=localhost;dbname=testdb','user','password');
$ficheDao = new FicheDao($pdo);
$fiche = $ficheDao->getFiche(840);
echo $fiche->getTitre();
echo $fichier->getEditeur();
L'avantage c'est que tu code la dao une seule fois et la réutilisé quand tu en a besoin.
j'ai aussi introduit le conception "d'injection de dépendance" (par le constructeur).
C'est à dire que l'on injecte (fournit) l'objet permettant la connexion à la base de donnée.
Pourquoi ?
Parce que cela permet de ne faire cette connexion qu'une seule fois, tu ne ballade les identifiants partout dans le code et tu n'auras pas 14 connexion d'ouvertes les unes après les autres (même si, bon réflexe, tu clos la connexion l'ouverture et surement ce qui demande le plus de temps et donc ralentis inutilement le script
).
Je sais que c'est dense, surement mal expliqué, mais si tu te lance dans l'objet autant le faire bien des le départ sur tu va perdre l'utilité du concept
@+