Possible d'étendre les types dans Typescript?

156

Disons que j'ai le type suivant:

type Event = {
   name: string;
   dateCreated: string;
   type: string;
}

Je veux maintenant étendre ce type, c'est à dire

type UserEvent extends Event = {
   UserId: string; 
}

Cela ne marche pas. Comment puis-je faire ceci?

javascript typescript

— Kousha
source

3

Le typemot-clé est utilisé pour définir des alias de type , pas des interfaces ou des classes.

— Heretic Monkey

285

Le mot-clé extendsne peut être utilisé que pour les interfaces et les classes.

Si vous souhaitez simplement déclarer un type qui a des propriétés supplémentaires, vous pouvez utiliser le type d'intersection :

type UserEvent = Event & {UserId: string}

UPDATE pour TypeScript 2.2, il est maintenant possible d'avoir une interface qui étend le type objet , si le type satisfait à certaines restrictions:

type Event = {
   name: string;
   dateCreated: string;
   type: string;
}

interface UserEvent extends Event {
   UserId: string; 
}

Cela ne fonctionne pas dans l'autre sens - UserEventdoit être déclaré comme interface, pas a typesi vous souhaitez utiliser la extendssyntaxe.

Et il est toujours impossible de l'utiliser extend avec des types arbitraires - par exemple, cela ne fonctionne pas s'il Events'agit d'un paramètre de type sans aucune contrainte.

— artem
source

J'utilise TS v3.5.2 et je ne peux pas avoir d'interface pour étendre un type. interface A<T> extends B<T> {blar}Une interface ne peut étendre qu'un type d'objet ou une intersection de types d'objet avec des membres statiquement connus

— WORMSS

@WORMSS cela interface Identifiable<T> extends T { id: string }me donne l'erreur "Une interface ne peut étendre qu'un type d'objet ou une intersection de types d'objets avec des membres.ts (2312) statiquement connus"

— maninak

22

vous pouvez croiser les types:

type TypeA = {
    nameA: string;
};
type TypeB = {
    nameB: string;
};
export type TypeC = TypeA & TypeB;

quelque part dans votre code, vous pouvez maintenant faire:

const some: TypeC = {
    nameB: 'B',
    nameA: 'A',
};

— Stanislav
source

6

Ce que vous essayez d'accomplir équivaut à

interface Event {
   name: string;
   dateCreated: string;
   type: string;
}

interface UserEvent extends Event {
   UserId: string; 
}

La façon dont vous avez défini les types ne permet pas de spécifier l'héritage, mais vous pouvez obtenir quelque chose de similaire en utilisant des types d'intersection, comme l'a souligné artem .

— Olydis
source

8

Ouais, mais je n'aime pas le mot interfacequand je veux dire untype

— Kousha

Très bien, alors la réponse d'artem devrait vous convenir :)

— olydis

-1

Peut-être que l'approche ci-dessous sera utile pour quelqu'un TS avec reactjs

interface Event {
   name: string;
   dateCreated: string;
   type: string;
}

interface UserEvent<T> extends Event<T> {
    UserId: string;
}

— Jaison
source