Beginnersfouten tegengaan

Het is belangrijk dat je tijdens het programmeren overzichtelijk programmeert. Denk hierbij bijvoorbeeld aan de volgende dingen:

• [li]Variabelen buiten quotes en de juiste quotes gebruiken[/li]
  [li]Aanduiding van het type[/li]
  [li]Commentaar[/li]
  [li]Inspringen[/li]
  [li]Voldoende ruimte[/li]
  [li]Duidelijke query's (hier komen we later op terug)[/li]
  [li]Het gebruik van de juiste editor[/li]

Dit is natuurlijk erg leuk om te weten, maar hoe doe je dat nou, zo netjes en overzichtelijk programmeren? Dat leg ik uit aan de hand van het volgende voorbeeld, waarbij we een [php]array[/php] hebben waar we doorheen lopen en de voornamen en achternamen van enkele mensen op het scherm tonen.

<?php
$namen = array("Stan"=>"Marsh","Kyle"=>"Broflovski","Eric"=>"Cartman","Kenny"=>"McCormick");
foreach($namen as $voornaam=>$achternaam){
echo "Naam: $voornaam $achternaam<br/>";
}
?>

Je ziet dat er in het bovenstaande voorbeeld geen enkele duidelijkheid zit, en dit maakt het alleen maar moeilijker om het later terug te lezen. Laten we eens kijken naar een duidelijke code.

<?php
// Array met de mensen waarbij de key de voornaam is en de value de achternaam
$aNamen = array(
    'Stan' => 'Marsh',
    'Kyle' => 'Broflovski',
    'Eric' => 'Cartman',
    'Kenny' => 'McCormick'
);

// Doorloop de array en toon de mensen en plaats ze ieder op een nieuwe regel
foreach ($aNamen as $sVoornaam => $sAchternaam)
{
    echo 'Naam: ' . $sVoornaam . ' ' . $sAchternaam . '<br />';
}
?>

Variabelen buiten quotes en juiste quotes gebruiken
In het eerste voorbeeld zie je dubbele quotes (") om iets op het scherm te tonen. Voor de overzichtelijkheid en het gemak, gebruiken we enkele quotes ('). Dit doe je omdat je zo voor HTML niet hoeft te escapen, maar vooral omdat het overzichtelijker is.

Aanduiding van het type
Je ziet dat dit er een stuk duidelijker uitziet. De naam array begint nu met een a om het type [php]array[/php] aan te duiden, gevolgd door de naam van de array (namen). Door de eerste letter van het type voor de naam te zetten, schep je duidelijkheid in je variabelen. Je kunt dan tijdens het debuggen in één keer zien wat voor type je variabele is, wat veel tijd kan besparen.

Nog enkele voorbeelden
[table]
[tr]
[td]Array[/td]
[td]$aNamen[/td]
[/tr]
[tr]
[td]String[/td]
[td]$sWoord[/td]
[/tr]
[tr]
[td]Integer[/td]
[td]$iGetal[/td]
[/tr]
[tr]
[td]Boolean[/td]
[td]$bGelukt[/td]
[/tr]
[/table]
Commentaar
Ook zie je commentaar boven stukjes code staan. Dit geeft (in het kort) aan wat dat stukje code doet. Wanneer iemand anders jouw werk overneemt en je hebt geen commentaar bij je code staan, dan kan het lastig worden voor de programmeur om verder te bouwen aan jouw webapplicatie.

Inspringen
Om 'unexpected $end' errors makkelijker op te sporen en om je code overzichtelijker te maken, is het van belang dat je bij een scope ({ en }) inspringt. Dat wil zeggen dat je de body van een scope een stukje naar rechts zet, zodat iedere [php]if[/php], [php]while[/php], etc. netjes uit te lezen is. Als je bijvoorbeeld een 'unexpected $end' error krijgt, kijk je gewoon waar je een } mist, en los je het probleem zo op.

Voldoende ruimte
Zorg dat je voldoende ruimte tussen verschillende stukjes code hebt. Zo is het bijvoorbeeld overzichtelijker om bij een if-statement niet gelijk ()-haken te typen, maar om eerst een spatie te typen. Dit geldt overigens ook voor een echo (ruimte tussen aan elkaar geplakte stukken met punten).

Vergelijk het eerste voorbeeld maar eens goed met het tweede, zo zul je zien dat het tweede voorbeeld veel makkelijker te lezen en te begrijpen is dan het eerste voorbeeld.

Het is natuurlijk niet verplicht deze manier van programmeren aan te houden. Mocht je bijvoorbeeld accolades ({ en }) liever op dezelfde regel zetten als een if-statement, dan is dat geen enkel probleem!

Het gebruik van de juiste editor
Het gebruik van de juiste editor is ook erg belangrijk. Met name de syntax highlighting is erg belangrijk, want op die manier kun je vrijwel nooit fouten krijgen als je bijvoorbeeld bent vergeten een [php]echo[/php] af te sluiten met een quote. Ook het automatisch aanvullen van functienamen is een groot voordeel. Hieronder een greep uit een aantal goede editors, zowel gratis als betaald:
[table]
[tr]
[td]Notepad2[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Notepad++[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Aptana[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]NetBeans[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Vim[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Eclipse[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]phpDesigner[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]TextPad[/td]
[td][color=green]Gratis[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Sublime Text 2[/td]
[td][color=orange]Proefversie[/color][/td]
[td]Download[/td]
[/tr]
[tr]
[td]Zend Studio[/td]
[td][color=blue]Betaald[/color][/td]
[td]Download[/td]
[/tr]
[/table]
Referenties

• [li]php.net - array[/li]
  [li]php.net - if[/li]
  [li]php.net - while[/li]
  [li]php.net - echo[/li]
  [li]Wikipedia.org - Syntaxkleuring[/li]

Zodra je gaat werken met een database, moet je rekening houden met beveiliging. Het belangrijkste is om alle input van de gebruiker te controleren en te filteren!

Wat is SQL-injection?
SQL-injection komt erop neer dat de gebruiker (voor de programmeur dus ongewild) eigen code kan injecteren in de query, iets wat je absoluut niet wilt. Wat SQL-injection precies is ga ik niet uitleggen omdat ik alleen de protectie ervan uitleg, maar voor precieze uitleg verwijs ik je graag door naar deze tutorial.

Een fout voorbeeld
In het onderstaande voorbeeld laten we een gebruiker een bericht aanmaken voor een shoutbox, maar we escapen de input van de gebruiker nog niet. (op de foutenafhandeling komen we later nog terug)

<?php
// Kijken of er gepost is
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
    // Controleren of het bericht is ingevuld
    if (empty($_POST['bericht']))
    {
        echo 'Je hebt geen bericht ingevuld!';
    }
    else
    {
        // Query maken en invoegen
        $sQuery = "
        INSERT INTO berichten
        (
            bericht,
            datum
        )
        VALUES
        (
            '" . $_POST['bericht'] . "',
            NOW()
        )
        ";
        $qSql = mysql_query($sQuery);
        if ($qSql === false)
        {
            echo 'Er gaat iets fout tijdens het invoegen!';
        }
        else
        {
            echo 'Je bericht is toegevoegd!';
        }
    }
}
// Form op het scherm tonen
?>
<form method="post" action=""><p>
Bericht: <input type="text" name="bericht" /><br />
<input type="submit" value="Versturen" />
</p></form>

Op het eerste zicht ziet dit er misschien goed uit, maar het mag duidelijk zijn dat het script lek is. Vult de gebruiker bijvoorbeeld 's Hertogenbosch in, dan gaat het fout. De quote wordt dan namelijk al afgesloten in de query en komt er tekst buiten de quote te staan. Dit komt er dan namelijk te staan:

INSERT INTO berichten
(
    bericht,
    datum
)
VALUES
(
    ''s Hertogenbosch',
    NOW()
)

Het is duidelijk te zien dat er iets fout gaat, want er wordt na bosch een quote afgesloten die nooit gestart is, wat dus een fout oplevert.

Voor dit soort problemen (en uiteraard voor de beveiliging) escapen we de input van de gebruiker.

Hoe doen we dat?
De input filteren, dat doen we met [php]mysql_real_escape_string[/php] (of een variant in MySQLi of PDO). Deze functie zet een backslash (\) voor iedere quote, zodat een quote ge-escaped wordt en deze de query niet kan verpesten.

Dat ziet er in de praktijk zo uit:

<?php
// Kijken of er gepost is
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
    // Controleren of het bericht is ingevuld
    if (empty($_POST['bericht']))
    {
        echo 'Je hebt geen bericht ingevuld!';
    }
    else
    {
        // Query maken en invoegen
        $sQuery = "
        INSERT INTO berichten
        (
            bericht,
            datum
        )
        VALUES
        (
            '" . mysql_real_escape_string($_POST['bericht']) . "',
	    NOW()
        )
        ";
        $qSql = mysql_query($sQuery);
        if ($qSql === false)
        {
            echo 'Er gaat iets fout tijdens het invoegen!';
        }
        else
        {
            echo 'Je bericht is toegevoegd!';
        }
    }
}
// Form op het scherm tonen
?>

Onze query ziet er dan zo uit, en kan dan niet fout lopen op dat stuk:

INSERT INTO berichten
(
    bericht,
    datum
)
VALUES
(
    '\'s Hertogenbosch',
    NOW()
)

Let er wel op dat input van een gebruiker [color=red]NOOIT[/color] te vertrouwen is, zelfs niet als het een administratiepaneel is dat je alleen voor persoonlijk gebruik ontwikkelt. Beveilig alle input die je voor je database gebruikt!

Referenties

• [li]php.net - mysql_real_escape_string[/li]
  [li]SQL Injection Guide[/li]

PHP is dynamisch en er wordt vaak met een database gewerkt. Maar net zoals in de vorige pagina, waarbij we pagina naar de database stuurden, is het beveiligen van het ophalen van data uit de database net zo belangrijk. (gedetailleerde uitleg: klik hier)

Wat is XSS-injection?
XSS staat voor Cross-site scripting. XSS-injection betekent dat gebruikers hun eigen code in de HTML kunnen injecteren. Dat kan ertoe leiden dat er bijvoorbeeld cookies van administrators, die belangrijke informatie bevatten, uitgelezen kunnen worden. Dat is natuurlijk iets wat je wilt voorkomen.

Hoe werkt XSS-injection?
Wanneer er op een pagina dynamische content (bijvoorbeeld dat van een gebruiker) getoond wordt, is het belangrijk dat dit geen HTML-code kan zijn. Als dit wel het geval is, dan kan de gebruiker HTML-code invoegen, en dat is niet de bedoeling.

We gebruiken als voorbeeld een klein formulier waarbij de gebruiker zijn naam en leeftijd moet opgeven. Als hij één van de twee velden niet invult, dan moet hij het formulier opnieuw invullen en wordt het veld dat wél was ingevuld, opnieuw gevuld met hetgeen dat hij daarvoor ingevuld had.

<?php
// Kijken of er gepost is
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
    // Controleren of beide velden ingevuld zijn
    if (empty($_POST['bericht']) || empty($_POST['leeftijd']))
    {
        echo 'Je hebt niet beide velden ingevuld!';
    }
    else
    {
        // Hier de verdere verwerking van het formulier
    }
}
// Form op het scherm tonen
?>
<form method="post" action=""><p>
Naam: <input type="text" name="naam" value="<?php echo (isset($_POST['naam']) ? $_POST['naam'] : ''); ?>" /><br />
Leeftijd: <input type="text" name="leeftijd" value="<?php echo (isset($_POST['leeftijd']) ? $_POST['leeftijd'] : ''); ?>" /><br />
<input type="submit" value="Versturen" />
</p></form>

Ook hier lijkt er op het eerste gezicht niet veel fout te zijn aan de code. Alleen op regel achttien en negentien zit toch wel degelijk een fout. Je ziet het misschien niet goed, maar de post-waarde van 'naam' en 'leeftijd' wordt op het scherm getoond. En dit wordt niet speciaal aangepast, maar het wordt gewoon precies zoals ingetypt in de broncode gezet.

Stel dat iemand bijvoorbeeld invult Kees"/> - wat gebeurt er dan? Dan plaatst PHP dat stuk [color=red]PRECIES[/color] tussen de value tags en krijg je gewoon dit in je broncode:
<input type="text" name="naam" value="Kees" />" />

Hoe kan dit?
Omdat je PHP de instructie geeft de input van de gebruiker daar op het scherm te tonen, zal PHP dit ook zo doen. Je ziet dus dat het tekstvak afgesloten wordt op basis van de input van de gebruiker. Daarom is het belangrijk om gebruiker input altijd te filteren voordat je het op het scherm toont!

Hoe doe je dit?
Dat is erg simpel, je gebruikt gewoon de [php]htmlspecialchars[/php] functie van PHP. Deze zet "vreemde" tekens om naar tekens die ongevaarlijk zijn voor de broncode.

Voorbeeld in de praktijk

<form method="post" action=""><p>
Naam: <input type="text" name="naam" value="<?php echo (isset($_POST['naam']) ? htmlspecialchars($_POST['naam']) : ''); ?>" /><br />
Leeftijd: <input type="text" name="leeftijd" value="<?php echo (isset($_POST['leeftijd']) ? htmlspecialchars($_POST['leeftijd']) : ''); ?>" /><br />
<input type="submit" value="Versturen" />
</p></form>

Wat gebeurt er nu?
De "vreemde" tekens (zoals quotes en kleiner-dan en groter-dan tekens) worden dan omgezet naar HTML codes die de browser niet parsed. Dat klinkt misschien ingewikkeld, maar eigenlijk is dat helemaal niet zo. Wanneer je nu Kees" /> invult, dan krijg je deze output, die ongevaarlijk is:
<input type="text" name="naam" value="Kees\&quot; /&gt;" />

Zoals je ziet wordt hier het 'value' attribuut niet afgesloten door de input van de gebruiker.

Ook hier weer geen ernstige fout die je kunt misbruiken, maar dit is zowat het simpelste misbruik van XSS-injectie.

Referenties

• [li]php.net - htmlspecialchars[/li]
  [li]PHPhulp.nl - beveiliging | xss, versie 2[/li]

In MySQL (en andere databaseservers zoals Oracle) is het mogelijk om backticks (`) in een query te plaatsen. Deze backticks plaats je dan om de naam van een kolom heen of om de naam van een tabel. Het gebruik ervan wordt echter sterk afgeraden!

Waarom gebruik je backticks?
Het gebruik van backticks kan in principe altijd, ook wanneer het niet nodig is. Het wordt echter sterk afgeraden omdat het meer gezien wordt als een smerige oplossing voor een verkeerd databasemodel. De reden daarvan is dat er in MySQL een aantal gereserveerde woorden zitten. Die woorden gebruikt MySQL om goed te functioneren. Hieronder een greep uit de gereserveerde woorden: (volledige lijst: klik hier)

• [li]DATE[/li]
  [li]LIMIT[/li]
  [li]ORDER[/li]
  [li]VALUES[/li]

Wanneer je één of meerdere van deze woorden gebruikt als kolom- en/of tabelnaam, dan zul je deze tussen backticks moeten plaatsen. Een voorbeeld van query met een gereserveerd woord ziet er zo uit: (we gebruiken een database met dropsoorten)

SELECT
    naam
FROM
    `drop`

Op zich is het logisch dat het woord drop tussen backticks moet, 'drop' wordt namelijk gebruikt om een tabel of database weg te gooien (te droppen).

Verkeerd databasemodel
Wanneer je met backticks moet gaan werken, dan moet je jezelf afvragen of je je databasemodel wel goed gebouwd hebt. Er zijn genoeg oplossingen om het gebruik van backticks te vermijden. Een voorbeeld daarvan is een prefix: tbl_*

Column
Op PHPhulp is er een column geschreven over persoonlijke ervaringen met betrekking tot het gebruik van backticks. Deze kun je hier vinden.

Referenties

• [li]MySQL.com - Reserved words[/li]
  [li]PHPhulp.nl - Column: backticks in SQL-querys[/li]

Wanneer je met PHP werkt kan er natuurlijk altijd iets mis gaan. Dat is niet erg wanneer je aan het debuggen bent, maar een fout tonen aan de gebruiker is zachtgezegd niet netjes. Een gebruiker kan hier vaak niks mee, en vooral voor hackers is het nuttige informatie om systemen te kraken.

Waar pas je foutenafhandeling toe?
Je past foutenafhandeling in principe toe op dingen die fout zouden kunnen gaan. Denk hierbij aan de volgende voorbeelden:

• [li]MySQL statements[/li]
  [li]Uploaden van bestanden[/li]
  [li]Ophalen van externe content (denk aan een API)[/li]

Dit soort fouten kun je in de meeste gevallen opvangen met een if-statement. Complexere applicaties kun je vaak beveiligen door middel van een try ... catch constructie (lees: php.net), maar daar gaan we ons hier niet mee bezig houden. Wij houden het op het eerste voorbeeld: MySQL statements.

Fouten onderdrukken
Sommige 'programmeurs' lossen hun problemen vaak op met smerige fixes die de fout niet oplossen. Op zo'n moment onderdrukken ze de fout dus, waardoor de fout niet echt verholpen is en PHP of MySQL er fouten voor genereert, maar ze worden gewoon onderdrukt om extra beveiliging te vermijden. De fout is er op dat moment dus nog wel, alleen wordt hij onderdrukt - en dat is uit den boze!

Hoe onderdruk je een fout?
Een fout onderdruk je simpelweg door hem óf niet op te vangen (dus zonder if-statement of try ... catch constructie), of door er een speciaal teken voor te zetten: een apenstaart (@). Hiervan een voorbeeld met een e-mail die verstuurd moet worden:

<?php
// Verstuur een mail naar een klant
@mail($sOntvanger, $sOnderwerp, $sBericht, $sHeaders);
echo 'De e-mail is verstuurd!';
?>

Je ziet dat er een @ voor de functie [php]mail[/php] staat. Dit betekent letterlijk:
Probeer het maar, maar als het fout gaat, geef dan geen fout.

Een ander voorbeeld is het gebruik van rare buffer fixes. Veel beginners krijgen wel eens de 'header already sent'-fout te zien, en hen wordt dan verzocht bovenin hun code [php]ob_start[/php] te zetten zodat de fout onderdrukt wordt - hij is dan dus niet opgelost!

Meer over 'headers already sent'-fouten: klik hier

Waarom foutenafhandeling?
Nette foutenafhandeling is noodzakelijk omdat je geen vreemde (of voor hackers informatieve) teksten op het scherm wilt tonen. Het is daarom de bedoeling dat je je fouten netjes opvangt en een nette melding op het scherm van de gebruiker toont.

Voorbeeld in een MySQL statement
In MySQL maken mensen vaak gebruik van de functie [php]mysql_query[/php] (deze functie hebben we in een paar pagina's hiervoor besproken). Deze functie wordt gebruikt om een query naar de MySQL server te sturen. Wat beginners vaak doen, is het opvangen van fouten op een groffe manier afhandelen, (met [php]die[/php] en [php]mysql_error[/php]) door het parsen van de pagina direct af te breken en een smerige fout naar de gebruiker te gooien. Op deze manier stopt PHP direct met het parsen van de pagina. Een voorbeeld daarvan is dat je layout onder de foutmelding niet meer afgemaakt wordt, wat niet de bedoeling is. Dit is hiervan een voorbeeld:

<?php
mysql_query("SELECT nsaam FROM klanten") or die (mysql_error());
?>

Let op de typfout 'nsaam', wat tijdens het openen van de pagina de volgende melding zou moeten geven:
#1054 - Unknown column 'nsaam' in 'field list'

Dit is iets wat een gebruiker niet hoort te zien. We gaan daarom met een if-statement de melding opvangen en een nette melding op het scherm tonen.

<?php
// Query netjes in een variabele zetten zodat je hem eventueel later kunt loggen, mocht het fout gaan
$sQuery = "
            SELECT
                nsaam
            FROM
                klanten
";
$qSql = mysql_query($sQuery);
// Controleren of de query succesvol uitgevoerd is
if ($qSql === false)
{
    echo 'De klanten kunnen niet opgehaald worden, probeer het later opnieuw!';
    // Eventueel loggen van de error
}
else
{
    echo 'Het ophalen van de klanten is gelukt!';
}
?>

Nu krijgt de gebruiker de volgende melding op het scherm:
De klanten kunnen niet opgehaald worden, probeer het later opnieuw!

Dat is een stuk netter, en bovendien krijg je in je true-scope (regel 13 en 14) de mogelijkheid om de fouten eventueel te loggen zodat je ze makkelijk op kunt lossen.

Gebruik van or die en mysql_error
Het gebruik van or die is dus uit den boze! Let er ook op dat de gebruiker geen mysql_error te zien krijgt. Deze twee dingen mogen duidelijk zijn! (mysql_error kun je overigens wél gebruiken om eventueel een foutmelding te loggen)

Referenties

• [li]php.net - Exception[/li]
  [li]php.net - MySQL[/li]
  [li]php.net - ob_start[/li]
  [li]php.net - mysql_query[/li]
  [li]php.net - die[/li]
  [li]php.net - mysql_error[/li]
  [li]PHPhulp.nl - Headers already sent[/li]

Het is belangrijk dat je geheugenefficiënt programmeert. Dat wil zeggen dat je op je geheugen en op de performance let en niet klakkeloos code gaat tikken zonder dat je bij geheugen en performance nadenkt. Een goed voorbeeld hiervan is het gebruik van variabelen. Vaak zie je mensen die onnodig variabelen aanmaken om een bepaalde handeling uit te voeren. In mijn voorbeeld gaan we een gebruiker invoegen met de volgende gegevens:

• [li]naam[/li]
  [li]adres[/li]
  [li]woonplaats[/li]
  [li]postcode[/li]
  [li]telnummer[/li]

Hiervoor gebruiken we het volgende stukje code:

<?php
// Kijken of er gepost is
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
    $sNaam = $_POST['naam'];
    $sAdres = $_POST['adres'];
    $sWoonplaats = $_POST['woonplaats'];
    $sPostcode = $_POST['postcode'];
    $sTelnummer = $_POST['telnummer'];
		
    $sEscapeNaam = mysql_real_escape_string($sNaam);
    $sEscapeAdres = mysql_real_escape_string($sAdres);
    $sEscapeWoonplaats = mysql_real_escape_string($sWoonplaats);
    $sEscapePostcode = mysql_real_escape_string($sPostcode);
    $sEscapeTelnummer = mysql_real_escape_string($sTelnummer);		
		
    // Query aanmaken
    $sQuery = "
    INSERT INTO gebruikers
    (
        naam,
        adres,
        woonplaats,
        postcode,
        telnummer
    )
    VALUES
    (
        '" . $sEscapeNaam . "',
        '" . $sEscapeAdres . "',
        '" . $sEscapeWoonplaats . "',
        '" . $sEscapePostcode . "',
        '" . $sEscapeTelnummer . "'
    )
    ";
    // Verdere verwerking van het formulier en invoegen van het record
}
?>
<form method="post" action=""><p>
Naam: <input type="text" name="naam" /><br /><br />
Adres: <input type="text" name="adres" /><br /><br />
Woonplaats: <input type="text" name="woonplaats" /><br /><br />
Postcode: <input type="text" name="postcode" /><br /><br />
Telefoonnummer: <input type="text" name="telnummer" /><br /><br />
</p></form>

Je zult misschien lachen om dit extreme voorbeeld, maar dit wordt in de praktijk dus echt zo gedaan. Voor iedere aanpassing in een string, een nieuwe variabele. Dat is onnodig, onoverzichtelijk én het verspilt geheugen dat je niet voor niks hoeft te verspillen!

Hoe moet het dan wel?
In ons voorbeeld gebruiken we een post-waarde die we direct ophalen zonder er een variabele voor aan te maken. Die kunnen we gemakkelijk tijdens het invoegen van het record escapen, je hoeft dus geen extra variabelen aan te maken voor iedere stap die je zet in een variabele!

<?php
// Kijken of er gepost is
if ($_SERVER['REQUEST_METHOD'] == 'POST')
{
    // Query aanmaken
    $sQuery = "
    INSERT INTO gebruikers
    (
        naam,
        adres,
        woonplaats,
        postcode,
        telnummer
    )
    VALUES
    (
        '" . mysql_real_escape_string($_POST['naam']) . "',
        '" . mysql_real_escape_string($_POST['adres']) . "',
        '" . mysql_real_escape_string($_POST['woonplaats']) . "',
        '" . mysql_real_escape_string($_POST['postcode']) . "',
        '" . mysql_real_escape_string($_POST['telnummer']) . "'
    )
    ";
    // Verdere verwerking van het formulier en invoegen van het record
}
?>
<form method="post" action=""><p>
Naam: <input type="text" name="naam" /><br /><br />
Adres: <input type="text" name="adres" /><br /><br />
Woonplaats: <input type="text" name="woonplaats" /><br /><br />
Postcode: <input type="text" name="postcode" /><br /><br />
Telefoonnummer: <input type="text" name="telnummer" /><br /><br />
</p></form>

Dit stukje code doet precies hetzelfde, alleen is het op een geheugenefficiëntere manier dan het stukje daarvoor gebouwd.

Ook is het in je SQL-statements belangrijk om geheugeneffieciënt te werk te gaan. Veel mensen selecteren bijvoorbeeld van een record alle data, terwijl er maar 10% van nodig is. Hier een voorbeeld, waar we gebruik maken van de tabel gebruikers met de volgende kolommen:

+------------+
| id         |
| naam       |
| adres      |
| woonplaats |
| email      |
| wachtwoord |
| status     |
+------------+

Wat doen mensen vaak als ze alleen de woonplaats willen hebben? Dan halen ze alle kolommen uit het record op:

SELECT
    *
FROM
    gebruikers

Je ziet dat er geselecteerd wordt met een asterisk (*). Dit wil zeggen:
Alle kolommen uit het record

Dit is onnodig, want zes van die kolommen gebruik je niet. Het is dus niet nodig om ze op te halen. Geef daarom bij je query op welke kolommen je wilt selecteren, zo worden je querys sneller en verspil je niet onnodig geheugen:

SELECT
    woonplaats
FROM
    gebruikers

Verder valt er over dit stuk niet veel te vertellen. Het is gewoon belangrijk dat je geen onnodige ruimte verspilt, dat is nergens voor nodig en het komt de snelheid (die merk je overigens vrijwel niet) niet ten goede.

Ik hoop dat jullie wat aan mijn tutorial gehad hebben! Hier staan de links uit de tutorial op een rijtje voor het geval je ze nog nodig hebt!

• [li]SQL Injection Guide[/li]
  [li]beveiliging | xss, versie 2[/li]
  [li]Lijst van gereserveerde woorden MySQL[/li]
  [li]COLUMN: Backticks in SQL-Queries[/li]
  [li]Tweakers.net: Sql-injectie en xss: de beste verdediging[/li]

Handige links en gedetailleerde uitleg op Wikipedia:

• [li]SQL-injectie[/li]
  [li]Cross-site scripting[/li]

Handige tutorials en scripts op PHPhulp

• [li]$end error (script)[/li]
  [li]Header already sent (tutorial - [color=green]aanrader![/color])[/li]

Handige frameworks

• [li]jQuery - JavaScript framework[/li]
  [li]Zend Framework - PHP framework[/li]

Mocht je nog vragen hebben, dan kun je me een bericht sturen of op het forum plaatsen. Gelieve inhoudelijke op- en/of aanmerkingen hieronder te plaatsen.

Happy coding! :-)