Você sabe a diferença entre any e unknown?
any
e unknown
são tipos bem parecidos e podem parecer que são até iguais, mas possuem suas diferenças.
A confusão que se tem sobre esses dois tipos vem do fato de que, se criarmos uma função que recebe dois parâmetros, um do tipo any
e outro do tipo unknown
, veremos que podemos passar qualquer variável para ambos os tipos sem erros.
const foo = (anyType: any, unknownType: unknown) => {}
foo({}, {})
foo(123, 456)
foo(null, null)
foo(() => {}, () => {})
Mas é possível ver a diferença quando se usa essas variáveis.
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 não é nenhum tipo e você precisará verificar qual é o tipo.
Uma variável do tipo any
você pode ser usada como uma string
ou como uma função 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 não se pode usa-lo como uma string
, função, 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 variável 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 variável é de fato string
, e o mesmo pode ser feito para uma função.
const str2: string = unknownType; // => erro
if(typeof unknownType === 'string') {
const str2: string = unknownType; // => ok
}
unknownType(); // => erro
if(typeof unknownType === 'function') {
unknownType(); // => ok
}
Para verificar se uma variável é de um tipo mais especifico, como um objeto com algumas propriedades especificas, é necessário utilizar um user-defined type guard, que é uma função que o retorno dela define um type predicate, ou seja, define que uma variável é 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; // => erro
if(isFooType(unknownType)) {
unknownType.foo; // => ok
}
Ao utilizar unknown
ao invés de any
você permite que seu código seja utilizado de forma muito mais segura.
Top comments (0)