TypeScript Strict Mode

Strict mode in TypeScript is a set of type-checking rules that provide more thorough checks during development, aiming to catch errors early and ensure that the code adheres to more stringent standards. Enabling strict mode increases the safety and robustness of your TypeScript code, particularly in larger projects.

When strict mode is enabled, TypeScript applies a series of additional checks that prevent certain potentially unsafe or ambiguous coding practices.

 

Key Features of Strict Mode

noImplicitAny

• This setting prevents TypeScript from inferring the any type for variables or function parameters without an explicit type declaration.
• Benefit: Helps avoid loose typing and makes the code more predictable.
• Example:

let value; // Error: Variable 'value' implicitly has an 'any' type.

strictNullChecks

• This ensures that null and undefined are not assignable to any other type, except for null or undefined themselves.
• Benefit: Helps avoid null or undefined errors at runtime.
• Example:

let name: string = null; // Error: Type 'null' is not assignable to type 'string'.

noImplicitThis

• In strict mode, the this keyword must be explicitly typed in functions and methods. TypeScript will raise an error if it cannot infer the type of this.
• Benefit: Helps avoid confusion about the context of this.
• Example:

function myFunction() {
  this.someProperty = 5; // Error: 'this' implicitly has an 'any' type.
}

alwaysStrict

• Ensures that your code is always parsed in strict mode, even if it's not explicitly set in the file.
• Benefit: Ensures that your codebase is always treated with strict type-checking regardless of the source.
• Example:

"compilerOptions": {
  "alwaysStrict": true
}

noUnusedLocals

• Flags any variables that are declared but not used in the code.
• Benefit: Helps clean up unused code and avoid unnecessary declarations.
• Example:

let unusedVariable = 10; // Error: 'unusedVariable' is declared but never used.

noUnusedParameters

• Flags function parameters that are declared but never used inside the function body.
• Benefit: Helps clean up functions and prevent unnecessary parameters.
• Example:

function add(a: number, b: number) {
  return a + 5; // Error: Parameter 'b' is unused.
}

strictFunctionTypes

• Enforces that function types are checked more strictly, especially when it comes to the covariance of arguments.
• Benefit: Ensures that functions with mismatched argument types raise an error.
• Example:

let f1: (a: number) => void = (a) => {}; 
let f2: (a: string) => void = (a) => {}; 
f1 = f2; // Error: Type '(a: string) => void' is not assignable to type '(a: number) => void'.

noImplicitReturns

• This ensures that all functions have an explicit return statement in every branch.
• Benefit: Prevents accidental undefined returns.
• Example:

function getValue(x: number): number {
  if (x > 10) {
    return x;
  }
  // Error: Function lacks return type annotation and has an implicit return.
}

noFallthroughCasesInSwitch

• This prevents fall-through behavior in switch statements, where code inadvertently runs into the next case.
• Benefit: Avoids logic bugs from unintended fall-through.
• Example:

function getValue(x: number): number {
  if (x > 10) {
    return x;
  }
  // Error: Function lacks return type annotation and has an implicit return.
}

 

Enabling Strict Mode

Strict mode can be enabled globally by setting "strict": true in the tsconfig.json file. This turns on all strict checks, including the options mentioned above. You can also enable individual strict checks by setting specific compiler options.

Example of Enabling Strict Mode in tsconfig.json:

{
  "compilerOptions": {
    "strict": true
  }
}

Alternatively, you can enable individual strict options like this:

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitThis": true,
    "strictFunctionTypes": true
  }
}

 

Summary

Strict mode in TypeScript enables a suite of type-checking rules that help catch potential errors early, improve code quality, and make the codebase safer and easier to maintain. By enabling strict mode, you ensure better handling of types, null values, unused variables, and function signatures. This makes TypeScript a more powerful tool for large-scale applications, promoting better development practices and reducing the chances of runtime errors.