0Pricing
TypeScript Academy · Lesson

The strict Flag and What It Enables

Understand strictNullChecks, noImplicitAny, and more.

The strict Flag and What It Enables is a free TypeScript Academy lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the TypeScript Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

Welcome

The strict flag in tsconfig enables a set of stricter type checking options. Understanding what each does helps you configure TypeScript for maximum safety.

What strict Enables

strict: true enables multiple sub-flags at once.
// strict enables:
// strictNullChecks, noImplicitAny, strictFunctionTypes,
// strictBindCallApply, strictPropertyInitialization,
// noImplicitThis, useUnknownInCatchVariables, alwaysStrict

strictNullChecks

Prevents assigning null/undefined to non-nullable types.
// Without: let s: string = null; // OK
// With: let s: string = null; // Error

noImplicitAny

Requires explicit type annotations where TypeScript would infer any.
// Without: function fn(x) {} // x: any
// With: // Error: Parameter has implicit any type

strictFunctionTypes

Enforces contravariance for function parameter types.
type Fn = (x: string | number) => void;
const fn: Fn = (x: string) => {}; // Error with strict

strictPropertyInitialization

Properties must be initialized in the constructor or marked !.
class C {
  name: string; // Error — not initialized
  // name!: string; // OK — known to be set later
  constructor() { this.name = 'Alice'; } // OK
}

noImplicitThis

Disallows using this with an any type (e.g., in non-class functions).

alwaysStrict

Emits use strict in every output file.

strictBindCallApply

Enforces correct types for bind, call, and apply on functions.
function add(a: number, b: number): number { return a + b; }
add.call(null, 1, '2'); // Error with strict

Incrementally Enabling Strict

Add strict sub-flags one at a time when migrating a large codebase.
{ "compilerOptions": { "strictNullChecks": true, "noImplicitAny": true } }

strict in New Projects

Always start new projects with strict: true. Retrofitting is much harder.

Quick Check

Which strict sub-flag prevents assigning null to a string variable?

Recap

The strict Flag and What It Enables: mastered the key concepts and patterns.

Frequently asked questions

Is the “The strict Flag and What It Enables” lesson free?

Yes — the full text of “The strict Flag and What It Enables” is free to read here on the web, and the TypeScript Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the TypeScript Academy course, upgrade to CoddyKit PRO.

What will I learn in “The strict Flag and What It Enables”?

Understand strictNullChecks, noImplicitAny, and more. You practise TypeScript Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start TypeScript Academy?

No prior experience is required. TypeScript Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “The strict Flag and What It Enables” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this TypeScript Academy lesson?

Yes. Every TypeScript Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. The strict Flag and What It Enables
  2. Module and Target Configuration
  3. Path Aliases and baseUrl
  4. Incremental Builds and Declaration Files
← Back to TypeScript Academy