Apprendre la POO doucement...

par AB » 02 juin 2008, 13:43

Oui c'est un peu plus simple tout en ayant les mêmes fonctionnalités.
Je fais souvent comme cela car ça me permet de connaitre directement les valeurs par défaut assignées aux propriétés sans avoir à regarder dans chacune des méthodes.

par **Cyrano** » 02 juin 2008, 07:03

Ou encore en simplifiant :

<?php
class VerifierFormulaire
{
    // Propriétés
    private $donnees;
    private $erreurs;
    private $ListeErreurs;
    private $separateur;
    // Constructeur
    public function __construct( $donnees, $separateur = ',' )
    {
        $this->donnees    = $donnees;
        $this->erreurs    = array();
        $this->separateur = $separateur;
    }
    
    // Méthodes
    private function Recup_champs($champs)
    {
        $tableau = explode($this->separateur, $champs);
        return $tableau;
    }   
    
    
    public function TesterChampsVides($Champs)
    {
        $Champs = $this->Recup_champs($Champs);
        //...

On affecte la valeur par défaut dns le paramètre du constructeur et dans ce cas on assigne de toutes façons cette valeur à la propriété VerifierFormulaire::separateur

par AB » 02 juin 2008, 02:28

C'est juste un exemple pour la forme mais ça pourrait donner quelque chose comme ça

class VerifierFormulaire
{
// Propriétés
    private $donnees;
    private $erreurs;
    private $ListeErreurs;
	private $separateur = ',';
// Constructeur
    public function __construct( $donnees, $separateur = null )
    {
        $this -> donnees = $donnees;
        $this -> erreurs = array();
		if (isset($separateur)) $this->separateur = $separateur;
        //$this -> ListeErreurs = NULL;
    }
	
// Méthodes
	private function Recup_champs($champs)
	{
	$tableau = explode($this->separateur, $champs);
	return $tableau;
	}   
	
	
    public function TesterChampsVides($Champs)
    {
        $Champs = $this->Recup_champs($Champs);

  //...

Pour instancier ta classe avec le séparateur ',' par défaut il te suffit de faire comme avant
$VerifForm = new VerifierFormulaire($_POST);

mais si tu voulais utiliser le point virgule sans avoir à modifier ta classe, il te suffirait de faire
$VerifForm = new VerifierFormulaire($_POST, ';');

Mais encore une fois ce n'est pas forcément utile, juste un exemple pour le principe.

par AB » 02 juin 2008, 01:33

Tant que tu n'as pas à l'utiliser depuis l'extérieur de ta classe, oui. Mais ça fonctionnerait également si tu la mettais "public". La mettre en "private" est une mesure de sécurité.

par **supercanard** » 01 juin 2008, 23:47

Par exemple dans tes méthodes de test tu fais systématiquement
$Champs = explode( ',', $Champs );
Tu pourrais faire une fonction pour réaliser cette ligne, fonction qui serait appelée par chacune de tes méthodes de test. Ainsi il te suffirait de changer uniquement cette fonction si pour une raison quelconque tu devais changer de séparateur. Mais tu pourrais aussi aller plus loin, déclarer une variable pour le séparateur qui par défaut pourrait-être égal = ',' et à l'instanciation de ta classe ou dans l'appel de tes fonctions, passer en argument le nouveau séparateur s'il est différent de celui par défaut. Cela rendrait ton objet adaptable à plus de situations. Bon, ce n'est pas nécessairement utile, mais juste un exemple au passage.

[Note : ce message a été posté de manière anonyme avant d'être réattribué à son auteur]

Juste pour voir si ça rentre bien dans mon crane : Cette méthode appellée par des autres serrais donc private ?

par AB » 01 juin 2008, 23:24

Par exemple dans tes méthodes de test tu fais systématiquement

$Champs = explode( ',', $Champs );

Tu pourrais faire une fonction pour réaliser cette ligne, fonction qui serait appelée par chacune de tes méthodes de test. Ainsi il te suffirait de changer uniquement cette fonction si pour une raison quelconque tu devais changer de séparateur. Mais tu pourrais aussi aller plus loin, déclarer une variable pour le séparateur qui par défaut pourrait-être égal = ',' et à l'instanciation de ta classe ou dans l'appel de tes fonctions, passer en argument le nouveau séparateur s'il est différent de celui par défaut. Cela rendrait ton objet adaptable à plus de situations. Bon, ce n'est pas nécessairement utile, mais juste un exemple au passage.

[Note : ce message a été posté de manière anonyme avant d'être réattribué à son auteur]

par **Cyrano** » 01 juin 2008, 21:36

lol, absolument et un jour tu monteras ce genre de chose toi-même D

par **supercanard** » 01 juin 2008, 20:38

Pour les variables dans les méthodes, ton raisonnement est tout à fait valable.

Et si ça fonctionne à ta satisfaction, alors c'est très bien. Avec le temps, tu amélioreras petit à petit certains détails. Comme par exemple faire des boucles foreach non pas sur les données mais sur le tableau issu du paramètre. Et au fond pourquoi ne pas envoyer directement un paramètre... etc, etc... Tout te montrer maintenant ne serait pas très utile à mon sens. Tes propres raisonnement t'amèneront à optimiser progressivement.

Merci de ta réponse.
Je vais pouvoir clore le topic.
Merci à tous ceux qui m'ont aidés et un merci spécial à toi Cyrano

C'est grâce à ton exemple que j'ai pu faire mon premier objet. J'ai l'impression d'être un gamin qui découvre les légo là

par **Cyrano** » 01 juin 2008, 18:41

Pour les variables dans les méthodes, ton raisonnement est tout à fait valable.

Et si ça fonctionne à ta satisfaction, alors c'est très bien. Avec le temps, tu amélioreras petit à petit certains détails. Comme par exemple faire des boucles foreach non pas sur les données mais sur le tableau issu du paramètre. Et au fond pourquoi ne pas envoyer directement un paramètre... etc, etc... Tout te montrer maintenant ne serait pas très utile à mon sens. Tes propres raisonnement t'amèneront à optimiser progressivement.

par **supercanard** » 01 juin 2008, 18:09

Pas évident à tout comprendre d'un seul coup ^^

Bon j'ai quand même réussi à faire mon tout premier objet, qui fonctionne

Meme si ma fonction TesterChampsIdentiques est un peu longue pour ce qu'elle fait.

J'ai toutefois un doute au niveau de tous mes foreach. J'utilise des variables ( $cle et $valeur) qui ne sont pas des propriétés de l'objet. je ne sais pas si j'ai eu tord mais mon raisonnement était que ces variables en question ne servent qu'au sein d'une fonction, donc il n'y a pas lieu que ces variables soient des propriétés de l'objet... puisqu'on ne s'en sert pas ailleur... ??

<?php
/*
A rajouter : Test valeur numérique et test valeurs identiques ( pours champs mot de passe )
*/
class VerifierFormulaire
{
// Propriétés
	private $donnees;
	private $erreurs;
	private $ListeErreurs;
// Constructeur
	public function __construct( $donnees )
    {
		$this -> donnees = $donnees;
		$this -> erreurs = array();
		//$this -> ListeErreurs = NULL;
    }
// Méthodes   
    public function TesterChampsVides( $Champs )
    {
		$Champs = explode( ',', $Champs );
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( ( in_array( $cle, $Champs ) ) && ( $valeur == NULL ) )
			{
				$this -> erreurs[] = 'Le champ '.$cle.' est obligatoire';
			}
		}
    }
	public function TesterChampsEmail( $Champs )
    {
		$Champs = explode( ',', $Champs );
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( ( in_array( $cle, $Champs ) ) && ( !ereg( '.+(@.+)(\.[[:alpha:]]{2}([[:alpha:]]?))$', $valeur ) ) )
			{
				$this -> erreurs[] = 'Le champ '.$cle.' doit contenir une adresse email valide';
			}
		}
    }
	public function TesterChampsIdentiques( $Champs )
    {
		$Champs = explode( ',', $Champs );
		$i = 1;
		$x = NULL;
		$y = NULL;
		foreach( $this -> donnees as $cle => $valeur )
		{
			if ( in_array( $cle, $Champs ) )
			{
				if ( $i == 1 )
				{
					$x = $valeur;
					$xNom = $cle;
					$i++;
				}
				else
				{
					$y = $valeur;
					$yNom = $cle;
				}
			}
		}
		if ( $x != $y )
		{
			$this -> erreurs[] = 'Les champs '.$xNom.' et  '.$yNom.' doivent être identiques';
		}
    }
	public function AfficherErreurs()
	{
		$this -> ListeErreurs .= '<ul>';
		foreach( $this -> erreurs as $valeur )
		{
			$this -> ListeErreurs .= '<li>'.$valeur.'</li>';
		}
		$this -> ListeErreurs .= '</ul>';
		return $this -> ListeErreurs;
	}
}
?>

<?php
########## Vérification du formulaire

/*
##### Paramètres
- TestChampsVides : Retournera une erreur si les valeurs sont vides
- TestChampsEmail : Retournera une erreur si les valeurs ne sont pas du type [email protected]
*/
$TestChampsVides = 'Nom,Email'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
$TestChampsEmail = 'Email'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
$TestChampsIdentiques = 'Password,Confirmation'; // Entrez le nom des champs à vérifier ( Entre les '' et séparés par des virgules )
/*
##### Vérification
*/
if ( isset( $_POST ) )
{
	$VerifForm = new VerifierFormulaire( $_POST );
	$VerifForm -> TesterChampsVides( $TestChampsVides );
	$VerifForm -> TesterChampsEmail( $TestChampsEmail );
	$VerifForm -> TesterChampsIdentiques( $TestChampsIdentiques );
	$ListeErreurs = $VerifForm -> AfficherErreurs();
	echo $ListeErreurs;
}
?>

<form method="post" action="#">
<p><label>Nom</label><input type="text" name="Nom" /></p>
<p><label>Email</label><input type="text" name="Email" /></p>
<p><label>Password</label><input type="password" name="Password" /></p>
<p><label>Confirmation</label><input type="password" name="Confirmation" /></p>
<input type="submit" />
</form>

par **Cyrano** » 01 juin 2008, 07:58

Voilà, tout simplement.

Mais encore une fois, tu initialises $this->erreurs à NULL, c'est complètement sans intérêt.

Un point qu'il faut arriver à saisir de la POO : lorsque tu crées une instance de classe, l'objet créé a des propriétés qui ont ou non une valeur selon ce que tu as défini dans le constructeur. Si tu n'as rien défini, alors la propriété n'a pas de valeur. Et c'est indépendant de ces mêmes propriétés pour un objet qui serait une autre instance parallèle de la même classe.

Pourquoi écrire davantage de code si le supplément est inutile ?

par **supercanard** » 31 mai 2008, 23:33

Ah bon attends cette fois je crois que j'ai compris. J'espere, mais si c'est pas le cas, promis je fait pas expré hein

Ce qui me met dans la confusion c'ets que lorsque je fait ça :

$VerifForm = new VerifierFormulaire( $_POST );

Je créé donc une instance, et je lui envois un tableau de données

Et dans le constructeur

public function __construct( $donnees )

Je passe donc ce tableau. Comme dans une fonction en fait.

Donc si j'ai bien suivis ça c'est juste ?

// ... Debut
public function __construct( $donnees )
    {
		$this -> donnees = $donnees;
		$this -> NbChampsVides = 0;
		$this -> erreurs = NULL;
    }

// ... suite

$VerifForm = new VerifierFormulaire( $_POST );

par **Cyrano** » 31 mai 2008, 22:57

Ah j'ai compris, rien ne sert d'envoyer le paramètre donc.
Désolé j'ai mis du temps à capter

Ben non animal...

mais si tu as :

public function __construct( $donnees )

Et qu'après ça tu fais :

$this -> donnees = $_POST;

Veux-tu bien m'expliquer à quoi sert d'envoyer $donnees ?? Et pourquoi tu ne fais pas plutôt :

$this -> donnees = $donnees;

par **supercanard** » 31 mai 2008, 18:30

Ah j'ai compris, rien ne sert d'envoyer le paramètre donc.
Désolé j'ai mis du temps à capter

Ok, et maintenant si je veut vérifier seulement certains champs, ma première idée et de faire comme ça, mais je suis pas sur même si ça marche très bien que ce soit une solution correcte... :
( Je me rend compte à l'instant que je n'ai pas déclaré $test comme propriété de l'objet, mais bon ça ne gène pas pour l'instant )

<?php
class VerifFormulaire
{
	private $NbChampsVides;
	private $cle;
	private $valeur;
	private $ErreursForm;

	public function __construct()
    {
		$this -> NbChampsVides = 0;
    }
    
    public function ChampVides( $test )
    {
		foreach( $test as $cle => $valeur )
		{
			if ( $valeur == NULL )
			{
				$this -> NbChampsVides++;
			}
		}
    }
	public function AfficherErreurs()
	{
		if ( $this -> NbChampsVides != 0 )
		{
			$this -> ErreursForm .= $this -> NbChampsVides.' champ(s) vide(s)';
		}
		return $this -> ErreursForm;
	}
}
?>

<?php
if ( isset( $_POST['Champ1'] ) )
{
	$VerifForm = new VerifFormulaire();
	$VerifForm -> ChampVides( array( $_POST['Champ1'] ) );
	$ErreursForm = $VerifForm -> AfficherErreurs();
	echo $ErreursForm;
}
?>

par **Cyrano** » 31 mai 2008, 17:39

Manqué.

Alors un détail : il est inutile d'affecté NULL à tes propriétés de classes. Si tu n'as pas de valeur à y affecter, alors tu les oublies tout simplement, elles seront initialisées au moment opportun dans les méthodes appropriées avec des valeurs.

Mais l'erreur n'est pas là. Tu avais une instanciation correcte de ta classe mais tu n'utilisais pas le paramètre envoyé. Pourtant au départ c'était la bonne méthode, c'est la suite qui ne collait pas.

C'est comme avec n'importe quelle fonction : si tu appelles une fonction en indiquant un paramètre, ça ne sert pas à grand chose si tu n'utilises pas ce paramètre. Penses-y un moment

Regarde ta méthode :

<?php
//... 
    public function __construct( $donnees )
    {
        $this -> donnees = $_POST;
        $this -> NbChampsVides = 0;
        $this -> cle = NULL;
        $this -> valeur = NULL;
        $this -> ErreursForm = NULL;
    }
//...

Là, ton paramètre $donnees n'est jamais utilisé, nulle part. Or c'est pourtant la manière logique d'envoyer les données à traiter dans ton objet. Donc...

Apprendre la POO doucement...

Répondre

Étendre la vue Revue du sujet : Apprendre la POO doucement...