Parole d'un prof de métier: la meilleure façon d'apprendre et de maîtriser est de l'expliquer ou d'enseigner. Bref, il y a un côté égoiste dans cet humanisme!
Bon, vite fait, après avoir écrit un roman, je simplifie ma réponse finale: ce bout n'est pas à comprendre tant que cela pour le moment. Ça va s'éclairer si tu persistes et fais d'autres cours: celui sur le framework Symfony m'éclaire.
$api: réfère aux API, des interfaces ou programmes qui permettent à des composantes qui utilisent souvent des langages différents d'interagir. Il y a un cours sur les Api sur OC et de nombreuses explications sur le Net.
Ici, $api est un attribut qui désigne le nom de l'api qui est unique dans ce framework: 'PDO' comme tu le verras dans le constructeur du BackController. Et dans le fait qu'on a PDOFactory.php qui ne donne qu'un api possible PDO. On a vu dans une leçon de ce cours une classe du genre qui donnait l'option entre les interfaces PDO et MySQLI, il me semble. Ce sont 2 APIS différentes qui font le même genre de travail: permettre l'interaction entre une appli et une bdd.
$dao: le mot vient de DAO Data Access Object. Quand on fait new PDO, c'est justement un DAO qu'on initie. $dao est donc l'objet PDO instancié qui va permettre d'interagir avec la bdd. Bon c'est un peu compliqué et je ne suis pas encore sûr de tout comprendre ce qu'implique ce dao. Enfin, pour sûr, il a l'adresse de la bdd et ses accès via la seule fonction de PDOFactory qui initie et renvoie ce DAO (new PDO). Le réglage des paramètres de la parenthèse dans cette ligne $db = new \PDO('mysql:host=localhost;dbname=news', 'root', ''); est critique, sinon on va avoir une erreur fatale.
Managers.php est le manager des managers (plus spécifiquement de ceux qu'on peut ici instancier: CommentManagerPDO et NewsManagerPDO). C'est une classe instanciée quand un contrôleur est appelé et instancié après que la route ait été vérifiée par le Router.php.
Managers, au moment de son instanciation, récupère dans une variable attribut le $dao ou PDO object. Fais un var_dump($this->managers); exit; au début de n'importe quelle fonction executeAction() dans un des 2 contrôleurs pour t'en rendre compte. Promène cette ligne après celles qui contiennent $this->managers->getManagerOf(. Tu verras notre $this->managers s'enrichir de valeurs.
Tu verras là que «protected $managers =[]» peut être vide ou contenir un array 'news' => OBJECT PDO qui correspond à l'objet manager des news. Ou celui des commentaires ou les deux.
Manager.php est la classe grand-mère abstraite des managers spécifiques. A chaque instanciation de CommentManagerPDO et NewsManagerPDO qui se font dans le getManagerOf() justement, ces managers récupèrent, via la classe abstraite Manager.php qui a un constructeur, le $dao objet PDO pour l'utiliser. Regarde les "extends" qui relient toutes ces classes qui concernent les managers. ex: CommentsManagerPDO extends CommentsManager extends Manager.
Managers a une unique fonction qui permet d'appeler un manager. Protected $manager représente le ou les managers appelés que le gestionnaire garde dans sa mémoire temporaire d'objet pendant une requête.
Bref, $managers = 'News' => Object PDO après avoir appelé le manager des news. Pas avant.
Et pour finir:$this->managers[$module] = new $manager($this->dao);
La ligne devant cette ligne précise ce que contient $manager qu'on instancie: c'est le chemin menant à un des manager qu'on peut appeler. $$manager, c'est pour le moment CommentsManagerPDO ou NewsManagersPDO. C'est la ligne qui instancie le manager dont on a besoin qui est retourné par la fonction getManagerOf() de la classe Managers. Managers sert à faire cette ligne! Envoyer le bon manager. Et à passer le $dao (l'objet PDO) à ce manager des commentaires ou des news, son lien avec la BDD.
En terminant, il faut comprendre de ce rayon des managers que c'est une architecture de classes qui s'emboitent et se passent des variables qui permettrait d'intégrer des options (permettre de choisir une interface ou une autre, de choisir une bdd ou une autre théoriquement. Ces options, tu les auras quand tu seras capable un jour de choisir tes librairies, de les installer et de les utiliser dans ta programmation. Les frameworks offrent ce genre de possibilités et de choix, car il y a différentes cultures de programmation et différents besoins. En fait, on a juste à comprendre le principe. Ici, dans ce cours, pour comprendre un peu ou enfin appréhender le concept, on doit jouer dans des fichiers de la librairie. Je ne crois pas qu'on va normalement jouer dans des classes comme Page.php ou HTTPResponse.
En réalité, avec un framework, on ne va même plus savoir si c'est PDO ou MYSQLI qui est utilisé par le framework, on voudra juste savoir comment appeler le manager dont on a besoin et les commandes qu'on peut lui faire. On ira jamais toucher à une classe comme CommentManagerPDO.php.
Voilà, je ne sais pas si mon explication ou mes réponses sont compréhensibles, c'est compliqué!
Bon, l'enjeu de ce cours est de faire un cache. Évidemment, il faut décortiquer ce dans quoi on patauge. Mais les Managers ne sont pas le gros du problème à mon sens!
Merci Chat Botté. En effet tes explications sont très bien agencées et cela m'a permis enfin de comprendre ce framwork. Effectivement avec tes explications, je vois maintenant les sujets pour lesquels je manque de connaissance et je vais très vite y remédier. Tu as pris du tempt pour me répondre promptement et bien je te remercie.
Juste pour apporter mon grain de sel, étant donné le nombre de messages se plaignant de la difficulté de la partie 3 du cours :
Je suis bien d'accord avec vous, c'est vraiment un niveau au-dessus du reste; des fonctions et des classes semblent sortir de nulle part, on ne comprend pas bien comment va fonctionner l'application, comment vont interagir les classes entre elles...
En ce qui me concerne, il m'a fallu recopier le code deux fois pour comprendre la logique de fonctionnement. La première fois, j'ai bêtement réécrit les lignes de chaque fichier en ayant la frustration, à chaque ligne tapée, de ne pas savoir comment allaient s'agencer toutes mes classes et mes méthodes. On nous parle soudainement d'application (j'ai tout de suite imaginé quelque chose comme une application mobile, qu'il y en avait donc une seule pour un projet), ensuite on apprend qu'il y en a plusieurs, etc.
La seconde fois j'ai pris le temps de comprendre chaque fonction en l'écrivant. Aller jusqu'au bout du TP permet de comprendre par la suite comment va fonctionner le coeur de l'application.
Si ça peut vous aider, je vais décortiquer le fonctionnement de l'application en y allant étape par étape, pour charger une page :
- L'utilisateur accède au site web
- Un fichier .htaccess va faire pointer toutes les URL possibles sur votre fichier bootstrap.php (j'aurais bien aimé qu'on me l'explique lorsque la notion de routeur a été abordée)
- La suite, c'est bootstrap.php qui la prend en charge. Ce fichier est là pour mettre en place le chargement automatique de vos classes, récupérer leurs namespaces et instancier votre application selon que vous souhaitez accéder à la partie publique (Frontend) ou la partie administration (Backend). L'instanciation de l'application est faite via une variable $_GET qui par défaut sera http://nomdedomaine.com/boostrap.php?app=frontend. On distingue deux application dans ce TP, car les fonctionnalités, le CSS et le code HTML des parties admin et publique ne seront pas les mêmes
- A partir de là, bootstrap.php sait quelle application il faut instancier. On considère pour la suite que c'est l'application Frontend qui sera instanciée. On l'exécute par le biais de la méthode run()
- ApplicationFrontend, qui hérite de la classe abstraite Application est alors instanciée. Son rôle est juste d'appeler le contrôleur, qui aura pour but de mettre en relation les modèles (toute la gestion de la base de données) par l'attribut "$managers" et les vues (le code HTML isolé de chaque page), puis d'indiquer quelle page il faut afficher, selon l'URL, par l'attribut "$page". Elle instanciera aussi tous les objets composants de l'application qui vous serviront, entre autres, dans votre contrôleur et votre vue pour créer la logique de votre code.
La méthode getController() de la classe Application, qui permet donc d'appeler le contrôleur correspondant à l'URL, analyse les routes que vous avez saisies dans votre fichier routes.xml, par les classes Routes(qui n'est rien de pus qu'une entité) et Router, puis récupère le module correspondant et l'action. Par exemple, on est situé sur l'adresse www.nomdedomaine.com/news. Grâce au fichier routes.xml qui a été bien renseigné, on sait que l'adresse "news" correspond au module de news et à l'action "index" qui permettra de lister toutes nos news.
La méthode getController() va récupérer ces informations, puis les transmettre au constructeur du contrôleur correspondant au module news en allant le chercher par le chemin "App/Frontend/Modules/News/NewsController.php"
- La suite, c'est le contrôleur qui s'en occupe. Lors de son instanciation, il hydrate tout seul ses attributs "action", "module" et "vue" par les méthodes setX() et instancie un nouvel objet des classes Page et Managers. La méthode setView() est importante car c'est elle qui va dire à l'objet page quelle vue est à inclure dans la page web, et quel fichier il faut aller charger grâce aux attributs "$action" et "$module".
- Pour résumer jusqu'ici : dans bootstrap.php, on appelle l'application voulue et on l'exécute par la méthode run(). Celle-ci appelle d'abord le contrôleur correspondant à l'URL via getController(), puis exécute l'action (ici, index) par la méthode execute() de la classe abstraite BackController, dont sont pourvus tous les contrôleurs de chaque module, puisqu'ils héritent de cette classe.
La logique est que chaque action d'un module sera nommée ainsi, dans son contrôleur : "executeAction", ici executeIndex. La méthode execute() du contrôleur instancié, ici NewsController, va tout simplement appeler la fonction correspondante à l'action, donc executeIndex() de NewsController.
- Le contrôleur correspondant au module a donc été appelé, et sa méthode execute() héritée du back controller appelle sa méthode executeIndex(). Ici, on se servira de l'attribut "$managers" pour récupérer la liste des news, les utilisateurs l'ayant rédigée, etc., dans la base de données.
Les méthodes correspondant aux actions ont pour but de traiter les données renvoyées par les modèles (les managers), puis d'envoyer ce qu'il y a à afficher à la page par la méthode addVar() de la classe Page.
- Pour ce qui est des managers, on a une classe Managers qui a pour rôle d'appeler le manager correspondant au module, ici, NewsManagerPDO. Lorsqu'on instancie la classe Managers, lors de l'appel de notre contrôleur donc, puisque c'est ce qu'on a défini dans le constructeur de la classe BackController, on lui précise l'"API" et le "DAO".
En gros, vu qu'on travaille avec PDO pour interagir avec notre BDD, dans ce TP, il faut préciser que l'API qu'on utilise s'appelle "PDO" et qu'on retrouvera ce mots à la fin de nos noms de classes de managers. En second paramètre, on renvoie la méthode getMysqlConnection() de notre classe PDOFactory qui initialise la connexion à la BDD. Cette façon de faire présente l'intérêt de n'avoir qu'une ligne de code à changer, si, pour un autre projet, on travaille avec un autre gestionnaire de BDD.
On écrirait donc, dans notre BackController :
$managers = new Managers('Une autre interface de gestion de BDD', AutreInterface::GetConnection()).
On a également la classe abstraite Manager, sans "s", dont héritera chaque manager, qui est ici pour que nous n'ayons pas à réécrire dans chaque manager qu'il faut passer lui passer l'objet PDO (le DAO, la connexion à la BDD quoi) à chaque instanciation pour pouvoir faire nos requêtes correctement...
Le TP veut ensuite que pour le manager de chaque module, il faille deux classes.
Par exemple, pour le module de news, on créera une classe "NewsManager" et une autre "NewsManagerPDO". La première hérite de la classe Manager, et la seconde hérite de NewsManager. Dans le cas où on travaillerait avec plusieurs interfaces de gestion de BDD, on aurait les fichiers :
C'est donc dans le but de ne pas avoir à réécrire les mêmes lignes, les mêmes méthodes et les mêmes attributs dans chaque fichier de chaque API qu'on créée une classe abstraite ModuleManager, puis une classe à instancier ModuleManagerPDO
- Le manager NewsManagerPDO contiendra toutes les requêtes SQL pour récupérer la liste de news, récupérer une seule news, en supprimer une, en ajouter une, en modifier une, etc. C'est tout
- C'est le contrôleur qui a pour but de dire, "OK, on est sur le module de news, la route de l'URL m'indique qu'on veut lister toutes les news, ma méthode executeIndex() doit donc faire appel au manager voulu en utilisant mon attribut $managers instancié plus tôt, et sa fonction getManagerOf('News'), ensuite je fais appel à sa méthode listerLesNews() qui va, telles qu'on l'a écrite, va me renvoyer des instances de l'entité News. A partir de là, je serai capable de faire des opérations et des vérifications sur mes données et de les transmettre à ma page."
Une entité, c'est un objet, comme Personnage, News, Commentaire ou autre. Il contient tout simplement les informations propres à votre objet. Dans notre cas, le titre de la news, son id, son contenu, sa date d'ajout, etc.
Les entités sont utilisées un peu partout, notamment lorsque PDO récupère toutes les news dans la BDD.
Par la fonction setFetchMode(\PDO::FETCH_CLASS | \PDO::FETCH_PROPS_LATE, '\Entity\News'), chaque news sera placée dans un objet entité News.
Pour les récupérer dans le contrôleur, il suffit de faire ceci :
$managers = New Managers('PDO', PDOFactory::getMySqlConnection); // la ligne dans le constructeur du back controller
// La fonction executeIndex() de NewsController
newsManager = $this->managers->getManagerOf('News');
$news = $newsManager->listerLesNews();
foreach ($news as $element) { if (!empty($element->titre())) // On exploite le titre renvoyé par notre entité News pour faire des opérations { //Toute la logique de votre code } }
Maintenant que vous avez accès à vos news, vous pouvez faire tous les traitements que vous voulez dans votre contrôleur. Je prends n'importe quel exemple, mais si un utilisateur veut ajouter un commentaire sur une news, le contrôleur CommentairesController sera, par exemple, appelé, et l'URL indiquera qu'il faut exécuter sa méthode "executeAjouter()" afin de vérifier l'utilisateur a bien renseigné son pseudo, qu'il a entré une adresse mail valide, que le contenu du commentaire n'est pas vide, etc., avant d'utiliser la fonction "ajouter()" de votre manager et d'insérer le commentaire dans la BDD.
C'est là qu'on comprend l'intérêt d'avoir instancié nos classes HttpRequest, HttpResponse, User au sein de notre classe Application, car elle est globale à tout notre site, puisque l'instance de cette classe est passée à chaque composant (le contrôleur, la page, etc.)
Pour récupérer les données d'un formulaire, j'ai juste à écrire : "$this->app->httpRequest()->getPost('Pseudo')", où si je veux vérifier qu'un utilisateur est connecté : "$this->app->user()->getAttribute('Connexion')";
Il est indispensable de pouvoir utiliser des classes dans d'autres classes pour établir la logique de notre code.
- A la fin de votre méthode executeIndex(), une fois que vous avez traité toutes vos données, vous n'avez plus qu'à les renvoyer sur votre page grâce à la méthode addVar() de la classe Page.
Rappelez-vous, nous avons instancié un objet Page dans le BackController, donc cet objet est appelé lorsque NewsController est instancié.
- La suite est simple, nous avons, lors de l'instanciation de notre contrôleur NewsController, défini la vue par la méthode setView(), qui indique à notre instance de la classe Page quel est le chemin de celle-ci.
Notre objet Page sait donc, dès l'appel de notre contrôleur, qu'il faut inclure la vue "/App/Frontend/Modules/News/index.php" dans l'affichage de la page.
- Pour en revenir à notre application Frontend, il ne reste plus qu'à transmettre notre instance de Page à notre objet HttpResponse via la méthode setPage(), puis à exécuter l'affichage de celle-ci par la méthode send() qui exploite elle-même la méthode getGeneratedPage() de l'objet Page.
Cette méthode ne fait qu'inclure le layout.php, puis la vue, et récupère toutes les variables transmises depuis le contrôleur à afficher.
Par la classe HttpRequest, on récupère toutes les infos dont on a besoin sur la requête du visiteur, puis la classe HttpResponse exploite l'instance de Page pour lui renvoyer l'affichage.
Pour faire un résumé plus concis :
bootstrap.php est lancé
Il instancie l'application et l'exécute
L'application appelle, par la classe Router, le contrôleur
Le contrôleur fait ses calculs, indique à l'objet Page où est la vue à afficher et lui transmet des variables
L'application transmet l'instance de la page via le contrôleur à l'objet HttpResponse
L'application demande à HttpResponse d'afficher la vue et le layout
Bravo Linon, quelle explication! Des heures, des jours de travail...
J'ajouterais ceci que j'ai mieux compris par la suite que les entités sont des objets qui correspondent à une table de bdd. Elles sont toutes des objets, des classes, alors que toutes les classes ou objets ne sont pas des entités.
Tu dis que routes est une entité, je comprends donc que la notions d'entité s'étend au objet qui font l'objet d'un enregistrement pas nécessairement en bdd.
Merci Chat Botté, le plus dur a été de reprendre le code du tuto, puis de le comprendre. L'expliquer aura pris bien peu de temps à côté de ça J'espère juste que c'est assez clair.
En ce qui me concerne, je dirais qu'une entité est la représentation d'un objet concret (un message, un utilisateur, une URL, ou plus ancré dans la vie réelle, une voiture, un fruit, etc.) dont le but est avant tout de renvoyer ses caractéristiques qui seront exploitées, contrôlées et traitées par d'autres classes.
Dans le cas d'un objet Route, ses caractéristiques sont son URL, son action, son module et ses variables.
Router collecte toutes les routes existantes pour trouver la correspondance avec l'URL, et la méthode getController() d'Application exploite et traite les caractéristiques de la route correspondante pour récupérer le contrôleur.
Je suis un apprenant su language PHP et j'ai des difficultés pour installer les scripts non seulement sur WAMPSERVER mais également sur le serveur de mon hébergeur web.
Voici le message que je reçois quand je tente de lancer l'installation du script:
Connection error :SQLSTATE[HY000] [2002] php_network_getaddresses: getaddrinfo failed: Name or service not known Notice: Undefined variable: pdo in /srv/disk8/2039633/www/woibs.africachangemeetings.com/header.php on line 8
Fatal error: Uncaught Error: Call to a member function prepare() on null in /srv/disk8/2039633/www/woibs.africachangemeetings.com/header.php:8 Stack trace: #0 /srv/disk8/2039633/www/woibs.africachangemeetings.com/index.php(1): require_once() #1 {main} thrown in /srv/disk8/2039633/www/woibs.africachangemeetings.com/header.php on line 8
SOUS WAMP SERVER, voiçi ce que je reçois comme message:
Connection error :SQLSTATE[HY000] [1045] Access denied for user 'root'@'localhost' (using password: YES)
( ! ) Notice: Undefined variable: pdo in C:\wamp\www\whois-ent\header.php on line 8
Il semble que votre appli (scripts de site ne connecte pas avec votre bdd). Bref, c'est un problème de configuration de la base de donnée. Il faut avoir une base de donnée pour commencer! La créer dans phpMyAdmin. Elle aura un nom à noter. Il y aura un nom d'usager et un mot de passe. Tout ça doit se configurer quelque part dans votre script pour lier la BDD au script.
Si c'est ici dans ce cours(3e partie), c'est dans le fichier PDOFactory.php.
Sous Wamp, l'usager normalement à mettre est 'root' et le mot de passe est normalement ''(c'est à dire rien). D'après le message d'erreur, je dirais que le problème est là. Si on en a défini en bdd de différents, il faut ajuster.
le problème c est que je peut pas se connecter avec base de donnes
quand j execute le code var_dump($manager):ca donne $db=null pourquoi
merci
index.php
<?php
function chargerClass($class)
{
require $class.'.php';
}
spl_autoload_register('chargerClass');
$db=new PDO('mysql:host=localhost;dbname=test','root','');
$manager=new personnageManager();
var_dump($manager);// ca donne $_db=null.....au lieu de se connecter avec la base de donnes pourquoi ce probleme????
?>
<html>
<head>
</head>
<body>
<form action ='' method='POST'>
<input type='text' name='nom'></br>
<input type='submit' value ='Cree un personnage' name='Cree'></br>
<input type='submit' value ='Utiliser ce personnage' name='Utiliser'>
</form>
</body>
</html>
personnageManager.php
<?php
class personnageManager
{
private $_db;
public function __construct($db)
{
$this->setdb($db);//explique moi pourquoi $_db =null????
}
public function setdb(PDO $db)
{
$this->_db=$db;
}
}
?>
merci monsieur Daouda Traore5 j'ai rajouter $db comme vous me suggerer mais le probleme est encore existe
index.php
<?php
function chargerClass($class)
{
require $class.'.php';
}
spl_autoload_register('chargerClass');
$db=new PDO('mysql:host=localhost;dbname=test','root','');
$manager=new personnageManager($db);//voila j ai rajouter $db
if(isset($_POST['Cree'])&& isset($_POST['nom']))
{
$donne=array('nom'=>$_POST['nom']);
$perso=new personnage($donne);
}
var_dump($perso);// ca donne null ??????
?>
<html>
<head>
</head>
<body>
<form action ='' method='POST'>
<input type='text' name='nom'></br>
<input type='submit' value ='Cree un personnage' name='Cree'></br>
<input type='submit' value ='Utiliser ce personnage' name='Utiliser'>
</form>
</body>
</html>
personnageManager.php
<?php
class personnageManager
{
private $_db;
public function __construct($db)
{
$this->setdb($db);//explique moi pourquoi $_db =null????
}
public function setdb(PDO $db)
{
$this->_db=$db;
}
}
?>
voici un autre code très simple mais le problème c est que je peut pas accéder au base de donne et de récupérer les donnes avec la requet query();
voici le code:
<?php
class connexion
{
private $pdo;
public function getpdo()
{
$this->pdo=new PDO('mysql:host=localhost;dbname=test','root','');
$this->pdo->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
return $this->pdo;
}
public function getinfo()
{
$reponse=$this->getpdo()->query('SELECT*FROM personnage');
$info=$reponse->fetchColumn();
return $info;
}
}
$perso=new connexion();
var_dump($perso->getinfo());/* il doit afficher un tableau au sien de la base de donnes au lieu d'afficher string 1 length=1 ?????*/
?>
Suite de notre histoire. En vérité pour pouvoir manipuler une bdd, il te faut une entité et un manager. l'entité, c'est le plan de ce que tu veux réaliser et le manager c'est celui qui a le pouvoir d'utiliser ce plan pour manipuler la table de ta bdd. tu verras que pour utiliser la bdd, Ton manager aura besoin de se connecter à ta bdd. c'est pour cela que le manager a besoin de $db.
chafikkchikache3, sache que pour fabriquer une entité il te faut obligatoirement te servir de tes connaissances concernant la création d'une class.
chafikkchikache3, sache que pour fabriquer un manager il te faut aussi obligatoirement te servir de tes connaissances concernant la création d'une class.
Fin de notre histoire. pour pouvoir donc jouer:index, il faut une bdd:test, un manager:personnageManager, et une entité:Personnage. Tu as réunis tout sauf personnage, que t'a t'il fait? Pourquoi le détestes-tu?. Alors chafikkchikache3 tu es puni et tu ne pourras pas jouer. rajoute donc ta class Personnage et tout ira bien. Le jeu pourra ainsi ne faire que commencer.
s'il te plait Chafikkchikache, je peux jouer avec toi?
PARTIE 2
PHP POO DERNIER DEVOIR.
Patate, incroyable, j'ai bossé dur et j'ai bien compris le système de cache. Honnêtement je n'ai pas utilisé serialize,mais je vais le faire aujourd'hui. j'ai donc fais le système de cache pour ma page d'accueil. Mais surprise lorsque je relis l'énoncé du devoir.
Objectif
Vous devrez mettre en cache plusieurs parties du site :
La vue correspondant à la page d’accueil du site.
Chacune des news.
Toutes les listes de commentaires (une liste de commentaires correspond à l’ensemble des commentaires liés à une news).
Alors là ma tension artérielle est montée à 18. Je suis sûr que ce devoir en a tué au moins un. Bon je suis sous le choc.J'arrête de pleurnicher. Je me calme. Je ferme tout. Je vais me reposer 2 jours et je continuerai. Aurevoir. Non, attendez! quand j'ai aussi vu:/tmp/cache/datas mais aussi /tmp/cache/views alors là patate, pour éviter une crise cardiac, j'ai, j'ai, jaiiiiiiiii. c'est bon, je suis énervé, je vous quitte. Aurevoir.
- Edité par DaoudaTraore5 25 octobre 2018 à 8:43:00
merci beaucoup monsieur Daouda Traore5 vous êtes énormément généreux d'avoir m'expliquer de cette façons votre suggestion qui est vraiment incroyable pour moi merci encore une autre fois
Question:monsieur sachant que l'hydratation sert juste pour assigner des valeurs a des variables dans notre class et moi je sais pas pourquoi on est utiliser la methode hydrate() dans lamethode add() précisément dans le class personnageManager
voici le code
index.php
<?php
function chargerClass($class)
{
require $class.'.php';
}
spl_autoload_register('chargerClass');
$db=new PDO('mysql:host=localhost;dbname=test','root','');
$db->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
$manager=new personnageManager($db);
if (isset ($_POST['cree']) && isset ($_POST['nom']))
{
$donne=array('nom'=>$_POST['nom']);
$perso=new personnage($donne);
if(!$perso->nomvalid())
{
$message='SVP: saisie le nom de personnage...!?';
unset($perso);
}elseif($manager->exists($perso->nom()))
{
$message='le nom est deja existe...';
unset($perso);
}
else
{
$manager->add($perso);
}
}
elseif(isset($_POST['utiliser'])&& isset($_POST['nom']))
{
if($manager->exists($_POST['nom']))
{
$perso=$manager->get($_POST['nom']);
}
else
{
$message='ce personnage n\'exists pas au BDD';
}
}
var_dump($perso);
?>
<html>
<head>
<style>
body{width:1024p;height:1000px;background:rgb(245,245,245);}
#form{width:800px;height:600px;background:rgb(232,232,232);margin:50px auto;}
form{width:600px;height:100%;margin:0px auto;display:flex;flex-direction:column;}
input{width:100%;height:60px;border-radius:6px; background:white;margin:20px auto; border:1px solid rgb(245,245,245);}
input[type=submit]{background:rgb(52,201,86);color:white; font-size:1.2em;}
</style>
<title>TP::Mini Jeu De Combat</title>
</head>
<body>
<div id='form'>
personnage.php
<?php
class personnage
{
private $id;
private $nom;
private $degats;
public function __construct(array $donne)
{
$this->hydrate($donne);
}
public function hydrate(array $donne)
{
foreach($donne as $key => $value)
{
$method='set'.ucfirst($key);
if(method_exists($this,$method))
{
return $this->$method($value);
}
}
}
public function nomvalid()
{
return !empty($this->nom);
}
public function nom()
{
return $this->nom;
}
public function degats()
{
return $this->degats;
}
public function id()
{
return $this->id;
}
public function setnom($nom)
{
$this->nom=$nom;
}
public function setdegats($degats)
{
$this->degats=$degats;
}
public function setid($id)
{
$this->id=$id;
}
}
?>
<form action='' method='POST'>
<input type='text' name='nom'>
<input type='submit'name='cree' value ='Cree un personnage'>
<input type='submit' name='utiliser' value='Utiliser un personnage'>
</form>
</div>
</body>
</html>
personnageManager.php
<?php
class personnageManager
{
private $_db;
public function __construct(PDO $db)
{
$this->getdb($db);
}
public function getdb(PDO $db)
{
return $this->_db=$db;
}
public function exists($valSaisie)
{
if(is_int($valSaisie))
{
return(bool)$this->_db->query('SELECT COUNT(*)FROM personnage WHERE id='.$valSaisie)->fetchColumn();
}
$q=$this->_db->prepare('SELECT COUNT(*)FROM personnage WHERE nom=:nom');
$q->execute(array('nom'=>$valSaisie));
return(bool)$q->fetchColumn();
}
public function add(personnage $perso)
{
$q=$this->_db->prepare('INSERT INTO personnage(nom)VALUE(:nom)');
$q->bindValue('nom',$perso->nom());
$q->execute();
$perso->hydrate(array('id'=>$this->_db->lastInsertId(),'degats'=>0));
}
public function get($valSaisie)
{
if(is_int($valSaisie))
{
$q=$this->_db->query('SELECT * FROM personnage WHERE id='.$valSaisie);
$donne=$q->fetch(PDO::FETCH_ASSOC);
return new personnage($donne);
}
else
{
$q=$this->_db->prepare('SELECT * FROM personnage WHERE nom=:nom');
$q->execute(array('nom'=>$valSaisie));
return new personnage($q->fetch(PDO::FETCH_ASSOC));
}
}
}
?>
Dans la 1ère ligne on prévient la bdd qu'on va lui envoyer une variable appelée (nom) à laquelle on affectera une valeur appelée (:nom).
Dans la 2me ligne on tient notre promesse en attachant à (nom) la valeur de $perso->nom().
dans la 3me ligne on enclenche l'exécution des 2 premières lignes.
Dans la 4me ligne on dit tout simplement à la bdd que puisqu'elle vient d'enregistrer une nouvelle ligne alors il faut qu'elle nous donne son identifiant.En effet grâce à cet identifiant on peut utiliser cette nouvelle ligne là ou on veut. Puisque hydrater un objet consiste à le mouiller, cad à lui attribuer une valeur, alors pour connaître la valeur de cet id on l'hydrate tout simplement. Cette 4eme ligne consiste donc à affecter à id la valeur $this->_db->lastInsertId() et d'affecter à dégats la valeur 0.
J'ajouterais que l'hydration n'est pas juste lui attribuer une valeur, c'est plus que ça. C'est charger toutes les valeurs des attributs dans l'objet instancié: les valeurs de départs dans la méthode add(perso) ou toutes les valeurs enregistrées en bdd quand on démarrera une session éventuellement quand la méthode get(Personnage) sera en place et que la méthode update(personnage) va permettre ce fonctionnement.
Il faut comprendre qu'un objet entité (comme l'est Personnage), quand il est instancié, agit comme une sorte de mémoire tampon. Avec les setters, on met des valeurs dans cette mémoire temporaire de l'objet instancié: un personnage particulier. Ces valeurs des attributs (son nom, sa force, etc) sont à la disposition du script qui peut changer à tout moment ces valeurs. Puis on peut enregistrer ces valeurs changées en bdd si on veut retenir pour le futur ces changements. Lors d'une nouvelle session, l'objet est vide. Pour retrouver les valeurs, on ira les chercher en bdd grâce au id de l'entité-objet (ici le personnage) qu'on veut instancier et l'hydratation va «setter» (bien regarder la méthode hydrate() située dans l'objet personnage qui est une machine à setter tous les attributs de l'objet instancié) toutes les valeurs des attributs de l'objet selon ce que lui donne la bdd: bref on retrouve le personnage x (id) où il en est rendu. Mais lors de la création du personnage, il n'y a pas de id encore, c'est le seul attribut qu'on ne peut setter, car c'est la bdd qui va lui affecter un id. Bref, on enregistre l'objet et le script l'hydrate une première fois en allant chercher ce dernier id que récupère la fonction lastInsertId() qui est l'id du personnage qu'on vient de créer. Lors de la première hydratation de l'objet nouvellement enregistré avec un nouvel id, on peut lui setter des valeurs de départ qui seront temporaires. Si on veut maintenir ces valeurs éventuellement, il faudra les retransférer en bdd avec un update de l'entité en bdd.
Pour l'instant, chafikkchikache3, ton PersonnageManager n'a pas grand chose comme méthode, mais éventuellement tu auras un update(Personnage) qui sera la principale méthode utilisée par index.php qui controle tout le processus. Typiquement, une page pour afficher où on en est rendu va faire un get(Personnage) si c'est l'ouverture de sesssion - ou utiliser l'objet instancié déja hydraté mis dans la variable session qui est récupéré dès le départ si c'est le cas - pour hydrater le personnage de façon à le modifier ou à l'afficher, puis selon ce qu'on entre dans le formulaire on va récupérer les variables $_POST pour setter les changements et ensuite faire un enregistrement en bdd avec un update(personnage).
Bref, à retenir un objet c'est une sorte de mémoire temporaire qu'on modifie durant la lecture d'un script ou tout le long d'une session si cet objet instancié est mis dans une variable $_SESSION. Si on veut que ces changements persistent il faut updater l'instance de l'objet associé à un id.
L'hydratation, c'est le chargement des valeurs conservés en bdd ou des valeurs par défauts quand on crée le personnage. L'hydratation est la première chose que fait une instanciation(perso) de l'objet Personnage (méthode __construct).
Et à remarquer: une table dans une dbb correspond à l'entité objet: chaque colonne est un de ces attributs à conserver dans le long terme. ET chaque entrée correspond à chaque instance de l'objet (ici à chaque personnage) créée.
Je ne crois pas que Vyk12 va vous répondre ici, enfin je n'ai pas trouvé d'autres interventions de Vyk12 que celle de la création du forum. Bref, c'est aux autres participants au cours que vous vous adressez ou à des anciens comme moi! D'ailleurs, si vous voulez avoir accès à toute la communauté des utilisateurs, il vaut souvent mieux poster votre question dans le forum générale php, ici c'est surtout tout ceux qui «rament» dans ce cours! Je suis passé par là! Je reviens ici encore régulièrement me rappeler ce que j'y ai appris! J'ai fini le cours au debut du présent mois.
Je vous propose donc cette réponse à votre question.
La classe Personnage qui est une entité représentent la structure de la bdd. Un classe, quand elle a une correspondance en bdd, est appelé une entité. Le manager est une classe qui donc créé des objets, mais n'a pas de structure à mémoriser en bdd. Vous auriez raison dans ce cas, un objet est juste un utilitaire temporaire dans le script. D'ailleurs, le manager doit être instancié à chaque chargement.
Par contre, dès le moment où cette classe-entité Personnage est instanciée, il crée un objet personnage et cet objet doit avoir, puisqu'il s'agit ici d'une entité une entrée en bdd. Ici, pour utiliser ce petit programme, on doit créer un personnage et donc, pas le choix, il y aura un add(personnage), la création d'une entrée en bdd. Bref, l'objet Personnage ne peut pas ne pas avoir une équivalence en bdd. L'objet Personnage représente-t-il la bdd ou c'est la bdd qui représente l'objet personnage? Grande question, ils sont en correspondance un peu comme la mémoire à court terme de quelque chose et sa représentation en mémoire à long terme. Un peu comme vous changez dans votre mémoire à court terme qui réfléchit, soupèse, évalue l'information et transforme votre compréhension de la POO et vous la fixez régulièrement dans votre mémoire à long terme(votre bdd biologique interne!)
Bref, comme je l'ai expliqué justement il y a dans mon intervention précédente, l'objet est là pour être lu et modifié pendant la session ou le script et régulièrement ces changements seront envoyés à la bdd qui fixe une mémoire à long terme pour le cas où la session serait interrompue. L'objet est donc un médiateur entre l'action qui se passe dans le script , une sorte de mémoire temporaire utilitaire , et la mémoire à long terme que le Manager va gérer sur commande faite par un contrôleur. Ici dans le petit programme que vous travaillez en ce moment, ce contrôleur est dans le début de la page index.php où sont prises toutes les décisions (Si... -> alors...) en fonction des actions de l'utilisateur. Éventuellement, ce contrôleur peut être dans un autre endroit dans la structure d'une application ou d'un programme.
SALUT LES AMIES JE VOUS SOUHAITES UNE BELLE JOURNÉE
ALORS JE VEUX QUELQU’UN M 'AIDER A DÉCOUVRIR LE DIFFÉRENCE ENTRE LES DEUX CODE SUIVANT CAR MOI JE PENSE QU IL N Y A AUCUN DIFFÉRENCE
foreach($persos as $unpersos)// voici le code que j'ecrit :
//je pense qu il n'y a aucun deffirence # avec celui de monsieur veky 12 dans le cour..
//juste au lieu de $unperso j ecrit $unpersos et plus les deux accolade de la syntaxt foreach
// il ma donne un FATAL_ERROR:execueter ce code ?
{
echo '<a href="?frapper=',$unPersos->id(), '">', htmlspecialchars($unPersos->nom()), '</a> (dégâts : ', $unPersos->degats(), ')<br />';
}
/*********************DEUXIEM SYNTAXTS DE COURS TP:MINI JEU DE COMBAT*****************/
foreach ($persos as $unPerso)
//par contre celui la il marche bien :JE VEUX SAVOIRE LE PROBLEME ET LE #ENTERE EUX
echo '<a href="?frapper=', $unPerso->id(), '">', htmlspecialchars($unPerso->nom()), '</a> (dégâts : ', $unPerso->degats(), ')<br />';
APRES L’EXÉCUTION DE 1 ERE CODE JE OBTIENT LES RÉSULTATS SUIVANT:
PAR CONTRE LE DEUXIÈME IL MARCHE BIEN SANS AUCUN PROBLÈME
VOICI LE CODE COMPLET
INDEX.PHP
<?php
function chargerClass($class)
{
require $class.'.php';
}
spl_autoload_register('chargerClass');
$db=new PDO("mysql:host=localhost;dbname=test","root","");
$db->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);
$manager=new personnageManager($db);
if(isset($_POST['cree'])&& isset($_POST['nom']))
{
$donne =array('nom'=>$_POST['nom']);
$perso=new personnage($donne);
if(!$perso->nomvalid())
{
$message='Veuillesz saisie un nom';unset($perso);
}
elseif($manager->exists($perso->nom()))
{
$message='le nom que vous saisie est deja exists';unset($perso);
}
else
{
$manager->add($perso);
}
}
if(isset($_POST['utiliser'])&& isset($_POST['nom']))
{
if($manager->exists($_POST['nom']))
{
$perso=$manager->get($_POST['nom']);
}
else
{
$message='le nom que vous saisie n\exists pas';
}
}
?>
<html>
<head><title>TP::Mini Jeu De Combats</title>
<body>
<h2>le nombre des personnages cree :<?=$manager->count()?></h2>
<?php
if(isset($message))
{
echo "<p>".$message."</p>";
}
if(isset($perso))
{
?>
<fieldset>
<legend>Mes Information</legend>
<p>
NOM:<?=htmlspecialchars($perso->nom())?>
DEGATS:<?=$perso->degats()?>
</p>
</fieldset>
<fieldset>
<legend>Qui Frapper...!</legend>
<p>
<?php
$persos=$manager->getlist($perso->nom());
if(empty($persos))
{
echo 'personne a frapper';
}
else
{
/* foreach($persos as $unpersos)// voici le code que j'ecrit :
//je pense qu il n'y a aucun deffirence # avec celui de monsieur veky 12 dans le cour..
//juste au lieu de $unperso j ecrit $unpersos et plus les deux accolade de la syntaxt foreach
// il ma donne un FATAL_ERROR:execueter ce code ?
{
echo '<a href="?frapper=',$unPersos->id(), '">', htmlspecialchars($unPersos->nom()), '</a> (dégâts : ', $unPersos->degats(), ')<br />';
}*/
foreach ($persos as $unPerso) //par contre celui la il marche bien :JE VEUX SAVOIRE LE PROBLEME ET LE #ENTERE EUX
echo '<a href="?frapper=', $unPerso->id(), '">', htmlspecialchars($unPerso->nom()), '</a> (dégâts : ', $unPerso->degats(), ')<br />';
}
?>
</p>
</fieldset>
<?php
}
else
{
?>
<div id='form'>
<form action='' method='POST'>
<input type='text' name='nom'>
<input type='submit'name='cree' value ='Cree un personnage'>
<input type='submit' name='utiliser' value='Utiliser un personnage'>
</form>
</div>
<?php
}
?>
</body>
</html>
personnageManager.PHP
<?php
class personnageManager
{
private $_db;
public function __construct($db)
{
$this->setdb($db);
}
public function setdb(PDO $db)
{
$this->_db=$db;
}
public function exists($valSai)
{
if(is_int($valSai))
{
return(bool)$this->_db->query('SELECT COUNT(*)FROM personnage WHERE id='.$valSai)->fetchColumn();
}
$q=$this->_db->prepare('SELECT COUNT(*)FROM personnage WHERE nom=:nom');
$q->bindValue(':nom',$valSai);
$q->execute();
return (bool)$q->fetchColumn();
}
public function add(personnage $perso)
{
$q=$this->_db->prepare('INSERT INTO personnage(nom)VALUE(:nom)');
$q->bindValue('nom',$perso->nom());
$q->execute();
$perso->hydrate(array('id'=>$this->_db->lastInsertId(),'degats'=>0));
}
public function get($valChoix)
{ if(is_int($valChoix))
{
$q=$this->_db->query('SELECT * FROM personnage WHERE id='.$valChoix);
$donne=$q->fetch(PDO::FETCH_ASSOC);
return new personnage($donne);
}
$q=$this->_db->prepare('SELECT * FROM personnage WHERE nom=:nom');
$q->bindValue('nom',$valChoix);
$q->execute();
return new personnage($q->fetch(PDO::FETCH_ASSOC));
}
public function count()
{
return $this->_db->query('SELECT COUNT(*) FROM personnage')->fetchColumn();
}
public function getlist($nom)
{
$persos=[];
$q=$this->_db->prepare('SELECT*FROM personnage WHERE nom<>:nom ORDER BY nom');
$q->bindValue('nom',$nom);
$q->execute();
while($donne=$q->fetch(PDO::FETCH_ASSOC))
{
$persos[]= new personnage($donne);
}
return $persos;
}
}
?>
personnage.php
<?php
class personnage
{
private $id;
private $nom;
private $degats;
public function __construct($donne)
{
$this->hydrate($donne);
}
public function hydrate(array $donne)
{
foreach($donne as $key => $value)
{
$method='set'.ucfirst($key);
if(method_exists($this,$method))
{
$this->$method($value);
}
}
}
public function nomvalid()
{
return !empty($this->nom());
}
public function nom()
{
return $this->nom;
}
public function degats()
{
return $this->degats;
}
public function id()
{
return $this->id;
}
public function setnom($nom)
{
$this->nom=$nom;
}
public function setdegats($degats)
{
$this->degats=$degats;
}
public function setid($id)
{
$this->id=$id;
}
}
?>
L'écriture en majuscules est considérée comme une parole criée et diminue autant la lisibilité du texte que sa compréhension. Les majuscules abusives sont donc interdites aussi bien dans les titres que dans les messages.
(et il serait peut-être plus pertinent de poster un nouveau sujet pour ça)
Pas d'aide concernant le code par MP, le forum est là pour ça :)
Il y a une différence, le nom des variables est sensible à la casse (majuscules et minuscules font une différence), si vous rendez cohérent votre «as $unpersos» et celui dans l'écho: $unPersos->getId(), cela devrait fonctionner. C'est ce que d'ailleurs vous dit le message d'erreur: Undefined variable. Remarquez bien cette erreur, on la corrige souvent, car nous sommes fondamentalement sujets à l'erreur! Undefined variable est, 90% du temps, une erreur de ce genre, on a mal réécrit une variable qui avait été déclaré ailleurs, et donc le script ne la trouve pas.
La deuxième partie de l'erreur est une conséquence: $unPersos, cet inconnu, comment peut-il demander un id avec une méthode id() typique d'un objet s'il n'est pas identifié comme un objet? Lire les erreurs aide à comprendre le code aussi!
Ceci dit si on comprend le sens d'un foreach qui fait une boucle pour sortir chaque objet (ou élément) d'un ensemble d'objets (ou d'éléments) mis dans un array pour les afficher (ou, plus généralement, les traiter) un après l'autre, on ne mettra pas de s à «as $unPerso», car c'est justement une valeur référent à un objet unique(ou élément unique). Lire la déclaration d'un foreach(les parenthèses), c'est un peu comme dire ceci: à partir de la liste (array $Persos), faites les opérations suivantes dans l'ordre sur chaque élément de la liste que nous appellerons $unPerso. Bref, $unperso est un élément de la liste $Persos. Cet élément de la déclaration foreach (array as $valeur) met logiquement et conventionnellement l'élément $value au singulier. Les variables qui représentent des listes ou tableaux de valeurs (array) sont mises au pluriel, ce qui fait sens et aide tous les codeurs à se comprendre!
Merci chat Botte pour vos explications. Cela dit je ne comprend pas tous.
"La classe Personnage qui est une entité représentent la structure de la bdd. Un classe, quand elle a une correspondance en bdd, est appelé une entité"
Ca sous entend que ce que j'instancie comme objet Personnage est dans ma bdd? et dans le cas d'un ajout dans ma bdd, je suis bien obliger d'instancier un personnage puisque c'est ce que je dois passer en paramètre du moins le temps de vie de mon script.
exemple nouveau personnage:
$gestion_perso= new Manager();
$gestion_perso->add(new Personnage(array('nom'=>'moi','degat'=>0)));
//envoie dans la bdd, avec une verif dans le construct par exemple
exemple recup personnage:
$gestion_perso= new Manager();
$perso = $gestion_perso->add($gestion_perso->getId(2)); // le getId renvoyant un personnage depuis bdd, la boucle est bouclé.
et donc ...
"Par contre, dès le moment où cette classe-entité Personnage est instanciée, il crée un objet personnage et cet objet doit avoir, puisqu'il s'agit ici d'une entité une entrée en bdd. Ici, pour utiliser ce petit programme, on doit créer un personnage et donc, pas le choix, il y aura un add(personnage), la création d'une entrée en bdd. Bref, l'objet Personnage ne peut pas ne pas avoir une équivalence en bdd."
??? tant qu'on l'a pas instancié Personnage dans notre add(Personnage $perso), il peut ne pas être présent.
En vous remerciant
- Edité par FrancoisPessard 1 novembre 2018 à 9:31:44
Faites attention, mettez vos bouts de code dans </> du présent formulaire de commentaire, vous allez avoir un avertissement du modérateur!
Il y a deux niveaux à comprendre et distinguer: la structure (Classe avec la table correspondante en bdd) et l'objet particulier instancié: un entrée qui vivra, c'est à dire qu'il naitra lors de la création de son entrée en bdd, puis vivra ou se transformera jusqu'à sa «mort» (qui est sa suppression de la bdd) au gré de la succession des scripts dans le processus du jeu.
Vous avez raison, il n'y a pas de magie, un objet instancié même une entité comme Personnage n'a pas forcément encore un enregistrement en bdd tant qu'on ne fait pas la commande sql pour le faire, mais cet objet est encore habituellement vide. Évidemment, on pourrait le renseigner sur ces attributs comme on dit «à la dure» en écrivant du code qui «setterait» ces attributs. On peut également enregistrer des données dans un fichier qui fera office de bdd, sous d'autres forme de mémoire qu'une entrée en bdd comme MySQL.Bref, on pourrait faire beaucoup de chose sur cet objet pour le caractériser lors du script, on pourrait le passer de page en page dans une variable de session $_SESSION qui permet très bien de promener un objet et de le faire vivre longtemps, mais si à un moment de cette succession de script, ce dernier plante, et bien c'est foutu, le personnage se sera évaporé. On pourrait probablement même le passer dans un cookie et le faire perdurer longtemps comme cela. Même après la déconnexion de l'utilisateur. Bref, oui, pendant tout ce temps, l'objet Personnage existe bien dans ces variables et n'a aucune entrée en bdd. Et donc pendant tout ce temps, la classe personnage n'a pas de représentation en bdd.
Mais bon, vu que le script peut planter, vu qu'un cookie peut être supprimé par des processus externes, habituellement, la classe entité est habituellement programmé dès le départ, dès la création du Personnage pour être en correspondance avec une entrée en bdd, ce qui assure sa persistance dans le site ou l'ordinateur où le jeu a lieu.
Donc, si on a une appli qui utilise une classe Personnage tenant lieu de portrait des caractéristiques et regroupant les méthodes possibles pour transformer un personnage, on va forcément créer dans la plupart des cas, une table en base de donnée pour cette classe qui est une entité nécessaire à ce jeu. Bref, lors de la création d'un personnage et de l'instanciation à ce moment de la classe, tout devrait être prêt (une table avec tous les attributs d'un personnage dans ses colonnes) à recevoir une empreinte de ce nouveau personnage. L'enregistrement en bdd des caractéristiques propres ou valeurs associés à ce nouveau personnage, logiquement, c'est une des premières choses que l'instanciation d'une entité va chercher à faire et ce qui lui permettra d'obtenir son id qui est déterminé par la BDD, sinon cet objet entité va disparaitre à la fin du script, puis ici l'objet va s'hydrater en ajoutant le id et des valeurs par défaut à modifier au cours du script. Comme je l'ai expliqué, l'objet-entité Personnage est comme une sorte de mémoire temporaire qui est utilisé par le script qui ne va pas tout le temps faire des commandes en bdd à chaque besoin. En fait, un objet est une sorte de tableau associatif (ou array) déclaré dans le script qui contient des infos que le script peut modifier, ou consulter ou utiliser via l'utilisation des méthodes de la classe associée à cet objet. Au cours du script, parfois il y aura normalement un enregistrement en bdd et/ou une introduction de ces caractéristiques dans des variables de session, une photo de l'objet qui sera conservé en mémoire. A la prochaine utilisation, le manager ($manager->get($paramètre pour pointer le bon personnage: son nom ou un id)) va aller chercher les valeurs associés à une entité précise pour le réactualiser (hydrater) et permettre de le récupérer dans le script pour l'utilisation à faire, puis enregistrement en bdd s'il y a des modifications à faire et ainsi de suite.
Bon, cette partie de code que vous proposez:
$gestion_perso= new Manager();
$perso = $gestion_perso->add($gestion_perso->getId(2)); // le getId renvoyant un personnage depuis bdd, la boucle est bouclé.
..ne fait pas trop de sens.
Pour aller récupérer une entité enregistrée en bdd, on ne fera pas un $manager->add() qui concerne uniquement les enregistrements de nouveau personnage avec une commande sql INSERT INTO, mais un $manager->get($paramètre) qui va faire un SELECT pour retrouver une entrée de la table en particulier qui correspond au personnage que l'on chercher à retrouver
... et je ne sais pas si votre objet $manager a un getId() comme méthode, mais on ne va pas mettre un paramètre $id à un getId(), mais un autre comme son $nom pour justement retrouver son id si on ne le connait pas du côté du script. Mais plus habituellement, on ira chercher toutes les données à propos de l'objet que l'on veut instancier en bdd (lors de l'utilisation du personnage) et on retrouvera l'id avec un $perso->id() pour l'utiliser dans le script.
En terminant, si on reprend l'énoncé de Vyk: «La classe Personnage a pour rôle de représenter un personnage présent en BDD.» c'est bien ce que fait la classe dans le script. Vers quel bout de script se tourne-t-on pour récupérer, ou transformer un attribut d'un objet Personnage, ou pour faire agir le personnage? Toujours la classe Personnage qui est sa structure de base. Dans le jeu que vous travaillez, il n'y a qu'un moment ou l'objet personnage est «vide», c'est au moment de sa création. Le contrôleur (dans le index.php) instancie alors un nouvel objet et demande à $manager de créer le personnage: $manager->add() récupère les données de création dans un paramètre (que le contrôleur a eu de l'utilisateur via le formulaire: $nom), les insère dans la base de donnée qui lui crée le id. Puis manager hydrate l'objet, rempli l'objet de valeurs qui n'est plus vide et devient un personnage en particulier (ceci est après l'entrée en bdd).Bref, un objet personnage ($perso) particulier est créé vraiment juste à la suite de sa mise en bdd.
Quand il est déjà existant, sur commande du contrôleur qui est renseigné via le formulaire, $manager récupère de la bdd les données du personnage à instancier et il instancie directement l'objet en particulier qui s'hydrate grâce au constructeur de la classe. (Voir la méthode get() du manager).
Bon, toute cette matière est une représentation à se faire: au gré de votre propre évolution dans le codage, vous vous imprégnerez davantage de ces réalités du codage! Continuez le cours!
$gestion_perso= new Manager();
$perso = $gestion_perso->add($gestion_perso->getId(2));
effectivement le add() a peut d'intérêt. Concernant le getId(), j'ai dit ca comme ca histoire de renvoyer un identifiant unique (dans mon cas je n'utilise qu'une clé primaire PK, pas de clé étrangère FK)
Juste une petite question pour finir. Pour le add() comme le but finale est de rapidement envoyé les caractéristiques dans la bdd pour en faire une entité, on aurait très bien pu passer en paramètre un array associatif. Pourquoi avoir choisi un objet Personnage a ce stade est ce pour avoir une cohérence avec le reste?
NOTE: je ne suis pas encore au bout du TP.
Merci d'avance
Francois
- Edité par FrancoisPessard 1 novembre 2018 à 9:29:03
Je dirais qu'on travaille maintenant avec des objets! Et donc oui, pour être cohérent! Un objet est l'équivalent d'un array associatif et en plus il est augmenté de plusieurs caractéristiques comme des méthodes associées, mais évidemment pour faire cette première entrée, on aurait très probablement (vous testerez, moi je réfère au code publié plus haut dans cette page , car je n'ai plus ces fichiers sur mon ordi) bien pu envoyer le array('nom' =>$_POST['nom']) en paramètre à add() et adapter le code de récupération pour la requête en bdd dans l'action de cette méthode.
Mais observez votre section qui joue le rôle de contrôleur dans index.php:
if(isset($_POST['cree'])&& isset($_POST['nom']))
{
$donne =array('nom'=>$_POST['nom']);
$perso=new personnage($donne);
if(!$perso->nomvalid())
{
$message='Veuillesz saisie un nom';unset($perso);
}
elseif($manager->exists($perso->nom()))
{
$message='le nom que vous saisie est deja exists';unset($perso);
}
else
{
$manager->add($perso);
}
}
Dans cette section, vous instanciez un personnage $perso qui a un premier attribut qu'on lui sert sous forme d'un array en paramètre ($donne), cet objet $perso va comporter de nombreux avantages dans la suite du programme: sa plus-value d'objet avec ses méthodes et bien d'autres avantages que vous verrez dans les framework qui utilisent la POO. De toute façon, le array $donne est dans l'objet maintenant sous forme d'un attribut renseigné et on va l'envoyer au manager d'objets personnage sous cette forme (on l'a instancié de toute façon pour l'utiliser cet objet), car le rôle du PersonnageManager est de gérer des objets Personnage, pas des array quelconque. Sa méthode add() ferait un peu tache si elle utilisait une récupération de donnée comme on le ferait avec un array de type: $q->bindValue('nom',$perso['nom']); au lieu de $q->bindValue('nom',$perso->nom());
Il faudrait enlever le mot «Personnage» dans le paramètre de la méthode, car le programme s'enrayerait, car cette précision fait qu'il attend en paramètre un objet Personnage. La POO veut créer une certaine forme de compartimentation du code comme le font les langages informatiques évolués et utilise largement le processus d'encapsulation qui permet de rendre le code bien organisé et de sortir de l'enchevêtrement que permet le langage PHP à cause de son origine qui n'était pas d'être au départ un langage de programmation et qui le rend si intéressant pour l'apprentissage du codage pour les débutants. Mais à un niveau professionnel, ce mélange code serveur( php) et de html et de sql dans un même fichier n'est pas très propice au travail d'équipes spécialisées ni à la capacité d'un code d'évoluer facilement.
Si l'histoire du php vous intéresse, je vous propose cette vidéo au titre assez accrocheur et très instructive sur l'histoire du PHP et le monde du codage que j'ai trouvé récemment Php «c'est de la merde». Le type, que vous connaissez peut-être, qui la fait en passant propose des tutoriels très intéressants d'apprentissage du codage à un prix d'abonnement assez dérisoire pour l'accès à ses fichiers en plus des vidéos qui sont gratuites. Bref, à connaitre!
Impeccable. Effectivement, d'ailleurs, pour traiter les entrées utilisateurs mon getter contient une fonction preg_match() et htmlentities() et seul une cohérence tout objet me permet de traiter de façon simple, lisible et efficace mon array.
En vous remerciant.
Francois
NOTE: Je connaissais le site dont vous parlez, j'avais suivi la construction d'un blog mais j'ai bloqué sur la partie MVC et c'est le bouquin du site du zero sur PHP/mysql qui m'a un peu ouvert les yeux mais il y a encore du boulot.
Pas d'aide concernant le code par MP, le forum est là pour ça :)