Dus, Wat gaan we doen?

Eigenlijk gaan we weer hetzelfde doen als in het vorige deel, we gaan weer een auto klasse maken. Maar elke auto is natuurlijk anders, dus maken we meerdere klassen. Dit lijkt omslachtig ja, maar dat is waar het extends keyword komt kijken!

Eerst wat theorie.

De definitie van een klasse kennen jullie nu natuurlijk al (anders moet je m’n eerste deel nog maar is lezen). Maar er komt nog een deel bij. Een klasse kan namelijk ook iets zijn dat een uitbreiding is van een andere klasse. Als dit het geval is, dan neemt een klasse alle methods en variabelen van de ouder-klasse over. Vervolgens kun je nieuwe methods toevoegen, variabelen toevoegen, methods veranderen en variabelen veranderen, behalve als er een bescherming op zit.

Een bescherming?

Ja een bescherming! Weet je nog dat we het hadden over private, protected en public? Je weet dat public was om een method of variabele vanuit de instantie te kunnen benaderen, maar wat is nou het verschil tussen private en protected. Een private method of variabele kan alleen worden gebruikt door de klasse waarin hij gedefinieerd is, een protected method of variabele kan ook worden gebruikt door een uitbreiding van de klasse/kinderklasse/extended klasse. Behalve als je echt niet wilt dat iets in een uitbreidingsklasse wordt gebruikt, raad ik je dus aan om altijd protected te gebruiken!

Maak maar een auto dan!

We gaan nu eerst weer de auto klasse terughalen, ik voeg hier ook een maximumsnelheid aan toe, ook heb ik alle echo’s verwijderd, omdat dat niet netjes is:

class Auto
{
public $merk = 'onbekend';
public $kleur = 'onbekend';
public $nummerbord = 'on-be-kend';
protected $snelheid = 0;
protected $maxSnelheid = 150; //sneller dan dit mag de auto niet gaan
protected $lichten = false; //lichten standaard uit

public function __construct($merk, $kleur, $nummerbord)
{
$this->merk = $merk;
$this->kleur = $kleur;
$this->nummerbord = $nummerbord;
$this->lichten = rand(0, 1);
}

public function geefGas($snelheid = 5)
{
$this->snelheid += $snelheid; //Let op dat je hier niet in de war raakt!
}

public function geefMinderGas($snelheid = 5)
{
$this->snelheid -= $snelheid; //natuurlijk kun je dit ook bereiken met de vorige method, bij een snelheid van -5
}

public function kijkOpSnelheidsmeter()
{
return $this->snelheid;
}

public function handrem()
{
$snelheid = $this->snelheid; //de oude snelheid bewaren
$this->snelheid = 0;

$this->botsing($snelheid); //roep een andere method aan
}

public function switchLichten()
{
$this->lichten = !$this->lichten;

return $this->lichten;
}

private function botsing($beginsnelheid)
{
if(!rand(0, 9) || $beginsnelheid > 100 || $beginsnelheid < -100)
{
return true;
}
else
{
return false;
}
}
}
?>

Nu wil ik een Ferrari die harder kan rijden en sneller optrekt, een Audi die minder snel kan rijden en geen lichten heeft en een bmw zonder handrem en met een kapotte snelheidsmeter. Dit kunnen we op twee manieren berijken:
1. We maken voor elke auto een andere klasse, nadeel: kost erg veel ruimte! Voordeel: dat begrijpen we!
2. We maken extend klassen van de Auto klasse waarmee we bepaalde dingen veranderen, nadeel: begrijpen we nog niet! Voordeel: lekker makkelijk/klein
Natuurlijk kiezen we voor optie 2, we zijn lui! En geen zorgen, ik leg het wel uit!

Aan de slag dan maar!

Juist, we beginnen met de makkelijkste, de Ferrari! Eerst maken we de klasse en zeggen we dat de klasse Auto moet naapen:
class Ferrari extends Auto
{
}
Eerst vertellen we dat hij harder mag rijden:
class Ferrari extends Auto
{
protected $maxSnelheid = 355;
}
Nu schrijven we de geefGas method opnieuw:

class Ferrari extends Auto
{
protected $maxSnelheid = 355;

public function geefGas($snelheid = 10) //door de 10 trekt de ferrari twee keer zo snel op!
{
$this->snelheid += $snelheid; //Let op dat je hier niet in de war raakt!
if($this->snelheid > $this->maxSnelheid)
{
$this->snelheid = $this->maxSnelheid;
}
}
}

En dat is alles wat je nodig hebt om een nieuwe klasse te schrijven, alle andere methods en variabelen werken namelijk ook nogsteeds! Nu gaan we hetzelfde doen, maar dan voor de Audi!

class Audi extends Auto
{
protected $maxSnelheid = 76;

public function __construct($merk, $kleur, $nummerbord)
{
$this->merk = $merk;
$this->kleur = $kleur;
$this->nummerbord = $nummerbord;
//we willen niet dat hier de lichten aan kunnen gaan!
//$this->lichten = rand(0, 1);
}

public function switchLichten()
{
return false;
}
}

En voor de bmw:

class BMW extends Auto
{
public function handrem(){} //geen handrem meer!

public function kijkOpSnelheidsmeter()
{
return $this->snelheid + rand(-10, 10);
}
}

Zoals je ziet kost het dus helemaal geen moeite om 3 verschillende auto’s maken!

Laat maar zien hoe makkelijk je dit gebruikt dan!

Oke, hoe je het gebruikt is eigenlijk gewoon hetzelfde als met een normale klasse! Ik zal jullie ff een voorbeeldcode geven om het uit te kunnen testen Bekijk die hier, de uiteindelijke versie van de klassen is hier te vinden.
Maar, waarvoor kan ik dit dan gebruiken!
Het kunnen extenden van klasses is erg handig bij het gebruik maken van Exceptions. Ook is het erg handig als je een systeem maakt dat kan worden gedownload/gekocht door iedereen! Dan kun je een db klasse maken die alle standaard dingen met de db afhandeld, een mysql klasse maken die db extend en alle dingen doet waarvoor het type nodig is. En dan zo ook een pgsql klasse maken enz.

Tja, dat was het..

Ik hoop dat je het nu begrijpt en kunt toepassen. Snap je iets niet of wil je nog iets anders weten, moet ik nog iets anders behandelen? Vraag het in de comments of op het forum! En onthoud: nog een keer lezen en dingen uitproberen is gratis!

Om uit te leggen hoe je van deze wijze van fouten afhandeling gebruik kan maken, zal ik dit uitleggen aan de hand van een programmeervoorbeeld. In dit programmeervoorbeeld haal ik uit een tabel met berichten, de berichttitel, in dit geval gaan we van een phpBB tabel uit.

Hoe doen we het nu

Dit artikel gaat er van uit dat je kennis hebt van hoe object georienteerd programmeren in php werkt. Zo niet is het handig om eerst dit artikel aandachtig door te nemen.

Allereerst begin ik met de manier waarop normaal in PHP fouten die optreden worden afgehandeld. Hiervoor heb ik een bestand gemaakt met een aantal aangepaste SQL functies, om de omvang van het bericht te minimaliseren zal ik steeds naar dit SQL bestand verwijzen. We beginnen met ons eerste sql_bestand.

Onderstaande code zal uit de database de onderwerpen van de berichten halen, en deze weergeven op je pagina.

<?php
include('sql_none.php');
$db = 'phpbb';
$host = 'localhost';
$pass = '';
$user = 'root';if (!($connection = connect($user, $pass, $host, $db)))
{
die('Failed to connect to DB');
}$sql = 'SELECT post_subject FROM phpbb_posts';if (!($result = sql_query($sql, $connection)))
{
die('Failed to query DB');
}

Door gebruik te maken van de false uitkomsten van de verschillende SQL functies, kunnen we controleren of een functie gelukt is of niet. Wat hier gelijk opvalt, is dat de foutverwerking in de code zit verweven door middel van de if-then-else statements. Doordat de fouten verwerking binnen in je code zit, kan dit soms er voor zorgen dat je code niet heel duidelijk wordt. Helaas is bovenstaande code niet dermate complex om dit te kunnen weergeven. Het idee achter exceptions is dus ook onder andere het scheiden van foutafhandeling van je daadwerkelijke code geweest. Verder kun je het ook heel handig gebruiken om je fouten te identificeren. We gaan nu verder in op hoe je Exceptions zou kunnen toepassen op bovenstaande code.

Implementeren van exceptions

Om beter te begrijpen wat het volgende codevoorbeeld doet, is het eerst belangrijk om te weten wat er nou precies gebeurd wanneer er een Exception optreed. De constructie die achter Exceptions zit is de volgende:

1. Je voert een functie uit.
2. Er treed een fout op in de functie, de functie gooit hierop een Exception. Keyword hierbij is throw.
3. Je script gaat op zoek naar de eerst volgende Exception vanger. Keyword hierbij is catch.
4. Je script voert de code uit, die bij deze Exception opvanger staat.
5. Je script gaat hieronder verder.

Belangrijk hier om te weten is, dat alle code tussen de functie die de Exception laat optreden en de opvanger van de Exception niet wordt uitgevoerd. Maar wat is nu precies die Exception. Exception is een class binnen php. Wanneer er een fout optreed in je functie, maak je een instance aan van de Exception class, waarna je deze class laat gooien. In je php code ziet dat er op de volgende wijze uit:

if ($error) throw new Exception('Een fout');

Wanneer je error true is, zal deze code een Exception gooien, met de door jouw ingevoerde foutmelding in de vorm van een string. Het is niet verplicht om een string mee te geven aan de functie, maar dit is voor jezelf wel handig voor het debuggen. Wanneer we deze code implementeren levert ons dat het volgende sql_bestand op. In plaats van dat we return false gebruiken om een fout aan te geven, gooien we nu een exception. Wanneer de exception gegooid wordt, zal de functie stoppen en zal in de code gezocht worden naar de eerst volgende Exception vanger.

Opvangen van Exceptions

We hebben nu dus functies die Exceptions gooien, wanneer er iets fout gaat. Echter hebben we daar niets aan als we deze ook niet kunnen opvangen. De code om dit te doen ziet er ’schematisch’ ongeveer het volgende uit: Probeer { code } vang op { exception }.

In php code ziet dit er als volgt uit:

try
{
do_stuff();
}
catch (Exception $e)
{
echo $e->getMessage();
}

Er wordt geprobeerd om de code die in het try gedeelte staat, uit te voeren. Wanneer er echter een een Exception optreed zal Exception optreed, zal het script springen naar de eerst volgende catch statement wat bij die Exception hoort en de code die hierin staat uitvoeren. Wanneer we dit gaan toepassen op ons vorige code voorbeeld, ziet onze code er als volgt uit:

<?php
include('sql_general.php');
try
{
$db = 'phpbb';
$host = 'localhost';
$pass = '';
$user = 'root';$connection = connect($user, $pass, $host, $db);$sql = 'SELECT post_subject FROM phpbb_posts';$result = sql_query($sql, $connection);

Het eerste wat opvalt is dat nu de foutafhandeling compleet los staat van de rest van je code, wat resulteert in beter leesbare code wanneer je aan de slag gaat met complexere scripts. Daarnaast zien we ook een bepaalde functie naar voren komen welke onderdeel is van de Exception class. getMessage() print de fout string, die jij in je Exception declaratie hebt meegegeven. Hiermee kan je bijvoorbeeld aangeven waar je Exception is opgetreden.

Al met al bied bovenstaande code een heleboel leuke mogelijkheden, echter is dit nog niet erg handig nog in gebruik, omdat ik hier alleen maar een tekst string heb die mij verteld welke foutmelding er precies is geweest. Alle foutmeldingen zijn van het type Exception en dat is slechts een type.

Geavanceerde technieken

En nu komt dan eindelijk een van de grote voordelen om de hoek kijken die het object georiënteerd programmeren met zich meebrengt, namelijk het feit dat ik een class kan uitbreiden. In mijn bovenstaande code voorbeeld zou je bijvoorbeeld kunnen denken dat het handig is om de volgende foutmeldingen te kunnen waarnemen:

• Connectie fout
• Database selectie fout
• Etc.

We kunnen dus onze eigen Exceptions creëren, bijvoorbeeld:
class ConnectException extends Exception { }
Maar dat is niet het enige. We kunnen ook meerdere catch clausules onder elkaar maken, waarmee we de verschillende Exceptions kunnen opvangen, bijvoorbeeld:

catch (FirstException $e) { echo $e->getMessage(); }
catch (SecondException $e) { echo $e->getMessage(); }

Hiermee kunnen we per fout dus een apart stukje code aanroepen dat afgehandeld wordt wanneer een bepaalde fout optreed. We kunnen dus nu ons sql_bestand aanpassen en deze eigen foutmeldingen toepassen. En wanneer we ook ons script aanpassen komt het er als volgt uit te zien:

<?php
include('sql_costumised.php');
try
{
$db = 'phpbb';
$host = 'loalhost';
$pass = '';
$user = 'root';$connection = connect($user, $pass, $host, $db);$sql = 'SELECT post_subject FROM phpbb_posts';$result = sql_query($sql, $connection);

De exception opvangers zien er nu zeer complex uit, maar bovenstaande constructie bied een legio aan mogelijkheden. Zo kun je bepaalde stukken code uitvoeren wanneer je een bepaalde fout krijgt, je kunt bijvoorbeeld de sql verbinding afbreken.

Belangrijk is het wel dat wanneer je je eigen Exceptions gaat creëren, dat je wel al je Exceptions die kunnen optreden, ook daadwerkelijk opvangt. Immers het php script zal pas verdergaan met de code, na je exception opvanger.

Ik hoop dat ik jullie hiermee een beetje een introductie heb kunnen geven in deze nieuwe manier van het opvangen van fouten die optreden tijdens het uitvoeren van je code en hoop natuurlijk dat dit je helpt bij het schrijven van betere code voor de toekomst.

Voor meer informatie over hoe Exceptions werken, kijk je het best even op de site van php.net over Exceptions.

In deze tutorial ga ik er wel vanuit dat je minimaal PHP versie 5.* gebruikt, voor deze versie is de ondersteuning van OOP namelijk heel slecht.

Dus.. wat is OOP nou eigenlijk?

OOP staat voor object oriented programming. Dit is dus het gebruiken van objecten bij het programmeren. Vaak wordt OOP met klassen (classes) verward, maar dit is niet helemaal het zelfde, OOP gaat namelijk ook over de manier waarop je die gebruikt enzovoort.

OOP bestaat trouwens niet in PHP, maar in de meeste andere talen. Van alle talen waarin OOP ondersteund wordt is de ondersteuning van PHP zelfs een van de minst uitgebreide.

Oke! Maar wat zijn die klassen dan?

De basis van OOP zijn de klassen. Een klasse (class in PHP) kun je wel zien als een blauwdruk of gewoon een object (daar komt de eerste O in OOP dus vandaan ). In een klasse stop je methods. Dit zijn eigenlijk gewoon functies, maar dan in een klasse. Daarnaast kun je er ook variabelen in stoppen. Eigenlijk is een klasse dus een verzameling van functies die over gezamenlijke variabelen beschikken.

Juist ja, maar wat is dan het nut? Kan ik niet gewoon functies gebruiken?

Het nut van een functie is, dat je een bepaald stuk code op meerdere plaatsen kunt gebruiken, terwijl je de code maar één keer typt! Het nut van een klasse is dat je verschillende functies samen laat werken. In sommige gevallen is het dus handiger om functies te gebruiken en in sommige gevallen is het handiger om klassen te gebruiken.

Hoe maak ik dan zo’n klasse?

Even geduld, ik heb eerst nog één kleine opmerking. Ik ga in deze tut een voorbeeld van een klasse voor een auto gebruiken, natuurlijk heb je hier niets aan in je code, maar het is wel handig om aan te tonen wat je met klassen kunt!

Een klasse openen in PHP is nog makkelijker dan een functie openen, je doet namelijk gewoon dit (let op, de naam is net zoals bijna alles in PHP hoofdlettergevoelig):

[code lang="php"] class Auto
{
}
?>[/code]

Een klasse op zich kan niet erg veel.. sterker nog, het kan helemaal niets! Elke keer als je een bepaalde klasse wilt gebruiken (je kunt elke klasse natuurlijk vaker gebruiken, zelfs tegelijkertijd), moet je er een instantie van maken. Vanuit deze instantie gaan we later ook weer de methods aanroepen.

Het maken van een instantie doe je zo:

[code lang="php"] $bmw = new Auto(); //Dit wordt mijn BMW!
$ferrari = new Auto(); //Dit wordt mijn Ferrari, omdat de variabele naam anders is dan die van de BMW, zullen ze elkaar niet lastig vallen!
?>[/code]

Maar, hier kan ik toch helemaal niets mee?

Dat heb je heel goed gezien! Om er wel iets mee te kunnen gaan we nu eerst variabelen toe voegen. Deze variabelen zijn wel iets anders dan gewone variabelen, je kunt ze namelijk: private, protected en public maken.

• Private variabelen kunnen alleen worden benaderd vanuit de klasse waarvan ze onderdeel zijn.
• Protected variabelen kunnen alleen worden benaderd vanuit de klasse waarvan ze onderdeel zijn en vanuit klassen die een aanvulling zijn op deze klasse.
• Public variabelen kunnen ‘overal’ vandaan worden benaderd.

Een variabele moet aan het begin van de klasse worden aangegeven, je kunt daar kiezen voor het soort variabele, de naam van de variabele en eventueel de waarde. Dit kun je zo doen:

[code lang="php"] [type] $[naam]; //variabele zonder waarde
[type] $[naam] = [waarde]; //variabele met waarde
?>[/code]

Laat me dan nu variabelen toevoegen aan onze klasse!

In onze klasse gaan we variabelen gebruiken om de kenmerken van onze auto aan te geven: merk, kleur, snelheid, nummerbord, lichten (aan/uit). Dan krijgen we dus zoiets:

[code lang="php"] class Auto
{
public $merk = 'onbekend';
public $kleur = ‘onbekend';
public $nummerbord = 'on-be-kend';
protected $snelheid = 0;
protected $lichten = false; //lichten standaard uit
}
?>[/code]

Het is niet nodig om de public variabelen van de protected variabelen te scheiden, maar dat doe ik hier gewoon voor de duidelijkheid.

Ik wil de variabelen nu kunnen aanpassen!

Om dingen uit een instantie te benaderen gebruik je in PHP -> . In ons voorbeeld kunnen we dus dit gebruiken:

[code lang="php"] $bmw = new Auto(); //Dit wordt mijn BMW!
$ferrari = new Auto(); //Dit wordt mijn Ferrari, omdat de variabele naam anders is dan die van de BMW, zullen ze elkaar niet lastig vallen!

$ferrari->merk = ‘Ferrari';
$ferrari->kleur = ‘rood' ;
$ferrari->nummerbord = ‘PH-PO-OP';

echo $ferrari->merk . ‘ '; //Ferrari
echo $ferrari->kleur . ‘'; //rood
echo $ferrari->nummerbord . ‘

'; //PH-PO-OP

echo $bmw->merk . ‘

' ; //onbekend

$bmw->merk = ‘BMW';

echo $bmw->merk; //BMW
?>[/code]

Tja, een auto, maar hij kan toch helemaal niets!

Om de auto dingen te laten doen, gaan we de methods gebruiken, maar wat wel handig is om eerst te weten: variabelen van de klasse kun je binnen de klasse aanroepen met $this.

Omdat een method ongeveer het zelfde is als een functie, is de manier hoe je hem aanmaakt ook ongeveer hetzelfde. Het enige verschil is, dat je weer private, protected en public moet gebruiken! Dit doe je dan dus zo:

[code lang="php"] [type] function [naam]([parameters])
{
}
?>[/code]

Laten we dit dan maar aan onze klasse toe gaan voegen, zodat het eindelijk echt ergens op begint te lijken!

[code lang="php"] class Auto
{
public $merk = ‘onbekend';
public $kleur = ‘onbekend';
public $nummerbord = ‘on-be-kend';
protected $snelheid = 0;
protected $lichten = false; //lichten standaard uit

public function geefGas($snelheid = 5)
{
$this->snelheid += $snelheid; //Let op dat je hier niet in de war raakt!

echo ‘Vroem!'; //normaal echo je niet in een method, maar anders wordt het wel erg omslachtig!
}

public function geefMinderGas($snelheid = 5)
{
$this->snelheid -= $snelheid; //natuurlijk kun je dit ook bereiken met de vorige method, bij een snelheid van -5

echo ‘Pfffff!';
}

public function handrem()
{
$snelheid = $this->snelheid; //de oude snelheid bewaren

$this->snelheid = 0;

echo ‘IIIIIIIEEEEEEEE!';

$this->botsing($snelheid); //roep een andere method aan
}

public function switchLichten()
{
$this->lichten = !$this->lichten;

return $this->lichten;
}

private function botsing($beginsnelheid)
{
if(!rand(0, 9) || $beginsnelheid > 100 || $beginsnelheid < -100)
{
echo ‘BOEM!';
}
}
}
?>[/code]

Hoe gebruik ik deze methods?

Een method gebruiken is het zelfde als een variabele gebruiken! We kunnen nu dus bijvoorbeeld zo’n code krijgen:

[code lang="php"]
$bmw = new Auto(); //Dit wordt mijn BMW!
$ferrari = new Auto(); //Dit wordt mijn Ferrari, omdat de variabele naam anders is dan die van de BMW, zullen ze elkaar niet lastig vallen!
$ferrari->merk = 'Ferrari';
$ferrari->kleur = ‘rood' ;
$ferrari->nummerbord = ‘PH-PO-OP';
echo $ferrari->merk . ‘ '; //Ferrari
echo $ferrari->kleur . ‘'; //rood
echo $ferrari->nummerbord . ‘

'; //PH-PO-OP
echo $bmw->merk . ‘

' ; //onbekend
$bmw->merk = ‘BMW';
echo $bmw->merk; //BMW
echo ‘

';
//En nu de methods (ik gebruik ff alleen ferrari)
$ferrari->geefGas();
$ferrari->geefMinderGas();
$ferrari->geefGas(100);
$ferrari->geefMinderGas(10);
$ferrari->geefGas(47);
$ferrari->geefMinderGas(38); //snelheid wordt nu 99 als ik me niet vergis..
$ferrari->handrem();

$rand = rand(5, 15);
for($i = 0; $i < $rand; $i++)
{
$ferrari->switchLichten();
}

echo ($ferrari->switchLichten()) ? ‘Aan' : ‘Uit';
?>
[/code]

Dat is stoer! Het is alleen wel een beetje omslachtig om op deze manier de eigenschappen te moeten aangeven!

Er zijn ook nog speciale methods, deze beginnen met twee liggende streepjes __ . één daarvan is de constructor. Als we deze toevoegen aan onze klasse, dan komt hij er zo uit te zien:

[code lang="php"] class Auto
{
public $merk = ‘onbekend';
public $kleur = ‘onbekend';
public $nummerbord = ‘on-be-kend';
protected $snelheid = 0;
protected $lichten = false; //lichten standaard uit

public function __construct($merk, $kleur, $nummerbord)
{
$this->merk = $merk;
$this->kleur = $kleur;
$this->nummerbord = $nummerbord;

$this->lichten = rand(0, 1);
}

public function geefGas($snelheid = 5)
{
$this->snelheid += $snelheid; //Let op dat je hier niet in de war raakt!

echo ‘Vroem!'; //normaal echo je niet in een method, maar anders wordt het wel erg omslachtig!
}

public function geefMinderGas($snelheid = 5)
{
$this->snelheid -= $snelheid; //natuurlijk kun je dit ook bereiken met de vorige method, bij een snelheid van -5

echo ‘Pfffff!';
}

public function handrem()
{
$snelheid = $this->snelheid; //de oude snelheid bewaren

$this->snelheid = 0;

echo ‘IIIIIIIEEEEEEEE!';

$this->botsing($snelheid); //roep een andere method aan
}

public function switchLichten()
{
$this->lichten = !$this->lichten;

return $this->lichten;
}

private function botsing($beginsnelheid)
{
if(!rand(0, 9) || $beginsnelheid > 100 || $beginsnelheid < -100)
{
echo ‘BOEM!';
}
}
}
?>[/code]

Dit kunnen we nu gebruiken om op een snelle manier eigenschappen aan een instantie mee te geven! Omdat het geen normale method is, kun je wel verwachten dat je hem ook niet zo aanroept! De construct method wordt aangeroepen als een nieuwe instantie van de klasse wordt gemaakt:

[code lang="php"] $bmw = new Auto(‘BMW', ‘Pimpel paars met zilveren sterretjes', ‘OO-PP-HP'); //Dit wordt mijn BMW!
$ferrari = new Auto(‘Ferrari', ‘rood', ‘PH-PO-OP'); //Dit wordt mijn Ferrari, omdat de variabele naam anders is dan die van de BMW, zullen ze elkaar niet lastig vallen!

echo $ferrari->merk . ‘ '; //Ferrari
echo $ferrari->kleur . ‘'; //rood
echo $ferrari->nummerbord . ‘

'; //PH-PO-OP

echo $bmw->merk; //BMW

echo ‘

';

//En nu de methods (ik gebruik ff alleen ferrari)
$ferrari->geefGas();
$ferrari->geefMinderGas();
$ferrari->geefGas(100);
$ferrari->geefMinderGas(10);
$ferrari->geefGas(47);
$ferrari->geefMinderGas(38); //snelheid wordt nu 99 als ik me niet vergis..
$ferrari->handrem();

$rand = rand(5, 15);
for($i = 0; $i < $rand; $i++)
{
$ferrari->switchLichten();
}

echo ($ferrari->switchLichten()) ? ‘Aan' : ‘Uit';
?>[/code]

Zo dat maakt je code weer lekker een stuk korter!

Bedankt! Nu snap ik het!

Graag gedaan! Tip: zorg dat je alles wat hier boven staat goed snapt en ga dan zelf experimenteren. En reacties, commentaar, opmerkingen, aanmerkingen, verbeteringen, enz. zijn natuurlijk altijd welkom

Quotes

Quotes is een Engelse term voor aanhalingstekens, maar aangezien in het programmeren Engelse terminologie wordt gebruikt hebben we het over quotes.

Single-quote: ‘Hello‘

Double-quote: “Hello“

Verschillen

Ik ga de verschillen illustreren in php, deze verschillen liggen meestal ook zo bij andere programmeertalen (maar dus niet altijd)

Single-Quotes

$sString = 'World' ;

echo ‘Hello $sString’ ;

geeft: Hello $sString

Als je Hello World wilt krijgen, dan moet je de variabel buiten de quotes brengen:

echo ‘Hello’ . $sString ;

Geeft dan wel: Hello World

Double-Quotes

$sString = 'World' ;

echo ‘Hello $sString’ ;

geeft: Hello World

Ook kan je bij double-quotes de variabel buiten de quotes zetten.

echo ‘Hello’ . $sString ;

Geeft : Hello World

Wat is het best?

Ik zelf prefereer de single-quotes, omdat ik dit zelf duidelijker vind staan. Je maakt als programmeur zelf het verschil duidelijk tussen gewone tekst en variabelen en laat dat niet over aan de parser van php.

Het voordeel van double-quotes is dat het lekker snel programmeert, want je hoeft niet de hele tijd de variabelen buiten de quotes te zetten.

Maar ik zelf vind duidelijkheid en overzicht belangrijker dan de snelheid waar mee een script geschreven wordt, dus doe mij daarom maar de single-quotes.

]]> http://webmasterplein.net/blog/2008/10/single-quotes-vs-double-quotes/feed/ 6 http://webmasterplein.net/blog/2008/10/microsoft-silverlight-2-eindelijk-light-up-the-web/ http://webmasterplein.net/blog/2008/10/microsoft-silverlight-2-eindelijk-light-up-the-web/#comments Wed, 15 Oct 2008 20:09:47 +0000 Stefan http://webmasterplein.net/blog/?p=68 Voor die gene die niet weten wat Silverlight is: het is de concurent van de Flash-player en is net als de Flash-player een plug-in voor browsers. Microsoft heeft gister zijn tweede versie van Silverlight geïntroduceerd. Microsoft Silverlight 2 is de opvolger van versie 1 en heeft vele veranderingen ondergaan, waaronder meer mogelijkheden tot het schrijven van Silverlight applicaties.

Ondersteuing van .Net-framework, een deepzoom feature, advertentie weergave en betere beveiligde drm (Digital Rights Management) zijn nieuwe toevoegingen voor de nieuwe versie van Silverlight. Ook de GUI-objecten (Graphical User Interface) uit Silverlight hebben een grote verandering ondergaan, hierdoor is de applicatie overzichtelijker geworden, zowel voor de programmeur als voor de beginner in Silverlight.

Door de ondersteuning van .Net-framework is in Silverlight nu mogelijk om applicaties te maken in C#, Javascript, IronPython en IronRuby.

Silverlight 2 is downloaden op de site van Microsoft Silverlight. Huidige installaties van Silverlight worden automatisch geüpdate.

De grootste verbetering van het programma is dus het ’showen’ van 3D-objecten in een flash-animatie. In de eerder deze maand uitgebrachte Adobe Flash CS4 is een tool gebouwd om gemakkelijk 2D-objecten te converteren naar 3D-objecten. De nieuwe tool in het programma is de ‘authoringtool’ en kan ingezet worden op elk figuur, zowel op tekst als op een graphic.

De layout van tekst kan in Flash CS4 verbeterd worden dankzij de nieuwe Flash Player. Zo kan de tekst meerdere opmaken krijgen en je kan per Frame deze opmaak ook werkelijk veranderen. Shadow en Glow zijn nieuwe onderdelen die tijdens het afspelen van de tekst-animatie blijven bestaan, maar hierdoor krijgt de GPU het soms wel moeilijk. Daarom is het bij het maken van dit soort animaties handig om de GPU aan te spreken op zijn gedrag en eventueel een andere versnelling van de GPU in te stellen.

Ook wat totaal niet mocht ontbreken in de nieuwe Flash Player is het animeren van HD-kwaliteit video’s, waarbij de gemiddelde HD-kwaliteit ligt op h.264 formaat. Hierdoor zullen animaties en applicaties nog mooier worden dan in de Flash Player 9 formaat. Flash Player 9 had soms in de applicaties nog moeite met oudere versies van Flash maar dat is met versie 10 helemaal verhopen. De compabiliteit van versie 10 is erg verbeterd ten opzichte van versie 9.

Flash Player 10 is beschikbaar voor Windows, MacOS x en Linux en is te downloaden op de website van Adobe Flash Player. Op die website zie je meteen ook al een klein voorproefje van de toekomst van de flash-animaties.

Afgelopen week werd Silverlight 2 ook al uitgebracht door Microsoft en bezit ook vele extra’s. Probeer zelf uit te vinden welke player jij het beste vind werken!

Op internet doemde al jaren het idee dat Google moeite heeft met dynamische URL’s, hoewel Google indirect toegeeft dat dit in het verleden ook zo was, is dit nu verleden tijd en schrijft men:

We can crawl dynamic URLs and interpret the different parameters. We might have problems crawling and ranking your dynamic URLs if you try to make your urls look static and in the process hide parameters which offer the Googlebot valuable information. One recommendation is to avoid reformatting a dynamic URL to make it look static. It’s always advisable to use static content with static URLs as much as possible, but in cases where you decide to use dynamic content, you should give us the possibility to analyze your URL structure and not remove information by hiding parameters and making them look static.

Het populaire mod_rewriting is volgens Google niet de juiste keuze om content duidelijk weer te geven, liever hebben ze de dynamische URL zodat Google zelf de informatie er uit pikt die het wil hebben. Bang dat de webmaster enkele handige informatie voor de zoekmachine achterhoud.

Op de weblog van Google Webmaster Central heeft het in ieder geval geleid voor flink wat discussie.

Daarom heb ik een simpele class geschreven om het debuggen net iets makkelijker te maken (download). Deze class bevat een aantal simpele functies die het debuggen wat makkelijker en ook mooier maken. Niets van de debug-informatie wordt ge-output voordat je de functie display() aanroept. Alle debug-informatie kun je dus fijn laten staan.

Genoeg gepraat, laten we eens kijken hoe het werkt:

<?php
require_once('../class.debug.php'); // Include bestand
$d = new Debugger(); // Maak een nieuwe debugger instance

$d->write('Debug test'); // Schrijf een nieuwe debug-regel
$d->display(); // Echo alles
?>

Deze code zal, natuurlijk, de class includen en de regel ‘Debug test’ weergeven, door de functie display. Ik hoop deze code nog wel een beetje duidelijk is, zo moeilijk zal het niet zijn. Al de output zal trouwens in ‘<div id=”debug”>’ komen te staan, zodat je deze makkelijk kan stylen of verbergen.

Natuurlijk is deze simpele debug-regeltjes schrijven niet het enige wat je met de debugger kan:

<?php
require_once('../class.debug.php');
$d = new Debugger();

$d->var_dump(array('a', 'b'), 'testArray'); // Doe een var dump

$d->benchmark('before'); // Benchmark
sleep(3); // Doe hier 'iets'
$d->benchmark('after'); // Nog een benchmark
$d->benchmarks_result('before', 'after'); // Vergelijk resultaten

$d->display();
?>

Nog een stukje code voor jullie. Weer niet zo heel erg moeilijk. Wat we als eerste doen is een var dump. Deze gebruikt de standaard var_dump functie van PHP, maar zet deze tussen de andere debug regels. Het eerste argument is de variabel die je wil dumpen, het mag van elk type zijn, dus niet alleen arrays. De tweede is een naam die je mag opgeven (dus optioneel), zo kan je je dump makkelijk herkennen.

Daarna gaan we wat performance testen, wat hier ontzettend simpel werkt. Je benchmarked eerst een punt, doet iets en daarna nog een punt. Met de functie benchmarks_result() kan je daarna te tijd krijgen die er tussen 2 benchmarks zit. Eigenlijk heel simpel, toch?

Er zijn nog een aantal laatste dingen. Zo kan je bijvoorbeeld alle debug data loggen in een bestand of zelfs gebruik maken van een error handler:

<?php
require_once('../class.debug.php');
$d = new Debugger('debuglog.txt'); // Deze keer met een anders bestand als debug log (optioneel)
set_error_handler(array($d, 'error')); // Eigen error handler gebruiken
$d->log = true; // Loggen aanzetten

$d->display();
?>

Het log bestand komt standaard in debug.log, maar je kan dus je eigen bestand meegeven als eerste argument bij het nieuwe object, daarna moet je het wel nog aanzetten. De error handler is nog ontzettend beperkt, zo kan je bijvoorbeeld niet zien of het een notice warning of andere error is. Ik raad je ook aan om, via het tweede argument, het aantal errors waarbij de debug error handler te beperken naar alleen notices en warnings. Wat er gebeurd bij een fatal error heb ik niet getest, maar ik ben bang dat je niet meer dan een wit scherm krijgt.

Ik hoop dat ik genoeg uitleg heb gegeven over hoe de debugger werkt, het helpt je weliswaar niet met ontzettend veel informatie te geven, maar als je zelf een plek hebt om je informatie kwijt te kunnen kan al ontzettend fijn zijn, geloof me!

Je kent ze vast wel de bekende iconen in de adresbalk en tabbladen, ze zorgen niet enkel voor een mooi compleet beeld van je website, het zorgt ook voor herkenning in je tabbladenbalk en bladwijzerlijst. We pakken bijvoorbeeld: en je ziet direct dat het van Google afkomstig is, is Microsoft en jawel… Geenstijl. Kortom een fav(orite)-icoon staat niet alleen leuk, het bouwt ook herkenbaarheid op.

Een favicon voor je website is geen noodzaak, maar het helpt je bezoekers wel jouw website eruit te plukken, in bijvoorbeeld de bladwijzerlijst. Laten we dus uiteenzetten hoe we het favicon plaatsen op je website.

Formaat:
Het favicon bevat altijd de afmeting 16 breed en 16 hoog, dit is het universele formaat waarin je icoon zeker goed wordt weergegeven.

De afbeelding moet worden opgeslagen worden in het ico-formaat hier zijn verschillende programma’s voor:

• Favicon Editor (online)
• ICOFormat (photoshop plugin)
• PNG to icon converter

Plaatsen:
Je favicon plaats je in de root van je website, dus op de plek waar in 9 van de 10 gevallen zich ook het index.html bestand bevind. Zodra je hem hebt geüpload naar de root, zouden browsers hem automatisch moeten herkennen en weergeven.

Gebeurd dit niet of wil je de favicon in een andere directory stallen dan kun je door middel van de link tag hem in je website zetten:

<link href="./favicon.ico" link rel="shortcut icon" type="image/x-icon" />

<html>
<head>
<title>Mijndomein.nl</title>
<link href="./stylesheet.css" rel="stylesheet" type="text/css" media="all" />
<link href="./favicon.ico" link rel="shortcut icon" type="image/x-icon" />
</head>
<body>

Opmerking:
Mocht je het opslaan als ico-formaat lastig vinden, dan wijk je hier vanaf en maak je een gif-afbeelding en vul je in het href-attribuut gewoon: “favicon.gif” in.
<link href="./favicon.gif" link rel="shortcut icon" type="image/x-icon" />
Let op: Dan wordt hij niet automatisch door browsers herkent en zul je op iedere pagina deze regel moeten plaatsen.

Inspiratie:
Op het prachtige inspiratieblog Smashing Magazine vind je 5 blogposts om inspiraties op te doen voor jouw eigen unieke favicon:

• Inspire Yourself: 50 Remarkable Favicons
• Inspire Yourself: More Creative Favicons
• Creative Favicons: When Small Is Beautiful
• Creative Favicons: Tiny Artwork
• Favicons Episode 5: The Delicate Beauties

Tips bij het maken

1. Trek een gelijkenis met je website; Zorg dat je icoon overeenkomt met je website, is je website simpel en strak? Zorg voor een simpel en strak icoontje. Verwerk de kleuren van je site in het icoon. Of pak de eerste letter van je logo.
2. Houd het simpel; Je hebt maar 16×16 als grootte, dat is klein en ga dus geen ingewikkelde afbeeldingen er in verwerken die worden meestal niet herkend.
3. Transparante icoontjes; Onthoud dat met een achtergrondkleur je favicon een blok wordt en dus niet samengaat met je adresbalk. Als voorbeeld het oude favicon van webmasterplein:

Nou, wat is het idee achter een Framework? Het idee achter een Framework is dat je steeds dezelfde dingen programmeert, maar met een beetje maatwerk erin. En als dat het geval is, waarom zou je dan steeds hetzelfde programmeren? Frameworks doen dat voor jou: De Frameworks kunnen van alles doen, en jij bent er om ze te vertellen wat ze moeten doen.

Wat voor voordelen heeft een Framework dan zoal?

Een Framework ten eerste ontzettend tijdbesparend. En nee, daarmee bedoel ik niet dat je op een groot project een paar uurtjes minder besteed, daarmee bedoel ik dat je nog niet eens een kwart van de tijd bezig bent. Geloof me, de tijd om een Framework te leren heb je in één klein project al gelijk weer ingehaald.

Ook bevordert een Framework het mooier programmeren. De meeste moderne Frameworks gebruiken het MVC-pattern. Deze zorgt ervoor dat je je code mooi opdeelt. Ik zal een korte uitleg over het MVC-pattern geven:

De model (M) doet eigenlijk het echte werk, de bedoeling is dat alleen de model query’s op de database uitvoert, naar bestanden schrijft en het echte rekenwerk doet. De model wordt helaas toch wel vaak in het MVC-pattern. De controller (C, Zie beneden) dient dan als controller en model.

De view (V) is eigenlijk het HTML bestand. Deze mag dus al helemaal geen query’s uitvoeren, of naar bestanden schrijven, of rekenwerk doen. Nee, het is puur het grafische, met wat PHP variabelen of template-parser variabelen. Wil je toch iets anders hebben in je views? Heel simpel, zorg ervoor dat je PHP functies van je controller of model in je views kan gebruiken. Nee, dit gaat niet tegen de regels van MVC, het blijft net zo overzichtelijk, zo niet, overzichtelijker.

De controller (C) is eigenlijk wat de hele boel bij elkaar houdt. Hij staat tussen de model en de view in, hij roept functies in de model aan en zorgt ervoor dat alles weer terugkomt in de goede view file met de goede data erin. Zoals al eerder gezegd, wordt de controller te vaak ook als model gebruikt.

Hopelijk heb ik hiermee het MVC pattern een beetje uitgelegd. Voor wat meer informatie zal je moeten Googlen, maar helaas is er vrij weinig goede informatie over te vinden. Maarja, gewoon beginnen, dan leer je het vanzelf!

Een Framework heeft natuurlijk niet alleen maar voordelen, maar ook nadelen:

Dat je zelf een hele hoop programmeert, zegt natuurlijk dat je in totaal minder regels code gebruikt. Het grootste nadeel is dan ook Frameworks groot en soms langzaam zijn. Een hele hoop code wordt uitgevoerd voor het geval dat . Voor het geval dat een module een “custom query” wil, moeten we dat nakijken. In de meeste gevallen is dat natuurlijk niet nodig. Een erg groot nadeel dus.

Wat ook erg ergerlijk kan zijn aan Framework is, dat je toch weer iets nieuws moet gaan leren. Je werkt dan weliswaar nog in PHP, je moet zou gebruiken moeten maken van de functies van het Framework, omdat dat vaak beter qua samenwerking met het Framework. Al die dingen leren kost toch wel een hoop tijd. Wat dus ook een van de belangrijkste dingen van een Framework is, is documentatie. Gelukkig zijn er een aantal goed gedocumenteerde Frameworks te vinden.

Helaas is het geven van een voorbeeld nogal moeilijk, hoewel Frameworks de hoeveelheid code die je schrijft ontzettend verminderen, blijft er in veel Frameworks toch nog een hoop code over. Dat is trouwens niet altijd slecht voor een Framework, meer code betekent meestal wel meer vrijheid.

Om je toch een beetje op weg te helpen met PHP Frameworks, zal ik een lijstje opstellen met Frameworks inclusief een kleine beschrijving:

1. CodeIgniter: CodeIgniter is een prachtig all-round framework, dat gebruik maakt van het MVC pattern. De extreem goede documentatie maakt het echt een genoegen om mee te werken.
2. CakePHP: Nog zo’n all-round Framework, die ook gebruik maakt het MVC Pattern. Ook wel aardig gedocumenteerd.
3. Zend Framework: En nog zo’n zelfde Framework, maar dan van het grote Zend.

Waarschijnlijk heb ik je wel een beetje overtuigd, maar misschien ben je zelfs zo enthousiast dat je gelijk zelf een Framework wil gaan maken. Dat raad ik je helaas af. De meeste veelgebruikte Frameworks zijn door professionele teams gebouwd en de PHP-wereld zit helaas al aardig vol met Frameworks.

Probeer dus eerst echt andere Frameworks te leren kennen. Geloof me, PHP is nog nooit zo leuk geweest als met een Framework!