Firmas de aserción de TypeScript: Validación de tipos en tiempo de ejecución para un código robusto

TypeScript proporciona una excelente comprobación de tipos estáticos durante el desarrollo, detectando errores potenciales antes del tiempo de ejecución. Sin embargo, a veces es necesario garantizar la seguridad de los tipos en tiempo de ejecución. Aquí es donde entran en juego las firmas de aserción. Permiten definir funciones que no solo comprueban el tipo de un valor, sino que también informan a TypeScript de que el tipo del valor se ha restringido en función del resultado de la comprobación.

¿Qué son las firmas de aserción?

Una firma de aserción es un tipo especial de firma de función en TypeScript que utiliza la palabra clave asserts. Le dice a TypeScript que si la función se devuelve sin lanzar un error, entonces una condición específica sobre el tipo de un argumento está garantizada que es verdadera. Esto le permite refinar los tipos de una manera que el compilador entiende, incluso cuando no puede inferir automáticamente el tipo basándose en el código.

La sintaxis básica es:

            function assertsCondition(argument: Type): asserts argument is NarrowedType {
  // ... implementación que comprueba la condición y lanza un error si es falsa ...
}

            

              
                Copy
              
            
          

• assertsCondition: El nombre de su función.
• argument: Type: El argumento cuyo tipo desea comprobar.
• asserts argument is NarrowedType: Esta es la firma de aserción. Le dice a TypeScript que si assertsCondition(argument) devuelve sin lanzar un error, entonces TypeScript puede tratar argument como si tuviera el tipo NarrowedType.

¿Por qué usar firmas de aserción?

Las firmas de aserción ofrecen varias ventajas:

• Validación de tipos en tiempo de ejecución: Permiten validar el tipo de un valor en tiempo de ejecución, evitando errores inesperados que podrían surgir de datos incorrectos.
• Seguridad del código mejorada: Al aplicar restricciones de tipo en tiempo de ejecución, puede reducir el riesgo de errores y mejorar la fiabilidad general de su código.
• Restricción de tipos: Las firmas de aserción permiten a TypeScript restringir el tipo de una variable en función del resultado de una comprobación en tiempo de ejecución, lo que permite una comprobación de tipos más precisa en el código posterior.
• Legibilidad del código mejorada: Hacen que su código sea más explícito sobre los tipos esperados, lo que facilita su comprensión y mantenimiento.

Ejemplos prácticos

Ejemplo 1: Comprobación de una cadena

Creemos una función que afirme que un valor es una cadena. Si no es una cadena, lanza un error.

            function assertIsString(value: any): asserts value is string {
  if (typeof value !== 'string') {
    throw new Error(`Se esperaba una cadena, pero se recibió ${typeof value}`);
  }
}

function processString(input: any) {
  assertIsString(input);
  // TypeScript ahora sabe que 'input' es una cadena
  console.log(input.toUpperCase());
}

processString("hola"); // Funciona bien
// processString(123); // Lanza un error en tiempo de ejecución

            

              
                Copy
              
            
          

En este ejemplo, assertIsString comprueba si el valor de entrada es una cadena. Si no lo es, lanza un error. Si devuelve sin lanzar un error, TypeScript sabe que input es una cadena, lo que le permite llamar de forma segura a métodos de cadena como toUpperCase().

Ejemplo 2: Comprobación de una estructura de objeto específica

Supongamos que está trabajando con datos obtenidos de una API y desea asegurarse de que se ajustan a una estructura de objeto específica antes de procesarlos. Digamos que espera un objeto con propiedades name (cadena) y age (número).

            interface Person {
  name: string;
  age: number;
}

function assertIsPerson(value: any): asserts value is Person {
  if (typeof value !== 'object' || value === null) {
    throw new Error(`Se esperaba un objeto, pero se recibió ${typeof value}`);
  }

  if (!('name' in value) || typeof value.name !== 'string') {
    throw new Error(`Se esperaba una propiedad 'name' de tipo cadena`);
  }

  if (!('age' in value) || typeof value.age !== 'number') {
    throw new Error(`Se esperaba una propiedad 'age' de tipo número`);
  }
}

function processPerson(data: any) {
  assertIsPerson(data);
  // TypeScript ahora sabe que 'data' es una Persona
  console.log(`Nombre: ${data.name}, Edad: ${data.age}`);
}

processPerson({ name: "Alicia", age: 30 }); // Funciona bien
// processPerson({ name: "Bob", age: "30" }); // Lanza un error en tiempo de ejecución
// processPerson({ name: "Carlos" }); // Lanza un error en tiempo de ejecución

            

              
                Copy
              
            
          

Aquí, assertIsPerson comprueba si el valor de entrada es un objeto con las propiedades y los tipos requeridos. Si alguna comprobación falla, lanza un error. De lo contrario, TypeScript trata data como un objeto Person.

Ejemplo 3: Comprobación de un valor de enum específico

Considere un enum que representa diferentes estados de pedido.

            enum OrderStatus {
  PENDIENTE = "PENDIENTE",
  PROCESANDO = "PROCESANDO",
  ENVIADO = "ENVIADO",
  ENTREGADO = "ENTREGADO",
}

function assertIsOrderStatus(value: any): asserts value is OrderStatus {
  if (!Object.values(OrderStatus).includes(value)) {
    throw new Error(`Se esperaba OrderStatus, pero se recibió ${value}`);
  }
}

function processOrder(status: any) {
  assertIsOrderStatus(status);
  // TypeScript ahora sabe que 'status' es un OrderStatus
  console.log(`Estado del pedido: ${status}`);
}

processOrder(OrderStatus.ENVIADO); // Funciona bien
// processOrder("CANCELADO"); // Lanza un error en tiempo de ejecución

            

              
                Copy
              
            
          

En este ejemplo, assertIsOrderStatus asegura que el valor de entrada es un valor de enum OrderStatus válido. Si no lo es, lanza un error. Esto ayuda a evitar que se procesen estados de pedido no válidos.

Ejemplo 4: Uso de predicados de tipo con funciones de aserción

Es posible combinar predicados de tipo y funciones de aserción para una mayor flexibilidad.

            function isString(value: any): value is string {
    return typeof value === 'string';
}

function assertString(value: any): asserts value is string {
    if (!isString(value)) {
        throw new Error(`Se esperaba una cadena, pero se recibió ${typeof value}`);
    }
}

function processValue(input: any) {
    assertString(input);
    console.log(input.toUpperCase());
}

processValue("TypeScript"); // Funciona
// processValue(123); // Lanza

            

              
                Copy
              
            
          

Mejores prácticas

• Mantener las aserciones concisas: Concéntrese en validar las propiedades o condiciones esenciales necesarias para que su código funcione correctamente. Evite aserciones demasiado complejas que podrían ralentizar su aplicación.
• Proporcionar mensajes de error claros: Incluya mensajes de error informativos que ayuden a los desarrolladores a identificar rápidamente la causa del error y cómo solucionarlo. Utilice un lenguaje específico que guíe al usuario. Por ejemplo, en lugar de decir "Datos no válidos", diga "Se esperaba un objeto con propiedades 'nombre' y 'edad'".
• Utilizar predicados de tipo para comprobaciones complejas: Si su lógica de validación es compleja, considere la posibilidad de utilizar predicados de tipo para encapsular la lógica de comprobación de tipos y mejorar la legibilidad del código.
• Considerar las implicaciones de rendimiento: La validación de tipos en tiempo de ejecución añade sobrecarga a su aplicación. Utilice firmas de aserción con prudencia y solo cuando sea necesario. La comprobación de tipos estáticos debe ser preferida siempre que sea posible.
• Gestionar los errores con elegancia: Asegúrese de que su aplicación gestiona los errores lanzados por las funciones de aserción con elegancia, evitando fallos y proporcionando una buena experiencia de usuario. Considere la posibilidad de envolver el código que puede fallar en bloques try-catch.
• Documentar sus aserciones: Documente claramente el propósito y el comportamiento de sus funciones de aserción, explicando las condiciones que comprueban y los tipos esperados. Esto ayudará a otros desarrolladores a entender y usar su código correctamente.

Casos de uso en diferentes industrias

Las firmas de aserción pueden ser beneficiosas en varias industrias:

• Comercio electrónico: Validar la entrada del usuario durante el pago para asegurar que las direcciones de envío, la información de pago y los detalles del pedido son correctos.
• Finanzas: Verificar los datos financieros de fuentes externas, como los precios de las acciones o los tipos de cambio de divisas, antes de utilizarlos en cálculos o informes.
• Atención médica: Asegurar que los datos del paciente se ajusten a formatos y estándares específicos, como registros médicos o resultados de laboratorio.
• Fabricación: Validar los datos de los sensores y la maquinaria para asegurar que los procesos de producción se ejecutan sin problemas y de forma eficiente.
• Logística: Comprobar que los datos de los envíos, como los números de seguimiento y las direcciones de entrega, son precisos y completos.

Alternativas a las firmas de aserción

Si bien las firmas de aserción son una herramienta poderosa, también existen otros enfoques para la validación de tipos en tiempo de ejecución en TypeScript:

• Guardias de tipo: Los guardias de tipo son funciones que devuelven un valor booleano que indica si un valor es de un tipo específico. Se pueden utilizar para restringir el tipo de una variable dentro de un bloque condicional. Sin embargo, a diferencia de las firmas de aserción, no lanzan errores cuando la comprobación de tipos falla.
• Bibliotecas de comprobación de tipos en tiempo de ejecución: Bibliotecas como io-ts, zod y yup proporcionan capacidades completas de comprobación de tipos en tiempo de ejecución, incluyendo la validación de esquemas y la transformación de datos. Estas bibliotecas pueden ser particularmente útiles cuando se trata de estructuras de datos complejas o APIs externas.

Conclusión

Las firmas de aserción de TypeScript proporcionan un poderoso mecanismo para reforzar la validación de tipos en tiempo de ejecución, mejorando la fiabilidad del código y previniendo errores inesperados. Al definir funciones que afirman el tipo de un valor, puede mejorar la seguridad de los tipos, restringir los tipos y hacer que su código sea más explícito y mantenible. Si bien existen alternativas, las firmas de aserción ofrecen una forma ligera y eficaz de añadir comprobaciones de tipos en tiempo de ejecución a sus proyectos de TypeScript. Siguiendo las mejores prácticas y considerando cuidadosamente las implicaciones de rendimiento, puede aprovechar las firmas de aserción para construir aplicaciones más robustas y fiables.

Recuerde que las firmas de aserción son más efectivas cuando se utilizan junto con las funciones de comprobación de tipos estáticos de TypeScript. Deben utilizarse para complementar, no para reemplazar, la comprobación de tipos estáticos. Combinando la validación de tipos estáticos y en tiempo de ejecución, puede lograr un alto nivel de seguridad del código y evitar muchos errores comunes.