How to check if a function is a constructor

You are looking for if a function has a [[Construct]] internal method. The internal method IsConstructor details the steps:

IsConstructor(argument)

ReturnIfAbrupt(argument).  // (Check if an exception has been thrown; Not important.)  
If Type(argument) is not Object, return false.  // argument === Object(argument), or (typeof argument === 'Object' || typeof argument === 'function')  
If argument has a [[Construct]] internal method, return true.  
Return false.

Now we need to find places where IsConstructor is used, but [[Construct]] isn't called (usually by the Construct internal method.)

I found that it is used in the String function's newTarget (new.target in js), which can be used with Reflect.construct:

function is_constructor(f) {
  try {
    Reflect.construct(String, [], f);
  } catch (e) {
    return false;
  }
  return true;
}

(I could have used anything really, like Reflect.construct(Array, [], f);, but String was first)

Which yields the following results:

// true
is_constructor(function(){});
is_constructor(class A {});
is_constructor(Array);
is_constructor(Function);
is_constructor(new Function);

// false
is_constructor();
is_constructor(undefined);
is_constructor(null);
is_constructor(1);
is_constructor(new Number(1));
is_constructor(Array.prototype);
is_constructor(Function.prototype);
is_constructor(() => {})
is_constructor({method() {}}.method)

<note>

The only value that I found it didn't work for is Symbol, which, although new Symbol throws a TypeError: Symbol is not a constructor in Firefox, is_constructor(Symbol) === true. This is technically the correct answer, as Symbol does have a [[Construct]] internal method (Which means it can also be subclassed), but using new or super is special cased for Symbol to throw an error (So, Symbol is a constructor, the error message is wrong, it just can't be used as one.) You can just add if (f === Symbol) return false; to the top though.

The same for something like this:

function not_a_constructor() {
  if (new.target) throw new TypeError('not_a_constructor is not a constructor.');
  return stuff(arguments);
}

is_constructor(not_a_constructor);  // true
new not_a_constructor;  // TypeError: not_a_constructor is not a constructor.

So the intentions of the function of being a constructor can't be gotton like this (Until somthing like Symbol.is_constructor or some other flag is added).

</note>

With ES6+ Proxies, one can test for [[Construct]] without actually invoking the constructor. Here's a snippet:

const handler={construct(){return handler}} //Must return ANY object, so reuse one
const isConstructor=x=>{
    try{
        return !!(new (new Proxy(x,handler))())
    }catch(e){
        return false
    }
}

If the passed item isn't an object, the Proxy constructor throws an error. If it's not a constructable object, then new throws an error. But if it's a constructable object, then it returns the handler object without invoking its constructor, which is then not-notted into true.

As you might expect, Symbol is still considered a constructor. That's because it is, and the implementation merely throws an error when [[Construct]] is invoked. This could be the case on ANY user-defined function that throws an error when new.target exists, so it doesn't seem right to specifically weed it out as an additional check, but feel free to do so if you find that to be helpful.

There is a quick and easy way of determining if function can be instantiated, without having to resort to try-catch statements (which can not be optimized by v8)

function isConstructor(obj) {
  return !!obj.prototype && !!obj.prototype.constructor.name;
}

1. First we check if object is part of a prototype chain.
2. Then we exclude anonymous functions

There is a caveat, which is: functions named inside a definition will still incur a name property and thus pass this check, so caution is required when relying on tests for function constructors.

In the following example, the function is not anonymous but in fact is called 'myFunc'. It's prototype can be extended as any JS class.

let myFunc = function () {};

If the function is a constructor then it will have a "prototype" member which in turn has a "constructor" member that is equal to the function itself.

function isConstructor(func) {
    return typeof func === 'function' && !!func.prototype && func.prototype.constructor === func;
}

There is a quick and easy way of determining if function can be instantiated, without having to resort to try-catch statements, which can not be optimized by v8 (until 2017), and which requires the constructor to support said try-catch.

function isConstructor(value) {
    return !!value && !!value.prototype && !!value.prototype.constructor;
}

1. First, we check value is truthy.
2. Then checks if value is part of a prototype chain.
3. At last, simply checks if constructor is set ;-)

Note that above is named isConstructor not is isConstructable, I mean, this will return false for Bound-constructors as said in comments, because "bound" means to redirect to something, instead of being a real constructor directly.

So this answers title's "check ... is constructor" question, but not later "check ... can be called with new" question.

Example:

const myClazz = {method() {}};
myClazz.method = myClazz.method.bind(myClazz);

// We can call above with new keyword.
new (myClazz.method);

// But it's just a callback.
if (isConstructor(myClass))
   throw new Error('expected to return false for arrow-functions and similar.');

Unit-testing

Below is based on Jasmine.

// Change import to wherever your common functions are 
// (for me they're in src directory, outside of tests directory).
import * as common from '../common-tools';

let isMyClassCalled = false;
class MyClass {
  constructor() {
      isMyClassCalled = true;
  }
}

describe('App isConstructor tool', () => {
    it('should detect constructor', function () {
        detect(class A {});
        detect(Array);
        detect(Function);
        detect(new Function);
        detect({method() {}}.method);
    });

    it('should NOT detect as constructor', function () {
        noDetect();
        noDetect(undefined);
        noDetect(null);
        noDetect(1);
        noDetect(new Number(1));
        noDetect(new (function(){}));
        noDetect(Array.prototype);
        noDetect(Function.prototype);
        // Commented because optimizations convert below into function.
        //noDetect((() => {}));
    });

    it('should NOT detect bound constructors', function () {
        const clazz = {method() {}};
        clazz.method = clazz.method.bind(clazz);
        noDetect(clazz.method);
    });

    it('should never call constructor', function () {
        common.isConstructor(MyClass);
        expect(isMyClassCalled).toBe(false);
    });

    function detect(value, expecting = true) {
        expect(common.isConstructor(value))
            .withContext('For "' + value + '" value')
            .toBe(expecting);
    }

    function noDetect(value) {
        detect(value, false);
    }
});

Alternative

All above tests pass with below as well.

function isConstructor(value) {
    return typeof value === 'function' && !!value.prototype && value.prototype.constructor === value;
}

If speed is what you're after and you're not worried about edge cases:

typeof value=='function' && !!value.prototype

But if you're looking for some level of fool-proofness without using try/catch, this uses a regular expression on the string representation of functions to green light uppercase functions and all user-defined functions which are always constructable, while always ruling out arrow functions. Try/catch is only used in the edge case of bound and some native functions. Works in old browsers.

function isConstructable(value) {
    if (typeof value=='function') {

        // Test if Function.prototype.toString works as expected
        // due to many browsers having unexpected implementations.
        // This test can be moved into global scope.
        var FUNC2STRING = /^\s*function\s*Date\s*\(\)\s*\{\s*\[native code\b/.test(Date) && Date.toString
        
        if (FUNC2STRING) {
            // test for arrow function, else extract name from native function
            var matches = /^[^{*]*(?:\/\*[\s\S]*?\*\/[^{*]*)*=>|^\s*function\s*([\w\$]*)\s*\(\)\s*\{\s*\[native code\b/.exec(FUNC2STRING.call(value));

            if (!matches || /^[A-Z]/.test(matches[1])) {
                // non-native and uppercase functions are always constructable.
                return true;
            }
        }

        // Other native functions must be tested more rigorously
        // since they might be bound functions or otherwise constructable
        if (!matches || matches[1]!=null) {
            // necessary to test bound functions constructability
            try {
                // Throws if target function is not constructable
                typeof Proxy=='function'?
                    new new Proxy(value, {construct:Object})// ES6 needed
                :
                    {} instanceof value;
                return true;
            }
            catch(e) {
            }
        }
        
    }
    return false;
}

If you want the best of both worlds, this prioritizes speed over edge cases while still supporting bound functions. Works in ES6+:

function isConstructableFast(value) {
    if (typeof value=='function') {
        if (value.prototype) {
            var retval = true;
        }
        else if (value.name.slice(0, 6)=='bound ') try {
            retval = new new Proxy(value, {construct:Object});
        }
        catch(e) {
        }
    }
    return !!retval;
}

I tried many workarounds but it didn't satisfy my needs, So i made my own workaround by using reflection metadata.

GOAL: Check if the current Function has it's own __class__ metadata which represent if this function is a constructor or not.

• npm install reflect-metadata
• Create class decorator factory @Class()
• Create a helper function to check __class__ metadata attached to the current function or not.

NOTE: The only way in this workaround to distinguish between Constructor Function and Normal Function or Class is by using Class Decorator @Class()

import 'reflect-metadata';

type Constructor<T = any> = new (...args: any[]) => T;

function Class() {
    return function (target: Constructor) {
        if (!!Reflect.getOwnMetadata('__class__', target)) {
            throw new Error(`Cannot apply @Class decorator on ${target.name} multiple times.`);
        }
        Reflect.defineMetadata('__class__', target, target);
    };
}

function isConstructor<T>(type: Constructor<T>): boolean {
    if (typeof type !== 'function') return false;
    return !!Reflect.getOwnMetadata('__class__', type);
}

/*
 * ------------------
 * Example
 * ------------------
 */

@Class()
class ServiceClass1 {}

class ServiceClass2 {}

function Test() {}

console.log(isConstructor(ServiceClass1)) // true
console.log(isConstructor(ServiceClass2)) // false
console.log(isConstructor(Test)) // false

The simple way in ECMAScript 2015 and later (without calling the function) is to try to make a subclass:

function isConstructor(f)
{
    try
    {
        class test extends f {}
        return true
    }
    catch(e)
    {
        return false
    }
}

function test(f, name) {
    console.log(`${name} is constructable: ${isConstructor(f)}`);
}

test(class foo {}, 'class expression')
test(function (){console.log('fn called')}, 'function expression') // doesn't print
test(x=>0, 'arrow function')  
test({x(){}}.x, 'shorthand method (no function keyword)')

For question 1, what about this helper?

Function.isConstructor = ({ prototype }) => Boolean(prototype) && Boolean(prototype.constructor)

Function.isConstructor(class {}); // true
Function.isConstructor(function() {}); // true
Function.isConstructor(() => {}); // false
Function.isConstructor("a string"); // false

For question 2, the arrow function is the solution. It cannot be used as a constructor since it does not rely on the same scope as a regular function and does not have a prototype (definition of instances, similar to class definition for real OOP)

const constructable = function() { console.log(this); };
const callable = () => { console.log(this); };

constructable(); // Window {}
callable(); // Window {}
new constructable(); // aConstructableFunction {}
new callable(); // Uncaught TypeError: callable is not a constructor

As an addition to Felix Kling's answer, even if a function is not constructable, we can still use it like a constructor if it has a prototype property. We can do this with the help of Object.create(). Example:

// The built-in object Symbol is not constructable, even though it has a "prototype" property:
new Symbol
// TypeError: Symbol is not a constructor.
Object.create(Symbol.prototype);
// Symbol {}
//   description: (...)
//   __proto__: Symbol

If you need a solution that works in old browsers (ES3+), you can use instanceof because it will throw if the right-side operator is not constructor. More exactly, it will throw if the right-side operator is not a function or has no prototype object which in the most common use case is not a constructor. It also works with constructables created with Function.prototype.bind() because instanceof checks the prototype property of the bound target function.

The Proxy solution provided by Ryan Hanekamp is also incorporated into my answer below because it takes care of edge cases that instanceof does not.

function isConstructable(value) {
    try {
        typeof Proxy=='function'?
            // Throws if value is not constructable
            new new Proxy(value, {construct:Object})// ES6 needed
        :
            // Throws if not function or target function has no prototype object
            {} instanceof value;
        var isConstructable = true;
    }
    catch(e) {
    }
    return !!isConstructable;
}

here is my solution:

const isFunction = (val) => {
  return typeof val === 'function' || Object.prototype.toString.apply(val) === '[object Function]'
}

/**
 * 检测测试数据是否为 JavaScript 内置函数
 * ========================================================================
 * @method isNativeFunction
 * @param {Function|Object} fn - 要测试的函数
 * @returns {Boolean} - fn 是内置函数，返回 true，否则返回 false;
 */
const isNativeFunction = (fn) => {
  return isFunction(fn) && /\{\s*\[native code\]\s*\}/.test('' + fn)
}

import isFunction from './isFunction'
import isNativeFunction from './isNativeFunction'

/**
 * 检测测试函数是否为构造函数
 * ========================================================================
 * @method isConstructor
 * @category Lang
 * @param {Function|Object} fn - 要测试的（构造）函数
 * @returns {Boolean} - fn 是构造函数，返回 true，否则返回 false;
 */
const isConstructor = (fn) => {
  const proto = fn.prototype
  const constructor = fn.constructor
  let instance

  if (!isFunction(fn) || !proto) {
    return false
  }

  if (
    isNativeFunction(fn) &&
    (constructor === Function || constructor === fn)
  ) {
    return true
  }

  // 判断 fn 是否为 Promise 构造函数
  instance = new fn()

  // 判断 constructor
  return (
    (instance.constructor === fn && instance instanceof fn) ||
    (instance.constructor === Object && instance instanceof Object)
  )
}