foreach sur un objet

Version imprimable

Bonjour,

Est-il possible de faire un foreach sur un objet retourné dans le constructeur ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
class Functions {
 
private $func = []; 
 
public function __construct() { 
 $this->fonctions_a_appeler(); 
}
 
public function fonctions_a_appeler() {
 $this-> addFunction (['isRequired', 'isAlphaM']);
}
 
public function addFunction (array $functions=[]) { 
 $this->func = $functions;
}
 
public function getField() {
 return $this->func; 
}

Code:

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
 
class Valid {
 
private $post = []; 
private $func = []; //'isRequired', 'isAlphaM'
 
public function __construct ($post,$ofunctions) { //
 var_dump($this->post = $post); 
 var_dump($this->func = $ofunctions); 
}
 
static function isRequired($value){
 if(!empty(trim($value))) {
  echo 'OK pour required : ' .$value. '<br><br>';
 } else {
  echo ' required KO <br><br>';
 return false;
 }
}
 
static function isAlphaM($value){
 if (!preg_match('/^[A-Z\'-_]{2,30}$/', $value)) {
  echo 'Alpha Majucule KO : ' .$value. '<br><br>' ; 
  return false;
 } else {
  echo 'OK Alpha : ' .$value. '<br><br>';
 }
}
 
public function getPost() {
 return $this->post; 
}
 
public function getFunction() {
 return $this->func; 
}
 
public function test(){
 foreach ($this->getPost() as $name => $value) {
  foreach ($this->getFunction() as $rules => $rule) {
   echo 'test des foreach'; 
   //call_user_func_array(array($this, $rule), array($value));
  //}  
 }
}
 
}
 
$functions = new Functions(); 
//var_dump($functions); 
 
$valid = new Valid ($_POST, $functions); // je passe le post et l'objet Functions dans le constructeur 
//var_dump($valid); 
//var_dump($valid->getPost()); 
//var_dump($valid->getFunction());
 
$valid->test();

j'aimerai déjà réussir à faire apparaître le 'echo : test des foreach '. Il n'y a pas de message d'erreurs mais rien ne s'affiche....
Le écho apparaît lorsque je mets les appels des méthodes directement dans la propriété privée
private $func = ['isRequired', 'isAlphaM'];

Pb :
peut-on faire passer un objet dans un constructeur d'une autre class
comment réussir ma boucle sur mon objet
faire appel call user func array pour appeler mes fonctions via mon objet

merci pour vos retours

Merci pour vos retours

27/10/2018, 12h40
rawsrc

Salut,

Citation:

Envoyé par bricoreur

peut-on faire passer un objet dans un constructeur d'une autre class

Bien sûr, il te suffit de typer ton paramètre

Citation:

Envoyé par bricoreur

comment réussir ma boucle sur mon objet

Boucler les fonctions d'un objet n'a quasiment aucune utilité et relève d'après moi d'une erreur de conception.

Si tu cherches à exécuter des fonction dans un contexte particulier, tu as pour cela en PHP les closures

Bonne continuation dans la recherche d'un système de validation flexible et ouvert :ccool:

Comme ça ça à l'air de fonctionner.
J'ai mis $this->getFunction()->getField() à la place de $this->getFunction().

Code:

1
2
3
4
5
6
7
 
<form action="test9503b.php" method="post" name="form1">
 <input type="input" name="tosave"  id="tosave"/>
 <input type="input" name="go"      id="go" value="1"/> 
 <input type="input" name="usefile" id="usefile"/> 
  <input type="submit"/> 
</form>

fichier : test9503b.php

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
<?php
 
class Functions {
 
 private $func = []; 
 
 public function __construct() { 
  $this->fonctions_a_appeler(); 
 }
 
 public function fonctions_a_appeler() {
  $this-> addFunction (['isRequired', 'isAlphaM']);
 }
 
 public function addFunction (array $functions=[]) { 
  $this->func = $functions; //============== je me demande s'il ne faudrait pas écrire  $this->func[] puisque $func est un tableau !
 }
 
 public function getField() {
  return $this->func; 
 }
}
 
class Valid {
 
 private $post = []; 
 private $func = []; //'isRequired', 'isAlphaM'
 
 public function __construct ($post,$ofunctions) { //
  $this->post = $post; 
   $this->func = $ofunctions; 
 }
 
 static function isRequired($value){
  if(!empty(trim($value))) {
   echo 'OK pour required : ' .$value. '<br><br>';
  } else {
   echo ' required KO <br><br>';
  return false;
  }
 }
 
 static function isAlphaM($value){
  if (!preg_match('/^[A-Z\'-_]{2,30}$/', $value)) {
   echo 'Alpha Majucule KO : ' .$value. '<br><br>' ; 
   return false;
  } else {
   echo 'OK Alpha : ' .$value. '<br><br>';
  }
 }
 
 public function getPost() {
  return $this->post; 
 }
 
 public function getFunction() {
  return $this->func; 
 }
 
 public function test(){
  foreach ($this->getPost() as $name => $value) {
   foreach ($this->getFunction()->getField() as $rules => $rule) { //==================== modifié
    echo 'test des foreach'; 
    //call_user_func_array(array($this, $rule), array($value));
   //}  
   }
  }
 }
}
 
$functions = new Functions(); 
//var_dump($functions); 
 
$valid = new Valid ($_POST, $functions); // je passe le post et l'objet Functions dans le constructeur 
//var_dump($valid); 
//var_dump($valid->getPost()); 
//var_dump($valid->getFunction());
 
$valid->test();

Merci, vos codes marchent très bien..et je pensais m'en sortir à partir de vos conseils mais je n'arrive toujours pas à écrire ma méthode validate()

code html

Code:

1
2
3
4
5
6
 
<form action = "form_post.php" method="post">
 <p><input type="text" name="nom"></p>
 <p><input type="text" name="prenom"></p>
 <input type="submit" name="SOUMETTRE" value="VALIDATION">
</form>

autoload.php

Code:

1
2
3
4
5
6
7
8
 
<?php
spl_autoload_register('autoload');
 
function autoload($class){
 //die($class); 
 require "$class.php";
}

form_post.php

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
<?php
 
require 'Autoload.php'; 
 
$functions = new Functions(); 
 
 echo 'Résultat de getField() : '; 
 echo '<pre>';
 print_r($functions->getField());
 echo '</pre>';
 
$valid = new Valid ($_POST, $functions); // 
 
 
$valid->validate(); 
 
if (!$valid->isValid()) {
$valid->displayErrors(); 
} else {
echo 'SUITE DU TRAITEMENT - ENREGISTREMENT'; 
}

Code:

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
 
<?php
 
class Functions {                     // le choix du nom n'est pas pertinent -> Rules_Form_connexion , Rules_Form_SignUp, Rules_Form_xxxxx
 private $func = []; 
 
 public function __construct() { 
  $this->fonctions_todo(); 
 }
 
 public function fonctions_todo() {
  $this-> addFunction ('nom', ['isRequired', 'isAlphaM']);
  $this-> addFunction ('prenom', ['isAlphaM']);
 // tous les tests que j'aimerai faire sur les champs d'un formulaire - à terme j'écrirai une class Abstraite et des class filles par formulaire distinct.....
 }
 
 public function addFunction ($name, array $functions=[]) { 
  $this->func[$name] = $functions;
 }
 
 public function getField() {
  return $this->func; 
 }
}
 
?>

Code:

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
59
60
61
62
63
64
65
66
67
68
69
 
<?php
 
class Valid {
 
 private $post = []; 
 private $func = [];    
 
 public function __construct ($post,$ofunctions) { 
  $this->post = $post;
  $this->func = $ofunctions;
 }
 
 static function isRequired($value){
  if(!empty(trim($value))) {
   echo 'OK Required: ' .$value. '<br><br>';
  } else {
   echo ' Required KO <br><br>';
   return false;
  }
 }
 
 static function isAlphaM($value){
  if (!preg_match('/^[A-Z\'-_]{2,30}$/', $value)) {
   echo 'Alpha Majucule KO : ' .$value. '<br><br>' ; 
   return false;
  } else {
   echo 'OK Alpha : ' .$value. '<br><br>';
  }
 }
 
 public function getPost() {
  return $this->post; 
 }
 
 public function getFunction() {
  return $this->func; 
 }
 
 public function isValid() {  //renvoi un booléen
  return empty($this->errors);
 }
 
 private function getErrors() { // si utilisation displayErrors => private
  return $this->errors;
 }
 
 public function displayErrors(){
  $html = '<ul>';
  foreach($this->getErrors() as $errors){
   $html .= "<li> Erreur : " .$errors."</li>";
  }
  $html .= '</ul>';
  echo $html; //return $html
 }  
 
 public function validate(){ // je n'arrive pas avec les différents tableaux à chercher les bonnes valeurs et les associer ---------------------- ????
  foreach ($this->getPost() as $name => $value) {
 
   foreach ($this->getFunction()->getField() as $rules => $rule) { 
 
    // $this->$name = $this->{rule};  QUELQUE CHOSE COMME CELA 
 
   call_user_func_array(array($this, $rule), array($value)); // J'AIMERAIS APPELER MES METHODES SUR MES CHAMPS AVEC LEUR VALEURS - si erreur retourne False sinon retourne les valeurs (ou true ?)
   }
  }
 }
 
}

Je reste débutant donc je ne sais pas si ma conception est bonne. Mais bon maintenant je ne peux pas faire mieux
l'idée est la suivante

J'ai un objet dans lequel j'attribue mes règles à mes champs. (ici Class Functions)

Je transfert cet objet dans le constructeur de ma Class Valid qui via une méthode validate() pourrait tester si mes champs en corrélation avec mon objet sont True ou False.

je ne sais pas si cela est possible.

l'idée est d'avoir une class Valid qui comporte mes méthodes de test + méthode Validate. ET des class ultérieures (une par formulaire) qui accueilleront les règles associées à mes champs

j'espère avoir été clair

Merci pour votre aide je m'embrouille

28/10/2018, 00h34
badaze

Il y a deux ou trois semaines j’ai commencé à faire ce que tu veux faire en utilisant les closures. Mais entre temps je suis passé à autre chose.
Je regarderai ce que j’ai fait en la matière (mais il ne faut pas s’attendre à du transcendant).
28/10/2018, 01h21
bricoreur

Merci
Je vais regarder en attendant les closures pour apprendre et comprendre je l’espere

1 pièce(s) jointe(s)

Voici un exemple avec des closures. ATTENTION. Ce n'est pas un produit fini.

validate.class.php

Code:

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
59
60
61
62
63
 
<?php
class Validate
{
 private $fieldArrayOfControls  = array();
 private $arrayOfData           = array();
 private $ruleNumber            = 0;
 
 public function addControl($errorMessage,$arrayOfFieldNames, $control)
 {
  $this->fieldArrayOfControls[$this->ruleNumber] = [$errorMessage,$arrayOfFieldNames,$control];
  $this->ruleNumber++;
 }
 
 
 public function control($arrayOfData)
 {
  $results = array();
 
  foreach($this->fieldArrayOfControls as $ruleNumber => $data)
  {
   // init pour traitement champs manquants
   $arrMissing    = array();
   $missingFields = false;
   // préparation du message en sortie
   $message     = $data[0];
   // constitution des paramètres de la fonction de closure
   $arrayToMap   = array();
   $fieldNames   = $data[1];
   foreach($fieldNames as $key => $fieldName)
   {
    if (! isset($arrayOfData[$fieldName]))
    {
     // champ manquant
     $missingFields = true; 
     $arrMissing[]  = $fieldName;
    }
    else 
    {
     $fieldValue   = $arrayOfData[$fieldName];
     $arrayToMap[] = $fieldValue;
     // message en sortie
     $message      = str_replace("#$fieldName",$fieldValue,$message);     
    }
   }
   if (!$missingFields)
   {
    // Pas de champ manquant => exécution de la closure
    $function           = $data[2];
    $results[$message]  = array_map($function, [$arrayToMap])[0];     
   }
   else
   {
    foreach($arrMissing as $missingField)
    {
     $results["*** Missing field '$missingField'"] = false;
    }
   }
 
  }
  return $results;
 }
}

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
 
<?php
include("validate.class.php");
//==============================================================================
//-------------- closures - les fonctions renvoient true ou false
//==============================================================================
// controle qu'un champ est rempli
$remplissage = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};
// exemple de contrôle combiné => controle les valeur des 2 champs options
$controleOption = function($array)
{
 list($option1,$option2) = $array;
 if ($option1==$option2)
 {
  return false;
 }
 return true;
};
// contrôle qu'une valeur est numérique
$numerique = function($array)
{
 $valeur = $array[0];
 return (is_numeric($valeur)) ? true : false;
};
//==============================================================================
 
$toto = new Validate();
$toto->addControl('Le nom n\'est pas renseigné',["nom"], $remplissage);
$toto->addControl('Le prénom n\'est pas renseigné',["prenom"], $remplissage);
$toto->addControl("L'âge n'est pas renseigné",["age"], $remplissage);
$toto->addControl("L'âge n'est pas numérique => #age",["age"], $numerique);
$toto->addControl("Les deux options ne peuvent avoir la même valeur => option 1 = #option1 et option 2 = #option2",["option1","option2"], $controleOption);
//+++++++++++++++++++++++++++++++++++++++++++++
//-------------- j'ai mis ce nom au tableau mais on peut fort bien passer $_POST s'il est renseigné. 
//               On peut mettre n'importe quel tableau du moment que ses postes sont "nommés"
// problème sur les options
$valeurAController = ['nom'=>'Dupont','prenom'=>'Pierre','age'=>25,'option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
// on parcourt les résultats qui ont retourné faux pour afficher le message d'erreur.
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}
//+++++++++++++++++++++++++++++++++++++++++++++
print "<hr/>";
// problème sur le nom l'âge et les options
$valeurAController = ['nom'=>'','prenom'=>'Pierre','age'=>'AZ','option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}
//+++++++++++++++++++++++++++++++++++++++++++++
print "<hr/>";
// problème sur le nom l'âge qui manque et les options
$valeurAController = ['nom'=>'','prenom'=>'Pierre','option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}

Donne :

Pièce jointe 422692

Merci je vais regarder votre proposition

De mon côté j'ai essayé cela je vous le soumets.

J'ai un dernier pb à règler :

soit je fais le foreach sur $_POST mais du coup j'ai mes contrôles qui se répètent (mais ils fonctionnent)

ou

soit je ne fais pas de foreach sur $_POST mais comment faire passer mes valeurs des champs $_Post ?

Je pense ne plus être très loin. je vous laisse uniquement le fichier Class Valid - pour le reste rien n'a changé

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
<?php
 
class Valid {
 
 private $post = []; 
 private $func = [];    
 
 public function __construct ($post,$ofunctions) { 
  $this->post = $post;
  $this->func = $ofunctions;
 }
 
 static function isRequired($value){
  if(!empty(trim($value))) {
   echo 'OK Required: ' .$value. '<br><br>';
  } else {
   echo ' Required KO <br><br>';
   return false;
  }
 }
 
 static function isAlphaM($value){
  if (!preg_match('/^[A-Z\'-_]{2,30}$/', $value)) {
   echo 'Alpha Majucule KO : ' .$value. '<br><br>' ; 
   return false;
  } else {
   echo 'OK Alpha : ' .$value. '<br><br>';
  }
 }
 
 public function getPost() {
  return $this->post; 
 }
 
 public function getFunction() {
  return $this->func; 
 }
 
 public function isValid() {  //renvoi un booléen
  return empty($this->errors);
 }
 
 private function getErrors() { // si utilisation displayErrors => private
  return $this->errors;
 }
 
 public function displayErrors(){
  $html = '<ul>';
  foreach($this->getErrors() as $errors){
   $html .= "<li> Erreur : " .$errors."</li>";
  }
  $html .= '</ul>';
  echo $html; //return $html
 }  
 
 public function test(){
 
  foreach ($this->getPost() as $name => $value) {            // $name = key (nom des champs) && $value = valeur des champs 
 
   foreach ($this->getFunction()->getField() as $nameC  => $rules) {      // $nameC est bien un Array puisqu'ils a plusieurs champs possibles
 
    if(isset($name, $nameC)) {                           // array_key_exists => pourquoi cela ne marche pas puisque $nameC est un array 
 
     $name = $nameC;  
 
     echo " _name [array] &nbsp;&nbsp : &nbsp;&nbsp" .$name. "<br>";
 
     foreach($rules as $rule) {
 
      $name = $rule; 
 
      echo " &nbsp;&nbsp;&nbsp;&nbsp - Rules [array] &nbsp;&nbsp   as &nbsp;&nbsp _rule &nbsp;&nbsp : &nbsp;&nbsp" .$rule. "<br>";
 
      call_user_func_array(array($this, $rule), array($value));  // répète plusieurs fois les tests à cause du foreach $_POST - comment faire passer les valeurs $value du $_POST ??
      }
    }
   }
  }
 }
 
}

comment boucler sur $_POST sans réitérer mes méthodes ?

j'ai tenté de créer une méthode getValuePOST() pour récupérer toutes mes valeurs afin de les réattribuer dans mes boucles mais elle ne fonctionne pas ...j'y suis presque je crois

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
<?php
 
class Valid {
 
private $post = []; 
private $func = [];
private $errors = [];  
 
public function __construct ($post,$oform_tocheck) { 
 $this->post = $post;
 $this->func = $oform_tocheck;
}
 
private function isRequired($value){
 if(!empty(trim($value))) {
   return true; 
 } else {
  $this->errors[$value] = 'La saisie du champ est obligatoire.';
 return false;
 }
}
 
private function isAlphaM($value){
 if(!empty($value)) {
  if (!preg_match('/^[A-Z\'-_]{2,30}$/', $value)) {
   $this->errors[$value] = 'La saisie du champ  : &nbsp;&nbsp;&nbsp' .$value. ' &nbsp;&nbsp doit être Apha Majuscule.';
   return false;
  } else {
  return true; 
  }
  return true; 
 }  
}
 
public function getPost() {
 return $this->post; 
}
 
public function getFunction() {
 return $this->func; 
}
 
public function isValid() {  //renvoi un booléen False si getErrors rencontre au moins une erreur ou True si pas d'Erreur
 return empty($this->errors);
}
 
private function getErrors() { 
 return $this->errors;
}
 
public function displayErrors(){
 $html = '<ul>';
 foreach($this->getErrors() as $errors){
 $html .= "<li> Erreur : " .$errors."</li>";
 }
 $html .= '</ul>';
 echo $html; //return $html
}  
 
public function getValuePOST() {
 foreach ($this->getPost() as $name => $value) { // ne boucle pas -- cela récupère uniquement la première valeur
 return $value;
 }
}
 
 
public function validate(){
 
 foreach ($this->getPost() as $name => $value) {  
  var_dump(($name). '<br>'); // JE RECUPERE BIEN LES DIFFERENTES VALEURS DU POST
  //return $value;  
 } 
 
 //var_dump($this->getValuePOST()); // LA BOUCLE NE MARCHE PAS 
 
 foreach ($this->getFunction()->getField() as $nameC  => $rules) {   
 
  echo " _name [array] &nbsp;&nbsp;&nbsp : &nbsp;&nbsp;&nbsp" .$nameC. " &nbsp;&nbsp;&nbsp - &nbsp;&nbsp;&nbsp et sa valeur : &nbsp;&nbsp;&nbsp " .$this->getValuePOST(). "<br>";
 
   foreach($rules as $rule) {
 
    echo " &nbsp;&nbsp;&nbsp;&nbsp - Rules [array] &nbsp;&nbsp;&nbsp   as &nbsp;&nbsp;&nbsp _rule &nbsp;&nbsp;&nbsp : &nbsp;&nbsp;&nbsp" .$rule.  "<br>";
 
    call_user_func_array(array($this, $rule), array($this->getValuePOST())); // COMMENT BLOUCLER SUR LES VALEURS
   }
  }
 }
}

j'ai modifié test() -> validate() entre autre pour mieux m'y retrouver.

28/10/2018, 19h42
badaze
Je pense que conceptuellement parlant tu ne peux pas mettre tous les types de contrôles dans une classe car il en manquera toujours un.
De plus tu ne gère pas les contrôles combinés qui mettent en œuvre plusieurs champs.

EDIT.

Une chose. On ne contrôle pas qu'une entrée est en majuscules. Il est plus simple de toujours mettre la donnée en majuscules.

Exemple :
Code:

1 2 $toto = strtoupper($toto);
28/10/2018, 19h52
rawsrc

Salutations,

Il faut penser à préserver la possibilité d'ajouter des tests de validation. Il t'en manquera toujours, crois-moi... L'idée d'utiliser des closures te permet de résoudre assez élégamment ce problème.
Tu définis un socle de tests par défaut et tu offres la possibilité d'en créer si nécessaire.

Oh Salutations,

justement c'est le but recherché

j'aurai une Class Valid qui stockera tous mes tests (évolutifs) dont j'aurai besoin + méthode validate() qui lancera les tests

j'ai une class Rules_Abstract (mère) qui impose une construction et méthodes de class

et j'aurai des class Rules_Form_A (fille) + class Rules_Form_B (fille)....qui comporteront chacun les champs et les tests à réaliser sur ces derniers. Ces objets seront envoyés dans le constructeur de la Class Valid comme paramètres.

il ne me reste plus finaliser la méthode validate()....

Au passage comment fait-on pour renvoyer tous les champs d'un $_POST via une fonction, je m'explique :
Code:

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 class Valid { private $post = []; private $func = []; private $errors = []; public function __construct ($post) { //,$oform_tocheck $this->post = $post; //$this->func = $oform_tocheck; } public function getPost() { return $this->post; } public function getValuePOST() { foreach ($this->getPost() as $name => $value) { return $value; // comment faire marcher ma boucle -> je ne récupère que la première valeur du $_POST } } public function validate(){ foreach ($this->getPost() as $name => $value) { print_r($name. "---" .$value. ' ') ; // OK J'AFFICHE BIEN TOUTES LES NOMS ET VALEURS DES CHAMPS DU $_POST } echo ' '; print_r($this->getValuePOST()); // LA BOUCLE NE MARCHE PAS - JE N'AI QUE LA PREMIERE VALEUR //...............

28/10/2018, 20h35
badaze

Tu te concentre sur $_POST alors qu’il y a aussi $_GET, etc... sans parler des tableaux qui traiteraient des données sans passer par par de la saisie.
Bref tu devrais être plus générique dans le nommage de tes méthodes.

merci pour tous vos retours mais cela fait beaucoup d'informations à traiter...j'essaye de les prendre une à une mais pas facile...

si vous avez des exemples ...de mon côté je m'acharne pour essayer de progresser

il est vrai que jusqu'à présent j'utilisais $_POST...je vais voir du côté GET et Tableau et des closures...je continue à étudier vos codes mais pas facile même si j'ai compris des choses

Si vous aviez une proposition pour ma méthode Validate() ...je vous serai plus que reconnaissant et preneur

c'est reparti pour toute la nuit encore
Code:

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 public function getPost() { return $this->post; } public function getValuePOST() { foreach ($this->getPost() as $name => $value) { return $value; } } public function validate(){ foreach ($this->getPost() as $name => $value) { print_r($name. "---" .$value. ' ') ; // ok j'affiche bien toutes mes données du $_POST } echo ' '; print_r($this->getValuePOST()); //ne retourne que la 1ere valeur echo ' '; foreach ($this->getFunction()->getField() as $nameC => $rules) { echo " _name [array]   &nbsp :   &nbsp" .$nameC. "   &nbsp -   &nbsp et sa valeur :   &nbsp " .$this->getValuePOST(). " "; // insère que la première valeur de $POST foreach($rules as $rule) { echo "   &nbsp - Rules [array]   &nbsp as   &nbsp _rule   &nbsp :   &nbsp" .$rule. " "; call_user_func_array(array($this, $rule), array($this->getValuePOST())); // insère que la première valeur de $POST } } }

28/10/2018, 21h11
badaze

As-tu essayé le code que j’ai posté ?

oui votre code marche très bien ....

mais je ne comprends pas tout ...j'ai réussi à rajouter une closure
Code:

1 2 3 4 5 6 7 8 9 10 $toto = new Validate(); $toto->addControl('Le nom n\'est pas renseigné',["nom"], $remplissage); $toto->addControl('Le nom n\'est pas AlphaM',["nom"], $alphaM); // nouvelle closure qui fonctionne bien $toto->addControl('Le prénom n\'est pas renseigné',["prenom"], $remplissage); $toto->addControl("L'âge n'est pas renseigné",["age"], $remplissage); $toto->addControl("L'âge n'est pas numérique => #age",["age"], $numerique); $toto->addControl("Les deux options ne peuvent avoir la même valeur => option 1 = #option1 et option 2 = #option2",["option1","option2"], $controleOption);
Cependant, je n'ai pas encore tester avec un $_POST car mon formulaire comprendra beaucoup beaucoup de champs car il comportera des tableaux à renseigner

Ensuite, j'aimais bien mon idée d'avoir un addField dans lequel je pouvais renseigner un champ et tous les contrôles à réaliser sur ce dernier en 1 seule ligne

Enfin, j'aimerai pour progresser réussir à finaliser ma méthode validate();

si vous pouviez y jeter un coup d'oeil, j'espère être tout prêt ....

Je garde sous le coude votre proposition pour l'étudier et me l'approprier ... pas facile lorsqu'on ne maîtrise pas tous les concepts et avec peu de ressources

Ce qui est bien avec la POO c'est que c'est facilement améliorable.

Méthode à ajouter à la classe

Code:

1
2
3
4
5
6
7
8
 
 public function addField($errorMessages,$arrayOfFieldNames, $controls)
 {
  foreach($errorMessages as $key => $errorMessage)
  {
   $this->addControl($errorMessage,$arrayOfFieldNames, $controls[$key]);
  }
 }

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
<?php
include("validate.class.php");
//==============================================================================
//-------------- closures - les fonctions renvoient true ou false
//==============================================================================
// controle qu'un champ est rempli
$remplissage = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};
// exemple de contrôle combiné => controle les valeur des 2 champs options
$controleOption = function($array)
{
 list($option1,$option2) = $array;
 if ($option1==$option2)
 {
  return false;
 }
 return true;
};
// contrôle qu'une valeur est numérique
$numerique = function($array)
{
 $valeur = $array[0];
 return (is_numeric($valeur)) ? true : false;
};
//==============================================================================
 
$toto = new Validate();
$toto->addControl('Le nom n\'est pas renseigné',["nom"], $remplissage);
$toto->addControl('Le prénom n\'est pas renseigné',["prenom"], $remplissage);
//$toto->addControl("L'âge n'est pas renseigné",["age"], $remplissage);
//$toto->addControl("L'âge n'est pas numérique => #age",["age"], $numerique);
$toto->addField(["L'âge n'est pas renseigné","L'âge n'est pas numérique => #age"],["age"], [$remplissage, $numerique]);
$toto->addControl("Les deux options ne peuvent avoir la même valeur => option 1 = #option1 et option 2 = #option2",["option1","option2"], $controleOption);
//+++++++++++++++++++++++++++++++++++++++++++++
//-------------- j'ai mis ce nom au tableau mais on peut fort bien passer $_POST s'il est renseigné. 
//               On peut mettre n'importe quel tableau du moment que ses postes sont "nommés"
// problème sur les options
$valeurAController = ['nom'=>'Dupont','prenom'=>'Pierre','age'=>25,'option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
// on parcourt les résultats qui ont retourné faux pour afficher le message d'erreur.
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}
//+++++++++++++++++++++++++++++++++++++++++++++
print "<hr/>";
// problème sur le nom l'âge et les options
$valeurAController = ['nom'=>'','prenom'=>'Pierre','age'=>'AZ','option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}
//+++++++++++++++++++++++++++++++++++++++++++++
print "<hr/>";
// problème sur le nom l'âge qui manque et les options
$valeurAController = ['nom'=>'','prenom'=>'Pierre','option1'=>'oui','option2'=>'oui'];
$result = $toto->control($valeurAController);
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}

28/10/2018, 22h16
badaze
Le foreach n'est exécuté qu'une fois puisqu'il y a un return qui fait sortir de la méthode.
Code:

1 2 3 4 5 6 public function getValuePOST() { foreach ($this->getPost() as $name => $value) { return $value; } }
28/10/2018, 22h42
bricoreur

Merci pour avoir pris le temps de regarder mes codes..en effet, j'ai enlevé les return mais je n'arrive pas à faire passer mes values les unes après les autres...pfff

je vais me plonger sur votre proposition mais je reste frustré de ne pas avoir trouvé
29/10/2018, 00h25
badaze

Dans ton cas, une fonction de contrôle n’a qu’un seul paramètre. Il faut que tu ailles prendre la valeur dans $_POST qui correspond à ta règle.

Cependant, tout cela est vain car ne suffit pas d’afficher des messages d’erreurs. Tu ne renvoies pas de true ou de false qui permettrait de stopper l’exécution du script après le validate.

En plus je pense qu’il ne faut pas afficher les messages d’erreurs dans la classe. En effet, le contrôle est une chose et l’affichage de l’erreur en est une autre. Si quelqu’un d’autre que toi utilise ta classe il n’a pas forcément envie de voir l’affichage comme tu l’as pensé car il a une présentation différente ou a une autre langue que la tienne. Idem pour toi so tu fais évoluer ton affichage.

En POO une classe ne doit faire que ce qu’elle est censée faire et rien d’autre.
29/10/2018, 00h38
badaze

Citation:

Envoyé par bricoreur

Ensuite, j'aimais bien mon idée d'avoir un addField dans lequel je pouvais renseigner un champ et tous les contrôles à réaliser sur ce dernier en 1 seule ligne.

En informatique, comme partout ailleurs, le mieux est souvent l'ennemi du bien. Un bon script doit être lisible et facilement compréhensible même si on le relit quelques années plus tard. Mettre trop d'informations seulement pour dire d'avoir moins de lignes est une fausse bonne idée AMHA.
29/10/2018, 00h50
bricoreur

Merci

votre code marche très bien et d'appeler plusieurs fonctions (super)

je vais maintenant travailler sur votre code et essayer de le décortiquer pour le comprendre et me l'approprier définitivement

j'ai bien noté vos conseils sur les retours True et False et séparer les messages d'erreurs....

Cependant j'aimerai quand même réussir à finaliser mon premier script pour comprendre les modifications à apporter

On peut même utiliser les closures dans d'autres closures. Voir $email_non_obligatoire.

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
<?php
include("validate.class.php");
//==============================================================================
//-------------- closures - les fonctions renvoient true ou false
//==============================================================================
// controle qu'un champ est rempli
$remplissage = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};
// exemple de contrôle combiné => controle les valeur des 2 champs options
$controleOption = function($array)
{
 list($option1,$option2) = $array;
 if ($option1==$option2)
 {
  return false;
 }
 return true;
};
// contrôle qu'une valeur est numérique
$numerique = function($array)
{
 $valeur = $array[0];
 return (is_numeric($valeur)) ? true : false;
};
// contrôle facultatif - on ne contrôle l'email que s'il est renseigné
// et on utilise un autre de nos contrôles !!!
$email_non_obligatoire = function ($array) use ($remplissage)
{
 if ($remplissage($array))
 {
  if (filter_var($array[0], FILTER_VALIDATE_EMAIL)) 
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 return true;
};
//==============================================================================
 
$toto = new Validate();
$toto->addControl('Le nom n\'est pas renseigné',["nom"], $remplissage);
$toto->addControl('Le prénom n\'est pas renseigné',["prenom"], $remplissage);
$toto->addField(["L'âge n'est pas renseigné","L'âge n'est pas numérique => #age"],["age"], [$remplissage, $numerique]);
$toto->addControl("Les deux options ne peuvent avoir la même valeur => option 1 = #option1 et option 2 = #option2",["option1","option2"], $controleOption);
$toto->addControl('Email #email invalide',["email"], $email_non_obligatoire);
//+++++++++++++++++++++++++++++++++++++++++++++
// problème sur les options
$valeurAController = ['nom'=>'Dupont','prenom'=>'Pierre','age'=>25,'option1'=>'oui','option2'=>'oui','email'=>''];
$result = $toto->control($valeurAController);
// on parcourt les résultats qui ont retourné faux pour afficher le message d'erreur.
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}
//+++++++++++++++++++++++++++++++++++++++++++++
print "<br/>";
// problème sur les options et l'email qui est invalide
$valeurAController = ['nom'=>'Dupont','prenom'=>'Pierre','age'=>25,'option1'=>'oui','option2'=>'oui','email'=>'totot @yoyo.fr'];
$result = $toto->control($valeurAController);
// on parcourt les résultats qui ont retourné faux pour afficher le message d'erreur.
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}

Bonjour,

j'ai travaillé sur vos codes...je commence à comprendre mais je bloque sur la méthode Contrôle() qui est la plus complexe.

j'ai tenté de faire cela à partir de votre proposition :

- un formulaire (SignUp)
- un fichier (class Closures ?)dans lequel il y a que des closures qui pourraient être appelées lorsque j'en aurai besoin. Est-ce pertinent ?
- une class Validate
- un fichier Closures_SignUp dans lequel j'instancie la class Validate (+closures)
- un fichier autoload;

L'idée étant de créer un fichier Closures_FormA, Closures_FormB,....

En revanche, comme je vous l'ai indiqué, je ne comprends pas tout dans la méthode Contrôle et je n'arrive pas à passer mes valeurs
NB : dans le fichier Closures, j'ai essayé d'écrire ma propre closure que j'ai associé à la variable $tel (qu'en pensez-vous ?)

Form_SignuUp.php

Code:

1
2
3
4
5
6
7
8
9
 
<form action="Closures_SignUp.php" method="post">
 <p>Nom : <input type="text" name="nom"></p>
 <p>Prenom : <input type="text" name="prenom"></p>
 <p>Age : <input type="text" name="age"></p>
 <p>Mail : <input type="text" name="mail"></p>
 <p>Tel : <input type="text" name="tel" placeholder="00.00.00.00.00"></p>
 <input type="submit" name="inscription" value="INSCRIRE">
</form>

Closures_SignUp.php

Code:

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
 
<?php
 
require "Autoload.php";
require "Closures.php"; 
 
$valid = new Validate();
  $valid->addControl('Le nom n\'est pas renseigné',[($_POST["nom"])], $required); 
  $valid->addControl('Le prénom n\'est pas renseigné',[($_POST["prenom"])], $required);
  $valid->addField(["L'âge n'est pas renseigné","L'âge n'est pas numérique => #age"],[($_POST["age"])], [$required, $numerique]);
  $valid->addControl("Le mail renseigné n'est pas valide",[($_POST["mail"])], $email_non_obligatoire);
  $valid->addField(["Veuillez saisir votre numéro de téléphone","Votre numero de tel n'est pas valide => #tel"],[($_POST["tel"])], [$required, $tel]); // ma propre closure
 
$valeurAController = [$_POST]; // array [0] => array [6]  <---> $this->fieldArrayOfControls[$this->ruleNumber] = [$errorMessage,$arrayOfFieldNames,$control];
var_dump($valeurAController); 
 
$result = $valid->control($valeurAController);
 
foreach($result as $message => $result)
{
 if (! $result)
 {
  print "$message<br/>";
 }
}

Closures. php

Code:

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
59
60
61
62
63
64
 
<?php
 
// Ceci est déjà une class CLOSURE - donc pas besoin de la redeclarer ???
 
//==============================================================================
//-------------- ECRIRE TOUTES LES CLOSURES  - les fonctions renvoient true ou false
//==============================================================================
 
 
// controle qu'un champ est rempli
$required = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};
 
 
// exemple de contrôle combiné => controle les valeur des 2 champs options
$controleOption = function($array)
{
 list($option1,$option2) = $array;
 if ($option1==$option2)
 {
  return false;
 }
 return true;
};
 
 
// contrôle qu'une valeur est numérique
$numerique = function($array)
{
 $valeur = $array[0];
 return (is_numeric($valeur)) ? true : false;
};
 
// contrôle facultatif - on ne contrôle l'email que s'il est renseigné
// et on utilise un autre de nos contrôles !!!
$email_non_obligatoire = function ($array) use ($required)
{
 if ($required($array))
 {
  if (filter_var($array[0], FILTER_VALIDATE_EMAIL)) 
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 return true;
};
 
 
//CONTROLE SAISIE DU TELEPHONE
$tel = function ($array)
{
 if (filter_var($array[0], FILTER_VALIDATE_REGEXP, array("options" => array("regexp"=>"/^[0-9]{2}.[0-9]{2}.[0-9]{2}.[0-9]{2}.[0-9]{2}$/"))) !== false) {
  return true;
 } else {
  return false;
 }
};

Validate.php

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
 
<?php
class Validate
{
 private $fieldArrayOfControls  = array();
 private $arrayOfData           = array();
 private $ruleNumber            = 0;
 
 
 public function addControl($errorMessage,$arrayOfFieldNames, $control)
 {
  $this->fieldArrayOfControls[$this->ruleNumber] = [$errorMessage,$arrayOfFieldNames,$control];
  $this->ruleNumber++;
 }
 
 
 public function addField($errorMessages,$arrayOfFieldNames, $controls)
 {
  foreach($errorMessages as $key => $errorMessage)
  {
   $this->addControl($errorMessage,$arrayOfFieldNames, $controls[$key]);
  }
 }
 
 public function control($arrayOfData)
 {
  $results = array();
 
  foreach($this->fieldArrayOfControls as $ruleNumber => $data)
  {
   // init pour traitement champs manquants
   $arrMissing    = array();
   $missingFields = false;
 
   // préparation du message en sortie
   $message     = $data[0];
 
   // constitution des paramètres de la fonction de closure
   $arrayToMap   = array();
   $fieldNames   = $data[1];
   foreach($fieldNames as $key => $fieldName)
   {
    if (! isset($arrayOfData[$fieldName]))
    {
 
     // champ manquant
     $missingFields = true; 
     $arrMissing[]  = $fieldName;
    }
    else 
    {
     $fieldValue   = $arrayOfData[$fieldName];
     $arrayToMap[] = $fieldValue;
 
     // message en sortie
     $message      = str_replace("#$fieldName",$fieldValue,$message);     
    }
   }
   if (!$missingFields)
   {
 
    // Pas de champ manquant => exécution de la closure
    $function           = $data[2];
    $results[$message]  = array_map($function, [$arrayToMap])[0];     
   }
   else
   {
    foreach($arrMissing as $missingField)
    {
     $results["*** Missing field '$missingField'"] = false;
    }
   }
 
  }
  return $results;
 }
}

Autoload.php

Code:

1
2
3
4
5
6
7
8
9
 
<?php
 
spl_autoload_register('autoload');
 
function autoload($class){
    //die($class); 
    require "$class.php";
}

29/10/2018, 19h20
badaze

$_POST est un tabeau. Pas la peine de le mettre entre []
29/10/2018, 20h09
bricoreur

Merci beaucoup, :applo::applo:

j'ai corrigé la syntaxe sur $_Post ainsi que dans mes AddField et AddControl.

tout semble très bien fonctionner. Je vais continuer à faire mes tests et rajouter les closures.

Maintenant je vous avoue ne pas avoir tout compris dans la fonction controle()...je vais chercher à me l'approprier

je poursuis.....

Le principe de control est de renvoyer un tableau contenant les messages d'erreurs comme clés de tableau et true ou false comme valeur.

De cette manière tu peux faire un boucle sur le tableau et n'afficher que les postes du tableau dont les clés ont une valeur false.

Par contre pour "arrêter" le script il faut contrôler l'existence d'un moins un poste de tableau à false.

Pour pallier ce problème, on peut faire en sorte que control retourne à la fois un indicateur qui dira s'il y a eu globalement au moins une erreur et la liste des erreurs. J'ai choisi de renvoyer un tableau qui contient le résultat global des contrôles dans un poste et un tableau ne contenant plus que les messages d'erreurs => return ["controlok"=>$resultOK,"errorlist"=>$errList];

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
<?php
class Validate
{
 private $fieldArrayOfControls  = array();
 private $arrayOfData           = array();
 private $ruleNumber            = 0;
 
 public function addControl($errorMessage,$arrayOfFieldNames, $control)
 {
  $this->fieldArrayOfControls[$this->ruleNumber] = [$errorMessage,$arrayOfFieldNames,$control];
  $this->ruleNumber++;
 }
 
 public function addField($errorMessages,$arrayOfFieldNames, $controls)
 {
  foreach($errorMessages as $key => $errorMessage)
  {
   $this->addControl($errorMessage,$arrayOfFieldNames, $controls[$key]);
  }
 } 
 
 public function control($arrayOfData)
 {
  $errList  = array();
  // si au moins une erreur $resultOK = false
  $resultOK = true;
 
  foreach($this->fieldArrayOfControls as $ruleNumber => $data)
  {
   // init pour traitement champs manquants
   $arrMissing    = array();
   $missingFields = false;
   // préparation du message en sortie
   $message     = $data[0];
   // constitution des paramètres de la fonction de closure
   $arrayToMap   = array();
   $fieldNames   = $data[1];
   foreach($fieldNames as $key => $fieldName)
   {
    if (! isset($arrayOfData[$fieldName]))
    {
     // champ manquant
     $missingFields = true; 
     $arrMissing[]  = $fieldName;
    }
    else 
    {
     $fieldValue   = $arrayOfData[$fieldName];
     $arrayToMap[] = $fieldValue;
     // message en sortie
     $message      = str_replace("#$fieldName",$fieldValue,$message);     
    }
   }
   if (!$missingFields)
   {
    // Pas de champ manquant => exécution de la closure
    $function           = $data[2];
    $currentResult      = array_map($function, [$arrayToMap])[0];
    if (! $currentResult)
    {
     // on n'enregistre que les valeurs qui ne passent pas les tests
     $errList[$message] = $currentResult;
     $resultOK          = false;
    }
   }
   else
   {
    foreach($arrMissing as $missingField)
    {
     $errList["*** Missing field '$missingField'"] = false;
     $resultOK = false;
    }
   }
  }
 
  // on renvoie un tableau avec deux postes - j'ai mis controlok et errorlist comme clés
  // mais tu peux mettre ce que tu veux
  return ["controlok"=>$resultOK,"errorlist"=>$errList];
 }
}

Code:

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
59
60
61
62
63
64
65
 
<?php
include("validate.class.php");
//==============================================================================
//-------------- closures - les fonctions renvoient true ou false
//==============================================================================
// controle qu'un champ est rempli
$remplissage = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};
// exemple de contrôle combiné => controle les valeur des 2 champs options
$controleOption = function($array)
{
 list($option1,$option2) = $array;
 if ($option1==$option2)
 {
  return false;
 }
 return true;
};
// contrôle qu'une valeur est numérique
$numerique = function($array)
{
 $valeur = $array[0];
 return (is_numeric($valeur)) ? true : false;
};
// contrôle facultatif - on ne contrôle l'email que s'il est renseigné
// et on utilise un autre de nos contrôles !!!
$email_non_obligatoire = function ($array) use ($remplissage)
{
 if ($remplissage($array))
 {
  if (filter_var($array[0], FILTER_VALIDATE_EMAIL)) 
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 return true;
};
//==============================================================================
 
$toto = new Validate();
$toto->addControl('Le nom n\'est pas renseigné',["nom"], $remplissage);
$toto->addControl('Le prénom n\'est pas renseigné',["prenom"], $remplissage);
$toto->addField(["L'âge n'est pas renseigné","L'âge n'est pas numérique => #age"],["age"], [$remplissage, $numerique]);
$toto->addControl("Les deux options ne peuvent avoir la même valeur => option 1 = #option1 et option 2 = #option2",["option1","option2"], $controleOption);
$toto->addControl('Email #email invalide',["email"], $email_non_obligatoire);
//+++++++++++++++++++++++++++++++++++++++++++++
// problème sur les options et sur email
$valeurAController = ['nom'=>'Dupont','prenom'=>'Pierre','age'=>25,'option1'=>'oui','option2'=>'oui','email'=>'opopp.@mmm.'];
$result = $toto->control($valeurAController);
if ($result["controlok"] == false)
{
 // il y a au moins une erreur
 // on parcourt les résultats qui ont retourné faux pour afficher le message d'erreur.
 foreach($result["errorlist"] as $message => $result)
 {
   print "$message<br/>";
 } 
}

30/10/2018, 00h47
badaze

Un exercice que tu pourrais faire serait que control ne renvoie qu’un booléen et que la liste des erreurs soit renvoyée par une méthode getErrorList() . Ce serait même plus propre.

On verra ensuite qu'on peut faire plus propre.

Bonsoir

Après un travail acharné et en m'inspirant de vos conseils j'ai enfin réussi à écrire ma fonction Validate ()

Je vous la soumets pour échange

Code:

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
 
 private $post = []; 
 private $func = [];
 private $errors = []; 
 private $errorsMessages = [];  
 
 
 public function __construct ($post,$oform_tocheck) { 
  $this->post = $post;
  $this->form_tocheck = $oform_tocheck;
  $this->errorsMessages = [
   "isRequired" => "Le champ #name# est obligatoire", 
   "isAlphaM" => "Le champ '#name# doit être Alpha Majuscule" 
  ]; 
 }
 
......
 
 public function validate(){
 
  foreach ($this->form_tocheck->getFields() as $name  => $rules) { 
 
   if (!array_key_exists($name, $this->post)) {
    $value = NULL;
   } else {
    $value = $this->post[$name]; 
   }
   foreach($rules as $rule) {
 
    $result = call_user_func_array(array($this, $rule), array($value));
 
    if ($result === false) {
 
     if (!array_key_exists($name, $this->errors)) {
      $this->errors[$name] = []; 
     }  
     $this->errors[$name][] =  str_replace('#name#', Secur::screen($name), $this->errorsMessages[$rule]); 
    }
 
   }
  }
 }

Code:

1
2
3
4
5
6
7
8
9
10
11
 
class Rules_SignUp extends Rules_Abstract {
 
 public function build() {
  $this->addField('nom', ['isRequired', 'isAlphaM']);
  $this->addField('prenom', ['isAlphaM']);
  $this->addField('taille', ['isRequired']);
  $this->addField('sexe', ['isRequired', 'isAlphaM']); 
 
  }
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
require 'Autoload.php'; 
 
$form_tocheck = new Rules_SignUp(); 
 
$valid = new Valid ($_POST, $form_tocheck); 
$valid->validate(); 
 
if (!$valid->isValid()) {
 $valid->displayErrors(); 
} else {
 echo 'SUITE DU TRAITEMENT - ENREGISTREMENT'; }

Merci pour votre temps et si cela peut aider modestement.....

Par ailleurs, je souhaiterai trouver mon erreur dans ma class Secur(). En effet, j'aimerai avoir quelques fonctions en static que je pourrai appeler en cas de besoin. Et appliquer une fonction de "nettoyage" à tous mes champs via $_POST.

Secur.php

Code:

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
 
<?php
 
class Secur {
 
 static function protectArray($POST) { // problème pour appliquer des méthodes sur la superglobale $_POST
 
 foreach ($POST as $name => $value) {
 
  $post[$name] = self::removeAccents($value);
  $post[$name] = strtoupper($value);
  $post[$name] = trim($value);
  $post[$name] = htmlentities($value);
  $post[$name] = strip_tags($value);
  $post[$name] = addcslashes($value, '%_');
  }
  return $post; // PROBLEME POUR RETOURNER TOUTES MES VALEURS = []
 } 
 
 
 static function protect($data) {
  $data = self::removeAccents($data);
  $data = trim($data);
  $data = htmlentities($data);
  $data = strip_tags($data);
  $data = addcslashes($data, '%_');
 
  return $data; // OK POUR CETTE FONCTION CAR IL Y A UN SEUL CHAMP
 }
 
 
 static function screen($string) {
  return htmlentities($string);
 }
 
 static function removeAccents($string) {
  $a = array('À', 'Á', 'Â', 'Ã', 'Ä', 'Å', 'Æ', 'Ç', 'È', 'É', 'Ê', 'Ë', 'Ì', 'Í', 'Î', 'Ï', 'Ð', 'Ñ', 'Ò', 'Ó', 'Ô', 'Õ', 'Ö', 'Ø');
  $b = array('A', 'A', 'A', 'A', 'A', 'A', 'AE', 'C', 'E', 'E', 'E', 'E', 'I', 'I', 'I', 'I', 'D', 'N', 'O', 'O', 'O', 'O', 'O', 'O');
  return str_replace($a, $b, $string);
 }
 
}

1. Je sais que mes fonctions de contrôles me permettent déjà de vérifier la validité des données reçus
2. En utilisant PDO et les requêtes préparées je me préserve des injections SQL
3 Je dois protéger les données qui seront affichées...

Mais pour mon apprentissage j'aimerai tout de même comprendre comment faire pour appeler plusieurs fonctions simplement ou faut-il encore passer par un array_map ou call user......
si vous avez un exemple ....

- la méthode removeAccents() ok
- la méthode protect ok

- la méthode protectArray sur un $_POST me pose problème

Code:

1
2
3
4
5
6
 
<form action="traitement.php" method="post">
 <p>Nom : <input type="text" name="nom"></p>
 <p>Prenom : <input type="text" name="prenom"></p>
 <input type="submit" name="inscriptioné" value="inscécé">
</form>

traitement.php

Code:

1
2
3
4
5
6
7
8
9
10
 
<?php
 
require 'Autoload.php'; 
require 'Secur.php'; 
 
var_dump($_POST); 
 
$post = Secur::protectArray($_POST);
var_dump($post); //  ne retourne que la dernière valeur ?? return $post !! faut-il array

je pense que cela n'est pas grand chose

Il y a beaucoup à lire et à dire.

Déjà tu n'as pas suivi les conseils qui t'ont été donnés à savoir ne pas mettre les contrôles dans la classe. Mais bon tu t'apercevras vite qu'il en manque toujours un et qu'une alternative sont les closures qui te permettent de définir des contrôles personnalisés pour chaque problématique.

Ta fonction validate ne renvoie rien et on ne voit pas le code pour isValid. Un des inconvénients de cette méthode est qu'on peut éventuellement utiliser isValid avant d'avoir appelé validate.
Comme il a déjà été dit on ne contrôle pas qu'un champ soit en MAJUSCULES ou en minuscules. On le met au bon format un point c'est tout qu'il ait été tapé en majuscules ou pas.
Tes noms de contrôles sont isRequired ou isAlphaM. Si j'écris isrequired plus rien ne fonctionne. Il faudrait que tu utilises des constantes et non pas des chaînes de caractères. Les noms des constantes sont écrits en MAJUSCULES. exemple IS_REQUIRED. Ensuite la valeur de la constante peut être "isRequired" même si pour ma part et dans un tel cas je préfèrerais donner des valeurs numériques.
Tu as mis les messages d'erreurs dans la classe. Si je suis étranger et que je dois utiliser ta classe il faut que je la modifie pour l'utiliser. Or l'intérêt d'une classe est justement d'être utilisable telle qu'elle.
Tu as nommé une variable $post. Un autre nom serait plus judicieux car tu peux utiliser une classe pour n'importe quel type d'array.
Il y a d'autres choses à dire mais je m'arrête là pour le moment. Je te félicite pour ta ténacité et ta volonté d'avancer. C'est comme ça qu'on progresse... mais il faut aussi écouter les conseils des autres ;).

Indépendamment du fait que ce soit à faire ou pas comme ça.
Tu as..
Code:

1 2 3 4 5 6 7 $post[$name] = self::removeAccents($value); $post[$name] = strtoupper($value); $post[$name] = trim($value); $post[$name] = htmlentities($value); $post[$name] = strip_tags($value); $post[$name] = addcslashes($value, '%_');
Il faudrait
Code:

1 2 3 4 5 6 7 $post[$name] = self::removeAccents($value); $post[$name] = strtoupper($post[$name]); $post[$name] = trim($post[$name]); $post[$name] = htmlentities($post[$name]); $post[$name] = strip_tags($post[$name]); $post[$name] = addcslashes($post[$name], '%_');
Il faudrait aussi que tu "initialises" le tableau $post ($post = array(); ) avant le foreach. En informatique si on initialisait tous les variables qu'on utilise il y aurait des milliards de bugs en moins.

16/11/2018, 21h04
bricoreur

Merci

j'ai apporté qq modifications

un grand merci pour m'avoir accordé du temps à la résolution de mon problème.
16/11/2018, 23h27
badaze

Depuis je me suis fait ma propre bibliothèque.
17/11/2018, 11h06
rawsrc

@badaze
attention : les fonctions strtoupper(), strip_tags(), addcslashes ne sont pas compatibles unicode !
Vu que la règle maintenant établie est de ne coder qu'en utf-8, cela va induire des problèmes chiants à déboguer.

Pour ce qui est de ta bibliothèque de validation avec des closures, je serai curieux de voir comment tu l'as implémentée, j'ai un système semblable dans mon framework.

1 pièce(s) jointe(s)

@rawsrc.

Merci je ne savais pas.

Pour ma bibliothèque, j'ai arrêté d'utiliser les closures et suis passé sur un modèle orienté objet car je voulais implémenter un système de messages d'erreur et je ne voulais pas forcément les passer en paramètre.

Avec les closures j'avais ça (je n'ai pas mis les déclarations).

Code:

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
<?php
// controle qu'un champ est rempli
$remplissage = function($array) {
 $valeur = $array[0];
    return (!empty($valeur)) ? true : false;
};// contrôle facultatif - on ne contrôle l'email que s'il est renseigné
$email_non_obligatoire = function ($array) use ($remplissage)
{
 if ($remplissage($array))
 {
  if (filter_var($array[0], FILTER_VALIDATE_EMAIL)) 
  {
   return true;
  }
  else
  {
   return false;
  }
 }
 return true;
};
// Paramètre 1 = le(s) nom(s) du/des champs à contrôler.
// Paramètre 2 = la fonction de contrôle.
// Paramètre 3 = le message d'erreur #email est remplacé par la valeur du champ. Exemple : Email toto@ invalide
$toto->addErrorControl(["email"], $email_non_obligatoire,'Email #email invalide');

Avec le modèle objet j'ai ça. Succinctement résumé.

Code:

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
 
class Controls extends GenericControls {
 
 // la méthode setError est héritée de GenericControls
 // Paramètre 1 = le code de l'erreur
 // Paramètre 2 = le message d'erreur
 //               #FD = description du champ #VA = valeur du champ
 //               Le premier #FD sera remplacé par la 1ère description de champ, le second par la 2ème
 //               Le premier #VA sera remplacé par $option1 le second par $option2
 // Dans un message on peut aussi utiliser #FN qui est remplacé par le nom du champ à contrôler
 // et #FV qui est remplacé par une valeur fixe passée à la méthode
 public function option1_option2($option1, $option2) {
  $this->setError('ERR0001',"Champs #FD et #FD. #VA est différent de #VA");
  return $option1 == $option2;
 }
 
 public function obligatoire($valeur) {
  $this->setError('ERR0002','Le champ #FD est obligatoire');
  return empty($valeur) ? false : true;
 }
 
 // ici la méthode setError a un code d'erreur uniquement
 // le texte du message provient soit d'un fichier des messages d'erreurs passé en paramètre au constructor
 // de cette classe => $controls = new Controls('error_msg_fr.txt');
 // ou passé en paramètre sur la méthode 
 public function longueur_chaine_ok($chaine,$longueur) {
  $this->setError('ERR0003');
  return (strlen($chaine) >= $longueur) ? true : false;
 } 
}
 
$controls = new Controls();
// on passe l'instance à la classe de validation
$toto = new Validate($controls);
// Paramètre 1 : tableau. Le premier élément contient le nom de la méthode de contrôle
//               les éléments suivants correspondent aux valeurs fixes de la méthode (voir un peu plus loin)
// Paramètre 2 : tableau. les noms des champs à contrôler
// Paramètre 3 : tableau. Les descriptions des champs voir #FD
$toto->addError(['obligatoire'],['nom'],['Nom']);
// Paramètre 1 : tableau. on voit la valeur 6 qui est passée au paramètre $longueur de la méthode longueur_chaine_ok
//               ceci permet d'avoir des contrôles plus 
// Paramètre 2 : tableau. le nom du champ à contrôler
// Paramètre 3 : le message d'erreur #FV est remplacé par 6.
//               le message d'erreur passé en paramètre prend le pas sur celui défini dans la méthode ou le fichier de messages
$toto->addError(['longueur_chaine_ok',6],['pseudo'],['Le pseudo n\'est pas assez long (#FV caractères min)']);
// Ici on dit que le mot de passe doit faire au moins 8 caractères.
$toto->addError(['longueur_chaine_ok',8],['mdp'],['Le mot de passe n\'est pas assez long (#FV caractères min)']);

En retour des contrôles on a un nouvel objet error qui renvoie les erreurs rencontrées sous forme de tableau (pour du PHP) ou de JSON (pour du javascript).
Grosso modo il y a 6 types d'erreurs :
1 - les erreurs addError
2 - les avertissements addWarning
3 - les champs manquants (ceux déclarés via addError ou addWarning mais qui ne sont pas passés aux contrôles)
4 - les champs en plus (ceux qui ne sont pas déclarés addError ou addWarning et qui sont passés dans le tableau des données à contrôler).
5 - la méthode passée est inconnue
6 - le nombre de paramètres est incorrect

Les méthodes de retour peuvent être filtrées par types d'erreur. Par exemple ne voir que les erreurs. Voir les erreurs et les avertissements. Tout voir sauf les erreurs champs manquants ou champs en plus. etc...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
$retour = $toto->control($_POST);
 
// renvoie s'il y a eu (au moins) une erreur parmi les 6 types possibles
$resultat = $retour->error()->errorFound();
// équivalent à 
$resultat = $retour->error(VALIDATE::FIELD_ALL)->errorFound();
 
// équivalent à erreur et avertissement. Donc si les seules erreurs étaient de type 3 à 6 mais aucune sur les types 1 et 2 cela renverra errorFound à false.
$resultat = $retour->error(VALIDATE::FIELD_ALL & ~FIELD_SYS_ERROR)->errorFound();
 
// Les données JSON sont accessibles - ici aussi les filtres s'appliquent
$json = $retour->error()->getDetailsJSON();

Le JSON est facilement utilisable.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
<script>function toto() {
    var elements = document.querySelectorAll("[id^='e_']");
 $.each(elements, function(index, element) {
  element.innerHTML ='';
 }); 
   
 $.ajax({
        url: 'test9514b.php',
        type: 'post',
        dataType: 'html',
        data: $('form#myform').serialize(),
        success: function(json) {
   alert(json);
   $.each(JSON.parse(json), function(i, obj) {
    var current = $('#e_'+obj.field).html();
    if (current == '') {
     $('#e_'+obj.field).html(obj.message);
    }
   });
        }
    }); 
}
</script>

Pièce jointe 427625

Salut badaze,

comment fais-tu pour permettre l'ajout de validateurs à la volée en cas de nécessité ? Tu est obligé de reprendre le code source de ta classe ?
Ton validateur ne devrait pas gérer le message d'erreur. quand tu écris ça :

Citation:

Pour ma bibliothèque, j'ai arrêté d'utiliser les closures et suis passé sur un modèle orienté objet car je voulais implémenter un système de messages d'erreur et je ne voulais pas forcément les passer en paramètre.

je ne vois pas en quoi la souplesse des closures t'a posé des problèmes.

Mon système de validation est assez proche (une version légèrement simplifiée):
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /** * Validator: not empty string * @param array $p * @return bool */ $len = function(array $p): bool { return isset($p[0]) ? (bool)mb_strlen((string)$p[0]) : false; }; /** * @param mixed $value * @param array $in * @return bool */ $not_in_strict = function(array $p): bool { return (isset($p[0], $p[1]) && is_scalar($p[0]) && is_array($p[1])) ? ( ! in_array($p[0], $p[1], true)) : false; };
puis le test :
Code:

1 2 3 $value_to_check = 'xyz'; Validator::check($value_to_check, ['$len', '$not_in_strict' => ['abc', 'def']]) // valeur non vide et différente de 'abc' et de 'def'

17/11/2018, 21h57
badaze
@rawsrc

Dans mon esprit il y a une classe pour chaque "écran" à contrôler donc on peut ajouter des contrôles à la volée. On peut la voir comme un conteneur au même titre que le fichier .php est le conteneur des fonctions closures; les méthodes utilisées étant définie dans la classe parente.

Mon but est d'avoir une gestion de messages d'erreurs intégrée mais qui n'est cependant pas obligatoire. Les méthodes qui renvoient les erreurs contiennent tous les éléments pour faire ses propres messages, à savoir : le type d'erreur, le code erreur (qui peut ne pas être renseigné), les noms des champs testés, leurs valeurs, le message d'erreur (qui lui aussi n'est pas obligatoire).

J'aurais pu faire une classe qui constitue les messages d'erreur mais j'ai estimé qu'elle interviendrait trop tard. En effet si je contrôle le remplissage d'un champ et sa valeur (comme dans ton exemple) et que je constitue les messages d'erreurs après le contrôle, il faut que j'arrive à savoir si le message d'erreur que je dois afficher est celui qui indique que le champ n'est pas rempli ou bien que la valeur renseignée est incorrecte. Donc au mieux j'ai besoin que ma classe de contrôle renvoie un code erreur que je remplacerai par un message et au pire si je n'ai aucune information sur l'erreur je ne peux pas déterminer laquelle afficher. Donc quand je me suis aperçu qu'il me fallait au moins un code erreur pour afficher la bonne information à l'utilisateur je me suis dit que tant qu'à faire autant constituer le message au moment où on fait le contrôle. Mais bon, avec l'expérience on sait qu'on ne pense pas forcément à tout au moment où on programme et je me suis laissé une porte ouverte en renvoyant tous les éléments permettant de constituer en dehors de la classe de contrôle les messages à afficher.

Un autre avantage que j'ai vu est la possibilité de décrire et mettre des noms aux paramètres. Ainsi :
Bien évidemment il s'agit d'un exemple trivial.
Code:

1 2 3 4 public function controle_option($option1, $option2) { return $option1 == $option2; }
est plus parlant que :
Code:

1 2 3 4 5 $controleOption = function($array) { return $array[0] == $array[1]; };
ou (si on veut rendre le code plus parlant) que :
Code:

1 2 3 4 5 6 $controleOption = function($array) { list($option1,$option2) = $array; return $option1 == $option2; };
17/11/2018, 22h25
rawsrc

Citation:

Envoyé par badaze

si je contrôle le remplissage d'un champ et sa valeur (comme dans ton exemple) et que je constitue les messages d'erreurs après le contrôle, il faut que j'arrive à savoir si le message d'erreur que je dois afficher est celui qui indique que le champ n'est pas rempli ou bien que la valeur renseignée est incorrecte. Donc au mieux j'ai besoin que ma classe de contrôle renvoie un code erreur que je remplacerai par un message et au pire si je n'ai aucune information sur l'erreur je ne peux pas déterminer laquelle afficher. Donc quand je me suis aperçu qu'il me fallait au moins un code erreur pour afficher la bonne information à l'utilisateur je me suis dit que tant qu'à faire autant constituer le message au moment où on fait le contrôle. Mais bon, avec l'expérience on sait qu'on ne pense pas forcément à tout au moment où on programme et je me suis laissé une porte ouverte en renvoyant tous les éléments permettant de constituer en dehors de la classe de contrôle les messages à afficher.

J'ai résolu ce problème avec une classe spécifique : dès qu'une valeur se présente, elle est encapsulée dans une classe qui lui fournit tous les services d'identification, de valeur saisie, de collecteur d'erreur.
Ma valeur ne voyage à travers toute l'application qu'armée de se classe ce qui elle permet de remonter à la surface n'importe quel problème relatif à la valeur où qu'elle apparaît et ainsi au final, tu peux tout remonter au rendu à ta guise.
Enfin, question perfs, aucun souci dans la mesure où une classe n'est manipulée que par référence alors que les scalaire et tableau sont dupliqués (certes PHP bénéficie d'un sacré mécanisme d'optimisation dans ce cas de figure)
18/11/2018, 00h00
badaze

Tu peux poster un exemple ? Je suis curieux.

Salut,

quelque chose dans ce genre

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
class MyVar
implements IEECollectable
{
    /**
     * Valeur saisie et récupérée par l'utilisateur
     *
     * @var mixed
     */
    private $user_value;
    /**
     * Nom littéral de la valeur utilisé dans l'interface graphique
     * utilisé pour la personnalisation automatique des messages d'erreur
     *
     * @var string
     */
    private $gui_name = null;
    /**
     * @var EECollector Exceptions and Errors Collector
     */
    private $eec;
 
    /**
     * @param mixed  $value
     * @param string $gui_name Nom littéral de la valeur utilisé dans une interface graphique
     */
    public function __construct($value = null, ?string $gui_name = null)
    {
        $this->user_value = $value;
        $this->gui_name   = $gui_name;
        $this->eec        = new EECollector();
    }
 
    /**
     * Renvoie le collecteur d'erreurs et d'exceptions
     *
     * @return EECollector
     */
    public function eec(): EECollector
    {
        return $this->eec;
    }
 
    /**
     * @return mixed
     */
    public function userValue()
    {
        return $this->user_value;
    }
 
    /**
     * Définit l'identifiant de l'interface graphique auquel est rattachée la variable
     *
     * @param  string $p
     * @return MyVar
     */
    public function setGuiName(string $p): self
    {
        $this->gui_name = $p;
 
        return $this;
    }
 
    /**
     * Renvoie l'identifiant de l'interface graphique auquel est rattachée la variable
     *
     * @return string|null
     */
    public function guiName(): ?string
    {
        return $this->gui_name;
    }
}

ensuite quand t'as besoin de manipuler une donnée externe sans savoir au préalable quls traitements elle va subir : $nom = new MyVar($_POST['nom'], 'nom_du_controle_sur_le_formulaire');Comme cette classe contient un collecteur d'erreurs, tu la passes partout où t'en as besoin et en cas d'erreur : $nom->eec()->addAlert(...); ou $nom->eec()->addException($e);En fin de traitement, tu gardes ta variable $nom et tu peux savoir tout ce qu'elle a collecté.
Version simplifiée, mais la logique est là :ccool:

19/11/2018, 19h45
badaze

Merci.
Je pense avoir saisi le concept mais il faut que ça mûrisse. Par contre je ne vois pas comment cela peut fonctionner dans le cas d’un contrôle qui implique plusieurs champs.

Fuseau horaire GMT +2. Il est actuellement 08h45.