URL Optimalisatie

Deze tutorial beschrijft een onderdeel van zoekmachine optimalisatie. Namelijk het onderdeel URL optimalisatie.

Een url als index.php?page=zoeken&view=resultaten&keyword=belangrijk_keyword wordt gezien als zoekmachine onvriendelijk. De parameters in de URL worden door de meeste zoekmachine-crawlers genegeerd, terwijl de URL juist een belangrijk punt is voor waardering van je site, en deze parameters vaak belangrijke keywords (kunnen) bevatten voor je pagina. Ik wil daarom de URLs zo goed mogelijk inrichten zodat deze optimaal 'presteerd' in de zoekmachine.

Deze tutorial beschrijft o.a. het algemeen belang van URL optimalisatie, en de technieken die we gebruiken om dit te doen (common sense, PHP en htaccess).



Note: Deze tutorial is geschreven n.a.v. een paar scripts die ik gepost heb op phphulp.nl.
Zie: http://www.phphulp.nl/php/scripts/7/868/

Wanneer een pagina van je website wordt geindexeerd door een zoekmachine-crawler* let deze crawler op een aantal zaken. Ze bekijkt de inhoud van deze pagina, en overige pagina's die binnen jou domein zijn geindexeert. De links waarnaar jij doorverwijst op je site. Ze analiseert pagina's die naar jou pagina doorverwijst (de zogenaamde 'link populairity'). Je URL, en (bij de meeste crawlers) je metatags.

Al met al krijg je van de zoekmachine een waardering (de zogenaamde 'pagerank') die van belang is hoe je website 'scoort' in de zoekmachine.

Als je op/via je website een product of dienst verkoopt, en je afhankelijk bent van bezoekers die je via zoekmachines kunnen vinden is zoekmachine optimalisatie dus erg belangrijk.

Deze tutorial richt zich op het optimaliseren van eigen URLs. Een van de onderdelen van dit optimalisatie proces.

De meeste zoekmachines-crawlers hechten waarden aan de URL structuur van je webpagina. Doorgaans bestaat deze URL structuur uit 4 delen.

- Domeinnaam
- Pad
- Bestand
- Query (de additionele pagina variabelen die je via PHP met $_GET kunt benaderen).

http://[domeinnaam]/[pad/pad/pad]/[bestand.php]?[query]


Een aantal algemene stellingen die (doorgaans) juist blijken te zijn m.b.t. URL optimalisatie:

- Hoe korter de URL, hoe beter de URL scoort op de 'woorden' die deze nog wel bevat. Het blijft echte lastig om op een enkel woord te optimaliseren. Doorgaans zijn woordcombinaties beter om goede resultaten te behalen.
- Hoe beter de URL aansluit op keywords die je gebruik in de <TITEL>, <META>, en in <H1> en <H2>, hoe beter je URL/pagina scoort.
- Hoe verder woorden naar links staan in je URL, hoe beter deze woorden gewaardeerd worden.

Aan de domeinnaam zelf kan geen enkel script wat doen, gebruik je verstand om een passende URL te vinden voor je inhoud, of bouw de inhoud van je site om je domeinnaam heen :P whatever pleases you.

Het pad, bestandsnaam en de query kun je wél manipuleren (en dat is precies wat we gaan doen in deze tutorial).

De ideale URL bestaat bestaat enkel uit belangrijke keywords voor onze webpagina. Liefst alleen in de domeinnaam.

http://www.belangrijkste-keywords.tld/

Omdat het echter een dure grap zou zijn om voor elke pagina een eigen domein te registreren, moeten we hier wat consessies doen. Al zou het m.b.t. URL optimalisatie goed zijn eigen URLs te hebben, is dit zowiezo geen goed idee. De crawlers hechten veel waarden aan de inhoud van overige pagina's binnen je domein, en als er geen overige pagina's zijn (omdat deze een totaal andere URL hebben) kunnen ze elkaar niet helpen hun pagerank op te krikken.


Een goed alternatief:
http://www.belangrijkste-keywords.tld/iets-minder-belangrijke-keywords/

Het 2e deel van de url, het 'pad' kunnen we op deze manier pagina specifiek maken. Dit is een heel goede methode om je URL te optimaliseren. Helaas wat betreft URL optimalisatie worden PHP gestuurde websites vaak opgebouwd uit 1 indexpagina. (Ik ga er in deze tutorial van uit dat dit het geval is).

Het is dan ook in eerste instantie niet mogelijk om dergelijke 'mooie' paden te gebruiken omdat alles wordt geladen vanuit http://www.domeinnaam.tld/index.php.

Hier voor gaan we dadelijk onze HTACCESS-goocheldoos voor open trekken om deze mooie paden te simuleren (:


We botsen nog tegen 1 ander probleem aan, en dat is de QUERY string die in de URL staat. Deze bevat doorgaans best belangrijke keywords. Ook deze zouden we in geoptimaliseert vorm terug zien. Omdat ze doorgaans minder belangrijk zijn dan de hoofd keywords, zetten we deze verder naar rechts in de URL.

Het mooiste zou dan een url als deze zijn:
http://www.belangrijkste-keywords.tld/iets-minder-belangrijke-keywords/val0/val1/val2/

Nadeel is echter dat QUERY strings zó verschillende kunnen zijn dat het nagenoeg onmogelijk naderhand te kunnen bepalen welke waarde bij welke key hoorde.

Nog een alternatief:
http://www.belangrijkste-keywords.tld/iets-minder-belangrijke-keywords/key0/val0/key1/val1/key2/val2/


De URL wordt echter steeds langer, iets wat minder wenselijk is. Ik heb er voor gekozen om de QUERY string toch te optimaliseren, omdat deze in mijn systeem veel belangrijke waarden bevatten die om technische redenen niet anders omsloten konden worden. Maar eigenlijk zou de query string niet dergelijke kritieke informatie mogen bevatten. Onderstaande URL zou de beste gulden middenweg zijn:

http://www.belangrijkste-keywords.tld/iets-minder-belangrijke-keywords/index.php?querystring

In dit geval zou de querystring dus (doorgaans) genegeerd worden bij de waardering van de URL. Wanneer deze bestaat uit met name numerieke waarden is dit geen enkel probleem; staan er echter veel strings in dan kunnen deze waarden doorgaans beter toch geoptimaliseerd worden.

Zoals ik er al eerder op hamerde, is het belangrijk om goede keywords in je URL te hebben die aansluiten bij de inhoud van de betreffende URL. Het zaak dat je de links in je websites aanpast zodat overal een geoptimaliseerde URL gebruikt wordt.

Ik zit in de luxe positie dat bij het laden van een webpagina alle data eerst volledig wordt geparsed, en pas als alle data (met succes) is verwerkt wordt deze in 1x ge-output naar de bezoeker. Dit bood mij de mogelijkheid om vlak voor het outputten van deze data alle URLs in de data te analiseren en te optimaliseren.

Wat ik doe is alle URLs opsporen in de data, en deze te vervangen met de geoptimaliseerde versie. Belangrijk is dat we a.d.h.v. de oude URL kunnen bepalen wat de geoptimaliseerde URL zou moeten zijn. Je zou hiervoor bepaalde keys in je QUERY string kunnen opsommen. Maar gezien het doel optimaliseren is, en deze keys mogelijk niet optimaal genoeg zijn, neem ik daar geen genoegen mee.

Ik gebruik (misbruik) daarom 1 key met een vaste naam uit de QUERY string, die ik gereserveerd heb voor dit doel. De naam die ik gebruik is '&seo=' (Search Engine Optimalisation), maar dit kan in principe elke naam zijn. Liefst gebruik je er 1 waarvan je kunt verwachten dat je die nooit ergens anders voor wilt gebruiken. Zo zou je als key misschien ook '&google=' kunnen gebruiken.

Belangrijk om te beseffen is dat deze KEY dus totaal geen verder doel heeft in de URL dan optimalisatie. Het is enkel opgenomen voor het optimaliseren, net als dat je metatags opneemt in je pagina neem je een dergelijk label op in de URL.

Een tag die ik vaak gebruik is 'view'. Deze definieert doorgaans een 'subpagina' binnen een module. Omdat ik de waarde van deze tag interessant acht voor de zoekmachine neem ik deze ook op in de geoptimaliseerde URL (zie code). Merk op dat deze VIEW optioneel moet blijven.




URLs ombouwen ZONDER query optimalisatie
URLs worden omgebouwd zodat ze de volgende structuur krijgen: http://www.domeinnaam.tld/[iets-minder-belangrijke-keywords]/[view].php?querystring

URLs worden als volgt vertaald:

Was: index.php?page=zoeken&view=resultaten&keyword=fiets&seo=belangrijke-trefwoorden
Wordt: http://www.domeinnaam.tld/belangrijke-trefwoorden/resultaten.php?page=zoeken&view=resultaten&keyword=fiets

Was: index.php?page=zoeken&keyword=fiets&seo=belangrijke-trefwoorden
Wordt: http://www.domeinnaam.tld/belangrijke-trefwoorden/?page=zoeken&view=resultaten&keyword=fiets

Was: index.php?page=zoeken&view=resultaten&keyword=fiets
Wordt: http://www.domeinnaam.tld/resultaten.php?page=zoeken&view=resultaten&keyword=fiets

Was: index.php?page=zoeken&keyword=fiets
Wordt: http://www.domeinnaam.tld/?page=zoeken&keyword=fiets




URLs ombouwen MET query optimalisatie
URLs worden omgebouwd zodat ze de volgende structuur krijgen: http://www.domeinnaam.tld/[iets-minder-belangrijke-keywords]/key0/val0/key1/val1/key2/val3/
Merk op dat als het de key 'seo' niet bestaat in de oorspronkelijke URL, deze wordt vervangen door een standaard waarde. Ik gebruik het liefst de ~ (tilde) als NULL karakter, maar je zou hier ook een default waarde kunnen opgeven.

URLs worden als volgt vertaald:

Was: index.php?page=zoeken&view=resultaten&keyword=fiets&seo=belangrijke-trefwoorden
Wordt: http://www.domeinnaam.tld/belangrijke-trefwoorden/page/zoeken/view/resultaten/keyword/fiets/

Was: index.php?page=zoeken&keyword=fiets&seo=belangrijke-trefwoorden
Wordt: http://www.domeinnaam.tld/belangrijke-trefwoorden/page/zoeken/keyword/fiets/

Was: index.php?page=zoeken&view=resultaten&keyword=fiets
Wordt: http://www.domeinnaam.tld/~/page/zoeken/view/resultaten/keyword/fiets/

Was: index.php?page=zoeken&keyword=fiets
Wordt: http://www.domeinnaam.tld/~/page/zoeken/keyword/fiets/



Voor dit alles gebruik ik de volgende code:

<?php

	// Tools to uptimize URL's
	function optimizeUrls($sContent, $sDomainRoot = false)
	{
		$matches = array();

		if($sDomainRoot)
		{
			$expr = '/(?:"' . escapeRegex($sDomainRoot) . 'index\.php(?:[^"]*)")|(?:\'' . escapeRegex($sDomainRoot) . 'index\.php(?:[^\']*)\')|(?:\'index\.php(?:[^\']*)\')|(?:"index\.php(?:[^"]*)")/';
		}
		else
		{
			$expr = '/(?:\'index\.php(?:[^\']*)\')|(?:"index\.php(?:[^"]*)")/';
		}
		
		preg_match_all($expr, $sContent, $matches);

		for($i = 0; $i < sizeof($matches[0]); $i++)
		{
			$sQuote = substr($matches[0][$i], 0, 1);
			$sOldUrl = substr($matches[0][$i], 1, -1);
			$sNewUrl = optimizeUrl($sOldUrl, $sDomainRoot, true); // Geef FALSE als de querystring niet geoptimaliseert hoeft te worden

			// echo '<b>' . $sOldUrl . '</b><br>' . $sNewUrl . '<br><br><br>';

			$sContent = str_replace(($sQuote . $sOldUrl . $sQuote), ($sQuote . $sNewUrl . $sQuote), $sContent);
		}

		return $sContent;
	}

	function optimizeUrl($sUrl, $sDomainRoot = false, $bOptimizeQuerystring = true)
	{
		$sResult = '';
		$aArguments = array();

		// Strip domain path
		if($sDomainRoot)
		{
			$sResult = $sDomainRoot;
			if(strcasecmp(substr($sUrl, 0, strlen($sDomainRoot)), $sDomainRoot) === 0)
			{
				$sUrl = substr($sUrl, strlen($sDomainRoot)); // Slice domainpath
			}
		}

		// Strip 'index.php?'
		$sUrl = substr($sUrl, strlen("index.php?"));

		// Get each key/val pair
		$args = explode("&", $sUrl);
		for($i = 0; $i < sizeof($args); $i++)
		{
			$arg = explode("=", $args[$i]);

			$key = strtolower(trim($arg[0]));
			$val = '';

			if(sizeof($arg) > 0)
			{
				$val = trim(urldecode($arg[1]));
			}

			$aArguments[$key] = $val;
		}

		if(array_key_exists("seo", $aArguments) && (strcasecmp($aArguments["seo"], "") !== 0))
		{
			$sResult .= urlencode($aArguments["seo"]) . '/';
		}
		else
		{
			if($bOptimizeQuerystring)
			{
				$sResult .= '~/';
			}
		}

		if($bOptimizeQuerystring)
		{
			foreach($aArguments AS $key => $val)
			{
				if((strcasecmp($key, "seo") !== 0) && (strcasecmp($key, "file") !== 0))
				{
					$sResult .= urlencode($key) . '/' . urlencode($val) . '/';
				}
			}

			if(array_key_exists("file", $aArguments) && (strcasecmp($aArguments["file"], "") !== 0))
			{
				$sResult .= 'file/' . urlencode($aArguments["file"]);
			}
		}
		else
		{
			if(array_key_exists("view", $aArguments) && (strcasecmp($aArguments["view"], "") !== 0))
			{
				$sResult .= urlencode($aArguments["view"]) . '.php';
			}
			
			$sResult .= '?';

			foreach($aArguments AS $key => $val)
			{
				if(strcasecmp($key, "seo") !== 0)
				{
					$sResult .= urlencode($key) . '=' . urlencode($val) . '&';
				}
			}

			$sResult .= substr($sResult, 0, -1); // Strip last '&'.
		}

		return $sResult;
	}

	// Escape Regular expression special characters
	function escapeRegex($string)
	{
		// Escape special characters: \/[]()|?^.*+$
		$string = str_replace("\\", "\\\\", $string);
		$string = str_replace("/", "\\/", $string);

		$string = str_replace("[", "\[", $string);
		$string = str_replace("]", "]", $string);
		$string = str_replace("(", "\(", $string);
		$string = str_replace(")", "\)", $string);

		$string = str_replace("|", "\|", $string);
		$string = str_replace("?", "\?", $string);

		$string = str_replace("^", "\^", $string);
		$string = str_replace(".", "\.", $string);
		$string = str_replace("*", "\*", $string);
		$string = str_replace("+", "\+", $string);

		$string = str_replace("\$", "\\\$", $string);

		return $string;
	}

?> 

Deze code zoekt alle URLs die voldoen aan de volgende syntax
- "index.php..."
- 'index.php...'
- "domeinroot/index.php..."
- 'domeinroot/index.php...'



Eventueel kun je zelf de optimizeUrl() aanpassen zodat deze nog beter aansluit bij jou wensen. Zo kun je bepaalde keys opnemen die verder naar voren worden geschoven in de url. Leef je uit..

Als iemand een geoptimaliseerde URL op geeft moet deze vertaald worden zodat het systeem de juiste pagina weer kan laden. Deze vertaalslag gebeurd in 1 of 2 stappen.

Stap 1: De bezoeker omleiden naar de index pagina
Stap 2: Parameters uit de URL in de $_GET laden (dit is alleen nodig wanneer de QUERY string ook geoptimaliseert wordt).

Stap 1:
M.b.v. HTACCESS kunnen we de bezoekers omleiden. Plaats daarvoor een bestand met de naam ".htaccess" in de root van je website, waar ook je index.php staat. Dit bestand stuurt de bezoeker door naar de index pagina als de gevraagde URL geen bestaand pad is op je server.

De HTACCESS file bevat de volgende regels:

# Start rewrite engine
RewriteEngine On

# Catch non existing files and/or folders (treat as optimized urls)
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [NC,L]

Voordeel van deze methode is dat zowel geoptimaliseerde als niet geoptimaliseerde URLs blijven werken.


Stap 2: (indien van toepassing)
M.b.v. PHP wordt gechecked of er een geoptimaliseerde URL was opgegeven. Zo ja wordt deze URL verwerkt indien nodig.

Hiervoor gebruik ik de functie translateUrl(). Deze functie plaats bij een geoptimaliseerde querystring de juiste key/value weer in de $_GET array.
Zorg dat deze gfunctie bovenin je pagina wordt aangeroepen.

<?php

	function translateUrl()
	{
		if(array_key_exists("REDIRECT_URL", $_SERVER) && (strcasecmp($_SERVER["REDIRECT_URL"], "") !== 0)) // See if htaccess detected an optimized url
		{
			$sPath = substr($_SERVER["SCRIPT_NAME"], 0, strlen($_SERVER["SCRIPT_NAME"]) - strlen("index.php"));
			$sRequest = substr($_SERVER["REDIRECT_URL"], strlen($sPath));
			$args = explode('/', $sRequest);

			if(sizeof($args) > 0)
			{
				// Overwrite arguments (if any)
				for($i = 1; $i < sizeof($args); $i += 2)
				{
					if((strcasecmp($args[$i], "~") !== 0) && (strcasecmp($args[$i], "") !== 0))
					{
						$key = urldecode($args[$i]);
						$_GET[$key] = ((strcasecmp($args[$i + 1], "~") === 0) ? '' : urldecode($args[$i + 1]));
					}
				}

				// Get lable
				$_GET["seo"] = ((strcasecmp($args[0], "~") === 0) ? '' : urldecode($args[0]));

				ksort($_GET);
			}
		}
	}

?>

Je index file krijgt bij de implementatie van deze codes een dergelijke structuur:

<?php

	// Als er een geoptimaliseerde URL is gedetecteerd, overschrijft deze functie de $_GET met de juiste waarden
	translateUrl();

	// Laad de inhoud van de website op basis van de nieuwe $_GET waarden (zelf verder uit te werken)
	$sData = loadContent();

	// Overschrijf de URLs in de data met hun geoptimaliseerde equavalent
	$sData = optimizeUrls($sData);

	// Output data
	echo $sData;

?>

Een dergelijke index file, i.c.m. je htaccess file zijn genoeg middelen om te kunnen profiteren van optimale URLs!!




Vragen en opmerkingen zijn welkom!
M.v.g. Martijn