8791 sujets

Développement web côté serveur, CMS

Pages :
Bonjour à tous,

j'ai commencé il y a peu à m'intéresser à la POO, et je tente de mettre en pratique ces derniers jours en créant ... ma première classe Smiley smile , que je ne parviens pas à faire fonctionner, pour de nombreuses raisons, je pense, que j'ignore et que je ne comprends pas.
Si vous aviez des pistes, des conseils, ou si vous repériez des "étrangetés", vous me seriez d'un grand secours, je n'y vois pas clair du tout.

D'avance je vous en remercie.

Voici donc :
le tout est constitué comme suit :
--dossier-- site
-----index.php
-----dossier-- includes
----------config.php
----------dossier-- class
---------------Connexion.class.php
---------------Gestion.class.php
---------------Contact.class.php

et, dans l'ordre : index.php

<?php
//INCLUSIONS environement de travail
	//CONFIG includes
		define('INCLUDES','includes/');
		set_include_path(get_include_path().PATH_SEPARATOR.INCLUDES);
		
	//CONFIG bdd + classes
		require_once('config.inc');

	//CONSTANTES bdd
		$config['driver'] = DRIVER;
		$config['dbname'] = DBNAME;
		$config['host'] = HOST;
		$config['user'] = USER;
		$config['password'] = PASSWORD;
		$config['dsn'] = $config['driver'] 
						. ':dbname=' . $config['dbname'] 
						. ';host=' . $config['host'];
		
?>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title></title>
    </head>
    <body>
        <?php
		//$connexion =
		$connexion = Connexion::getInstanceConnexion($config);
		//Durée d'exécution du script de connexion
		$connexion->getTimeScriptConnexion();
		?>
		
		$Contact=new Contact();
		$Contact->lire();
		?>
	</body>
</html>


config.php


define('DRIVER','mysql');
define('DBNAME','poo1');
define('HOST','localhost');
define('USER','root');
define('PASSWORD','');

define('CLASS_DIR', 'includes/class/');
set_include_path(get_include_path().PATH_SEPARATOR.CLASS_DIR);
//spl autoload pour charger les fichiers .class
spl_autoload_extensions('.class.php');
spl_autoload_register();


Connexion.class.php


// Connexion BDD = classe Singleton
class Connexion
{
	//durée d'execution du script
	private $_startTime;
	private $_endTime;
	private $_time;
    
	//valeurs de la connexion à la BDD à null
	public static $_connexionBdd = null;
	private static $_instanceConnexion = null;
	
	private static $_host = null;
	private static $_bdd = null;
	private static $_user = null;
	private static $_pswd = null;
	
	private function __construct($config=false)
	{
		//si fction construct déclenchée, tps départ en microsecondes
		$this->_startTime = round(microtime(), "6");
        
		self::$_instanceConnexion = null;
		self::$_host = $config['host'];
		self::$_bdd = $config['dbname'];
		self::$_user = $config['user'];
		self::$_pswd = $config['password'];
		
		//connexion
		try
		{
			self::$_instanceConnexion = new PDO($config['dsn'],$config['user'],$config['password']);  
		}
		//gestion des erreurs
		catch(PDOException $e)
		{
			echo 'Erreur de connexion au serveur MySQL ! <br /> Erreur détectée : '.$e->getMessage();
			exit(); 
		}
	}
	
	//"anti-cloning" (classe Singleton)
	private function __clone()
	{
	}
	/*  2nd type d'"anti-cloning" :
			public function __clone()
			{
			  throw new Exception('ERREUR DE MANIPULATION : Tentative de clônage de la classe Singleton Connexion !');
			}
	*/
	
	//lancement de la connexion
	public static function getInstanceConnexion($config)
	{
		//si la propriété $_instanceConnexion vaut null, créée la connexion, sinon renvoit sa valeur
		if (is_null(self::$_instanceConnexion))
		{
			self::$_connexionBdd = new Connexion($config);
		}
		return self::$_connexionBdd;
	}
	
	public function __destruct()
    {
        if (!is_null(self::$_instanceConnexion)) 
		{
            self::$_connexionBdd = null;
            self::$_instanceConnexion = null;
            echo 'Connexion fermée.';
        }
    }
	
	public function getTimeScriptConnexion()
	{
		//fin du script
			$this->_endTime = round(microtime(), "6");
		//calcul du temps d'éxecution du script de connexion BDD en microsecondes
			$this->_time = $this->_endTime - $this->_startTime;
			$this->_time = round($this->_time, "6");
			
			$this->_timeScript = 
				'<table border="1" cellspacing="0" cellpadding="5">
					<th colspan=2 style="background:#cccccc">Temps du script
					</th>
					<tr> 
						<td style="background:#eeeeee">Début du script
						</td>
						<td>' . $this->_startTime . '
						</td>
					</tr>
					<tr>
						<td style="background:#eeeeee">Fin du script
						</td>
						<td>' . $this->_endTime . '
						</td>
					</tr>
					<tr>
						<td style="background:#eeeeee">Tps d\'éxecution total
						</td>
						<td>' . $this->_time . '
						</td>
					</tr>
				</table>' ;
				
			echo $this->_timeScript ;
	}
}


Gestion.class.php


class Gestion
{
	//propriété nom de la table
	public $_table;
	//$id pr delete
	public $id;
	
		
	//fction lecture champs BDD
	public function lire($champs=null)
	{
		//si pas de paramètre
		if ($champs==null) { $champs='*'; }
		try{
			//prépare la requete
			$this->_connexionBdd->prepare("SELECT $champs FROM ".$this->_table." WHERE id=".$this->id);
			//execute la requete
			$this->_connexionBdd->execute();
			//récup les résultats de la requete sous forme de tableau
			$result=$this->_connexionBdd->fetch(PDO::FETCH_ASSOC);
		}
		catch(PDOException $e){
		   echo 'Erreur : '.$e->getMessage();
		   exit();
		}
		//parcours du tableau et récupération des données
		foreach ($result as $cle=>$valeur)
		{ 
			$this->$cle = $valeur;
		}
	}
}


Contact.class.php

class Contact extends Gestion
{
	public $_table = 'contacts';
}


Deux erreurs à la ligne 17 :
Notice: Undefined property: Client::$_connexionBdd
Fatal error: Call to a member function prepare() on a non-object

J'ai bien essayé de passer en paramètre de ma fonction lire() $_connexionBdd, qui est retournée dans $connexion : $Client->lire('',$connexion);
tout en la récupérant de l'autre coté mais ça ne fonctionne pas non plus.

dans ma fonction lire() également, j'utilise des $this-> mais je ne suis pas sûre qu'ils soient utiles, dans la mesure où mon champ est "public"... je voulais savoir ce que vous en pensiez.

Pour finir, je me demande si mon destructeur dans ma classe Connexion a une utilité.

En bref, mon code est bien bancal. Donc si vous pouviez me donner des pistes pour mieux comprendre tout ça...

Merci du courage déployé pour me lire jusque là et merci d'avance de vos réponses.
Modifié par ClR (18 Jul 2011 - 23:15)
Je ne parviens pas à colorer proprement le code de la page d'index...mais bon.
et le code de la classe Contact est là... Il est juste un peu court Smiley smile ...
Merci
Modifié par ClR (04 Jul 2011 - 19:08)
Merci, je vais regarder ça tout à l'heure.

Déjà un petit truc :

var $_table = 'contacts';

Le mot clé "var" servait à déclarer des membres d'une classe en PHP 4. En PHP 5 ça n'existe plus, à la place tu dois utiliser les mots clés public, private ou static. Tant qu'à coder en PHP 5 autant le faire jusqu'au bout. Smiley smile
Modifié par jb_gfx (04 Jul 2011 - 20:13)
J'ai corrigé le var, et j'ai mit la variable en public.
Merci de tes réponses jb_gfx et merci(pardon) au modérateur d'avoir dé(re)placé mon sujet au bon endroit. Smiley smile
en fait il y a beaucoup trop de choses qui coince dans la compréhension même de ce que j'ai essayé de faire. Même pour moi c'est super flou et je me pose trop de questions pour ne pas faire perdre son temps à tout le monde...
Donc je vais aller gratter un peu dans mon coin et j'actualiserai tout ça quand j'aurais avancé.
En revanche si vous avez des conseils sur des tutos bien (j'en ai lu quelques-uns déjà) je suis preneuse.
Je vous remercie et je m'excuse du dérangement inutile.
Bonne soirée
Bonjour je trouve ça très louable ! bienvenue dans la POO ça simplifie la vie, pour commencer quelques règles :
http://www.btsinfogap.org/cours/s3/ig2/poo/POO_ch2.htm
Donc les membres d'une classe ont toujours (sauf cas très particulier) l'attribut private (encapsulation voir le lien).

L'exemple de la voiture :
les données privées : la couleur, les roues, la marque etc...
pourquoi elle sont privées ? Car l'utilisateur n'a pas besoin de connaitre cela pour utiliser sa voiture, pour utiliser sa voiture il utiliseras des méthodes exemple : maVoiture->demarer()
Et si un autre utilisateur lui demande de quel couleur est sa voiture : maVoiture->getCouleur()
si l'utilisateur veut changer la couleur de sa voiture : maVoiture->setCouleur('FFF')

Du concret !
Donc perso ma classe connexion ressemble à ça :

class MySQL
{
	private static $connected = false;
	public static function Connexion($config)
	{	
		if (!self::$connected)
		{
			mysql_connect($config['sHost'], $config['sUser'], $config['sPwd'])or die ("Pb connexion serveur ".mysql_error());
			mysql_select_db($config['sBase']) or die ("Pb selection base ".mysql_error());
			self::$connected = true;
			mysql_query("SET NAMES UTF8")  or die(mysql_error());
		}
	}
	public static function Deconnexion()
	{
		mysql_close();
	}
	
	public static function checkChampVersBase ($p_champ)
	{
		if($p_champ=='')
			return 'NULL';
		elseif($p_champ== NULL || $p_champ=='NULL')
			return 'NULL';
		elseif($p_champ[0] == '0' && isset($p_champ[1]))
			return '"'.$p_champ.'"';
		elseif(is_numeric($p_champ))
			return $p_champ;
		elseif(is_string($p_champ))
			return '"'.$p_champ.'"';
		else
			return $p_champ;
	}
	

		
}


et une classe :


class module {
     //les membres privés
    private $m_id;
    private $m_libelle;
    private $m_mesLecons;
     //le constructeur avec une surcharge dessus (case 1 , case 2)
    public function __construct() {
	$this->m_mesLecons = new collection();
	$num = func_num_args();
	switch ($num) {
	    case 1:
		//un seul paramètre passé
		$p_code = func_get_arg(0);
		$requeteSQL = 'SELECT mod_libelle FROM el_module WHERE mod_id = ' . MySQL::checkChampVersBase($p_code);
		$result = mysql_query($requeteSQL) or die(mysql_error() . 'module::constructeur1: ' . $requeteSQL);
		if ($object = mysql_fetch_object($result)) {
		    $this->m_id = MySQL::checkChampVersObjet($p_code);
		    $this->m_libelle = MySQL::checkChampVersObjet($object->mod_libelle);
		}
		break;
	    case 2:
		$this->m_id = MySQL::checkChampVersObjet(func_get_arg(0));
		$this->m_libelle = MySQL::checkChampVersObjet(func_get_arg(1));

		break;
	    default :
		echo 'erreur constructeur';
		break;
	}
    }
     //les methodes
      //methode magique
    public function __toString() {
	return $this->m_libelle;
    }
    //accesseur (le mieux étant de faire des accesseurs pour chacun des champs)
    public function __set($champ, $valeur) {
	$this->{$champ} = $valeur;
    }

    public function __get($champ) {
	return $this->{$champ};
    }
    // methode d'insertion
    public function insertMySQL() {
	$requeteSQL = 'INSERT INTO el_module (mod_libelle)
								VALUES(
								' . MySQL::checkChampVersBase($this->m_libelle) . '
								);';
	mysql_query($requeteSQL) or die(mysql_error() . 'module::constructeur2: ' . $requeteSQL);
	$this->m_id = mysql_insert_id();
    }

    public function updateMySQL() {
	$requeteSQL = 'UPDATE el_module SET
						mod_libelle = ' . MySQL::checkChampVersBase($this->m_libelle) . '					
					WHERE mod_id = ' . MySQL::checkChampVersBase($this->m_id);
	mysql_query($requeteSQL) or die(mysql_error() . 'module::updateMySQL: ' . $requeteSQL);
    }

    public function deleteMySQL() {
	$requeteSQL = 'DELETE FROM el_module WHERE mod_id = ' . MySQL::checkChampVersBase($p_code);
	mysql_query($requeteSQL) or die(mysql_error() . 'module::deleteMySQL: ' . $requeteSQL);
    }
      // un transformeur, il charge toutes les leçons du module dans le module
    public function chargeMesLecons() {
	$requeteSQL = 'SELECT lec_id,
				    lec_libelle
			    FROM el_lecon WHERE lec_mod_id = ' . MySQL::checkChampVersBase($this->m_id);
	$result = mysql_query($requeteSQL) or die(mysql_error() . 'module::constructeur1: ' . $requeteSQL);
	while ($object = mysql_fetch_object($result))
	    $this->m_mesLecons->ajouter(
		    new lecon(
			    $object->lec_id,
			    $object->lec_libelle
		    )
	    );
    }
     // les methodes statiques

    public static function tous() {
        //retourne une collection de module qui contient tous les modules.
	$requeteSQL = 'SELECT mod_id,mod_libelle from el_module order by mod_ordre';
	$result = mysql_query($requeteSQL) or die(mysql_error() . 'module::constructeur1: ' . $requeteSQL);
	$lesModules = new Collection();
	while ($object = mysql_fetch_object($result)) {
	    $lesModules->ajouter(new module($object->mod_id, $object->mod_libelle));
	}
	return $lesModules;
    }

}



Les accès à la base c'est dans les classes (donc si tu as un problème de requête tu sais que c'est un problème dans une de tes classes). Et Après pour l'utilisation c'est que du fun et c'est clair.
un exemple d'utilisation (le but étant d'afficher le sommaire d'une application de E-learning) :
Module -> leçons -> séquences -> Objectifs

//j'extrais tous les modules
//j'affiche le 1er module
//je charge les lecons du modules
//j'affiche la premiere leçon du module
// je charge les sequences de la leçon etc....
$lesModules = module::tous();
for ($im = 0; $im < $lesModules->cardinal(); $im++) {
    $leModule = $lesModules->extraire($im);
    ?>
    <h2><?= $leModule ?></h2>
    <?php
    $leModule->chargeMesLecons();
    for ($il = 0; $il < $leModule->m_mesLecons->cardinal(); $il++) {
	$laLecon = $leModule->m_mesLecons->extraire($il);
	?>
	<h3><?= $laLecon ?></h3>
	<?php
	$laLecon->chargeMesSequences();
	?>
	<ul>
	<?php
	for ($is = 0; $is < $laLecon->m_mesSequences->cardinal(); $is++) {
	    $laSequence = $laLecon->m_mesSequences->extraire($is);
	    $laSequence->chargeMesObjectifs();
	    for ($io = 0; $io < $laSequence->m_mesObjectifs->cardinal(); $io++) {
		$lObjectif = $laSequence->m_mesObjectifs->extraire($io);
		?>
		<li><?= $lObjectif  ?> (<?= $laSequence ?>)</li>
		<?php
	    }
	}
	?>
	</ul>
	<?php
    }
}



Voila ! Je ne dis pas que c'est parfait mais j'essaie de respecter au maximum les principes de la POO si chère à mes yeux.

Dans une prochaine leçon tu verras l’héritage (permet de maintenir une bonne évolutivité) et les interfaces (permet de définir des règles), tu pourrais aussi voir les classes statiques (permet + ou - de faire du procédural dans une application objet)
Modifié par Su4p (05 Jul 2011 - 11:49)
Smiley smile Smiley smile Smiley smile Bonjour et merci, car ton message, tout d'abord, me redonne un peu de baume au coeur. j'ai essayé déjà de faire pas mal de tuto, lire des cours... mais je ne parviens pas, seule, à mettre tout ça en application.

je vais lire attentivement les liens que tu proposes et l'exemple de ta classe de connexion.

j'ai déjà réussit à faire un mini système qui "parlait à ma base" en mysql, en revanche dès que je tente de le faire en pdo, et qui plus est avec des requêtes préparées, l'enfer commence.

pourtant vu la flexibilité je crois que PDO est intimement lié à l'OO...

Merci de ton aide en tous les cas
Je n'utilise pas PDO par contre, sur ce point je ne peux pas t'aider. Mais si tu as des questions concernant la POO je me ferait un plaisir d'y répondre .
PDO constitue déjà en soit une librairie POO pour la connexion à une base de donnée.
La logique voudrait donc d'étendre PDO pou ry ajouter les fonctionnalités que tu souhaites.

Par exemple ajouter un singleton pour récupérer le connexion courante ou ajouter des méthodes de construction de requête.
merci vraiment de votre aide et de vos encouragements.
Petite question en te lisant moust : donc dans l'idée, il est impossible de créer une class :
'class PDO{ //...}' car elle existe déjà, en revanche tu me conseillerais une classe :
'class PDObis extends PDO { //avec mes méthodes perso pour lire/ajouter/modif/delete... }'...
je te suis ?
Aurais-tu un exemple (une méthode) pour voir simplement comment ça s'organise pour faire des requêtes préparées qui fonctionnent ?
Merci d'avance
Perso j'utilise une classe Model de base contenant mes méthodes CRUD (create, read, update et delete). Ensuite pour chaque module de mon projet j'ai un ou plusieurs modèles qui étendent la classe Model et dans lesquels j'ai mes méthodes spécifiques au module.

Pour la connexion je préfère garder ça dans une classe indépendante de PDO, au cas où je devrais par exemple utiliser mysqli plutôt que PDO sur un projet spécifique (ou une autre extension) je préfère avoir le minimum de dépendance.

a écrit :

Aurais-tu un exemple (une méthode) pour voir simplement comment ça s'organise pour faire des requêtes préparées qui fonctionnent ?


Attention avec les requêtes préparées :

- PDO ne veut pas forcément dire requêtes préparées.
- Abuser de ce type de requête à un impact sur les performances.

Voilà un exemple de requête préparée que j'utilise dans ma classe Model (c'est la méthode qui sert à insérer ou mettre à jour un enregistrement dans la base de données) :


	/**
	 * Insert or update a record
	 *
	 * @access public
	 * @param array $data Data to save
	 * @param mixed $id Table's primary key as string or bool FALSE
	 * @return int id
   */
	public function save($data=array(), $id_name=NULL, $table_name=NULL)
	{
		$id_name = !empty($id_name) ? $id_name : $this->id_name;
		$table_name = !empty($table_name) ? $table_name : $this->table_name;

		if (empty($data[$id_name]))
		{
			$fields = '';
			$prepared_fields = '';
			foreach ($data as $k => $v)
			{
				$fields .= $k.', ';
				$prepared_fields .= ':'.$k.', ';
			}

			// remove last comma and space
			$fields = substr($fields,0,-2);
			$prepared_fields = substr($prepared_fields,0,-2);

			$query = "INSERT INTO ".TABLE_PREFIX.$table_name." (".$fields.") VALUES (".$prepared_fields.")";
		}
		else
		{
			$fields = '';
			foreach ($data as $k => $v)
			{
				if ($k != $id_name)
					$fields .= $k."=:".$k.", ";
			}

			// remove last comma and space
			$fields = substr($fields,0,-2);

			// update existing datas
			$query = "UPDATE ".TABLE_PREFIX.$table_name." SET ".$fields." WHERE ".$id_name."=".$data[$id_name];
			$old_id = $data[$id_name];
			unset($data[$id_name]);
		}

		try {
			$prepare = $this->db->prepare($query, array(PDO::ATTR_CURSOR => PDO::CURSOR_FWDONLY));
			$prepare->execute($data);
		}
		catch(PDOException $e) {
			Db::outputError($e->getMessage(), $this->db->errorInfo(), $query, __FILE__, __LINE__);
			return FALSE;
		}
 		
		return isset($old_id) ? $old_id : $this->db->lastInsertId();
	}

Modifié par jb_gfx (05 Jul 2011 - 18:56)
C'est ça.

Je peux te donner en exemple la base d'une classe que j'utilise de temps en temps pour exploitation simple de PDO. Il s'agit d'une simple extension pour profiter un signleton, comme je l'évoquais dans ma réponse précédente, qui permet de récupérer la connexion courante ou le cas échéant d'instancier la connexion PDO avec les données de configuration gérées via une autre classe de mon cru (que je ne développerai pas ici car ce n'est pas le sujet).

class Database extends PDO
{
	private static $_connexion;
	
	public static function getConnexion()
	{
		if( self::$_connexion )
		{
			return self::$_connexion;
		}
		
		$dsn = Config::get('database_dsn');
		$user = Config::get('database_user');
		$password = Config::get('database_password');
		$driver_options = Config::get('database_driver_options');
		
		try {
		    self::$_connexion = new self($dsn, $user, $password, $driver_options);
		}
		catch (PDOException $e)
		{
		    throw new Exception('Échec de connexion à la base de donnée : ' . $e->getMessage());
		}

		return self::$_connexion;
	}
	
}

Modifié par moust (05 Jul 2011 - 19:01)
Ok ok je comprends mieux je crois, et vos exemples ne sont pas de trop.
Merci à vous.
Je vais m'attacher à créer cette première classe donc, en reprenant.
je l'éditerais ici dès qu'elle sera faite et vous me direz ce que vous en pensez.
Je vous remercie encore.
Bonjour bonjour,
Je n'ai pas réussit à faire ce que je voulais, cette classe et la fonction pour lire me pose bien des difficultés... °__°'
Quelque chose m'échappe.
Bon voici :

Ma page index.php (pour ce qui importe)

	//$connexion =
	$connexion = Connexion::getInstance($config);
	var_dump($connexion);
	$Contact=new Contact($config);
	$Contact->lire();


Ma classe Contact.class.php

class Contact extends Model
{
	public $_table = 'contacts';
	public $_prefId = 'cont_';
	public $_config;
	
	public function __construct($pConfig)
	{
		$this->_config=$pConfig;
	}
}



// Connexion BDD = classe Singleton
class Connexion extends PDO
{
	//durée d'execution du script
	private $_startTime;
	private $_endTime;
	private $_time;
    
	//valeurs de la connexion à la BDD à null
	private static $_instance = null;
	
	private $_config;
	
	public function __construct($pConfig=false)
	{
		$this->_config = $pConfig; 
		
		//si fction construct déclenchée, tps départ en microsecondes
		$this->_startTime = round(microtime(), "6");
        
		self::$_instance = null;
		
		//connexion
		try
		{
			self::$_instance = new PDO($this->_config['dsn'],$this->_config['user'],$this->_config['password']);  
		}
		//gestion des erreurs
		catch(PDOException $e)
		{
			echo 'Erreur de connexion au serveur MySQL ! <br /> Erreur détectée : '.$e->getMessage();
			exit(); 
		}
	}
	
	//"anti-cloning" (classe Singleton)
	public function __clone()
	{
	}
	/*  2nd type d'"anti-cloning" :
			public function __clone()
			{
			  throw new Exception('ERREUR DE MANIPULATION : Tentative de clônage de la classe Singleton Connexion !');
			}
	*/
	
	//lancement de la connexion
	public static function getInstance($config)
	{
		//si la propriété $_instance vaut null, créée la connexion, sinon renvoit sa valeur
		if (is_null(self::$_instance))
		{
			self::$_instance = new Connexion($config);
		}
		return self::$_instance;
	}
	
	public function __destruct()
    {
        if (!is_null(self::$_instance)) 
		{
            self::$_instance = null;
            echo 'Connexion fermée.';
        }
    }
	
	public function getTimeScriptConnexion()
	{
		//fin du script
			$this->_endTime = round(microtime(), "6");
		//calcul du temps d'éxecution du script de connexion BDD en microsecondes
			$this->_time = $this->_endTime - $this->_startTime;
			$this->_time = round($this->_time, "6");
			
			$this->_timeScript = 
				'<table border="1" cellspacing="0" cellpadding="5">
					<th colspan=2 style="background:#cccccc">Temps du script
					</th>
					<tr> 
						<td style="background:#eeeeee">Début du script
						</td>
						<td>' . $this->_startTime . '
						</td>
					</tr>
					<tr>
						<td style="background:#eeeeee">Fin du script
						</td>
						<td>' . $this->_endTime . '
						</td>
					</tr>
					<tr>
						<td style="background:#eeeeee">Tps d\'éxecution total
						</td>
						<td>' . $this->_time . '
						</td>
					</tr>
				</table>' ;
				
			echo $this->_timeScript ;
	}
}


Ma classe Model.class.php

class Model 
{
	//propriété nom de la table
	public $_table;
	//prefixe
	public $_prefId;
	//$id pr delete
	public $_id;
	//config
	public $_config;
	
	//connexion Database
	private $_db;
	//sql
	private $_sql;
	//état
	private $_statement;
	
	public function __construct($pConfig)
    {
        $this->_config=$pConfig;
		$this->_db = Connexion::getInstance($this->_config);
    }	
	
	//fction lecture champs BDD
	public function lire($champs=null)
	{
		
		//si pas de paramètre
		if ($champs==null) { $champs='*'; }
		//prépare la requete
		$this->_sql = "SELECT $champs FROM ".$this->_table." WHERE ".$this->_prefId."id=".$this->_id;
		try
		{
			//prépare & execute la requete
			$this->_db = Connexion::getInstance($this->_config);
			$this->_db->prepare($this->_sql);
			$this->_db->execute();
			$this->_result=$this->_db->fetch(PDO::FETCH_ASSOC);
			print_r($this->result);
			//parcours du tableau et récupération des données
			foreach ($this->result as $cle=>$valeur)
			{ 
				$this->$cle = $valeur;
			}
		}
		catch(PDOException $e){
		   echo 'Erreur : '.$e->getMessage();
		   exit();
		}
	}
}


Résultat :
- Warning: PDO::prepare() [pdo.prepare]: SQLSTATE[00000]: No error: PDO constructor was not called in D:\wamp\www\...\includes\class\Model.class.php on line 38
- Fatal error: Call to undefined method Connexion::execute() in D:\wamp\www\bdd_technisante\laverie_gd_trou\includes\class\Model.class.php on line 39
Donc il n'instancie pas ma classe, il ne lance pas mon constructeur ?
C'est pas ce que je fais dans le construct ?
Pourtant si je le var_dump(),il me semble que la connexion se fait bien.
Pas évident tout ça...je m'en vois pour comprendre comment ça fonctionne.
Bref,entre temps j'ai essayé de faire une calculette du coup, pour faire de la poo sans bdd.
là aussi je me casse les dents.
Et moust, j'ai essayé de lire et comprendre le lien que tu m'avais donné mais je crois que c'est encore trop complexe...
Pfiou ! que de déception...
Que me conseillez vous (à part fuir au job)?
Modifié par ClR (08 Jul 2011 - 11:38)
Quel est le code de ta classe Connexion ?

Au passage, ce n'est pas très pratique de devoir transmettre à chaque appel les données de configuration.
Bonjour,
Et voila , je vais encore faire hurler mais bon ....
Je veux te convaincre a ne jamais mettre de PDO dans une de tes class POO,
pourtant tu trouvera des millier de sujet qui t'explique comment le faire.
Coluche dirait:
"Ce n'est pas parcequ'ils sont nombreux a avoir tort qu'ils ont raison" Smiley cligne

Allez pour essayer de te convaincre je vais caricaturer, admetons que ton POO me plaise
(celui qui inclu du POO (PDO) dans ton POO.
Alors pour l'utiliser je vais le "mettre a ma main", en me faisant ma CLASS a moi
Ainsi j'aurais des CLASS de CLASS de CLASS .... bonjour le débuguage Smiley decu
Modifié par Christele (08 Jul 2011 - 11:30)
Bonjour,
@moust : Tout d'abord désolé pour l'oubli de la class connexion... J'ai édité le message précédent afin qu'elle y soit également. et oui en effet, mais je ne suis pas parvenu à ne pas refaire passer mon tableau de config pour rester connectée.
@Christele : tous les conseils sont les bienvenus, et tu peux ouvrir le débat. Moi je débute alors je suis à l'écoute... Smiley smile
Si quelques experts pouvaient s'exprimer sur le sujet...
Modifié par ClR (08 Jul 2011 - 12:47)
ClR a écrit :
Bonjour,
@Christele : tous les conseils sont les bienvenus, et tu peux ouvrir le débat. Moi je débute alors je suis à l'écoute... Smiley smile

Dans ma caricature, je parlais de CLASS de CLASS de CLASS Smiley eek

Toi n'exagérons pas tu n'est qu'a CLASS de CLASS , mais il te suffit de lire la litanie des erreurs obtenues pour comprendre que si tu as des CLASS a toi c'est parfait,
mais appelles PDO toi même directement ...
Pages :