PHP Validerings klass


 Inspiration från boken ”PHP Object Oriented Solutions” av David Powers

Detta är andra delen i serien – PHP Validering. Idag fortsätter vi där vi slutade förra gånge och börjar bygga på en PHP validerings klass, så att man slipper hålla på med alla komplicerade arrayer med alternativ och konstanter. För trots filterfunktionernas komplexitet, så är deras förmåga att filtrera eller validera flera variabler i ett enda moment väldigt användbar. Vad vi behöver är en anpassad klass för att bygga flerdimensionella arrayer som avgör hur varje variabel ska behandlas. När arrayen har byggtsär det bara en fråga om att föra den till den lämpliga filterfunktionen och fånga resultatet. Genom att kapsla varje steg i processen inne i klassen, kommer vi att sluta med ett valideringsverktyg som är enklare att använda, då den lämnar allt det hårda arbete till filterfunktionerna.

Först av allt, låt oss överväga vilken funktionalitet klassen ska ha.

 

Bestämma vad klassen ska göra

Om man tittar på dom tillgängliga filtren kan man snabbt komma underfund med vad klassen bör kunna validera:

  • Heltal
  • Flyttal
  • Booleska värden
  • Email adresser
  • URL adresser
  • Och matcha reguljära uttryck

…den måste också kunna ta bort HTML-taggar och omvandla specialtecken. Följande uppgifter behövs ofta vid validering av indata från användaren:

  • Kontrollera att alla obligatoriska fält har ett värde.
  • Kontrollera om en array är numerisk.
  • Ange ett lägsta och högsta antal tecken vid textinmatning.

…slutligen behövs en metod som gör ingenting! Den lägger helt enkelt en oförändrad värde till det filtrerade resultat, som man sedan kan bearbeta separat.
Efter att indata från användaren har validerats, ska klassen producera tre arrayer på följande sätt:

  • De filtrerade resultat.
  • Namnen på obligatoriska fält som fattades.
  • Eventuella felmeddelanden som genererades under valideringsprocessen.

…okej nu räcker det, eftersom det här betyder en hel del kodning och vill du, kan du lägga till egna metoder senare.

 

Planera klassen

Då var det dags att planera klassen. Eftersom den bör kunna ta emot flera värden åt gången behöver den baseras på antingen filter_var_array() eller filter_input_array() och om man behöver filtrera endast ett värde kan man göra det i en array med endast ett element. Så till att börja med skapar vi en klass som hanterar input från $_POST och $_GET och skulle man behöva hantera input från någon annanstans så kan man lägga till den funktionaliteten senare.

Hela syftet med klassen är att dölja komplexiteten av arrayn med dess filter-konstanter, flaggor och alternativ, så dess huvudfunktion blir att bygga den arrayn bakom kulisserna, och sedan passera det till filter_input_array(), och fånga resultatet. Så klassen behöver följ dessa tre steg:

  1. Instantiering (konstruktorn)
    Hämta data från $_POST eller $_GET arrayn.
    Kontrollera om några obligatoriska fält saknas.
  2. Valideringsmetoder
    Skapa ett arrayelement för varje fält med lämpliga filterkonstanter, flaggor och alternativ.
    Generera felmeddelanden.
  3. Validering
    Kontrollera så attvarje obligatoriskt fält har passerat valideringstestet.
    Lämna över array med filter-konstanter, flaggor och alternativ till filter_input_array().
    Lagra det filtrerade resultat, felmeddelanden och namn på uteblivna obligatoriska fält.

Nu när vi har en plan för klassen, är det dags att börja med själva koden.

 

 

Namnge fält & definiera konstruktorn

När vi nu beslutat vilka egenskaper vi behöver definiera så är det inte alltid praktiskt möjligt att se vad som behövs i början, men på ett minimum, behöver vi ett sätt inne i klassen, att hänvisa till följande:

  • Var inmatningen kommer ifrån; $_POST eller $_GET arrayn (vi namnge medlemsvariabeln $_inputType).
  • Den ofiltrerade inmatningen ($_submitted).
  • En lista över obligatoriska fält ($ _required).
  • Den array av filter, alternativ och flaggor som ska skickas till filter_input_array() (med namnet $_filterArgs).
  • Den filtrerade inmatningen ($_filtered).
  • En lista över obligatoriska fält som fattades ($_missing).
  • Felmeddelanden genererade av validator ($_errors).

 

class My_Validator

My_Validator klassen kommer att innehålla följande medlemsvariabler och metoder:

 

 

Medlemsvariabler

Till att börja med skapar vi en fil som heter my_validator.php definierar klasssen i den. Sedan skriver vi in alla medlemsvariabler
Sätt in följande kod my_validator.php:

Detta definierar My_Validator klassen med medlemsvariabler och en tom konstruktor. Vid validering av inmatning, är det viktigt att förhindra eventuell yttre påverkan från att förvränga datan, så alla egenskaper har deklarerats som protected (och alla namn börjar med en understreck som en påminnelse om deras synlighet).

 

 

__construct()

Konstruktorn ska initiera medlemsvariablerna som ska innehålla listan över nödvändiga objekt; $_required och den för vilken typ av inmatning det gäller; $_inputType. Det även också se till att filterfunktioner finns tillgängliga på servern (utan dem, kommer klassen inte att fungerar). Konstruktorn ska också kontrollera att alla obligatoriska fält i $_required har ett värde, måste man passera en array som innehåller namnen på de obligatoriska fälten till konstruktorn som sedan lagras i $_required. Klassen kommer att hantera antingen en $_POST eller $_GET array, därför behöver man även passera det som argument till konstruktorn. Men det är möjligt att man ibland inte vill att några fält måste vara obligatoriska, och därför bör argumentet vara valfritt. För att göra klassen lite mer flexibel, gör vi även inmatningstypen till ett valfritt argument, genom att ge det ett standardvärde ‘post‘ som syftar till INPUT_POST.

Modifiera konstruktorn så här:

De två argument, $required och $inputType, har samma namn som sina motsvarande egenskaper, men utan understreck. Detta är en påminnelse om att deras värden kommer från utanför klassen. $required är satt som standard till en tom array, och $inputType till ”post”. Vilket gör båda argumenten frivilliga, men om andra värden passeras till konstruktorn, kommer dessa användas i stället.

Att ställa in värdet för $_required är okomplicerat, den får värdet från det första argumentet; $required. Dock måste egenskapen $_inputType hanteras annorlunda. Som du kanske minns från förra artikeln, tar filter_input_array() som första argument en av inmatningskonstanterna:

…vilka har en motsvarande superglobal; $_POST, $_GET, $_COOKIE, $_SESSION o.s.v. Vår klass kommer att koncentrera sig på två av dom; INPUT_POST och INPUT_GET. Och här skulle vi kunnat använda just INPUT_POST som argument, men det betyder att man skulle behöva passera in INPUT_GET till konstruktorn om man istället vill validera en $_GET superglobal. Men en av de viktigaste idéerna bakom My_Validator klassen är ju trots allt att dölja de otympliga konstanterna, därför kommer vi att använda en enkel sträng som argument. Detta innebär att klassen behöver kolla upp rätt konstant att tilldela $_inputType. Den uppgiften ger vi till en protected metod som vi kallar för setInputType(), (lite senare i artikeln).

Klassen förlitar sig på filterfunktioner för att göra allt det hårda arbetet, så man måste se till att dessa är tillgängliga. Det är också en bra idé att kontrollera att $required argumentet innehåller en array.

Ändra koden till att kasta undantag (throw exeption) om något av villkoren inte uppfylls:

Den första villkorliga satsen kontrollerar om filter_list() funktionen finns (den som listar alla filterfunktionerna), om inte, vet man att ingen av filtren finns tillgängligt och ett undantag kastas. Den andra villkorssats om $required måste det vara lika med en array(), annars kastas ett undantag. Även om bara ett fält krävs, måste man se till det är en array, annars får man problem senare. Om en array med obligatoriska fält har getts som argument, måste man kontrollera att varje fält har ett värde.

Modifiera koden så här:

Om det första argumentet inte finns, så sätts $_this->_required till en tom array, vilket PHP ser som FALSE; annars anropar konstruktorn en protected metod; checkRequired(), (som vi skapar snart). Och till sist sätts $_filterArgs och $_errors egenskaperna till tomma arrayer. Då var vi klara med konstruktorn för tillfället. Vi kommer att lägga till ett par punkter senare, eftersom det är enklare att förklara dem i sitt sammanhang. Konstruktören gör anrop till två protected metoder; checkRequired() och setInputType() vilka kommer härnäst.

 

Sätt inmatningstyp & kontrollera obligatoriska fält

setInputType() och checkRequired() metoderna kallas båda inifrån konstruktorn, vilket låter oss dölja deras existens från alla användare av klassen. Och när det kommer till setInputType() är detta särskilt viktigt, eftersom man inte vill att någon ska kunna ändra inmatningskällan godtyckligt, när det väl har ställts in. Därför kommer båda metoderna att definieras som protected, och därigenom begränsa tillgången till klassen My_Validator, (men dom kan användas av alla barnklasser om man skulle bestämma sig för att förlänga (extends) klassen senare).

 

setInputType()

Syftet med setInputType() är dubbelt: såväl som inställning av inmatningskälla till ”post” eller ”get”, tilldelar den variablerna från inmatningskällan till $_submitted. Därigenom får klassen tillgång till de variabler man vill validera. Koden är rätt så enkelt, här är hela koden för metoden:

Funktionen innehåller en enkel switch sats, vilket tar det argument det som passerats till setInputType() och skickar den till strtolower(). Det innebär att det andra argumentet i klassens konstruktor är skiftlägeskänsligt . Därför spelar det ingen roll om användaren skriver ”get” eller ”GET”, då det omvandlas till små bokstäver. Beroende på värdet som skickas till setInputType(), är egenskapen $_inputType inställd för rätt inmatnings konstant. Detta kommer att behövas senare, när du passerar variablerna till filter_input_array() för bearbetning. Samtidigt, är innehållet i den relevanta superglobal arrayen delad till $_submitted egenskapen.

Om ett annat värde än post eller få skickas, då metoden ger ett undantag med ett lämpligt meddelande.

 

checkRequired()

Nu när vi har fyllt i $_submitted, kan den jämföras med arrayn av obligatoriska fält.

Så här ser checkRequired() metoden ut:

Metoden börjar med att initiera en lokal variabel $OK som en tom array. En foreach loop går sedan igenom varje del av $_submitted arrayn, med andra ord en; $_POST eller $_GET array, beroende på vilken inmatningstyp som har valts. Vi vill inte att folk att kringgår ett obligatoriskt fält genom att bara trycka på mellanslagstangenten några gånger, så följande rad avlägsnar mellanslag från värdet, om det inte är en array:

Eftersom man inte kan passera en array till trim(), så detta använder villkorliga operatören (? :) för att kontrollera om värdet är en array. Om det är en array, tilldelar den värdet till $value oförändrad; Annars anropas trim() som tar bort alla blanksteg innan $value tilldelas tillbaka till sig själv. Om $value inte är tom, skall namnet på den variabel läggas till $OK array. När loopen är klar,innehåller $OK namnen på alla fält som innehåller ett värde.

Det finns en potentiell brist i denna strategi. Om en array innehåller bara tomma strängar, kommer det ändå att passera testet. Dock är syftet med klassen att bearbeta inmatning från online-formulär. Värden skickas som arrayer från grupper avkryssrutor och flervalslistor. Om formuläret är korrekt inställd, så är det enda sättet man kan få en array med tomma strängar genom $_POST eller $_GET, är om någon använder spoofing på formuläret. Om det händer, finns det andra säkerhetsåtgärder, såsom en CAPTCHA (helt automatiserad Turing test för att skilja datorer och människor åt, se www.captcha.net), vilket kommer sannolikt att vara mer effektivt än att stärka just denna test.

Allt som återstår är att ta reda på om det finns någon skillnad mellan de namnen i $OK och de i $_required. Detta görs genom att leda $_required egenskap och $OK till array_diff() funktion, som returnerar en array som innehåller alla värden från den första array som inte finns i den andra. Så, är något värde i $_required skiljer sig från $OK array, lagras det i $_missing.

Om alla värden i $_required finns dom också i $OK arrayen, medan $_missing innehåller en tom array vilket betyder att alla obligatoriska fält har fyllts i. Det är ganska troligt att de $OK arrayen kan innehålla namnen på valfri fält som har fyllts i, men det spelar ingen roll eftersom array_diff() lämnas utan gards några extra element i den andra array.

Det kan vara svårt att förstå hur detta fungerar, så här är ett praktiskt exempel. $_required och $OK arrayerna är så kallade indexerade arrayer som innehåller bara namnen på variablerna, inte deras värden, de kan se ut ungefär så här:

När array_diff() returnerar en array med saknade värden, bevarar den de ursprungliga nyckel/värde paren. I detta fall är värdena bara namnen på variablerna.

Föregående exempel skulle returnera en array som innehåller följande enskilt element:

Den enda array som innehåller både namnen på de inlämnade fälten och deras värden är $_submitted.

 

 

Testa checkRequired

Nu börjar det bli dags att kontrollera koden som vi skrivit så här långt, genom att testa checkRequired(). Att testa koden med jämna mellanrum gör det mycket lättare att spåra problem.

Här kommer kod till testet:

Denna formulär innehåller tre fält med name attributen; name, email och comments, och knappen ”Skicka kommentarer” med attributet name=”send”. Metod attributet är satt att post, och action har lämnats tom, så formen blir automatiskt riktad till sig själv.
Lägg in följande kod efter formen:

Detta använder filter_has_var() för att kontrollera om $_POST arrayen innehåller en variabel som heter send, vilket gör att koden inuti klammerparenteser endast körs om knappen ”Skicka kommentar” har klickats. Vi inkluderar klassen My_Validator med require_once, och därefter skapas en array med namnet $required som innehåller namnen på dom tre formulärfälten, för att sedan skicka den som ett argument till en ny instans av My_Validator klassen.

 

Till sist ska du öppna my_validator.php igen och lägg till en sista rad i metoden checkRequired():

print_r() visar då innehållet i $_missing. Spara filerna och ladda test_validator.php i en webbläsare och klicka på ”Skicka kommentar” knappen utan att fylla i något av fälten. Om allt är som det ska bör du se namnen på de tre utelämnade områdena precis efter formuläret, som bilden nedanför visar:

Screenshot - Testa My_validator klass

Testa My_validator klass

Den visar vilka obligatoriska fält som blev utelämnade. Förtsätt med testet genom att fylla i ett av fälten, och sätt ett par blanksteg i en annan, och klicka på ”Skicka kommentarer” igen. Array() ska inte längre innehålla namnen på dom fälten som du fyllde i med något, men den med bara blanksteg bör visas.

Fyll nu i varje fält och klicka på”Skicka kommentarer” igen. Resultatet bör bli Array(), vilket tyder på att $_missing innehåller en tom array.

 

Nu är vi klara med testet så du kan ta bort följande rad från checkRequired() eftersom den endast behövdes för teständamål:

Denna övning bekräftar inte bara att checkRequired() fungerar, utan också att konstruktorn fyller i $_required och setInputType() sätter värden för $_submitted från $_POST arrayen.

 

Inga Dubletter Tack!

Innan vi går vidare till definitionen av valideringsmetoderna behöver vi ytterligare en skyddad metod. Att tillämpa flera filter på en variabel kan ha oförutsägbara resultat, så det är en bra idé att testa det. Klassen behöver för att bygga en flerdimensionell array som innehåller namnet på varje inmatningsfält eller variabel, tillsammans med filtret, alternativen och flaggorna man vill applicera på den. Detta kommer att lagras i $_filterArgs. Om fältnamnet redan har registrerats i $_filterArgs array, vet du att ett duplikat filtret tillämpas, så du måste kasta ett undantag.
Istället för att skriva ut ett liknande meddelande i varje valideringsmetod, är det bättre delegera ansvaret till en skyddad metod som vi kallar för checkDuplicateFilter():

Denna metod kommer att kallas av varje valideringsmetod, som kommer att passera det namnet på det fält som ska valideras. Om $ _filterArgs array redan innehåller ett element för fältet, klassen kastar ett undantag, visar fältnamnet i felmeddelandet.

 

Validerings-Metoder

Filterfunktionerna erbjuder ett mycket användbart utbud av alternativ och flaggor. Ett sätt att använda dem skulle vara att skapa separata metoder med namn som anger exakt vad de gör. Det har fördelen av att vara detaljerad, men det skulle resultera i en hel del kodning, för att inte nämna faran för att skapa ett gränssnitt precis lika komplicerad som det vi försöker dölja med klassen. Lösningen som vi kommer att använda oss av är att kontrollera alternativen genom valfria argument till varje validerings-metod. Det första argumentet är inte villkorligt, och innehåller namnet på inmatningsfält eller variabel som man vill validera. Där det är möjligt kommer det andra argument att ha ett standardvärde och därigenom bli villkorligt.

Även om detta kan bli komplicerat, så löser vi det med hjälp av phpdoc kommentarer och en IDE som har förmågan att visa kodtips (NetBeans är min favorit gratis applikation, och en annan är Aptana Studio som också är mycket bra):

Screenshot - Codehint - i NetBeans

Kodtips – i NetBeans

Strukturen för varje valideringsmetoden är väldigt lika. Dom kommer alla att deklareras som public och börjar genom att anropa checkDuplicateFilter() för att kontrollera om ett filter redan har tillämpats. Om checkDuplicateFilter() inte kastar ett undantag (throw exeption), tillägger valideringsmetoden namnet på fältet eller variabeln till den översta nivån av $_filterArgs arrayn, och därigenom ställer in filtret och eventuella flaggor eller alternativen. Koden är relativt enkel och bygger helt enkelt på en array av konstanter, alternativ och flaggorna. Arrayn liknar den i avsnittet ”Flera Variabler åt Gången” i  förra artikeln PHP filter_var och filter_input. Så, vi kommer att gå igenom varje metod relativt fort.

 

Validera Heltal

Filterkonstanten för validering av heltal accepterar två alternativ för att ange minimi- och maximum acceptabla värden; minimum och maximum . Eftersom du inte alltid kommer att vilja ställa dessa värden, ska argumenten för båda alternativen måste vara frivillig. Koden för isint() metoden ser ut så här:

Standardvärdet på $ min och $ max är satt till null. min_range och max_range alternativ är båda valfritt, så att vi kan sätta antingen båda eller ingen. Att fastställa en lägsta godtagbar värde på egen hand, vi utelämnar det tredje argumentet. Men att ställa in ett maximalt värde utan ställa ett minimum, måste du passera null (utan citationstecken) som det andra argument.

 

Validera Flyttal

Filterkonstanten som validerar flyttal accepterar ett alternativ för att ställa in vilket tecken som används som decimalpunkt och en flagga för att tillåta tusentals separator. Båda alternativen ges standardvärden. Koden för isFloat() ser ut så här:

Standardvärdet för $decimalPoint har satts till en punkt, och
$allowThousandSeparator standard true. Detta innebär att båda argumenten kan utelämnas.

 

Valider Numerisk Array

Följande valideringsmetod finns med främst att demonstrera användningen av en av flaggan FILTER_REQUIRE_ARRAY. isNumericArray() funktionen tar tre valfria argument: $allowDecimalFractions, $decimalPoint och $allowThousandSeparator, vilka fungerar på samma sätt som för förra funktionen; isFloat():

Det valfria argument är alla inställda på de vanligaste värdena, och kan därför utelämnas. Men, om du vill att array endast innehåller heltal, ställa in det andra argumentet ($ allowDecimalFractions) till false.

En viktig sak att notera om denna metod är det sätt flaggorna för att möjliggöra decimal fraktioner och tusentalsavgränsare läggs till befintliga flagg element med den kombinerade tilldelnings operatören | =. Det vertikala strecket är en så kallad bitwise operatör och kan kombineras med ett likhetstecken på samma sätt som aritmetiska operatorer, t.ex. += eller *=.

 

Validera Email

Denna metod har av förklarliga skäl inga alternativ eller flaggor, utan kollar bara om det är en email adress:

 

Validera Fullständig URL

Denna metod validerar en fullständig URL, och kontrollerar då bara om det är rätt format, d.v.s. att det börjar med; http:// , https://, eller ftp:// etc. Funktionen tar ett valfritt argument: $queryStringRequired, vilket är satt till false som standard:

 

Validera URL

Denna metod är identisk med isFullURL(), förutom att det inte behöver börjar med; http:// , https://, eller ftp:// etc.:

 

Validera Booleskt Värde

Filterfunktioner returnerar variabelns värde vid framgång, och false om inte valideringstestet lyckas. Detta innebär dock ett problem vid validering av ett booleskt värde eftersom, även om valideringstestet lyckas – kan värdet av variabeln som testats vara false. För att undvika den här typen av falska negativa, måste du lägga till en protected egenskap som vi kallar för $_booleans. Du måste också initiera den som en tom array i konstruktorn. Lägg till den högst upp i klassdefinitionen, och lägg till en sista rad i konstruktorn:

…och isBool() metoden ser ut så här:

Förutom att ställa lämpliga filter argumenten, lägger denna metod namnet på den Boolean fältet till $ _booleans egenskapen. Detta används senare av validateInput() för att förhindra booleska fält från generera felmeddelanden.

 

Validera Reguljära Uttryck

Följande metod matchar ett värde mot en Perl-kompatibel reguljär uttryck (PCRE). Det tar två argument, som båda måste anges: namnet på fältet eller en variabel som testas och en PCRE (reguljärt uttryck). Om matchningen lyckas, ska hela värdet returneras, inte bara den matchande delen.

 

Sanerings-Metoder

 

Sanera Strängar

Den första saneringsmetoden vi ska skapa sanerar strängar. Det tar bort alla taggar, inklusive HTML, PHP och XML, från en input array på ett liknande sätt som PHP:s strip_tags(). Men det finns en stor skillnad mot strip_tags() metoden som är att filterkonstanten; FILTER_SANITIZE_STRING, inte accepterar en lista över godtagbara taggar. Istället erbjuder den en mycket strängare tillvägagångssätt med alternativ för att ta bort eller omkoda tecken som har ett ASCII-värde på mindre än 32 eller större än 127. Det kodar även valfritt et-tecken (&) och bevarar citationstecken.

Med så många alternativ blev det enklare sätta dom alla till FALSE som standard. Så, om removeTags() används med endast namnet på den variabel eller fält som ska saneras, avlägsnas HTML-, PHP- och XML-taggar, enkla och dubbla citationstecken omvandlas, medan et-tecken (&) lämnas orörda.

Här kommer removeTags():

Notera hur flaggorna hanteras. Varje flagga har bakom kulisserna en konstant som representeras av ett heltal. Så, när inga flaggor är inställda behöver $_flags subarray bli satt till 0;

 

Om argumentet för en flagga är satt till true, kommer dess värde att läggas till med hjälp bitvis kombinerade tilldelningsoperatorn |=.

Notera – Det stora antalet alternativ i föregående metod och följande är opraktiskt om man behöver aktivera dem regelbundet. Vi kunde ha skapat olika metoder för varje kombination av alternativen, men det skulle ha lagt till en ny nivå av komplexitet, att tvinga användarna att komma ihåg vad varje metod gör. Vid utformningen av en klass, måste man bestämma hur ofta en funktion är sannolikt kommer att användas. Där finns det tyvärr ingen formel för att få rätt balans, utan man får ta det från fall till fall.

 

 

Sanera Array genom att avlägsna taggar

Följande metod är identisk med den förra, förutom att den bearbetar innehållet i en array.

Koden ser ut så här:

Standardvärdet för $_filterArgs subarray är satt till:

Detta applicerar filterfunktionen till varje element i arrayen, inklusive nästlade arrayer.

 

 

Sanera sträng » omvandla specialtecken

Följande metod omvandlar enkla och dubbla citationstecken, <>, &, och tecken med en ASCII-värde på mindre än 32 till HTML enheter. Dom valfria argumenten kollar om det gäller en array, om man ska koda tecken med ASCII värde större än 127, eller ta bort låga och höga specialtecken. Flaggorna ställs in precis som i removeTags().

Koden för useEntities() ser ut så här:

 

 

Kontrollera Textlängden

Detta är den enda valideringsmetod som inte använder någon av filterfunktionerna eller konstanterna, så det kan användas i kombination med en av våra andra metoder. Den använder PHP strlen() för att fastställa antalet tecken i den angivna strängen, och förbereder lämpliga felmeddelanden som läggs till i $_errors. Liksom alla andra verifieringsmetoder, är det första argumentet namnet på fältet eller variabeln som man vill kontrollera.

Eftersom vi vill kontrollera innehållet i fältet eller variabeln, är det nödvändigt att hämta det från $_submitted, som innehåller en array med alla inlämnade data. Det andra argumentet $min representerar det lägsta antalet acceptabla tecken och är ett obligatoriskt argument. Det tredje argumentet är frivilligt och sätter det högsta antalet tecken. Eftersom $ min behövs, vi sätta den till 0 som standard, om vi bara vill begränsa det maximala antalet tecken tillåtna.

 

 

Specialhantering av Data

Följande metod använder filterkonstanten; FILTER_UNSAFE_RAW för att hantera data som man vill behandla på ett sätt som inte täcks av de andra metoderna. Den har två alternativ: antingen hantera en array eller avkoda et-tecken (&). Skälet till att skapa denna till synes värdelösa metod är att lägga data till en arrayn av filtrerade objekt. Man kan sedan loopa igenom den filtrerade arrayen, övertygad om att den endast innehåller variabler som man redan har specifierat.

Koden ser ut så här:

 

Testa Medlemsvariabeln; $_filterArgs

Valideringsmetoderna vi har skapat är ansvariga för att fylla $_filterArgs, vilket är en array som specificerar alla filter, alternativ och flaggor som man vill använda på alla inmatningsvariabler. Det är viktigt att se till att arrayen byggs på rätt sätt, så följande övning tillämpar vissa valideringstest till ett formulär för att se vad $_filterArgs innehåller.

Denna validering tillämpar kontroller på de tre fälten i formuläret och sedan använder print_r() mellan <pre> taggar för att visa innehållet i $ _filterArgs och $_errors.

$_filterArgs och $_errors är deklarerade som protected egenskaper, så man måste ändra det tillfälligt till public:

Spara båda sidor, ladda formuläret i en webbläsare och klicka på skicka-knappen. Du bör se liknande ut som den nedan:

Testa My_Validator class

Testa My_Validator class

Nu ska vi testa om checkDuplicateFilter() fungerar som den ska genom att använda ett till filter på comments. Skriv in följande rad någonstans i kodblocket:

Du bör nu få ett felmeddelande eftersom checkDuplicateFilter() kastar ett undantag:

Exeption dubbla filter

Exeption dubbla filter

 

Bearbeta tester och returnera resultaten

Nu när vi har byggt en array med filter, alternativ och flaggor, är allt som återstår att skicka det till filter_input_array(). Den tar två argument: vilken typ inmatnings (som vi har i $ _inputType) och arrayn av filter (lagrad i $_filterArgs). Denna funktionen returnerar en array som innehåller det filtrerade och validerade inmatningen, och lagrar det i $_filtered medlemsvariabel. Och, allt detta hårda arbete utförts av ett enda kommando:

Men för att få validerarklass ska producera användbara resultat, behöver vi några fler steg. Först av allt, är hela poängen med att använda en validator till se till att resten av skriptet får endast hanterar data som du vet har filtrerats. Så, efter att ha satt $_POST eller $_GET array som indata, bör man inte längre ha direkt tillgång till datan den innehåller, i stället ska man alltid ta det från $_filtered. Detta innebär att det inte finns någon mening med att ange ett fält som $_required om man inte ska tillämpa någon av valideringsmetoder på den.

Den andra saken som vi behöver göra, är att bygga en lista över objekt som misslyckats valideringen. Egentligen borde det vara alla element som returnerar FALSE från $_filtered arrayn, men riktigt så enkelt är det inte. Du måste utesluta allt som har passerat till isBool() valideringen, eftersom FALSE helt enkelt kan vara booleskt värde i den variabeln.

Vi måste också utesluta poster som har lagts till $_missing för att undvika rapportering av samma fel två gånger.

Vi utesluter även fält som inte markerats som $_required , med antagandet att, om det inte är ett nödvändigt fält, behöver man inte vara orolig för datan i den misslyckas valideringen. Sådana poster kommer att dyka upp i $_filtered som FALSE.

För att summera, behöver metoden validateInput() följande för att utföra dessa tre uppgifter:

1. Kontrollera att alla obligatoriska fält har filtrerats.
2. Applicera filtren på ingångsdata, och lagra resultatet i $_filtered.
3. Skapa en lista över objekt som misslyckats valideringen och lagras dess namn i $_errors.

Den kommenterade koden för validateInput() pkommer här:

Allt som återstår är att tillhandahålla public metoder för att ger tillträde till den skyddade $_missing, $_filtered och $_errors (eftersom alla medlemsvariabler är protected). Var och en returnerar helt enkelt egenskapen som du kan se av följande kod:

Okej, det var all kod för My_Validator klassen. Lämna gärna en kommentar om du undrar över något eller har synpunkter.

 

Jag hoppas att du kan dra nytta av klassen i framtiden, och till nästa gång – Koda Smart 🙂

Lämna en kommentar

E-postadressen publiceras inte. Obligatoriska fält är märkta *