Unknown, any and never types in Typescript
Tags: typescript, any, unknown, never
Published: 2023-03-28 19:18:02

---
title: Unknown, any and never types in Typescript
published: true
description: 
tags: typescript, any, unknown, never
# cover_image: ![Iran, Tabriz, Rainbow mountains](![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nst17gfyno6gw233h73g.jpg))
# Use a ratio of 100:42 for best results.
# published_at: 2023-023-28 21:10 +0000
---

### Intro
TypeScript is an open-source programming language that adds optional static typing to JavaScript. It is widely used for developing large-scale applications and has several types that help developers to write better code. In this article, we will discuss the differences between the `unknown`, `any`, and `never` types in TypeScript.

### Difference
Let's take a look at a simple code example to understand the difference between `unknown` and `any` types:

```typescript
function getValue(): unknown {
  return "Hello, world!";
}

const value: any = getValue();

console.log(value.toUpperCase()); // No error at compile-time, but can throw runtime error
```
In this example, the `getValue` function returns a value of type `unknown`, which means that the type of the value is not yet known during the execution of the program. When we assign the value to a variable value of type `any`, we tell TypeScript to allow any type of value to be assigned to that variable, including the value returned by `getValue`.

Now, when we call the `toUpperCase` method on the value variable, TypeScript does not throw an error at compile-time, but it can still throw a runtime error if the value is not a string. This is because the any type does not provide any type safety, and the developer needs to ensure that the value is of the correct type before using it.

On the other hand, if we change the type of the value variable to `unknown`, TypeScript will require us to perform a type check before using the value, like this:

```typescript
function getValue(): unknown {
  return "Hello, world!";
}

const value: unknown = getValue();

if (typeof value === "string") {
  console.log(value.toUpperCase()); // No error
}
```
In this example, we perform a type check to ensure that the value variable is a string before calling the `toUpperCase` method. This provides better type safety and prevents runtime errors.

The `never` type is different from `unknown` and `any` types, as it represents values that will never occur. Here's an example:
```typescript
function throwError(): never {
  throw new Error("Something went wrong!");
}

const result: never = throwError(); // No error
```
In this example, the throwError function always throws an error, so it will never return a value. We can use the `never` type as the return type of the function to communicate this to the compiler. This helps in improving the overall code quality and maintainability, as it clearly communicates the intent of the function.

### Usecase:
The `unknown` type in TypeScript should be used when the type of a value is not known at the time of declaration. It is particularly useful when working with dynamic data, such as data from API responses, as it provides better type safety and prevents runtime errors.

The `any` type should only be used as a last resort, when it is not possible to determine the type of a value. It should be avoided as much as possible, as it can lead to runtime errors and make the codebase difficult to maintain.

The `never` type should be used as a return type for functions that will never return or throw an error. This helps in making the code more readable and maintainable, as it clearly communicates the intent of the function.

### Conclusion:
In conclusion, TypeScript has several types that help developers to write better code. The `unknown` type provides better type safety and is useful when working with dynamic data. The `any` type should be avoided as much as possible, as it can lead to runtime errors and make the codebase difficult