OOP vragen
Ik ben bezig met OOP leren met het PHP Superboek, alleen ik kom een paar vraagjes tegen die niet staan uitgelegd (of ik snap de uitleg niet).
Mijn eerste vraag staat op blz 72 en 73 van het hierboven genoemde boek.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
class clsBD {
var $M_conDB;
const dbName = "MyDB";
//constructor
function __construct($_p_sHost, $p_sUser, $p_sPassword) {
// Open a regular connection
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
}
?>
class clsBD {
var $M_conDB;
const dbName = "MyDB";
//constructor
function __construct($_p_sHost, $p_sUser, $p_sPassword) {
// Open a regular connection
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
}
?>
Maar eerste vraag is over: var en const. Ik heb mensen horen praten dat de variabele in een class niet meer aangemaakt moet worden, en wat is 'const dbName' verschil tussen $dbName?
Verder vind ik de regel met $this raar (of ik snap het niet helemaal). Wat doet hij presies met de regel? de regel uitvoeren of opslaan in m_conDB? en waarom moet de regel eronder niet ook met $this->m_conDB staan?
Mijn andere vraag gaat over iets wat verder staat:
Wat betekend dat? als de waarde niet leeg is?
$blaat is een attribuut van de klasse en is variabel. En is public of wel voor alles en iedereen te gebruiken. Alle atributen van een klasse zouden private moeten zijn als je PHP5 gebruik.
Code (php)
1
2
3
2
3
<?php
const blaat = 'blaat';
?>
const blaat = 'blaat';
?>
blaat is een constante en kan dus niet meer worden veranderd.
vraag 2:
$this is het object van de klasse. $this zou je kunnen vergelijken met:
Code (php)
1
2
3
2
3
<?php
$this = new MijnKlasse;
?>
$this = new MijnKlasse;
?>
Alleen kun je met de $this in de klasse alle attributen en methodes benaderen ook al zijn ze private.
In PHP4 is de $this (van de code hierboven) een kopie en in PHP5 is dit een referentie.
vraag 3:
We gaan niet in de if als $this->m_conDB gelijk is aan:
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
<?php
$this->m_conDB = false; //of
$this->m_conDB = ''; //of
$this->m_conDB = array(); //of
$this->m_conDB = null; //of
$this->m_conDB = 0; //of
?>
$this->m_conDB = false; //of
$this->m_conDB = ''; //of
$this->m_conDB = array(); //of
$this->m_conDB = null; //of
$this->m_conDB = 0; //of
?>
Alle waardes zijn leeg ofwel hebben hetzelfde gedrag als boolean false in een expressie.
Gewijzigd op 01/01/1970 01:00:00 door Martijn B
1) var en const
Je kunt een variabele in een class prima aanmaken, waarom niet? Met const definieer je een klasse-constante. Vergelijk hem maar met een define in PHP.
2) die regel met $this is ook raar, want er staat een spelfout in. De hoofdletter M is ineens een kleine letter m geworden. Het keyword this verwijst altijd naar het huidige object, in dit geval de klasse zelf. De functie __construct wordt automatisch uitgevoerd als je een nieuwe klasse aanmaakt. In dit geval maakt hij dus verbinding met je DB.
3) Je kunt de Scope Resolution Operator (dat zijn die dubbele dubbele puntjes) gewoon binnen een klasse gebruiken, dus met regel 9 is er niets aan de hand.
4) $this->m_conDB bevat de returnwaarde van mysql_connect (regel 8)
Als die connectie fout gaat, retourneert mysql_connect de waarde false. Daar is die if dus voor.
Quote:
3) Je kunt de Scope Resolution Operator (dat zijn die dubbele dubbele puntjes) gewoon binnen een klasse gebruiken, dus met regel 9 is er niets aan de hand.
Paamayim Nekudotayim veel betere naam :D
Code (php)
1
2
3
4
2
3
4
<?php
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
?>
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
?>
waarom niet:
Code (php)
1
2
3
4
2
3
4
<?php
mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
?>
mysql_connect($p_sHost, $p_sUser, $p_sPassword);
mysql_select_db(clsDB::dbName);
?>
of
Code (php)
1
2
3
4
2
3
4
<?php
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
$this->m_conDB = mysql_select_db(clsDB::dbName);
?>
$this->m_conDB = mysql_connect($p_sHost, $p_sUser, $p_sPassword);
$this->m_conDB = mysql_select_db(clsDB::dbName);
?>
Ik zie het nu zo, de eerste regel wordt een 'nieuwe' connectie gemaakt (door $this->), en de database wordt in de regel onder geopend, maar waarom moet je ook niet een 'nieuwe' database selecteren?
mysql_select_db geeft alleen maar terug of het gelukt is of niet. Dus om de resource-identifier die je net hebt opgeslagen te vervangen met deze boolean, beetje nutteloos.
Ik vond nog een eigennaardigheid in het boek (of dat lijkt mij):
Dit voorbeeld staat op blz 90 van het Superboek.
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
public funtion __construct() {
$this->m_sTitle= "Titel";
$this->m_sText= "text van het bericht";
}
?>
public funtion __construct() {
$this->m_sTitle= "Titel";
$this->m_sText= "text van het bericht";
}
?>
Het rare vind ik dat als je een class aanroept, hij eerst de constructor aanroept, en dan worden de variabele m_sTitle gedefinieerde waardes, maar het lijkt mij dat die waardes variabel moeten zijn, anders heeft elk artikel de titel: Titel en tekst "text van het bericht".
Hetzelfde doen ze op blz 75, en dat is eigenlijk nog raardes (lijkt mij):
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
<?php
class clsCalendar {
var $m_nDay;
var $m_nMonth;
var $m_nYear;
function __construct() {
$this->m_nDay = -1;
$this->m_nMonth = -1;
$this->m_nYear = -1;
}
?>
class clsCalendar {
var $m_nDay;
var $m_nMonth;
var $m_nYear;
function __construct() {
$this->m_nDay = -1;
$this->m_nMonth = -1;
$this->m_nYear = -1;
}
?>
Hierzo worden eerste variabele gedefineerd, en daarna word de contructor aangeroepen en worden de variabele een vaste waarde (-1), of zie ik dat verkeerd?
Gewijzigd op 01/01/1970 01:00:00 door Zim Zim
In veel talen kan je namelijk niet bij de declaratie van een variabele (regel 2/3/4) al een waarde opgeven, dus moet dat in de constructor. En waarschijnlijk zet hij die 3 eigenschappen op -1 omdat 0 een mogelijk antwoord is, en -1 later herkenbaar is als een fout antwoord waar eventueel makkelijk op gecontroleerd kan worden en waarna een foutmelding kan volgen.
Wat ik dan weer raar vind: Waarom prefixt dat boek al zijn klassen met 'cls'. Wat kan het anders zijn dan een klasse :/
Jelmer schreef op 30.12.2006 14:32:
Met het gevaar dat ik hier antwoord geef op een retorische vraag: waarschijnlijk heeft de auteur ooit eens gehoord van "Hungarian Notation" en probeert hij dat nu toe te passen.Wat ik dan weer raar vind: Waarom prefixt dat boek al zijn klassen met 'cls'. Wat kan het anders zijn dan een klasse :/
Hij ziet daarbij over het hoofd dat HN voor OO-omgevingen nutteloos is, omdat variabelen in een OO-taal type-loos zijn; ze bevatten objecten, en het type daarvan hangt af van het object en niet van de variabele.
Quote:
afgezien daarvan zou uit de naamgeving van variabelen of properties al duidelijk moeten zijn wat voor type het is, en je kan natuurlijk ook nog templates hebben :)Hij ziet daarbij over het hoofd dat HN voor OO-omgevingen nutteloos is, omdat variabelen in een OO-taal type-loos zijn; ze bevatten objecten, en het type daarvan hangt af van het object en niet van de variabele.
Ook voor variabelen kan het handig zijn, zo kunt u bijvoorbeeld als u een bestand aan het doorbladeren bent met fopen "$result = fopen(" etc ... en je wilt ook nog tegelijkertijd wat uit de database halen "$result1 = mysql_query" etc .. dan kan dat behoorlijk verwarrend zijn. Gebruik bijvoorbeeld gewoon "$fileResult = fopen(" en "$sqlResult = mysql_query" etc ... dan weet u meteen waar het van is, WAt het is dat is niet zo heel erg belangrijk.
Maar het was inderdaad een vraag die moest aanzetten tot nadenken. Het antwoord op de vraag zelf wist ik al, heb ik al vaak genoeg moeten aanhoren :)
Quote:
$result = fopen(" etc
Tsja, wat moet ik hierop zeggen? Zelf vind ik $result hier sowieso een verkeerd gekozen naam, omdat je van fopen geen resultaat terugkrijgt, maar een filehandle. Ik zou dan ook eerder kiezen voor $fh, maar omdat ik ooit ben opgegroeid in een C-omgeving, gebruik ik in de praktijk $fp (file pointer).
Bij gebruik van meerdere file pointers tegelijk komt daar dan nog de functie achter te staan: $fpIn, $fpOut, $fpErr, $fpLog, etc. Kort en (m.i.) duidelijk.
Quote:
dan weet u meteen waar het van is, WAt het is dat is niet zo heel erg belangrijk.
Ook hierover verschillen we van mening ;-)
Om terug te komen op je query: stel dat je even later gaat fetchen. Het is dan niet belangrijk om te weten waar je data vandaan komt (database, csv-file, watdanook) maar je wilt wel weten of het bijvoorbeeld een array of een object is.
En nee, $mysqlFetchObjectResult = mysql_fetch_object($sqlResult) vind ik geen goed voorbeeld van een duidelijke naamgeving :)