在 TypeScript 中，我如何使用索引类型查询运算符来仅获取类型属性的子集？

Question

I have the following code:

var o = { x: 5, y: 6, z: 'hi' }
type OnlyNumberProps = keyof typeof o; // 'x' | 'y' | 'z' I want it somehow to be 'x' | 'y'
var p : OnlyNumberProps = 'z' // How to get error here ?
var z : OnlyNumberProps = 'x' // And OK here ?

How can I filter the type OnlyNumberProps to contain only names of number properties of object o ?

Answer 1

This is not possible to do.

The closest you can get using mapped types is this:

var o = { x: 5, y: 6, z: 'hi' }
type TypeOfO = typeof o;

type OnlyNumber = {
    [P in keyof TypeOfO]: number;
}

But then OnlyNumber will be:

type OnlyNumbers = { x: number; y: number; z: number; }

Which isn't what you're looking for.
There's no way to filter the keys.

Answer 2

I think this is a possible solution:

var o = { x: 5, y: 6, z: 'hi' }

type PropertyNames<T> = {
  [k in keyof T]: T[k] extends number ? k : never
} [keyof T]

type Properties<T> = Pick<T, PropertyNames<T>>;

let c1: Properties<typeof o> = {x: 1, y: 3} //ok
let c2: Properties<typeof o> = {x: 1, y: 3, z: "huhu"} //error
let c3: Properties<typeof o> = {} //error
let c4: Properties<typeof o> = {huhu: true} //error

Playground

step by step explanation:

1. typeof o resolves to {x: number, y: number, z: string}
2. A type like

 type Foo<T> = {
                 [k in keyof T]:k
               }

supplied with the type argument Foo<typeof o> resolves to {x: "x", y: "y", z: "z"}

3. A type like

 type Foo<T> = {
                 [k in keyof T]:T[k]
               }

supplied with the type argument Foo<typeof o> resolves to {x: number, y: number, z: string}

4. We use the conditional type T[k] extends number? k: never T[k] extends number? k: never . If T[k] resolves to a number the conditional type resolves to the key of T as a string literal type otherwise to never.

5. A type like

 type Foo<T> = {
                 [k in keyof T]:T[k] extends number ? k : never
               }

supplied with the type argument Foo<typeof o> resolves to {x: "x", y: "y", z: never}

6. In the next step we want to get a union type of the values of the above type. For this we use indexed access types indexed access types

type PropertyNames<T> = {
  [k in keyof T]: T[k] extends number ? k : never
} [keyof T]

supplied with the type argument PropertyNames<typeof o> resolves to "x"|"y"|never which is the same as "x"|"y"

7. In the last step we use the utility type Pick to create the desired type

Pick<typeof o, "x"|"y">

resolves to {x: number, y: number}