Come posso semplificare l'elaborazione dei moduli in PHP?

Question

Sono stato uno sviluppatore PHP da un po 'di tempo ma fino ad oggi non ho trovato un modo semplice per elaborare (cioè normalizzare, disinfettare, convalidare, popolare e visualizzare i moduli ed i rispettivi errori di campo).

So che la maggior parte dei framework PHP oggigiorno rende questo lavoro più semplice ma in qualche modo non mi sento come trasferire tutto il mio codice su uno di questi framework e non riesco a capire come viene implementata la validazione del modulo in Django per esempio (lo so, è Python ma mi piace molto il loro approccio), quindi penso che il modo migliore per me di pubblicare qui il modo in cui elaboro un semplice modulo e forse voi ragazzi potete indicarmi la direzione migliore.

<?php 

// sample controller 
class _sample extends framework 
{ 
    // sample action 
    function contact() 
    { 
     if ($this->Is->Post() === true) 
     { 
      $errors = array(); 

      if ($this->Is->Set($_POST['name']) === false) 
      { 
       $errors['name'] = 'Please fill in your name.'; 
      } 

      if (($this->Is->Email($_POST['email']) === false) || ($this->Is->Set($_POST['email']) === false)) 
      { 
       $errors['email'] = 'Please fill in your email address.'; 
      } 

      if (($this->Is->Phone($_POST['contact']) === false) && ($this->Is->Mobile($_POST['contact']) === false)) 
      { 
       $errors['contact'] = 'Please fill in your phone (or cell phone) number.'; 
      } 

      if ($this->Is->Set($_POST['message']) === false) 
      { 
       $errors['message'] = 'Please type a message'; 
      } 

      // no errors, it's valid! 
      if (empty($errors) === true) 
      { 
       // do stuff and redirect to "success"/"thank you" page 
      } 

      // load the form view, and let it display the errors 
      // automatically prefill fields with $_POST values 
      else 
      { 
       $this->View('contact_form', $errors); 
      } 
     } 

     // load the form view for the first time 
     else 
     { 
      $this->View('contact_form'); 
     } 
    } 
} 

?> 

Come si può vedere, questo dovrebbe essere un semplice modulo di contatto però ci vuole la vita fuori di me per la convalida, l'ho cercato in alcuni modelli di progettazione (Observer, fabbrica) ma non lo faccio sentirsi sicuri se e in che modo dovrei implementarli.

Answer 1

È possibile creare una classe base astratta per tutti i moduli, classi per fieldtypes e una classe statica solo per la convalida dei valori di vari tipi (validateString, validateHtml, validateEmail, validateNumber, date, ecc., Solo i metodi ..). Definendo il tuo modulo, definiresti quali oggetti del campo utilizzerebbe, quindi il metodo Form-> validate() invocherà Field-> validate() e restituirà il valore filtrato o il messaggio di errore. Specificare i messaggi di errore predefiniti per i campi, ma dare un'opzione per sovrascriverli quando si definiscono i campi nella classe del modulo.

Oh, e lascia quella cosa $ _POST. Leggere il post una volta, passarlo una volta alla convalida del modulo e quindi lavorare sui valori dei campi filtrati.

Un'altra cosa è che ci sono vari modi per ottenere la convalida del modulo a seconda delle esigenze e dell'architettura delle applicazioni, può essere difficile fare un validatore di moduli per tutti gli usi quando si hanno diversi approcci alla progettazione dell'applicazione. Scegli un modo di fare il tuo lavoro e attenersi ad esso (indipendentemente dal fatto che sia un framework pronto per andare o il tuo codice), o qualsiasi altra convalida di super-duper-form che scrivi, non avrà alcun senso in questi ultimi progetti.

Uno di più: come Django? Buona! Quindi inizia a programmare Python in Django, cambierai davvero il modo di pensare a come portare a termine il tuo lavoro.

Answer 2

So che è qualcosa che hai escluso, e anche io ero come te fino a un anno fa, quando mi sono imposto di imparare qualcosa di oscuro come Qcodo (framework php), ed ecco, non posso fare nulla senza ora. È semplicemente meraviglioso togliersi un sacco di peso sempre ripetuto dalle spalle. Perché Qcodo? A quel tempo volevo imparare quello più avanzato da quando sto già imparando, quindi ho cercato il set di funzioni più ampio, che Qcodo sembrava offrire. Oggi non so quale sia il più caldo, ma per me Qcodo continua a soddisfare tutti i miei bisogni.

Answer 3

IMHO, il tentativo di trattare un modulo come un singolo concetto è un fallimento. Se si dispone di un qualsiasi tipo di architettura a più livelli per l'applicazione, è probabile che i moduli li attraversino. I moduli hanno una logica applicativa (livello controller), hanno una rappresentazione visiva (livello vista), hanno stato (modello livello applicazione) e alla fine invocano di solito un qualche tipo di script transazionale (livello del modello).

Penso che sia molto meglio abbandonare l'idea di una "forma" come entità e concentrarsi invece sulle tre parti (elaborazione di input, rendering e livello del modello) come argomenti completamente separati, che potrebbero solo (o potrebbero non) capita di essere strettamente collegati l'uno all'altro. Questo è talvolta definito come il pattern MVC, sebbene il termine sia così fortemente caricato da ora che potrebbe significare un sacco di cose.