Diferena entre Any e Unknown no Typescript

Voc sabe a diferena entre any e unknown?

any e unknown so tipos bem parecidos e podem parecer que so at iguais, mas possuem suas diferenas.

A confuso que se tem sobre esses dois tipos vem do fato de que, se criarmos uma funo que recebe dois parmetros, um do tipo any e outro do tipo unknown, veremos que podemos passar qualquer varivel para ambos os tipos sem erros.

const foo = (anyType: any, unknownType: unknown) => {}foo({}, {})foo(123, 456)foo(null, null)foo(() => {}, () => {})

Mas possvel ver a diferena quando se usa essas variveis.

Com any voc pode atribuir qualquer tipo e usar como se fosse qualquer tipo. J unknown voc pode atribuir qualquer tipo, mas ao usar ele no nenhum tipo e voc precisar verificar qual o tipo.

Uma varivel do tipo any voc pode ser usada como uma string ou como uma funo e at mesmo como um objeto, mostrando que any equivalente a todos os tipos.

const foo = (anyType: any, unknownType: unknown) => {  const str1: string = anyType; // => ok  anyType(); // => ok  anyType.foo; // => ok}

J o unknown, mesmo podendo receber qualquer tipo, ele da erro quando se tenta usa-lo como qualquer tipo, portanto no se pode usa-lo como uma string, funo, objeto ou qualquer outro tipo diferente de unknown.

const foo = (anyType: any, unknownType: unknown) => {  const str1: string = anyType; // => ok  anyType(); // => ok  anyType.foo; // => ok  const str2: string = unknownType; // => erro  unknownType(); // => erro  unknownType.foo; // => erro}

Para voc poder usar uma varivel do tipo unknown, preciso que se verifique o tipo antes. Para atribuir unknown para uma string, pode-se verificar utilizando typeof e ver se o tipo da varivel de fato string, e o mesmo pode ser feito para uma funo.

const str2: string = unknownType; // => erroif(typeof unknownType === 'string') {  const str2: string = unknownType; // => ok}unknownType(); // => erroif(typeof unknownType === 'function') {    unknownType(); // => ok}

Para verificar se uma varivel de um tipo mais especifico, como um objeto com algumas propriedades especificas, necessrio utilizar um user-defined type guard, que uma funo que o retorno dela define um type predicate, ou seja, define que uma varivel de um determinado tipo utilizando is.

interface Foo {  foo: string}// user-defined type guard      *type predicate*const isFooType = (foo: unknown): foo is Foo => {  return (foo as Foo)?.foo !== undefined}unknownType.foo; // => erroif(isFooType(unknownType)) {    unknownType.foo; // => ok}

Ao utilizar unknown ao invs de any voc permite que seu cdigo seja utilizado de forma muito mais segura.