如何展平typescript中的泛型类型声明?

如何展平typescript中的泛型类型声明?,typescript,generics,Typescript,Generics,案例: 函数输入嵌套的通用对象,并输出平面对象,如下所示: interface Deep<T> { p1: T; p2: T; } type Nested<T> = { [P in keyof T]: Deep<any>; } type Flat<T, ?> = { [P in keyof T]: T[P]?; } function flat<T extends Nested<T>>(input: T,

案例:

函数输入嵌套的通用对象,并输出平面对象,如下所示:

interface Deep<T> {
  p1: T;
  p2: T;
}

type Nested<T> = {
  [P in keyof T]: Deep<any>;
}

type Flat<T, ?> = {
  [P in keyof T]: T[P]?;
}

function flat<T extends Nested<T>>(input: T, p: keyof Deep<any>): Flat<T, ?> {
  const put: any = {}
  for (let k in input)
    put[k] = input[k][p]
}

const foo = flat({
  name: { p1: 'name', p2: 'name' },
  { fn: { p1: () => 0, p2: () => 1 }
})
接口深度{
p1:T;
p2:T;
}
嵌套类型={
[P in keyof T]:深;
}
类型扁平={
[P in keyof T]:T[P]?;
}
功能平坦(输入:T,p:keyof Deep):平坦{
常量put:any={}
for(让k输入)
put[k]=输入[k][p]
}
常数foo=平坦({
名称:{p1:'名称',p2:'名称'},
{fn:{p1:()=>0,p2:()=>1}
})
在这种情况下,输入是一个嵌套对象,具有不同的
Deep
类型,我希望typescript可以将
foo.name
的类型提示为
string
,将
foo.fn
的类型提示为
()=>number


我应该如何声明
Flat
的类型?

我必须对您的类型和代码进行一些调整,并猜测您正在尝试做什么,但这似乎是您想要的一个示例。不要试图描述一个类型函数
Flat
,它接受嵌套的
输入并将其展平以生成输出类型,而不要尝试描述它相反:将
T
视为平坦的输出类型,将
Nested
视为输入类型:

// this is the same
interface Deep<T> {
  p1: T;
  p2: T;
}

// changed: for every property of T with key P and value of type T[P],
// there is a property of Nested<T> with key P and value of type Deep<T[P]>
type Nested<T> = {
  [P in keyof T]: Deep<T[P]>;
}

// output is T, input is Nested<T> and a key of Deep<>
function flat<T>(input: Nested<T>, p: keyof Deep<any>): T {
  const put = {} as T; // assert as type T
  for (let k in input)
    put[k] = input[k][p];
  return put; // added return value
}

希望这能有所帮助;祝你好运!

我不得不修改一下你的类型和代码,猜测一下你想做什么,但这似乎是你想要的一个例子。与其试图描述一个类型函数
展开
,它将输入
嵌套
并展开以生成输出类型,不如做相反的事情:想想
T
作为展平输出类型,而
Nested
作为输入类型:

// this is the same
interface Deep<T> {
  p1: T;
  p2: T;
}

// changed: for every property of T with key P and value of type T[P],
// there is a property of Nested<T> with key P and value of type Deep<T[P]>
type Nested<T> = {
  [P in keyof T]: Deep<T[P]>;
}

// output is T, input is Nested<T> and a key of Deep<>
function flat<T>(input: Nested<T>, p: keyof Deep<any>): T {
  const put = {} as T; // assert as type T
  for (let k in input)
    put[k] = input[k][p];
  return put; // added return value
}
希望有帮助,祝你好运