Testing if something is a class in javascript

Question

Hey all, I am trying to test if the argument passed into my function is a class name so that I may compare it to other classes using instanceof.

For example:

function foo(class1, class2) {
  // Test to see if the parameter is a class.
  if(class1 is a class)
  {
    //do some kind of class comparison.
    if(class2 is a class)
    {
       if(class1 instanceof class2)
       {
          //...
       }
    }
    else
    {
       //...
    }
  }
  else
    //...
}

Is this possible? I am having trouble googleing an answer.

Answer 1

There is really no such thing as a "class" in javascript -- everything but primitives are an object. Even functions are objects.

instanceof DOES work with functions though. Check out this link.

function Car(make, model, year)
{
  this.make = make;
  this.model = model;
  this.year = year;
}
var mycar = new Car("Honda", "Accord", 1998);
var a = mycar instanceof Car;    // returns true
var b = mycar instanceof Object; // returns true

Answer 2

Now that we have native implementations of ES6, there are "real classes". These are largely syntactic sugar for prototypal inheritance as with constructor functions, but there are subtle differences and the two are not completely interchangeable.

So far, the only way I've found is to get the .toString() of the object's prototype's constructor function and check if it starts with class OR if the object has a constructor and the .toString() of that starts with class.

Note that if your code is compiled (ie: most Babel or TypeScript setups), then this will return function... instead of class... at runtime (since classes are transpiled to constructor functions).

function isClass(obj) {
  const isCtorClass = obj.constructor
      && obj.constructor.toString().substring(0, 5) === 'class'
  if(obj.prototype === undefined) {
    return isCtorClass
  }
  const isPrototypeCtorClass = obj.prototype.constructor 
    && obj.prototype.constructor.toString
    && obj.prototype.constructor.toString().substring(0, 5) === 'class'
  return isCtorClass || isPrototypeCtorClass
}

This will only work in native environments (Chrome, Firefox, Edge, node.js, etc.) that have implemented class for code that has not been transpiled to function.

Usage:

class A {}
class B extends A {}
isClass(A) // true
isClass(new A()) // true
isClass(B) // true
isClass(new B()) // true

function C() {}
isClass(C) // false
isClass(new C()) // false
isClass({}) // false
isClass(Date) // false
isClass(new Date()) // false

//These cases return 'true' but I'm not sure it's desired
isClass(Object.create(A)) // true    
const x = {}
Object.setPrototypeOf(x, A)
isClass(x) // true

If there is a better way, I'd love to know what it is.

Answer 3

Here's a quick and dirty way to determine if you have a class or a function.

function myFunc() {};
class MyClass {};

Object.getOwnPropertyNames(myFunc);
// -> [ 'length', 'name', 'arguments', 'caller', 'prototype' ]

Object.getOwnPropertyNames(MyClass);
// -> [ 'length', 'prototype', 'name' ]

So we know we have a function and not a class if arguments is a property name:

Object.getOwnPropertyNames(myFunc).includes('arguments');
// -> true

Object.getOwnPropertyNames(MyClass).includes('arguments');
// -> false

Arrow functions and aysnc functions won't have an arguments property name or a prototype. A more complete example might look like this (assuming we know the input can only be a function or a class):

function isFunction(funcOrClass) {
  const propertyNames = Object.getOwnPropertyNames(funcOrClass);
  return (!propertyNames.includes('prototype') || propertyNames.includes('arguments'));
}

function isFunction(funcOrClass) {
  const propertyNames = Object.getOwnPropertyNames(funcOrClass);
  return (!propertyNames.includes('prototype') || propertyNames.includes('arguments'));
}

console.log('class isFunction?', isFunction(class A {}));
console.log('function isFunction?', isFunction(function() {}));
console.log('async function isFunction?', isFunction(async function() {}));
console.log('arrow function isFunction?', isFunction(() => {}));

Answer 4

I know that using constructor.name on a function will return "Function" but doing so on an ES6 class instance will return the name of the class.

I do use it like this:

function isAClassInstance(item){
 return item.constructor.name !== "Function" && item.constructor.name !== "Object";
}

class A {};
function B(){};
const aInstanceClass = new A();
const bFunctionInstance = new B();
const bFunction = B;
const aClass = A;
console.log(aInstanceClass.constructor.name); /*Will return "A"*/
console.log(bFunctionInstance.constructor.name); /*Will return "B"*/
console.log(A.constructor.name); /*Will return "Function"*/
console.log(B.constructor.name); /*Will return "Function"*/
console.log(bFunction.constructor.name); /*Will return "Function"*/
console.log("is A a class instance: ", isAClassInstance(aClass)); /*false*/
console.log("is B a class instance: ", isAClassInstance(aClass)); /*false*/
console.log("is aInstanceClass a class: ", isAClassInstance(aInstanceClass)); /*true*/
console.log("is bFunction a class: ", isAClassInstance(bFunction)); /*false*/
console.log("is bFunctionInstance a class: ", isAClassInstance(bFunctionInstance)); /*true*/

For the cases i used this worked perfectly.

note: since a class is technically a function doing new A() and new B() are both the same thus returning the same result from isAClassInstance. The only way to dinstinguish a function from a class is to not use new on a function and keep this keyword for class only.

Hope this will help :).

Answer 5

JavaScript does not have classes. It has functions which, when used with new, can be used to produce object instances. Therefore, you really want to test if class2 is a function. There are numerous ways of accomplishing this; the current (1.3) implementation of isFunction() in jQuery looks like this:

isFunction: function( obj ) {
    return toString.call(obj) === "[object Function]";
},

...But see here for a rundown of the different methods: Best method of testing for a function in JavaScript?

Answer 6

My solution is by checking if the function prototype has property other than constructor and checking if the function prototype is Function.prototype.

This solution can also work even after transpiled with babel, or the script is running with "use strict". But this solution will only work if the class have at least one public function, or have extend other class.

function isClass(func){
  // Class constructor is also a function
  if(!(func && func.constructor === Function) || func.prototype === undefined)
    return false;
  
  // This is a class that extends other class
  if(Function.prototype !== Object.getPrototypeOf(func))
    return true;
  
  // Usually a function will only have 'constructor' in the prototype
  return Object.getOwnPropertyNames(func.prototype).length > 1;
}


// ----Example----

class Fruit{
  hello(){} // At least must have one public function
}

// Or at least it extend other class
class Pear extends Fruit{}

console.log(isClass(Fruit)); // true
console.log(isClass(Pear)); // true
console.log(isClass(function(){})); // false
console.log(isClass(function(){"use strict"})); // false
console.log(isClass(() => {})); // false
console.log(isClass({hello: 1})); // false

Answer 7

Try this one:

function isClass(C) { 
    return typeof C === "function" && C.prototype !== undefined;
}

Every class is internally just a function that creates instances of this class, plus a prototype property that's assigned to [[Prototype]] of newly created objects to make them behave like instances of this particular class. So, to check if C is a class, you need to check these two things - this is what the isClass() code above does.

Note that all functions declared with function keyword can also be used with new as constructors, and inside instanceof tests. They're equivalent to classes, and have a prototype likewise, so every function of this type is (correctly) recognized as a class by the isClass() function above.

console.log(isClass(Object));    // true
console.log(isClass(Number));    // true
console.log(isClass({a:1}));     // false
console.log(isClass(123));       // false
console.log(isClass("123"));     // false

class A {}
class B extends A {}

console.log(isClass(A));         // true
console.log(isClass(B));         // true
console.log(isClass(new B()));   // false

function f(name) { this.name = name; }

console.log(isClass(f));         // true

Answer 8

Hey just updating an old thread I took one of the above answers and made it work with all the predefined classes in javascript. eg. String, Map, extra

Original:

function isClass(obj) {
  const isCtorClass = obj.constructor
      && obj.constructor.toString().substring(0, 5) === 'class'
  if(obj.prototype === undefined) {
    return isCtorClass
  }
  const isPrototypeCtorClass = obj.prototype.constructor 
    && obj.prototype.constructor.toString
    && obj.prototype.constructor.toString().substring(0, 5) === 'class'
  return isCtorClass || isPrototypeCtorClass
}

New:

export const isClass = (obj) => {
    if (obj == null || typeof obj == "undefined") { return false; }
    const isCtorClass = obj.constructor
        && obj.constructor.toString().substring(0, 5) === 'class'
    const isNativeCtorClass= obj.constructor && 
                                  obj.constructor.name != "Function" && 
                                  obj.constructor.name in global;
    if (obj.prototype === undefined) {
        return isCtorClass || isNativeCtorClass
    }
    const isPrototypeCtorClass = obj.prototype.constructor
        && obj.prototype.constructor.toString
        && obj.prototype.constructor.toString().substring(0, 5) === 'class'

    const isNativePrototypeCtorClass = obj.prototype.constructor.name in global && (
            global[obj.prototype.constructor.name] == obj.constructor || 
            global[obj.prototype.constructor.name] == obj
        );
    return isCtorClass || isPrototypeCtorClass || isNativeCtorClass || isNativePrototypeCtorClass
}

This checks the object in the global javascript object to check if it's a currently registered object.

Let me know if this would break for some use cases but it works for me.

isClass(function test() {})    // false
isClass(() => {})              // false
isClass(function  String() {}) // false
isClass(String)                // true
isClass("")                    // true
isClass(0)                     // true
isClass(class Test {})         // true
isClass(new Number(0))         // true
isClass(new (class Test{})())  // true

Answer 9

After reviewing the answers here I built out my own internal solution. I wanted to ensure that it only returns true if its a Class and not an instance of a class and I wanted distinguish between ES6 and classic / builtin (eg. Array) classes.

This solution should work for anything you throw at it. Please let me know if you find any exceptions.

// Will only return true for ES6 Class definitions
function isES6Class(o) {
    return isClass(o, {es6: true})
}

// Will return any class unless {es6:true} is passed (see isES6Class)
function isClass(o, opts) {
    if(!o)return false
    if(!o.prototype) return false
    if(__cls(o.constructor) || __cls(o.prototype.constructor)) return true
    if(opts && opts.es6) return false

    // Old school or builtin class
    // If is function that has name with first letter capitalized
    if((typeof o) === 'function'){ 
        var s = funcName(o)
        if (s.length > 0){
            var i = s.charCodeAt(0)
            if (i > 64 && i < 91){ return true }
        }
    }
    return false
    function __cls(v){
        return v.toString && v.toString().indexOf('class')===0
    }
}
// helper
var RE_FUNC_DEF = new RegExp("^\\s*function\\s*(\\S*)\\s*\\((.*)\\)");
function funcName(f){
    if (!f) return("(funcName() - f is Nothing!)")
    if(!_.isFunction(f))return("(funcName() - f is not a function!) - f = " + String(f))
    var s = f.toString(), m = s.match(RE_FUNC_DEF)
    if (m && m.length > 1) return m[1]
    return null
}

Answer 10

Based on @Nate answer, which is isFunction I refactored function to return isClass as my reserch and this question is how to check if something is a class.

function isClass(funcOrClass) {
    const propertyNames = Object.getOwnPropertyNames(funcOrClass);
    return propertyNames.includes('prototype') && !propertyNames.includes('arguments');
}

function isFunction(funcOrClass) {
    return typeof funcOrClass === 'function' && !isClass(funcOrClass);
}

Answer 11

I haven't found any 100% certain way to figure out if something is a class and not a function. The accepted answer above works in most cases but if someone redefines the method toString() of their class it may break in that case. Why would they ever redefine toString()? I don't know, ask them if they are still around :-)

So instead I took the approach of defining this function:

function isClass(v)
{ if (typeof v !== "function")
  { return false;
  }
  if ( typeof v.isClass === "function" &&
       v.isClass()
     )
  { return true;
  }
}

This means I can mark my own classes as being classes I recognize as classes by giving them the static method isClass() which returns true. If such classes have subclasses the subclasses inherit the method and are thus automatically recognized as "classes" as well.

If I need to work with someone else's classes which does not have this method I might first subclass their class so that my subclass is like their class except it also has the isClass() -method.

I hope the next version of EcmaScript will remedy this lack of standardized solution but for now this is the best I can do.

It has the additional benefit that I might in fact give the method isClass() to some of my non-class-functions as well, which are not classes proper, and then be able to treat such functions as if they were classes, for whatever reason I might want to.