[PHP 5.3] [POO] Comment enregistrer les informations dans une bd ?

[beegees]

Bonjour à toutes et à tous,

Je programme depuis pas mal de temps en PHP (+- 24 mois) en procédural. J'ai décidé aujourd'hui de consacrer un nouveau projet à l'apprentissage de la POO.

Tout le monde me dit que la POO c'est plus pro, que le code est plus facile à maintenir et à corriger.

J'ai plusieurs questions de débutant et je profite d'une tâche bien précise pour vous poser mes questions :

Ma première classe va me permettre de créer un utilisateur.

Un utilisateur est composé de :

- un nom
- un prénom
- une adresse email
- un numéro de GSM

J'ai donc codé ce bout de code :

Code :

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
 
 
<?php 
	class Utilisateurs()
	{
		private $nom = $nom;
		private $prenom = $prenom;
		private $email = $email;
		private $gsm = $gsm;
 
		public function __construct($nom, $prenom, $email, $gsm)
		{
			$this->nom = "";
			$this->prenom = "";
			$this->email = "";
			$this->gsm = "";
		}
 
 
 
		public function creer_utilisateur()
		{
			$this->nom = $nom;
			$this->prenom = $prenom;
			$this->email = $email;
			$this->gsm = $gsm;
		}
	}
 
?>

1ère question :

- Je voudrais contrôler que le nom contient au moins deux caractères, le prénom au moins 3 caractères... j'utilise des simples if ?

Genre :

Code :

1
2
3
4
5
 
if(strlen($nom) == 2) 
{
    $nom = $nom
}

2) est-ce autorisé d'avoir deux mêmes noms de variables comme je le fais ci-dessus ? (je sais qu'ils sont dans deux namespaces différents).

3) est-il encore nécessaire d'utiliser mysql_real_escape_string quand on utilise la POO ?

4) j'aimerais enregistrer les nouveaux utilisateurs dans une bd. J'aimerais utiliser AJAX pour faire cela, auriez-vous une idée de comment je pourrais m'y prendre ?

J'aurai d'autres questions (assez rapidement) après vos réponses.

Je vous remercie mille fois pour votre aide et je vous souhaite une bonne fin de W.E.

beegees

[roduce]

Bonjour,

pour répondre globalement dans un premier temps, la POO c'est bien, c'est propre c'est pro et facilite la maintenance, maintenant il faut voir si sa mise en place, (plus lourde) est justifiée. Un batch qui ne tourne qu'une fois ne sera pas écris en POO par exemple.

Ensuite pour ton code, au niveau de l'instanciation:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
private $nom = $nom;
		private $prenom;
		private $email;
		private $gsm;
 
		public function __construct($nom, $prenom, $email, $gsm)
		{
			$this->nom = $nom;
			$this->prenom = $prenom;
			$this->email = $email;
			$this->gsm = $gsm;
		}

Pour le contrôle des caractères, quite à faire de la POO réellement utile, créées toi une classe de contrôle (avec des regex etc etc) et utilise là pour tes autres classes. Ca t'évitera de trop écrire le même bout de code plein de fois, et oui les if sont présent en procédural comme en POO.
Pour ta fonction il serait plus sage d'utiliser un >= et non == ?

2/ je ne me suis pas + penché que ça sur les namespace, mais sans doute faut -il que tu précise l'appartenance de chacun si tu veux que ton code marche.

3/ Les fonctions de controles sont toujours utiles. Si un code béliqueux ne fais pas planter ta requete mysql, le risque de planter une autre partie du code php, n'est pas écarté.

4/ ajax ne change en rien concernant la POO. Ajax fais l'interface entre une page html et une page asynchrone PHP. Les données et instruction de page php seront simplement écritent en objet. Après à un moment donné ton code contiendra forcément un

Code :

sql="INSERT INTO 'utilisateurs' //etc ...

[Benjamin Delespierre]

1ère erreur: ta classe utilisateur est une classe modèle, c'est à dire qu'elle caractérise une information au niveau de ton système de persistance (généralement la BDD). On considère généralement que ce n'est pas le rôle des classes modèles de faire les vérifications, c'est le role des contrôleurs (merci de jeter un oeil au pattern MVC, généralement recommandé).

Pour faire tes contrôles tu as le choix entre les if classiques et les filtres.
Tu peux aussi créér tes propres classes de validation.

Code :

1
2
3
4
if(strlen($nom) == 2) 
{
    $nom = $nom
}

Ici les deux variables sont dans le même namespace. Voir les namespaces en PHP. Attention: les namespaces sont une nouveauté de PHP 5.3 et tous les hébergeurs ne le proposent pas !

est-il encore nécessaire d'utiliser mysql_real_escape_string quand on utilise la POO ?

Non, il existe PDO::quote.
Par ailleurs, pour te simplifier la vie je te recommande un singleton de PDO pour la connection avec la DBB.

Voici un implem d'un Singleton PDO:

Code :

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
<?php
/**
 * PHP AXIOM
 *
 * @license LGPL
 * @author Benjamin DELESPIERRE <benjamin.delespierre@gmail.com>
 * @category libAxiom
 * @package library
 * $Date: 2011-05-20 16:32:08 +0200 (ven., 20 mai 2011) $
 * $Id: Database.class.php 23055 2011-05-20 14:32:08Z delespierre $
 */
 
/**
 * Database Class
 *
 * @author Delespierre
 * @version $Rev: 23055 $
 * @subpackage Database
 */
class Database {
 
    protected static $_config = array();
 
    /**
     * Inner PDO instance
     * @var PDO
     */
    protected static $_pdo_instance;
 
    /**
     * The Database class cannot be instanciated
     * @internal
     */
    private function __construct () {
        throw new RuntimeException(__CLASS__ . " cannot be instanciated");
    }
 
    /**
     * Set database configuration
     * @param array $config = array
     * @return void
     */
    public static function setConfig ($config = array()) {
        $defaults = array(
            'type' => 'mysql',
            'database' => 'backoffice',
            'username' => 'root',
            'password' => '',
            'host' => 'localhost',
            'dsn' => null,
            'options' => array(),
        );
 
        self::$_config = $config + $defaults;
    }
 
    /**
     * Opens the database connection.
     *
     * It the ignore error is set to true
     * the connection failure will be
     * ignored.
     *
     * @param boolean $ignore_error = false
     * @return boolean
     */
    public static function open ($ignore_error = false) {
        extract(self::$_config);
        if (!isset($dsn))
            $dsn = "{$type}:dbname={$database};host={$host}";
 
        try {
            self::$_pdo_instance = new PDO($dsn, $username, $password, $options);
            return true;
        }
        catch (Exception $e) {
            if (!$ignore_error)
                die('-- Database Connection Error --');
            return false;
        }
    }
 
    /**
     * Get internal PDO instance
     * @return PDO
     */
    public static function getInstance () {
        return self::$_pdo_instance;
    }
 
    /**
     * Begin a transaction
     * @see PDO::beginTransaction
     * @return boolean
     */
    public static function beginTransaction () {
        return self::$_pdo_instance->beginTransaction();
    }
 
    /**
     * Commit a transaction
     * @see PDO::commit
     * @return boolean
     */
    public static function commit () {
        return self::$_pdo_instance->commit();
    }
 
    /**
     * Get error code
     * @see PDO::errorCode
     * @return mixed
     */
    public static function errorCode () {
        return self::$_pdo_instance->errorCode();
    }
 
    /**
     * Get error info
     * @see PDO::errorInfo
     * @return array
     */
    public static function errorInfo () {
        return self::$_pdo_instance->errorInfo();
    }
 
    /**
     * Exec an SQL statement
     * @see PDO::exec
     * @param string $statement
     * @return integer
     */
    public static function exec ($statement) {
        return self::$_pdo_instance->exec($statement);
    }
 
    /**
     * Get attribute
     * @see PDO::getAttribute
     * @param integer $attribute
     * @return mixed
     */
    public static function getAttribute ($attribute) {
        return self::$_pdo_instance->getAttribute($attribute);
    }
 
    /**
     * Get available drivers
     * @see PDO::getAvailableDrivers
     * @return array
     */
    public static function getAvailableDrivers () {
        return self::$_pdo_instance->getAvailableDrivers();
    }
 
    /**
     * Get last inserted id
     * @see PDO::lastInsertId
     * @param string $name = null
     * @return string
     */
    public static function lastInsertId ($name = null) {
        return self::$_pdo_instance->lastInsertId($name);
    }
 
    /**
     * Prepare a statement
     * @see PDO::prepare
     * @param string $statement
     * @param array $driver_options = array()
     * @return PDOStatement
     */
    public static function prepare ($statement, $driver_options = array()) {
        return self::$_pdo_instance->prepare($statement, $driver_options);
    }
 
    /**
     * Execute a query
     * @see PDO::query
     * @param string $statment
     * @return PDOStatement
     */
    public static function query ($statment) {
        return self::$_pdo_instance->query($statment);
    }
 
    /**
     * Quote string
     * @see PDO::quote
     * @param string $string
     * @param integer $parameter_type = PDO::PARAM_STR
     * @return string
     */
    public static function quote ($string, $parameter_type = PDO::PARAM_STR) {
        return self::$_pdo_instance->quote($string, $parameter_type);
    }
 
    /**
     * Rollback a transaction
     * @see PDO::rollBack
     * @return boolean
     */
    public static function rollBack () {
        return self::$_pdo_instance->rollBack();
    }
 
    /**
     * Sets an attribute
     * @see PDO::setAttribute
     * @param integer $attribute
     * @param mixed $value
     * @return boolean
     */
    public static function setAttribute ($attribute, $value) {
        return self::$_pdo_instance->setAttribute($attribute, $value);
    }
}

j'aimerais enregistrer les nouveaux utilisateurs dans une bd. J'aimerais utiliser AJAX pour faire cela, auriez-vous une idée de comment je pourrais m'y prendre ?

Apprends à jouer avec jQuery et ça se fera tout seul (ou presque). En tout cas c'est pas au niveau de PHP que tu vas faire ça - peu importe que tu sois en objet ou pas d'ailleurs.

[elderion]

Envoyé par Benjamin Delespierre

1ère erreur: ta classe utilisateur est une classe modèle, c'est à dire qu'elle caractérise une information au niveau de ton système de persistance (généralement la BDD).

A propos du "systeme de persistante"
bien que ce terme soit tout a fait exact, ca peut etre bien de simplifier sa definition (enfin je vais essayer a ma maniere) :
c'est un systeme, un moteur qui permet d'enregistrer l'etat de ton objet en base.
Concrement ca signifie que la classe de ton Utilisateur doit hériter d'un systeme ORM (ex: PEAR:B_DataObject, Doctrine, Propel, et...)
qui est capable de "convertir" l'etat de ton objet Utilisateur en une requete SQL classique de type "INSERT INTO".
Ainsi tu manipule un objet, modifie ses propriétés et tu utilise de simples methodes insert/update, ...

Code :

1
2
3
4
5
6
7
8
ex: 
$utilisateur = new Utilisateur('foo', 'bar');
$utilisateur->insert();
// ca produit automatiquement un "INSERT INTO"
 
$utilisateur->setNom('baz');
$utilisateur->update()
// ca produit automatiquement un "UPDATE..."

ya meme des systemes assez poussés (comme Doctrine il me semble)
qui proposent la méthode persist(), qui a la charge de deviner elle meme s'il faut faire un "insert", un "update" ...

L'avantage de ce moyen c'est que tu manipule ton objet, tu pense beaucoup moins SQL.

[roduce]

Je trouve ça super toutes les infos que vous lui donner, mais vous avez pas l'impression d'expliquer la théorie des cordes à quelqu'un qui vous pose sur une question sur les atomes en général ?

[Benjamin Delespierre]

Concrement ca signifie que la classe de ton Utilisateur doit hériter d'un systeme ORM

Oui enfin la plupart du temps, on a pas besoin d'une machine de guerre pareille. Une classe mère abstraite qui sait exécuter des requêtes SQL fait bien l'affaire dans 90% des cas

Voici la mienne:

Code :

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
<?php
/**
 * PHP AXIOM
 *
 * @license LGPL
 * @author Benjamin DELESPIERRE <benjamin.delespierre@gmail.com>
 * @category libAxiom
 * @package library
 * $Date: 2011-06-29 13:58:45 +0200 (mer., 29 juin 2011) $
 * $Id: Model.class.php 23967 2011-06-29 11:58:45Z delespierre $
 */
 
/**
 * Model Base Class
 *
 * @abstract
 * @author Delespierre
 * @version $Rev: 23967 $
 * @subpackage Model
 */
abstract class Model {
 
    /**
     * Model key id
     * @var string
     */
    protected $_id_key = 'id';
 
    /**
     * Model's data
     * @var array
     */
	protected $_data = array();
 
	/**
	 * Statements cache
	 * @var array
	 */
	protected $_statements = array();
 
	/**
	 * Initialize a model statement (part of CRUD)
	 * @abstract
	 * @param string $statement
	 * @return PDOStatement
	 */
	abstract protected function _init ($statement);
 
	/**
	 * Default constructor
	 * @param mixed $id
	 * @throws RuntimeException
	 */
	public function __construct ($id = null) {
	    if ($id !== null && $id !== false && !$this->find($id))
	        throw new RuntimeException("Cannot instanciate model");
	}
 
	/**
	 * __sleep overloading
	 * @return array
	 */
	public function __sleep () {
	    return array('_id_key', '_data');
	}
 
	/**
	 * Getter
	 * @param string $key
	 * @return mixed
	 */
    public function __get ($key) {
        return isset($this->_data[$key]) ? $this->_data[$key] : null;
	}
 
	/**
	 * Setter
	 * @param string $key
	 * @param mixed $value
	 * @return void
	 */
	public function __set ($key, $value) {
		$this->_data[$key] = $value;
	}
 
	/**
	 * __isset overloading
	 * @param string $key
	 * @return boolean
	 */
	public function __isset ($key) {
	    return isset($this->_data[$key]);
	}
 
	/**
	 * Get internal data
	 * @internal
	 * @return array
	 */
	public function getData () {
	    return $this->_data;
	}
 
	/**
	 * Retrieve method
	 * Will return false in case of error
	 * @param mixed $id
	 * @return Model
	 */
	public function find ($id) {
	    if (!$this->_init("retrieve"))
	        throw new RuntimeException("Cannot initialize " . __METHOD__);
 
	    if ($this->_statements['retrieve']->execute(array(":{$this->_id_key}" => $id))) {
		    if ($this->_statements['retrieve']->rowCount()) {
    		    $this->_data = $this->_statements['retrieve']->fetch(PDO::FETCH_ASSOC);
    		    return $this;
		    }
		}
	    return false;
	}
 
	/**
	 * Create methode
	 * Will return false in case of error
	 * @param array $data
	 * @throws RuntimeException
	 * @return Model
	 */
	public function create ($data) {
	    if (!$this->_init("create"))
	        throw new RuntimeException("Cannot initialize " . __METHOD__);
 
	    if ($this->_statements['create']->execute(array_keys_prefix($data, ':'))) {
			$id = Database::lastInsertId();
			return $this->find($id);
		}
		return false;
	}
 
	/**
	 * Update method
	 * @throws RuntimeException
	 * @return boolean
	 */
	public function update ($data = array()) {
	    if (!$this->_init("update"))
	        throw new RuntimeException("Cannot initialize " . __METHOD__);
 
	    if (!empty($this->_data)) {
 
	        $inputs = array_merge($this->_data, array_intersect_key($data, $this->_data));
	        return $this->_statements['update']->execute(array_keys_prefix($inputs, ':'));
	    }
	    return false;
	}
 
	/**
	 * Delete method
	 * @throws RuntimeException
	 * @return boolean
	 */
	public function delete () {
	    if (!$this->_init("delete"))
	        throw new RuntimeException("Cannot initialize " . __METHOD__);
 
	    if (!empty($this->_data))
	        return $this->_statements['delete']->execute(array(":{$this->_id_key}" => $this->_data[$this->_id_key]));
	    return false;
	}
}

Et voici par exemple une classe User:

Code :

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
<?php
/**
 * PHP AXIOM
 *
 * @license LGPL
 * @author Benjamin DELESPIERRE <benjamin.delespierre@gmail.com>
 * @category Model
 * @package Model
 * $Date: 2011-05-18 17:00:36 +0200 (mer., 18 mai 2011) $
 * $Id: User.class.php 22988 2011-05-18 15:00:36Z delespierre $
 */
 
/**
 * User Model
 *
 * @author Delespierre
 * @version $Rev: 22988 $
 * @subpackage User
 */
class User extends Model {
 
    protected function _init ($statement) {
        if (isset($this->_statements[$statement]))
            return $this->_statements[$statement];
 
        switch ($statement) {
            case 'create':
                $query = 'INSERT INTO `ax_users` (`login`,`password`,`name`,`surname`) VALUES (:login,:password,:name,:surname)';
                break;
            case 'retrieve':
                $query = 'SELECT * FROM `ax_users` WHERE `id`=:id';
                break;
            case 'update':
                $query = 'UPDATE `ax_users` SET `login`=:login, `password`=:password, `name`=:name, `surname`=:surname, '.
                		 '`creation`=:creation, `last_connection`=:last_connection WHERE `id`=:id';
                break;
            case 'delete':
                $query = 'DELETE FROM `ax_users` WHERE `id`=:id';
                break;
            default:
                throw new RuntimeException("$statement is unexepected for " . __METHOD__);
        }
 
        return $this->_statements[$statement] = Database::prepare($query);
    }
 
    public static function exists ($username, $password) {
        $query = "SELECT `id` FROM `ax_users` WHERE `login`=:login AND `password`=:password";
        $stmt = Database::prepare($query);
 
        $password = md5($password);
        $stmt->bindParam(':login', $username, PDO::PARAM_STR);
        $stmt->bindParam(':password', $password, PDO::PARAM_STR);
 
        if ($stmt->execute()) {
            if ($stmt->rowCount()) {
                $row = $stmt->fetch();
                return new self($row['id']);
            }
            return false;
        }
        else
            throw new RuntimeException("Error with query");
    }
 
    public static function getUsers ($search_params = array()) {
        $query = "SELECT * FROM `ax_users`";
 
        if (!empty($search_params)) {
            $pieces = array();
            foreach ($search_params as $key => $value)
                $pieces[] = "`$key`=:$key";
            $query .= " WHERE " . implode(' AND ', $pieces);
        }
 
        $stmt = Database::prepare($query);
        if ($stmt->execute(array_keys_prefix($search_params, ':'))) {
            $user = new self;
            $stmt->setFetchMode(PDO::FETCH_INTO, $user);
            return new PDOStatementIterator($stmt);
        }
        return false;
    }
}

Après on peut prévoir des patterns plus poussés (ActiveRecord, DIM, Proxy etc.) mais il faut savoir rester simple

[elderion]

Envoyé par beegees

Code :

Je vois les erreurs suivantes :
1. c'est censé etre quoi la variable $nom (celui de droite).

Code :

private $nom = $nom;

2. dans ton constructeur, il y a bien 4 arguments en entrée, mais il n'y a aucun affectations sur les propriétés de l'objet.

C'est justement la qu'il faut le faire, sinon tes propriétés n'auront jamais de valeur. D'autant plus que ya pas de paires de getter/setter, donc aucun moyen de les affecter plus tard.

3. méthode "creer_utilisateur()" : a quoi sert cette méthode ? Elle fait double emploi avec le constructeur.
De plus les variable locale $nom, $prenom, $email, $gsm n'ont aucune valeur, car elles n'existent pas dans la signature de la méthode.
Il faudrait au moins

Code :

1
2
3
4
 
public function creer_utilisateur($nom, $prenom, $email, $gsm)
{...
}

voila si ca peut t'aider...

[elderion]

Envoyé par Benjamin Delespierre

Oui enfin la plupart du temps, on a pas besoin d'une machine de guerre pareille. Une classe mère abstraite qui sait exécuter des requêtes SQL fait bien l'affaire dans 90% des cas

bien vu ton light-ORM.

En effet Doctrine et autres sont des machines de guerre.
Je dis pas du tout qu'il faut qu'il utilise ca (doux jesus !), car c'est surdimentionné
Je les cite juste a titre d'exemple.
Le but de mon propos c'etait surtout d'expliquer en résumé ce a quoi ca sert.

[rawsrc]

Envoyé par Benjamin Delespierre

On considère généralement que ce n'est pas le rôle des classes modèles de faire les vérifications, c'est le role des contrôleurs...

Sur le lien wiki que tu as indiqué, il est dit :

Il (le contrôleur) analyse la requête du client et se contente d'appeler le modèle adéquat

Rien n'indique que le contrôleur doive connaître les validations à faire pour satisfaire le modèle ou une action du modèle. Le contrôleur doit déterminer à quelle partie du code le traitement doit être transféré et rien de plus.
Pour cela il valide juste la partie de la requête du client nécessaire à la détermination du modèle mais ne sait pas valider autre chose et encore moins une partie du travail incombant au modèle.
Donc je pense que de ne pas valider les données du modèle dans le contrôleur n'est pas une erreur dans une architecture MVC.

[Benjamin Delespierre]

Rien n'indique que le contrôleur doive connaître les validations à faire pour satisfaire le modèle ou une action du modèle. Le contrôleur doit déterminer à quelle partie du code le traitement doit être transféré et rien de plus.
Pour cela il valide juste la partie de la requête du client nécessaire à la détermination du modèle mais ne sait pas valider autre chose et encore moins une partie du travail incombant au modèle.
Donc je pense que de ne pas valider les données du modèle dans le contrôleur n'est pas une erreur dans une architecture MVC.

MVC est un pattern, c'est à toi de l’interpréter et de le décrire selon ton besoin.

J'ai pris soin de faire remarquer qu'il s'agit d'une règle générale. La plupart des architectures MVC fonctionnent ainsi pour une raison simple: à quoi bon invoquer le métier / modèle si les données ne sont pas valides ? A mon sens, vu qu'il est de la responsabilité du contrôleur de prendre en charge la requête, il n'est pas faux de lui faire faire les vérifications d'usage.

http://tahe.developpez.com/web/php/mvc/

[beegees]

Bonsoir,

Merci à vous tous pour vos nombreuses réponse.

@roduce :

pour répondre globalement dans un premier temps, la POO c'est bien, c'est propre c'est pro et facilite la maintenance, maintenant il faut voir si sa mise en place, (plus lourde) est justifiée. Un batch qui ne tourne qu'une fois ne sera pas écris en POO par exemple.

Je suis d'accord avec toi, mon projet actuel est plus gros qu'un simple fichier batch.

Pour le contrôle des caractères, quite à faire de la POO réellement utile, créées toi une classe de contrôle (avec des regex etc etc) et utilise là pour tes autres classes.

OK, j'en prends bonne note. Est-ce que cela serait judicieux de mettre les fonctions de contrôles dans une interface (afin que cette fonction de contrôle soit disponible de partout) ? Je ne pense pas avoir bien compris le rôle des interfaces en fait...

Pour le contrôle des caractères, quite à faire de la POO réellement utile, créées toi une classe de contrôle (avec des regex etc etc) et utilise là pour tes autres classes.

Après de la lecture de documentations, je me suis aperçu qu'on appelle une fonction avec un nom d'objet, on ne peut donc pas se tromper.

4/ ajax ne change en rien concernant la POO. Ajax fais l'interface entre une page html et une page asynchrone PHP. Les données et instruction de page php seront simplement écritent en objet. Après à un moment donné ton code contiendra forcément un

Je reviendrai sur ce sujet un peu plus tard car je ne veux pas trop mélanger en une fois.

@Benjamin :

1ère erreur: ta classe utilisateur est une classe modèle, c'est à dire qu'elle caractérise une information au niveau de ton système de persistance (généralement la BDD). On considère généralement que ce n'est pas le rôle des classes modèles de faire les vérifications, c'est le role des contrôleurs (merci de jeter un oeil au pattern MVC, généralement recommandé).

Bon, tu me parles un peu chinois là

Je connais (théoriquement) le modèle MVC, je vais laisser ce modèle pour (un peu) plus tard, je commence par la POO.

Idem pour singleton, quand je maîtriserai les bases de la POO, je passerai aux concepts avancés.

Je prends donc bien note de vos commentaires, mais je vais essayer de comprendre l'utilité des interfaces et des classes abstraites avant d'aller plus loin.

Encore un tout grand merci à vous tous.

beegees

[Benjamin Delespierre]

OK, j'en prends bonne note. Est-ce que cela serait judicieux de mettre les fonctions de contrôles dans une interface (afin que cette fonction de contrôle soit disponible de partout) ? Je ne pense pas avoir bien compris le rôle des interfaces en fait...

Une classe abstraite (qui serait spécialisée pour chaque type de vérification ou chaque formulaire) serait plus appropriée. Le rôle d'une interface est de spécifier la "forme" d'une classe, c'est à dire qu'elle ne sert qu'a déclarer (mais pas à définir) des méthodes. Rappelles-toi qu'une classe peut étendre une ou aucune classe mais peut implémenter plusieurs interfaces.
Une interface est très utile par exemple dans le cadre des connections car toutes tes classes de connection vont avoir besoin au moins de "open", "close", "read" et "write" et ce peu importe le média avec lequel elle parlent.
Il est en revanche de la responsabilité des classes qui implémentent cette interface (I_Connect pourrait être son nom) de définir ces méthodes en respectant le prototype défini par I_Connect.

Après de la lecture de documentations, je me suis aperçu qu'on appelle une fonction avec un nom d'objet, on ne peut donc pas se tromper.

Tu veux dire en spécifiant le type de classe.
Voici un exemple:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
interface I_A { }
 
abstract class A_A implements I_A { }
 
class A extends A_A { }
 
function foo (I_A $a) { var_dump($a); }
function bar (A_A $a) { var_dump($a); }
function baz (A $a) { var_dump($a); }
 
$a = new A;
foo($a); // fonctionne car A étends A_A qui implémente I_A
bar($a); // fonctionne car A étends A_A
baz($a); // fonctionne car $a est de la classe A
 
 
class B implements I_A { }
 
$b = new B;
foo($b); // fonctionne car B implémente I_A
bar($b); // ne fonctionne pas car B n'est pas une fille de A_A
baz($b); // ne fonctionne pas car $b n'est pas une instance de A

Spécifier le type d'instance qu'une fonction / méthode est susceptible de recevoir est une bonne pratique au niveau sécurité: impossible de se tromper

Je reviendrai sur ce sujet un peu plus tard car je ne veux pas trop mélanger en une fois.

Il y a quand même un avantage à avoir de la POO en PHP quand on utilise Ajax: il est possible d'exporter des objets PHP pour en faire des objets JavaScript (par exemple avec XML ou JSon).
De plus il existe des bridges PHP / JavaScript comme XOAD pour faire ce mapping.

Pour ce qui est de ton apprentissage, je te suggère de suivre ce cursus:

1. Comprendre et maitriser PHP en procédural
2. Comprendre et maitriser le paradigme objet
3. Comprendre et maitriser la POO en PHP
4. Comprendre et maitriser les principaux design paterns (GRASP, GOF)
5. Comprendre l'architecture logicielle (au moins dans les grandes lignes - tout n'est pas applicable à PHP)
6. Evoluer vers un framework (si le besoin s'en fait sentir)

[kaymak]

Hello,

Je programme depuis pas mal de temps en PHP (+- 24 mois) en procédural. J'ai décidé aujourd'hui de consacrer un nouveau projet à l'apprentissage de la POO.

Tout le monde me dit que la POO c'est plus pro, que le code est plus facile à maintenir et à corriger.

Il m'est avis, que c'est surement formateur de se frotter à ce genre de problème. Cependant, si tu veux apprécier les bienfaits de la POO, en évitant les erreurs des premières conception, apprécier l'utilité de la séparation, mais aussi les méfaits que cela peut engendrer.
Je ne peux que te conseiller de prendre quelques heures pour te plonger dans un framework existant.

Tu pourras faire tout cela, rapidement apprécier les plus et les moins.

Sans vouloir faire de la pub, mais pour l'avoir testé je trouve qu'il est bien pour tout cela, symfony2 t'offrira une certaine vision des chose qu'il n'est pas nécessaire de prendre pour argent comptant, mais c'est intéressant à bien des points de vue d'une conception orientée objet et t'épargnera les détails d'implémentation qu'il faut écrire pour valider une conception soigneusement pensée.

mes 2 cents,
a+