#51 Le 23/01/2012, à 12:09
- Smon
Re : Discussion autour du concept de la POO
En fait, soit il n'existe pas et il se créé puis se retourne lui même, soit il existe et se retourne lui même.
Du coup tu ne créés plus l'objet toi même, tu appelles la fonction statique getInstance() et c'est elle qui choisit de se créer ou non.
Et du coup tu peux l'appeler dans plein d'objets différents, ce sera toujours le même qui te seras renvoyé.
Hors ligne
#52 Le 23/01/2012, à 12:12
- Morgiver
Re : Discussion autour du concept de la POO
Ha ok 
D'une certaine manière le singleton s'assure que l'objet sera bien instancier dans tous les cas de figures ?!
L'objet retourner par le singleton, je le transmet donc à mon objet Module ?!
Hors ligne
#53 Le 23/01/2012, à 12:29
- Smon
Re : Discussion autour du concept de la POO
Tu ne transmets rien du tout, l'objet module appelle directement ton singleton : Application::getInstance()
Hors ligne
#54 Le 23/01/2012, à 12:30
- Smon
Re : Discussion autour du concept de la POO
Mais tu sais, pour gérer les erreurs l'idéal reste d'étendre la classe Exception
Hors ligne
#55 Le 23/01/2012, à 12:32
- Mathieu147
Re : Discussion autour du concept de la POO
D'une certaine manière le singleton s'assure que l'objet sera bien instancier dans tous les cas de figures ?!
Le principe du singleton, c'est qu'il n'y en n'a jamais qu'un seul d'instancié. Tu veux un seul gestionnaire d'erreur, donc c'est tout à fait adapté à ton cas.
L'objet retourner par le singleton, je le transmet donc à mon objet Module ?!
Tu peux, dans chaque module, avoir une méthode setErreur() dans laquelle tu utilises le singleton. Ça ne sert à rien de l'appeler de l'extérieur de ton module, puis de le passer en argument à ton module, qui lui-même va l'utiliser. Autant que ce soit ton module qui l'appelle directement.
De toutes façons, cette fonction setErreur() elle n'est définie qu'une seule fois, dans la classe parente de tous tes modules.
Edit: bbq
Dernière modification par Mathieu147 (Le 23/01/2012, à 12:33)
Pffff…
Hors ligne
#56 Le 23/01/2012, à 12:45
- Smon
Re : Discussion autour du concept de la POO
HS : bbq ? késako ?
Hors ligne
#57 Le 23/01/2012, à 13:27
- Mathieu147
Re : Discussion autour du concept de la POO
HS : bbq ? késako ?
Tu as répondu ± la même chose que moi pendant que j'étais en train de répondre, tu m'as donc «grillé» (grillé → grill → barbecue → bbq → super marrant).
Dernière modification par Mathieu147 (Le 23/01/2012, à 13:28)
Pffff…
Hors ligne
#58 Le 23/01/2012, à 14:01
- Morgiver
Re : Discussion autour du concept de la POO
Mais tu sais, pour gérer les erreurs l'idéal reste d'étendre la classe Exception
Arf, ouais, c'est un truc que je dois encore faire, me documentay dessus. Pour l'instant je l'utilise juste pour récupérer les message d'erreur lors de mes traitement avec la base de données.
Mais je sais qu'il est possible de personnaliser les erreurs.
edit :
(grillé → grill → barbecue → bbq → super marrant).
Dernière modification par Morgiver (Le 23/01/2012, à 14:02)
Hors ligne
#59 Le 23/01/2012, à 14:04
- Smon
Re : Discussion autour du concept de la POO
(pour te faire plaisir 
)
Hors ligne
#60 Le 23/01/2012, à 16:40
- Morgiver
Re : Discussion autour du concept de la POO
C'est bonar en fait le singleton, est-ce que cela représente un problème dans certains cas ? si oui, quel genre de cas ?
Hors ligne
#61 Le 23/01/2012, à 16:49
- Luc Hermitte
Re : Discussion autour du concept de la POO
Hormis les faits :
- qu'il s'agisse d'une variable globale ? (ce qui induit introduit des couplages invisibles, gêne la mise en oeuvre de tests unitaires, ...)
- que s'il nécessite une initialisation paramétrée, alors la construction paresseuse n'a plus le moindre sens ? (hors c'est grooso-modo le seul intérêt des singletons)
- que disposer d'une construction paresseuse thread-safe et "légère" est impossible avec certains langages (C++98/03 ; plus C++11)
- que parfois l'assurance d'unicité est plus une contrainte qu'un véritable bénéfice ?
L'avantage: briller en société: http://www.siteduzero.com/forum-83-7230 … l#r6981704
google -> singleton anti-pattern
Hors ligne
#62 Le 23/01/2012, à 17:45
- Smon
Re : Discussion autour du concept de la POO
Le principal problème du singleton c'est qu'il pompe de la ressource.
Y'a aussi une mouvance anti-singleton en ce moment, justifiée ou non, telle est la question ...
Hors ligne
#63 Le 24/01/2012, à 10:16
- Mathieu147
Re : Discussion autour du concept de la POO
Chaque design pattern ou chaque paradigme de programmation est un outil pour parvenir à une fin, ce n'est pas en soi quelque chose de bon ou mauvais qu'il faut absolument utiliser ou ne pas utiliser. Il faut apprendre à s'en servir correctement et ne pas aveuglément les utiliser ou non simplement parce que quelqu'un a dit que c'était super ou merdique.
Personellement, j'ai suivi ce cours, dans lequel on parle entre autres des design patterns, dont le singleton (page 159 du cours téléchargeable en PDF).
Du même professeur, il y a aussi ce cours sur la programmation orientée-objet, qui être assez bien fait, et intéressant pour le débutant (celui qui programme depuis plusieurs années n'y apprendra sans-doute pas grand chose).
Pffff…
Hors ligne
#64 Le 26/01/2012, à 15:14
- Luc Hermitte
Re : Discussion autour du concept de la POO
a- Le principal problème du singleton c'est qu'il pompe de la ressource.
b- Y'a aussi une mouvance anti-singleton en ce moment, justifiée ou non, telle est la question ...
a- quoi ?
Le problème majeur, c'est un problème de couplage. C'est la raison pour laquelle les variables globales sont décriées en premier lieu.
b- Ce qui arrive aujourd'hui, c'est le contre-coup de l'effet de mode "vive les design patterns" qui est "ce pattern il est moisi en fait"
De la lecture il n'en manque pas (il y en a des kilomètres)
- http://caines.ca/blog/programming/singl … tern-ever/
- http://www.developpez.net/forums/d53021 … i-pattern/
- http://accu.org/index.php/journals/337
Hors ligne
#65 Le 27/01/2012, à 12:36
- Mathieu147
Re : Discussion autour du concept de la POO
Personellement, je ne suis pas tellement convaincu par les 3 liens que tu as donné, sauf quelques extraits, comme par exemple
mais bon comme tout, ca se discute et ca depend de la facon dont c'est utilisé.
ou
it is very rare to find a solution that works in all circumstances.
qui confirment ce que je disais juste au dessus dans mon message #63.
Je ne comprends pas bien en quoi un singleton est fort différent de l'utilisation de méthodes statiques.
Par exemple, dans le contexte d'un logiciel où une personne doit s'identifier et puis a accès à certaines choses suivant un système de droit, pourquoi est-ce qu'utiliser un singleton pour l'objet qui représente l'utilisateur est mauvais?
De même, dans le cadre d'un magasin en ligne où il faut gérer un panier, ou dans le cas d'un jeu vidéo où il faut gérer l'inventaire des objets du joueur, qu'est-ce qui fait qu'un singleton est si mauvais? Et surtout, qu'utiliserais-tu comme autre solution, et quels seraient les avantages de ladite solution?
Pffff…
Hors ligne
#66 Le 27/01/2012, à 13:22
- Smon
Re : Discussion autour du concept de la POO
Ou pour partager une connexion bdd entre plusieurs objets.
Hors ligne
#67 Le 27/01/2012, à 16:13
- Luc Hermitte
Re : Discussion autour du concept de la POO
a- Par exemple, dans le contexte d'un logiciel où une personne doit s'identifier et puis a accès à certaines choses suivant un système de droit, pourquoi est-ce qu'utiliser un singleton pour l'objet qui représente l'utilisateur est mauvais?
b- De même, dans le cadre d'un magasin en ligne où il faut gérer un panier, ou dans le cas d'un jeu vidéo où il faut gérer l'inventaire des objets du joueur, qu'est-ce qui fait qu'un singleton est si mauvais? Et surtout, qu'utiliserais-tu comme autre solution, et quels seraient les avantages de ladite solution?
Tu me poses des questions faciles.
a- cela complique grandement la mise en place de tests unitaires. [désolé, mais je ne partirai pas dans la démonstration du bien fondé de cette technique http://www.youtube.com/watch?v=wEhu57pih5w ]
b- Comment gères-tu un panel d'utilisateurs ?
Tu as certes un panier par utilisateur, mais certainement pas pour un panier pour ton application.
Pour le jeu video, comment gèrerai-tu les sacs à dos des autres personnages ? Voire les sacs et sacoches (au pluriel) de ces personnages ? Le singleton n'est absolument pas adapté.
J'avais même croisé des articles sur gamedev qui démontaient les singletons pour définir des engines.
PS: pour le lien, google singleton + anti-pattern est le lien à prendre. Je n'ai fait qu'en extraire 3.
autre lecture: http://www.ibm.com/developerworks/libra … index.html
Hors ligne
#68 Le 28/01/2012, à 12:07
- omc
Re : Discussion autour du concept de la POO
Je ne crois pas que le concept de singleton soit mauvais en lui-même.
Dans certains cas précis, il peut-être tout à fait légitime de n'avoir qu'une instance de classe.
Par contre, une bonne pratique est de faire en sorte que les autres classes ne présuppose pas de l'unicité de la classe singleton.
Comme cela, le jour où l'on souhaite enlever le caractère unique de la classe singleton, il n'y a pas de problème.
Attention, ce n'est que mon avis.
Hors ligne
#69 Le 03/02/2012, à 16:46
- Morgiver
Re : Discussion autour du concept de la POO
Hellow,
Après un petit moment d’absence, je reviens sur le sujet.
J'avais parler d'un système qui me permettrait de ne pas devoir ré-écrire un manager pour chaque classe (pardon Smon, ne me crucifie pas tout de suite, attend au moins que j'ai fini mon développement 
)
Mon problème avec cette méthode, c'est qu'elle était plutôt lourde à l'utilisation parce que j'avais pas trop compris certains truc.
Dans la construction je devais entrer pas mal de paramètres, avec une gestion de tableaux un peu chiante, bref, pas vraiment cool.
La maintenant ça a changer, en quelques ligne de code, je protège mes données et je les rentres dans la base de données, encore mieux pour la récupération.
Mon seul problème reste les jointure, je ne sais toujours pas comment ça fonctionne exactement (je suis en train de suivre un tuto, mais bon, je maîtrise pas encore assez pour pouvoir l'inclure dans le code).
J'ai essayer au mieux de respecter le principe d'encapsulation et j'ai oublier le singleton car après recherche, je trouve ce sujet beaucoup trop ambigu. Certains prône son utilisation, d'autres le déteste. Et comme je ne le connais pas, je me suis dit que c'était pas encore le moment de me prendre la tête dessus. Bref !
Voici 4 petites page :
La première, c'est ma classe, mon objet.
<?php
Class maClasse
{
//--------------------------------------
// Attribut de la classe.
//--------------------------------------
private $nomClasse = 'maClasse';
private $champClasse = array(
'champ1' => '',
'champ2' => '',
'champ3' => '');
private $erreur;
// Fin Attributs.
//--------------------------------------
//--------------------------------------
// Fonction de construction de l'objet
//--------------------------------------
public function __construct(array $donnees)
{
if($donnees != NULL)
{
$this->hydrate($donnees);
}
}
public function hydrate(array $donnees)
{
foreach($donnees as $cle => $valeur)
{
$methode = 'set'.ucfirst($cle);
if(method_exists($this, $methode))
{
$this->$methode($valeur);
}
}
}
// Fin constuction de l'objet.
//--------------------------------------
//--------------------------------------
// Les fonctions GETTER.
//--------------------------------------
public function champ1()
{
return $this->champClasse['champ1'];
}
public function champ2()
{
return $this->champClasse['champ2'];
}
public function champ3()
{
return $this->champClasse['champ3'];
}
public function erreur()
{
return $this->erreur;
}
public function champClasse($cle)
{
if(!isset($cle))
{
return $this->champClasse;
}
else {
return $this->$cle();
}
}
public function nomClasse()
{
return $this->nomClasse;
}
// Fin des GETTER
//--------------------------------------
//--------------------------------------
// Les fonctions SETTER.
//--------------------------------------
public function setChamp1($valeur)
{
// Différente opération sur champ1;
$this->champClasse['champ1'] = $valeur; // Etant un setter, rajoutez n'importe quelle operation dessus.
}
public function setChamp2($valeur)
{
// Différente opération sur champ1;
$this->champClasse['champ2'] = $valeur; // Etant un setter, rajoutez n'importe quelle operation dessus.
}
public function setChamp3($valeur)
{
// Différente opération sur champ1;
$this->champClasse['champ3'] = $valeur; // Etant un setter, rajoutez n'importe quelle operation dessus.
}
public function setErreur($erreur)
{
$this->erreur = $this->erreur.$erreur.'<br />';
}
// Fin des SETTER
//--------------------------------------
}
?>Deuxieme page, c'est mon Manager centralisé :
<?php
class Manager
{
//--------------------------------------
// Attributs de la Classe.
//--------------------------------------
private $db;
private $objet;
private $requete;
private $condition = NULL;
// Fin attributs.
//--------------------------------------
//--------------------------------------
// FOnction de construction.
//--------------------------------------
public function __construct(PDO $db, $objet)
{
$this->setDb($db);
$this->setObjet($objet);
}
// Fin construction.
//--------------------------------------
//--------------------------------------
// Les Fonction SETTER
//--------------------------------------
private function setDb(PDO $db)
{
$this->db = $db;
}
private function setObjet($objet)
{
$this->objet = $objet;
}
public function setCondition($condition)
{
$this->condition = $condition;
}
// Fin des SETTER.
//--------------------------------------
//--------------------------------------
// Les Fonctions du CRUD.
//--------------------------------------
public function create()
{
try
{
$i = 0;
foreach($this->objet->champClasse() as $leChamp)
{
$i++;
}
$this->requete = 'INSERT INTO '.$this->objet->nomClasse().' SET ';
foreach($this->objet->champClasse() as $cle => $valeur)
{
$this->requete = $this->requete.$cle.' = :'.$cle;
if(($i - 1) != 0)
{
$this->requete = $this->requete.', ';
}
$i--;
}
$req = $this->db->prepare($this->requete);
foreach($this->objet->champClasse() as $cle => $valeur)
{
$req->bindValue(':'.$cle, $this->objet->champClasse($cle));
}
$req->execute();
return TRUE;
} catch(Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
public function read()
{
try
{
$i = 0;
foreach($this->objet->champClasse() as $leChamp)
{
$i++;
}
$this->requete = 'SELECT ';
foreach($this->objet->champClasse() as $cle => $valeur)
{
$this->requete = $this->requete.$cle;
if(($i - 1) != 0)
{
$this->requete = $this->requete.', ';
}
$i--;
}
$this->requete = $this->requete.' FROM '.$this->objet->nomClasse().' '.$this->condition;
$req = $this->db->query($this->requete);
$donnees = $req->fetch(PDO::FETCH_ASSOC);
return new $this->objet->nomClasse($donnees);
} catch(Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
public function readList()
{
try
{
$i = 0;
foreach($this->objet->champClasse() as $leChamp)
{
$i++;
}
$this->requete = 'SELECT ';
foreach($this->objet->champClasse() as $cle => $valeur)
{
$this->requete = $this->requete.$cle;
if(($i - 1) != 0)
{
$this->requete = $this->requete.', ';
}
$i--;
}
$this->requete = $this->requete.' FROM '.$this->objet->nomClasse().' '.$this->condition;
$tableau = array();
$req = $this->db->query($this->requete);
$nomClasse = $this->objet->nomClasse();
while($donnees = $req->fetch(PDO::FETCH_ASSOC))
{
$tableau[] = new $nomClasse($donnees);
}
return $tableau;
} catch(Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
public function update()
{
try
{
$i = 0;
foreach($this->objet->champClasse() as $leChamp)
{
$i++;
}
$this->requete = 'UPDATE '.$this->nomClasse().' SET ';
foreach($this->objet->champClasse() as $cle => $valeur)
{
$this->requete = $this->requete.$cle.' = :'.$cle;
if(($i - 1) != 0)
{
$this->requete = $this->requete.', ';
}
$i++;
}
$this->requete = $this->requete.' '.$this->condition;
$req = $this->db->prepare($this->requete);
foreach($this->objet->champClasse() as $cle => $valeur)
{
$req->bindValue(':'.$cle, $this->objet->champClasse($cle));
}
$req->execute();
return TRUE;
} catch(Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
public function delete()
{
try
{
$this->requete = 'DELETE FROM '.$this->objet->nomClasse().' '.$this->condition;
$req = $this->db->exec($this->requete);
return TRUE;
} catch(Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
public function getInfoTable()
{
// Chargement des config de table et de colones.
try
{
$champ = array();
$req = $bdd->query('SHOW FULL COLUMNS FROM '.$this->objet->nomClasse());
while($donnees = $req->fetch())
{
$champ[] = $donnees;
}
return $champ;
} catch (Exception $e) {
$this->objet->setErreur($e->getMessage());
return FALSE;
}
}
// Fin du CRUD
//--------------------------------------
}
?>Ma troisième page étant la page d'exemple d'utilisation :
<?php
include 'class.config.php';
include 'class.maClasse.php';
include 'class.manager.php';
$config = new Config('admin');
$db = $config->bdd();
if(isset($_GET['creer']))
{
$donnees = array();
$maClasse = new maClasse($donnees);
foreach($_POST as $lePost => $valeur)
{
$valeur = htmlspecialchars(addslashes($valeur));
$methode = 'set'.ucfirst($lePost);
$maClasse->$methode($valeur);
}
$manager = new Manager($db, $maClasse);
$check = $manager->create();
if($check != TRUE)
{
echo 'Erreur lors du traitement des données :<p>'.$maClass->erreur().'</p>';
}
else {
echo 'Kewl tout s\'est bien passé !<br />';
}
unset($manager);
unset($maClasse);
}
echo '<form action="exemple.php?creer=1" method="POST">
<input type="text" id="champ1" name="champ1" /><br />
<input type="text" id="champ2" name="champ2" /><br />
<input type="text" id="champ3" name="champ3" /><br />
<input type="submit" value="Et on test !" /><br />
</form>';
echo '----------------------------<br />';
echo 'Verification du contenu des champs<br />';
echo '----------------------------<br />';
$donnees = array();
$maClasse = new maClasse($donnees);
$manager = new Manager($db, $maClasse);
$objet = $manager->readList();
if($objet != NULL && $objet != FALSE)
{
$i = 1;
foreach($objet as $leObjet)
{
echo 'Objet Numero :'.$i.'=> Champ 1 => '.$leObjet->champ1().' | Champ2 => '.$leObjet->champ2().' | Champ3 => '.$leObjet->champ3().'<br />';
$i++;
}
}
elseif ($objet == FALSE) {
echo 'Erreur lors de la récupération des données :<p>'.$maClasse->erreur().'</p>';
} else {
echo 'Pas de données à récupérer pour le moment.';
}
unset($objet);
unset($manager);
unset($maClasse);
?>Et la quatrième, c'est juste l'objet config que j'ai juste fait évoluer un petit peu (après vos intervention. Non je n'ai pas utiliser un fichier externe ).
<?php
class Config
{
private $db;
private $host;
private $user;
private $pass;
private $bdd;
public function __construct($rang)
{
switch($rang)
{
case "membre":
$this->setAcces('', 'localhost', 'root', '');
break;
case "moderateur":
$this->setAcces('', 'localhost', 'root', '');
break;
case "admin":
$this->setAcces('exemple', 'localhost', 'root', '');
break;
default:
$this->setAcces('', 'localhost', 'root', '');
break;
}
$pdo_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION;
$bdd = new PDO('mysql:host='.$this->host().';dbname='.$this->db().'', $this->user(), $this->pass(), $pdo_options);
$this->setBdd($bdd);
}
//------------------------------\\
// Les GETTER \\
//------------------------------\\
private function db()
{
return $this->db;
}
private function host()
{
return $this->host;
}
private function user()
{
return $this->user;
}
private function pass()
{
return $this->pass;
}
public function bdd()
{
return $this->bdd;
}
// Fin des GETTER
//------------------------------\\
//------------------------------\\
// Les SETTER \\
//------------------------------\\
private function setAcces($db, $host, $user, $pass)
{
$this->db = $db;
$this->host = $host;
$this->user = $user;
$this->pass = $pass;
}
public function setBdd($bdd)
{
$this->bdd = $bdd;
}
// Fin des SETTER
//------------------------------\\
}
?>Bon, voilà, je sais pas si je vais m'attirer des foudres ou pas.
Je voudrais juste votre avis, sur la manière de coder le tout. En regardant le code dans la page d'exemple, que pensez vous de l'utilisation du manager et de maClasse ? est-ce lourd ? facile ? difficile ? rapide ? lent ? Que feriez-vous ?
Je sais que certains ne sont pas pour ce genre d'utilisation, mais j'avais cette idée en tête, et je suis du genre têtu, j'avais besoin d'aller le plus loin possible la dedans, désoler si ça fait chier certains.
Merci d'avance pour vos futur réponses, critiques et autres réactions
Morgiver
Hors ligne
#70 Le 03/02/2012, à 16:56
- Smon
Re : Discussion autour du concept de la POO
À première vu ça m'a l'aire d'être plutôt bien utilisé tout ça
Après faudrait que je regarde de plus près mais ce sera plus tard
Hors ligne
#71 Le 04/02/2012, à 19:58
- Mathieu147
Re : Discussion autour du concept de la POO
Je dirais pareil que Smon, à ceci près que les classes appelées MaClasse, les fonctions appelées maFonction et les paramètres appelés champ1je trouve ça bizarre.
En fait, ta classe MaClasse, c'est un Data Access Object?
Pffff…
Hors ligne
#72 Le 04/02/2012, à 22:03
- Morgiver
Re : Discussion autour du concept de la POO
Je dirais pareil que Smon, à ceci près que les classes appelées MaClasse, les fonctions appelées maFonction et les paramètres appelés champ1je trouve ça bizarre.
En fait, ta classe MaClasse, c'est un Data Access Object?
Je l'ai appelée MaClasse parce qu'il n'y a pas d'utilité à cette classe, mis à part le fait qu'elle doit représenter un futur objet (d'où également la présence des champ1, champ2, etc...). En gros c'est un exemple de code minimal que je dois avoir pour pouvoir utiliser le manager au mieux. Si tu change les nom des champs par titre, contenu, etc.. tu fais un code rapide pour un gestionnaire de news par exemple.
Si j'ai bien compris le DAO c'est a peu près ça oui, enfin, je pense. C'est en effet une classe pour charger ou transmettre des données. Les différentes fonctions doivent pouvoir contrôler les entrées et sorties.
Hors ligne
#73 Le 04/02/2012, à 22:35
- Haleth
Re : Discussion autour du concept de la POO
<?php class Config { private $db; private $host; private $user; private $pass; private $bdd; public function __construct() { switch($_SESSION['rang']) { case "membre": $this->setDb('test'); $this->setHost('localhost'); $this->setUser('root'); $this->setPass(''); break; case "moderateur": $this->setDb('test'); $this->setHost('localhost'); $this->setUser('root'); $this->setPass(''); break; case "admin": $this->setDb('test'); $this->setHost('localhost'); $this->setUser('root'); $this->setPass(''); break; default: $this->setDb('test'); $this->setHost('localhost'); $this->setUser('root'); $this->setPass(''); break; } try { $pdo_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION; $bdd = new PDO('mysql:host='.$this->host().';dbname='.$this->db().'', $this->user(), $this->pass(), $pdo_option); $this->setBdd($bdd); } catch (Exception $e) { die('Erreur : ' . $e->getMessage()); } } //------------------------------\\ // Les GETTER \\ //------------------------------\\ private function db() { return $this->db; } private function host() { return $this->host; } private function user() { return $this->user; } private function pass() { return $this->pass; } public function bdd() { return $this->bdd; } // Fin des GETTER //------------------------------\\ //------------------------------\\ // Les SETTER \\ //------------------------------\\ private function setDb($db) { $this->db = $db; } private function setHost($host) { $this->host = $host; } private function setUser($user) { $this->user = $user; } private function setPass($pass) { $this->pass = $pass; } public function setBdd($bdd) { $this->bdd = $bdd; } // Fin des SETTER //------------------------------\\ } ?>
Tu sais à quoi servent tes getter/setter ?
A rien.
Rien du tout, si ce n'est te prendre du temps, des lignes, et rajouter des la complexité.
Aucun bénéfice.
Les ravages de la POO..
Ubuntu is an ancien African word which means "I can't configure Debian"
Because accessor & mutator are against encapsulation (one of OOP principles), good OOP-programmers do not use them. Obviously, procedural-devs do not. In fact, only ugly-devs are still using them.
Hors ligne
#74 Le 04/02/2012, à 23:58
- Morgiver
Re : Discussion autour du concept de la POO
Oui oui, on m'avait fait la réflexion, et j'ai même changer le code, regarde sur cette même page où tu es intervenu.
J'ai créer une fonction setAcces(), qui rassemble les SETTER. Pour ce qui est des getter, je préfère les laisser, même s'il ne font rien que renvoyer la valeur.
Je ne peux accéder aux attribut privé en dehors de l'objet (si j'ai bien compris) qu'en utilisant des getter.
Ravage, non, apprentissage, oui
EDIT : Merci de rester constructif, c'est bien de vouloir pointer des choses qui te choc, mais donner une solution, quelques explications, c'est encore mieux.
Dernière modification par Morgiver (Le 04/02/2012, à 23:59)
Hors ligne
#75 Le 05/02/2012, à 11:00
- Haleth
Re : Discussion autour du concept de la POO
Ok ok, je reprend ton dernier code !
<?php class Config { private $db; private $host; private $user; private $pass; private $bdd; public function __construct($rang) { switch($rang) { case "membre": $this->setAcces('', 'localhost', 'root', ''); break; case "moderateur": $this->setAcces('', 'localhost', 'root', ''); break; case "admin": $this->setAcces('exemple', 'localhost', 'root', ''); break; default: $this->setAcces('', 'localhost', 'root', ''); break; } $pdo_options[PDO::ATTR_ERRMODE] = PDO::ERRMODE_EXCEPTION; $bdd = new PDO('mysql:host='.$this->host().';dbname='.$this->db().'', $this->user(), $this->pass(), $pdo_options); $this->setBdd($bdd); } //------------------------------\\ // Les GETTER \\ //------------------------------\\ private function db() { return $this->db; } private function host() { return $this->host; } private function user() { return $this->user; } private function pass() { return $this->pass; } public function bdd() { return $this->bdd; } // Fin des GETTER //------------------------------\\ //------------------------------\\ // Les SETTER \\ //------------------------------\\ private function setAcces($db, $host, $user, $pass) { $this->db = $db; $this->host = $host; $this->user = $user; $this->pass = $pass; } public function setBdd($bdd) { $this->bdd = $bdd; } // Fin des SETTER //------------------------------\\ } ?>
Parlons des getter..
Quel est l'interet de ces fonctions ?
Elles sont privates, donc tu peux mettre les champs associés en private, et acceder directement audit champs ..
La fonction bdd est public, donc tu met le champ bdd en public, et tu prend le champ directement ..
Idem pour les setter !
Un getter/setter n'est utile que si il applique des restrictions sur le champs.
Par exemple :
class entier{
private int valeur;
public getValeur(){
return(valeur);
}
public setValeur(val){
if(val > 0)
valeur = val;
}
}Tu comprend la nuance ?
Faire un getter, et surtout un setter, c'est la possibilité d'ajouter du traitement à une action basique, dans le but de limiter et controler les données de l'object.
Sinon, ben si y'a pas de traitement, y'a aucun bénéfice à faire un setter, plutot qu'à acceder directement.. sauf la joie de faire 15 fonctions sans interet
J'espère que c'est plus clair, et donc plus constructif
Ubuntu is an ancien African word which means "I can't configure Debian"
Because accessor & mutator are against encapsulation (one of OOP principles), good OOP-programmers do not use them. Obviously, procedural-devs do not. In fact, only ugly-devs are still using them.
Hors ligne