PHP: Klassen

Deel 1: De basis

Deel 1: De basis

Deel 2: Basis uitbreiding

Deel 3: Klassen in praktijk 1

Deel 4: Klassen in praktijk 2

Introductie

Je vorige site in php werd op een gegeven moment een grote hooiberg. Overal stond code, je wist niet meer waar je moest zoeken. Aanpassingen waren nauwelijks mogelijk, en eigenlijk stond heel veel dubbel in je website, maar net weer een tikkie anders. Deze keer wil je het beter aanpakken, maar hoe?

Hiervoor kun je klassen gebruiken, waarmee je een structuur aanbrengt in je site. Je krijgt aparte klassen voor elk aparte onderdeel, hierbij kun je denken aan klassen voor je database, de gebruiker, de taal, error-handling, het systeem, de layout, etc...

In dit deel van de tutorial ga ik uitleggen hoe klassen globaal in elkaar zitten.

Herhaling

Even een korte herhaling. Enige basis-kennis is wel vereist.

Variabele

Een plek in het geheugen waarin je informatie kunt opslaan. Alle variabelen starten in php met een $, gevolgt door een naam: $leeftijd. Een variabele definieer je zo:

$leeftijd = 15;

Functies

Stukjes code die herhaaldelijk in je website terugkomen kun je in functies stoppen, zodat je website compacter en overzichtelijker wordt.

Functies zijn zo te gebruiken:

<?php
function tel_op($a, $b) {
$c = $a + $b;
return $c;
}
$resultaat = tel_op(4, 6);
?>

Benodigde functies en taal-constructies

echo: schrijf iets naar het scherm

Opmerkingen

1) Deze tut is gemaakt voor PHP 5, en waarschijnlijk werken de voorbeelden ook in PHP 6. Commentaar voor PHP 4 is onderaan te vinden!

2) Als in meer situaties, zijn klassen lastig om uit te leggen, je moet het gaan snappen aan de hand van praktische voorbeelden. Hier geef ik er dus ook een paar van. De beste leermethode is altijd nog de code die wordt gegeven overtypen, niet kopieren en plakken!

Klassen

Klassen bestaan uit een aantal basis-onderdelen, die net in de herhaling besproken zijn.

Dit zijn:

- Klasse-variabelen

- Klasse-functies

Voorbeeld

<?php
class persoon { // <-- je opent hier de klasse
  var $leeftijd; // <-- de klasse-variabelen
  var $kleur_ogen;
  var $naam;

  function __construct() { // <-- de functie __construct()
	  $this->leeftijd = 35; // bij $this-> hoef je bij de variabele geen $ meer neer te zetten!
	  $this->kleur_ogen = 'blauw';
	  $this->naam = 'Piet';
  }

}

$persoon = new persoon(); // creëer een nieuwe instantie van de klasse
?>

Zie hierboven. Je hebt een klasse genaamd 'persoon', met de eigenschappen leeftijd, kleur van de ogen, en de naam.

De functies __construct() en __destruct()

Deze 2 functies zijn speciaal. Alles wat je in de __construct zet, wordt uitgevoerd als je een nieuwe instantie van de klasse maakt, dus bij $persoon = new persoon();

Het omgekeerde is de __destruct(), die word uitgevoerd als de klasse gewist wordt. Dit kan bijvoorbeeld doordat je in bovenstaand geval $persoon unset, of doordat het einde van het document is bereikt.

Deze 2 functies hoeven niet per se gebruikt te worden, je kunt ze ook gewoon weglaten. Dan gebeurt er niets bij het maken of wissen van de instantie van de klasse.

Let op de 2 lage streepjes, _! Die horen erbij!

<?php
class persoon {
  var $leeftijd;
  var $kleur_ogen;
  var $naam;
  var $inLeven;

  function __construct() {
	  $this->leeftijd = 35;
	  $this->kleur_ogen = 'blauw';
	  $this->naam = 'Piet';
	  $this->inLeven = TRUE;
	  echo($name.' is geboren! =) ');
  }

  function __destruct() {
	  $this->inLeven = FALSE;
	  echo($name.' is overleden! =( ');
  }
}

$persoon = new persoon();
unset($persoon);
?>

Uitleg over de variabele $this komt later.

Eigen functies

Natuurlijk kunnen we hier nog weinig mee. We gaan er ook even voor zorgen dat Piet kan vallen. We maken er dus een functie val() bij.

<?php
class persoon {
  var $leeftijd;
  var $kleur_ogen;
  var $naam;
  var $inLeven;

  function __construct() {
	  $this->leeftijd = 35;
	  $this->kleur_ogen = 'blauw';
	  $this->naam = 'Piet';
	  $this->inLeven = TRUE;
	  echo($name.' is geboren! =) ');
  }

  function __destruct() {
	  $this->inLeven = FALSE;
	  echo($name.' is overleden! =( ');
  }

function val() {
	echo('Moest dat nou? Dat doet zeer!');
}
}
$persoon = new persoon();
$persoon->val(); // <-- laat het persoon vallen!
unset($persoon);
?>

Hier staat de eigen functie val() onder de construct en destruct, omdat ik dat gewend ben. Als je het echter logischer vind om de destruct helemaal onderaan te zetten kan dat ook. Anders gezegd: je bent helemaal vrij in welke volgorde je de functies zet.

Parameters

Het is natuurlijk niet logisch dat ons persoon altijd Piet heet. Daar gaan we ook wat aan doen. Net als bij gewone functies, kun je bij klasse-functies ook parameters meegeven. Dit kan dus ook in de construct en destruct.

<?php
class persoon {
  var $leeftijd;
  var $kleur_ogen;
  var $naam;
  var $inLeven;

  function __construct($age, $colour_eyes, $name) {
	  $this->leeftijd = $age;
	  $this->kleur_ogen = $colour_eyes;
	  $this->naam = $name;
	  $this->inLeven = TRUE;
	  echo($name.' is geboren! =) ');
}

function __destruct() {
	$this->inLeven = FALSE;
	echo($name.' is overleden! =( ');
}

function val() {
	echo('Moest dat nou? Dat doet zeer!');
}
}

$persoon = new persoon(35, 'blauw', 'Piet');
$persoon->val();
unset($persoon);
?>

De parameters van de construct zijn expres in het engels, om het verschil te benadrukken. Je kunt de eerste bijvoorbeeld ook gewoon $leeftijd noemen, maar dat is dan een andere variabele dan $this->leeftijd.

Voorbeeld

<?php

class dier {
  var $naam;

  function __construct() {
	  $this->naam = 'Bassie';
}

function iets($naam) {
	echo($this->naam); // Bassie
	echo($naam); // Adriaan
}
}

$dier = new dier();
$dier->iets('Adriaan');
?>

Variabelen en functies benaderen

Je

hebt vast en zeker al het woordje $this opgemerkt. Misschien heb je ook al eens gemerkt dat als je $this gebruikt buiten een klasse, dat dan een fatale foutmelding wordt gegeven. Dit komt omdat $this een gereserveerde variabele is. Deze wordt gebruikt binnen een klasse, om de variabelen en functies binnen diezelfde instantie van de klasse te benaderen.

Dit kun je echter ook van buitenaf doen. Dit heb je ook al eerder gezien, bij $persoon->val();. Hier breiden we het nog iets uit:

<?php
class persoon {
  var $leeftijd;
  var $kleur_ogen;
  var $naam;
  var $inLeven;

  function __construct($age, $colour_eyes, $name) {
	  $this->leeftijd = $age;
	  $this->kleur_ogen = $colour_eyes;
	  $this->naam = $name;
	  $this->inLeven = TRUE;
	  echo($name.' is geboren! =) ');
}

function val() {
	echo('Moest dat nou? Dat doet zeer!');
	$this->naarZiekenhuis();
}

function eet() {
	echo('Hmm lekker!');
}

function naarZiekenhuis() {
	echo('Een gebroken been zeker?');
}
}
$persoon = new persoon(15, 'bruin', 'Kees');
$persoon->eet();
$persoon->val();

echo('Mijn persoon\'s naam is: '.$persoon->naam);
$persoon->naam = 'Jan';
echo('Mijn persoon\'s naam is nu: '.$persoon->naam);
?>

Je maakt dus eerst een persoon, daarna gaat hij eten, waarna hij valt, en naar het ziekenhuis moet! Ik heb hier de destruct even weggelaten.

Het pijltje geeft aan dat $persoon een klasse is, en dat eet() een van zijn functies is, evenals dat naam een van zijn variabelen is.

Meerdere instanties

<?php
class persoon {
  var $leeftijd;
  var $kleur_ogen;
  var $naam;
  var $inLeven;

  function __construct($age, $colour_eyes, $name) {
	$this->leeftijd = $age;
	$this->kleur_ogen = $colour_eyes;
	$this->naam = $name;
	$this->inLeven = TRUE;
	echo($name.' is geboren! =) ');
}

function eet() {
	echo('Hmm lekker!');
}

function val() {
	echo('Moest dat nou? Dat doet zeer!');
}
}
$persoon1 = new persoon(15, 'bruin', 'Kees');
$persoon1->eet();

$persoon2 = new persoon(28, 'groen', 'Jan');
$persoon2->val();

$persoon3 = new persoon(35, 'blauw', 'Piet');
$persoon3->eet();
$persoon3->val();

echo($persoon1->naam); // Kees
echo($persoon3->naam); // Piet
?>

In bovenstaande code hebben we 3 instanties van dezelfde klasse. Dit is dus een praktisch voordeel van klassen: je kunt dezelfde code meerdere keren los van elkaar gebruiken. De klassen hebben onderling niets met elkaar te maken, of je moet dat zelf in gaan stellen.

PHP 4

In PHP 4 heb je geen constructors, en geen destructors (__construct() & __destruct()).

Je kunt deze echter wel nabootsen. In PHP 4 wordt eerst gekeken of er een functie is die dezelfde naam heeft als de klasse. Deze wordt dan uitgevoerd als constructor! Een destructor zit niet in het systeem, die moet je zelf aanroepen.

Voorbeeld

Deze 2 zijn hetzelfde, in verschillende php-versies:

PHP 5:

class voorbeeld {
function __construct() {
	echo('construct');
}

function __destruct() {
	echo('destruct');
}
}
$voorbeeld = new voorbeeld();//verdere code met voorbeeld

PHP 4:

class voorbeeld {
function voorbeeld() {
	echo('construct');
}

function __destruct() {
	echo('destruct');
}
}
$voorbeeld = new voorbeeld();
//verdere code met voorbeeld
$voorbeeld->__destruct();

Om sites die geschreven zijn in PHP 4 ook te laten werken in PHP 5, werkt het 2e voorbeeld ook in PHP 5. De parser kijkt eerst of er een __construct() is, en daarna, als __construct NIET gevonden is, of er een voorbeeld() is.

Einde deel 1

Dit was deel 1 van deze tutorial. Voor je met deel 2 begint is het handig om met dit deel nog wat te oefenen.

Beoordelingen, correcties en tips zijn welkom, dit was mijn eerste tutorial!

Bewerkt: 9 augustus 200915 jaren door marcootje

Nette tut! Ik ben niet goed in php, maar dit wist ik eigenlijk wel, ziet er goed uit, ook dat je nog even php 4 en 5 vergeleken hebt vind ik handig.

Misschien handig om er bij te zetten of dit script ook gaat werken op PHP 6.

Ik weet niet of het gaat werken met PHP 6.

In deze deel 1 heb ik nog om variabelen te bepalen het woordje 'var' gebruikt, wat in PHP 5 eigenlijk niet meer mag (kwam ik gisteren achter). Maargoed, voor een deel 1 is 'var' wat makkelijker.

De scripts in deel 2 zullen denk ik met meer zekerheid in PHP 6 werken.

Ik weet niet of het gaat werken met PHP 6.

In deze deel 1 heb ik nog om variabelen te bepalen het woordje 'var' gebruikt, wat in PHP 5 eigenlijk niet meer mag (kwam ik gisteren achter). Maargoed, voor een deel 1 is 'var' wat makkelijker.

De scripts in deel 2 zullen denk ik met meer zekerheid in PHP 6 werken.

Minor changes in PHP 6 zullen MySQL support changes worden, dus de kans dat het compatibel is met PHP 6 is redelijk groot.

aangepast

Mooie tutorial! Misschien ook handig om wat echte voorbeelden te geven zoals waar je het nou zal gebruiken in je site. En als je echt goed wilt werken en netjes wilt zijn kan je beter een framework gebruiken IMO .

Goede tutorial !

voorbeelden komen in deel 3

deel 2 is zojuist online gezet!

verder heb ik nog nooit met een framework gewerkt, maar ik vind het idee van een framework een beetje raar... ik werk liever met mijn eigen systeem, dan weet ik tenminste wat er precies gebeurd.

Sommige frameworks kunnen bij projecten handig te pas komen, zoals een online vertolker. Daarvoor kan men VoicePHP gebruiken, ik heb hun gehele documentatie doorgenomen, maar ik heb er van kunnen vernemen dat het framework nog in ontwikkeling is.

Kan er natuurlijk ook naast zitten.[/font]