Semplifica la gestione delle forme in grande stile

Risparmia tempo, riduci i problemi di manutenzione, semplifica il codice e fai tutto mentre ti senti un genio bizzarro! In questo tutorial, impara come usare variabili variabili, array di ricerca e un po 'di programmazione intelligente per semplificare la gestione delle forme in modo grandioso.

---

Variabili variabili, metodi e proprietà

Prima di poter utilizzare in modo approfondito un array di ricerca, è importante comprendere innanzitutto il concetto alla base delle variabili variabili.

Quali sono variabili variabili?

Variabile variabile è un termine che descrive l'uso di una variabile per dichiarare un'altra variabile.

Nella forma più semplice, una variabile variabile potrebbe essere simile a:

 $ pippo = 'Un valore!'; // Dichiara un valore iniziale $ bar = 'pippo'; // Aspetta, cosa sta succedendo? echo $$ bar; // Santo schifo! Quell'output "Un valore!"

Perché dovresti preoccuparti??

Quando si guarda una dimostrazione di concetto come nell'esempio precedente, l'uso di variabili variabili probabilmente sembra piuttosto sciocco e complicato. Tuttavia, ci sono davvero dei solidi motivi pratici per usarli in alcuni casi.

Esempi pratici

L'uso responsabile delle variabili variabili può ridurre drasticamente la quantità di codice che deve essere ripetuta, ad esempio, convertendo un array associativo in un oggetto con valori sterilizzati.

Esempio senza variabili variabili

$ comment = new stdClass (); // Crea un oggetto $ comment-> name = sanitize_value ($ array ['name']); $ comment-> email = sanitize_values ​​($ array ['email']); $ comment-> url = sanitize_values ​​($ array ['url']); $ comment-> comment_text = sanitize_values ​​($ array ['comment_text']);

Esempio con variabili variabili

$ comment = new stdClass (); // Crea un nuovo oggetto foreach ($ array come $ key => $ val) $ comment -> $ key = sanitize_values ​​($ val); 

Vedi quanto è stato più semplice? E puoi immaginare quale sia l'esempio senza variabili variabili apparirebbero se l'array avesse qualcosa come 50 o 100 valori.

NOTA: Sono consapevole che potresti anche usare array_map () ed espressamente cast l'array come un oggetto per realizzare la stessa cosa. Non è questo il punto. Stiamo illustrando un concetto, qui. Stare al gioco.

---

Il problema con l'elaborazione della forma

Trasforma la forma in un gioco da ragazzi.

Ora che sai come usare variabili variabili, possiamo passare alla carne e alle patate di questo articolo, che è l'idea che incorporare una matrice di ricerca invece di più file di controller o un'istruzione switch possa farti risparmiare molta manutenzione extra, codice ripetuto e mal di testa in generale.

Per illustrare il nostro concetto, useremo l'idea dell'elaborazione dei moduli. Questo è un aspetto essenziale della programmazione web e può anche essere una delle aree più noiose di qualsiasi progetto.

Tuttavia, dopo aver rivalutato le abitudini di codifica, è possibile rendere l'elaborazione dei moduli un gioco da ragazzi.

Spesso viene creato un singolo file per ogni modulo da elaborare o viene utilizzata un'istruzione switch. In questa sezione vedremo come entrambe le soluzioni potrebbero essere implementate, quindi esamineremo una soluzione utilizzando variabili variabili e come può migliorare i tuoi progetti.

Un esempio di lavoro con più file di elaborazione dei moduli

Un metodo spesso utilizzato per gestire gli invii di moduli consiste nel creare un file completamente nuovo per gestire separatamente i dati di ciascun modulo.

Prendiamo, ad esempio, questi tre moduli che aggiornano un account utente con un nuovo nome, una nuova email o entrambi:

 
 
Modulo 1
 Nome     
 
 
 
 
Modulo 2
 E-mail     
 
 
 
 
Modulo 3
 Nome   E-mail     
 

Ognuna di queste forme punta a un diverso file di elaborazione. Che aspetto hanno questi file??

Modulo di elaborazione 1 (assets / inc / ex1-form1.php)

save_name (); // Per questo esempio, emetti solo alcuni dati sull'invio del modulo echo "
File di elaborazione: ", $ _SERVER ['PHP_SELF'], \ n \ nMetodo di uscita:\ n ", $ output"
\ n ","
Torna indietro
';  else die ('Invalid form submission'); 

Modulo di elaborazione 2 (assets / inc / ex1-form2.php)

save_email (); // Per questo esempio, emetti solo alcuni dati sull'invio del modulo echo "
File di elaborazione: ", $ _SERVER ['PHP_SELF'], \ n \ nMetodo di uscita:\ n ", $ output"
\ n ","
Torna indietro
';  else die ('Invalid form submission'); 

Modulo di elaborazione 3 (assets / inc / ex1-form3.php)

save_both (); // Per questo esempio, emetti solo alcuni dati sull'invio del modulo echo "
File di elaborazione: ", $ _SERVER ['PHP_SELF'], \ n \ nMetodo di uscita:\ n ", $ output"
\ n ","
Torna indietro
';  else die ('Invalid form submission'); 

Come puoi vedere chiaramente, i file di esempio sopra riproducono una tonnellata di codice. Espandi questo a 15 moduli su un sito e troverai rapidamente che la manutenzione potrebbe diventare un incubo.

La classe account

Come puoi vedere, i file di elaborazione stanno creando un'istanza della classe CopterLabs_Account. Questa sarà una classe molto semplice che genera informazioni sull'invio di un modulo.

Ecco il codice per la classe (assets / inc / class.coperlabs_account.inc.php):

 * @copyright 2011 Copter Labs * @license http://www.opensource.org/licenses/mit-license.html * @license http://www.gnu.org/licenses/gpl-3.0.txt * / class CopterLabs_Account public $ name = NULL, $ email = NULL; public function save_name () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); return "Metodo:". __METODO__ . "\ nName:". $ questo-> nome. "\ N";  public function save_email () $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); return "Metodo:". __METODO__ . "\ nEmail:". $ this-> email. "\ N";  public function save_both () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); return "Metodo:". __METODO__ . "\ nName:". $ questo-> nome. "\ nEmail:". $ this-> email. "\ N"; 

Puoi provare questo codice nell'esempio 1 sulla pagina demo.

Un esempio di lavoro con un singolo file di elaborazione e una dichiarazione switch

Un'altra soluzione popolare per l'elaborazione dei moduli consiste nel consolidare tutti gli script di elaborazione in un unico file e determinare cosa fare con i dati utilizzando un'istruzione switch.

L'approccio switch utilizza comunemente un trucco in cui un input nascosto viene aggiunto al modulo contenente un'azione da intraprendere al momento dell'invio. Questo
l'azione viene quindi utilizzata per determinare cosa fare con il modulo.

Ecco le stesse tre forme, dall'alto, con le azioni aggiunte, tutte rivolte a un singolo file di elaborazione:

 
 
Modulo 1
 Nome      
 
 
 
 
Modulo 2
 E-mail      
 
 
 
 
Modulo 3
 Nome   E-mail      
 

E il nuovo file di elaborazione ha il seguente aspetto: (assets / inc / EX2-switch.php)

save_name (); rompere; // Form 2 che gestisce il caso 'update-email': $ output = $ account_obj-> save_email (); rompere; // Caso di gestione del modulo 3 'update-both': $ output = $ account_obj-> save_both (); rompere; // Se non viene trovata alcuna azione valida, qualcosa non è corretto default: die ('Azione non supportata.');  // Per questo esempio, è sufficiente generare alcuni dati sull'invio del modulo echo "
File di elaborazione: ", $ _SERVER ['PHP_SELF']," \ nAzione: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMetodo di uscita:\ n ", $ output"
\ n ","
Torna all'esempio 2
';  else die ('Invalid form submission'); 

Puoi vederlo in azione visitando l'Esempio 2 sulla pagina demo. Questo è un netto miglioramento rispetto all'uso di più moduli, ma puoi vedere che stiamo ancora duplicando del codice.

Oltre a questo, è una mia preferenza personale da evitare interruttore dichiarazioni ogni volta che posso. Questo è dovuto al fatto che interruttore usa paragoni allentati ('una stringa' si innescherà caso 0 perché una stringa valuta 0 se lo converti in un intero) e lo è estremamente facile da trasformare in codice spaghetti.

---

Risolvere il problema: cerca matrici e variabili variabili

Come abbiamo visto finora, entrambe le soluzioni di cui sopra hanno i loro svantaggi e richiedono un codice duplicato. Immagina se ci fossero una dozzina o più moduli sul sito - non belli.

Per risolvere questo problema, possiamo usare un concetto chiamato a array di ricerca, che mappa le azioni passate dal modulo a un metodo chiamato sull'oggetto.

Sì, è possibile impostare l'azione come nome del metodo, ma ciò consente a un modulo di invio falso di chiamare qualsiasi metodo pubblico. Rendere la matrice una coppia chiave-valore è un piccolo passo per aggiungere un po 'più di controllo senza molto lavoro extra.

Un esempio di lavoro con un singolo file di elaborazione e una matrice di ricerca

Usando la nostra conoscenza delle variabili variabili dall'inizio di questo tutorial, modifichiamo la demo per utilizzare un array di ricerca.

Modificare i tre moduli per puntare a un nuovo file di controller:

 
 
Modulo 1
 Nome      
 
 
 
 
Modulo 2
 E-mail      
 
 
 
 
Modulo 3
 Nome   E-mail      
 

Quindi, unisci il file di elaborazione che gestirà i moduli di invio (assets / inc / EX3-lookup-array.php):

 'save_name', 'update-email' => 'save_email', 'update-both' => 'save_both'); // Assicurati che la chiave dell'array esista se (array_key_exists ($ action, $ lookup_array)) // Usando variabili variabili, chiama il metodo corretto e memorizza l'output $ output = $ account_obj -> $ lookup_array [$ action] ();  else die ('Azione non supportata.');  // Per questo esempio, è sufficiente generare alcuni dati sull'invio del modulo echo "
File di elaborazione: ", $ _SERVER ['PHP_SELF']," \ nAzione: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMetodo di uscita:\ n ", $ output"
\ n ","
Torna all'esempio 3
';  else die ('Invalid form submission'); 

Dai un'occhiata alla pagina demo provando i moduli dell'esempio 3.

Dal momento che impostiamo l'azione come chiave nell'array, usiamo array_key_exists () per garantire che l'azione sia valida. Quindi, usiamo il valore che corrisponde all'azione come nome del metodo. Si noti che abbiamo aggiunto le parentesi dopo il valore per assicurarsi che sia eseguito come metodo.

L'aggiunta dell'array di ricerca mantiene il codice conciso, semplice e chiaro (una volta ottenuto il blocco delle variabili variabili).

---

Sommario

Utilizzati in modo responsabile, gli array di ricerca possono rendere gli script molto più facili da aggiornare e mantenere quando li si combina con variabili variabili.

Come pensi di poter integrare array di ricerca e variabili variabili nei tuoi progetti per semplificare la manutenzione? Fatemi sapere nei commenti!