Como Resolver o Erro Not Assignable to Parameter of Type Never em TypeScript

Neste artigo você vai aprender a como resolver o erro Not Assignable to Parameter of Type Never, um erro comum de TypeScript

Fala programador(a), beleza? Bora aprender mais sobre TypeScript!

Introdução

Ao trabalhar com TypeScript, você pode encontrar erros de tipo que dificultam a compreensão do problema subjacente. Um desses erros é o “Not assignable to parameter of type never”.

Esse erro pode ocorrer em várias situações, tornando-se um desafio para os desenvolvedores identificar e corrigir a causa raiz.

Neste artigo, vamos explorar o erro “not assignable to parameter of type never” em detalhes e discutir como resolvê-lo.

Entendendo o erro “not assignable to parameter of type never”

O erro “not assignable to parameter of type never” ocorre quando você tenta atribuir um valor a uma variável ou passar um valor para uma função cujo tipo esperado é never.

O tipo never em TypeScript representa um valor que nunca ocorre e geralmente é usado em funções que nunca retornam ou em variáveis que nunca são atribuídas.

O erro “not assignable to parameter of type never” indica que o TypeScript espera um valor que nunca ocorre, mas você está tentando atribuir ou passar um valor diferente, o que não é permitido.

Formação Recomendada

Formação Vibe Coding

Do Prompt ao Produto: Crie Software Real com IA

• 474 aulas
• 20 projetos
• 39h 27min

Conhecer formação

Exemplo de erro:

function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}

const value: string | number = "test";

switch (typeof value) {
  case "string":
    console.log("It's a string");
    break;
  case "number":
    console.log("It's a number");
    break;
  default:
    assertNever(value); // Error: Argument of type 'string | number' is not assignable to parameter of type 'never'
}

Neste exemplo, a função assertNever espera um parâmetro do tipo never, mas estamos passando um valor do tipo string | number, que resulta no erro “not assignable to parameter of type never”.

Resolvendo o erro not assignable to parameter of type never

Existem várias maneiras de resolver esse erro, dependendo da causa raiz e das intenções do código. Vamos explorar algumas soluções:

Use a cláusula default em um switch:

No exemplo acima, o erro pode ser resolvido usando uma cláusula default no switch em vez de chamar a função assertNever:

const value: string | number = "test";

switch (typeof value) {
  case "string":
    console.log("It's a string");
    break;
  case "number":
    console.log("It's a number");
    break;
  default:
    console.error(`Unexpected value: ${value}`);
}

Atualize a definição de tipo:

Se você estiver usando uniões de tipo e esquecer de incluir um tipo, poderá encontrar o erro “not assignable to parameter of type never”.

Atualize a definição de tipo para incluir o tipo ausente:

type MyType = "typeA" | "typeB" | "typeC";

function handleType(value: MyType) {
  switch (value) {
    case "typeA":
      console.log("It's typeA");
      break;
    case "typeB":
      console.log("It's typeB");
      break;
    case "typeC":
      console.log("It's typeC");
      break;
    default:
      assertNever(value); // No error
  }
}

Neste exemplo, atualizamos a definição de `MyType` para incluir todos os possíveis tipos de `value`.

Agora, a função `assertNever` não resulta em erro, pois o TypeScript entende que o valor passado para ela será do tipo `never`.

Use type narrowing:

Você pode usar o estreitamento de tipo para garantir que o TypeScript entenda que um valor específico é eliminado das possibilidades antes de chamar a função `assertNever`.

function isString(value: string | number): value is string {
  return typeof value === "string";
}

function isNumber(value: string | number): value is number {
  return typeof value === "number";
}

const value: string | number = "test";

if (isString(value)) {
  console.log("It's a string");
} else if (isNumber(value)) {
  console.log("It's a number");
} else {
  assertNever(value); // No error
}

Neste exemplo, usamos as funções de estreitamento de tipo isString e isNumber para garantir que o TypeScript entenda que um valor específico foi eliminado das possibilidades antes de chamar a função assertNever.

Isso evita o erro “not assignable to parameter of type never”.

Quer aprender mais sobre React? Confira o vídeo abaixo:

Conclusão

O erro “not assignable to parameter of type never” em TypeScript pode ser confuso e desafiador de resolver, mas compreender sua causa e as possíveis soluções é fundamental para evitar problemas em seu código.

Neste artigo, discutimos o motivo pelo qual esse erro ocorre e exploramos várias soluções, como usar a cláusula default em uma instrução switch, atualizar a definição de tipo e aplicar o estreitamento de tipo.

Ao aplicar essas técnicas e ter uma compreensão clara do erro “not assignable to parameter of type never”, você estará melhor preparado para lidar com esse tipo de erro em seus projetos TypeScript e garantir a qualidade e a robustez do seu código.

Está buscando a sua primeira vaga como Programador? Confira o nosso treinamento completo clicando aqui.

Nosso principal objetivo é tornar você um dev no menor tempo possível, através de uma metodologia planejada nos mínimos detalhes, após formar muitos outros desenvolvedores.

Uma plataforma de cursos com projetos completos, comunidade de alunos e muito mais!

Antes de partir pro switch e pro assertNever, vale falar do caso que mais aparece no dia a dia

Quando você cria um array vazio sem dizer o tipo, o TypeScript não tem como adivinhar o que vai entrar ali

Na hora que você tenta dar um push, estoura o erro

items.push("texto"); // Error: Argument of type ‘string’ is not assignable to parameter of type ‘never’

A correção é simples: diga o tipo do array na declaração

items.push("texto"); // funciona

Se o array vai receber mais de um tipo, use união

const items:

Se liga que aqui a causa é bem diferente da do assertNever: não é exhaustiveness, é o TypeScript caindo pro never porque ficou sem informação pra inferir

O post já fala de React, então vale o aviso: esse erro aparece MUITO no useState

O ajuste é passar o tipo direto no generic do useState

Se for um array de objetos, informe a interface

Já me ferrei com isso montando lista que começa vazia e enche depois do fetch, então fica o toque

Perguntas frequentes

Por que o TypeScript usa o tipo never aqui? O never representa um valor que nunca deveria acontecer

Quando o TypeScript não consegue inferir o tipo (array vazio, por exemplo) ou quando ele entende que todas as possibilidades já foram tratadas, ele usa never

Aí qualquer valor que você tentar encaixar dá conflito, porque never não aceita nada

Esse erro aparece usando o SDK do Directus (readItems), é o mesmo problema? A raiz é a mesma: o TypeScript ficou sem o tipo da coleção pra inferir e caiu no never

A solução passa por informar o tipo do que você está lendo, em vez de deixar a inferência no vácuo

Informe a tipagem da coleção/consulta e o argumento deixa de bater contra never

Adicionar um tipo com ‘as any’ resolve? Resolve de esconder o erro, sim, mas é gambiarra e volta pra te assombrar depois

Prefira dizer o tipo certo (o array anotado, o generic do useState, o tipo da coleção): o compilador para de reclamar porque o código passou a estar correto, não porque você calou ele