tsconfig.json compiler options - Type Checking

Question 1

What does allowUnreachableCode compiler option do?

Answer 1

When:

• undefined - (default) provide suggestions as warnings to editors.
• true - unreachable code is ignored.
• false - raises compiler errors about unreachable code.

{
  "compilerOptions": {
    "allowUnreachableCode": true
  }
}

Source typescriptlang

Question 2

What does allowUnusedLabels compiler option do?

Answer 2

When:

• undefined (default) - provide suggestions as warnings to editors.
• true - unused labels are ignored.
• false - raises compiler errors about unused labels.

{
  "compilerOptions": {
    "allowUnusedLabels": true
  }
}

Source typescriptlang

Question 3

What does alwaysStrict compiler option do?

Answer 3

Ensures that your files are parsed in the ECMAScript strict mode, and emit “use strict” for each source file.

{
  "compilerOptions": {
    "alwaysStrict": true
  }
}

Source typescriptlang

Question 4

What does exactOptionalPropertyTypes compiler option do?

Answer 4

exactOptionalPropertyTypes makes TypeScript truly enforce the definition provided as an optional property.

It won’t allow undefined as a valid value on optional interface properties.

{
  "compilerOptions": {
    "exactOptionalPropertyTypes": true
  }
}

Source typescriptlang

Question 5

What does noFallthroughCasesInSwitch compiler option do?

Answer 5

Report errors for fallthrough cases in switch statements. Ensures that any non-empty case inside a switch statement includes either break or return. This means you won’t accidentally ship a case fallthrough bug.

{
  "compilerOptions": {
    "noFallthroughCasesInSwitch": true
  }
}

Source typescriptlang

Question 6

What does noImplicitAny compiler option do?

Answer 6

TypeScript will issue an error whenever it infers any type.

{
	"compilerOptions": {
	  "noImplicitAny": true
	}
}

Source typescriptlang

Question 7

What does noImplicitOverride compiler option do?

Answer 7

Using noImplicitOverride you can ensure that the sub-classes never go out of sync, by ensuring that functions which override include the keyword override.

{
	"compilerOptions": {
	  "noImplicitOverride": true
	}
}

Source typescriptlang

Question 8

What does noImplicitReturns compiler option do?

Answer 8

When enabled, TypeScript will check all code paths in a function to ensure they return a value.

{
	"compilerOptions": {
	  "noImplicitReturns": true
	}
}

Source typescriptlang

Question 9

What does noImplicitThis compiler option do?

Answer 9

TypeScript will issue an error on this expressions with an implied any type.

{
	"compilerOptions": {
	  "noImplicitThis": true
	}
}

Source typescriptlang

Question 10

What does noPropertyAccessFromIndexSignature compiler option do?

Answer 10

This setting ensures consistency between accessing a field via the “dot” (obj.key) syntax, and “indexed” (obj["key"]) and the way which the property is declared in the type.

Without this flag, TypeScript will allow you to use the dot syntax to access fields which are not defined.

{
	"compilerOptions": {
	  "noPropertyAccessFromIndexSignature": true
	}
}

Source typescriptlang

Question 11

What does noUncheckedIndexedAccess compiler option do?

Answer 11

TypeScript has a way to describe objects which have unknown keys but known values on an object, via index signatures.

interface EnvironmentVars {
  NAME: string;
  OS: string;
 
  // Unknown properties are covered by this index signature.
  [propName: string]: string;
}
 
declare const env: EnvironmentVars; 

const nodeEnv = env.NODE_ENV;// type is string

Turning on noUncheckedIndexedAccess will add undefined to any un-declared field in the type.

declare const env: EnvironmentVars; 

const nodeEnv = env.NODE_ENV;// type is string | undefined

Source typescriptlang

Question 12

What does noUnusedLocals compiler option do?

Answer 12

Reports errors on unused local variables.

{
	"compilerOptions": {
	  "noUnusedLocals": true
	}
}

Source typescriptlang

Question 13

What does noUnusedParameters compiler option do?

Answer 13

Reports errors on unused parameters in functions.

{
	"compilerOptions": {
	  "noUnusedLocals": true
	}
}

Source typescriptlang

Question 14

What does strict compiler option do?

Answer 14

The strict flag enables a wide range of type checking behavior that results in stronger guarantees of program correctness. Turning this on is equivalent to enabling all of the strict mode family options. You can then turn off individual strict mode family checks as needed.

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

Source typescriptlang

Question 15

What does strictBindCallApply compiler option do?

Answer 15

When set, TypeScript will check that the built-in methods of functions call, bind, and apply are invoked with correct argument for the underlying function.

{
  "compilerOptions": {
    "strictBindCallApply": true
  }
}

Note: true if strict, false otherwise.

Source typescriptlang

Question 16

What does strictFunctionTypes compiler option do?

Answer 16

When enabled, this flag causes functions parameters to be checked more correctly.

{
  "compilerOptions": {
    "strictFunctionTypes": true
  }
}

Note: true if strict, false otherwise.

Source typescriptlang

Question 17

What does strictNullChecks compiler option do?

Answer 17

When strictNullChecks is false, null and undefined are effectively ignored by the language. This can lead to unexpected errors at runtime.

When strictNullChecks is true, null and undefined have their own distinct types and you’ll get a type error if you try to use them where a concrete value is expected.

{
  "compilerOptions": {
    "strictNullChecks": true
  }
}

Note: true if strict, false otherwise.

Source typescriptlang

Question 18

What does strictPropertyInitialization compiler option do?

Answer 18

When set to true, TypeScript will raise an error when a class property was declared but not initialised in the constructor nor on declaration.

{
  "compilerOptions": {
    "strictPropertyInitialization": true
  }
}

Note: true if strict, false otherwise.

Source typescriptlang

Question 19

What does useUnknownInCatchVariables compiler option do?

Answer 19

In TypeScript 4.0, support was added to allow changing the type of the variable in a catch clause from any to unknown.

This pattern ensures that error handling code becomes more comprehensive because you cannot guarantee that the object being thrown is a Error subclass ahead of time.

{
  "compilerOptions": {
    "useUnknownInCatchVariables": true
  }
}

Note: true if strict, false otherwise.

Source typescriptlang