typescriptでジェネリック型宣言をフラット化するには？

Question

ケース：

機能入力ネストされた汎用オブジェクト、フォローなどの出力フラットオブジェクト：この場合

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 } 
}) 

、入力が異なるDeep型のネストされたオブジェクトですが、私はtypescriptですが、ことを願っ私はfoo.nameのタイプをstring、foo.fnのタイプを() => numberとしています。

Flat<T, ?>のタイプはどのように宣言すればよいですか？

Answer 1

あなたのタイプとコードを修正して、何をしようとしているのか推測しなければなりませんでしたが、これはinference from mapped typesが必要な例です。入力の種類として平坦化出力タイプとNested<T>としてTを考える：

// 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 
} 

代わりに、入力 Nested<?>を受け取り、出力タイプを生成するために、それを平坦化するタイプの機能 Flat<>を記述する逆をやろうとしているの

そして、我々はそれをあなたが望む方法で使用することができます。

const foo = flat({ 
    name: { p1: 'name', p2: 'name' }, 
    fn: { p1:() => 0, p2:() => 1 }, 
}, 'p2'); // example code lacked 'p1' or 'p2' argument 

foo.name.charAt(0); // works 
foo.fn().toFixed(0); // works 

希望に役立ちます。がんばろう！