( ! ) Fatal error: Call to undefined function hydrate() in C:\wamp\www\backend\class.php on line 8
Call Stack
#
Time
Memory
Function
Location
1
0.0036
244016
{main}( )
..\class.php:0
<?php
class Modele {
private $_modele;
private $_modele2;
private $_prix;
private $_chambre;
private $_garage;
private $_garage_piece;
const MODELE_25721 = 25721;
public function hydrate(array $row) {
foreach ($row as $k => $v) {
$method = 'set'.ucfirst($k);
}
if( method_exists($this,$method) ){
$this->$method($v);
}
}
public function __construct($modele,$modele2,$prix,$chambre,$garage,$garage_piece) {
$this->setModele($modele);
$this->setModele2($modele2);
$this->setPrix($prix);
$this->setChambre($chambre);
$this->setGarage($garage);
$this->setGarage_piece($garage_piece);
}
/* setter */
public function setModele($modele) {
if(!is_numeric($modele)){
trigger_error('le modele doit etre un nombre', E_USER_WARNING);
return;
}
$this->_modele = $modele;
}
public function setModele2($modele2) {
if(!is_numeric($modele2)){
trigger_error('le modele 2 chambre doit etre un nombre', E_USER_WARNING);
return;
}
$this->_modele2 = $modele2;
}
public function setPrix($prix) {
if(!is_numeric($prix)){
trigger_error('le prix doit etre un nombre', E_USER_WARNING);
return;
}
$this->_prix = $prix;
}
public function setChambre($chambre) {
if(!is_numeric($chambre)){
trigger_error('le noombre de chambre doit etre un nombre', E_USER_WARNING);
return;
}
$this->_chambre = $chambre;
}
public function setGarage($garage) {
if(!is_numeric($garage)){
trigger_error('la variable garage doit etre un nombre', E_USER_WARNING);
return;
}elseif($garage < 0 || $garage > 1) {
trigger_error('la variable garage doit etre 1 ou 0', E_USER_WARNING);
return;
}
$this->_garage = $garage;
}
public function setGarage_piece($garage_piece) {
if(!is_numeric($garage_piece)){
trigger_error('la variable garage piece doit etre un nombre', E_USER_WARNING);
return;
}elseif($garage_piece < 0 || $garage_piece > 1) {
trigger_error('la variable garage piece doit etre 1 ou 0', E_USER_WARNING);
return;
}
$this->_garage_piece = $garage_piece;
}
/* getter */
public function modele() { return $this->_modele; }
public function modele2() { return $this->_modele2; }
public function prix() { return $this->_prix; }
public function chambre() { return $this->_chambre; }
public function garage() { return $this->_garage; }
public function garage_piece() { return $this->_garage_piece; }
}
$req = bdd()->query('SELECt modele,modele2,prix,chambre,garage,garage_piece FROM modele');
$rows = $req->fetchall(PDO::FETCH_ASSOC) ;
foreach( $rows as $row ) {
$modele = new Modele(hydrate($row));
echo 'modele : '.$modele->modele().'<br>';
}
- Edité par Lavoie005 10 juillet 2017 à 19:41:29
On se met la pression grave, mais y restera quoi le jour où on crèvera!
La politesse n'est pas un luxe ... Nous sommes là pour t'aider, mais il est plus agréable de répondre à quelqu'un de poli qu'à quelqu'un qui pose sa question brute ...
Après pour ton problème, il faut revoir un peu PHP ... Tu ne peux pas appeler la méthode d'une classe lors de l'instanciation ...
D'abord tu instancies, et ensuite tu appelles la méthode ...
Mais dans ton cas, c'est ta classe qui paraît tordue ... Le constructeur prend plusieurs paramètres qui semble être les mêmes que ceux contenus dans le tableau $row ...
Ta méthode hydrate est redondante avec le constructeur ... Soit tu supprimes la méthode hydrate, soit tu vides le constructeur ...
parfait donc c'est un ou l'autre, il est plus flexible d'utilisé hydrate que construct puisqu'il s'ajuste automatiquement avec l'ajout dans la base de données?
avec le constructeur on doit le mettre a jour manuellement si on modifie la BDD ou l'objet, c'est bien ça?
voici se que l'auteur explique : Il est courant d'implémenter un constructeur à ces classes demandant un tableau de valeurs pour qu'il appelle ensuite la fonction d'hydratation afin que l'objet soit hydraté dès sa création, comme on l'a vu au début de ce chapitre.
puis-je avoir une exemple?
- Edité par Lavoie005 11 juillet 2017 à 21:26:48
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Il est plus logique de remplir les valeurs de ton objet lors de sa construction que de le faire plus tard, mais une fonction hydrate peut servir dans certains cas (je n'en ai aucun sous la main, désolé, je laisse les exemples à ceux qui viendront expliquer).
Donc, dans ce cas, oui, hydrate ne sert à rien, mais il faut savoir que c'est possible de le faire avec.
si hydrate est utile car elle permet de donner au constructeur un tableau (vide ou plein). De là, si ton tableau contient des données, le constructeur va appeler hydrate et lui passer le tableau pour que ton objet créé soit avec les bonnes valeurs.
Dans beaucoup de mes projets, j'utilise hydrate de façon différentes:
Lorsque la donnée provient de la BDD, le constructeur appelle la méthode pour poser les bonnes données,
Lorsque je dois insérer une nouvelle donnée en base, je créé un objet vide, puis je lui passe les données provenant du formulaire (d'inscription par exemple), hydrate va les intégrer et les setter feront leur travail de test et lèveront (ou pas) des exception si il y a des problème. UNe fois le nouvel objet créé je le charge dans la base de données.
Voilà en gros les deux fonctions que je donne à hydrate.
J'ai un code que je voudrais amélioré si vous pouvez m'aider sa serais apprécier merci à l'avance.
J'ai créer un foreach pour ma fonction update afin de créer une seul ligne pour tous mes colonnes dans ma BDD pour la fonction BindValue.
Mais je ne sais pas comment m'y prendre pour le faire dans la fonction PREPARE afin quel s'ajuste automatiquement avec ma BDD.
Voici mon code si ma question n'est pas claire laisse moi le savoir.
<?php
public function update(LaveVaisselle $laveVaisselle) {
// Je selection toute les colonne de la DB
$arr = $this->_db->query('SELECT * FROM lave_vaisselle');
$row = $arr->fetch(PDO::FETCH_ASSOC);
//Je cree la requete de modification mais je sais pas comment lui assigné mes valeur avec $k
$q = $this->_db->prepare('UPDATE lave_vaisselle SET modele = :modele, serie = :serie, marque = :marque, fonctionne = :fonctionne, couleur = :couleur, interieur = :interieur, plaque_electrique = :plaque_electrique, plaque = :plaque, abime = :abime, panier = :panier, roulette = :roulette, prix_achat = :prix_achat, prix_vente = :prix_vente, date_achat = :date_achat, date_vente = :date_vente, prix_gas_achat = :prix_gas_achat, prix_gas_vente = :prix_gas_vente, note = :note WHERE id = :id');
//Je fais une boucle pour avoir tous les donné
foreach($row as $k => $v) {
$q->bindValue(':'.$k, $laveVaisselle->$k() );
}
$q->execute();
}
- Edité par Lavoie005 27 juillet 2017 à 5:05:52
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Salut, pourquoi pour hydrater ta class tu ne te sers pas des outils natifs de PDO :
Exemple :
class MyModel {
protected $id;
protected $otherField;
// ...
}
try {
$sth = $pdo->prepare("SELECT * FROM my_table");
$sth->execute();
// ici un array contenant des objets MyModel hydratés avec les champs de ta db
$myModels = $sth->fetchAll(PDO::FETCH_CLASS, MyModel::class);
} catch (\Exception $e) {
}
De plus, tu as mis des "_" sur les propriétés(ex: $_ma_property), cela j'imagine pour identifier tes propriétés privé. Hors cela n'est pas correcte si tu veux respecter les normes PSR de PHP, je t'invite à les virer.
Dans ta méthode "hydrate" tu fais un ucfirst pour retrouver le nom de tes méthodes, mais cela ne marchera pas puis ce que tu as des propriétés avec deus underscore(ex : $_garage_piece).
Bah les conventions OO sont de mettre un underscore pour indiquer que l'attribut est privé, et ce bien avant le commencement du développement de PHP (OO ou non) donc le PSR de PHP, il ferait mieux d'harmoniser avec le standard
Bah les conventions OO sont de mettre un underscore pour indiquer que l'attribut est privé, et ce bien avant le commencement du développement de PHP (OO ou non) donc le PSR de PHP, il ferait mieux d'harmoniser avec le standard
++
Bah non pas accord avec toi, il existe des conventions et je m'en sers tous les jours, peut-être un peut de doc à lire ? http://www.php-fig.org/psr/
Les conventions OO sont faites pour le C, les autres langages sont des dérivés. Si tu es alaise avec des bons framework comme symfony ou les gros acteurs du langage PHP par exemple, tu remarqueras que ton code n'est pas "conventionnel". Quitte à apprendre, autant le faire bien
puis que toute les getters sont des copier coller de ma key BDD?
Meme principe pour les variable private?
comme ceci?
<?php
$q = bdd()->query('SELECT * FROM lave_vaisselle');
$row = $q->fetch(PDO::FETCH_ASSOC);
Class LaveVaisselle {
/* Getter */
foreach($rows as $k => $v) {
public function $k() { return $this->_$k ;}
}
public function id() { return $this->_id ;}
public function modele() { return $this->_modele ;}
public function serie() { return $this->_serie ;}
public function marque() { return $this->_marque ;}
public function fonctionne() { return $this->_fonctionne ;}
public function couleur() { return $this->_couleur ;}
public function interieur() { return $this->_interieur ;}
public function plaque_electrique() { return $this->_plaque_electrique ;}
public function plaque() { return $this->_plaque ;}
public function abime() { return $this->_abime ;}
public function panier() { return $this->_panier ;}
public function roulette() { return $this->_roulette ;}
public function prix_achat() { return $this->_prix_achat ;}
public function prix_vente() { return $this->_prix_vente ;}
public function date_achat() { return $this->_date_achat ;}
public function date_vente() { return $this->_date_vente ;}
public function prix_gas_achat() { return $this->_prix_gas_achat ;}
public function prix_gas_vente() { return $this->_prix_gas_vente ;}
public function note() { return $this->_note ;}
}
- Edité par Lavoie005 28 juillet 2017 à 8:12:55
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Ta classe est une sorte de template. Excepté pour Static, tout n'est que du déclaratif: tu dis que telle ou telle méthode existe, mais ladite méthode ne sera exécutée que quand tu l'appellera toi-même.
Surtout tu lie la classe et une connexion à la base, bien de quoi se prendre les pieds dans le tapis, 1 classe == 1 responsabilité, dans ton cas 2 => pas bon.
Si ta classe décrit une table, tu créée une connexion, tu fais la requete puis tu utilises ta techniques.
EDIT: ou alors j'ai pas compris ton exemple
m_12_u a écrit:
Yep, pourquoi tu fais pas simplement ça, ta class est automatiquement hydraté...
<?php
$q = bdd()->query("SELECT * FROM lave_vaisselle LIMIT 1");
$row = $q->fetch(PDO::FETCH_CLASS, LaveVaisselle::class);
Class LaveVaisselle
{
private $_id;
private $_modele;
private $_serie;
private $_marque;
private $_fonctionne;
private $_couleur;
private $_interieur;
private $_plaque_electrique;
private $_plaque;
private $_abime;
private $_panier;
private $_roulette;
private $_prix_achat;
private $_prix_vente;
private $_date_achat;
private $_date_vente;
private $_prix_gas_achat;
private $_prix_gas_vente;
private $_note;
/**
* @return mixed
*/
public function getId()
{
return $this->_id;
}
/**
* @param mixed $id
* @return LaveVaisselle
*/
public function setId($id)
{
$this->_id = $id;
return $this;
}
/**
* @return mixed
*/
public function getModele()
{
return $this->_modele;
}
/**
* @param mixed $modele
* @return LaveVaisselle
*/
public function setModele($modele)
{
$this->_modele = $modele;
return $this;
}
/**
* @return mixed
*/
public function getSerie()
{
return $this->_serie;
}
/**
* @param mixed $serie
* @return LaveVaisselle
*/
public function setSerie($serie)
{
$this->_serie = $serie;
return $this;
}
/**
* @return mixed
*/
public function getMarque()
{
return $this->_marque;
}
/**
* @param mixed $marque
* @return LaveVaisselle
*/
public function setMarque($marque)
{
$this->_marque = $marque;
return $this;
}
/**
* @return mixed
*/
public function getFonctionne()
{
return $this->_fonctionne;
}
/**
* @param mixed $fonctionne
* @return LaveVaisselle
*/
public function setFonctionne($fonctionne)
{
$this->_fonctionne = $fonctionne;
return $this;
}
/**
* @return mixed
*/
public function getCouleur()
{
return $this->_couleur;
}
/**
* @param mixed $couleur
* @return LaveVaisselle
*/
public function setCouleur($couleur)
{
$this->_couleur = $couleur;
return $this;
}
/**
* @return mixed
*/
public function getInterieur()
{
return $this->_interieur;
}
/**
* @param mixed $interieur
* @return LaveVaisselle
*/
public function setInterieur($interieur)
{
$this->_interieur = $interieur;
return $this;
}
/**
* @return mixed
*/
public function getPlaqueElectrique()
{
return $this->_plaque_electrique;
}
/**
* @param mixed $plaque_electrique
* @return LaveVaisselle
*/
public function setPlaqueElectrique($plaque_electrique)
{
$this->_plaque_electrique = $plaque_electrique;
return $this;
}
/**
* @return mixed
*/
public function getPlaque()
{
return $this->_plaque;
}
/**
* @param mixed $plaque
* @return LaveVaisselle
*/
public function setPlaque($plaque)
{
$this->_plaque = $plaque;
return $this;
}
/**
* @return mixed
*/
public function getAbime()
{
return $this->_abime;
}
/**
* @param mixed $abime
* @return LaveVaisselle
*/
public function setAbime($abime)
{
$this->_abime = $abime;
return $this;
}
/**
* @return mixed
*/
public function getPanier()
{
return $this->_panier;
}
/**
* @param mixed $panier
* @return LaveVaisselle
*/
public function setPanier($panier)
{
$this->_panier = $panier;
return $this;
}
/**
* @return mixed
*/
public function getRoulette()
{
return $this->_roulette;
}
/**
* @param mixed $roulette
* @return LaveVaisselle
*/
public function setRoulette($roulette)
{
$this->_roulette = $roulette;
return $this;
}
/**
* @return mixed
*/
public function getPrixAchat()
{
return $this->_prix_achat;
}
/**
* @param mixed $prix_achat
* @return LaveVaisselle
*/
public function setPrixAchat($prix_achat)
{
$this->_prix_achat = $prix_achat;
return $this;
}
/**
* @return mixed
*/
public function getPrixVente()
{
return $this->_prix_vente;
}
/**
* @param mixed $prix_vente
* @return LaveVaisselle
*/
public function setPrixVente($prix_vente)
{
$this->_prix_vente = $prix_vente;
return $this;
}
/**
* @return mixed
*/
public function getDateAchat()
{
return $this->_date_achat;
}
/**
* @param mixed $date_achat
* @return LaveVaisselle
*/
public function setDateAchat($date_achat)
{
$this->_date_achat = $date_achat;
return $this;
}
/**
* @return mixed
*/
public function getDateVente()
{
return $this->_date_vente;
}
/**
* @param mixed $date_vente
* @return LaveVaisselle
*/
public function setDateVente($date_vente)
{
$this->_date_vente = $date_vente;
return $this;
}
/**
* @return mixed
*/
public function getPrixGasAchat()
{
return $this->_prix_gas_achat;
}
/**
* @param mixed $prix_gas_achat
* @return LaveVaisselle
*/
public function setPrixGasAchat($prix_gas_achat)
{
$this->_prix_gas_achat = $prix_gas_achat;
return $this;
}
/**
* @return mixed
*/
public function getPrixGasVente()
{
return $this->_prix_gas_vente;
}
/**
* @param mixed $prix_gas_vente
* @return LaveVaisselle
*/
public function setPrixGasVente($prix_gas_vente)
{
$this->_prix_gas_vente = $prix_gas_vente;
return $this;
}
/**
* @return mixed
*/
public function getNote()
{
return $this->_note;
}
/**
* @param mixed $note
* @return LaveVaisselle
*/
public function setNote($note)
{
$this->_note = $note;
return $this;
}
}
- Edité par m_12_u il y a 31 minutes
- Edité par christouphe 28 juillet 2017 à 16:11:26
Donc je auis obliger de déclarer chaque method et chaque attribu 1 par 1, je peut pas créé une boucle pour les ajuster automatiquement a ma BDD? Désolé l'expression mes c'est bin de la marde lol
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Il ne faut pas oublier qu'un programme, c'est à la base idiot. Tous ces outils, paradigmes, langages ont chacun des features permettant plus ou moins de fonctionnalités selon le domaine mais aucun ne fera tout.
Et une classe est une template contenant des fonctions, des attributs, des méthodes etc, et le système a besoin de charger ces templates afin de pouvoir construire des objets à partir de ces templates plus tard. Si tu commence à ajouter des instructions qui doivent s'exécuter et qui, potentiellement, dépendront d'autres de ces objets (donc templates), tu n'en finis plus de tenter d'exécuter du code qui n'existe pas encore (normal vu que ta template n'est pas encore créée, mais est en train de l'être)
Si tu veux faire autrement, je t'invite à consulter quelques oeuvres détaillant des paradigmes de programmation et à faire ton propre langage permettant ce genre de choses.
Tu te rendra bien vite compte qu'en fait, ce n'est pas si... "facile" à faire et que ces langages ne le permettent pas pour de très bonnes raisons.
Vu que la conversation n'alimente plus rien d'utile et que tu ne semble pas avoir d'autres questions, je t'invite à mettre ton sujet en "Résolu".
- La classe représente une "entité"(une chose qui existe au sens tangible), n'y plus n'y moins. - Hydrater une "entité", une class, ne représente aucun effort avec PDO. - Je suis d'accord avec christouphe, une class, une responsabilité. Dans mon exemple il n'y a rien de "lié", je comprend pas trop...C'est juste une class, l'appel PDO est forcément dans le même "exemple", mais c'est pour l'exemple
Cela dit, si tu veux pas te taper toutes les méthodes(tes accesseurs), tu peux utiliser la méthode magique(ci-dessous). Cette technique a cependant le désavantage d'être gourmande en mémoire, comme toutes les méthodes "magique".
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Keep It Simple Stupid - SF4 conf Swift - Cours 1/4 SF4 - Exceptions PDO - Formes Normales
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Keep It Simple Stupid - SF4 conf Swift - Cours 1/4 SF4 - Exceptions PDO - Formes Normales
Keep It Simple Stupid - SF4 conf Swift - Cours 1/4 SF4 - Exceptions PDO - Formes Normales
On se met la pression grave, mais y restera quoi le jour où on crèvera!
Keep It Simple Stupid - SF4 conf Swift - Cours 1/4 SF4 - Exceptions PDO - Formes Normales
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!
On se met la pression grave, mais y restera quoi le jour où on crèvera!