Validatie binnen of buiten method

Door Lord Gaga op 04-07-2014 12:02 gewijzigd op 04-07-2014 12:02

1.752 views

Hallo,

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:


/**
 * @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.

Lord Gaga

07-07-2014 16:03 gewijzigd op 07-07-2014 16:05

Iemand?

Op dit moment heb ik het volgende:


/**
 * @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');
	}
};

Frank Nietbelangrijk

07-07-2014 16:21

Deze class is - denk ik - verantwoordelijk voor het 'tijdelijk bewaren' van de data van één client.

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?

Lord Gaga

07-07-2014 19:04 gewijzigd op 07-07-2014 19:07

'Client' is het hoofdobject. Deze maakt (via andere classes) instanties van alle objecten in de game aan. Elk client object heeft bijvoorbeeld een StageManager en een KeyboardManager.

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.

Lord Gaga

10-07-2014 12:44

Iemand? Ik kom er niet echt uit.
Misschien is een ander voorbeeld makkelijker;

Stel je hebt de classes 'User' en 'UserManager'.
Een UserManager kan een User aanmaken:


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?

Frank Nietbelangrijk

10-07-2014 21:32

Nogmaals waarom die drang om te valideren?

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.

Reageren

Inloggen om te reageren