[POO] Utiliser des fonction statique ou un héritage

**pierrot10** · 15/02/2010, 20h44

Bonjour,
J'ai un petit soucis de choix a faire et ma connaissance de strater me pousse a vous demander votre avis.

J'ai créé une classe qui va etre utiliser pour faire les validations de champs dans le cadre d'un formulaire.
Dans ma classe j'ai plusieur fonctions dont voici un "extrait"

Code PHP :

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
 
class Check{
	private $call_NoData;
 
	public function Security($data){
		$data = trim(strip_tags($data));			//Remove all html and php code
		return $data;
	}
 
	public function RemoveAccent($string,$charset='utf-8'){
		$string = htmlentities($string, ENT_NOQUOTES, $charset);
	    $string = preg_replace('#\&([A-za-z])(?:acute|cedil|circ|grave|ring|tilde|uml)\;#', '\1', $string);
    	$string = preg_replace('#\&([A-za-z]{2})(?:lig)\;#', '\1', $string); // pour les ligatures e.g. '&oelig;'
    	$string = preg_replace('#\&[^;]+\;#', '', $string); // supprime les autres caractères
 
    	return $string;
	}
 
 
	public function NoData($name,$val){
		if(empty($val)) {
			$error = '<p class="f_error">Le champs <b>'.$name.'</b> ne doit pas &ecirc;re vide.</p>';	
			$this->call_NoData = 1;
		}else{ 
			$error ='';
			$this->call_NoData = 0;
		}
		return $error;
	}
}

J'ai une autre classe qui va hériter de cette dernière, et qui va elle définir un champs field

Code PHP :

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
class Field extends Check{
	private $accept;
	private $accesskey;
	private $align;
	private $alt;
	private $border;
	private $checked;
	private $dir;
	private $disabled;
	private $height;
	private $hspace;
	private $lang;
	private $maxlength;
	private $onblur;
	private $onchange;
	private $ondblclick;
	private $onfocus;
	private $onkeydown;
	private $onkeypress;
	private $onkeyup;
	private $onmousedown;
	private $onmousemove;
	private $onmouseout;
	private $onmouseover;
	private $onmouseup;
	private $onselect;
	private $readonly;
	private $size;
	private $src;
	private $style;
	private $tabindex;
	private $title;
	private $usemap;
	private $width;
 
 
	private $field;
 
	public function __construct($id,$name,$class,$value){
		$this->field = '<input id="'.$id.'" name="'.$name.'" class="'.$class.'" value="'.$value.'" /><br />';
	}
 
	public function __set($name, $value){
		echo 'Defini '.$name.' a : '.$value.'<br />';
		$this->$name=$value;
	}
 
	public function __get($name){
		echo 'Affiche '.$name.' : ';
		return $this->$name;
	}
 
	public function Display(){
		echo $this->field;
	}
 
}

Pour faire la validation je fais ainsi et ca marche très bien:

Code PHP :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
$nom = new Field('id_nom','nom','class','');
$nom->Display();
 
// -- ENVOI DU FORMULAIRE --//
// -- RECUPERATION DES VALEUR --//
 
(isset($_GET['nom'])) ? $f_nom = $_GET['nom'] : $f_nom = '';
 
	$f_nom = $nom->Security($f_nom);
	$f_nom = $nom->RemoveAccent($f_nom);
	echo $nom->NoData('Firstname',$f_nom);

Simplement, aujourd'hui, j'ai lu qu'on pouvais utiliser des fonction static qui me permette d'appeler des fonctions sans instentier la classe...

Donc si j'ai bien compris je pourrais faire ainsi

Code PHP :

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
 
class Check{
	private $call_NoData;
 
	static function Security($data){
		$data = trim(strip_tags($data));			//Remove all html and php code
		return $data;
	}
 
	static function RemoveAccent($string,$charset='utf-8'){
		$string = htmlentities($string, ENT_NOQUOTES, $charset);
	    $string = preg_replace('#\&([A-za-z])(?:acute|cedil|circ|grave|ring|tilde|uml)\;#', '\1', $string);
    	$string = preg_replace('#\&([A-za-z]{2})(?:lig)\;#', '\1', $string); // pour les ligatures e.g. '&oelig;'
    	$string = preg_replace('#\&[^;]+\;#', '', $string); // supprime les autres caractères
 
    	return $string;
	}
 
 
	static function NoData($name,$val){
		if(empty($val)) {
			$error = '<p class="f_error">Le champs <b>'.$name.'</b> ne doit pas &ecirc;re vide.</p>';	
			$this->call_NoData = 1;
		}else{ 
			$error ='';
			$this->call_NoData = 0;
		}
		return $error;
	}
}

et ma class Field, n'aurait plus besoin d'hériter de ma class Check.
N'est-ce pas?

je pourrais donc , ensuite, faire ainsi:

Code PHP :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
$nom = new Field('id_nom','nom','class','');
$nom->Display();
 
// -- ENVOI DU FORMULAIRE --//
// -- RECUPERATION DES VALEUR --//
 
(isset($_GET['nom'])) ? $f_nom = $_GET['nom'] : $f_nom = '';
 
	$f_nom = Check::Security($f_nom);
	$f_nom = Check::RemoveAccent($f_nom);
     echo Check::NoData($f_nom);

Donc pourquoi utilirais-je l'héritage?

**RunCodePhp** · 16/02/2010, 07h29

Salut

Personnellement, je ne vois pas vraiment l'intérêt de créer une classe Field, je trouve le concept un peu lourd, mais pourquoi pas.

Cependant, et dans ce cas là, j'aurais vu une classe Parente Formulaire qui aurait des classes enfants Form, Fieldset, Legend, Label, Input, Texarea, etc ... (qui hériterait donc de Formulaire).
Enfin, comme ça au feeling ...

et ma class Field, n'aurait plus besoin d'hériter de ma class Check.
N'est-ce pas?

Une méthode "static" de Security et de RemoveAccent me parais judicieux, il s'imposerait presque.
Par contre, je ne vois pas en quoi la classe Check hériterait de la classe Field, j'ai tendance à dire qu'elle n'ont pas grand chose en commun. Une vérification de données ne s'arrête pas seulement à un champ de formulaire, on "s'enfermerait" en quelque sorte.

Pour ce qui est du noData, là, j'adhère pas trop au concept, mais pourquoi pas.
Les retours d'erreurs peuvent être nombreux, et il me semble qu'il serait intéressant de déboucher sur 1 seul message d'erreurs rassemblant toutes les erreurs possible.
En gros, une méthode dans une condition : if ($check->hasError() === true) echo $check->getMessageError();
Donc d'éviter de traiter chaque champ individuellement, ce qui reviendrait presque au même de le faire "à la mano".
Le gros problème, l'énorme problème même, c'est : Quelles sont les vérifications à faire ?
Si on s'oriente à faire une classe que je dirais "généraliste" pour vérifier que chaque données retournées soient conforme à ce qui est attendue, il faudra définir à un moment ou à un autre la spécificité du champ à contrôler.
A mon sens il est impossible de le définir dans une classe, il risque fort d'en avoir de trop tellement les cas sont nombreux (numérique, date, mail, nombre à 10 chiffre, un autre seulement de 9, etc, etc ...).

L'orientation que tu prends n'est pas du plus simple, mais intéressant.

Personnellement, j'ai abandonné cette idée, les cas étaient tellement nombreux qu'il était compliqué de tous les gérer correctement, et en plus, en cas de re-looking ou de changement de logique d'une page par exemple, cela demande revoir tout ou en partie de cette classe, ce qui au final rend un projet difficilement évolutif, gros manque de souplesse.
Attention donc de ne pas tomber dans ce piège, on a vite fait tomber dedans.
Be carrefull

**pierrot10** · 16/02/2010, 09h23

Salut RUncodephp,

Super et mercis pour ton grand commentaire. J'en entre temps décidé que la class Check n'hérite plus la class Field et rendre toutes les function static de la class Check. C'est aussi plus claire dans mon code, dans la partie de validation. De plus je me joins a tes remartques... .

Aussi, je trouve très intressant ta remarque concernat un classe Formulaire dont ses attributs sont Field, textarea etc. Donc je vais revoir aussi ceci afin de rendre mon code encore mieux

.

Personnellement, j'ai abandonné cette idée, les cas étaient tellement nombreux

Personnellement, ca me "gonffle" de faire des formulaires, car ca prend du temps surtout si on veut le faire proprement avec une chaine de validation. Et vu que je developpe depuis un moment en PHP, mais que je ne me suis jamais tourné sur l'OO, je me suis dit que c'était un super exercice pour débuter (meme si je me lance dans un truc trop dur) en OO en faisant un formulaire qui me permettrait de pouvoir le mettre en place rapidement, en le "paramettrant", tout en gardant une partie de validation, qui me semble importante... Voilà, mais c'est avant un tout un exercice, que je trouve super intéressant, pour acquérir des premieres expériences en OO

.

En tout cas, milles mercis pour tes commentaires.

**ThomasR** · 16/02/2010, 09h36

Bonjour,

Cependant, et dans ce cas là, j'aurais vu une classe Parente Formulaire qui aurait des classes enfants Form, Fieldset, Legend, Label, Input, Texarea, etc ... (qui hériterait donc de Formulaire).

Non, conceptuellement, un champ Input n'hérite en rien d'un formulaire.
Ce qu'il faut faire c'est implémenter une collection de champ au sein de la classe Form.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
class Form implements ArrayAccess {
    private $action, $name, $enctype, $fields;
    // arrayaccess methods ... (to loop through fields)
}

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
 
class FormField {
    private $name, $id, $value;   
 
    public function __construct($id, $name, $value){
        $this->id = $id;
        $this->name = $name;
        $this->value = $value;
    }
 
    public function getValue(){
        return $this->value;
    }
 
    abstract public function onDisplay();
    abstract public function onSave();
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
class InputText extends FormField {
    public function onDisplay(){
        echo '<input id="'.$this->id.'" type="text" name="'.$this->name.'" value="'.$this->value.'" />';
    }
 
    public function onSave(){
        if(!check::isempty($_POST[$this->name])){
             echo 'VALEUR DE CHAMP VALIDE';
        }
    }
}

et ma class Field, n'aurait plus besoin d'hériter de ma class Check.
N'est-ce pas?

Tout à fait, si l'appel des méthodes de Check ne nécessitent pas d'instance, alors ces méthodes doivent être statiques.

**pierrot10** · 16/02/2010, 09h44

Ok Excellent, vous êtes extra!!
A ce moment, je ne peux pas me pencher sur vos réponses, mais je vois que du bon!!!

Je lirais attentivement toutes vos suggestions, et je suis juste impatient de corriger tout mon code en fonction de vos remarques, ce soir.

En tout cas, encore Mercis pour vos commentaires.

**pierrot10** · 16/02/2010, 19h51

Je ne veux pas réouvrir un post, alors je profite de celui là pour poser une petite question sur les fonction static.

J'ai donc un classe qui contient que des fonction static. Je n'arive pas à déclarer un variable, ou un attribut, que je souhaite utilisé dans cahque fonction static.

J'ai pensl faire ainsi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const $var;

mais j'ai un mesage d'erreur dans mes functions

Comment puis-je utiliser/declarer une varaible dans chaque fonction?

Aussi, qu'es-ce un fonction abstraite?

Mercis mercis

**vexa** · 25/03/2010, 19h42

Bonsoir,

La démarche est intéressante mais peut-être qu'utiliser une brique logicielle officielle et maintenue par une communauté d'utilisateurs serait plus simple.

Go to http://framework.zend.com/apidoc/core/ et partie Zend_Form
avec tout un tas d'éléments du type checkbox, radio button , ...

Xavier

**Thes32** · 26/03/2010, 17h04

Salut,
@RunCodePhp

Envoyé par RunCodePhp

...A mon sens il est impossible de le définir dans une classe, il risque fort d'en avoir de trop tellement les cas sont nombreux (numérique, date, mail, nombre à 10 chiffre, un autre seulement de 9, etc, etc ...).

Sur base du modèle qu'à fait ThomasR tu peux bien résoudre ton problème en y ajoutant une couche supplémentaire de contrôle indépendante de la classe.

Tu aurais par exemple une interface qui te permettras d'instancier des objets de validation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
interface FormCheck
{
   public function check( $value );
}

une classe de validation aura la forme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
class SampleCheck implements FormCheck
{
   public function check( $value )
   {
      //code de vérification ici renvoyant un booléen
   }
}

Dans la classe mère de ThomasR on pourrait avoir deux méthodes supplémentaires telle que :

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
 
class FormField {
    private $name, $id, $value; 
    public $checkArray = array();
 
    //constructeurs et autres méthodes
    //...
 
   //fonction d'ajout d'un validateur
    public function registerCheck( $checkFunction )
   {
       $this->checkArray = array_push( $this->checkArray, $checkFunction );
    }
 
    //fonction d'appel des validateurs enregistrés 
     public function applyCheckFunctions()
    {
       foreach( $this->checkArray as $checker )
       {
          if( !$checker->check( $this->value ) )
            return false;
       }
    }
 
}

Un peu de pratique :

création d'un checker

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class TextInputCheck implements FormCheck
{
   //un checker qui vérifie que la longueur du texte est > à 10
   public function check( $value )
   {
      if( str_len( $value ) > 10 )
        return false;
   }
}

création d'un autre checker

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
class TextInputCheck2 implements FormCheck
{
   //un checker qui vérifie que la chaîne ne contient pas un nombre
   public function check( $value )
   {
      if( preg_match( '/\d/' , $value) )
        return false;
   }
}

un exemple

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
 
//creation d'un champ input text
$myInput = new InputText( 'id', 'name', 'une valeur' );
 
//creation d'un checker 1
$mycheck = new TextInputCheck();
 
//creation d'un checker 2
$mycheck2 = new TextInputCheck2();
 
//assignation du checker 1 à l'input text
$myInput->registerCheck( $mycheck );
 
//assignation du checker 2 à l'input text
$myInput->registerCheck( $mycheck2 );
 
$myInput->doSave();
}

@ThomasR : Merci pour ta réflexion.

**pierrot10** · 26/03/2010, 20h25

Salut tous,
merci pour ces riches informations. Elles sont fortes intéressantes et je vais adapter ma classe en fonction de vos suggestions.
Pierrot

**pierrot10** · 27/03/2010, 23h05

Salut thomas,
Je m'intéresse a ton idée,
mais mes conniassances me peine.
Pourrais tu m'éclaissir sur ceci?

Code PHP :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
    public function __call($name, $args){
        if(method_exists('checker', $name)){
             $result = call_user_func_array(array('a', $name), $args);
             $return = $result === TRUE;
             if(!$return) $this->_errors[] = $result;
             return $return;
        }
        return;
    }

Autre petit détail que je en comrpends pas, c'est que ceci à qu'un argument

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print_r($checker->isEmptyString('Bonjour'));

Alors que la methode magique __call() en a deux?

Finalement, les message d'errter sont "stockés" ou? Dans les methodes statiques de la classe check? mais pourtant elles ne devraient pas retourner une vrai ou un faux?

**ThomasR** · 28/03/2010, 15h41

Bonjour,

Envoyé par pierrot10

Pourrais tu m'éclaissir sur ceci?

Code PHP :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
/* Fonction appelée lorsqu'on appelle une méthode sur notre instance de checker, cette classe s'appuie sur la classe check qui ne possède que des méthodes statiques */
public function __call($name, $args){
        // si la méthode $name existe dans la classe check
        if(method_exists('check', $name)){
             // on appelle la méthode $name sur la classe check (appel statique) 
             $result = call_user_func_array(array('check', $name), $args);
             // si cette méthode renvoie true alors la validation est OK
             $return = $result === TRUE;
             // sinon on récupère l'erreur dans une liste, cette erreur peut être une chaine
             if(!$return) $this->_errors[] = $result;
             return $return;
        }
        return;
    }

Envoyé par pierrot10

Autre petit détail que je en comrpends pas, c'est que ceci à qu'un argument

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

print_r($checker->isEmptyString('Bonjour'));

Alors que la methode magique __call() en a deux?

La méthode _call est une méthode magique.
http://fr.php.net/__call

Envoyé par pierrot10

Finalement, les message d'errter sont "stockés" ou? Dans les methodes statiques de la classe check? mais pourtant elles ne devraient pas retourner une vrai ou un faux?

Ils sont stockés dans le membre _errors de ton instance checker et accessible grâce à la méthode getErrors() :
Et les méthodes retournent bien vrai ou faux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
$string = 'Bonjour';
// $string = null;
if(!$checker->isEmptyString($string)){
   echo 'C\'est good';
}
if($checker->hasErrors()){
    foreach($checker->getErrors() as $i => $e){
        printf('<p>Erreur %d : %s<p/>', $i, $e);
    }
}

[POO] Utiliser des fonction statique ou un héritage

Langage PHP

Vue hybride

Discussions similaires

Partager

Partager