Cree una interfaz para opciones o use cualquiera como tipo,

 makeFunction((param, options: any) => { const a = options.optionsValue; })({optionsValue: 'some value'});

Typescript toma el tipo de opciones como {}, lo que causa problemas durante la compilación.

Necesitamos pensar cómo TS puede inferir el tipo de esta definición. TS puede entender el tipo de dos lugares:

• conjunto de tipos genérico explícito
• tipo de segundo argumento de la función

En su caso de uso, no proporciona el tipo en ninguno de esos lugares y esta es la razón por la que se vuelve unknown , porque TS puede saber qué tipo de argumento necesita. Para darle a TS la posibilidad de entender el tipo que puede hacer o:

Establecer explícitamente genérico por:

 makeFunction<YourType>((param, options) => {...))

Establezca el tipo en la función de devolución de llamada, por ejemplo, definiendo uno de antemano:

 const f = (a: number, b: {a: string}) => b // here types are set makeFunction(f)({a: 'some value'}) // makeFunction is able to infer the types by f

También puede hacer esto en línea diciendo ((param: number, options: MyType))

Responda después del comentario si options pueden ser dinámicas

Creo que quieres el siguiente comportamiento:

 const makeFunction = <F extends (someParam: number, options: any) => any>(callback: F) => { return (options: Parameters<F>[1]) => { const param = 4; return callback(param, options) } } const f = (a: number, b: {a: string}) => b makeFunction(f)({ a: 'a' }) const g = (a: number, b: {b: number}) => b makeFunction(g)({b: 1})

Decimos algunas cosas:

• F ahora es una función que se extiende desde la función binaria, y directamente inferimos su tipo
• Parameters<F>[1] es el segundo tipo de argumento de la función dada tipo F

Agregue un tipo a la función de llamada como esta:

function(): Observable<any>

para evitar que vuelva unknown .

Dado que este es el primer resultado que obtiene cuando busca en Google que el Object is of type 'unknown' , quiero publicar mi caso. Podría ayudar a futuros lectores. Esta no es la respuesta a la pregunta de OP.

Recibí este error en el bloque catch . Después de depurar durante un tiempo, me di cuenta de que al iniciar TypeScript v4.0, las variables de la cláusula catch tienen un tipo unknown en lugar de any .

Y de acuerdo con los documentos :

unknown es más seguro que any porque nos recuerda que debemos realizar algún tipo de verificación de tipos antes de operar con nuestros valores.

Mi código se parecía a esto antes de v4.0:

 try { // try something exceptional here } catch (error) { console.log(error.message); }

Y para corregir este error, tuve que poner una variable de if de error adicional.

 try { // try something exceptional here } catch (error) { let errorMessage = "Failed to do something exceptional"; if (error instanceof Error) { errorMessage = error.message; } console.log(errorMessage); }

Problema con TS 4.0 explicado aquí: https://devblogs.microsoft.com/typescript/anounce-typescript-4-0/#unknown-on-catch

Todas las otras respuestas no me funcionaron, pero usar isAxiosError funcionó bien:

 } catch (error) { if (axios.isAxiosError(error)) { const errResp = error.response; // Handle your error type safe here } else { // Handle the unknown } }

Ningún Object is of type 'unknown'.ts(2571) más.

Puedes usar casting: (err as Error)

Me gusta la solución de declaración if , pero esto también funciona:

 catch (error) { let msg = (error as Error).message; }

actualizar mi tsconfig.json con lo siguiente me ha funcionado:

"useUnknownInCatchVariables": false,

Actualizar:

necesitas ponerlo así en compilerOptions

 "compilerOptions": { "useUnknownInCatchVariables": false }

Obtuve este problema en un try/catch al pasar el mecanografiado a la versión 4.4 y encontré en la documentación la explicación para eso.

En resumen, agregaron el indicadoruseUnknownInCatchVariables que es verdadero de forma predeterminada si es strict . Básicamente, cambia el tipo de error en una catch de any a unknown que causa este problema.

Entonces, para pasar a 4.4, tiene algunas opciones:

 try { ... } catch(e) { console.log((e as Error).message) }

o:

 try { ... } catch(e) { if (e instanceof Error) { console.log(e.message) } }

o en su tsconfig.json puede establecer explícitamente el indicador en false :

 { "compilerOptions": { "strict": true, "useUnknownInCatchVariables": false } }