¿Por qué hay un error de mecanografiado con f2(f1) ? A mí me parece que f2, f3 y f4 tienen los mismos tipos. Simplemente se declara diferente. ¿Dónde está la diferencia de f4 a f2 o f3?
Tengo el siguiente ejemplo:
Patio de juegos mecanografiado
Código:
interface FullType { id: string; order_no: number; } interface OrderType { [key: string]: any; order_no: number; } const f1 = (d1: FullType): Promise<FullType> => { return new Promise(() => { return d1; }); }; function f2<Type extends OrderType, Fn extends (t: Type) => Promise<Type>>( f: Fn, ): void { // } function f3<Type extends OrderType>(f: (t: Type) => Promise<Type>): void { // } function f4<Type1 extends Type2, Type2 extends OrderType>( f: (item: Type1) => Promise<Type1>, ): void { // } f2(f1); // why is here a warning f3(f1); f4(f1);En TypeScript, los genéricos generalmente funcionan bien, sin embargo, cuando comienza a usar tipos genéricos ya extendidos para definir nuevos tipos genéricos que también se extenderán, aquí es donde ocurre el problema. En general, las restricciones genéricas (p. ej., <T> ) en TypeScript no se consideran tipos que puedan deducirse más, lo que significa que si bien extender un tipo extendido como el que tiene en f4 es inofensivo, extender un tipo recién definido que también usa genéricos es problemático :
f4 está perfectamente bien:
<Type1 extends Type2, Type2 extends OrderType>
f3 también está bien, ya que no extiende el tipo para definir la devolución de llamada, sino que crea directamente:
f: (t: Type) => Promise<Type>
f2 es donde comienza a ocurrir el problema, ya que el tipo de parámetro usa un tipo genérico extendido que también usa valores extendidos. Esto hace que el tipo vuelva por defecto a OrderType y debido a que FullType no es directamente igual a OrderType , está observando ese error:
Fn extends (t: Type) => Promise<Type>
Esto se puede ilustrar aún más definiendo esto en un tipo separado:
type CustomCallback<T> = (t: T) => Promise<T>; // This will work just fine function f2<Type extends OrderType>(f: CustomCallback<Type>): void { // } // this will not function f2<Type extends OrderType, paramType extends CustomCallback<Type>>(f: paramType): void { // }Aquí está el enlace de Playground.
Además, debo mencionar que la palabra clave extends extrae todas las propiedades conocidas de un tipo y permite que se usen otros valores debido a la firma de índice [key: string]: any; propiedad definida en OrderType , por lo que esta es la razón por la que no se muestran errores para f3 y f4 . Sin embargo, si usó un tipo directo en cualquiera de ellos, comenzará a ver una advertencia porque FullType no es igual a OrderType .
function f3(f: (t: OrderType) => Promise<OrderType>): void { // } f3(f1); // warningEn resumen, como regla general, trate de evitar extender tipos genéricos que ya usan variables extendidas.