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
More
Chinese
Taiwan
Deutsch
Italian
Janpanese
Korean
Turkish
Indonesian
Ukraine
Polish
Spanish
Slovenian
Recent articles How to open a car sharing service Vue developer as a vital part of every software team 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
Top view articles Top 10 Beautiful Christmas Countdown Timers Adding JavaScript to WordPress Effectively with JavaScript Localization feature 65 Free JavaScript Photo Gallery Solutions 16 Free Code Syntax Highlighters by Javascript For Better Programming Best Free Linux Web Programming Editors Top 10 Best JavaScript eBooks that Beginners should Learn Top 50 Most Addictive and Popular Facebook mini games More 30 Excellent JavaScript/AJAX based Photo Galleries to Boost your Sites Top 10 Free Web Chat box Plug-ins and Add-ons The Ultimate JavaScript Tutorial in Web Design