Sinds Augustus lijken veel Internet Explorer gebruikers (voor zowel 6 als) over te stappen op Firefox. Echter, als je niet naar de versies kijkt heeft Internet Explorer nog steeds een voorsprong van 12 procent op Firefox.

In Nederland zijn de aantallen echter anders dan het gemiddelde, Internet Explorer wordt hier nog veel meer gebruikt dan Firefox.

De eerste release bevat meer snelheid, gebruiksvriendelijkheid en veiligheid maar support voor Mac of Linux blijft voorlopig uit (al zal dat niet lang op zich laten wachten). Kortom wie de browser weer eens start, kan vrijwel gelijk de nieuwe updates binnenhalen.

Wat betreft de webstandaarden scoort Google Chrome 79 op 100 met de Acid3 test, iets beter dan Firefox 3.0 en net iets slechter dan Opera 9.5.

Maar de belangrijkste vraag: of Google een fatsoenlijk marktaandeel kan gaan opbouwen?

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.

Als we binnen Google Labs de functie aan zetten kunnen we zelf middels een URL (in de settings van gmail) een gadget toevoegen. Allemaal leuk en aardig, maar nu moeten we natuurlijk wel gadgets zien te krijgen. Er zijn nog maar weinig gadgets speciaal voor gmail gemaakt (onderaan de blog volgen er een paar).

Het is mogelijk om de gadgets die je aan je Google startpagina kan toevoegen toe te voegen aan je Gmail. Hoe doen we dit? Ga naar je iGoogle en klik op nieuwe gadgets toevoegen. Zoek een gadget uit en klik op de titel. Er verschijnt een optie in beeld om de gadget te delen met anderen. Kopieer het link adres van de knop “deze gadget delen” en plak deze in het invoer veld voor Google gadgets. De URL dient nog wel wat bewerkt te worden, namelijk, het eerste stuk moet eraf geknipt worden. Als we knippen op de &url= houden we een url over naar een xml document.

Voorbeeldje, de volgende link is van de Buienradar, voor de pagina “Deze gadget delen”:
http://www.google.nl/ig/directory?type=gadgets&url=www.30minutelunchbreak.com/gadgets/weer.xml#

Nu knippen we hem af en wordt de URL:
www.30minutelunchbreak.com/gadgets/weer.xml

Deze gadget kunnen we toevoegen in ons Gmail account.

Nu werkt dit niet met alle gadgets in de iGoogle database, maar alleen met de simpelere. Echter denk ik , dat je google account redelijk te vullen is met het aantal gadgets wat hier te vinden is.

Enkele voorbeelden van gadgets die speciaal voor gmail gemaakt zijn:

Een takenlijstje:
http://mostlycloudy.net/~dnl2ba/subpages/gdir-test/tasklist.xml

Youtube video’s:
http://www.google.com/ig/modules/youtube_videos.xml

Mijnenveger:
http://gmail.minesweeper.vedelaar.nl/minesweeper.xml

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!

Met behulp van Windows Cloud moet het mogelijk zijn om applicaties, zoals Microsoft Office, op een server te draaien vanaf de browser van een client (de gebruiker van de applicatie). Volgens Steve Ballmer zal ondanks Windows Cloud de client nogsteeds gebruik maken van lokale software voor een snelle aanpassing. Windows Cloud zal vooral in openbare lokaties aanslaan, omdat je je eigen programma’s kan blijven gebruiken, ondanks dat het niet op de PC staat geïnstalleerd.

Bij vele mensen is bij het horen van het woord cloudcomputing niet bekend wat het nu exact betekend. Om hier alvast mee in te springen zeggen Engelse vaak “the cloud” terwijl ze “het internet” bedoelen. Het is dus eigenlijk een grote wolk waar je je zelf in bevind. De Nederlandse vertaling van “computing” is “computeren” waardoor als je de woordencombinaties samenvoegt je Internet computeren krijgt.

Cloudcomputing is een soort van het SaaS-computing (Software as a Service). Dat bekentend het op een afstand gebruiken van een software, die geïnstalleerd staat op een server. Zo is het voor ontwikkelaars en systeembeheerders zeer gemakkelijk om de software te updaten of te upgraden.

Ondanks de verwachte hoge prijs voor het cloudcomputing zal volgens Richard Stallman (oprichter van Free Software Foundation) zal het cloudcomputing een hype gaan worden. Stallman denkt dat vooral bedrijven zich met het cloudcomputing gaan bezighouden. Zo kunnen systeembeheerders van een bedrijf veel makkelijker het netwerk beheren, en alle bestanden van de werknemers staan centraal op 1 server. Mocht er een PC in een netwerk de geest geven, dan staan de documenten op de server.

Windows Cloud zal als kern het Hyper-V System van Microsoft hebben, en is gratis te downloaden. Voor deze software zal de desbetreffende server wel moeten draaien op Windows Server 2008