How to get a JavaScript object’s class?

How to get a JavaScript object’s class?

I created a JavaScript object, but how I can determine the class of that object?
I want something similar to Java’s .getClass() method.


Solution 1:

There’s no exact counterpart to Java’s getClass() in JavaScript. Mostly that’s due to JavaScript being a prototype-based language, as opposed to Java being a class-based one.

Depending on what you need getClass() for, there are several options in JavaScript:

A few examples:

function Foo() {}
var foo = new Foo();

typeof Foo;             // == "function"
typeof foo;             // == "object"

foo instanceof Foo;     // == true;   // == "Foo"                // == "Foo"    

Foo.prototype.isPrototypeOf(foo);   // == true = function (x) {return x+x;};;            // == 42

Note: if you are compiling your code with Uglify it will change non-global class names. To prevent this, Uglify has a --mangle param that you can set to false is using gulp or grunt.

Solution 2:

is a reliable method in modern browsers. was officially added to the standard in ES6, making this a standards-compliant means of getting the “class” of a JavaScript object as a string. If the object is instantiated with var obj = new MyClass(), it will return “MyClass”.

It will return “Number” for numbers, “Array” for arrays and “Function” for functions, etc. It generally behaves as expected. The only cases where it fails are if an object is created without a prototype, via Object.create( null ), or the object was instantiated from an anonymously-defined (unnamed) function.

Also note that if you are minifying your code, it’s not safe to compare against hard-coded type strings. For example instead of checking if == "MyType", instead check == Or just compare the constructors themselves, however this won’t work across DOM boundaries as there are different instances of the constructor function on each DOM, thus doing an object comparison on their constructors won’t work.

Note when chaining prototypes

Edit: This is apparently moot now that ES6 has better support for classes and inheritance. As adalbertpl explains, behaves as expected in that scenario.

Oddly enough, returns the name of the base-most function used in a prototype chain, which is unfortunately not intuitive. For example, if B derives prototypically from A and you create a new instance of B, b, returns “A”, which seems wrong. It does work fine for single-level prototypes and all primitives, however.

Solution 3:

This function returns either "undefined", "null", or the "class" in [object class] from

function getClass(obj) {
  if (typeof obj === "undefined")
    return "undefined";
  if (obj === null)
    return "null";

getClass("")   === "String";
getClass(true) === "Boolean";
getClass(0)    === "Number";
getClass([])   === "Array";
getClass({})   === "Object";
getClass(null) === "null";
// etc...

Solution 4:

To get the “pseudo class”, you can get the constructor function, by


assuming the constructor is set correctly when you do the inheritance — which is by something like:

Dog.prototype = new Animal();
Dog.prototype.constructor = Dog;

and these two lines, together with:

var woofie = new Dog()

will make woofie.constructor point to Dog. Note that Dog is a constructor function, and is a Function object. But you can do if (woofie.constructor === Dog) { ... }.

If you want to get the class name as a string, I found the following working well:

function getObjectClass(obj) {
    if (obj && obj.constructor && obj.constructor.toString) {
        var arr = obj.constructor.toString().match(

        if (arr && arr.length == 2) {
            return arr[1];

    return undefined;

It gets to the constructor function, converts it to string, and extracts the name of the constructor function.

Note that could have worked well, but it is not standard. It is on Chrome and Firefox, but not on IE, including IE 9 or IE 10 RTM.

Solution 5:

You can get a reference to the constructor function which created the object by using the constructor property:

function MyObject(){

var obj = new MyObject();
obj.constructor; // MyObject

If you need to confirm the type of an object at runtime you can use the instanceof operator:

obj instanceof MyObject // true

Solution 6:

In keeping with its unbroken record of backwards-compatibility, ECMAScript 6, JavaScript still doesn’t have a class type (though not everyone understands this). It does have a class keyword as part of its class syntax for creating prototypes—but still no thing called class. JavaScript is not now and has never been a classical OOP language. Speaking of JS in terms of class is only either misleading or a sign of not yet grokking prototypical inheritance (just keeping it real).

That means this.constructor is still a great way to get a reference to the constructor function. And this.constructor.prototype is the way to access the prototype itself. Since this isn’t Java, it’s not a class. It’s the prototype object your instance was instantiated from. Here is an example using the ES6 syntactic sugar for creating a prototype chain:

class Foo {
  get foo () {,
    return 'foo'

class Bar extends Foo {
  get foo () {'[THIS]', this.constructor,, Object.getOwnPropertyNames(this.constructor.prototype))'[SUPER]', super.constructor,, Object.getOwnPropertyNames(super.constructor.prototype))

    return `${} + bar`

const bar = new Bar()

This is what that outputs using babel-node:

> $ babel-node ./foo.js                                                                                                                   ⬡ 6.2.0 [±master ●]
[THIS] [Function: Bar] 'Bar' [ 'constructor', 'foo' ]
[SUPER] [Function: Foo] 'Foo' [ 'constructor', 'foo' ]
[Function: Bar] 'Bar'
'foo + bar'

There you have it! In 2016, there’s a class keyword in JavaScript, but still no class type. this.constructor is the best way to get the constructor function, this.constructor.prototype the best way to get access to the prototype itself.