Get functions (methods) of a class [duplicate]

I have to dynamically fetch the properties and functions of a ES6 class. Is this even possible?

Using a loop, I only get to loop through the properties of a class instance:

class Foo {
  constructor() { = "hi";
  someFunc() {
var foo = new Foo();
for (var idx in foo) {





The members of a class are not enumerable. To get them, you have to use Object.getOwnPropertyNames:

var propertyNames = Object.getOwnPropertyNames(Object.getPrototypeOf(foo));
// or
var propertyNames = Object.getOwnPropertyNames(Foo.prototype);

Of course this won't get inherited methods. There is no method that can give you all of them. You'd have to traverse the prototype chain and get the properties for each prototype individually.


ES6 adds Reflection which makes the code to do this a bit cleaner.

function getAllMethodNames(obj) {
  let methods = new Set();
  while (obj = Reflect.getPrototypeOf(obj)) {
    let keys = Reflect.ownKeys(obj)
    keys.forEach((k) => methods.add(k));
  return methods;

/// a simple class hierarchy to test getAllMethodNames

// kind of like an abstract base class
class Shape {
  constructor() {}
  area() {
    throw new Error("can't define area for generic shape, use a subclass")

// Square: a shape with a sideLength property, an area function and getSideLength function
class Square extends Shape {
  constructor(sideLength) {
    this.sideLength = sideLength;
  area() {
    return this.sideLength * this.sideLength
  getSideLength() {
    return this.sideLength

// ColoredSquare: a square with a color
class ColoredSquare extends Square {
  constructor(sideLength, color) {
    this.color = color;
  getColor() {
    return this.color

let temp = new ColoredSquare(2, "red");
let methods = getAllMethodNames(temp);


There were a few issues in @MuhammadUmer answer for me (symbols, index i+1, listing of Object methods, etc...) so taking inspiration from it, I came up with this

(warning Typescript compiled to ES6)

const getAllMethods = (obj) => {
    let props = []

    do {
        const l = Object.getOwnPropertyNames(obj)
            .concat(Object.getOwnPropertySymbols(obj).map(s => s.toString()))
            .filter((p, i, arr) =>
                typeof obj[p] === 'function' &&  //only the methods
                p !== 'constructor' &&           //not the constructor
                (i == 0 || p !== arr[i - 1]) &&  //not overriding in this prototype
                props.indexOf(p) === -1          //not overridden in a child
        props = props.concat(l)
    while (
        (obj = Object.getPrototypeOf(obj)) &&   //walk-up the prototype chain
        Object.getPrototypeOf(obj)              //not the the Object prototype methods (hasOwnProperty, etc...)

    return props

This function will list all methods of an instance of the class including those inherited, but the constructor and those of the Object prototype.


The function returns

[ 'asyncMethod',
  'anotherEcho' ]

listing the methods of an instance of TestClass (typescript)

class Echo  {
    echo(data: string): string {
        return data
    anotherEcho(data: string): string {
        return `Echo ${data}`

class TestClass extends Echo {

    ping(data: string): string {
        if (data === 'ping') {
            return 'pong'
        throw new Error('"ping" was expected !')

    pong(data: string): string {
        if (data === 'pong') {
            return 'ping'
        throw new Error('"pong" was expected !')

    //overridden echo
    echo(data: string): string {
        return 'blah'

    async asyncMethod(): Promise<string> {
        return new Promise<string>((resolve: (value?: string) => void, reject: (reason?: any) => void) => {

    * generatorMethod(): IterableIterator<string> {
        yield 'blah'

To make members of class enumerable you can use Symbol.iterator

I had to get all allowed methods of object (including inherited). So i created class "Enumerable" and all my base classes inherited from him.

class Enumerable {
  constructor() {

    // Add this for enumerate ES6 class-methods
    var obj = this;

    var getProps = function* (object) {
      if (object !== Object.prototype) {
        for (let name of Object.getOwnPropertyNames(object)) {
          let method = object[name];
          // Supposedly you'd like to skip constructor and private methods (start with _ )
          if (method instanceof Function && name !== 'constructor' && name[0] !== '_')
            yield name;
        yield* getProps(Object.getPrototypeOf(object));

    this[Symbol.iterator] = function*() {
      yield* getProps(obj);
    // --------------

This function will get all functions. Inherited or not, enumerable or not. All functions are included.

function getAllFuncs(toCheck) {
    var props = [];
    var obj = toCheck;
    do {
        props = props.concat(Object.getOwnPropertyNames(obj));
    } while (obj = Object.getPrototypeOf(obj));

    return props.sort().filter(function(e, i, arr) { 
       if (e!=arr[i+1] && typeof toCheck[e] == 'function') return true;

Do test


console output:

["constructor", "toString", "toLocaleString", "join", "pop", "push", "concat", "reverse", "shift", "unshift", "slice", "splice", "sort", "filter", "forEach", "some", "every", "map", "indexOf", "lastIndexOf", "reduce", "reduceRight", "entries", "keys", "constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "__defineGetter__", "__lookupGetter__", "__defineSetter__", "__lookupSetter__"]


It doesn't return functions defined via symbols;


Recent Questions

Top Questions

Home Tags Terms of Service Privacy Policy DMCA Contact Us Javascript

©2020 All rights reserved.