Types conditionnels dans TypeScript

Je me demandais si je pouvais avoir des types conditionnels dans TypeScript?

Actuellement, j'ai l'interface suivante:

interface ValidationResult {
  isValid: boolean;
  errorText?: string;
}

Mais je veux retirer errorText, et seulement quand isValidest falsecomme nécessaire la propriété.

J'aimerais pouvoir l'écrire comme l'interface suivante:

interface ValidationResult {
  isValid: true;
}

interface ValidationResult {
  isValid: false;
  errorText: string;
}

Mais comme vous le savez, ce n'est pas possible. Alors, quelle est votre idée de cette situation?

Une façon de modéliser ce type de logique consiste à utiliser un type d'union, quelque chose comme ça

interface Valid {
  isValid: true
}

interface Invalid {
  isValid: false
  errorText: string
}

type ValidationResult = Valid | Invalid

const validate = (n: number): ValidationResult => {
  return n === 4 ? { isValid: true } : { isValid: false, errorText: "num is not 4" }
}

Le compilateur est alors en mesure de restreindre le type en fonction de l'indicateur booléen

const getErrorTextIfPresent = (r: ValidationResult): string | null => {
  return r.isValid ? null : r.errorText
}

Pour éviter de créer plusieurs interfaces qui ne sont utilisées que pour en créer une troisième, vous pouvez également alterner directement, avec un à la typeplace:

type ValidationResult = {
    isValid: false;
    errorText: string;
} | {
    isValid: true;
};

L' union démontrée par les bogues est la façon dont je recommande de gérer cela. Néanmoins, Tapuscrit n'ont quelque chose appelé « types conditionnels » , et ils peuvent gérer cela.

type ValidationResult<IsValid extends boolean = boolean> = (IsValid extends true
    ? { isValid: IsValid; }
    : { isValid: IsValid; errorText: string; }
);


declare const validation: ValidationResult;
if (!validation.isValid) {
    validation.errorText;
}

Cette ValidationResult (qui est en fait ValidationResult<boolean>dû au paramètre par défaut) est équivalent à l'union produite dans la réponse des bogues ou dans la réponse de CertainPerformance , et peut être utilisé de la même manière.

L'avantage ici est que vous pouvez également faire circuler une ValidationResult<false>valeur connue , et vous n'aurez alors pas à tester isValidcar elle serait connue falseet errorStringexisterait. Probablement pas nécessaire pour un cas comme celui-ci - et les types conditionnels peuvent être complexes et difficiles à déboguer, donc ils ne devraient probablement pas être utilisés inutilement. Mais vous le pouviez, et cela semblait utile de le mentionner.