Hoi allemaal.

Ik ben begonnen aan een validator class te schrijven die ik op 1 website voor meerdere formulieren te schrijven, ik heb dit ongeveer als schets geschreven:

//index.php
$validator = new Validator();
$validator->validate($_POST);

//Validator.php
$data = [];
$errors = [];

public function validate($values){
  $foreach($values as $key => $value){
    switch($value){
      case is_array($value);
        $this->validate_array($key, $value);
        break;
      default: 
        $this->validate_text($key, $value);
    }
  }
}

public function validate_text($key, $value){
  if(isset($value) && !empty($value)){
    $this->data[$key] = $value;
  } else {
    $key = ucfirst($key);
    $this->errors[$key] = "field for $key is required";
  }
}

public function validate_array($key, $value){
    $choices = array_filter($value);
    if(!empty($choices) && count($choices) > 0) {
       $this->data[$key] = $value;
    } else {
        $this->errors[$key] = "Make atleast one of the choices"
    }
}


Ik heb sowieso nog een functie nodig die checkt of er errors zijn, zo ja dan zou ik een error functie de errors moeten kunnen laten returnen naar de html om ze daar te plaatsen, en een functie die alle $data die ontvangen is kan versturen. Voor de rest zie ik zo gauw even geen foutjes, maar die zullen er vast wel tussen zitten.
Als je uitsluitend $validator->validate($_POST) aanroept, hoe weet je validator dan vervolgens hoe het formulier eruitziet en wat geldige en ongeldige formulierwaarden zijn?
Ik dacht dat ik met die foreach de velden kon loopen, en in de switch kan checken wat voor soort veld het is, en aan de hand daarvan de juiste validatie functie gebruiken.
Wat er niet is (bijvoorbeeld een niet aangevinkte checkbox zit niet in de $_POST) ga je dan ook niet controleren.

Is '123a' een (foutief) getal of een (correcte) string?

Wat als je at least 2 vinkjes moet zetten?

Wat als een string aan een bepaald formaat moet voldoen (min/max aantal tekens, geen cijfers, enz)?
In mijn geval is het met een array van iets dat in een $_POST variabel zit, is dat er minstens 1 waarde in de array moet zitten. een lege array zou dus een error moeten geven. Al die andere regels zoals wat je in je laatste zin zet, zou ik bijvoorbeeld een validate_email functie moeten maken om te checken of het een geldig email is, en voor andere velden het zelfde concept maar dan anders. Etc.
Een formulier bestaat uit velden. Aan velden kun je regels hangen. Bij de validatie zou de validatie-methode van het formulier de validatie-methode van het veld (voor alle velden, in een loop) aan moeten roepen. Elk veld zou vervolgens alle ingestelde regels voor dat veld moeten aflopen om te kijken of de validatie van het veld voldeed. Dit rapporteert het veld (object) terug aan het formulier (object), en uiteindelijk geeft het formulier een soort van reactie terug. Bijvoorbeeld ofwel een volledig gefilterd, gevalideerd array (van de oorspronkelijke POST data), ofwel false indien validatie mislukte.

Dan zul je bij velden nog leesbare foutmeldingen bij moeten houden, en deze op een of andere manier moeten bewaren als je terug wordt gestuurd naar het formulier. Deze zou je bijvoorbeeld op kunnen slaan in een sessie.

Idealiter zal er dus communicatie tussen de objecten plaatsvinden. Hierbij zou je zelfs de validatiemethoden aan een veld-class kunnen hangen, of er dus voor kunnen kiezen om hier aparte classes voor te maken, maar het is niet echt nodig om dit zover uit te splitsen allemaal, ook omdat de validatieregels vaak redelijk specifiek zijn, of op een specifieke manier gecontroleerd dienen te worden binnen het veld(type).

Reageren