Skip to main content

Type Annotations in TypeScript (Live Playground)

In this tutorial, we will explore type annotations and type inference in TypeScript. Understanding these concepts will help you leverage TypeScript's powerful type system to create maintainable and type-safe code.

Type Annotations

Type annotations in TypeScript allow you to explicitly specify the data type of a variable, function parameter, or return value. By providing type annotations, you can catch type-related errors during compilation, which can help prevent runtime errors.

Here's an example of type annotations for variables:

let fullName: string = 'John Doe';
let age: number = 30;
let isStudent: boolean = true;

And an example of type annotations for a function:

function greet(name: string): string {
return `Hello, ${name}!`;
Live Playground, Try it Yourself

Type Inference

TypeScript is capable of inferring the type of a variable or function return value based on the assigned value or the function's implementation. This means that you don't always need to provide explicit type annotations.

Variable Type Inference

When you assign a value to a variable, TypeScript can automatically infer its type:

let message = 'Hello, TypeScript!'; // TypeScript infers the `string` type
let age = 25; // TypeScript infers the `number` type
let isStudent = true; // TypeScript infers the `boolean` type

In these examples, TypeScript infers the type of each variable based on the assigned value, without the need for explicit type annotations.

Function Return Type Inference

TypeScript can also infer the return type of a function based on its implementation:

function add(a: number, b: number) {
return a + b;

// TypeScript infers the return type as `number`

In this example, TypeScript infers the return type of the add function as number because the function adds two numbers and returns their sum.

Live Playground, Try it Yourself

When to Use Type Annotations

While TypeScript's type inference is powerful and can save you from writing unnecessary type annotations, there are situations where providing explicit type annotations can be beneficial:

  1. When the inferred type is too broad or not specific enough, such as when TypeScript infers the any type.
  2. When you want to enforce a specific type for a variable or function parameter, even though TypeScript might infer a different type.
  3. When you want to make your code more readable and self-documenting.


In this tutorial, we have explored type annotations and type inference in TypeScript. Understanding how to use type annotations and how TypeScript infers types automatically will help you leverage the full potential of TypeScript's type system. This knowledge will allow you to write cleaner, more maintainable, and type-safe code.