Discussion :

[Kontas]

Salut à tous, j'ai une petite question sur les bonnes pratiques à avoir en programmation orienté objet.

Quelle est la méthode la plus logique parmi ses trois ou une 4^^, sur l'utilisation des objets pour l'insertion en base de données. L'une je passe les valeurs à ajouter dans les paramètres de la méthode et l'autre je défini les valeurs des variables de l'objet


Méthode 1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
 
class maClasse{
 
 var $id;
 var $valeur;
 
 function update($id,$valeur){
 
  $query = "UPDATE table SET valeur = '".$valeur."' WHERE id='".$id."' ";
  $result = mysqli_query ($link,$query);
 
  etc .....
 
 }
 
}
 
$maClasse = new maClasse;
$maClasse->update($id,$valeur);

Méthode 2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
class maClasse{
 
 var $id;
 var $valeur;
 
 function update(){
 
  $query = "UPDATE table  SET valeur = '".$this->valeur."' WHERE id='".$this->id."' "
  $result = mysqli_query ($link,$query);
 
  etc .....
 
 }
 
}
 
$maClasse = new maClasse;
$maClasse->id = 10;
$maClasse->valeur = 'test';
$maClasse->update();

Un membre d'un autre forum m'a proposé cette 3ème méthode

Code php :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
class maClasse{
protected $id;
protected $valeur;
 
function __construct($id, $val){
...
}
 
function save(){
 if(this->existeDeja(){
$this->update();
}
else{
$this->insert()
}
}
 
protected function update(){
  $query = "UPDATE table  SET valeur = '".$this->valeur."' WHERE id='".$this->id."' "
  $result = mysqli_query ($link,$query);
  etc .....
}
 
protected function insert(){
  $query = "insert into table  ...' "
  $result = mysqli_query ($link,$query);
  etc .....
}
 
}
$maClasse = new maClasse(10, 'test');
$maClasse->save();

Merci

[Tsilefy]

Ta question ramène à la question d'ordre générale de l'endroit où on doit injecter les paramètres.

- Solution no.1: injection dans le constructeur. À faire quand les paramètres sont obligatoires pour l'existence de l'objet. Dans ton cas, est-ce que ton objet peut exister sans $id et $valeur? Si non, il faut les injecter dans le constructeur.

- Solution no.2: si les paramètres ne sont pas obligatoires pour l'existence de ton objet, tu peux les injecter dans la méthode. On pourrait certes se demander si l'utilisation de paramètres non obligatoires n'entraîne pas une violation du principe de responsabilité unique - et c'est le cas dans un certain nombre de cas...

- Solution no.3: injection directe dans les propriétés - Oublie. Ça brise complètement l'encapsulation de ta classe, ce n'est plus la peine d'avoir des objets dans ce cas. En tout cas tant que PHP n'a pas les accesseurs à la C#

[Kontas]

Oky, donc vis a vis des exemple que j'ai donnée,

Soit l'exemple 1, avec le passage des infos dans les paramètre de la méthode donnée,
Soit l'exemple 3, avec le passage des info directement dans le constructeur.

Si je prend l'exemple d'une classe pour la gestion des utilisateurs, au moment de créer l'objet, je n'ai pas forcement toutes les informations, mais plutôt que sont id d'utilisateur. Dans ce cas si j'utilise le deuxieme exemple je vais créer un objet en passant que 1 paramètre sur les 10 (environ) au total de mon constructeur, c'est pas top top. A moins de passer par une méthode static , qui dans son code, renseigne les variable utilisateur et me retourne un objet avec tout les paramètres.

[grunk]

Ton objet peut tout à fait avoir un certains nombre d'attributs et n'en spécifier que certains lors de son instanciation. Les autres pouvant être ajouter via des setters :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class Personne {
 private $nom;
 private $prenom;
 private $age;
 
 public function __construct($nom) {
	$this->nom = $nom;
 }
 
 public function setNom($nom) {
	$this->nom = $nom;
 }
 
 public function setPrenom($prenom) {
	$this->prenom = $prenom;
 }
 
 public function setNom($age) {
	if($age > 0)
		$this->age = $nom;
	else
		throw new InvalidArgumentException("Age doit être positif");
 }
 
}

Tant qu'on est dans les bonnes pratiques la classe représentant ton objet ne devrait pas gérer les interactions avec la base de données. C'est une autre classe qui devrait être dédié à cette tache. Tu passerais simplement en paramètre à cette classe l'objet que tu veux enregistrer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
class PersonneDB {
	public function update(Personne $personne) {
		//Requeste sql pour enregistrer l'objet.
	}
}

Et pour finir oublie var devant les attributs de ta classe et donne leur une visibilité à la place (public, protected ou private)

[Kontas]

Oky, c'est simplement que créer un nouvel objet de cette manière je trouve ca assez moche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$utilisateur = new utilisateur('','','','','','',$nom);

Pour ce qui est des Var, c'est du au javascript que j'ai fais récemment, mais dans mon php il n'y sont jamais si cela peut te rassurer ^^

A force de lire des articles et autre tuto je retrouve assez fréquemment la séparation des classes qui font les action en base de donnée et celle qui manipule ces données, mais si je trouve cela affreusement redondant je le comprend assez, notamment dans le cas de changement d'un système de base, mais pour des petits projet, es ce bien nécessaire ?!

[Dendrite]

Pour des petits projets, je trouve extrêmement lisible de trouver dans la page appelante un code du genre :

Pour être plus claire, je dissocie dans mes classes les accès aux bases qui génèrent des array PHP, et les classes qui à partir d'un array PHP, génère des objets HTML.

Un espèce de MVC pour enfants. sans la partie modele... un VC quoi. Et ce sont les pages appelantes qui déroulent les procédures de façon assez lisible.

Ce que j'aime dans cette méthode, c'est que tous mes petits projets ont les mêmes noms de classes : connex, manager, view et tools... et que je ne me demande pas d'un projet sur l'autre comment ranger. C'est suffisamment abstrait pour ranger toujours pareil.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
$manager=new Manager();
$view=new View();
 
 
$ma_base=new Connex('ma_base');
$sql='select * from ma_table;';
 
$data=$manager->retourne_data($ma_base->pdo,$sql);
$table=$view->retourne_table($data,'Toutes les données de ma_table');
 
echo $table;

Mais bon, c'est ma bricole perso après 6 années d'expérience, et je lirai avec intérêt tous les conseils, cirtiques, admonestations, récriminations que vous jugerez bon de mettre sur ce fil.

[grunk]

mais pour des petits projet, es ce bien nécessaire ?!

Honnêtement écrire tes requêtes sql dans une autre classe , ca va te prendre le temps de créer la classe soit 20 sec de plus .

Un petit projet ne doit pas être une excuse pour faire "mal". C'est d'autant plus vrai quand finalement le petit projet devient un plus gros projets. Du coup si on à mal fait au départ au mieux on perd du temps à tout recommencer au pire on se retrouve avec un gros projet avec un socle pourri

[Kontas]

Je suis assez d'accord, surtout qu'a terme j'aimerais fixer une bonne fois pour toutes des bases suffisamment propre pour ne pas avoir à les améliorer et les retravailler pour chacun de mes projets

Donc pour la classe qui va gérer les transaction avec ma base de donnée, et t'il intéressant que ce soit une classe héritière de la première ?

J'entend la séparation des classes redondante plutot sur l'usage :

Je déclare un objet utilisateur avec la classe utilisateur, puis je créer un nouvelle utilisateur avec la classe utilisateurSQL, sauf qu'au moment ou je traite le retour d'un formulaire d'inscription je sais très bien que ca sera un nouvel utilisateur, donc dans ce cas pourquoi ne pas directement utiliser la classe utilisateurSQL d'autant plus que derrière j'utilise des requêtes préparé et tout le tintouin pour la protection.

[grunk]

Donc pour la classe qui va gérer les transaction avec ma base de donnée, et t'il intéressant que ce soit une classe héritière de la première ?

Non surtout pas, ca deviendrait de l'héritage fonctionnel (je dérive pour récupérer une fonctionnalité d'une autre classe) ce qui est à proscrire. L'héritage doit découler d'une relation sémantique (Véhicule => Voiture)

Je déclare un objet utilisateur avec la classe utilisateur, puis je créer un nouvelle utilisateur avec la classe utilisateurSQL, sauf qu'au moment ou je traite le retour d'un formulaire d'inscription je sais très bien que ca sera un nouvel utilisateur, donc dans ce cas pourquoi ne pas directement utiliser la classe utilisateurSQL d'autant plus que derrière j'utilise des requêtes préparé et tout le tintouin pour la protection.

Parce que sinon dans ta classe utilisateurSQL tu vas devoir gérer le cas ou tu lui passe un objet , ou tu lui passe des paramètres , ou tu lui passe une partie des paramètres ... Autant tout faire passer par un objet.
Je suis d'accord qu'en PHP ca perd un peu d'intérêt parce que une fois le script terminé tout disparaît et donc l'objet intermédiaire a une utilité limité. Mais faut imaginer que la création de l'utilisateur pourrait n'être qu'une étape d'un process plus complexe et l'objet utilisateur pourrait alors être réutilisé plus loin dans le code , voir même persisté pour un usage ultérieur sans faire appel à la base de données.

[Kontas]

Merci beaucoup pour ces explications


Par exemple pour une collection de livre liée à un utilisateur, là je peu faire une classe héritière, mais aucunement pour le traitement en base.

[grunk]

Par exemple pour une collection de livre liée à un utilisateur, là je peu faire une classe héritière, mais aucunement pour le traitement en base.

Non plus.
Un livre n'a rien à voir avec un utilisateur.

une collection de livre liée à un utilisateur va se modéliser par une aggregation ce qui va se matérialiser par une injection de dépendance (passage d'un objet à un autre sans induire de dépendance forte).
Voir pour le détail de l'agrégation http://julien-pauli.developpez.com/t...sons-uml/#LIII

[Kontas]

Et bien y'a encore du boulot.

Pour en revenir à la classe qui gère les données en base, prenons l'exemple d'une méthode qui récupère que certains champs, exemple un numéro de téléphone. dans la logique je n'ai besoin que de ce numéro de téléphone, alors sous quel format doit il être renvoyé ?

1/ avec juste un return $numéro uniquement.
2/ en recréant un objet utilisateur avec ce numéro de téléphone, mais le reste des donnée serait vide.
3/ Envoyé à cette méthode qui est sensé récupérer le numéro de téléphone un objet utilisateur (partiellement rempli puisqu'il n'a pas son numéro de téléphone) et ainsi renvoyé un utilisateur complet avec le numéro de téléphone.

Je sais c'est tordu, mais ca m'intéresse de savoir ^^, si les méthode pour les données sont sencé toujours renvoyer des objets, ou on peu au cas par cas renvoyer simplement une valeur. J'imagine que cela dépend essentiellement de comment seront utilisées les valeurs de retour.

[grunk]

Dans la théorie , tu ne devrais pas avoir de méthode pour récupérer le numéro de téléphone , mais une méthode pour récupérer un utilisateur qui va retourner un objet utilisateur dans lequel tu aura le numéro de téléphone.
C'est en général ce que l'on fait quand on utilise un ORM.

La problématique de faire comme ça c'est que le process d'hydratation de l'objet (récupération des données , puis création de l'objet) est relativement long comparé à une simple requête qui ne retourne qu'un champs.

Donc dans la pratique on fait souvent un entre deux. C'est à dire que tu vas avoir une méthode capable de te retourner un objet Utilisateur complet quand c'est nécessaire (par exemple pour un formulaire d'édition de l'utilisateur) puis des méthodes "utilitaires" quand tu veux récupérer juste une info rapidement.

[Kontas]

Oky,

C'est que cela apporte quelques contraintes ce type de programmation, mais j'imagine qu'a terme on s'y retrouve largement.

je suis d'ailleurs en train d'intégrer le processus d'hydratation dans ma classe.

Parmis les choses que je n'ai pas encore cerné, il y'en as une qui me tracasse

Si je déclare au sein de ma classe des variable protected, quand je créer un objet de cette classe et que j'essai d'accéder a une de mes variables j'ai une erreur de violation, ce qui est normal. Mais par contre, si je vais un print_r() de mon objet, je vois le contenu de mon objet, y compris les variables protégé, comment c'est possible et quel est la logique ?

[Tsilefy]

Oky, c'est simplement que créer un nouvel objet de cette manière je trouve ca assez moche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$utilisateur = new utilisateur('','','','','','',$nom);

Ouch, ouch, ouch. Si un constructeur a autant de paramètres, c'est le signe d'une mauvaise conception. Il est probable que ta classe fait beaucoup trop de choses (dans l'idéal, une classe ne doit faire qu'une seule et unique chose), ou que tous ces paramètres ne soient pas nécessaires pour instancier un object (et doivent donc aller dans une méthode).

Dans les rares cas où ta classe ne fait qu'une chose et que ces paramètres sont vraiment utiles, il peut être nécessaire de grouper ces paramètres en ce qu'on appelle un Data Transfer Object, ou même un simple tableau (l'avantage du Data Transfer Objet c'est qu'elle permet de valider les paramètres automatiquement, tandis que le tableau est plus flexible et plus rapide).

[Spartacusply]

D'ordinaire, on passe par un tableau d'attribut, qui permettrait d'indiquer (ou non) les valeurs des attributs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$utilisateur = new Utilisateur(['nom' => $nom]);

Pour info par convention les classes sont toujours écrites en CamelCase.

[Tsilefy]

Oky,

Parmis les choses que je n'ai pas encore cerné, il y'en as une qui me tracasse

Si je déclare au sein de ma classe des variable protected, quand je créer un objet de cette classe et que j'essai d'accéder a une de mes variables j'ai une erreur de violation, ce qui est normal. Mais par contre, si je vais un print_r() de mon objet, je vois le contenu de mon objet, y compris les variables protégé, comment c'est possible et quel est la logique ?

C'est normal, print_r (comme var_dump et var_export) est une fonction de débogage, il est donc normal qu'elle te permette d'inspecter les entrailles de ton objet. On sort du cadre ordinaire de la visibilité dans ce cas. Il y a aussi d'autres techniques pour enlever cette visibilité, par exemple la classe Reflection.

La visibilité s'inscrit dans le cadre de l'utilisation normale, mais si tu as des besoins spécifiques (débogage, reflection...), tu peux accéder à toutes les propriétés d'un objet.

[Kontas]

D'ordinaire, on passe par un tableau d'attribut, qui permettrait d'indiquer (ou non) les valeurs des attributs :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$utilisateur = new Utilisateur(['nom' => $nom]);

Pour info par convention les classes sont toujours écrites en CamelCase.

Merci pour l'info

C'est normal, print_r (comme var_dump et var_export) est une fonction de débogage, il est donc normal qu'elle te permette d'inspecter les entrailles de ton objet. On sort du cadre ordinaire de la visibilité dans ce cas. Il y a aussi d'autres techniques pour enlever cette visibilité, par exemple la classe Reflection.

La visibilité s'inscrit dans le cadre de l'utilisation normale, mais si tu as des besoins spécifiques (débogage, reflection...), tu peux accéder à toutes les propriétés d'un objet.

Merci pour l'info, maintenant ce ma parait moins bizarre .

Ouch, ouch, ouch. Si un constructeur a autant de paramètres, c'est le signe d'une mauvaise conception. Il est probable que ta classe fait beaucoup trop de choses (dans l'idéal, une classe ne doit faire qu'une seule et unique chose), ou que tous ces paramètres ne soient pas nécessaires pour instancier un object (et doivent donc aller dans une méthode).

Dans les rares cas où ta classe ne fait qu'une chose et que ces paramètres sont vraiment utiles, il peut être nécessaire de grouper ces paramètres en ce qu'on appelle un Data Transfer Object, ou même un simple tableau (l'avantage du Data Transfer Objet c'est qu'elle permet de valider les paramètres automatiquement, tandis que le tableau est plus flexible et plus rapide).

Je me suis rapproché de méthode d'un tuto d'oc, du coup j'utilise un tableau pour passer les informations à mon constructeur, je mets tous ca au propre avant de vous le présenter ^^

[Kontas]

Voici ou j'en suis dans l'usage des bonnes pratiques ( je n'ai pas encore appliqué les majuscules pour la première lettre des fonctions et méthodes )

Mes deux classes pour la gestion des utilisateurs

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
 
<?php
 
 
class utilisateurSql{
 
	private $_pdo; // Instance connexion db
 
	function __construct($pdo){
 
		$this->_pdo = $pdo;
	}
 
	function selectIdFromSession($idSession){
 
		$query 	= "SELECT idutilisateur FROM utilisateur, logConnexion WHERE utilisateur.idutilisateur  = logConnexion.utilisateur_idutilisateur AND logConnexion.idlogConnexion = :idsession";
		$prep  	= $this->_pdo->prepare($query);
		$prep->bindValue(':idsession', $idSession, PDO::PARAM_STR);
 
		try {
		   $prep->execute();
		   $data 	= $prep->fetch();
		   $retour	= $data['idutilisateur'];		   
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
	}
 
	function select($idutilisateur){
 
		$query 	= "SELECT * FROM utilisateur WHERE idutilisateur = :idutilisateur ";
		$prep  	= $this->_pdo->prepare($query);
		$prep->bindValue(':idutilisateur', $idutilisateur, PDO::PARAM_INT);
 
		try {
 
			$prep->execute();
		   	$data 		= $prep->fetch();
 
		   	$donnees	= [	'idUtilisateur' => $data['idutilisateur'],
							'utilisateurNom' => $data['utilisateurNom'],
							'utilisateurPrenom' => $data['utilisateurPrenom'],
							'utilisateurVille' => $data['utilisateurVille'],
							'utilisateurAdresse' => $data['utilisateurAdresse'],
							'utilisateurCodePostal' => $data['utilisateurCodePostal'],
							'utilisateurPays' => $data['utilisateurPays'],
							'utilisateurTel' => $data['utilisateurTel'],
							'utilisateurMail' => $data['utilisateurMail'],
							'utilisateurDateInscription' => $data['utilisateurDateInscription'],
							'utilisateurActif' => $data['utilisateurActif'],
							'utilisateurMdp' => $data['utilisateurMdp'],
							'utilisateurAdressePaypal' => $data['utilisateurAdressePaypal']];
 
		   $retour 		= new utilisateur($donnees);
		} 
		catch (PDOException $e) {
 
		   $retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour;
	}
 
	function selectInfoExpedition($idutilisateur){
 
		$query 	= "SELECT idutilisateur,utilisateurNom,utilisateurPrenom,utilisateurVille,utilisateurAdresse,utilisateurCodePostal,utilisateurPays,utilisateurTel 
					FROM utilisateur WHERE idutilisateur = :idutilisateur";
		$prep  	= $this->_pdo->prepare($query);
		$prep->bindValue(':idutilisaeur', $idutilisateur, PDO::PARAM_STR);
 
		try {
		   $prep->execute();
		   $data 	= $prep->fetch();
		   $donnees	= [	'idUtilisateur' 		=> $data['idutilisateur'],
						'utilisateurNom' 		=> $data['utilisateurNom'],
						'utilisateurPrenom' 	=> $data['utilisateurPrenom'],
						'utilisateurVille' 		=> $data['utilisateurVille'],
						'utilisateurAdresse' 	=> $data['utilisateurAdresse'],
						'utilisateurCodePostal' => $data['utilisateurCodePostal'],
						'utilisateurPays' 		=> $data['utilisateurPays'],
						'utilisateurTel' 		=> $data['utilisateurTel']];
 
		   $retour 	= new utilisateur($donnees);		   
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
	}
 
 
	/**
	 * Met à jour les informations d'un membre.
	 * Renvoi un tableau de resultat
	*/
	function update($utilisateur){
 
		$retour;
 
		$query = "	UPDATE utilisateur	SET 
					utilisateurNom			= :utilisateurNom,
					utilisateurPrenom		= :utilisateurPrenom,
					utilisateurVille		= :utilisateurVille,
					utilisateurAdresse 		= :utilisateurAdresse,
					utilisateurCodePostal	= :utilisateurCodePostal,
					utilisateurPays         = :utilisateurPays,
					utilisateurTel 			= :utilisateurTel
					WHERE idutilisateur 	= :idutilisateur LIMIT 1";
 
		$prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(':idutilisaeur', $utilisateur->idutilisateur, PDO::PARAM_INT);
		$prep->bindValue(':utilisateurNom', $utilisateur->utilisateurNom, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurPrenom', $utilisateur->utilisateurPrenom, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurVille', $utilisateur->utilisateurVille, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurAdresse', $utilisateur->utilisateurAdresse, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurCodePostal', $utilisateur->utilisateurCodePostal, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurPays', $utilisateur->utilisateurPays, PDO::PARAM_STR);
		$prep->bindValue(':utilisateurTel', $utilisateur->utilisateurTel, PDO::PARAM_STR);
 
		if(mysqli_query($link, $query)){
            $retour = TRUE;   
        }
        else{
            $retour = FALSE;
        }  
        deconnexionV3($link);         
 
        return $retour; 
	}
 
 
 
	 /**
     * Active ou desactive un compte utilisateur, lui permettant ainsi de pouvoir se connecter
     */
     function updateActivation($idutilisateur,$actif){
 
        $retour;
       	$query = "  UPDATE utilisateur  SET 
                    utilisateurActif        = ?
                    WHERE idutilisateur     = ? LIMIT 1";
 
        $prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(1, $actif, PDO::PARAM_STR);
		$prep->bindValue(2, $idutilisateur, PDO::PARAM_INT);
 
		try {
		   	if($prep->execute()){
				$retour = TRUE;
		   	}
			else{
				$retour = FALSE;
			}
 
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
    }
 
 
 
	/**
	 * Met à jour les informations d'un membre.
	 * Renvoi un tableau de resultat
	*/
	function updateLogin($idutilisateur,$mail){
 
		$retour;
       	$query = "  UPDATE utilisateur  SET 
                    utilisateurMail        	= :mail
                    WHERE idutilisateur     = :idutilisateur LIMIT 1";
 
        $prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(':mail', $mail, PDO::PARAM_STR);
		$prep->bindValue(':idutilisaeur', $idutilisateur, PDO::PARAM_INT);
 
		try {
		   	if($prep->execute()){
				$retour = TRUE;
		   	}
			else{
				$retour = FALSE;
			}
 
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
    }
 
	/**
	 * Met à jour le mot de passe sans vérification de l'ancien MDP
	 */
	 function updateMdpSansVerif($idutilisateur,$mdpCrypter){
 
	 	$retour;
       	$query = "  UPDATE utilisateur  SET 
                    utilisateurMail        	= :mail
                    WHERE idutilisateur     = :idutilisateur LIMIT 1";
 
        $prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(':mdpCrypter', $mdpCrypter, PDO::PARAM_STR);
		$prep->bindValue(':idutilisaeur', $idutilisateur, PDO::PARAM_INT);
 
		try {
		   	if($prep->execute()){
				$retour = TRUE;
		   	}
			else{
				$retour = FALSE;
			}
 
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
    }
 
	 /**
     * Insert un nouvel utilisteur
     * Renvoi l'id si OK
     * Renvoi FALSE si erreur
     */
	 function insert($utilisateur){
 
	 	print_r($utilisateur);
 
		$query 	= 'INSERT INTO utilisateur 
						(utilisateurNom,utilisateurPrenom,utilisateurVille,utilisateurAdresse,utilisateurCodePostal,utilisateurPays,utilisateurTel,utilisateurMail,utilisateurDateInscription,utilisateurActif,utilisateurMdp) 
               		VALUES 	(:nom,:prenom,:ville,:adresse,:codePostal,:pays,:tel,:mail,NOW(),:actif,:mdp)';
		$prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(':nom', $utilisateur->utilisateurNom, PDO::PARAM_STR);
		$prep->bindValue(':prenom', $utilisateur->utilisateurPrenom, PDO::PARAM_STR);
		$prep->bindValue(':adresse', $utilisateur->utilisateurAdresse, PDO::PARAM_STR);
		$prep->bindValue(':codePostal', $utilisateur->utilisateurCodePostal, PDO::PARAM_STR);
		$prep->bindValue(':pays', $utilisateur->utilisateurPays, PDO::PARAM_STR);
		$prep->bindValue(':ville', $utilisateur->utilisateurVille, PDO::PARAM_STR);
		$prep->bindValue(':tel', $utilisateur->utilisateurTel, PDO::PARAM_STR);
		$prep->bindValue(':mail', $utilisateur->utilisateurMail, PDO::PARAM_STR);
		$prep->bindValue(':actif', 0, PDO::PARAM_INT);
		$prep->bindValue(':mdp', $utilisateur->utilisateurMdp, PDO::PARAM_STR);
 
		try {
		   $prep->execute();
		   $retour = $this->_pdo->lastInsertId();
		} 
		catch (PDOException $e) {
 
		   $retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour;  
	 }
 
     /**
     * Verification que l'adresse Email utilisé est bien unique
     * @param $mail adresse Email a verifier
     * @param $idutilisateur, facultatif permet de valider une modification
	 * @return TRUE si disponible, FALSE si utilisé
     */
     function checkMail($mail,$idutilisateur){
 
		if($idutilisateur!=''){
           	$query = 'SELECT utilisateurMail FROM utilisateur WHERE utilisateurMail = ? '.$saufIdutilisateur.' AND idutilisateur !=?';
			$prep  = $this->_pdo->prepare($query);
 
			$prep->bindValue(1, $mail, PDO::PARAM_STR);
			$prep->bindValue(2, $idutilisateur, PDO::PARAM_INT);
        }
		else{
			$query = 'SELECT utilisateurMail FROM utilisateur WHERE utilisateurMail = ? '.$saufIdutilisateur.'';
			$prep  = $this->_pdo->prepare($query);
 
			$prep->bindValue(1, $mail, PDO::PARAM_STR);
		}
 
		try {
		   $prep->execute();
		   if($prep->rowCount()==0){
				$retour = TRUE;
			}
		} 
		catch (PDOException $e) {
 
		   $retour = FALSE;
		}
 
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour;
	}
 
	 /**
     * Defini adressePaypal
     */
     function updatePaypalMail($idutilisateur,$paypalMail){
 
        $retour;
       	$query = "  UPDATE utilisateur  SET 
                    utilisateurAdressePaypal= :paypalMail
                    WHERE idutilisateur     = :idutilisateur LIMIT 1";
 
        $prep  	= $this->_pdo->prepare($query);
 
		$prep->bindValue(':paypalMail', $paypalMail, PDO::PARAM_STR);
		$prep->bindValue(':idutilisaeur', $idutilisateur, PDO::PARAM_INT);
 
		try {
		   	if($prep->execute()){
				$retour = TRUE;
		   	}
			else{
				$retour = FALSE;
			}
 
		} 
		catch (PDOException $e) {
			$retour = FALSE;
			exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
		}
		if(isset($messages)){
			foreach($messages as $message)
			{
				echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
			}
		}
 
 
		//Clore la requête préparée
		$prep->closeCursor();
		unset($prep);
 
		return $retour; 
    }
}
 
 
class utilisateur{
 
	protected $idutilisateur;
	protected $utilisateurNom;
	protected $utilisateurPrenom;
	protected $utilisateurVille;
	protected $utilisateurAdresse;
	protected $utilisateurCodePostal;
	protected $utilisateurPays;
	protected $utilisateurTel;
	protected $utilisateurMail;
	protected $utilisateurDateInscription;
	protected $utilisateurActif;
	private   $utilisateurMdp;
	protected $utilisateurAdressePaypal;
 
	function __construct($donnees){
 
		$this->hydrate($donnees);
 
	}
 
	// Fait passer automatiquement les variables du tableau $donnée dans leurs SETTER
	public function hydrate(array $donnees){
		foreach ($donnees as $key => $value){
	    // On récupère le nom du setter correspondant à l'attribut.
	    	$method = 'set'.ucfirst($key);
 
	    	// Si le setter correspondant existe.
	    	if (method_exists($this, $method)){
	      		// On appelle le setter.
	      		$this->$method($value);
			}
			else{
				echo "erreur";
			}
		}
	}						
 
	/**
	 * Test Magic set
	 */						
	function __set($nom,$valeur){
 
		$this->$nom = $valeur;
	}
 
 
	//**** SET
 
	/**
	 * Vérifie que ID est bien numérique
	 */
	public function setIdUtilisateur($idutilisateur){
 
		$idutilisateur = (int) $idutilisateur;
		if ($idutilisateur > 0)
	    {
	      $this->idutilisateur = $idutilisateur;
	    }
	}
 
	/**
	 * Vérifie que utilisateurNom est bien alphanum
	 */
	public function setUtilisateurNom($utilisateurNom){
 
		if(ctype_alnum($utilisateurNom)){
			$this->utilisateurNom = $utilisateurNom;
		} 
	}
 
	/**
	 * Vérifie que utilisateurPrenom est bien alphanum
	 */
	public function setUtilisateurPrenom($utilisateurPrenom){
 
		if(ctype_alnum($utilisateurPrenom)){
			$this->utilisateurPrenom = $utilisateurPrenom;
		} 
	}
 
	/**
	 * Vérifie que utilisateurVille est bien alphanum
	 */
	public function setUtilisateurVille($utilisateurVille){
 
		if(ctype_alnum($utilisateurVille)){
			$this->utilisateurVille = $utilisateurVille;
		} 
	}
 
	/**
	 * Set utilisateurAdresse
	 */
	public function setUtilisateurAdresse($utilisateurAdresse){
 
		$this->utilisateurAdresse = $utilisateurAdresse;
 
	}
 
	/**
	 * Vérifie que le code postal est numérique et le Set
	 */
	public function setUtilisateurCodePostal($utilisateurCodePostal){
 
		if (is_numeric($utilisateurCodePostal)){
	      $this->utilisateurCodePostal = $utilisateurCodePostal;
	    }	
	}
 
	/**
	 * Vérifie que utilisateurPays est bien alphanum
	 */
	public function setUtilisateurPays($utilisateurPays){
 
		if(ctype_alnum($utilisateurPays)){
			$this->utilisateurPays = $utilisateurPays;
		} 
	}
 
 
	/**
	 * Vérifie que le téléphone est numerique
	 */
	function setUtilisateurTel($utilisateurTel){
 
		if (is_numeric($utilisateurTel)){
	      $this->utilisateurTel = $utilisateurTel;
	    }
	}
 
	/**
	 * Set l'adresse Email
	 */
	 function setUtilisateurMail($utilisateurMail){
 
		$this->utilisateurMail = $utilisateurMail;
 
	 }
 
	/**
	* Set date d'inscription 
	*/
	function setUtilisateurDateInscription($utilisateurDateInscription){
		$this->utilisateurDateInscription = $utilisateurDateInscription;
 
	}
 
	/**
	* Vérifie que actif soit numérique
	*/
	function setUtilisateurActif($utilisateurActif){
 
		if (is_numeric($utilisateurActif)){
	    	$this->utilisateurActif = $utilisateurActif;
		}
	}
 
	/**
	* Set utilisateurMdp
	*/
	function setUtilisateurMdp($utilisateurMdp){
 
		$this->utilisateurMdp = $utilisateurMdp;		
	}
 
	/**
	* Set utilisateurAdressePaypal
	*/
	function setUtilisateurAdressePayPal($utilisateurAdressePayPal){
		$this->utilisateurAdressePaypal = $utilisateurAdressePayPal;
	}
 
 
	//**** FIN DE SET
 
	//**** GET
 
	/**
	 * Test Magic get
	 */						
	function __get($nom){
		return $this->$nom;
	}
 
 
	/**
	 * get idutilisateur
	 */						
	public function getIdUtilisateur(){
		return $this->idutilisateur;
	} 
}
 
 
?>

Usage des classes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 
require('msclss/classAd.php');
require('msclss/classUtilisateur.php');
 
// Nouvelle connexion PDO
$conn 			= new conn;
$pdo 			= $conn->newCon('');
 
$utilisateurSql = new utilisateurSql($pdo);
 
//Selection d'un utilisateur
$utilisateur 	= $utilisateurSql->select('15');
 
// lecture variable actif
echo $utilisateur->__get('utilisateurActif');
 
// Changment actif
$utilisateur->setUtilisateurActif(1);
 
// Enregistrement nouvelle valeur actif
$utilisateurSql->updateActivation($utilisateur->__get('utilisateurActif'), 1);
 
// lecture actif
echo $utilisateur->__get('utilisateurActif');
 
 
// data d'un nouvel utilisateur
$dataNouvelUtilisateur = [	'utilisateurNom' 		=> 'Nom',
							'utilisateurPrenom' 	=> 'Prenom',
							'utilisateurVille' 		=> 'Manosque',
							'utilisateurMail'		=> 'mon@mail.fr',
							'utilisateurMdp'		=> 'motDePasse',
							'utilisateurAdresse' 	=> '23 rue de truc',
							'utilisateurCodePostal' => '04100',
							'utilisateurPays' 		=> 'FR',
							'utilisateurTel' 		=> '0606060606'];
 
// Déclaration du nouvel utilisateur
$nouvelUtilisateur = new utilisateur($dataNouvelUtilisateur);
 
// Enregistrement du nouvel utilisateur en base de donnée
$idNouvelUtilisateur = $utilisateurSql->insert($nouvelUtilisateur);

[Tsilefy]

Tes classes sont à l'évidence non terminées (il y a encore plein d'erreurs, d'utilisation de variables inexistantes ou de propriétés inaccessibles, etc...), donc j'en tiens compte.

Je rappelle que ce thread porte sur "les bonnes pratiques en POO", pas sûr "est-ce que ça marche?".

- Choisis un style et garde-le. Dans un classe, tu préfixes une propriété privée par _ (je ne suis pas fan, ça vient des langages qui n'ont pas de notion de visibilité. Le mot-clé private est suffisamment clair en PHP. Après c'est juste mon goût personnel), et dans l'autre tu ne le fais pas.

- Les noms de classes en majuscule (StudlyCaps), les noms de méthodes commencent par une minuscule, mais chaque mot commence ensuite par une majuscule (camelCase). Les variables aux choix ($camelCase ou $under_score).

- Spécifie clairement la visibilité de tes méthodes par private/protected/public. En POO (et en programmation en général), beaucoup de chose repose sur la clarté d'intention. Quand tu as l'occasion d'exprimer cette intention (méthode publique ou pas), fais-le. Pense au fait que dans 3 mois ou dans 6 mois tu reliras ton code (ou un autre développeur le lira) et fais en sorte que ton code soit facile à lire et à comprendre. Un code facile à comprendre = un code facile à modifier, à corriger et à étendre.

catch (PDOException $e) {
$retour = FALSE;
exit('<b>Catched exception at line '. $e->getLine() .' :</b> '. $e->getMessage());
}
if(isset($messages)){
foreach($messages as $message)
{
echo '<p>Le ', $message->date, ' par ', $message->auteur, ' : <br />', $message->contenu, '</p>';
}
}

Une classe ne dois pas avoir de code directement exécutable, c'est-à-dire affectant directement le contexte supérieur. Ce n'est pas de la responsabilité de ta classe d'arrêter le script et d'afficher un message HTML. Tu dois relancer PDOException, lancer tes propres exceptions pour $messages, ou retourner false (indiquant un échec), etc... mais tu ne dois jamais briser l'encapsulation (qui est la base même de l'OOP). C'est le script qui utilise ta classe qui doit décider quoi faire en cas d'erreur. Imagine que tu décides plus tard qu'un cas d'erreur, tu veux aussi envoyer un email au développeur, ou faire un roll back sur une transaction SQL. Est-ce que tu vas modifier une à une toutes tes méthodes pour ça? C'est une très -mauvaise solution. La meilleur solution est de transférer ce comportement à la classe/au script qui utilise ta classe: envoie un message signalant une erreur, et laisse la classe appelante décider quoi faire.

- Tu remarques que tu répétes plusieurs fois la même séquence:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
$query = "...";
$prep  	= $this->_pdo->prepare($query);
$prep->bindValue(...);
$prep->execute();
$data 		= $prep->fetch();
//etc...

Il faut refactoriser tout ça dans une méthode privée ou protégée afin d'éviter toutes ces répétitions.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
//Clore la requête préparée
        $prep->closeCursor();
        unset($prep);

Ces deux lignes sont inutiles. On peut déjà contester l'utilité de closeCursor() pour mysql, surtout dans un script PHP, mais en plus dans ton cas la variable $prep devient hors de portée dès que la méthode est terminée (après "return"), et donc PHP l'efface automatiquement et libère les ressources qui y sont associées.

- Je ne suis pas fan de ta méthode "magique" hydrate (encore une fois, question de clarté). Je préférerais que utilisateurSQL crée directement l'objet utilisateur, avec toutes les bonnes propriétés, en utilisant les setters si nécessaire. Si je parcours le code rapidement, "hydrate" est une boîte noire: je ne sais pas ce qu'elle fait, il faut que je regarde le code source pour cela (et encore, la source n'est pas facile à comprendre: il fait une concaténation de string, puis appelle une méthode dynamiquement. Encore une fois, oui, ça marche (pour l'instant), mais c'est fragile. Que se passe-t-il si tu as des méthodes autres que des set* ? Tu vas modifier hydrate() à chaque nouveau format de méthode?

- Fais gaffe à ctype_alnum. Suivant le locale présent sur le serveur et déclaré, ce genre de test peut donner false:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var_dump(ctype_alnum('accentué'));

- Mets une seule classe par fichier.

Le ?> final est inutile lorsque ton fichier ne contient que du code PHP. Au contraire, il peut être nuisible dans certains cas, si tu mets des lignes vides après (ou si ton éditeur en rajoute dans ton dos!).

Autrement, tu as bien compris le concept de Data Mapper, qui sépare la classe modèle de la classe persistance. Le principal intérêt c'est que ça te permet de réutiliser ta classe modèle ailleurs (par exemple dans la validation de formulaires, l'envoi d'emails, dans un API REST, dans un json pour afficher des tableaux etc...)