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:
var myObject = {},
myFunction = function(){},
myArray = [],
myboolean = true,
myNull = null,
myNumber = 1,
myUndefined; //undefined
console.log(typeof myObject); // "object"
console.log(typeof myFunction); // "function"
console.log(typeof myArray); // "object"
console.log(typeof myboolean); // "boolean"
console.log(typeof myNull); // "object"
console.log(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.
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 (Object.prototype.toString.call(o) === '[object 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.
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 validateArgs(types) {
//get the parameters of the function that is executing validateArgs
var args = validateArgs.caller.arguments,
len = args.length;
//Check if the function get the number of parameter you are expecting
if(types.length !== len){
throw new Error("The amount of parameters allowed is " + types.length + ", received: " + len);
return;
}
//Verify the type of each parameter. If one is wrong, throw an Error
for(var i = 0; i < len; i++){
if(typeOf(args[i]) !== types[i]){
throw new Error('In parameter no. ' + (i+1) + ' the type should be a ' + types[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 types of each parameter in the order the are expected. Example:
function add(n1, n2){
validateArgs(['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!
