Question

如何输入函数，以使输入对象与输出对象相同，但值不同？

//a has type { a: number;b: number }
let a = { 'a': 1, 'b': 1 };
interface IDictNumber {
   [key: string]: number;
}
interface IDictString {
   [key: string]: string;
}
function convert(f: IDictNumber) {
   return Object.keys(f)
      .reduce((p, v) => {
            p[v] = `${f[v]}`;
            return p;
         },
      {} as IDictString);
}
//b has type IDictString, but I wanted it to have { a: string;b: string }
let b= convert(a);

Answer 1

现在可以在TypeScript 2.1中使用：

//a has type { a: number;b: number }
let a = { 'a': 1, 'b': 1 };
type Convert<T,K> = {
   [P in keyof T]: K;
};
function convertToString<T>(f: T) {
   let a  = <(keyof T)[]>Object.keys(f);
   return a.reduce((p, v) => {
            p[v] = `${f[v]}`;
            return p;
         },
      {} as Convert<T, string>);
}
let b = convertToString(a);

Answer 2

您可以使用泛型：

let a = { 'a': 1, 'b': 1 };

interface A<T extends string|number> {
    [key: string]: T;
    a: T,
    b: T
}

function convert(f: A<number>) {
    return Object.keys(f)
        .reduce((p, v) => {
                p[v] = `${f[v]}`;
                return p;
            },
        {} as A<string>);
}

let b = convert(a);

Typescript对象转换

2 个答案: