[oop] beginners vraag
Ik ben pas begonnen met het programmeren in OOP en ben nu een form aan het maken.
Echter heb ik hier nog wel wat vragen over.
1. Is het zo dat voor elke input type je een aparte Class nodig hebt of kun je de types in 1 class doen. Bijvoorbeeld dit
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
Class form {
private $type;
private $name;
public function __construct($type,$name) {
$this->type = $type;
$this->name = $name;
}
public function draw {
if($this->type != 'textarea') {
return '<input type="'.$this->type.'" name="'.$this->name.'" />';
} else {
return '<textarea name="'.$this->name.'"></textarea>';
}
}
}
?>
Class form {
private $type;
private $name;
public function __construct($type,$name) {
$this->type = $type;
$this->name = $name;
}
public function draw {
if($this->type != 'textarea') {
return '<input type="'.$this->type.'" name="'.$this->name.'" />';
} else {
return '<textarea name="'.$this->name.'"></textarea>';
}
}
}
?>
of je doet het zo
Class Input_Text {
Code
}
Class Input_Radio {
Code
}
Etc..
Wat is dan beter om te doen.
Dus 1 Main class form en daar alle objects en methods in te doen Of meerdere classes met elk hun eigen objects en methods.
Met vriendelijke groet,
Thomas de Vries
Betekend overigens niet dat je input weer moet verdelen onder inputTekst en inputRadio, text, radio, password etc zijn namelijk eigenschappen van de input.
Dus tekst,password,radio,checkbox en wat dus geen <input type= /> in aparte class te stoppen.
Edit.
Ik heb nu dit
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
52
53
54
55
56
57
58
59
60
61
62
63
64
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
52
53
54
55
56
57
58
59
60
61
62
63
64
<?php
class FormLabel {
private $label;
private $labelClass;
private $labelText;
public function __construct($label,$labelClass,$labelText) {
$this->label = $label;
$this->labelClass = $labelClass;
$this->labelText = $labelText;
}
public function getLabel() {
return '<label for = "'.$this->label.'" class = "'.$this->labelClass.'" />'.$this->labelText.'</label>';
}
}
class FormField {
private $type;
private $name;
private $id;
private $value;
private $inputClass;
private $maxlength;
private $placeholder;
private $required;
public function __construct($type,$name,$id = false,$value = false,$inputClass = false,$maxlength,$placeholder,$required) {
$this->type = $type;
$this->name = $name;
$this->id = $id;
$this->inputClass = $inputClass;
$this->maxlength = $maxlength;
$this->placeholder = $placeholder;
$this->required = $required;
}
public function getInput() {
if(!empty($required)) {
$required = ' required="required" ';
}
return '<input type="'.$this->type.'" name="'.$this->name.'" id="'.$this->id.'" value="'.$this->value.'" class="'.$this->inputClass.'" maxlength="'.$this->maxlength.'" placeholder="'.$this->placeholder.'" '.$required.' />';
}
}
$Label = new FormLabel(
'test' //Sets the for id
,'labelRegistration' //Sets the class for the label
,'Account :' //Sets the text of the label
);
echo $Label->getLabel();
$Text = new FormField(
'text' //Setting the type of the input field
,'registAccountID' //Setting the name of the input field
,'registAccountID' //Setting the ID of the input field
,false //Setting an value for the input field
,'labelRegistration' //Setting an Class for the input field
,'16' //Setting the maxlength for the input field
,'Account' //Setting the placeholder for the input field
,REQUIRED //Set the input field as an required input
);
echo $Text->getInput();
?>
class FormLabel {
private $label;
private $labelClass;
private $labelText;
public function __construct($label,$labelClass,$labelText) {
$this->label = $label;
$this->labelClass = $labelClass;
$this->labelText = $labelText;
}
public function getLabel() {
return '<label for = "'.$this->label.'" class = "'.$this->labelClass.'" />'.$this->labelText.'</label>';
}
}
class FormField {
private $type;
private $name;
private $id;
private $value;
private $inputClass;
private $maxlength;
private $placeholder;
private $required;
public function __construct($type,$name,$id = false,$value = false,$inputClass = false,$maxlength,$placeholder,$required) {
$this->type = $type;
$this->name = $name;
$this->id = $id;
$this->inputClass = $inputClass;
$this->maxlength = $maxlength;
$this->placeholder = $placeholder;
$this->required = $required;
}
public function getInput() {
if(!empty($required)) {
$required = ' required="required" ';
}
return '<input type="'.$this->type.'" name="'.$this->name.'" id="'.$this->id.'" value="'.$this->value.'" class="'.$this->inputClass.'" maxlength="'.$this->maxlength.'" placeholder="'.$this->placeholder.'" '.$required.' />';
}
}
$Label = new FormLabel(
'test' //Sets the for id
,'labelRegistration' //Sets the class for the label
,'Account :' //Sets the text of the label
);
echo $Label->getLabel();
$Text = new FormField(
'text' //Setting the type of the input field
,'registAccountID' //Setting the name of the input field
,'registAccountID' //Setting the ID of the input field
,false //Setting an value for the input field
,'labelRegistration' //Setting an Class for the input field
,'16' //Setting the maxlength for the input field
,'Account' //Setting the placeholder for the input field
,REQUIRED //Set the input field as an required input
);
echo $Text->getInput();
?>
Is dit goed of zijn er andere dingen om rekening mee te houden. Het is natuurlijk niet af en dit is een voorbeeld om te zien of er nog wat verandert moet worden.
Gewijzigd op 06/03/2014 08:38:28 door thomas de vries
Code (php)
1
2
3
2
3
<label id="iets">
<input type="text" name="blabla" data-itemid="3">
</label>
<input type="text" name="blabla" data-itemid="3">
</label>
Bedenk dat classes dusdanig flexibel zouden moeten zijn dat je in principe alle mogelijke variaties aan zou moeten kunnen. Jouw classes zijn dusdanig strict dat elke afwijking direct al problemen opleveren. Ofwel je bent vanaf nu elke dag al aanpassingen aan het schrijven, ofwel je kan maar een zeer beperkt aantal HTML varianten aan.
Dit was dan ook een voorbeeld uiteindelijk moeten alle <input elements in de class komen te staan. of moet ik het anders doen ivm toekomst want als er uiteindelijk meer form elements komen dan moet ik dus ook de class weer gaan aanpassen.
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
class Input {
private $sName;
private $sType;
private $sValue;
private $sRequired;
private function __construct( $sName, $sType, $sValue, $sRequired )
{
$this->name = $sName;
$this->type = $sType;
$this->value = $sValue;
$this->required = $sRequired;
}
private function setName( $sName )
{
$this->name = (string) $sName;
}
private function setType( $sType )
{
$this->type = (string) $sType;
}
private function setValue( $sValue )
{
$this->value = (string) $sValue;
}
private function setRequired( $sRequired )
{
$this->required = (string) $sRequired;
}
private function getName()
{
return $this->name;
}
private function getType()
{
return $this->type;
}
private function getValue()
{
return $this->value;
}
private function getRequired()
{
return $this->required;
}
}
?>
class Input {
private $sName;
private $sType;
private $sValue;
private $sRequired;
private function __construct( $sName, $sType, $sValue, $sRequired )
{
$this->name = $sName;
$this->type = $sType;
$this->value = $sValue;
$this->required = $sRequired;
}
private function setName( $sName )
{
$this->name = (string) $sName;
}
private function setType( $sType )
{
$this->type = (string) $sType;
}
private function setValue( $sValue )
{
$this->value = (string) $sValue;
}
private function setRequired( $sRequired )
{
$this->required = (string) $sRequired;
}
private function getName()
{
return $this->name;
}
private function getType()
{
return $this->type;
}
private function getValue()
{
return $this->value;
}
private function getRequired()
{
return $this->required;
}
}
?>
En dan uiteindelijk denk ik dat je iets van een formbuilder nodig hebt om het uiteindelijke formulier te maken. Zoals je ziet ben je vrij flexibel in deze input klasse. Je kunt indien nodig redelijk gemakkelijk uitbreiden zonder dat de rest er echt hinder van vind.
Verder is er de mogelijkheid om te valideren. Neem bijvoorbeeld de functie setType. Daarin zou je kunnen controleren of de waarde wel klopt. Bijvoorbeeld:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
private function setType( $sType )
{
$aTypes = array( 'text', 'password', 'image', 'color', 'date', 'datetime', 'datetime-local', 'email', 'month', 'number', 'range', 'search', 'tel', 'time', 'url', 'week' );
if( in_array( $sType, $aTypes ) )
{
$this->type = (string) $sType;
}
else
{
$this->type = 'text';
}
}
?>
private function setType( $sType )
{
$aTypes = array( 'text', 'password', 'image', 'color', 'date', 'datetime', 'datetime-local', 'email', 'month', 'number', 'range', 'search', 'tel', 'time', 'url', 'week' );
if( in_array( $sType, $aTypes ) )
{
$this->type = (string) $sType;
}
else
{
$this->type = 'text';
}
}
?>
Vervolgens is ook weer het gebruiken van zo'n attribuut object goed om in een basis HTML class te plaatsen, want anders ben je zelfs dat weer overal aan het doen.
En als je dan toch al dat basis HTML element hebt, bedenk dan ook hoe de structuur van een HTML element eruit ziet. In principe is dat een boom structuur. HTML elementen kunnen namelijk weer kinderen hebben die in het element zitten. Als je dus een basis HTML element wilt bouwen dan zal je al uit moeten gaan van die boom structuur. Je zal dus de mogelijkheid willen hebben om kinderen aan het element toe te voegen. Maak derhalve ook een HTML interface die dit al afdwingt.
Als je dit hebt (attributen class, HTML element interface, HTML basis class) dan heb je al bijna je hele pagina gebouwd. Elk nieuw HTML element in een class stoppen (of een set aan elementen kan ook) is dan een koud kunstje. Dan ben je echt met OOP aan de slag.
Gewijzigd op 06/03/2014 09:48:29 door Erwin H
Erwin, het voorbeeld dat jij geeft... begrijp ik nu dat jij via OOP html wil creëren? Of begrijp ik je verkeerd?
Is het misschien verstandiger om in de __construct aan te geven dat er 3 types nodig zijn voor een geldige input en de andere attributen in een array te stoppen? Dus zo
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
Class FormField {
private $id;
private $type;
private $name;
private $Attributes;
public function __construct($id,$type,$name,$Attributes) {
$this->id = $id;
$this->type = $type;
$this->name = $name;
$this->Attributes = $Attributes;
}
public function getInput() {
foreach($this->Attributes AS $aAttribute) {
$bAttribute .= $aAttribute;
}
return '<input type="'.$this->type.'" name="'.$this->name.'" id="'.$this->id.'" '.$bAttribute.' />';
}
}
?>
Class FormField {
private $id;
private $type;
private $name;
private $Attributes;
public function __construct($id,$type,$name,$Attributes) {
$this->id = $id;
$this->type = $type;
$this->name = $name;
$this->Attributes = $Attributes;
}
public function getInput() {
foreach($this->Attributes AS $aAttribute) {
$bAttribute .= $aAttribute;
}
return '<input type="'.$this->type.'" name="'.$this->name.'" id="'.$this->id.'" '.$bAttribute.' />';
}
}
?>
En zo de de procedure code
$Tekst = new FormField(
'Test'
,'text'
,'Test'
,array('maxlength="5"','class="registerTest"')
);
Gewijzigd op 06/03/2014 13:14:40 door thomas de vries