OOP Juiste denkwijze
Hoi,
Ik ben sinds kort bezig met object-georiënteerd programmeren. Dit lukt me best, maar ik heb er sinds gisteren bijgeleerd om de try catch functie te gebruiken.
Mijn vraag is of ik nu de juiste denkwijze heb. Is het verstandig om alles via OOP te laten controleren en de output alleen via een try catch functie te laten verlopen?
Lastig verhaal misschien, maar ik heb dit gemaakt en ik vraag me af of dit nu de juiste denkwijze is.
Alvast bedankt :)
Ik ben sinds kort bezig met object-georiënteerd programmeren. Dit lukt me best, maar ik heb er sinds gisteren bijgeleerd om de try catch functie te gebruiken.
Mijn vraag is of ik nu de juiste denkwijze heb. Is het verstandig om alles via OOP te laten controleren en de output alleen via een try catch functie te laten verlopen?
Lastig verhaal misschien, maar ik heb dit gemaakt en ik vraag me af of dit nu de juiste denkwijze is.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?php
include("config.php");
class Speler
{
private $sNaam, $sWachtwoord, $sEmail;
public function __construct($sNaam, $sWachtwoord = '', $sEmail = '')
{
if (self::speler_exists($sNaam))
{
throw new Exception('Deze speler bestaat al!');
}
else
{
echo 'Aangemaakt!';
}
}
public static function speler_exists($sNaam)
{
$query = "SELECT id FROM gebruikers WHERE gebruikersnaam = '".mysql_real_escape_string($sNaam)."'";
$sql = mysql_query($query);
if ($sql)
{
if (mysql_num_rows($sql) > 0)
{
throw new Exception('Gebruiker bestaat al!');
return true;
}
else
{
return false;
}
}
else
{
throw new Exception('Mislukte query!');
}
}
}
try
{
$speler = new Speler('Roel');
}
catch (Exception $e)
{
echo $e->getMessage();
}
?>
include("config.php");
class Speler
{
private $sNaam, $sWachtwoord, $sEmail;
public function __construct($sNaam, $sWachtwoord = '', $sEmail = '')
{
if (self::speler_exists($sNaam))
{
throw new Exception('Deze speler bestaat al!');
}
else
{
echo 'Aangemaakt!';
}
}
public static function speler_exists($sNaam)
{
$query = "SELECT id FROM gebruikers WHERE gebruikersnaam = '".mysql_real_escape_string($sNaam)."'";
$sql = mysql_query($query);
if ($sql)
{
if (mysql_num_rows($sql) > 0)
{
throw new Exception('Gebruiker bestaat al!');
return true;
}
else
{
return false;
}
}
else
{
throw new Exception('Mislukte query!');
}
}
}
try
{
$speler = new Speler('Roel');
}
catch (Exception $e)
{
echo $e->getMessage();
}
?>
Alvast bedankt :)
Gewijzigd op 15/08/2011 11:07:40 door Roel van de Water
Gesponsorde koppelingen:
Bump!
Ik geef je één tip; gebruik Engelse benamingen voor variabelen, functies en classes.
In de toekomst ga je hier veel voordeel van hebben als je eventueel besluit samen te werken met een internationaal iemand of als je het script gaat verkopen / doorgeven.
Ook is het makkelijker als je ooit eens besluit je te registeren op een, bijvoorbeeld Engelstalig, forum en je script daar plaatst als je ergens niet uitkomt.
Het is maar een tip, maar het is natuurlijk helemaal jouw persoonlijke keuze.
In de toekomst ga je hier veel voordeel van hebben als je eventueel besluit samen te werken met een internationaal iemand of als je het script gaat verkopen / doorgeven.
Ook is het makkelijker als je ooit eens besluit je te registeren op een, bijvoorbeeld Engelstalig, forum en je script daar plaatst als je ergens niet uitkomt.
Het is maar een tip, maar het is natuurlijk helemaal jouw persoonlijke keuze.
Gewijzigd op 15/08/2011 22:23:10 door PHP Scripter
Hmm.. Daar zit wel wat in. Bedankt voor de tip.
Hoe vind je de code (en het idee) er verder uitzien?
Hoe vind je de code (en het idee) er verder uitzien?
1. Het is smaak en een mening maar ik zou nooit je members prefixen met het datatype, dit was echt een hype 3/4 jaar terug maar is een beetje not done tegenwoordig. Vaak als je het een goede naam geeft is het vaak duidelijk wat voor datatype het hier om gaat en bovendien is PHP loosely typed.
2. Ik zou de functie speler_exists hernoemen naar exists anders krijg je: speler::speler_exists().. netter lijkt me speler::exists().
Verder is het idee aardig!
2. Ik zou de functie speler_exists hernoemen naar exists anders krijg je: speler::speler_exists().. netter lijkt me speler::exists().
Verder is het idee aardig!
Een toevoeging op Kees zijn eerste opmerking; als je comments plaatst dan kan je het ook al een heel stuk duidelijker maken. Zelf doe ik dat op de "Java-manier". Als je voor of met mensen werkt die ook aan jouw code sleutelen, dan is dit een manier om het werken efficiënter te maken.
Hier een voorbeeldje van een script.
http://pastebin.com/vJCKgVGH
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
/**
* Method used to do nothing.
*
* @param String $String
* @return Boolean
* @since v1.0
*/
* Method used to do nothing.
*
* @param String $String
* @return Boolean
* @since v1.0
*/
Hier een voorbeeldje van een script.
http://pastebin.com/vJCKgVGH
Persoonlijk zou ik wél prefixen gebruiken. Het is naar mijn mening veel duidelijker & ook handiger tijdens het debuggen. Stel bijvoorbeeld je je gebruikers ophaalt, maar je krijgt niet het verwachte resultaat. Dan doe je print_r($aUsers). Nu, ik zie plots dat $aUsers helemaal geen array is maar bijvoorbeeld een int. Dan weet je al direct dat er iets niet pluis is.
Gewijzigd op 16/08/2011 11:09:53 door Write Down
Als je dan weet dat $users een array moet zijn, zie je ook dat er iets niet pluis is.
Als je het weet ja. Nog nooit een script aangepast dat je al tijdje geleden hebt gemaakt? Weet jij nog direct je denkproces van toen? In dit geval lijkt het logisch, maar ik kan me voorstellen dat er andere variabelen zijn waarbij het echt zijn nut bewijst.
Maar om even op de eerste vraag terug te komen:
Het meest logisch is om try en catch blokken op twee manieren te gebruiken:
Bij voorspelde exceptions doe je het try en catch blok zo laag mogelijk (zo dicht mogelijk bij het gooi-punt). Je kan dan bijvoorbeeld een nieuwe Exception gooien, een bepaalde resource negeren of een alternatief zoeken.
Bij onvoorspelde exceptions doe je het zo hoog mogelijk, bijv. in een MVC structuur in de laag boven je controller. Dan kan je alle onverwachte (DB) fouten mooi afhandelen met een 500 Internal Server Error voor gebruikers en mooie debug informatie voor de ontwikkelaar. Dat hoef je dan maar 1x te implementeren.
Het meest logisch is om try en catch blokken op twee manieren te gebruiken:
Bij voorspelde exceptions doe je het try en catch blok zo laag mogelijk (zo dicht mogelijk bij het gooi-punt). Je kan dan bijvoorbeeld een nieuwe Exception gooien, een bepaalde resource negeren of een alternatief zoeken.
Bij onvoorspelde exceptions doe je het zo hoog mogelijk, bijv. in een MVC structuur in de laag boven je controller. Dan kan je alle onverwachte (DB) fouten mooi afhandelen met een 500 Internal Server Error voor gebruikers en mooie debug informatie voor de ontwikkelaar. Dat hoef je dan maar 1x te implementeren.
Overigens is het zo dat vanuit een klasse geen zaken worden geëchood.
Roel L op 16/08/2011 10:20:50:
Een toevoeging op Kees zijn eerste opmerking; als je comments plaatst dan kan je het ook al een heel stuk duidelijker maken. Zelf doe ik dat op de "Java-manier". Als je voor of met mensen werkt die ook aan jouw code sleutelen, dan is dit een manier om het werken efficiënter te maken.
Hier een voorbeeldje van een script.
http://pastebin.com/vJCKgVGH
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
/**
* Method used to do nothing.
*
* @param String $String
* @return Boolean
* @since v1.0
*/
* Method used to do nothing.
*
* @param String $String
* @return Boolean
* @since v1.0
*/
Hier een voorbeeldje van een script.
http://pastebin.com/vJCKgVGH
Tags moeten lowercase zijn.



