google+javascriptbanktwitter@js_bankfacebook@jsbankrss@jsbank
Guest, register






Validating JavaScript Argument Type and JavaScript Object Type This JavaScript article tutorial provides us an overview to determine and validate the argument types of JavaScript objects, JavaScript functions and JavaScript variables with typeof and instanceof operators. Full detailed instructions and JavaScript code examples inside.


Free iPage Web Hosting for First Year NOW



If you're still looking for a reliable web host provider with affordable rates, why you don't take a little of time to try iPage, only with $1.89/month, included $500+ Free Extra Credits for the payment of 24 months ($45)?

Over 1,000,000+ existisng customers can not be wrong, definitely you're not, too! More important, when you register the web hosting at iPage through our link, we're going to be happy for resending a full refund to you. That's awesome! You should try iPage web hosting for FREE now! And contact us for anything you need to know about iPage.
Try iPage for FREE First Year NOW

The "typeof" operator is very useful at the moment for checking what kind or type of object we are dealing with. It returns a string containing the datatype of the object. The values returned are "number", "string", "boolean", "undefined", "function", and "object". However, this operator has some flaws at the time of detecting an array or a null value which in those cases it returns "object". Example:

var myObject = {},

  myFunction = function(){},
  myArray = [],

  myboolean = true,
  myNull = null,
  myNumber = 1,

  myUndefined = undefined;
 
typeof myObject; // "object"
typeof myFunction; // "function"

typeof myArray; // "object"
typeof myboolean // "boolean"
typeof myNull; // "object"

typeof myUndefined; // "undefined"

How to solve it?

With the help of instanceof We can create a function to determinate exactly what type of object it is. Example:

function typeOf(o){

	var type = typeof o;
         //If typeof return something different than object then returns it.
	if (type !== 'object') {

		return type;
         //If it is an instance of the Array then return "array"
	} else if (o instanceof Array) {

		return 'array';
         //If it is null then return "null"
	} else if (o === null) {

		return 'null';
       //if it gets here then it is an "object"
	} else {
		return 'object';

	}
}

Now we can easily execute the "typeOf" function to verify the real type of an object. Example:

 typeOf([34,45,6,67,8]); // "array"

 typeOf(null); // "null"

We are going to utilize this function as a helper to validate the type of the arguments or parameters of a function in the next section.

Argument Type Validation

As everybody knows, JavaScript is a loosely typed language, and we cannot declare arguments type in or method definitions. Some programmers have chosen different methodologies in order to avoid errors. One of them is the commenting the type of the parameter next it. Example:

function add(num1 /* number */, num2 /* number */);

This methodology works fine, the only problem is that it really does nothing. At the moment we pass a wrong parameter type, it would break our code and we can spend some time debugging just for a simple parameter. In order to solve this issue we can create a function "validArgs" that will use the "typeOf" function that we just created and performs some validation in the parameters passed to the function.

function validArgs(num, arrayType){
//get the parameters of the function that is executing validArgs
   var args = validArgs.caller.arguments,

          len = args.length;
//Check if the function get the number of parameter you are expecting. If not throw an error.
//If the parameter declared is 0 then do not perform this check
    if(num){

         if(num !== len){
  	    throw new Error('The amount of paramerts allow it is ' + num + ', received '+ len);

         }
     }
    //Verify the type of each of the parameters. If one is wrong throw an error.
    if(arrayType){
 	for(var i = 0; i < len; i++){

	    if(typeOf(args[i]) !== arrayType[i]){

		throw new Error('In parameter no. ' + (i+1)  + ' the type should be ' + arrayType[i] + ', received ' + typeOf(args[i]));

	    }           
	}
     }
}

The use of this function is very simple. In the first parameter we specify the amount of amount of arguments we are expecting in the function, and the second one is an array containing the the types of each parameter in the order the are expected. Example:

function add(n1, n2){

    validArgs(2, ['number', 'number']);
    return n1 + n2;

}
 
add(20,30) // 50
add(20, 'hello world') //Error: In parameter no. 2 the type should be number, received string

Conclusion

In conclusion, even though JavaScript is a loosely typed language, we can create some functions to solve this "problem". The beauty of JavaScript is that it is a loosely typed language and that gives you a lot of flexibilities at the time of coding an application. These functions can save a lot of time from debugging and I can recommend their use only in functions that you are expecting exactly one kind of arguments in their specific order. Hope you found this useful!

JavaScript by day


Google Safe Browsing McAfee SiteAdvisor Norton SafeWeb Dr.Web