为什么即使使用绑定我也会变得不确定？

Question

interface LooseObject {
    [key: string]: any
}

class C
{
    protected x: number = 100
    protected y : number = 200
    public s: string = "my dear string"

    constructor()
    {
        this.x = 20
        this.y = 10
        this.s = "hello, world!"
    }

    public function sayHello(): void
    {
        console.log('message --> ', this.s)
    }

    public get a(): string { return this.s }
    public get n(): number { return this.x }
}

function classToRegularObject(obj: LooseObject)
{
    console.log('s = ', obj["s"])

    let p:LooseObject = {};
    for (; obj != null; obj = Object.getPrototypeOf(obj))
    {
        for(var [k, v] of Object.entries(Object.getOwnPropertyDescriptors(obj)))
        {
            if(typeof v.get === 'function' && k !== '__proto__')
            {
                console.log('key = ', k, ', value = ', v.get.bind(obj)(), 
                            'val2 = ', obj[k])
                p[k] = obj[k]
            }
        }
    }
    
    return p
}

然后

let k = new C();
console.log(k.s)
k.sayHello()
console.log(classToRegularObject(k))

但是我从这一行得到 undefined const vv = v.get.bind(obj); 我错过了什么？

Answer 1

对于任何需要同样东西的人，设法让它与 keyof 运算符一起工作：

            const keyTyped = k as keyof LooseObject
            const value = obj[keyTyped]

那我可以做：

            p[k] = obj[keyTyped]

完美获取价值

为什么即使使用绑定我也会变得不确定？

Why am I getting undefined even using bind?

javascript

reflection

bind

typescript