Variabelen in PHP
1. Wat is een variabele ?
2. Welke soort variabelen zijn er allemaal ?
3. boolean
4. integer
5. float
6. string
7. array
8. object
9. resource
10. NULL
Inleiding
Als beginner is het niet noodzakelijk dat je deze tutorial helemaal vanbuiten leert. Wat je moet weten is wat een variabele is, en hoe je het gebruikt. Je hoeft dus niet direct alle types van variabelen te kennen, dit kan je later nog leren wanneer je voldoende basis kent. In deze tutorial worden ook operatoren gebruikt.
1. Wat is een variabele ?
Een variabele kun je het beste zien als een doos waar je wat in kunt stoppen. Om alle verschillende dozen (variabelen) uit elkaar te houden, plakken we op elke doos een etiket met een omschrijving van wat er in de doos zit (elke variabele heeft een naam die omschrijft wat deze variabele 'onthoudt').
bijvoorbeeld:
de variabele mijngetal onthoud een geheel getal.
We kunnen de inhoud van deze doos (de waarde van de variabele) bekijken, of de inhoud van deze doos veranderen door deze met zijn naam aan te spreken. Als je een waarde van een variabele opvraagt of wilt veranderen, moet je deze variabele aanspreken met zijn naam, voorafgegaan door een $. Dit wil zoveel zeggen als "de waarde van".
Om een variabele een waarde te geven moet je aan deze variabele een waarde toekennen. Dit wordt een toekenning (assignment) genoemd. Een toekenning gebeurt als volgt:
<?php
$mijngetal = 10;
// nu heeft mijngetal de waarde 10
?>
Hiermee zeg je: "De waarde van mijngetal wordt 10".
Na afloop van de toekenning is de waarde van mijngetal gelijk aan 10.
Om een waarde op te vragen (bijvoorbeeld om deze af te drukken), doe je het volgende:
<?php
// we nemen aan dat mijngetal een waarde heeft door een eerdere toekenning
echo $mijngetal;
?>
Hiermee zeg je: "Druk de waarde van mijngetal af".
Het aantal verschillende variabelen in een PHP programma zal doorgaans niet al te groot zijn. Toch is het verstandig variabelen altijd een omschrijvende naam te geven - op deze manier kun je de verschillende variabelen, die elk een eigen waarde en betekenis hebben, uit elkaar houden.
 top
2. Welke soort variabelen zijn er allemaal ?
Er zijn verschillende soorten variabelen, te weten:
Enkelvoudige typen:
boolean,
integer,
float,
string,
Samengestelde typen:
array,
object,
Speciale typen:
resource,
NULL
We zullen al deze typen bespreken.
top
3. boolean
Een variabele van het type boolean kan slechts een van de twee waarden hebben: true (waar) of false (onwaar). Deze variabelen worden gebruikt om een uitspraak te doen over de (on)juistheid van een bepaald scenario.
Een boolse variabele een waarde geven gebeurt als volgt:
(expliciete toekenning)
<?php
$mijnboolean = false;
// mijnboolean heeft nu de waarde 'onwaar'
?>
(impliciete toekenning)
<?php
$mijngetal = 10;
$mijnboolean1 = ($mijngetal < 10);
$mijnboolean2 = ($mijngetal == 10);
$mijnboolean3 = ($mijngetal >= 10);
?>
Laten we dit laatste voorbeeld eens nader bekijken. Allereerst krijgt de variabele mijngetal de waarde 10. Vervolgens krijgen mijnboolean1, mijnboolean2 en mijnboolean3 achtereenvolgens een waarde, afhankelijk van de waarde van mijngetal.
PHP 'leest' alle assignments (toekenningen) van rechts naar links. Allereerst word het rechter deel (rechts van het = teken) bekeken. Er word gekeken of dat wat er staat korter geschreven kan worden. Op de tweede regel staat rechts van het = teken ($mijngetal < 10). De haken zorgen ervoor dat dit één geheel is. Hier staat de uitdrukking (ook wel uitspraak of statement genoemd) "mijngetal is kleiner dan 10". Allereerst zal $mijngetal vervangen worden door de waarde die de variabele mijngetal heeft. Dan staat er dus (10 < 10). Deze uitspraak kan nog korter geschreven worden - 10 zal nooit kleiner zijn dan 10, dus dit zal vereenvoudigd worden tot false (onwaar).
($mijngetal < 10) wordt dus verkort tot false - en dit is dus ook de waarde die mijnboolean1 krijgt.
Op de derde regel, rechts van het = teken staat ($mijngetal == 10). Met == wordt gecontroleerd of links en rechts (eventueel na vereenvoudiging) van dit teken twee gelijkwaardige dingen staan. mijngetal had de waarde 10, dus ($mijngetal == 10) kan vereenvoudigd worden tot (10 == 10). Deze uitspraak is 'waar' en wordt dus op zijn beurt weer vereenvoudigd tot true - deze laatste waarde wordt toegekend aan mijnboolean2.
De uitspraak rechts van het = teken op regel 4 wil zeggen "mijngetal is groter of gelijk aan 10" (oftewel ten minste 10). Deze uitspraak zal vereenvoudigd worden tot (10 >= 10) en daarna tot true.
Na afloop van het bovenstaande PHP blok zal mijngetal de waarde 10 hebben, mijnboolean1 de waarde false, mijnboolean2 de waarde true en mijnboolean3 de waarde true.
Wanneer je een boolse variabele afdrukt nadat je hier true of false aan hebt toegekend, zal er waarschijnlijk NIET true of false afgedrukt worden, maar 1 of 0 (of iets anders, maar niet letterlijk true of false). PHP beschouwt namelijk alles wat ongelijk is aan 0, "" (de lege string - zie strings) of NULL (speciaal type) als true en 0, "" of NULL als false. Na de volgende toekenningen zijn de waarden van de variabelen dus allemaal true:
<?php
$variabele1 = 1;
$variabele2 = "aap";
?>
Veel gemaakte fouten:
* = en == worden door elkaar gehaald
Zorg ervoor dat je = (voor toekenningen van waarden aan variabelen) en == (voor het vergelijken van de waarden van twee dingen) goed uit elkaar houdt!
* Toekeningen gebeuren zo, dat de waarde van de variabele eigenlijk true moet zijn, maar false is (of andersom).
* Aanhalingstekens om true en false
Wanneer je de volgende toekenning doet:
<?php
$boolean1 = "false";
?>
zal boolean1 de niet-lege string (zie strings) "false" bevatten en zal dus ook true zijn!
false en true zijn 'gereserveerde' woorden, die je in feite kan zien als 0, "" of NULL en "iets anders dan 0, "" of NULL".
top
4. integer
Een integer is kortweg gezegd een geheel getal. Het waardenbereik (togestane waarden) voor integers is -2147483648 t/m 2147483647, hierboven (of onder) zal het getal beschouwd worden als een float (maar je kan er mee blijven rekenen als ware het een integer). Toekenning van een (integer)waarde aan een variabele gebeurt op de volgende wijze:
<?php
$mijninteger = 10;
// nu heeft mijninteger de waarde 10
?>
Het standaard stelsel waarin we rekenen met integers is het decimale (10-tallige) stelsel. Om goed te begrijpen wat het 10-tallig stelsel eigenlijk inhoudt, het volgende voorbeeld:
Het getal 20318 is ook te schrijven als
8 * 10^0 + (lees: 8 keer 10 tot de macht 0 (is 8) plus)
1 * 10^1 + (lees: 1 keer 10 tot de macht 1 (is 10) plus)
3 * 10^2 + (lees: 3 keer 10 tot de macht 2 (is 300) plus)
0 * 10^3 + (lees: 0 keer 10 tot de macht 3 (is 0) plus)
2 * 10^4 (lees: 2 keer 10 tot de macht 4 (is 20000))
Hierbij lezen we het getal van rechts naar links. De verschillende karakters die in het decimale stelsel gebruikt mogen worden zijn 1,2,3,4,5,6,7,8,9,0 met hun gebruikelijke betekenis. Integer variabelen in PHP kunnen nog op twee andere manieren (in twee andere stelsels) geschreven worden: het octale (8-tallige) en het hexadecimale (16-tallige) stelsel.
Octale getallen worden vooraf gegaan door een 0. Dit 0-teken zorgt ervoor dat het getal herkend wordt als zijnde een octaal getal.
Voorbeeld:
<?php
$mijnoctaalgetal = 0123;
?>
Na afloop van het voorgaande programma heeft de integer mijnoctaalgetal de octale waarde 0123. Maar hoeveel is dit decimaal? We gaan rekenen (en beginnen hiermee weer aan het einde (de rechterkant) van het getal):
0123 =
3 * 8^0 + (lees: 3 keer 8 tot de macht 0 (is 3 * 1 = 3) plus)
2 * 8^1 + (lees: 2 keer 8 tot de macht 1 (is 2 * 8 = 16) plus)
1 * 8^2 (lees: 1 keer 8 tot de macht 2 (is 1 * 64 = 64))
0123 octaal is dus 3+16+64 = 83 decimaal.
De verschillende karakters die in het octale stelsel gebruikt mogen worden zijn 1,2,3,4,5,6,7,0
Zo is er ook nog het hexadecimale (16-tallige) stelsel.
Hexadecimale getallen worden vooraf gegaan door 0x.
Voorbeeld:
<?php
$mijnhex = 0x2B;
?>
Na afloop heeft de variabele mijnhex de waarde 2B.
De verschillende karakters die in het hexadecimale stelsel gebruikt mogen worden zijn 0 t/m 9 (net als bij het decimale stelsel, en ook de letters A (waarde 10 decimaal), B (waarde 11 decimaal), C (waarde 12 decimaal), D (waarde 13 decimaal), E (waarde 14 decimaal), F (waarde 15 decimaal).
mijnhex is dus decimaal:
0x2B =
B * 16 ^ 0 + (lees: 11 keer 16 tot de macht 0 (is 11 * 1 = 11) plus)
2 * 16 ^ 1 (lees: 2 keer 16 tot de macht 1 (is 2 * 16 = 32)
0x2B hexadecimaal is dus 11+32 = 43 decimaal.
Veel gemaakte fouten:
* Integerwaarden staan tussen (enkele of dubbele) aanhalingstekens
Wanneer je een toekenning van een integerwaarde aan een variabele verricht, zorg dan dat deze waarde NIET tussen aanhalingstekens staat (bijv. $mijnvar = "10";) anders zal PHP mijnvar beschouwen als een string, en niet als een integer. Ook in MySQL queries hoef je geen aanhalingstekens te zetten om een variabele van het type integer.
top
5. float
Een float (floating point number, ook wel double of real number genoemd) is een getal met 'cijfers achter de komma'. Meestal verkrijg je een variabele van het type float door een berekening (met bijvoorbeeld integers) die een breuk oplevert (de integer waarin het resultaat van deze berekening wordt opgeslagen wordt dan automatisch omgezet naar een float). Ook wanneer je rekent met bijvoorbeeld breuken zal het (tussen)resultaat van deze berekening opgeslagen worden als een float. Wanneer je breuken opslaat, zal deze breuk worden afgerond. Dit gebeurt omdat de geheugenruimte waarin de waarde van zo'n variabele wordt opgeslagen eindig is.
Voorbeeld:
<?php
$mijnfloat = 1/3;
?>
Na afloop van dit programma heeft mijnfloat de waarde 0.33333333333333. Dit is een benadering van het getal 1/3. Bij het rekenen met floats moet er heel goed worden gelet op hoe (tussen)resultaten worden afgerond, want berekeningen kunnen soms ogenschijnlijk rare antwoorden opleveren. Het is ook onverstandig om floats op gelijkheid te testen, omdat er altijd enige speling zit in de precisie. Je moet floats niet van begin tot eind lezen en er dan vanuit gaan dat je float-variabele precies die waarde heeft - de waarde van een floatvariabele is een benadering, en dient niet 'letterlijk' gelezen te worden.
In het volgende voorbeeld wordt gebruik gemaakt van de functie floor(). Deze functie rondt een float af naar het eerste gehele getal (integer) wat onder dit floatgetal zit.
Voorbeeld:
<?php
$resultaat = floor((0.1+0.5)*10);
?>
Je zou verwachten dat de variabele resultaat nu altijd de waarde 6 zal hebben, maar soms is de waarde van resultaat gelijk aan 5 omdat 0.1 en 0.5 nooit helemaal precies zijn. Het kan dus gebeuren dat (0.1+0.5)*10 gelijk is aan 5.9999999..., en de functie floor() maakt hier 5 van.
Veel gemaakte fouten:
-
top
6. string
Een string bestaat uit een reeks van nul of meer karakters, omringd door enkele quotes (') of dubbele quotes (") (er is ook nog een derde schrijfwijze (heredoc) waar hier verder niet op ingegaan zal worden).
Voorbeeld:
<?php
$mijnstring = "Dit is een text.";
echo $mijnstring;
?>
Na afloop van dit programma zal de string-variabele mijnstring de waarde "Dit is een text." bevatten. Met de echo-regel zal de string worden afgedrukt, en zal het volgende op het scherm komen te staan:
Dit is een text.
Binnen een string mogen de karakters ' en " ook voorkomen, maar deze moeten dan van hun normale betekenis (namelijk het openen of sluiten van een string) ontdaan worden - ze moeten als gewone tekst gelezen worden. Dit doe je door het 'escapen' van een ' of ". Om aan te geven dat een bepaald karakter anders dan in de normale betekenis ervan gelezen moet worden, escape je dit karakter, door er een (backslash) voor te zetten. Zo zijn er nog een aantal tekens die ge-escaped kunnen worden:
\ Op deze manier kun je een backslash in een string zetten
Dit geescapete karakter zorgt voor een regelovergang (in je broncode)
Dit geescapete karakter zorgt voor een regelovergang (vergelijkbaar met een 'enter')
Dit geescapete karakter zorgt voor een tab in je code
$ Hiermee kun je het dollarteken printen ($ staat normaal vòòr een variabele)
' Hiermee kun je een single quote printen
" Hiermee kun je een double quote printen
De enige karakters die geescaped wordt in een single-quoted string, zijn de single quote (') zelf, en de backslash (). Andere geescapete karakters worden gewoon uitgeschreven.
Het volgende programma:
<?php
echo '\
$
" '';
?>
Drukt het volgende af:
$
" '
Ook variabelen worden niet uitgeschreven in een single-quoted string.
Het programma:
<?php
$mijnvar = 10;
echo 'mijnvar heeft de waarde: $mijnvar';
?>
Zal het volgende afdrukken:
mijnvar heeft de waarde: $mijnvar
String die afgesloten zijn met dubbele quotes zullen wel alle geescapete karakters verwerken en waarden van variabelen uitschrijven. Vergelijk met het vorige voorbeeld:
<?php
$mijnvar = 10;
echo "mijnvar heeft de waarde: $mijnvar";
?>
Levert:
mijnvar heeft de waarde: 10
Om (variabelen van het type) tekst en (andere) variabelen te scheiden kun je de operator (het teken) '.' gebruiken. Met '.' (een punt) kun je twee of meer strings, of een string en een ander ding aan elkaar lijmen. Het geheel zal altijd gelezen worden als een string. Dit automatisch omzetten van een type naar een ander type wordt een typecast genoemd. Wanneer er bijvoorbeeld gerekend wordt met integers, en door deling ontstaan er getallen met cijfers achter de komma, zullen deze integervariabelen ook automatisch naar het type float ge-typecast worden.
Het volgende programma met een single-quoted string zal dus wel werken:
<?php
$mijnvar = 10;
echo 'mijnvar heeft de waarde: '.$mijnvar;
?>
Levert:
mijnvar heeft de waarde: 10
Veel gemaakte fouten:
* Strings zijn niet afgesloten, teveel of te weinig, '.' vergeten
Wanneer je strings langer en moeilijker worden, neemt de kans dat een van bovenstaande dingen gebeurt toe. Om dit soort fouten te voorkomen en je code leesbaar te houden, kun je beter dat wat je af wilt drukken op verschillende regels (met meerdere echo's) in je code zetten.
top
7. array
Het array is een samengesteld type: het kan uit een of meerdere typen bestaan. Een array is (in zijn eenvoudigste vorm) het beste te vergelijken met een wiskundige functie (bijvoorbeeld die van een parabool). Je stopt er een waarde in (deze waarde wordt ook wel 'key' of 'index' genoemd), en er wordt een waarde geretourneerd (deze waarde wordt ook wel 'value' genoemd). Het enige verschil met een functie is dat je zelf alle 'uitkomsten' die je gebruikt moet opgeven. Keys mogen strings zijn, of niet-negatieve nummers (integers). Values mogen elk type hebben.
Bij het aanmaken van een array (het definiëren van een variabele van het type array) kun je twee dingen doen: Je kan het array initieel leeg laten, of je kan het een (aantal) beginwaarde(n) geven.
Een leeg array aanmaken doe je als volgt:
<?php
$mijnarray = array();
?>
Na afloop is mijnarray een variabele van het type array, en kun je hier arraybewerkingen (functies die op arrays werken) op uitvoeren.
Een array kun je ook een aantal beginwaarden geven:
<?php
$mijnarray = array(1,2,4,8,16);
?>
LET OP
Het rijtje 1,2,4,8,16 zijn allen waarden (values). De bijbehorende keys zijn hier niet vermeld. Wanneer je een array op deze manier aanmaakt, zullen de keys integers zijn, startende bij 0. Na afloop van het bovenstaande programma kun je de waarden van mijnarray opvragen / afdrukken met:
<?php
echo $mijnarray[0]; // levert 1
echo $mijnarray[1]; // levert 2
echo $mijnarray[2]; // levert 4
echo $mijnarray[3]; // levert 8
?>
Je moet de eerste regel van het bovenstaande programma als volgt lezen:
"Druk de waarde die op positie 0 (eerste plaats) van het array mijnarray staat af"
Op index 0 (key 0, de eerste plaats) van het array staat het getal 1, en dit getal wordt afgedrukt.
Op deze manier kun je de rest van de arraywaarden afdrukken (index 1 levert waarde 2, index 2 levert waarde 4, index 3 levert waarde 8).
Stel dat je op de eerste vrije plaats (vijfde plaats, key of index 4) de waarde 16 wilt toevoegen, maar je array is al aangemaakt. Je kunt nu op twee manieren op deze plaats een waarde toevoegen: door een toekenning van een waarde aan het array met key, of (wanneer je weet wat de eerste vrije plaats in je array is) zonder de vermelding van een key. De volgende twee fragmenten doen hetzelfde:
<?php
// aanname: mijnarray is aangemaakt zoals in bovenstaande voorbeeld
$mijnarray[4] = 16;
?>
of
<?php
// aanname: mijnarray is aangemaakt zoals in bovenstaande voorbeeld
$mijnarray[] = 16;
?>
Het eerste programma zet op index 4 (vijfde positie in het array) de waarde 16. Mocht er al een waarde bestaan voor deze index, zal deze overschreven worden. Het tweede programma zet op de eerste vrije index-plaats de waarde 16. De eerste vrije index-plaats wordt bepaald door de waarden van alle integer keys te pakken, hier de grootste van de nemen, en er hierna één bij op te tellen.
Nu kan het voorkomen dat je bij aanmaak van een array hier een aantal waarden in wilt zetten, alleen je wilt zelf je indices (keys) specificeren. Je kan dan expliciet aangeven op welke index (key) een waarde (value) moet komen te staan. Dit doe je (bij het aanmaken van het array) met de karakters =>.
Voorbeeld:
<?php
$mijnarray = array(1=>"een", 2=>"twee", 3=>"drie");
?>
Na afloop heeft $mijnarray[1] de waarde (string) "een", $mijnarray[2] de waarde "twee" en $mijnarray[3] de waarde "drie". Ook kun je met => eenvoudig aangeven bij welk getal een index moet beginnen.
Voorbeeld:
<?php
$maanden = array(1=>"jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec");
?>
Nu heeft $maanden[7] (de zevende maand van het jaar) de waarde "jul" (niet "aug" !, je begint immers bij 1 met nummeren in plaats van 0).
LET OP
Zoals al eerder gezegd mogen de indexes van arrays ook strings zijn. Als je een stringwaarde als index gebruikt, zorg dan dat je enkele of dubbele quotes om deze string zet. Wanneer je dit niet doet, zal je programma het waarschijnlijk wel doen, maar dit is niet 'correct' (en het zal ook 'Mededelingen' opleveren wanneer je error_reporting(E_ALL); gebruikt), omdat PHP de key als 'ongedefinieerde constante' ziet, en niet als string. Altijd quotes gebruiken dus!
Voorbeeld:
<?php
$leeftijden = array("Jan"=>10, "Piet"=>15, "Klaas"=>20);
echo $leeftijden["Jan"]; // goed - drukt het getal 10 af
echo $leeftijden[Piet]; // slordig - drukt met een portie geluk 15 af
?>
Ook bestaat de mogelijkheid om arrays in arrays te definiëren. Dit werkt in principe hetzelfde als een gewoon (één-dimensionaal) array.
In het volgende voorbeeld gaan we gegevens van een verenigingslid in een array zetten. De key van het array ledengegevens is een lidnummer, de 'sub-arrays' bevatten gegevens behorend bij dit lidnummer.
Voorbeeld:
<?php
$ledengegevens = array();
$ledengegevens[1]["naam"] = "Jan";
$ledengegevens[1]["adres"] = "Marktplein 10";
$ledengegevens[2] = array("naam" => "Piet", "adres" => "Ringbaan 12");
?>
Hierboven staan twee verschillende manieren om hetzelfde te doen. We gaan regel voor regel bekijken wat er gebeurt. Op regel 1 word het array ledengegevens aangemaakt. Op de tweede regel word op de eerste plaats (index 1) in het array ledengegevens een veld "naam" toegevoegd, met als waarde "Jan". Dit zorgt ervoor dat in het array ledengegevens op index 1 een nieuw array wordt gemaakt, met index "naam" en waarde "Jan".
Na de eerste twee regels ziet je array ledengegevens er dus als volgt uit:
array(
1 => array("naam" => "Jan")
)
Op de derde regel word er op index 1 van het ledengegevens-array een veld "adres" toegevoegd, met als waarde "Marktplein 10". Omdat er al een sub-array is aangemaakt, is dit niet opnieuw nodig - PHP voegt gewoon dit key-value paar toe in het bestaande sub-array. Het array ledengegevens ziet er nu als volgt uit:
array(
1 => array("naam" => "Jan", "adres" => "Marktplein 10")
)
Op de vierde en laatste regel van het programma worden in één keer de naam- en adres-waarden op een nieuwe index (2) toegevoegd aan het ledengegevens-array. Het ledengegevens-array ziet er nu als volgt uit:
array(
1 => array("naam" => "Jan", "adres" => "Marktplein 10"),
2 => array("naam" => "Piet", "adres" => "Ringbaan 12")
)
Gegevens opvragen kan nu als volgt:
<?php
echo $ledengegevens[1]["naam"]; // levert "Jan"
echo $ledengegevens[2]["adres"]; // levert "Ringbaan 12"
?>
In principe kun je op elke nieuwe index allemaal verschillende dingen zetten, je hoeft je niet aan een vast uiterlijk te houden. Meestal is het echter de bedoeling van een array om informatie (tijdelijk) gestructureerd (op eenzelfde wijze) op te slaan. Het volgende voorbeeld zal wel werken, maar is uit oogpunt van 'gestructureerd informatie opslaan' ongeschikt:
<?php
$zooi = array();
$zooi[2] = 5; // op index 2 staat waarde 5
$zooi["bla"] = "dibla"; // op index "bla" staat waarde "dibla"
$zooi[] = "boe!"// op de eerstvolgende vrije index (3) staat de waarde "boe!"
?>
Veel gemaakte fouten:
* Geen enkele/dubbele quotes om je keys van het type string.
Dit gaat meestal nog wel goed, alleen wanneer je error_reporting(E_ALL); ergens voor het gebruik van arrays in je code stopt zal het waarschuwingen regenen. Altijd quotes gebruiken bij keys van het type string!
top
8. object
Een aparte manier van programmeren is de object-georiënteerde aanpak (ook wel OOP - object oriented prgramming - genoemd). Hierbij werk je niet meer (direct) met variabelen en typen meer, alleen nog maar met objecten van een bepaalde klasse. Een klasse is een zelfgedefinieerd type - het is een blauwdruk van een object.
Het definieren van een klasse
Je kunt een klasse op de volgende wijze aanmaken:
class <klassenaam> {
<lijst van klasse variabelen>
<lijst van klasse functies>
}
Bijvoorbeeld (all begrippen worden hieronder uitgelegd):
<?php
class mijnklasse {
// zet hier je klasse-variabelen
var $text;
// zet hier je klasse-functies
// constructor
function mijnklasse() {
$this->text = "standaard text";
}
// getter
function gettext() {
return $this->text;
}
// setter
function settext($bla) {
$this->text = $bla;
}
}
?>
Elke klasse-variabele moet vooraf gegaan worden door var. De variabelen binnen een klasse mogen in principe van elk type zijn (ze kunnen zelf ook weer een object van een klasse zijn). Variabelen binnen een klasse zijn in principe niet rechtstreeks te benaderen - TENZIJ je de precieze naam van een variabele weet, maar dat is meestal niet het geval bij classes. Classes worden meestal aangeleverd als 'black boxes' met een lijst van functies die beschrijven hoe je met een object (van een klasse) kan communiceren. Voor alle initialiseer-, wijzig-, opslag-, verwijder- en afdrukoperaties van klasse-variabelen moeten functies geschreven worden. Omdat op voorhand niet bekend is hoe een object van een bepaalde klasse heet, word het object van een klasse met $this aangesproken binnen de klasse-functies. Let erop dat variabelen binnen een klasse benaderd worden met $this->variabelenaam, en niet met $this->$variabelenaam.
Zoals eerder gezegd moeten voor het veranderen, opvragen, ... van variabelen van een object functies geschreven worden. Dit worden ook wel 'getters' (voor het opvragen van een variabele) en 'setters' (voor het veranderen van een waarde van een variabele) genoemd. Ook heb je nog functies met een speciale betekenis. Wanneer je een functie definieert die dezelfde naam heeft als de klasse (deze functie word ook wel 'constructor' genoemd) zal deze functie bij de creatie van een object aangeroepen worden. De functie 'maakt' (construeert) als het ware het object. Constructors worden gebruikt om klasse-variabelen een initiële waarde te geven. De functie mijnklasse() is een voorbeeld van een constructor. Deze functie geeft bij de creatie van een object de bijbehorende variabele text de waarde "standaard text".
In het bovenstaande voorbeeld staat de functie gettext(). Hiermee wordt de tekst die in de string-variabele text staat geretourneerd. Dit is een voorbeeld van een getter. Met de functie settext() kun je de waarde van text veranderen. Dit is dus een setter.
Het aanmaken van een object van een bepaalde klasse gebeurt als volgt (let op het woord new):
<?php
$myclass = new mijnklasse;
?>
Na afloop van dit programma kan de variabele (het object) myclass alle operaties die voor de klasse mijnklasse zijn gedefinieerd uitvoeren. Om de tekst text af te drukken die in dit object zit, haal je de waarde van text op, en druk je deze af:
<?php
echo $myclass->gettext(); // drukt "standaard text" af
?>
Je kan nu op twee manieren de waarde van text binnen het object myclass aanpassen:
(netjes) via de setter settext():
<?php
// aanname myclass is een object van de klasse mijnklasse
$myclass->settext("some_text"); // nu heeft text in het object myclass de waarde "some_text"
?>
(slordig) rechtstreeks:
<?php
// aanname myclass is een object van de klasse mijnklasse
$myclass->text = "another_text"; // nu heeft text in het object myclass de waarde "another_text"
?>
Er zal hier niet verder ingegaan worden op objecten en classes. Wanneer je meer wilt weten over OOP, er zijn zeer veel boeken en tutorials over dit onderwerp beschikbaar. Voor meer informatie over OOP in PHP zie http://www.php.net/manual/en/language.oop.php.
Veel gemaakte fouten:
* $object->$variabele (fout) in plaats van $object->variabele (goed).
* variabelen rechtstreeks benaderen ipv via de voorgeschreven functies.
top
9. resource
php.net: "Een resource is een speciale variabele, die een verwijzing naar een externe bron bevat. Resources worden gemaakt en gebruikt door speciale functies."
Externe bronnen kunnen zijn: een bestand, een database, het canvas (tekenvlak) van een plaatje etc.
Voorbeeld:
<?php
$host = "localhost";
$user = "username";
$pass = "password";
$connectie = mysql_connect($host, $user, $pass);
?>
In dit voorbeeld word (getracht) een connectie op te bouwen met een database. De variabele connectie is een voorbeeld van een resource. De variabele is wanneer de connectiepoging succesvol is een 'MySQL link identifier'. Als de connectiepoging faalt, heeft connectie de waarde false.
Resources zijn meestal het resultaat van (worden gecreëerd door) een functieaanroep - je zult zelden zelf variabelen van het type resource definiëren.
top
10. NULL
php.net: "De speciale NULL-waarde geeft weer dat een variabele geen waarde heeft. NULL is de enige waarde van het type NULL.
Een variabele is van het type NULL wanneer:
- het de constante waarde NULL toegewezen heeft gekregen
- deze nog geen waarde heeft (gekregen)
- de variabele van zijn waarde is ontdaan met behulp van de functie unset()"
top
zie ook:
http://www.php.net/manual/en/language.types.php
|
Wat is jouw favoriete javascript framework? (S: 18, R: 2)
(4.04) 