Login🌙

Inference

One of the most powerful features of TypeScript is type inference. This means that TypeScript can automatically determine the type of a variable based on the value you assign to it, without needing you to explicitly define the type.

For example:

// Type: number
let age = 10;

Here, TypeScript automatically understands that age is a number because it’s initialized with a number (10). You don't need to write let age: number = 10; unless you want to be extra specific.

If you use const to declare a variable, TypeScript will infer an even more specific type. This is because const means the value can't change:

// Type: 10
const age = 10;

// Type: 'Michele'
const firstName = 'Michele';

In these examples, TypeScript knows that age is exactly 10 and firstName is exactly 'Michele'. These are called type literals, and their values can never change.

TypeScript can even understand when a variable is initialized with another variable’s value:

const age = 10;
const age2 = age; // Type: 10

In this case, age2 will have the same type as age, which is the literal value 10.

However, TypeScript cannot infer the result of an expression:

const a = 1;
const b = 2;

// Type: number, not 3
const c = a + b;

Here, c is typed as a number, but TypeScript doesn't know that it equals 3—it's not able to do that.

Inference within Functions

When you define a function, TypeScript can often figure out the return type on its own based on the types of the parameters and what the function returns. In most cases, you don’t need to specify the return type manually.

For example:

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

// Type: number
const sum = add(1, 2);

In this case, you don’t need to write function add(a: number, b: number): number. TypeScript knows that the return type is a number because you’re adding two number values.

If a function parameter has a default value, TypeScript can infer the type of that parameter as well:

// b is of type number
function add(a: number, b = 0) {
  return a + b;
}

Here, b is inferred as a number because its default value is 0, which is a number. So, even though we didn’t explicitly type b, TypeScript knows its type.

Conclusion

You can often let TypeScript infer types automatically (implicit types), or you can specify types manually (explicit types).

  • Implicit types: TypeScript figures out the type for you based on the value assigned.
  • Explicit types: You tell TypeScript exactly what type to use.

Both methods are fine to use, but it’s usually best to let TypeScript do the work for you with implicit types, unless you have a good reason to specify the type explicitly (like when working with more complex structures). This makes your code cleaner and easier to maintain.