Förenkla formulärhantering på ett stort sätt

Spara tid, minska underhållsbrist, förenkla din kod och gör allt medan du känner dig som ett freakin-geni! I den här handledningen kan du lära dig hur du använder variabla variabler, uppslagningsrader och lite smart programmering för att förenkla formulärhantering på ett stort sätt.

Variabla variabler, metoder och egenskaper

Innan vi kan få för djupt in i att använda en lookup-array, är det viktigt att först förstå konceptet bakom variabla variabler.

Vad är variabla variabler?

Variabel variabel är en term som beskriver användningen av en variabel för att deklarera en annan variabel.

I den enklaste formen kan en variabel variabel se ut:

 $ foo = 'Ett värde!'; // Förklara ett initialvärde $ bar = 'foo'; // Vänta, vad händer? echo $$ bar; // Helig skit! Den utsignalen "Ett värde!"

Varför ska du bry dig?

När man tittar på ett bevis på konceptet som det föregående exemplet ser det sig ganska dumt och överkomplicerat med hjälp av variabla variabler. Det finns emellertid i själva verket sola, praktiska skäl att använda dem i vissa fall.

Praktiska exempel

Den ansvarsfulla användningen av variabla variabler kan drastiskt minska mängden kod som måste upprepas genom att säga att konvertera en associativ array till ett objekt med saniterade värden.

Exempel utan variabla variabler

$ comment = new stdClass (); // Skapa ett objekt $ 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']);

Exempel med variabla variabler

$ comment = new stdClass (); // Skapa ett nytt objekt foreach ($ array som $ key => $ val) $ comment -> $ key = sanitize_values ($ val);

Se hur mycket enklare det var? Och du kan föreställa dig vad exemplet utan variabla variabler skulle se ut om arrayen hade något liknande 50 eller 100 värden.

NOTERA: Jag är medveten om att du också kan använda array_map () och uttryckligen kasta matrisen som ett objekt för att uppnå samma sak. Det är inte det som är poängen. Vi illustrerar ett koncept här. Spela med.

Problemet med formulärbehandling

Gör en form som bearbetar en bris.

Nu när du vet hur du använder variabla variabler, kan vi gå vidare till köttet och potatisen i den här artikeln, vilket är tanken att det med en uppslagningsgrupp istället för flera kontrollerfiler eller ett omkopplingsdeklaration kan spara mycket extra underhåll, upprepad kod och huvudvärk i allmänhet.

För att illustrera vårt koncept ska vi använda idén om formbehandling. Detta är en viktig aspekt av webbprogrammering, och kan också vara en av de mest tråkiga områdena i något projekt.

Men efter att ha utvärderat dina kodvanor kan du eventuellt göra formuläret att bearbeta en bris.

Ofta skapas en enskild fil för varje formulär som ska behandlas, eller om ett omkopplingsdeklaration används. I det här avsnittet går vi igenom hur båda lösningarna kan implementeras, och vi undersöker en lösning med variabla variabler och hur det kan förbättra dina projekt.

Ett arbetsexempel med flera formbehandlingsfiler

En ofta använd metod för hantering av formulärinsändningar är att skapa en helt ny fil som hanterar varje formulärs data separat.

Ta till exempel dessa tre formulär som uppdaterar ett användarkonto med ett nytt namn, nytt e-postmeddelande eller båda:

  Form 1
 namn     
 
   Form 2
 E-post     
 
   Form 3
 namn   E-post

Vart och ett av dessa formulär pekar på en annan behandlingsfil. Så hur ser alla dessa filer ut?

Bearbetningsformulär 1 (tillgångar / inc / ex1-form1.php)

save_name (); // För det här exemplet, skriv bara ut några data om formulärinsändningen eko "Behandlingsfil: ", $ _SERVER ['PHP_SELF']," \ n \ nMetodutgång:\ n ", $ output"
\ n ","Gå tillbaka
';  else die ('Invalid form submission');

Bearbetningsformulär 2 (tillgångar / inc / ex1-form2.php)

save_email (); // För det här exemplet, skriv bara ut några data om formulärinsändningen eko "Behandlingsfil: ", $ _SERVER ['PHP_SELF']," \ n \ nMetodutgång:\ n ", $ output"
\ n ","Gå tillbaka
';  else die ('Invalid form submission');

Bearbetningsformulär 3 (tillgångar / inc / ex1-form3.php)

save_both (); // För det här exemplet, skriv bara ut några data om formulärinsändningen eko "Behandlingsfil: ", $ _SERVER ['PHP_SELF']," \ n \ nMetodutgång:\ n ", $ output"
\ n ","Gå tillbaka
';  else die ('Invalid form submission');

Som du tydligt kan se, duplicerar exemplet filer ovan ett ton kod. Utöka detta till 15 formulär på en webbplats, och du hittar snabbt att underhåll kan bli en mardröm.

Kontoklassen

Som du kan se skapar bearbetningsfilerna en förekomst av klassen CopterLabs_Account. Detta kommer att bli en mycket enkel klass som ger information om formulärinsändning.

Här är koden för klassen (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; allmän funktion save_name () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); returnera "Metod:". __METHOD__. "\ nName:". $ this-> namn. "\ N";  allmän funktion save_email () $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); returnera "Metod:". __METHOD__. "\ nEmail:". $ this-> email. "\ N";  allmän funktion save_both () $ this-> name = htmlentities ($ _ POST ['name'], ENT_QUOTES); $ this-> email = htmlentities ($ _ POST ['email'], ENT_QUOTES); returnera "Metod:". __METHOD__. "\ nName:". $ this-> namn. "\ nEmail:". $ this-> email. "\ N";

Du kan prova den här koden på exempel 1 på demosidan.

Ett arbetsexempel med en enda bearbetningsfil och en omkopplingsförklaring

En annan populär lösning för formbehandling är att konsolidera alla behandlingsskript i en fil och bestämma vad som ska göras med data med hjälp av en omkopplingsdeklaration.

Omkopplingsmetoden använder ofta ett knep där en dold ingång läggs till i formuläret som innehåller en åtgärd som ska vidtas vid inlämning. Detta
åtgärd används sedan för att bestämma vad man ska göra med formuläret.

Här är samma tre former, ovanifrån, med tillagda åtgärder, alla pekar på en enda behandlingsfil:

  Form 1
 namn      
 
   Form 2
 E-post      
 
   Form 3
 namn   E-post

Och den nya behandlingsfilen ser ut som: (tillgångar / inc / ex2-switch.php)

save_name (); ha sönder; // Form 2 hanteringsfall "uppdaterings-email": $ output = $ account_obj-> save_email (); ha sönder; // Form 3 hanteringsfall 'uppdatering-båda': $ output = $ account_obj-> save_both (); ha sönder; // Om ingen giltig åtgärd hittas finns något inte rätt standard: die ("Unsupported action.");  // För det här exemplet, skriv bara ut några data om formulärinsändningsekoholet "Processfil: ", $ _SERVER ['PHP_SELF']," \ nAction: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMetodutgång:\ n ", $ output"
\ n ","Gå tillbaka till exempel 2
';  else die ('Invalid form submission');

Du kan se detta i åtgärd genom att besöka exempel 2 på demosidan. Det här är en markant förbättring jämfört med flera former, men du kan se att vi fortfarande duplicerar någon kod.

Utöver det är det en personlig preferens för mig att undvika växla uttalanden när jag kan. Detta beror på det faktum att växla använder lös jämförelser ("en sträng" kommer att utlösa fall 0 eftersom en sträng utvärderas till 0 om du konverterar det till ett heltal) och är ytterst lätt att göra om till spagetti koden.

Åtgärda problemet: Lookup Arrays och variabla variabler

Såsom vi har sett hittills har båda ovanstående lösningar sina nackdelar och kräver dubbla kod. Tänk om det fanns ett dussin eller flera former på webbplatsen - inte söt.

För att lösa problemet kan vi använda ett koncept som heter a lookup array, som kartlägger de åtgärder som överförts från formuläret till en metod som kallas objektet.

Ja, du kan ange åtgärden som metodnamn, men det tillåter att en falsk formulär inlämnas för att ringa någon offentlig metod. Att göra matrisen ett nyckelvärdespar är ett litet steg för att lägga till lite mer kontroll utan mycket extra arbete.

Ett arbetsexempel med en enda bearbetningsfil och en uppslagsarray

Med hjälp av vår kunskap om variabla variabler från början av denna handledning, låt oss ändra vår demo för att använda en lookup-array.

Ändra de tre formulären för att peka på en ny kontrollerfil:

  Form 1
 namn      
 
   Form 2
 E-post      
 
   Form 3
 namn   E-post

Därefter sammanställs bearbetningsfilen som hanterar formulärinsändningar (assets / inc / EX3-lookup-array.php):

 'save_name', 'update-email' => 'save_email', 'update-both' => 'save_both'); // Se till att matrisnyckeln existerar om (array_key_exists ($ action, $ lookup_array)) // Använd variabelvariabler, ring den korrekta metoden och lagra utmatningen $ output = $ account_obj -> $ lookup_array [$ action] ();  else die ("Unsupported action.");  // För det här exemplet, skriv bara ut några data om formulärinsändningsekoholet "Processfil: ", $ _SERVER ['PHP_SELF']," \ nAction: ", htmlentities ($ _ POST ['action'], ENT_QUOTES)," \ n \ nMetodutgång:\ n ", $ output"
\ n ","Gå tillbaka till exempel 3
';  else die ('Invalid form submission');

Kolla in det här på demoversidan genom att prova formulären i exempel 3.

Eftersom vi sätter åtgärden som nyckeln i matrisen använder vi array_key_exists () för att säkerställa att åtgärden är giltig Sedan använder vi värdet som motsvarar åtgärden som metodnamn. Observera att vi lagt till parenteserna efter värdet för att se till att det exekveras som en metod.

Tillägget av lookup-arrayen håller koden kortfattad, enkel och klar (när du hänger på variabla variabler).

Sammanfattning

Används på ett ansvarsfullt sätt, kan sökfält göra dina skript mycket enklare att uppdatera och underhålla när du kombinerar dem med variabla variabler.

Hur tror du att du kan integrera sökfält och variabla variabler i dina projekt för att underlätta underhållet? Låt mig veta i kommentarerna!

Koda