How does TypeScript handle null and undefined by default in strict mode?

Understanding Null and Undefined in TypeScript's Strict Mode

In TypeScript, strict mode is a way to opt into a safer way of programming. One of the features of this mode is how it handles null and undefined values. They are not seen as equivalent to an empty string, they are not ignored, and they certainly do not cause a compilation error. Instead, they are treated as separate types.

This is a fundamental aspect of TypeScript's strict type checking system and is powerful in preventing possible runtime errors in your code. Let's delve into this concept further to gain a more in-depth understanding.

Null and Undefined in TypeScript

The types null and undefined in TypeScript are subtypes of all other types, which means that you can assign null and undefined to something like number. However, when TypeScript is in strict mode, null and undefined get their own separate types and you cannot freely assign them to other types of variables.

For instance, if we have a string type:

let str: string;
str = null; // Throws an error in strict mode.

Here, assigning null to the str variable throws a compilation error because null is not considered a string in strict mode.

Practical Impact

This strict separation has practical impacts on how you code in TypeScript. It forces you to handle null and undefined values explicitly, which can prevent many common bugs.

For example, say you have a function that takes a string argument:

function greet(name: string) {
   return "Hello, "+name;

In JavaScript, if you forget to pass an argument or pass in null, this function could silently produce Hello, undefined or Hello, null. However, in TypeScript strict mode, calling greet without an argument or with null would raise a compile-time error due to the argument types not matching.


Thus, TypeScript's handling of null and undefined in strict mode is one of the features that makes TypeScript a powerful tool for writing safer, more predictable code. By treating them as separate types, TypeScript ensures that developers need to explicitly handle these special values, preventing bugs and making code more understandable.

Related Questions

Do you find this helpful?