Have you ever wished TypeScript had an expression-syntax equivalent of switch
? I have. Unfortunately, JavaScript/TypeScript switch
doesn't return a value. You can fake it with a function, something like this:
const result = (() => {
switch (value) {
case 1: return 'One';
case 2: return 'Two';
default: return 'Neither'
}
})();
That's a lot of code, though, and you need to add a return type annotation if you want some kind of enforcement of the return type (in the above example, you can change 'two'
to 2
and TypeScript won't complain).
Switche gives you a nicer syntax to achieve the same result, with a little more type safety.
Provide the value to test in a call to switche
, then provide multiple .case
calls, and finally a .default
call. The result of the call chain will be the second parameter of the first matching case, or else the parameter passed to .default
const result = switche(value)
.case(1, 'One')
.case(2, 'Two')
.default('Neither');
As well as providing values to match against, you can provide predicate functions:
const result = switche(value)
.case(v => v < 0, 'Negative')
.case(1, 'One')
.case(2, 'Two')
.default('Neither');
Instead of providing a default, you can tell Switche to throw an error if there is no match. .orThrow
takes two optional parameters: an error message and an error type. If you provide an error type, it must inherit from Error
and accept a string in the constructor.
const result = switche(value)
.case(1, 'One')
.orThrow('The provided value was not 1');
class CustomError extends Error {
constructor(details) {
super(`Custom error being thrown with message '${details}'`);
}
}
const result = switche(value)
.case(1, 'One')
.orThrow('The provided value was not 1', CustomError);
If your custom error constructor doesn't take a single string parameter or you otherwise want to control the creation of the error, you can pass a function as the first parameter which will be called to create the error to throw. In this case, the second parameter is ignored.
class ComplexCustomError extends Error {
constructor(errorCode: number) {
super(`Error thrown with code ${errorCode}`);
}
}
try {
const result = switche(i)
.case(2, 'Two')
.orThrow(() => new ComplexCustomError(5));
} catch (ex) {
ex;//?
}
const result = switche(value)
.case(1, 'One')
.case(2, 'Two')
.default('Neither'); // Expression type: string
Unlike in the switch
example above, if you replace one of the strings with something of a different type, you'll get a type error. All to case
or default
must be of the same type as the first parameter to the first case
call.
const result = switche(value)
.case(1, 'One')
.case(2, 2) // Type error: Argument of type 'number' is not assignable to parameter of type 'string'.
.default('Neither');
You can control the result type using generic parameters. For example, if you want to allow either strings or numbers, you can provide string|number
as a generic parameter to the first case
call.
const result = switche(value)
.case<string|number>(1, 'One')
.case(2, 2)
.default('Neither'); // Expression type: string|number
You can place the generic parameter immediately after the switche
call as well, but then you have to provide the input type as the first parameter (the second parameter, which specifies the output type, is optional):
const result = switche<number,string|number>(value)
.case(1, 'One')
.case(2, 2)
.default('Neither'); // Expression type: string|number
If you provide generic parameters in both places, the second one will be ignored. In this example, string
(provided as the generic parameter to switche
) will be used, and number|string
provided to the first case
call will be ignored.
const result = switche<number,string>(value)
.case<number|string>(1, 'One')
.case(2, 2) // Type error: Argument of type 'number' is not assignable to parameter of type 'string'.
.default('Neither');