Typescript如何编写嵌套的keyof

我有以下代码

class Transform<T> {
  constructor(private value: T) {}
}


class Test<T extends object> {
  constructor(private a: T) {}

  transform(): { [K in keyof T]: Transform<T[K]> } {
    // functionality omitted
    return this.a as any;
  }
}

const test = new Test({
    a: '',
    b: {
      c: '',
      d: {
          v: ''
      }
    }
})

const transformed = test.transform();

但我想要的是每个键都是Transform类型：

const transformed: {
    a: Transform<string>;
    b: Transform<{
        c: Transform<string>;
        d: Transform<{
            v: Transform<string>;
        }>;
    }>;
}

const转换：{
a：变换；
b：变换；
}

---

有一种方法可以通过TS实现它？

当然。请尝试以下条件递归类型：

type Transformed<T> = {
  [K in keyof T]:
    T[K] extends object
      ? Transform<Transformed<T[K]>>
      : Transform<T[K]>
};

结果是：

/**
 * @returns
 *
 * {
 *    a: Transform<string>;
 *    b: Transform<{
 *        c: Transform<string>;
 *        d: Transform<{
 *            v: Transform<string>;
 *        }>;
 *    }>;
 * }
 *
 */
const transformed = test.transform();

现在它将完全像你要求的那样。希望有帮助

class Test<T extends object> {
  constructor(private a: T) {}

  transform(): Transformed<T> {
    // functionality omitted
    return this.a as any;
  }
}

/**
 * @returns
 *
 * {
 *    a: Transform<string>;
 *    b: Transform<{
 *        c: Transform<string>;
 *        d: Transform<{
 *            v: Transform<string>;
 *        }>;
 *    }>;
 * }
 *
 */
const transformed = test.transform();

/**
 * @see https://github.com/microsoft/TypeScript/issues/14829#issuecomment-320754731
 */
type Compact<T> = {} & { [P in keyof T]: T[P] };

type Transformed<T> = Compact<{
  [K in keyof T]:
    T[K] extends object
      ? Transform<Transformed<T[K]>>
      : Transform<T[K]>
}>;