TypeScript tiene is operador que ayuda a crear una función de prueba para la verificación de tipos. Recientemente vi dos implementaciones diferentes de este operador, una de las cuales usa la palabra clave asserts .
No encontré información sobre la diferencia de las dos formas de uso en los documentos. Jugué un poco con él y, si no me equivoco, la asserts no te permite devolver nada de la función, pero aparte de esto, no encontré ninguna diferencia.
Aquí está el código con el que probé:
// Asserts and tests the value without returninng anything function assertIsString(value: unknown): asserts value is string { if (typeof value !== "string") throw Error("value is not a string"); } // Tests the value and returns something so it can be used for typecheck // more explicitly function testIsString(value: unknown): value is string { return typeof value === "string"; } const string = "hello"; const number = 123; assertIsString(string); // does nothing assertIsString(number); // throws Error testIsString(string); // returns true testIsString(number); // returns falsePregunta: ¿Hay otras diferencias entre los dos casos de uso?
Resumen: La principal diferencia es que uno lanza mientras que el otro debe usarse en un condicional.
Las funciones que potencialmente arrojan una excepción y devuelven un void se denominan funciones de aserción .
Estos hacen una afirmación (podría pensar en ello como la creación de un contrato con el compilador), que si la función no arroja una excepción, el predicado en el valor de retorno será verdadero. A partir de ese momento (dentro del alcance actual), la información de tipo en el predicado estará en vigor.
Las funciones que devuelven valores boolean se denominan predicados de tipo .
En lugar de lanzar potencialmente una excepción (y hacer que su programa se detenga a menos que sea atrapado (vea try...catch ), estos simplemente devuelven un valor booleano. Si el booleano es verdadero, entonces para el resto del alcance donde el predicado fue invocado (por ejemplo, un bloque de código), el predicado tendrá efecto.
Los enlaces de documentación tienen varios ejemplos para cada caso (e información adicional). Aquí hay una demostración:
// predicate function exists <T>(maybe: T): maybe is NonNullable<T> { return maybe != null; } // assertion function assertExists <T>(maybe: T): asserts maybe is NonNullable<T> { if (maybe == null) throw new Error(`${maybe} doesn't exist`); } function example1 () { console.log('example1 begin'); let maybe: string | undefined; if (exists(maybe)) { maybe; // string } else { maybe; // undefined } console.log('example1 end'); } function example2 () { console.log('example2 begin'); let maybe: string | undefined; assertExists(maybe); maybe; // string console.log('example2 end'); } example1(); // 'example1 begin' then 'example1 end' example2(); // only 'example2 begin', then exception is thrown: `undefined doesn't exist`