TypeScript 返回相同的嵌套对象结构但类型不同

Question

我正在使用此函数重建初始对象，但递归地将每个值转换为 BigNumbers。

export const castObjectValuesToBigNumber = function(initialObj: StringMap, nestedProp?: string) {

    let _castedObj: StringMap = {};

    for(const [property, value] of Object.entries(initialObj)) {

        if(typeof(value) === "object" && !(value instanceof BN)) {
            const newVal = castObjectValuesToBigNumber(value, property);
            _castedObj = { ..._castedObj, ...newVal };
        } else {
            if(nestedProp) {
                if(!_castedObj[nestedProp]) _castedObj[nestedProp] = {};
                _castedObj[nestedProp][property] = BigNumber.from(value.toString());
            } else {
                _castedObj[property] = BigNumber.from(value.toString());
            }
        }
    }

    return _castedObj;
}

我想使返回类型与 initialObj 类型相同，但最终值为 BigNumber 类型。

例子:

const myValue = {
   propertyA: new BN(105),
   propertyB: {
      propertyC: new BN(1),
      propertyD: new BN(2),
      propertyE: new BN(3)
   },
   propertyF: {
      propertyG: new BN(4)
   }
}

我希望如果我把这个值作为我的函数的参数， typescript 会自动返回这个类型:

{
   propertyA: BigNumber,
   propertyB: {
      propertyC: BigNumber,
      propertyD: BigNumber,
      propertyE: BigNumber
   },
   propertyF: {
      propertyG: BigNumber
   }
}

我尝试了很多关于泛型类型和嵌套类型的事情，但我总是遇到某种类型的错误。

这是一个最小可重现的例子:

/////////////////////
/// DECLARATIONS

interface StringMap { [key: string]: any }

class BN {
    value;
    constructor(num: number | string) {
        this.value = num;
    }

    _isBN() {
        return true;
    }
}

class BigNumber {
    value;
    constructor(num: number | string) {
        this.value = num;
    }

    _isBigNumber() {
        return true;
    }
}

const myValue = {
   propertyA: new BN(105),
   propertyB: {
      propertyC: new BN(1),
      propertyD: new BN(2),
      propertyE: new BN(3)
   },
   propertyF: {
      propertyG: new BN(4)
   }
};

/////////////////////
/// FUNCTION
export const castObjectValuesToBigNumber = function(initialObj: StringMap, nestedProp?: string) {

    let _castedObj: StringMap = {};

    for(const [property, value] of Object.entries(initialObj)) {

        if(typeof(value) === "object" && !(value instanceof BN)) {
            const newVal = castObjectValuesToBigNumber(value, property);
            _castedObj = { ..._castedObj, ...newVal };
        } else {
            if(nestedProp) {
                if(!_castedObj[nestedProp]) _castedObj[nestedProp] = {};
                _castedObj[nestedProp][property] = new BigNumber(value.toString());
            } else {
                _castedObj[property] = new BigNumber(value.toString());
            }
        }
    }

    return _castedObj;
}

/////////////////////
/// TEST

/*
    Result is of type StringMap while I would like it to be :

    {
        propertyA: BigNumber,
        propertyB: {
            propertyC: BigNumber,
            propertyD: BigNumber,
            propertyE: BigNumber
        },
        propertyF: {
            propertyG: BigNumber
        }
    }
    
*/

const myCastedValue = castObjectValuesToBigNumber(myValue); 

Answer 1

我们将用来递归地将每个 BN 更改为 BigNumber 的类型可能如下所示:

type CastToBigNumber<T> = T extends BN ? BigNumber : {
    [K in keyof T]: CastToBigNumber<T[K]>
};

如果 T 是一个 BN，那么我们将其更改为 BigNumber，否则它是一个对象，我们将更改其所有属性。

函数定义现在看起来像这样，使用了一个通用参数:

export const castObjectValuesToBigNumber = function<Initial extends StringMap>(initialObj: Initial, nestedProp?: string): CastToBigNumber<Initial> {

Playground