Question

7

Get properties of class in typescript

rated 0 times [ 8] [ 1] / answers: 1 / hits: 26245 / 8 Years ago, tue, january 31, 2017, 12:00:00

I've the following class:

export class Test {



        private _rowsCount: string;

        public get RowsCount(): string {

            return this._rowsCount;

        };

        public set RowsCount(value: string) {

            this._rowsCount = value;

        };



        private _rowsCount2: string;

        public get RowsCount2(): string {

            return this._rowsCount2;

        };

        public set RowsCount2(value: string) {

            this._rowsCount2 = value;

        };

    }

I need to iterate over the properties in a specific class, I tried the following:

Object.keys(this).forEach((key)=> {

    console.log(key);

});

But the problem that this iterate just over the private fields, I tried also the following I got all the methods and properties:

    for (var property in this) {

        if (this.hasOwnProperty(property)) {

            console.log(property);                

        }

    }

Does anyone have a solution?

Thanks!

Answers

Only authorized users can answer the question. Please sign in first, or register a free account.

alonso

Add To Favorites

Follow

Total Points: 747

Total Questions: 108

Total Answers: 105

Location: Mauritania

Member since Sun, Sep 25, 2022

2 Years ago

answered 8 Years ago monicag · Accepted Answer

If you need to only get the getters/setters, then you'll need to do something like:

class Test {

    ...



    public static getGetters(): string[] {

        return Object.keys(this.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.prototype, name)[get] === function

        });

    }



    public static getSetters(): string[] {

        return Object.keys(this.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.prototype, name)[set] === function

        });

    }

}



Test.getGetters(); // [RowsCount, RowsCount2]

Test.getSetters(); // [RowsCount, RowsCount2]

(code in playground)

You can put the static methods in a base class, and then when you extend it the subclass will have those static methods as well:

class Base {

    public static getGetters(): string[] {

        return Object.keys(this.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.prototype, name)[get] === function

        });

    }



    public static getSetters(): string[] {

        return Object.keys(this.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.prototype, name)[set] === function

        });

    }

}



class Test extends Base {

   ...

}



Test.getGetters(); // work the same

(code in playground)

If you want these methods to be instance methods then you can do this:

class Base {

    public getGetters(): string[] {

        return Object.keys(this.constructor.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.constructor.prototype, name)[get] === function

        });

    }



    public getSetters(): string[] {

        return Object.keys(this.constructor.prototype).filter(name => {

            return typeof Object.getOwnPropertyDescriptor(this.constructor.prototype, name)[set] === function

        });

    }

}

The change is that instead of using this.prototype you're using this.constructor.prototype.

Then you simply:

let a = new Test();

a.getGetters(); // [RowsCount, RowsCount2]

(code in playground)

Edit

Based on a comment by @Twois, who pointed out that it won't work when targetting es6, here's a version that will work:

class Base {

    public static getGetters(): string[] {

        return Reflect.ownKeys(this.prototype).filter(name => {

            return typeof Reflect.getOwnPropertyDescriptor(this.prototype, name)[get] === function;

        }) as string[];

    }



    public static getSetters(): string[] {

        return Reflect.ownKeys(this.prototype).filter(name => {

            return typeof Reflect.getOwnPropertyDescriptor(this.prototype, name)[set] === function;

        }) as string[];

    }

}

The main difference: using Reflect.ownKeys(this.prototype) instead of Object.keys(this.prototype).