URL Vriendelijkheid (SEO)

Een URL ziet er over het algemeen ontzettend lelijk uit. Zeker als je werkt met parameters. Een vraagteken en een boel &’tjes maken het er niet mooier op. Dat kan beter. Via o.a. .htaccess en (om het optimaal te benutten) PHP kun je een prachtige URL samenstellen.

Wat hebben we hiervoor nodig?
We maken gebruik van het bekende mod_rewrite (.htaccess). Waarmee je URLs ergens heen kan sturen waar jij zelf wilt. Daarnaast vangen we wat af d.m.v. PHP. Geen ingewikkelde functies worden er overigens gebruikt, je zult zien dat het een stuk makkelijker in elkaar zit dan vooraf lijkt.

De URL kan er uit gaan zien precies zoals jij wilt. De boel gaat gescheiden worden door mooie slashes, en daarbij kun jij zelf blijven opgeven hoe de parameters gaan heten. Geen vaste structuur waar je je per se aan moet houden.

Een voorbeeldje:
De URL ziet er voordat we hem netjes gaan maken bijvoorbeeld zo uit:
http://www.jouwdomein.nl/index.php?page=home&lang=nl&id=5

Het liefst zouden we deze URL er zo uit laten zien:
http://www.jouwdomein.nl/home/nl/5

Via dit script is dat haalbaar, dat leg ik uit, maar het is niet geheel handig. Wat is die nl? Wat is die 5? Daarom kunnen we de URL er ook zo uit laten zien:
http://www.jouwdomein.nl/home/lang=nl/id=5

Een stuk handiger, toch? Bovendien houden de slashes het enigszins netjes. Je kunt hier overigens ook ervoor kiezen om een : in plaats van een = te gaan gebruiken, dat is aan jou.

We gaan beginnen met het eerste gedeelte: .htaccess. Dit ziet er moeilijk uit, maar is het zeker niet. Maak een nieuw bestand aan in je editor, gooi het helemaal leeg dat je echt een leeg bestandje hebt. Nu zet je bovenaan – om mod_rewrite te activeren:

RewriteEngine On

Om de basis te stellen op de root, voegen we daar nog een regel aan toe:

RewriteEngine On
RewriteBase /

Dat is alvast geopend. We willen natuurlijk dat bestaande bestanden gewoon te bereiken zijn. Dat doen we door een paar regels aan de .htaccess toe te voegen, zo ziet het er nu uit:

RewriteEngine On
RewriteBase /

# Bestaande bestanden of mappen uitsluiten
RewriteCond %{REQUEST_FILENAME} -f [NC,OR]
RewriteCond %{REQUEST_FILENAME} -d [NC]
RewriteRule ^(.*?)$ $1 [L]

Je ziet nu: bestaande bestanden worden naar zichzelf doorgestuurd. Dat zorgt er alvast voor dat we daar niet mee in de knoop komen.

Het volgende is ook niet zo moeilijk. Nu willen we natuurlijk het deel achter je domeinnaam naar de normale parameters ?parameter=value&parameter2=value e.d. rewriten. Maar nu komt het: we willen het zo variabel en los mogelijk houden, en dat gaat niet als we iedere parameter weer apart gaan rewriten. Daarom doen we het zo; we rewriten alles achter het domein naar één parameter. Zo komt alles achter http://www.jouwdomein.nl/ dus in die parameter te zitten. Waarom? Dat zul je straks zien. Onze .htaccess gaat er nu zo uit zien:

RewriteEngine On
RewriteBase /

# Bestaande bestanden of mappen uitsluiten
RewriteCond %{REQUEST_FILENAME} -f [NC,OR]
RewriteCond %{REQUEST_FILENAME} -d [NC]

RewriteRule ^(.*?)$ $1 [L]
# Alles naar één parameter
RewriteRule ^(.*?)$ index.php?p=$1 [L,QSA]

We zijn nu klaar, sla dit bestandje op als .htaccess (meer niet! – vergeet niet om ‘all formats’ o.i.d. te selecteren, anders zou er .htaccess.php of zo kunnen komen te staan en dan werkt het niet!).

Edit:
Let er nu wel op, dat CSS-bestand en plaatjes (die door HTML geïnclude worden, dus niet door PHP!) het pad van de URL volgen. Ze zullen dus niet goed terecht komen als je plaatjes doodgewoon images/plaatje.png zijn. Hij plakt dat dan achter de URL en dat gaat niet werken. Daarom kun je het zo oplossen: /images/plaatje.png. Met de eerste / geef je aan dat er vanuit de root gewerkt moet worden. Wat je ook kunt doen is: http://www.jedomein.nl/images/plaatje.png - oftewel het absolute pad opgeven. Ik prefereer de eerste manier, maar dat is aan jou ;).

In PHP kunnen we die ene parameter nu opvangen via $_GET[‘p’]. Wat krijgen we dan te zien? Als we teruggaan naar de voorbeeld URL (de handige versie), zien we dit: home/lang=nl/id=5.
Met een beetje PHP kennis, kunnen we nu heel handig de [php]explode[/php]() functie gebruiken op deze string, de / scheidt namelijk alle parameters die we hebben. Dan hebben we de parameters dus al los. We doen het volgende:

<?php
if(!empty($_GET) && isset($_GET['p'])) {
$aParameters = explode("/", $_GET['p']);
}
?>

$aParameters ziet er nu zo uit: array(“home”, “lang=nl”, “id=5”). Ik hoop dat je hem al aan ziet komen. In de parameters zit nog steeds dat =’je, waardoor niet alle parameters direct al waardes zijn van een parameter. We doorlopen ieder element van de array $aParameters, kijken of daar een = in zit en laten daar ook even explode() op los, i.c.m. met list() hebben we dat varkentje zo gewassen.

<?php
if(!empty($_GET) && isset($_GET['p'])) {
$aParameters = explode("/", $_GET['p']);
foreach($aParameters as $sParameter) {
if(preg_match("_=_", $sParameter)) {
list($key, $value) = explode("=", $sParameter);
}
}
}
?>

We hebben nu in $key en $value de naam en de waarde van de parameter zitten. Die stoppen we opnieuw in $_GET, zodat het lijkt alsof ze uit de URL komen – en je, bij verandering van je URLs in deze nette, geen wijzigingen qua variabelen hoeft door te voeren.

<?php
if(!empty($_GET) && isset($_GET['p'])) {
$aParameters = explode("/", $_GET['p']);
foreach($aParameters as $sParameter) {
if(preg_match("_=_", $sParameter)) {
list($key, $value) = explode("=", $sParameter);
$_GET[$key] = $value;
}
}
}
?>

$_GET wordt ondertussen weer gevuld met de nodige parameters uit de URL. Maar wat gebeurt er nu met de parameters waar geen = in zitten, en die dus al direct een waarde zijn? Dat doen we ook heel simpel. Alleen vergt dit wel weer wat wijzigingen mocht je je huidige website om willen bouwen naar deze nette URLs.

We doen het volgende: de eerste naamloze waarde die we hebben (dus zonder een = in de parameter) kennen we toe aan $_GET[‘p’]. Die hebben we verder toch niet meer nodig, en meestal bevat de eerste naamloze waarde toch wel de naam van de pagina. We maken daarbij gebruik van een teller. Zo:

<?php
if(!empty($_GET) && isset($_GET['p'])) {
$aParameters = explode("/", $_GET['p']);
$iTeller = 0;
foreach($aParameters as $sParameter) {
if(preg_match("_=_", $sParameter)) {
list($key, $value) = explode("=", $sParameter);
$_GET[$key] = $value;
} else {
if($iTeller > 0) {
$_GET['param'.$iTeller] = $sParameter;
} else {
$_GET['p'] = $sParameter;
}
$iTeller++;
}
}
}
?>

We noemen iedere parameter zonder = na de eerste: param$iTeller, beginnend met $iTeller vanaf 1. De eerste parameter na $_GET[‘p’] wordt dus $_GET[‘param1’]. Als we dat met een voorbeeldje doen, komt $_GET er zo uit te zien, nadat hij behandelt is door dit script:

Voorbeeld URL: http://www.jouwdomein.nl/nieuws/phphulp/id=5
Uitkomst: $_GET = array( ‘p’ => ‘nieuws’, ‘param1’ => ‘phphulp’, ‘id’ => ‘5’);

Je kunt zo oneindig veel parameters hebben, en toch worden ze allemaal netjes in $_GET gestopt. Je kunt deze code in een apart bestandje zetten en includen, maar je kunt het ook bovenaan in je index.php zetten (als je verder toch alles via $_GET include - zal eigenlijk ook wel moeten).

De .htaccess – en dan vooral het bestaande bestanden stukje – heb ik uit een tutorial van Blanche’ website PHPtuts.nl. De credits daarvan zijn voor hem : ). Verder is alle code door mij geschreven, en van nergens anders gekopieerd of overgenomen.

Dit is overigens mijn manier van het behandelen van nette URLs. Er zullen vast andere methoden bestaan om dit te doen, maar dit vind ik de makkelijkste weg en het werkt hartstikke goed.