Cookie class
En waarom is cookie een child van CookieStorage? Dat zijn toch 2 compleet andere objecten? De een houdt gegevens vast over een cookie en de ander zorgt dat we die gegevens kunnen omzetten naar een echte cookie.
Waarom doe je dan extends? Ze hebben toch geen IS_EEN relatie? Cookie IS EEN CookieStorage. Dat klopt toch niet? Is het niet meer een HEEFT_EEN relatie? CookieStorage HEEFT_EEN Cookie?
Je moet dat Cookie object meegeven aan de CRUD methods zodat de CookieStorage deze Entity (Cookie object) kan omzetten tot een echte Cookie.
en hoe moet ik het meegeven aan de CRUD methods?
die properties zijn er om die cookie te setten. maar dat moet volgens mij pas in de Cookie class toch?
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
/**
* Constructor
*/
public function __construct() {
$this->cookie = new CookieStorage();
}
?>
/**
* Constructor
*/
public function __construct() {
$this->cookie = new CookieStorage();
}
?>
CookieStorage kan dus ook niet zomaar de properties van Cookie krijgen. Die zitten verstopt in het Cookie object en krijgt niemand zomaar te zien, zonder gebruik van de getters en setters.
Wat je dus moet doen is een Cookie object aanmaken, gegevens meegeven, vervolgens geef je dit complete Cookie object mee aan een van de CookieStorage methods en die kan hem dan gebruiken om gegevens te krijgen om een Cookie op te slaan:
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
$cookie = new Cookie('Cookie naam');
$cookie->setValue('Foo');
$cookie->setTime(time() + 3600); // uur
$cookieStorage = new CookieStorage();
$cookieStorage->create($cookie); // maak de cookie
?>
$cookie = new Cookie('Cookie naam');
$cookie->setValue('Foo');
$cookie->setTime(time() + 3600); // uur
$cookieStorage = new CookieStorage();
$cookieStorage->create($cookie); // maak de cookie
?>
En als je het nou echt goed wil doen zal je ook nog moeten zorgen dat het Cookie object een superklasse (of interface) krijgt die je ook kan gebruiken voor Session Objecten. Iets als Storagable.
dus dan krijg ik een Cookie class: http://pastebin.com/eSMSUtEg
en een CookieStorage class: alleen die cookiestorage class snap ik niet hoe deze aan de parameters moet komen van de Cookie class.
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
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
<?php
interface StorageInterface
{
public function set();
public function get();
public function update();
public function delete();
}
class CookieStorage implements StorageInterface
{
/* parameters?
/**
* constructor
*/
public function __construct() {
}
/**
* Create cookie.
*/
public function set() {
return setcookie(
$this->name,
$this->getValue(),
$this->getTime(),
$this->getPath(),
$this->getDomain(),
$this->getSecure(), true
);
}
/**
* Get cookie.
*/
public function get() {
return $_COOKIE[$this->getName()];
}
/**
* Update cookie.
*/
public function update() {
return $this->update();
}
public function delete() {
return $this->delete();
}
}
?>
interface StorageInterface
{
public function set();
public function get();
public function update();
public function delete();
}
class CookieStorage implements StorageInterface
{
/* parameters?
/**
* constructor
*/
public function __construct() {
}
/**
* Create cookie.
*/
public function set() {
return setcookie(
$this->name,
$this->getValue(),
$this->getTime(),
$this->getPath(),
$this->getDomain(),
$this->getSecure(), true
);
}
/**
* Get cookie.
*/
public function get() {
return $_COOKIE[$this->getName()];
}
/**
* Update cookie.
*/
public function update() {
return $this->update();
}
public function delete() {
return $this->delete();
}
}
?>
Code (php)
Maar nu gaan we problemen krijgen met onze StorageInterface. Dus we zullen die StorageInterface nu wat moeten gaan veranderen, namelijk dat we een object meegeven aan de CRUD methods. Dat object moet wel weer een bepaald object zijn, als we een PDO object meegeven loopt de hele code in de soep. Vandaar dat onze Cookie object (en later ons Session object enz.) een interface zullen moeten implementeren zodat we daarop kunnen controleren.
en het enige wat ik dus moet doen is de cookie object aan de set() meegeven maar maakt het uit dat ze in aparte bestandjes staan of komt dat goed door de autoloader die ze ophaalt?
ik zou eigenlijk zelfs verwachten dat dit in de construct geplaatst moet want anders moet ik het aan alle CRUD methods in CookieStorage meegeven toch?
Ja, dat zal je verwachten als een object echt 1 iets voorstelt. Maar hier kunnen we 1 cookie maken en een andere cookie verwijderen, we zullen dus per method moeten vast stellen om welk object (cookie) het gaat.
>> Oke, en hoe ziet dat er uit dan?
Ik weet niet wat je bedoelt, maar ik zou zeggen probeer zelf wat uit en zie wat het wordt!
>> en het enige wat ik dus moet doen is de cookie object aan de set() meegeven maar maakt het uit dat ze in aparte bestandjes staan of komt dat goed door de autoloader die ze ophaalt?
Je begrijpt het dus nog steeds niet helemaal, dat deed je in je vorige OO topics ook al niet. Er moet ergens bij jou een knop om zodat je dit principe gaat begrijpen. Vandaar even stap voor stap: Vertel bij welke stap je het niet meer begrijpt
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
<?php
# Stap 1
$arr = array('hello', 'world');
echo $arr[0]; // hello
# Stap 2
function foo($bar) {
return $bar[0];
}
$arr = array('hello', 'world');
echo foo($arr); // hello
# Stap 3
class Foo
{
function bar($baz)
{
return $baz[0];
}
}
$arr = array('hello', 'world');
$foo = new Foo();
echo $foo->bar($arr); // hello
# Stap 4
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
echo $arr->getIpsum(); // 'Hello World'
# Stap 5
function foo($bar) {
return $bar->getIpsum();
}
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
echo foo($arr); // 'Hello World'
# Stap 6
class Foo
{
public function bar($baz)
{
return $baz->getIpsum();
}
}
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
$foo = new Foo();
echo $foo->bar($arr); // 'Hello World'
?>
# Stap 1
$arr = array('hello', 'world');
echo $arr[0]; // hello
# Stap 2
function foo($bar) {
return $bar[0];
}
$arr = array('hello', 'world');
echo foo($arr); // hello
# Stap 3
class Foo
{
function bar($baz)
{
return $baz[0];
}
}
$arr = array('hello', 'world');
$foo = new Foo();
echo $foo->bar($arr); // hello
# Stap 4
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
echo $arr->getIpsum(); // 'Hello World'
# Stap 5
function foo($bar) {
return $bar->getIpsum();
}
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
echo foo($arr); // 'Hello World'
# Stap 6
class Foo
{
public function bar($baz)
{
return $baz->getIpsum();
}
}
class Arr
{
protected $ipsum;
public function __construct()
{
$this->ipsum = 'Hello World';
}
function getIpsum()
{
return $this->ipsum;
}
}
$arr = new Arr();
$foo = new Foo();
echo $foo->bar($arr); // 'Hello World'
?>
Bij stap 6 heb je 20 regels code nodig om wat bij stap 1 nog gewoon in 2 regels kan.
En dan is stap 6 beter..... jaaaa jaaa.
Sorry dat ik even zo inbreek hoor, maar geef me eens ongelijk.
Als je zo een heel klein stukje uit een script knipt heb je misschien wel gelijk. OOP is dan ook niet bedacht voor de kleine huis-tuin-keuken sites, maar voor complexere sites. Als je namelijk een site hebt met vele tientallen (variaties op) pagina's, werkt met complexe data structuren en alle input kanalen, dan ga je wel de voordelen zien. Als je opeens niet meer een dag nodig hebt om een kleine verandering aan te brengen, maar 5 minuten.... website breed.
Als je een goede OOP structuur hebt dan is elke verandering op 1 plaats te maken en hoef je nooit hetzelfde te doen op meerdere plaatsen. Dat is de kracht en dan zie je je ongelijk.
Gewijzigd op 09/07/2012 17:46:22 door Erwin H
Ik zie het nu van functies/classes ook wel in, maar het is veel meer code voor hetzelfde wat met minder code ook kan.
2) Meer code, maakt dat jou iets uit? Nee. Maakt het systeem dat iets uit? Nee. Maakt dat de bezoeker iets uit? Nee.
Een kortere tijd om iets bij te werken/verandering aan te brengen. Maakt dat jou iets uit? Ja. Maakt het systeem dat iets uit? Nee. Maakt dat de bezoeker iets uit? Ja.
3) Goed nadenken over wat een script nou doet vs Als een kip zonder kop beginnen met schrijven. Ik weet wel welke beter is...
4) In 1 keer iets flexibel en goed schrijven zodat je dat altijd en in elk project kunt gebruiken i.p.v. alles per project opnieuw te schrijven. Ik weet wel wat ik wil...
5) Een goede structuur in je code hebben, alles mooi verdelen en van je code een overzichtelijk gebeuren maken is nooit fout geweest.
Offtopic:
We gaan wel erg offtopic nu, misschien even een ander topic hiervoor starten?
Gewijzigd op 09/07/2012 18:16:01 door Wouter J
Eddy Erkelens op 09/07/2012 17:54:48:
Euh nee. OO is in dit geval echt flauwekul en overloaded.
Ik zie het nu van functies/classes ook wel in, maar het is veel meer code voor hetzelfde wat met minder code ook kan.
Ik zie het nu van functies/classes ook wel in, maar het is veel meer code voor hetzelfde wat met minder code ook kan.
Nogmaals, voor kleine, simpele websites kan ik je er wel gelijk in geven. Ik heb zelf ook een persoonlijke site waar ik niet veel op heb staan en behalve een database class die ik toch al had gebruik ik daar ook geen OOP voor.
Maar voor complexere websites ligt het echt anders en betwijfel ik zelfs of je wel gelijk hebt met het 'meer code' verhaal. Ik kan wel wat voorbeelden bedenken waarbij dat op zijn minst discutabel is. Maar om verder te gaan ga ik met Wouter mee. Dus wil je hier verder op door (want wel een interessante discussie) dan is een nieuw topic wellicht beter.