Validatie binnen of buiten method
Op dit moment heb ik een class waarbij de setters in de constructor moeten worden aangeroepen, maar ik weet nu niet waar ik de validatie moet plaatsen, het betreft de volgende 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
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
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
/**
* @class Client
* @param {Object} options
*/
var Client = function Client(options)
{
/**
* @returns {Element}
*/
this._canvas;
/**
* @returns {Object}
*/
this._context;
/**
* @returns {Uint}
*/
this._fps;
/**
* @constructor Client
* @param {Object} options
*/
{
}
/**
* @method getCanvas
* @syntax Client.getCanvas()
* @returns {Element}
*/
this.getCanvas = function()
{
};
/**
* @method getContext
* @syntax Client.getContext()
* @returns {Object}
*/
this.getContext = function()
{
};
/**
* @method getFps
* @syntax Client.getFps()
* @returns {Uint}
*/
this.getFps = function()
{
};
/**
* @method setCanvas
* @syntax Client.setCanvas(canvas)
* @param {Element} canvas
*/
this.setCanvas = function(canvas)
{
};
/**
* @method setContext
* @syntax Client.setContext(context)
* @param {String} context
*/
this.setContext = function(context)
{
};
/**
* @method setFps
* @syntax Client.setFps(fps)
* @param {Uint} fps
*/
this.setFps = function(fps)
{
};
};
* @class Client
* @param {Object} options
*/
var Client = function Client(options)
{
/**
* @returns {Element}
*/
this._canvas;
/**
* @returns {Object}
*/
this._context;
/**
* @returns {Uint}
*/
this._fps;
/**
* @constructor Client
* @param {Object} options
*/
{
}
/**
* @method getCanvas
* @syntax Client.getCanvas()
* @returns {Element}
*/
this.getCanvas = function()
{
};
/**
* @method getContext
* @syntax Client.getContext()
* @returns {Object}
*/
this.getContext = function()
{
};
/**
* @method getFps
* @syntax Client.getFps()
* @returns {Uint}
*/
this.getFps = function()
{
};
/**
* @method setCanvas
* @syntax Client.setCanvas(canvas)
* @param {Element} canvas
*/
this.setCanvas = function(canvas)
{
};
/**
* @method setContext
* @syntax Client.setContext(context)
* @param {String} context
*/
this.setContext = function(context)
{
};
/**
* @method setFps
* @syntax Client.setFps(fps)
* @param {Uint} fps
*/
this.setFps = function(fps)
{
};
};
Nu wil ik bij het setten controleren of:
- canvas een element van het type canvas is
- context een string is
- fps een unsigned integer is
Ik weet hoe ik dat moet controleren, nu is alleen nog de vraag; waar controleer ik dit? In de desbetreffende methods, of voordat ik ze meegeef aan de methods, dus in de constructor.
Gewijzigd op 04/07/2014 12:02:39 door Lord Gaga
Op dit moment heb ik het volgende:
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
/**
* @class Client
* @param {Element} canvas
* @param {String} contextType
* @param {Uint} fps
*/
var Client = function Client(canvas, contextType, fps)
{
/**
* @returns {Element}
*/
this._canvas;
/**
* @returns {Object}
*/
this._context;
/**
* @returns {Uint}
*/
this._fps;
/**
* @constructor Client
*/
{
if (Common.isDefined(canvas))
{
try
{
this.setCanvas(canvas);
}
catch(e)
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects parameter 1 to be a valid canvas Element');
}
}
else
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects at least 1 parameter, ' + arguments.length + ' given');
}
if (Common.isDefined(contextType))
{
try
{
this.setContext(contextType);
}
catch(e)
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects parameter 2 to be a valid context type');
}
}
else
{
this.setContext('2d');
}
if (Common.isDefined(fps))
{
try
{
this.setFps(fps);
}
catch(e)
{
throw new Error('Client.construct(canvas, contextType[, fps]) expects parameter 3 to be a valid Uint');
}
}
else
{
this.setFps(60);
}
};
};
/**
* @method getCanvas()
* @syntax Client.getCanvas()
* @returns {Element}
*/
Client.prototype.getCanvas = function()
{
return this._canvas;
};
/**
* @method getContext()
* @syntax Client.getContext()
* @returns {Object}
*/
Client.prototype.getContext = function()
{
return this._context;
};
/**
* @method getFps()
* @syntax Client.getFps()
* @returns {Uint}
*/
Client.prototype.getFps = function()
{
return this._fps;
};
/**
* @method setCanvas
* @syntax Client.setCanvas(canvas)
* @param {Element} canvas
*/
Client.prototype.setCanvas = function(canvas)
{
if (Common.isDefined(canvas))
{
if (Common.isElementSpecific(canvas, 'canvas'))
{
this._canvas = canvas;
}
else
{
throw new Error('Client.setCanvas(canvas) expects parameter 1 to be a valid canvas Element');
}
}
else
{
throw new Error('Client.setCanvas(canvas) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
/**
* @method setContext
* @syntax Client.setContext(contextType);
* @param {String} contextType
*/
Client.prototype.setContext = function(contextType)
{
if (Common.isDefined(contextType))
{
if (contextType === '2d')
{
this._context = this.getCanvas().getContext(contextType);
}
else
{
throw new Error('Client.setContext(context) expects parameter 1 to be a valid context type');
}
}
else
{
throw new Error('Client.setContext(context) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
/**
* @method setFps
* @syntax Client.setFps(fps);
* @param {Uint} fps
*/
Client.prototype.setFps = function(fps)
{
if (Common.isDefined(fps))
{
if (Common.isUint(fps))
{
this._fps = fps;
}
else
{
throw new Error('Client.setFps(fps) expects parameter 1 to be a valid Uint');
}
}
else
{
throw new Error('Client.setFps(fps) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
* @class Client
* @param {Element} canvas
* @param {String} contextType
* @param {Uint} fps
*/
var Client = function Client(canvas, contextType, fps)
{
/**
* @returns {Element}
*/
this._canvas;
/**
* @returns {Object}
*/
this._context;
/**
* @returns {Uint}
*/
this._fps;
/**
* @constructor Client
*/
{
if (Common.isDefined(canvas))
{
try
{
this.setCanvas(canvas);
}
catch(e)
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects parameter 1 to be a valid canvas Element');
}
}
else
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects at least 1 parameter, ' + arguments.length + ' given');
}
if (Common.isDefined(contextType))
{
try
{
this.setContext(contextType);
}
catch(e)
{
throw new Error('Client.construct(canvas[, contextType[, fps]]) expects parameter 2 to be a valid context type');
}
}
else
{
this.setContext('2d');
}
if (Common.isDefined(fps))
{
try
{
this.setFps(fps);
}
catch(e)
{
throw new Error('Client.construct(canvas, contextType[, fps]) expects parameter 3 to be a valid Uint');
}
}
else
{
this.setFps(60);
}
};
};
/**
* @method getCanvas()
* @syntax Client.getCanvas()
* @returns {Element}
*/
Client.prototype.getCanvas = function()
{
return this._canvas;
};
/**
* @method getContext()
* @syntax Client.getContext()
* @returns {Object}
*/
Client.prototype.getContext = function()
{
return this._context;
};
/**
* @method getFps()
* @syntax Client.getFps()
* @returns {Uint}
*/
Client.prototype.getFps = function()
{
return this._fps;
};
/**
* @method setCanvas
* @syntax Client.setCanvas(canvas)
* @param {Element} canvas
*/
Client.prototype.setCanvas = function(canvas)
{
if (Common.isDefined(canvas))
{
if (Common.isElementSpecific(canvas, 'canvas'))
{
this._canvas = canvas;
}
else
{
throw new Error('Client.setCanvas(canvas) expects parameter 1 to be a valid canvas Element');
}
}
else
{
throw new Error('Client.setCanvas(canvas) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
/**
* @method setContext
* @syntax Client.setContext(contextType);
* @param {String} contextType
*/
Client.prototype.setContext = function(contextType)
{
if (Common.isDefined(contextType))
{
if (contextType === '2d')
{
this._context = this.getCanvas().getContext(contextType);
}
else
{
throw new Error('Client.setContext(context) expects parameter 1 to be a valid context type');
}
}
else
{
throw new Error('Client.setContext(context) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
/**
* @method setFps
* @syntax Client.setFps(fps);
* @param {Uint} fps
*/
Client.prototype.setFps = function(fps)
{
if (Common.isDefined(fps))
{
if (Common.isUint(fps))
{
this._fps = fps;
}
else
{
throw new Error('Client.setFps(fps) expects parameter 1 to be a valid Uint');
}
}
else
{
throw new Error('Client.setFps(fps) expects exactly 1 parameter, ' + arguments.length + ' given');
}
};
Gewijzigd op 07/07/2014 16:05:25 door Lord Gaga
Ergens buiten deze class zal deze class één of meerdere keren geinstantïeert worden. Je kunt ook op die plek valideren. Maar waarom wil je dat eigenlijk? komen die variabelen dan van buiten je applicatie? Want dat wat binnen je applicatie blijft mag je wel als veilig beschouwen lijkt mij?
Het gaat me trouwens niet zo zeer om deze class, maar in het algemeen, want ook in de rest van de code die ik schrijf / ga schrijven weet ik niet waar ik nou precies moet valideren.
Gewijzigd op 07/07/2014 19:07:55 door Lord Gaga
Misschien is een ander voorbeeld makkelijker;
Stel je hebt de classes 'User' en 'UserManager'.
Een UserManager kan een User aanmaken:
Code (php)
1
UserManager.createUser('John', 22);
Nu maakt hij een User aan met de naam 'John' en de leeftijd '22'. Waar worden nu de naam en leeftijd gevalideerd?
- In de method createUser?
- In de constructor van User?
- In de constructor van User via een method (_setName(), _setAge())?
Of dit gecombineerd?
een formulier is wat je moet valideren. Waarom? omdat formulieren door mensen worden ingevuld. En mensen doen de meest stomme, onaardige en dwaze dingen die je maar kunt bedenken. En omdat de gegevens van BUITEN je applicatie komen en dus niet te vertrouwen zijn.
en verder hoef je helemaal niets te valideren dus ik zou het antwoord op je vraag dan ook niet weten.