DEV Community

Lukas Gaucas
Lukas Gaucas

Posted on

Stringify global objects – debugging helpers

[object Window]

Object.prototype.toString.call(this) // '[object Window]'
Object.prototype.toString.call(window) // '[object Window]'
this === window // true
Enter fullscreen mode Exit fullscreen mode

[object Object]

function stringify (x) {
    console.log(Object.prototype.toString.call(x));
}
console.log(stringify({})); // console output: [object Object]
// typeof {} // 'object'
Enter fullscreen mode Exit fullscreen mode

NOTE : [object Object] is most common one . Sometimes it happens then you e.g.:

console.log(`Begin ${object_variable} end.`) 
Enter fullscreen mode Exit fullscreen mode

: if variable of object_variable returns object rather than primitive you will definitely end up into [object Object], solution would be console.log() it outside the template literals e.g.:

console.log(`Begin`, object_variable, `end.`)
Enter fullscreen mode Exit fullscreen mode

: unless object_variable.some_property whereas some_property is some primitive such as Number or String literal then you could stick within template literals as in a first place shown above .


[object Array]

typeof [] /* 'object' : technically it's true as everything in JS is an object under the hood , although it limits debugging , a solution to this is : */
function stringify (x) {
    console.log(Object.prototype.toString.call(x));
}
console.log(stringify([])); // console output: [object Array]
// alternatively do so :
Object.prototype.toString.call([]) === '[object Array]' // true
// or simply  :
Array.isArray([]) // true 
Enter fullscreen mode Exit fullscreen mode

NOTE : we use Array.prototype quite often , sometimes we need to check type i.e. double check if it's not an object an we can apply Array.prototype otherwise if e.g. .push() applied upon Object.prototype would end up in an error message of ".push() is not a function" – common sense – you cannot expect otherwise as Object.prototype is not ant Array i.e. it has no idea what a heck is .push() & what it is doing in a wrong world of Object's ..!


[object String]

// Hereby string presented as object rather than primitive !
Object.prototype.toString.call("" || '' || ``); // [object String]
// e.g.:
Object.prototype.toString.call("" || '' || ``) !== Object.prototype.toString.call(RegExp); // true
// although be careful :
String.prototype.toString.call("food"); // "food"
Object.prototype.toString.call("food"); // [object String]
Enter fullscreen mode Exit fullscreen mode

I guess least used option would be a typeof 'function' , i.e.:

[object Function]

// in function declaration form :..
Object.prototype.toString.call(function(){}); // '[object Function]'
typeof function(){} // 'function'
// in function factory form :..
typeof Function // 'function' 
Object.prototype.toString.call(Function); // '[object Function]'
// although be careful as some X.prototype may still be returned as Function if CCCapitalized e.g.:
Object.prototype.toString.call(Object || Array || String || RegExp); '[object Function]'
Enter fullscreen mode Exit fullscreen mode

To conclude : in most of programming langs the most important is to know what type is returned (debugging) or expected to be returned (testing) – then you know the type i.e. the X.prototype you are dealing with – worst is in the past . Now jump in your IDE & do some coding as well as little of debugging cause it's fun !

Discussion (0)