Exceptions of booleans?
Als je in OOP een form validatie maakt, met formulier klassen, InputElement klassen, InputRule klassen, etc. Is het dan beter om een fout ingevulde input component te verwerken met een exception, of met een functie die bijvoorbeeld true of false geeft?
Ik heb bijvoorbeeld een formulier klasse, daarin zet ik InputElements die in de formulier klasse worden opgeslagen. Dan heb je nog een inputValidator die het formulier op fout ingevulde velden controleert. Elk InputElement object in het Form object heeft een aantal InputRules in zich gekregen. Bijvoorbeeld een veld voor een emailadres heeft een InputRule object gekregen dat controleert of het emailadres echt is. Zo'n InputRule object heeft een functie validate() die nu true of false teruggeeft om aan te geven of aan die input regel wordt voldaan. Is het beter om dit dus met booleans te doen, of met exceptions?
Je gaat hier iets valideren. Daar kan een "geldig" of een "ongeldig" uitkomen. Voor jezelf kun je dit duidelijker maken door niet als functienaam validate() te gebruiken, maar isValid(). En dan heb je ook meteen antwoord op je vraag. IsValid? Ja of nee, ofwel true of false.
Exceptions zou ik persoonlijk vooral voorbehouden aan situaties die verkeerd kunnen gaan, bijvoorbeeld het niet tot stand kunnen komen van een databaseverbinding.
Zover mij bekend zie je dan in de OOP systemen meestal dat een formfield object geen, één of meerdere validationRules toegewezen krijgt. Jouw email veld zou dan een NotEmptyValidationRule kunnen krijgen en een ValidMailaddressValidationRule bijvoorbeeld. Naast een IsValid method zou je wellicht een getErrorMessage method kunnen maken die ingeval van validatie fouten wordt aangeroepen om een keurige foutmelding te tonen.
Toevoeging op 01/02/2015 14:27:03:
Verder is de ValidationRule ook typisch zo een class waarbij je gebruik gaat maken van een interface
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
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
<?php
interface iValidationRule
{
function __construct(\FormField $formfield);
public function isValid();
public function getErrorMessage();
}
class ValidationRule implements iValidationRule
{
protected $formField;
public function __construct(\FormField $formfield) {
$this->formField = $formfield;
}
public function isValid()
{
return TRUE;
}
public function getErrorMessage()
{
return NULL;
}
}
class NotEmptyValidationRule extends ValidationRule
{
public function isValid()
{
if(strlen($this->formField->getContent()) > 0)
return TRUE;
return FALSE;
}
public function getErrorMessage()
{
return $GLOBALS['translater']->getTranslation('NotEmptyMessage');
}
}
?>
interface iValidationRule
{
function __construct(\FormField $formfield);
public function isValid();
public function getErrorMessage();
}
class ValidationRule implements iValidationRule
{
protected $formField;
public function __construct(\FormField $formfield) {
$this->formField = $formfield;
}
public function isValid()
{
return TRUE;
}
public function getErrorMessage()
{
return NULL;
}
}
class NotEmptyValidationRule extends ValidationRule
{
public function isValid()
{
if(strlen($this->formField->getContent()) > 0)
return TRUE;
return FALSE;
}
public function getErrorMessage()
{
return $GLOBALS['translater']->getTranslation('NotEmptyMessage');
}
}
?>
Gewijzigd op 01/02/2015 14:52:21 door Frank Nietbelangrijk
ik heb dus ook objecten voor de formulier elementen waar ik de InputRules aan toewijs, maar als ik de value van zo'n element wil hebben, dan moet ik gebruik maken van de $_POST of $_GET global, maar het is vanzelfsprekend dat je dit niet doet in OOP, normaal haal je dit soort dingen uit het Request object.
Ik heb dus ook een Form object waar ik de input objecten aan toevoeg. Het formulier heeft een submit function die als parameter het Request object bevat. Maar wanneer ga ik uit dat request object de waardes halen van POST en GET, in het Form object en dan in de submit function de input objecten vullen met die waarde, en dan validaren? Of een andere manier?
Precies.
>> Maar wanneer ga ik uit dat request object de waardes halen van POST en GET
Dit doe je in een speciale method van je FormBuilder:
Code (php)
1
2
3
2
3
<?php
$form->handleRequest($request);
?>
$form->handleRequest($request);
?>
In je controller wil je alleen iets als dit hebben:
bron: http://symfony.com/doc/current/book/forms.html
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
public function newAction(Request $request)
{
$form = $this->createFormBuilder()
->add('task', 'text')
->add('dueDate', 'date')
->add('save', 'submit', array('label' => 'Create Task'))
->getForm();
$form->handleRequest($request);
if ($form->isValid()) {
// perform some action, such as saving the task to the database
}
}?>
public function newAction(Request $request)
{
$form = $this->createFormBuilder()
->add('task', 'text')
->add('dueDate', 'date')
->add('save', 'submit', array('label' => 'Create Task'))
->getForm();
$form->handleRequest($request);
if ($form->isValid()) {
// perform some action, such as saving the task to the database
}
}?>
even de structuur (gedeeltelijk)
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
FormBuilder
|
|----FormField
| |
| |----Label
| |----Name
| |----Value
| |----Option(s)
| |----ValidationRule(s)
|
|----FormField
| |
| |----Label
| |----Name
| |----Value
| |----Option(s)
| |----ValidationRule(s)
|
|
|----FormField
| |
| |----Label
| |----Name
| |----Value
| |----Option(s)
| |----ValidationRule(s)
|
|----FormField
| |
| |----Label
| |----Name
| |----Value
| |----Option(s)
| |----ValidationRule(s)
|
Je kunt dit in MVC-stijl opsplitsen: het formulier is een view (V) en een controller (C) plaatst daarin data die uit een model (M) komen. De form controller kan in dit geval nieuwe data uit een request-object halen, maar er zijn ook situaties waarin je bijvoorbeeld eerder ingevulde data uit een database wilt hergebruiken. Dat gaat allemaal aan het formulier (de view) voorbij: de controller regelt dit.
Het formulier doet bijvoorbeeld alleen echo $voornaam en de controller bepaalt hoe die $voornaam wordt gevuld.
>> Maar wanneer ga ik uit dat request object de waardes halen van POST en GET, in het Form object en dan in de submit function de input objecten vullen met die waarde, en dan validaren? Of een andere manier?
Je kunt, om te beginnen, niet alles overlaten aan individuele objecten: je hebt ook altijd een applicatie die de objecten onderling verbindt en laat samenwerken. Aangezien je altijd maar één request beantwoord, laat je een front controller (index.php) dat één keer aanmaken. Hiervoor wordt ook vaak een registry gebruikt die naast $_GET en $_POST bijvoorbeeld nog $_SERVER afhandelt. Met andere woorden: dat voor het verwerken van een request meerdere objecten in een specifieke volgorde nodig zijn (bijvoorbeeld request -> validator -> controller -> view), bepaal je op het niveau van de applicatie.