web-dev-qa-db-fra.com

Exclure la propriété du type

Je voudrais exclure une propriété unique du type. Comment puis je faire ça?

Par exemple j'ai

interface XYZ {
  x: number;
  y: number;
  z: number;
}

Et je veux exclure la propriété z pour obtenir

type XY = { x: number, y: number };
typescript
96
Qwertiy

Pour les versions de TypeScript supérieures ou égales à 3.5

Dans TypeScript 3.5, le type Omit a été ajouté à la bibliothèque standard. Voir les exemples ci-dessous pour savoir comment l'utiliser.

Pour les versions de TypeScript inférieures à 3.5

Dans TypeScript 2.8, le type Exclude a été ajouté à la bibliothèque standard, ce qui permet d'écrire un type d'omission simplement en tant que:

type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

Pour les versions de TypeScript inférieures à 2.8

Vous ne pouvez pas utiliser le type Exclude dans les versions inférieures à 2.8, mais vous pouvez le remplacer afin d'utiliser le même type de définition que ci-dessus. Cependant, ce remplacement ne fonctionnera que pour les types de chaîne, il n'est donc pas aussi puissant que Exclude.

// Functionally the same as Exclude, but for strings only.
type Diff<T extends string, U extends string> = ({[P in T]: P } & {[P in U]: never } & { [x: string]: never })[T]
type Omit<T, K extends keyof T> = Pick<T, Diff<keyof T, K>>

Et un exemple de ce type en usage:

interface Test {
    a: string;
    b: number;
    c: boolean;
}

// Omit a single property:
type OmitA = Omit<Test, "a">; // Equivalent to: {b: number, c: boolean}

// Or, to omit multiple properties:
type OmitAB = Omit<Test, "a"|"b">; // Equivalent to: {c: boolean}
221
CRice

Avec TypeScript 2.8, vous pouvez utiliser le nouveau type Exclude intégré. Les notes de version 2.8 en font mention dans la section "Types conditionnels prédéfinis":

Remarque: Le type Exclude est une implémentation appropriée du type Diff suggéré ici. [...] Nous n'avons pas inclus le type Omit car il est écrit trivialement comme Pick<T, Exclude<keyof T, K>>.

En appliquant ceci à votre exemple, le type XY pourrait être défini comme suit:

type XY = Pick<XYZ, Exclude<keyof XYZ, "z">>
33
Jason Hoetger

J'ai trouvé solution avec la déclaration de certaines variables et l'utilisation de l'opérateur spread pour déduire le type:

interface XYZ {
  x: number;
  y: number;
  z: number;
}

declare var { z, ...xy }: XYZ;

type XY = typeof xy; // { x: number; y: number; }

Cela fonctionne, mais je serais heureux de voir une meilleure solution.

17
Qwertiy

TypeScript 3.5

À partir de TypeScript 3.5, l’assistant d’Omit sera inclus: TypeScript 3.5 RC - Le type d’Aide d’Omit

Vous pouvez l'utiliser directement et vous devez supprimer votre propre définition de l'aide Omit lors de la mise à jour.

3
GonchuB

Si vous préférez utiliser une bibliothèque, utilisez ts-essentials .

import { Omit } from "ts-essentials";

type ComplexObject = {
  simple: number;
  nested: {
    a: string;
    array: [{ bar: number }];
  };
};

type SimplifiedComplexObject = Omit<ComplexObject, "nested">;

// Result:
// {
//  simple: number
// }

// if you want to Omit multiple properties just use union type:
type SimplifiedComplexObject = Omit<ComplexObject, "nested" | "simple">;

// Result:
// { } (empty type)

PS: Vous y trouverez plein d'autres choses utiles;)

2
Krzysztof Kaczor

J'aime ça:

interface XYZ {
  x: number;
  y: number;
  z: number;
}
const a:XYZ = {x:1, y:2, z:3};
const { x, y, ...last } = a;
const { z, ...firstTwo} = a;
console.log(firstTwo, last);
0
Andrew Zolotarev

Dans TypeScript 3.5 + :

interface TypographyProps {
    variant: string
    fontSize: number
}

type TypographyPropsMinusVariant = Omit<TypographyProps, "variant">
0
CorayThan