How to get a JavaScript object s class

Question

I created a JavaScript object  but how I can determine the class of that object   I want something similar to Java s  getClass   method

User · Answer

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 () {
    console.info(this.constructor, this.constructor.name)
    return 'foo'
  }
}

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

    return `${super.foo} + bar`
  }
}

const bar = new Bar()
console.dir(bar.foo)

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.

User · Answer

You can also do something like this    x000D   x000D   class Hello   x000D       constructor    x000D         x000D        x000D       x000D        function isClass  func    x000D          return typeof func      function   amp  amp    class s  test Function prototype toString call func   x000D        x000D       x000D     console log isClass Hello   x000D   x000D   x000D    This will tell you if the input is class or not

User · Answer

To get the  pseudo class   you can get the constructor function  by  obj constructor   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   http   blog magnetiq com post 514962277 finding-out-class-names-of-javascript-objects  function getObjectClass obj        if  obj  amp  amp  obj constructor  amp  amp  obj constructor toString            var arr   obj constructor toString   match               function s   w               if  arr  amp  amp  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 obj constructor name 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

User · Answer

Here s a implementation of getClass   and getInstance    You are able to get a reference for an Object s class using this constructor   From an instance context   function A       this getClass   function         return this constructor         this getNewInstance   function         return new this constructor         var a   new A    console log a getClass          function A      etc          you can even  var b   new  a getClass     console log b instanceof A      true var c   a getNewInstance    console log c instanceof A      true   From static context   function A        A getClass   function       return this     A getInstance       return new this

User · Answer

I suggest using Object prototype constructor name   Object defineProperty Object prototype   getClass         value  function           return this constructor name             var x   new DOMParser    console log x getClass         DOMParser   var y   new Error      console log y getClass         Error

User · Answer

Agree with dfa  that s why i consider the prototye as the class when no named class found  Here is an upgraded function of the one posted by Eli Grey  to match my way of mind  function what obj       if typeof obj     undefined  return  undefined       if obj   null return  Null       var res   Object prototype toString call obj  match     object s          1       if res    Object            res   obj constructor name          if typeof res    string     res length  0               if obj instanceof jQuery return  jQuery     jQuery build stranges Objects             if obj instanceof Array return  Array     Array prototype is very sneaky             return  Object                       return res

User · Answer

There is one another technique to identify your class You can store ref to your class in instance like bellow  class MyClass       static myStaticProperty    default       constructor             this   class     new target          this showStaticProperty   function                 console log this   class   myStaticProperty                      class MyChildClass extends MyClass       static myStaticProperty    custom      let myClass   new MyClass    let child   new MyChildClass     myClass showStaticProperty       default child showStaticProperty       custom  myClass   class       MyClass     true child   class       MyClass     false child   class       MyChildClass     true

User · Answer

In javascript  there are no classes  but I think that you want the constructor name and obj constructor toString   will tell you what you need

User · Answer

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     typeof instanceof obj constructor func prototype  proto isPrototypeOf   A few examples   function Foo      var foo   new Foo     typeof Foo                     function  typeof foo                     object   foo instanceof Foo            true foo constructor name           Foo  Foo name                       Foo       Foo prototype isPrototypeOf foo           true  Foo prototype bar   function  x   return x x    foo bar 21                    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

User · Answer

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

User · Answer

If you need to not only GET class but also EXTEND it from having just an instance  write  let s have  class A      constructor name         this name   name            const a1   new A  hello a1     so to extend A having the instance only use  const a2   new  Object getPrototypeOf a   constructor  hello a2      the analog of const a2   new A    console log a2 name    hello a2

User · Answer

Question seems already answered but the OP wants to access the class of and object  just like we do in Java and the selected answer is not enough  imho    With the following explanation  we can get a class of an object it s actually called prototype in javascript    var arr   new Array  red    green    blue    var arr2   new Array  white    black    orange      You can add a property like this   Object defineProperty arr  last       get  function        return this this length -1           console log arr last     blue   But  last property will only be available to  arr  object which is instantiated from Array prototype  So  in order to have the  last property to be available for all objects instantiated from Array prototype  we have to define the  last property for Array prototype   Object defineProperty Array prototype  last       get  function        return this this length -1           console log arr last     blue console log arr2 last     orange   The problem here is  you have to know which object type  prototype  the  arr  and  arr2  variables belongs to  In other words  if you don t know class type  prototype  of the  arr  object  then you won t be able to define a property for them  In the above example  we know arr is instance of the Array object  that s why we used Array prototype to define a property for Array  But what if we didn t know the class prototype  of the  arr    Object defineProperty arr   proto    last2       get  function        return this this length -1           console log arr last     blue console log arr2 last     orange   As you can see  without knowing that  arr  is an Array  we can add a new property just bu referring the class of the  arr  by using  arr   proto      We accessed the prototype of the  arr  without knowing that it s an instance of Array and I think that s what OP asked

User · Answer

This getNativeClass   function returns  quot undefined quot  for undefined values and  quot null quot  for null For all other values  the CLASSNAME-part is extracted from  object CLASSNAME   which is the result of using Object prototype toString call value   getAnyClass   behaves the same as getNativeClass    but also supports custom constructors function getNativeClass obj      if  typeof obj      quot undefined quot   return  quot undefined quot     if  obj     null  return  quot null quot     return Object prototype toString call obj  match     object s          1      function getAnyClass obj      if  typeof obj      quot undefined quot   return  quot undefined quot     if  obj     null  return  quot null quot     return obj constructor name     getClass  quot  quot          quot String quot   getClass true       quot Boolean quot   getClass 0          quot Number quot   getClass            quot Array quot   getClass            quot Object quot   getClass null       quot null quot    getAnyClass new  function Foo            quot Foo quot   getAnyClass new class Foo         quot Foo quot       etc

User · Answer

i had a situation to work generic now and used this   class Test        your class definition    nameByType   function type     return type prototype  constructor    name        console log nameByType Test      thats the only way i found to get the class name by type input if you don t have a instance of an object    written in ES2017   dot notation also works fine  console log Test prototype constructor name      returns  Test

User · Answer

getClass   function using constructor prototype name I found a way to access the class that is much cleaner than some of the solutions above  here it is  function getClass obj           if the type is not an object return the type    if  let type   typeof obj       object   return type             otherwise  access the class using obj constructor name    else return obj constructor name        How it works the constructor has a property called name accessing that will give you the class name  cleaner version of the code  function getClass obj           if the type is not an object return the type    let type   typeof obj    if  type      object             return type        else     otherwise  access the class using obj constructor name       return obj constructor name

User · Answer

For Javascript Classes in ES6 you can use object constructor  In the example class below the getClass   method returns the ES6 class as you would expect   var Cat   class        meow              console log  meow                 getClass              return this constructor             var fluffy   new Cat          var AlsoCat   fluffy getClass    var ruffles   new AlsoCat     ruffles meow           meow     If you instantiate the class from the getClass method make sure you wrap it in brackets e g  ruffles   new   fluffy getClass      args

User · Answer

I find object constructor toString   return  object objectClass  in IE  rather than function objectClass       returned in chome  So I think the code in http   blog magnetiq com post 514962277 finding-out-class-names-of-javascript-objects may not work well in IE And I fixed the code as follows  code  var getObjectClass   function  obj            if  obj  amp  amp  obj constructor  amp  amp  obj constructor toString                                                          for browsers which have name property in the constructor                     of the object such as chrome                                      if obj constructor name                        return obj constructor name                                    var str   obj constructor toString                                          executed if the return of object constructor toString   is                      quot  object objectClass  quot                                                        if str charAt 0                                                    var arr   str match     w  s   w                          else                                                         executed if the return of object constructor toString   is                              quot function objectClass       quot                             for IE Firefox                                                     var arr   str match  function s   w                                        if  arr  amp  amp  arr length    2                                return arr 1                                                   return undefined

User · Answer

Any object in JavaScript is created based on a constructor function  And each function  including a constructor one  owns a name  which we can easily read  class Person     type    quot developer quot     let p   new Person     p constructor name    Person

User · Answer

obj constructor name   is a reliable method in modern browsers  Function name 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 obj constructor name     MyType   instead check obj constructor name    MyType name  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

User · Answer

Javascript is a class-less languages  there are no classes that defines the behaviour of a class statically as in Java  JavaScript uses prototypes instead of classes for defining object properties  including methods  and inheritance  It is possible to simulate many class-based features with prototypes in JavaScript

[javascript] How to get a JavaScript object's class?

Examples related to javascript

Examples related to oop