How to use Type Inference in TypeScript

We can use two options to define types in TypeScript:

• explicit typing - declares types directly in the code

  // exsplisit as string 
  let personOne: string = 'Mary'; 
  
  // exsplisit as number 
  let personOneAge: number = 25; 
  
  // exsplisit as string 
  const personTwo: string = 'Bob'; 
  
  // exsplisit as number 
  const personTwoAge: number = 22; 

• implicit typing - TypeScript inferences types automatically with the context.

  // implicit as string 
  let personOne = 'Mary';
  
  // implicit as number 
  let personOneAge = 25; 
  
  // implicit as "Bob", since we can't re-assign consts
  const personTwo = 'Bob'; 
  
  // implicit as 22, since we can't re-assign consts
  const personTwoAge = 22; 

In most cases, the Type Inferences works fine, but there are some cases where we need to use explisity typing.

The general idea - try to avoid implicity inferred any as much as possible. Some basic examples:

// inferred as any
let name;
name = 'Bob';

// inferred as string
let name: string; 
name = 'Bob';

// inferred as (num: any) => any
const count = (num) => num + 2; 

// inferred as (num: number) => number
const count = (num: number): number => num + 2; 

Also, external operations and data structures are good signs to use explicit typing.

GOOD PRACTICE: You can check some of such cases automatically. Just add at least these compiler flags in your tsconfig.json:

• --noImplicitAny - to avoid introducing anys inside your codebase when a type could be specified.
• --noImplicitThis - to raise errors when ‘this’ would be any.