Error Class: correct?
Beste PHP-ers,
Ik ben bezig met een error class maar deze is niet echt goed 'valid' OOP.
Dit is mijn code:
Is er een manier om dit anders te doen maar om dan bijvoorbeeld niet met functions te werken?
Raoul
Ik ben bezig met een error class maar deze is niet echt goed 'valid' OOP.
Dit is mijn code:
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
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
<?php
class Errors {
public static $_errors;
public static $_totalErrors = 0;
public static function addError($err) {
self::$_errors[] = $err;
self::$_totalErrors++;
}
public static function isSuccess() {
if (self::$_totalErrors == 0)
return true;
else
return false;
}
public static function getErrors() {
$return = '';
if (self::$_totalErrors == 1)
$return .= 'Er is een fout opgetreden';
else
$return .= 'Er zijn ' . self::$_totalErrors . ' fouten opgetreden';
$return .= '<ul>';
foreach(self::$_errors as $err) {
$return .= '<li>' . $err . '</li>';
}
$return .= '</ul>';
self::$_errors = null;
self::$_totalErrors = 0;
return $return;
}
}
?>
class Errors {
public static $_errors;
public static $_totalErrors = 0;
public static function addError($err) {
self::$_errors[] = $err;
self::$_totalErrors++;
}
public static function isSuccess() {
if (self::$_totalErrors == 0)
return true;
else
return false;
}
public static function getErrors() {
$return = '';
if (self::$_totalErrors == 1)
$return .= 'Er is een fout opgetreden';
else
$return .= 'Er zijn ' . self::$_totalErrors . ' fouten opgetreden';
$return .= '<ul>';
foreach(self::$_errors as $err) {
$return .= '<li>' . $err . '</li>';
}
$return .= '</ul>';
self::$_errors = null;
self::$_totalErrors = 0;
return $return;
}
}
?>
Is er een manier om dit anders te doen maar om dan bijvoorbeeld niet met functions te werken?
Raoul
Kun je het misschien anders uitleggen? Want de code zelf is gewoon valide code. Het is een static class dus geen OO maar wel OO geprogrammeerd, daarentegen heb je wel "output" in je class wat weer niet hoort.
Over de functionaliteit, als die werkt en het werkt naar behoren zou ik niet al te veel lopen aanpassen.
Wat bedoel je met "bijvoorbeeld niet met functions te werken" ?
Over de functionaliteit, als die werkt en het werkt naar behoren zou ik niet al te veel lopen aanpassen.
Wat bedoel je met "bijvoorbeeld niet met functions te werken" ?
Probeer als je OO werkt te zorgen dat een methode maar verantwoordelijk is voor één ding. Als ik naar je methode addError kijk doet die al twee dingen, namelijk: een error in een array zetten en de count bijhouden.
Je kunt bijvoorbeeld een nieuwe methode maken countError() in deze methode kun je met de php functie count ophalen hoeveel resultaten er in de array zitten. Dat zijn dan de aantal fouten.
Verder zie ik je inderdaad met static werken. Werk in OO met $this->var;.
Kijk eens naar de error klasse van Mark: https://webdevils.nl/articles/12-oop-gastenboek-deel-8-validators/
Mochten er dingen onduidelijk voor je zijn kun je daar ook altijd even op reageren.
Je kunt bijvoorbeeld een nieuwe methode maken countError() in deze methode kun je met de php functie count ophalen hoeveel resultaten er in de array zitten. Dat zijn dan de aantal fouten.
Verder zie ik je inderdaad met static werken. Werk in OO met $this->var;.
Kijk eens naar de error klasse van Mark: https://webdevils.nl/articles/12-oop-gastenboek-deel-8-validators/
Mochten er dingen onduidelijk voor je zijn kun je daar ook altijd even op reageren.
Tom Swinkels op 04/03/2012 21:41:27:
Probeer als je OO werkt te zorgen dat een methode maar verantwoordelijk is voor één ding. Als ik naar je methode addError kijk doet die al twee dingen, namelijk: een error in een array zetten en de count bijhouden.
Je voegt een error toe en je telt 'm . Kan toch prima in 1 functie? Lijkt me raar om daar 2 functies van te maken.
@Ozzie Dan is het geen OO meer, een methode mag maar verantwoordelijk zijn voor een ding. Verder zou ik het nooit op die manier doen, aangezien je ook gewoon de array met count kan tellen.
Zoals je bij het voorbeeld ziet kan er met de methode setError() een error opgegeven worden. Wanneer je de methode countError() oproept zal die terug geven hoeveel fouten er in de array zitten.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
private $_error;
public function __construct()
{
$this->_error = array();
}
public function setError($message)
{
$this->_error[] = $message;
}
public function countError()
{
return count($this->_error);
}
public function __construct()
{
$this->_error = array();
}
public function setError($message)
{
$this->_error[] = $message;
}
public function countError()
{
return count($this->_error);
}
Zoals je bij het voorbeeld ziet kan er met de methode setError() een error opgegeven worden. Wanneer je de methode countError() oproept zal die terug geven hoeveel fouten er in de array zitten.
Het is natuurlijk niet heel strict genomen en hier kan het gewoon in 1 method gebruiken.
Al is het wel onzinnig om bij te houden, want met een simpele count op de errors lukt het ook al en dat is naar mijn mening iets meer OO.
Ook static werken is werken in OO. Met bijv. singletons of dit soort dingen kun je gewoon heel goed static gebruiken. De klasse is dan meer een verzameling van functies dan een object, maar het is gewoon OO. Zoiets met normale methods doen is gekkenwerk.
Een puntje waar ik wat op aan te merken heb is de getErrors klasse. Deze vult meteen al in hoe het op het scherm moet komen. Totaal geen flexibiliteit. In dit geval kan ik er ook voor kiezen om de errors in een table te plaatsen. Dan moet ik eerst weer de klasse aanpassen en dat wil je niet in OO.
Je kunt dus beter in de getErrors doen wat de method zegt, de errors in een mooie array teruggeven. Wat je vervolgens met die array doet hoeft die klasse totaal niet te weten.
Al is het wel onzinnig om bij te houden, want met een simpele count op de errors lukt het ook al en dat is naar mijn mening iets meer OO.
Quote:
Verder zie ik je inderdaad met static werken. Werk in OO met $this->var;.
Ook static werken is werken in OO. Met bijv. singletons of dit soort dingen kun je gewoon heel goed static gebruiken. De klasse is dan meer een verzameling van functies dan een object, maar het is gewoon OO. Zoiets met normale methods doen is gekkenwerk.
Een puntje waar ik wat op aan te merken heb is de getErrors klasse. Deze vult meteen al in hoe het op het scherm moet komen. Totaal geen flexibiliteit. In dit geval kan ik er ook voor kiezen om de errors in een table te plaatsen. Dan moet ik eerst weer de klasse aanpassen en dat wil je niet in OO.
Je kunt dus beter in de getErrors doen wat de method zegt, de errors in een mooie array teruggeven. Wat je vervolgens met die array doet hoeft die klasse totaal niet te weten.
@Wouter J: Een methode mag toch maar verantwoordelijk zijn voor één ding? Hij is nu verantwoordelijk voor het maken van een string, en het tellen? Teminste, zo heb ik het geleerd.
Bedankt voor jullie reacties.
De static gebruik ik eigenlijk omdat ik die class erg vaak zal nodig hebben én het is irritant om er dan iedere x een instance voor aan te maken.
De static gebruik ik eigenlijk omdat ik die class erg vaak zal nodig hebben én het is irritant om er dan iedere x een instance voor aan te maken.




