CODEWITHSUNDEEP
javascripttypescripttypestypescript-conditional-types
Arman Taherian
Arman Taherian

Reputation: 1092

Conditional types in TypeScript

I was wondering if I can have conditional types in TypeScript?

Currently I have the following interface:

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

But I want to remove errorText, and only have it when isValid is false as a required property.

I wish I was able to write it as the following interface:

interface ValidationResult {
  isValid: true;
}

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

But as you know, it is not possible. So, what is your idea about this situation?

Upvotes: 76

Views: 12204

Answers (4)

Willem van der Veen
Willem van der Veen

Reputation: 36580

Here is an alternative approach where you don't need the isValid property. Instead we can use the presence or abscence of the errortext property as a marker instead. Here is an example:

// Empty for now, can always add properties to it
interface Valid{}

interface InValid {
    errorText: string;
}

// sum/union type, the type is either Valid OR InValid
type ValidationResult =  Valid | InValid;

// custom type guard to determine the type of the result
// TS uses this function to narrow down the type to eiter valid or invalid
function checkIfValidResult(result: ValidationResult): result is InValid{
    return result.hasOwnProperty('errorText') ? true : false;
}

// example of using the type guard
function doSomethingWithResult(result: ValidationResult) {
    if (checkIfValidResult(result)) {
        throw new Error(result.errorText);
    } else {
        console.log('Success!');
    }
}

doSomethingWithResult({});
// logs: Success

doSomethingWithResult({errorText:'Oops something went wrong'});
// Throws error: Oops something went wrong

Upvotes: 1

bugs
bugs

Reputation: 15313

One way to model this kind of logic is to use a union type, something like this

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" }
}

The compiler is then able to narrow the type down based on the boolean flag

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

Upvotes: 99

KRyan
KRyan

Reputation: 7598

The union demonstrated by bugs is how I recommend handling this. Nonetheless, Typescript does have something known as “conditional types,” and they can handle this.

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


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

This ValidationResult (which is actually ValidationResult<boolean> due to the default parameter) is equivalent to the union produced in bugs’s answer or in CertainPerformance’s answer, and can be used in the same manner.

The advantage here is that you could also pass around a known ValidationResult<false> value, and then you wouldn’t have to test isValid as it would be known to be false and errorString would be known to exist. Probably not necessary for a case like this—and conditional types can be complex and difficult to debug, so they probably shouldn’t be used unnecessarily. But you could, and that seemed worth mentioning.

Upvotes: 23

CertainPerformance
CertainPerformance

Reputation: 370669

To avoid creating multiple interfaces which only get used to create a third, you can also alternate directly, with a type instead:

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

Upvotes: 48

Related Questions