根据TypeScript中函数的行为自动生成/获取简单类型

Question

Given an object such as:

const foo = {
   a: {id: 1},
   b: {id: 1},
   c: {id: 1},
   d: {id: 1},
   ....
}

and a function that converts the object to:

const bar = {
   a: 1,
   b: 1,
   c: 1,
   d: 1,
   ....
}

such as:

function<MyInputInterface>(map: MyInputInterface): MyOutputInterface? {
  const newMap = {};
  _.forIn(map, (val, key) => {
      newMap[key] = val.id;
  }
  return newMap;
}

Is there a way to define only one interface in Typescript that automatically assumes the structure of the other (either input or output)? Eg passing MyInputInterface into the function will return MyOutputInterface ?

In general, the pattern I described is found in a lot of places in my code-base due to some library extracting meta information and returning only certain values (eg id).I could certainly define input/output as interfaces to get more type-information, but I'd be interested in seeing whether there is a solution to only have to define either input OR output and get the other type-info for free.

Since this example might not be not clear enough, here a better example:

const properties = {
   propA: {
      desc: 'property a',
      val: 1
   },
   propB: {
      desc: 'property b',
      val: 'hello'
   }
   // any arbitrary number of properties
};

needs to convert to:

const parsedProperties = {
  propA: 1,
  probB: 'hello'
};

Answer 1

you can try this:

private foo:Foo= {
    propA: {
        desc: 'property a',
        val: 1
    },
    propB: {
        desc: 'property b',
        val: 'hello'
    }
};

converter(foo:Foo , probName ):Bar{
    let bar:Bar={};
    for(let a in foo){
        bar[a] = foo[a][probName];
        }
    return bar;
    }
}

interface Foo{
    [propA: string]:{[propB:string]:string|number};
}
interface Bar{
    [name: string]:string|number ;
}

console.log('bar' , this.converter(this.foo , 'val' ));