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.

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!