Perché ... non cedendo metodi

Question

Dato quanto segue:

export class MyClass {
    public dataA = 0
    private dataB = 123
    public myMethod(): any {
        return {
            test: 'true'
        }
    }

    constructor() {
        for (const propOrMethod in this) {
            console.log({propOrMethod})
        }
    }
}

const myInst = new MyClass()

Lo eseguo ts-node index.tse tutto ciò che ottengo è:

{ propOrMethod: 'dataA' }
{ propOrMethod: 'dataB' }

Senza riferimento a myMethod. Vorrei iterare su tutti i metodi della mia classe, ma non sembrano esistere

Answer 1

for..initera su tutte le proprietà enumerabili dell'istanza e lungo la catena del prototipo. Ma i metodi normali in una classe non sono enumerabili:

class MyClass {
    myMethod() {
        return {
            test: 'true'
        };
    }
}
console.log(Object.getOwnPropertyDescriptor(MyClass.prototype, 'myMethod').enumerable);

Quindi non viene ripetuto.

Se si desidera iterare su immobili non enumerabili pure, l'uso Object.getOwnPropertyNames(che itera dell'oggetto propri nomi di proprietà, quindi avrai bisogno di farlo in modo ricorsivo, se si desidera che tutti i nomi di proprietà ovunque nella catena di prototipi):

const recurseLog = obj => {
  for (const name of Object.getOwnPropertyNames(obj)) {
    console.log(name);
  }
  const proto = Object.getPrototypeOf(obj);
  if (proto !== Object.prototype) recurseLog(proto);
};
class MyClass {
    dataA = 0;
    dataB = 123;
    constructor() {
        recurseLog(this);
    }
    myMethod() {
        return {
            test: 'true'
        };
    }
}
const myInst = new MyClass();

Puoi anche rendere il metodo enumerabile:

class MyClass {
    dataA = 0;
    dataB = 123;
    constructor() {
         for (const propOrMethod in this) {
            console.log({propOrMethod})
        }
    }
    myMethod() {
        return {
            test: 'true'
        };
    }
}
Object.defineProperty(MyClass.prototype, 'myMethod', { enumerable: true, value: MyClass.prototype.myMethod });
const myInst = new MyClass();

Oppure assegna il metodo dopo la definizione della classe:

class MyClass {
    dataA = 0;
    dataB = 123;
    constructor() {
         for (const propOrMethod in this) {
            console.log({propOrMethod})
        }
    }
}
MyClass.prototype.myMethod = () => ({ test: 'true' });
const myInst = new MyClass();

Oppure assegnalo all'istanza nel costruttore:

class MyClass {
    dataA = 0;
    dataB = 123;
    constructor() {
        this.myMethod = this.myMethod;
         for (const propOrMethod in this) {
            console.log({propOrMethod})
        }
    }
     myMethod() {
        return {
            test: 'true'
        };
    }
}
const myInst = new MyClass();