Filters in PHP 5

Veiligheid is een van de belangrijkste aspecten waar je tijdens het programmeren in PHP bij stil moet staan. Elk script of programma heeft input nodig voordat er output gegeven wordt of een actie gestart wordt. Deze input komt uit een ander script of nog vaker direct van de gebruiker. Helaas is deze input altijd onbetrouwbaar en een gouden regel is dan ook dat deze data altijd gecontroleerd moet worden.

Controleren van input is dus een van de belangrijkste punten die in een script nooit vergeten mogen worden. Het controleren en filteren van externe data kan al gauw een vervelend en herhaaldelijk klusje worden. Het komt snel voor dat een bepaalde controle vergeten of niet goed toegepast wordt, hetgeen direct kan leiden tot veiligheidslekken. Voorheen bevatte PHP geen standaard functie voor het controleren van externe data, maar vanaf PHP 5 is daar met de filter extensie verandering in gekomen.

In deze tutorial zal ik een uitleg geven over de werking van deze nieuwe extensie en aan de hand van voorbeelden duidelijk maken hoe je hem kunt gebruiken. De minimale vereiste versie van PHP voor gebruik van de functies in deze tutorial is 5.2.0.

Benodigde voorkennis
- Basis PHP
- Verwerken van formulieren in PHP

Het begrip externe data omvat eigenlijk alle gegevens die ofwel door een gebruiker ingevoerd zijn ofwel door een ander programma/script gegenereerd worden. De volgende dingen vallen dus onder externe data:

[li]$_POST en $_GET variabelen[/li]
[li]$_COOKIE en in bepaalde gevallen $_SESSION gegevens[/li]
[li]Gegevens uit externe bestanden[/li]
[li]Gegevens uit server variabelen zoals bijvoorbeeld $_SERVER['HTTP_HOST'][/li]
[li]Variabelen uit de $_ENV array[/li]
[li]Resultaten die voortkomen uit een database query[/li]

Als je in een script gebruik maakt van een variabele uit dit lijstje, dan is het dus altijd van belang om zo'n variabele te controleren. Het volgende voorbeeld geeft een scriptje waarin van een variabele op de oude manier gecontroleerd wordt of het een integer is.

Voorbeeld 1: Integer controle
<?php
$leeftijd = 19;

if(isset($leeftijd))
{
if(is_numeric($leeftijd))
{
if(is_int($leeftijd))
{
echo 'De opgegeven leeftijd is een integer: '.$leeftijd;
}
}
else
{
echo 'De opgegeven leeftijd is niet numeriek';
}
}
else
{
echo 'Er is geen leeftijd opgegeven';
}
?>
Nu is dit een hele eenvoudige maar in veel gevallen noodzakelijke controle. Als je veel van dit soort relatief eenvoudig controles in je script nodig hebt, zal dat een niet al te fijn werkje zijn om dat elke keer te moeten scripten. Met het gebruik van filters zijn dit soort controles een piece of cake. Ook de lastigere controles die we verderop in deze tutorial zullen zien, zijn door het gebruik van filters een stuk te vereenvoudigen.

Voordat ik de eigenlijke werking van de filters bespreek, zal ik eerst een overzicht geven van de beschikbare filters in PHP. Ook zal ik een overzicht geven van voorgedefinieerde constanten die je gebruikt als je werkt met filters. Beschouw deze pagina dus als benodigde voorkennis en vraag je nog even niet af hoe we die filters nu in een script verwerken. Aan die punten besteed ik verder op in deze tutorial aandacht.

Filters
De filters in PHP zijn onder te verdelen in 2 categorieen.

[li]Logical filters: controleren van data op juistheid van type en formaat.[/li]
[li]Sanitizing filters: toestaan of weigeren van bepaalde tekens in een variabele en desnoods de variabele aanpassen.[/li]

Het eerste type filters kun je gebruiken om de inhoud van variabelen te valideren. Controleer bijvoorbeeld of een variabele een integer, boolean of float is of dat de inhoud een geldig email adres, url of ip adres is. Dit type filters is herkenbaar aan het VALIDATE gedeelte in de naam van de filter. De volgende logical filters zijn beschikbaar:

[li]FILTER_VALIDATE_INT - Controleert of een variabele een integer is[/li]
[li]FILTER_VALIDATE_BOOLEAN - Controleert of een variabele een boolean is[/li]
[li]FILTER_VALIDATE_FLOAT - Controleert of een variabele een float is[/li]
[li]FILTER_VALIDATE_REGEXP - Controleert of een variabele aan een bepaalde reguliere expressie voldoet[/li]
[li]FILTER_VALIDATE_URL - Controleert of een variabele een geldig formaat voor een url heeft[/li]
[li]FILTER_VALIDATE_EMAIL - Controleert of een variabele een geldig formaat voor een email adres heeft[/li]

Het tweede type filter is herkenbaar aan het SANITZE gedeelte in de naam en controleert de inhoud van variabelen op aanwezigheid van bepaalde karakters. Afhankelijk van de filter worden deze karakters toegestaan, verwijderd of bijvoorbeeld geencodeerd. Van dit type kent PHP onder andere de volgende filters:

[li]FILTER_SANITIZE_STRING - Verwijdert tags uit een string[/li]
[li]FILTER_SANITIZE_ENCODED - Levert het zelfde resultaat als de urlencode() functie[/li]
[li]FILTER_SANITIZE_SPECIAL_CHARS - Escaped alle HTML tekens in een string[/li]
[li]FILTER_SANITIZE_EMAIL - Verwijdert alle tekens uit een string die niet in een email adres voor kunnen komen[/li]
[li]FILTER_SANITIZE_NUMBER_INT - Verwijdert alle tekens behalve cijfers, + en -[/li]

Flags
Bij het gebruik van bepaalde filters is het mogelijk om zogenaamde flags mee te geven. Deze flags passen de werking van een filter aan. Zo kun je aan FILTER_VALIDATE_URL bijvoorbeeld de flag FILTER_FLAG_HOST_REQUIRED meegeven. In dat geval zal ook gecontroleerd worden of er wel een host aanwezig is in de gecontroleerd url.

Elke filter kent zijn eigen flags en het toepassen daarvan is optioneel.

Options
Sommige filters kennen naast de flags ook nog zogenaamde options. Deze options geven iets meer informatie aan de filter waar rekening mee gehouden moet worden. Zo moet je bijvoorbeeld bij FILTER_VALIDATE_REGEXP de gebruikte reguliere expressie als option meegeven.

In sommige gevallen zijn deze options vereist, maar meestal zijn ze optioneel.

Voorgedefinieerde constanten
De namen van filters en flags die hierboven aangegeven zijn, zijn allemaal voorbeelden van voorgedefinieerde constanten. Ze verwijzen in werkelijkheid naar een bepaald getal waaraan PHP herkent welke filter er gebruikt moet worden. Hoewel het mogelijk is om ook dit getal als aanduiding van de filter te gebruiken, zou ik om de overzichtelijkheid van je code te bewaren toch aanraden om de voorgedefinieerde constante te gebruiken.

Naast de namen van filters en flags zijn er nog een aantal constanten die vooraf bepaald zijn. De belangrijkste zijn

[li]INPUT_POST[/li]
[li]INPUT_GET[/li]

Zoals de namen al doen vermoeden verwijzen deze constanten naar de gegevens uit respectievelijk de $_POST en $_GET arrays. We zullen zien dat deze constanten bij het werken met filters nog al eens van pas komen.

Een volledig overzicht van alle filters, flags, options en constanten is te vinden in de php.net handleiding. Daarnaast kun je de filter_list() functie gebruiken om te kijken welke filters op jouw eigen server beschikbaar zijn. Gebruik daarvoor bijvoorbeeld het volgende scriptje:

Voorbeeld 2: Controleren welke filters beschikbaar zijn
<?php
echo '<pre>';
print_r(filter_list());
echo '</pre>';
?>

In mijn geval geeft dat het volgende resultaat:

Array
(
    [0] => int
    [1] => boolean
    [2] => float
    [3] => validate_regexp
    [4] => validate_url
    [5] => validate_email
    [6] => validate_ip
    [7] => string
    [8] => stripped
    [9] => encoded
    [10] => special_chars
    [11] => unsafe_raw
    [12] => email
    [13] => url
    [14] => number_int
    [15] => number_float
    [16] => magic_quotes
    [17] => callback
)

Voor het werken met filters biedt PHP een viertal functies:

[li]filter_var()[/li]
[li]filter_var_array()[/li]
[li]filter_input()[/li]
[li]filter_input_array()[/li]

Van deze vier is de werking van filter_var() het makkelijkst te begrijpen. Ik zal daarom aan de hand van enkele voorbeelden met deze functie demonstreren hoe de verschillende soorten filters werken. Verderop in deze tutorial zal ik met de andere functies complexere voorbeelden van het gebruik van filters geven.

De filter_var() functie
Deze functie gebruik je om een filter toe te passen op een enkele variabele. De functie vereist dan ook een variabele en een filter om op de variabele toe te passen.

Voorbeeld 3: Syntax voor het gebruik van filter_var()
<?php
$leeftijd = 19;
$leeftijd = filter_var($leeftijd, FILTER_VALIDATE_INT);

var_dump($leeftijd); // Output: int(19)
?>
In dit voorbeeld heb ik een variabele $leeftijd met daarin een waarde. Natuurlijk moet een leeftijd een integer zijn, dus dat gaan we controleren.

Hiervoor gebruiken we de filter FILTER_VALIDATE_INT in combinatie met de filter_var() functie. Ik maak gebruik van var_dump() zodat we duidelijk zien wat het resultaat van de filter_var() functie is.

Een filter kan standaard namelijk 3 verschillende resultaten geven. Als de filter slaagt wordt de gefilterde variabele in het juiste formaat gegeven. In andere gevallen geeft de filter FALSE terug als de filter mislukt of NULL als de variabele niet bestaat.

Voorbeeld 4: Resultaat bij een mislukte filter
<?php
$leeftijd = '19 jaar';
$leeftijd = filter_var($leeftijd, FILTER_VALIDATE_INT);

var_dump($leeftijd); // Output: bool(false)
?>

Als we dit alles in een scriptje opnemen zou het er als volgt uit kunnen zien:

Voorbeeld 5: Gebruik filter om leeftijd te valideren
<?php
$leeftijd = 19;
$leeftijd = filter_var($leeftijd, FILTER_VALIDATE_INT);

if($leeftijd === FALSE)
{
echo 'De leeftijd is geen integer';
}
else
{
echo 'De leeftijd is een integer: '.$leeftijd;
}
?>

Na toepassen van de filter blijk dat $leeftijd inderdaad een integer is en dat de waarde in de variabele $leeftijd te vinden is.

Voorbeeld 6: Escape alle HTML tekens in een string
<?php
$string = 'Deze string <b>bevat</b> verschillende <i>html</i> tags';
$string = filter_var($string, FILTER_SANITIZE_SPECIAL_CHARS);

echo $string;
?>

Dit scriptje zal als uitkomst hebben:

Deze string <b>bevat</b> verschillende <i>html</i> tags.

We hebben namelijk de FILTER_SANITIZE_SPECIAL_CHARS gebruikt om alle HTML tekens te escapen zodat de code gewoon weergegeven worden.

De filter_var_array() functie
Deze functie kunnen we gebruiken om filters toe te passen op waarden uit een array. De syntax van deze functie vereist een array met variabelen en een array met de toe te passen filters. Om ervoor te zorgen dat PHP begrijpt welke filter op welke variabele toegepast moet worden, is het vereist dat de keys van beide array overeenkomen en een string zijn.

Voorbeeld 7: Meerdere waarden tegelijk filteren
<?php
$gegevens = array(
'leeftijd' => '19 jaar',
'string' => 'Deze string <b>bevat</b> verschillende <i>html</i> tags',
'email' => '[email protected]' );

$filters = array(
'leeftijd' => FILTER_VALIDATE_INT,
'string' => FILTER_SANITIZE_SPECIAL_CHARS,
'email' => FILTER_VALIDATE_EMAIL,
'bestaat_niet' => FILTER_VALIDATE_INT );

$resultaat = filter_var_array($gegevens, $filters);

echo '<pre>';
var_dump($resultaat);
echo '</pre>';
?>
Het resultaat ziet er als volgt uit:

array(4) 
{
  ["leeftijd"]=> bool(false)
  ["string"]=> string(87) "Deze string <b>bevat</b> verschillende <i>html</i> tags"
  ["email"]=>  string(17) "[email protected]"
  ["bestaat_niet"]=> NULL 
}

In dit resultaat zien we dat de leeftijd geen integer was, de HTML tekens geescaped zijn en het email adres goedgekeurd is. Daarnaast zien we dat de filter onder de laatste key NULL als resultaat terug gegeven heeft. Dat komt omdat die key niet voorkwam in de originele array met gegevens.

Op dit moment hebben we twee van de vier functies die je kunt gebruiken in combinatie met filters behandeld. De overgebleven functies, filter_input() en filter_input_array(), kun je gebruiken om input van bijvoorbeeld een gebruiker te filteren.

Deze manier van controleren van informatie is uitermate geschikt voor bijvoorbeeld het verwerken van een formulier. Natuurlijk kunnen we filter_var() gebruiken om een variabele uit de $_POST array controleren, maar PHP heeft daar ook een andere functie voor.

De filter_input() functie
Binnen deze functie maken we gebruik van de voorgedefinieerde constanten INPUT_POST en INPUT_GET om waarden uit respectievelijk de $_POST en $_GET array te benaderen.

Voorbeeld 8: Een waarde uit de $_GET array controleren
<?php
// URL: http://www.mijnsite.nl/index.php?pagina=4
$pagina = filter_input(INPUT_GET, 'pagina', FILTER_VALIDATE_INT);
?>
Met dit scriptje controleren we of de variabele $_GET['pagina'] een integer is. Allereerst zien we het gebruik van de filter_input() functie. De constante INPUT_GET geeft aan dat we informatie uit de $_GET array willen hebben. De tweede parameter geeft de betreffende key uit de $_GET array aan. De derde parameter tenslotte bevat de toe te passen filter.

Nu is deze controle natuurlijk nog niet helemaal voltooid. We hebben nu alleen een variabele $pagina met daarin het resultaat van de filter functie. Dit kan als volgt verder verwerkt worden:

Voorbeeld 8: Een waarde uit de $_GET array controleren (2)
<?php
// URL: http://www.mijnsite.nl/index.php?pagina=4
$pagina = filter_input(INPUT_GET, 'pagina', FILTER_VALIDATE_INT);

if(is_null($pagina))
{
echo 'Er is geen pagina opgegeven';
}
elseif($pagina === FALSE)
{
echo 'De opgegeven pagina is geen integer';
}
else
{
echo 'De opgevraagde pagina is: '.$pagina;
}
// Output: De opgevraagde pagina is 4
?>

De functie filter_input_array()
Naast het controleren van een enkele GET of POST variabele, kunnen we ook de hele $_GET of $_POST array in een keer filteren. Deze functie werkt bijna hetzelfde als de filter_var_array() functie, alleen geef je nu in plaats van een array met variabelen de constante INPUT_POST of INPUT_GET op.

Voorbeeld 9: Filteren van de hele $_POST array
<?php
/* Velden uit een POST formulier:
- leeftijd
- string
- email
*/

$filters = array(
'leeftijd' => FILTER_VALIDATE_INT,
'string' => FILTER_SANITIZE_SPECIAL_CHARS,
'email' => FILTER_VALIDATE_EMAIL,
'bestaat_niet' => FILTER_VALIDATE_INT );

$resultaten = filter_input_array(INPUT_POST, $filters);
?>
De array $resultaten bevat nu alle gefilterde resultaten.

Natuurlijk zijn er vele manieren om zoiets aan te pakken. Het voordeel echter van deze manier van filteren is dat je zeker weet dat een filter altijd maar 3 mogelijke uitkomsten heeft: de gefilterde correcte waarde, FALSE of NULL. De resultaat array zou je nu met een foreach loop dus kunnen uitlezen en kunnen testen op deze condities.

Voorbeeld 10: Verwerken van gefilterde gegevens uit een $_POST array
<?php
/* Velden uit een POST formulier:
- leeftijd
- string
- email
*/

$filters = array(
'leeftijd' => FILTER_VALIDATE_INT,
'string' => FILTER_SANITIZE_SPECIAL_CHARS,
'email' => FILTER_VALIDATE_EMAIL,
'bestaat_niet' => FILTER_VALIDATE_INT );

$resultaten = filter_input_array(INPUT_POST, $filters);

foreach($resultaten as $veld => $resultaat)
{
if(is_null($resultaat))
{
echo 'Je bent vergeten om '.$veld.' in te vullen.';
}
elseif($resultaat === FALSE)
{
echo 'Je hebt geen geldige waarde ingevuld voor: '.$veld;
}
else
{
echo 'Voor '.$veld.' heb je '.$resultaat.' ingevuld.';
}
}
?>

Tot op dit moment hebben we alleen nog de standaard instelling van verschillende filters gebruiken. Maar zoals ik eerder al aangaf hebben we ook de beschikking over verschillende flags en options die de werking van een bepaalde filter iets wijzigen. Flags en options worden als extra parameter(s) aan filter functies meegegeven.

Flags
Een flag die toe te passen is op alle filters is FILTER_NULL_ON_FAILURE. Deze flag zorgt ervoor dat de filters NULL in plaats van FALSE retourneren als een filter mislukt.

Voorbeeld 11: Return NULL als de filter mislukt
<?php
$leeftijd = '19 jaar';
$leeftijd = filter_var($leeftijd, FILTER_VALIDATE_INT, FILTER_NULL_ON_FAILURE);

var_dump($leeftijd); // Output: NULL
?>

Een ander voorbeeld van flags dat ik wil geven is er een met de FILTER_SANITIZE_STRING filter. Deze filter kent verschillende flags. Ik maak nu gebruik van de flag FILTER_FLAG_ENCODE_AMP. Deze flag zorgt ervoor dat een & in de input geencodeerd wordt.

Voorbeeld 12: Encoden van een &
<?php
$input = 'Een string met & erin';
$output = filter_var($input, FILTER_SANITIZE_STRING, FILTER_FLAG_ENCODE_AMP);

echo $output;
?>
In eerste instantie lijkt er niets veranderd is als we $output echoen. Maar als we naar de bron van de pagina kijken, zien we dat de & wel degelijk geencodeerd is:

Een string met & erin

Ook is het mogelijk om meerdere flags tegelijk toe te passen. Deze flags moeten dan gescheiden worden door een |.

Voorbeeld 13: Meerdere flags gebruiken
<?php
// $_POST['naam']: Johnny Weißmüller <b>Jr</b>
$naam = filter_input(INPUT_POST, 'naam' , FILTER_SANITIZE_STRING, FILTER_FLAG_ENCODE_HIGH|FILTER_FLAG_ENCODE_LOW);
echo $naam;
?>
Wederom lijkt er niets veranderd maar de broncode wijst iets anders uit:

Johnny Weisßmüller Jr.

Options
Naast flags zijn er ook nog een aantal filters waarbij een option meegegeven kan worden. Net als een flag worden options als extra parameter aan de filter functie meegegeven. Als er options meegegeven worden, wordt de derde parameter altijd een associatieve array met de options onder de key 'options'.

Voorbeeld 14: Filter integers in een bepaalde range
<?php
$leeftijd = 19;

$options = array('options' => array('min_range' => 20, 'max_range' => 25));
$leeftijd = filter_var($leeftijd, FILTER_VALIDATE_INT, $options);

var_dump($leeftijd); // Output: bool(false)
?>
De filter geeft nu FALSE terug omdat 19 niet in de range van 20 tot 25 valt.

Natuurlijk zijn al deze feiten ook weer te combineren in bijvoorbeeld de verwerking van een formulier. Als je echter flags of options gaat toepassen, zul je de array met filters multidimensionaal moeten maken. Per key krijg je dan weer een array met daarin de filter en eventuele flags of options.

Voorbeeld 15: De verwerking van een gepost formulier
<?php
/* Velden uit een POST formulier:
- leeftijd
- string
- email
*/

$filters = array(
'leeftijd' => array (
'filter' => FILTER_VALIDATE_INT,
'options' => array('min_range' => 20, 'max_range' => 25)
);
'string' => array (
'filter' => FILTER_SANITIZE_SPECIAL_CHARS,
'flags' => FILTER_FLAG_ENCODE_HIGH|FILTER_FLAG_ENCODE_LOW
);
'email' => FILTER_VALIDATE_EMAIL,
'bestaat_niet' => FILTER_VALIDATE_INT
);

$resultaten = filter_input_array(INPUT_POST, $filters);
?>
Dit voorbeeld laat duidelijk zien hoe de array met filters opgebouwd dient te worden als er zowel filters als flags of options toegepast worden.

Met de FILTER_CALLBACK filter is het mogelijk om elke willekeurige php functie te gebruiken om onze gegevens te filteren. De gebruikte functies mogen zelf geschreven functies zijn maar ook reeds bestaande php functies. Op deze manier kunnen we dus helemaal zelf bepalen hoe we onze data willen filteren.

Voorbeeld 16: Spaties vervangen door underscores
<?php
function space2underscore($string)
{
return str_replace(' ', '_', $string);
}

$string = 'Een string met spaties';
$string = filter_var($string, FILTER_CALLBACK, array('options' => 'space2underscore'));

echo $string; // Output: Een_string_met_spaties
?>
In dit scriptje hebben we een functie genaamd space2underscore(). Met behulp van de FILTER_CALLBACK filter passen we deze functie toe op de te filteren variabele.

Hetzelfde is mogelijk met een reeds bestaande php functie.

Voorbeeld 17: Allemaal hoofdletters
<?php
$string = 'een string zonder hoofdletters';
$string = filter_var($string, FILTER_CALLBACK, array('options' => 'strtoupper'));

echo $string; // Output: EEN STRING ZONDER HOOFDLETTERS
?>

Ook kunnen we met deze filter een methode uit een klasse gebruiken om toe te passen op de filteren variabele.

Voorbeeld 18: Methode uit een klasse als filter
<?php
class myClass
{
public function space2underscore($string)
{
return str_replace(' ', '_', $string);
}
}

$string = 'Een string met spaties';
$string = filter_var($string, FILTER_CALLBACK, array('options' => array('myClass', 'space2underscore')));

echo $string; // Output: Een_string_met_spaties
?>

De FILTER_CALLBACK filter is ook toe te passen op arrays. Waar we vroeger gebruik moesten maken van functies als array_walk() om callback functies uit te voeren op waarden in een array, kunnen we daar nu een filter voor gebruiken.

Voorbeeld 19: Filter een array met CALLBACK
<?php
function space2underscore($string)
{
return str_replace(' ', '_', $string);
}

$input = array('deze array', 'bevat strings', 'met spaties');
$output = filter_var($input, FILTER_CALLBACK, array('options' => 'space2underscore'));

echo '<pre>';
print_r($output);
echo '</pre>';
?>
De output van dit scriptje is:

Array
(
    [0] => deze_array
    [1] => bevat_strings
    [2] => met_spaties
)

De CALLBACK filters is de meest veelzijdige uit het rijtje filters dat PHP biedt. Deze filter zorgt ervoor dat je ook zelf filters kunt schrijven.

Een ander voorbeeld waar je deze filter bijvoorbeeld heel goed zou kunnen gebruiken is bij het beveiligen van data die naar een database geschreven moet worden. Het voorbeeld van de verwerking van het POST formulier kan dan iets uitgebreid worden.

Voorbeeld 20: Beveiligen van data voor database query
<?php
/* Velden uit een POST formulier:
- leeftijd
- string
- email
*/

// Array met filters die op de verschillende velden toegepast worden.
$filters = array(
'leeftijd' => FILTER_VALIDATE_INT,
'string' => FILTER_SANITIZE_SPECIAL_CHARS,
'email' => FILTER_VALIDATE_EMAIL,
'bestaat_niet' => FILTER_VALIDATE_INT );

$resultaten = filter_input_array(INPUT_POST, $filters);

// Uitlezen van de filterresultaten.
foreach($resultaten as $veld => $resultaat)
{
if(is_null($resultaat))
{
$error = true;
$errors[] = '<p>Je bent vergeten om '.$veld.' in te vullen.</p>';
}
elseif($resultaat === FALSE)
{
$error = true;
$errors[] = '<p>Je hebt geen geldige waarde ingevuld voor: '.$veld.'</p>';
}
else
{
$error = false;
$data[$veld] = $resultaat;
}
}

if($error === TRUE)
{
// Als er fouten opgetreden zijn bij 1 of meer filters
foreach($errors as $error)
{
echo $error;
}
}
else
{
// Geen fouten? Data beveiligen en wegschrijven.
$data = filter_var($data, FILTER_CALLBACK, 'mysql_real_escape_string');
// $data bevat waarden geschikt voor een database query.
}
?>
De array $data bevat nu allemaal waarden die gereed zijn om ingevoerd te worden in een database zonder dat dit problemen oplevert.

Een laatste voorbeeld dat ik wil geven is het gebruik van een CALLBACK filter om meerdere filters op een waarde toe te passen.

Voorbeeld 21: Meerdere filters toepassen op 1 variabele
<?php
function filterData($var)
{
// Controleer of de variabele wel een string is.
if(!is_string($var))
{
return false;
}
else
{
// Alle HTML tags uit de string strippen
$var = filter_var($var, FILTER_SANITIZE_STRING);

// De & encoderen
$var = filter_var($var, FILTER_UNSAFE_RAW, FILTER_FLAG_ENCODE_AMP);

// Alleen het eerste teken is een hoofdletter
$var = filter_var($var, FILTER_CALLBACK, array('options' => 'strtolower'));
$var = filter_var($var, FILTER_CALLBACK, array('options' => 'ucfirst'));
}

return $var;
}

// Een voorbeeld string
$string = 'deze zin bevat <html> tags & RandoM hOOfdletters';

// Filteren en weergeven van de string
$string = filter_var($string, FILTER_CALLBACK, array('options' => 'filterData'));
echo $string;
?>
Het resultaat van dit script:

Deze zin bevat  tags & random hoofdletters

Tot zover deze tutorial over het gebruik van de filter extensie in PHP. Ik geprobeerd om een inzicht te geven in de vele mogelijkheden die deze extensie met zich meebrengt. Dit onderdeel van PHP biedt een nieuwe manier voor het controleren en valideren van data. Een manier die eenvoudiger en sneller toe te passen is dan vele andere vormen van validatie.

De mogelijkheden van deze functionaliteit zijn zo uitgebreid, dat ik lang niet alles in deze tutorial heb kunnen beschrijven. Ik heb een overzicht gegeven van de meest gangbare vormen van controle en validatie, maar zoals gezegd zijn er nog veel meer mogelijkheden met deze extensie. Het is dan ook aan de geinteresserde lezer van deze tutorial om zelf verder op onderzoek uit te gaan en andere toepassingen te ontdekken.

Voor het schrijven van deze tutorial heb ik van een aantal bronnen gebruik gemaakt. Enkele voorbeelden uit deze tutorial komen uit de tutorial van Zend geschreven door Pierre.

PHP Built in Input filtering - Zend tutorial over filters in php.
Filtering Data with PHP - PHPro tutorial met van elke filter een voorbeeld.
Filter functies op php.net - Een overzicht van alle filters, flags, options en bruikbare functies.

Mocht je vragen of opmerkingen hebben naar aanleiding van deze tutorial of mocht je fouten gevonden hebben, reacties zijn altijd welkom.

Deze tutorial is ook hier te vinden.