Pattern Matching es una característica poderosa que permite comparar una estructura de datos con un patrón y ejecutar el código dependiendo de cómo coincidan. Aunque TypeScript no tiene un soporte nativo de pattern matching al estilo de lenguajes como Scala o Haskell, pero se puede simular de manera efectiva utilizando algunas características como los tipos discriminados y el refinamiento de tipos para implementar pattern matching. Estos tipos combinan un campo común discriminante que puede diferenciar uniones de tipos de forma segura.
Veamos un ejemplo:
type Shape =
| { kind: 'circle', radius: number }
| { kind: 'square', sideLength: number }
| { kind: 'rectangle', width: number, height: number };
function area(shape: Shape): number {
switch (shape.kind) {
case 'circle':
return Math.PI * shape.radius ** 2;
case 'square':
return shape.sideLength ** 2;
case 'rectangle':
return shape.width * shape.height;
}
}
const myCircle: Shape = { kind: 'circle', radius: 5 };
console.log(area(myCircle)); // 78.53981633974483
Otra forma de hacer pattern matching es mediante guard clauses, que son condiciones específicas para cada caso. Aquí tienes un ejemplo:
function printNumber(x: number | string): string {
if (typeof x === 'number') {
return `Es un número: ${x}`;
} else if (typeof x === 'string') {
return `Es una cadena de texto: ${x}`;
} else {
return `Valor no soportado`;
}
}
// Uso
console.log(printNumber(42)); // Es un número: 42
console.log(printNumber('42')); // Es una cadena de texto: 42
TypeScript también permite un estilo de pattern matching mediante desestructuración de objetos y arrays.
type Person = { name: string, age: number };
type Animal = { species: string };
function describe(input: Person | Animal): string {
if ('name' in input) {
return `Persona: ${input.name}, Edad: ${input.age}`;
} else {
return `Especie: ${input.species}`;
}
}
// Uso
const person: Person = { name: 'John', age: 30 };
const animal: Animal = { species: 'Dog' };
console.log(describe(person)); // Persona: John, Edad: 30
console.log(describe(animal)); // Especie: Dog
El uso de `switch` puede complementarse con guardias para realizar un matching más fino de patrones, filtrando por condiciones adicionales.
function classifyNumber(x: number): string {
switch (true) {
case x < 0:
return 'Número negativo';
case x === 0:
return 'Cero';
case x > 0:
return 'Número positivo';
default:
return 'Valor desconocido';
}
}
console.log(classifyNumber(-5)); // Número negativo
console.log(classifyNumber(0)); // Cero
console.log(classifyNumber(10)); // Número positivo
Si bien TypeScript no tiene soporte nativo para el pattern matching al nivel de otros lenguajes funcionales, podemos simularlo utilizando sus características de refinamiento de tipos, tipos discriminados, guard clauses y desestructuración.
Con estos enfoques, puedes aplicar las ideas de pattern matching de forma clara y eficiente en TypeScript. Este tipo de técnica puede mejorar la legibilidad de tu código y hacerlo más fácil de mantener.
