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.


Sampled by © JavaScriptBank.com

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!

Language
Translate this page to English Translate this page to French Translate this page to Vietnamese

Recent articles
Vue.js developers: hire them, use them and get ahead of the competition
3 Reasons Why Java is so Popular
Migrate to Angular: why and how you should do it
The Possible Working Methods of Python Ideology
JavaScript Research Paper: 6 Writing Tips to Craft a Masterpiece
Learning How to Make Use of New Marketing Trends
5 Important Elements of an E-commerce Website
How To Create A Successful Prototype For Your PCB
WordPress Landing Page Conversion Essentials to Convert More
Lifeasapa and Neurosphere


Top view articles
Top 10 Beautiful Christmas Countdown Timers
65 Free JavaScript Photo Gallery Solutions
Best Free Linux Web Programming Editors
Top 50 Most Addictive and Popular Facebook mini games
Top 10 Free Web Chat box Plug-ins and Add-ons
Top 10 Best JavaScript eBooks that Beginners should Learn
50+ Beautiful Resources of HTML Form using CSS and JavaScript
The Ultimate JavaScript Tutorial in Web Design
10 Great JavaScript Frameworks for Faster JavaScript Application Development
HTML5 Web Workers Multithreading in JavaScript


Free JavaScript Tutorials & Articles
at www.JavaScriptBank.com