Puede leer más sobre unknown en el anuncio de PR o RC , pero la esencia es:

[..] desconocido cuál es la contraparte segura de tipo de cualquiera. Cualquier cosa se puede asignar a unknown, pero unknown no se puede asignar a nada más que a sí mismo y a cualquiera sin una afirmación de tipo o un estrechamiento basado en el flujo de control. Del mismo modo, no se permiten operaciones sobre un desconocido sin primero afirmar o reducir a un tipo más específico.

Algunos ejemplos:

 let vAny: any = 10; // We can assign anything to any let vUnknown: unknown = 10; // We can assign anything to unknown just like any let s1: string = vAny; // Any is assignable to anything let s2: string = vUnknown; // Invalid; we can't assign vUnknown to any other type (without an explicit assertion) vAny.method(); // Ok; anything goes with any vUnknown.method(); // Not ok; we don't know anything about this variable

El uso sugerido es:

A menudo, en ocasiones queremos describir el tipo menos capaz en TypeScript. Esto es útil para las API que desean señalar "este puede ser cualquier valor, por lo que debe realizar algún tipo de verificación antes de usarlo". Esto obliga a los usuarios a realizar una introspección segura de los valores devueltos.

La diferencia entre desconocido y cualquiera se describe como:

Al igual que any , cualquier valor se puede asignar a unknown ; sin embargo, a diferencia de any , no puede acceder a ninguna propiedad en valores con el tipo unknown , ni puede llamarlos/construirlos. Además, los valores de tipo unknown solo se pueden asignar a unknown o any .

Para responder a su pregunta de cuándo debe usar unknown sobre any :

Esto es útil para las API que desean señalar "este puede ser cualquier valor, por lo que debe realizar algún tipo de verificación antes de usarlo". Esto obliga a los usuarios a realizar una introspección segura de los valores devueltos.

Eche un vistazo al anuncio de TypeScript 3.0 para ver ejemplos de comprobación de tipo de una variable de tipo unknown y una explicación más detallada.

any tipo:

El tipo any representa todos los valores JS posibles. Cada tipo es asignable para escribir any . Por tanto, el tipo any es un supertipo universal del sistema de tipos. El compilador de TS permitirá cualquier operación en valores escritos en any . Por ejemplo:

 let myVar: any; myVar[0]; myVar(); myVar.length; new myVar();

En muchas ocasiones, esto es demasiado indulgente con el compilador de TS. es decir, permitirá operaciones que podríamos haber sabido que estaban dando como resultado un error de tiempo de ejecución.

tipo unknown :

El tipo unknown representa (como any ) todos los valores JS posibles. Cada tipo es asignable al tipo unknown . Por lo tanto, el tipo unknown es otro supertipo universal del sistema de tipos (junto con any ). Sin embargo, el compilador de TS no permitirá ninguna operación en valores escritos unknown . Además, el tipo unknown solo se puede asignar al tipo any . Un ejemplo aclarará esto:

 let myVar: unknown; let myVar1: unknown = myVar; // No error let myVar2: any = myVar; // No error let myVar3: boolean = myVar; // Type 'unknown' is not assignable to type 'boolean' // The following operations on myVar all give the error: // Object is of type 'unknown' myVar[0]; myVar(); myVar.length; new myVar();

cualquiera, desconocido:

• permitir asignar cualquier tipo

ninguna:

• permite ser asignado a cualquier tipo
• permite llamar a cualquier método

desconocido:

• no permite ser asignado a ningún tipo
• no permite llamar a ningún método

 const a: any = 'a'; // OK const b: unknown = 'b' // OK const v1: string = a; // OK const v2: string = b; // ERROR const v3: string = b as string; // OK a.trim() // OK b.trim() // ERROR

son diferentes en semántica.

unknown es el tipo principal de todos los demás tipos. es un tipo normal en el sistema de tipos.

any significa "desactivar la verificación de tipo". es una especie de metaprogramación.

Desconocido

Si escribe una función que solo pasa una entrada a otra función, use unknown . Desde la perspectiva de la función: "No sé, no quiero saber". No hay nada de malo en usar unknown .

P.ej:

 function buy(item: unknown): Purchase { if (item) { return purchase(item); } else { throw new TypeError('item is missing'); } }

Ninguna

Si necesita llamar a propiedades en ese valor, entonces any es más adecuado.

Es posible que a Linting no le guste any , lo que le sugiere que sea más específico con su entrada. De esa manera, si cambia la interfaz de isItem a isValid , TypeScript le indica que actualice su código.

P.ej:

 // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types function isItem(item: any): item is Purchase { return !!item?.price; }

Propiedades de llamada

 function isStuff(item: unknown): item is Stuff { return (item as Stuff).it !== undefined; } function isStuff(item: any): item is Stuff { return item.it !== undefined; } camelcaseKeys(item) as unknown as Item;

Vea los protectores definidos por el usuario si está interesado, lo traje porque es uno de los pocos casos en los que necesito alguno.

De este blog de ultimatecourses :

Use any tipo cuando no haya otras opciones

Es difícil encontrar buenos ejemplos para any .