Bonsoir,

Je m'essaye a la programmation OBJECT (et c'est pas gagné)

Ma class user

class User
 {
 	private $pseudo;
 	private $email;
 	private $password;


	 	public function __construct($dbh, $ps, $pa)
	 	{
	        $pseudo   = (iSset($ps) ? $ps : NULL );
	        $password = (iSset($pa) ? $pa : NULL);

	 		$sql = " SELECT id_user, pseudo, nom, prenom, password, email, grade, photo FROM users
	 		         WHERE pseudo = :pseudo
	 		         AND password = :password ";

	        $result = $dbh->prepare($sql);

	        $var = array(':pseudo' => $pseudo,
	                     ':password' => $password);

	        $result->execute($var);
	        $resultat  = $result->fetchAll(PDO::FETCH_ASSOC);

	        $nbr = count($resultat);

			if($nbr === 0)
			{
				echo '<div class="error">Identifiants incorrects!</br>';
				echo '<a href="membre.php">Recommencer</a></div>';
				exit();
	        }
	        elseif($nbr === 1)
	        {
	            $row = $resultat[0];

			    $this->iduser = $row['id_user'];
			    $this->pseudo = $row['pseudo'];
			    $this->pass   = $row['password'];
			    $this->nom    = $row['nom'];
			    $this->prenom = $row['prenom'];
			    $this->email  = $row['email'];
			    $this->grade  = $row['grade'];
			    $this->photo  = $row['photo'];
	        }
	        else
	        {
	        	echo 'Erreur technique !<BR />';
	        }




	 	}


	 	//-->GETTER<---//
	    public function getPseudo()
	    {
	        return $this->pseudo;
	    }

	    public function getPassword()
	    {
	        return $this->pass;
	    }

	    public function getNom()
	    {
	        return $this->nom;
	    }

	    public function getPrenom()
	    {
	        return $this->prenom;
	    }

	    public function getEmail()
	    {
	        return $this->email;
	    }

	    public function getGrade()
	    {
	        return $this->grade;
	    }

	    public function getIduser()
	    {
	        return $this->iduser;
	    }

	    public function getAvatar()
	    {
	        return $this->photo;
	    }

 }

Ma question est la suivante y a t'il un autre moyen que de créer des GETTER pour avoir accée a mes variables ?

D'avance merci

tu les met en public

public $pseudo;

tu y accède comme ca après

$user->pseudo


tu pourrais faire un surcharge avec __call si tu tiens a garder la forme getMachin()

Salut,
Ok merci

Oui mais ce n'est pas équivalent du point de vue de l'utilisation de ton code.

En faisant comme dans ton premier exemple $user->getNom() tu ne peux récupérer que la valeur de $this->nom et il n'existe pas de moyen externe (non contrôlé par ta classe) de modifier $this->nom.

Par contre si tu mets ta variable $nom en public tu peux affecter une valeur à ta variable $nom depuis l'extérieur de ta classe en faisant simplement $user->nom = 'toto'; donc cela peut également servir de setter

Donc globalement, quand la classe peut être employée par d'autre personnes que celui qui l'a programmée, on utilise de préférence ta première méthode avec les getters pour éviter toute fausse manip. La seconde est moins rigoureuse et demande de faire plus attention

Oui mais ce n'est pas équivalent du point de vue de l'utilisation de ton code.

En faisant comme dans ton premier exemple $user->getNom() tu ne peux récupérer que la valeur de $this->nom et il n'existe pas de moyen externe (non contrôlé par ta classe) de modifier $this->nom.

Par contre si tu mets ta variable $nom en public tu peux affecter une valeur à ta variable $nom depuis l'extérieur de ta classe en faisant simplement $user->nom = 'toto'; donc cela peut également servir de setter

Donc globalement, quand la classe peut être employée par d'autre personnes que celui qui l'a programmée, on utilise de préférence ta première méthode avec les getters pour éviter toute fausse manip. La seconde est moins rigoureuse et demande de faire plus attention

Oui je suis d'accord avec toi et c'est pour cela que je vais garder ma méthode certe plus rigoureuse mais également plus sur.
je voulais juste savoir si je pouvais éviter les getter qui à la longue me .... mais bon pas grave

la surcharge avec __call peu être une bonne alternative

et la méthode magique __get ? C'est pas le cas d'utilisation ici ? http://www.apprendre-php.com/tutoriels/ ... t-get.html

Ce serait plus approprié que __call, effectivement.

On peut simplifier

Personnellement, je procède comme suit : la méthode magique __get est fort pratique mais présente certains inconvénients : je ne veux pas que toutes les propriétés privés soient accessibles. Donc je filtre : dans le constructeur, je commence par initialiser un tableau des propriétés qu'on peut récupérer de l'extérieur. Ensuite, j'ajuste mon __get(). En reprenant ta classe de base, la transformation donnera ceci :

<?php
class User
{
    private $pseudo;
    private $email;
    private $password;
    /**
     * Liste des propriétés récupérables par getter
     *
     * @var Array
     */
    private $_aProps = array();


    public function __construct($dbh, $ps, $pa)
    {
        $pseudo   = (iSset($ps) ? $ps : NULL );
        $password = (iSset($pa) ? $pa : NULL);
        /**
         * Initialisation de la liste des propriétés accessibles par getter
         */
        $this->_aProps = array('id_user','pseudo','nom','prenom','password','email','grade','photo');

        $sql = "SELECT id_user, pseudo, nom, prenom, password, email, grade, photo
                FROM users
                WHERE pseudo = :pseudo
                AND password = :password ";

        $result = $dbh->prepare($sql);

        $var = array(
            ':pseudo' => $pseudo,
            ':password' => $password
        );

        $result->execute($var);
        $resultat  = $result->fetchAll(PDO::FETCH_ASSOC);

        $nbr = count($resultat);

        if($nbr === 0)
        {
            echo '<div class="error">Identifiants incorrects!</br>';
            echo '<a href="membre.php">Recommencer</a></div>';
            exit();
        }
        elseif($nbr === 1)
        {
            $row = $resultat[0];

            $this->iduser = $row['id_user'];
            $this->pseudo = $row['pseudo'];
            $this->pass   = $row['password'];
            $this->nom    = $row['nom'];
            $this->prenom = $row['prenom'];
            $this->email  = $row['email'];
            $this->grade  = $row['grade'];
            $this->photo  = $row['photo'];
        }
        else
        {
            echo 'Erreur technique !<BR />';
        }
    }

    //-->GETTER<---//
    /**
     * Getter unique avec filtration : on ne retourne pas tout : 
     * S'il ne s'agit pas d'une colonne de ma table, je jette.
     *
     * @param unknown_type $prop
     * @return unknown
     */
    public function __get($prop)
    {
        if(in_array($prop, $this->_aProps))
        {
            return $this->{$prop};
        }
        else 
        {
            throw new Exception("Propriété ". $prop ." non accessible de la classe ". __CLASS__ , E_USER_WARNING);
        }
    }
}

Salut Cyrano

Merci pour l'info, c'est effectivement bien plus pratique que ma méthode de départ.
je vasi testé

Merci

C'est sûr que pour des getters identiques c'est la solution idéale.

C'est quand les getters sont différents que l'intérêt de __get est moins évident car cela revient à traiter spécifiquement les différentes propriétés dans une grosse fonction plutôt que de faire des petits getters spécifiques.

Cela dit on peut aussi utiliser les deux méthodes conjointement

On peut simplifier

Pas mal Cyrano

Mais plutôt que de passer par un tableau contenant la liste des propriétés (ce qui peut quand même être assez long dans certain cas et surtout un peu galère à gérer), tu peux utiliser la fonction property_exists (si ta version de PHP est supérieur à la 5.1.0, ce dont je ne doute pas).

http://php.net/manual/fr/function.property-exists.php

Exact, mais l'intérêt du tableau, c'est que certaines propriétés existent et je souhaite qu'elles restent privée, et accessoirement, là il s'agit de colonnes d'une table : on peut très bien avoir des propriétés dynamiques qui n'auront pas été définies et qui sont alors initialisées à la volée dans le setter pour autant qu'on lui applique le même système. Dans sa classe, Dunbar fait ça dans le constructeur en initialisant des propriétés dynamiquement.

Par contre, l'utilisation suggérée de property_exists() peut très bien s'ajouter dans le filtrage du getter dynamique pour le cas où on aura pas initialisé une des propriétés dynamiques.

Effectivement, je suis passé un peu vite sur le code ^^

Je note ta façon de faire.

Instinctivement, j'aurai utiliser un switch/cases

    public function __get($prop)
    {
        switch($prop)
        {
             case "id_user":
             case "pseudo":
             case "nom":
             case "xxxx":
                  return $this->{$prop};
                  break;
            default:
               throw new Exception("Propriété ". $prop ." non accessible de la classe ". __CLASS__ , E_USER_WARNING);
        }
    }

Mais la solution du tableau me va aussi