web-dev-qa-db-fra.com

Dans TypeScript Comment spécifier uniquement des clés d'un objet générique dont les valeurs sont-elles des chaînes?

J'ai essayé de créer un type composé des clés de type T dont les valeurs sont des chaînes. Dans pseudocode, ce serait keyof T where T[P] is a string.

La seule façon dont je peux penser à faire cela est en deux étapes:

// a mapped type that filters out properties that aren't strings via a conditional type
type StringValueKeys<T> = { [P in keyof T]: T[P] extends string ? T[P] : never };

// all keys of the above type
type Key<T> = keyof StringValueKeys<T>;

Cependant, le compilateur TS dit que Key<T> est simplement égal à keyof T, même si j'ai filtré les clés dont les valeurs ne sont pas des cordes en les fixant à never à l'aide d'un type conditionnel.

Donc, cela permet toujours cela, par exemple:

interface Thing {
    id: string;
    price: number;
    other: { stuff: boolean };
}

const key: Key<Thing> = 'other';

lorsque la seule valeur autorisée de key devrait vraiment être "id", ne pas "id" | "price" | "other", comme les deux autres valeurs des deux clés ne sont pas des cordes.

Lien vers un échantillon de code dans le terrain de jeu Typescript

9
Aron

Une autre alternative à la réponse de JCALZ est dans Documents de rupture de type Wiki :

type KeysOfType<TObj, TProp, K extends keyof TObj = keyof TObj> = K extends K ? TObj[K] extends TProp ? K : never : never;
0
cherryblossom