Discussion :

[matthieu_c]

Bonjour,
Je débute en PHP orienté objet et j'ai 3 petites questions concernant un script contenant une classe "database" que j'ai légèrement modifié (connexion en PDO et plus via MySQL). Le script fonctionne correctement, la question (triple) est plus théorique qu'autre chose.
Voici la classe :

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
<?php 
class Db { 
private $_host; 
private $_base; 
private $_user; 
private $_password; 
private static $_instance = null; 
public function __construct() { 
require_once(dirname(__FILE__) . '/../config/config.php'); 
$this->_host = $_CONFIG['hostname']; 
$this->_base = $_CONFIG['dbname']; 
$this->_user = $_CONFIG['username']; 
$this->_password = $_CONFIG['password']; 
try { 
$this->_instance = new PDO('mysql:host=' . $this->_host . ';dbname=' . $this->_base, $this->_user, $this->_password); 
$this->_instance->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); 
$this->_instance->setAttribute(PDO::ATTR_EMULATE_PREPARES, false); 
$this->_instance->exec("SET NAMES utf8;"); 
} 
catch (Exception $e) { 
echo "Connexion MySQL impossible : " . $e->getMessage(); 
die(); 
} 
} 
public static function getInstance() { 
if (!(self::$_instance instanceof self)) 
self::$_instance = new self(); 
return self::$_instance; 
} 
} 
public function select($fields = array(), $from, $where_prep = array()) { 
// fonction permettant un SELECT dans la BDD. 
} 
$_db = Db::getInstance(); 
$test=$_db->select(array('url'),'articles',array()); 
var_dump($test); 
?>

$test retourne bien les résultats voulus.

Mes questions sont les suivantes :

1/ La doc dit à propos des constructeurs : "Le constructeur est la fonction qui est appelée automatiquement par la classe lorsque vous créez une nouvelle instance d'une classe à l'aide de l'opérateur new."

La doc, en parlant du mot clé "static" : "Le fait de déclarer des propriétés ou des méthodes comme statiques vous permet d'y accéder sans avoir besoin d'instancier la classe."

Sachant que l'appel à la BDD se fait dans le constructeur, comment se fait-il que ma connexion se fasse correctement en passant via une méthode statique (qui théoriquement ne fait pas appel au constructeur car n'instancie pas la classe) ? Si j'ai bien compris c'est car cette instance est créée dans la méthode (self::$_instance = new self(), c'est ça ?

2/ Si le constructeur est une fonction appelée par la classe, et non un objet de cette classe, c'est donc qu'elle par définition statique. Alors, pourquoi emploie-t-on "$this" et pas "self" ?

3/ La fonction getInstance() me semble peut utile (voire pas du tout). Elle revient à recréer une instance d'une classe, ce qui est normalement fait par le constructeur...
Pourquoi pas tout simplement enlever cette fonction statique
et faire ça : $_db = new Db;
$test=$_db->select(array('url'),'articles',array());
var_dump($test);
Ce qui semble retourner la même chose.
Merci pour vos réponses et votre patience

[Bisûnûrs]

Sachant que l'appel à la BDD se fait dans le constructeur, comment se fait-il que ma connexion se fasse correctement en passant via une méthode statique (qui théoriquement ne fait pas appel au constructeur car n'instancie pas la classe) ?

Tu peux appeler la méthode getInstance() de manière statique, ce qui est fait, sans instancier la classe DB. Cette méthode retourne une instance de la classe (new self()), donc le constructeur de la classe est bien appelé. Ce n'est pas parce que tu es dans une méthode statique que tu n'as pas le droit d'y instancier des classes.

Si le constructeur est une fonction appelée par la classe, et non un objet de cette classe, c'est donc qu'elle par définition statique. Alors, pourquoi emploie-t-on "$this" et pas "self" ?

Le constructeur permet de construire un objet de cette classe. $this permet d'accéder à l'objet courant. Cela dit je n'ai pas bien compris ta question, donc je réponds sans doute un peu à côté.

La fonction getInstance() me semble peut utile (voire pas du tout). Elle revient à recréer une instance d'une classe, ce qui est normalement fait par le constructeur...

La méthode getInstance() créé une instance de cette classe. En mettant le résultat dans une propriété statique de cette classe et en vérifiant son existence, ça permet d'éviter de recréer inutilement plusieurs instances de la classe (ce qui alourdit la charge serveur) quand il n'y en a besoin que d'une seule.