Any, void, unknown

TypeScript has some special types that allow you to handle certain situations where the exact type is not clear or where we want to restrict how we use a value. These types are not always mentioned early on in other courses, but understanding them early will make you a more confident TypeScript user. Let’s take a look at three important ones: any, void, and unknown.

Any

Sometimes, we might not know or care what type a variable will hold. This is where any comes in. The any type allows a variable to hold a value of any type, and TypeScript won’t check the type for us.

For example:

let something: any;

something = 10;          // OK
something = "Michele";   // OK
something = true;        // OK

The any type removes TypeScript’s type-checking for that variable. This means you can assign any value to it without getting errors.

However, while this sounds convenient, it also removes the safety TypeScript provides. Using any can lead to bugs because you might accidentally use the variable in an unexpected way. So, use any carefully and only when necessary.

Void

In JavaScript, if you write a function that doesn’t return anything, it will return undefined by default:

function log(msg: string) {
  console.log(msg);
}

const test = log('Hello');
console.log(test); // undefined

This is fine, but TypeScript provides a more specific type for functions that don’t return anything: void.

function log(msg: string): void {
  console.log(msg);
}

What does void mean? It means "this function doesn’t return anything." It's not the same as undefined, but it signals that the function has no return value. You’ll typically see void used in functions where you don’t care about the return value (like logging functions or callback functions).

Let’s consider an example of how void is useful in callback functions. Imagine you are writing a forEach function, which processes each item in an array by calling a function (a callback) for every element:

function forEach(arr: any[], callback: (el: any) => void) {
  for (let i = 0; i < arr.length; i++) {
    callback(arr[i]);
  }
}

forEach([1, 2, 3], (n) => console.log(n));

In this case, we use void because the callback function does not need to return anything.

If we used undefined instead of void, we would get an error because the callback could return anything (for example, arr.push() would return a number).

let anotherArray = [];

// Here you'd get an error if you used `undefined`,
// because push() accidentally returns something.
forEach([1, 2, 3], n => anotherArray.push(n));

By using void, we tell TypeScript that the return value is not important.

The function we wrote just now is typed very, very badly. It uses any twice. But in order to make it better, we must get to the chapter about Generics!

Unknown

Like any, unknown can store any type of value. However, unlike any, it is more restrictive. You cannot perform operations on an unknown value unless you first check what it actually is.

let test: unknown;

test = 'hello';
test = 123;
test = true;

So far, this is similar to any. But the difference comes when we try to use an unknown value. With unknown, TypeScript will stop us from performing any operations on the value until we have confirmed its type.

For example:

let test: unknown;

let a: boolean = test;  // ERROR
let b: number = test;   // ERROR
let c: string = test;   // ERROR

With unknown, we can’t just assign the value to a variable of another type. TypeScript won’t allow us to do anything with it until we check the type.

To safely use an unknown value, you need to narrow its type. For example, we can use an if statement to check the type of the value before using it:

let test: unknown = 'hello';

if (typeof test === 'string') {
  let str: string = test;  // OK, because we now know it's a string
}

In this case, the if statement checks the type of test and only allows us to use it as a string inside the block. This makes unknown a safer option than any, as it forces us to be explicit about how we handle the value.

What we just did is called Type Narrowing: again, we'll explore it in detail in another chapter.

Summary

• Use any when you don't know the type of a variable and don't need type-checking. However, be careful, as it removes the safety that TypeScript provides.
• Use void when typing a function (typically a callback) that doesn't need to return anything.
• Use unknown when you don't know the type of a value but want to be safe about how you handle it. You need to check its type before using it in any operation.

These special types allow you to handle situations where type information is unclear, but each has its purpose and trade-offs. As you become more comfortable with TypeScript, you'll know when it's appropriate to use each of them.