Strict Mode TypeScript: Apa yang Diaktifkan strict: true

Strict mode adalah opsi "strict": true di tsconfig.json. Opsi ini adalah satu sakelar untuk delapan flag pengecekan tipe yang menangkap any implisit, null dan undefined yang tidak dicek, assignment fungsi yang tidak aman, dan field class yang tidak diinisialisasi. Di TypeScript 7, strict aktif secara default. Beginilah bentuk kode yang lolos pengecekannya:

function double(x: number) { // noImplicitAny: x needs a type
  return x * 2;
}

function findUser(id: number): { name: string } | undefined {
  return id === 1 ? { name: "Ada" } : undefined;
}

const user = findUser(2);
console.log(user?.name ?? "no user"); // strictNullChecks: user may be undefined

try {
  JSON.parse("{");
} catch (err) { // useUnknownInCatchVariables: err is unknown
  console.log(err instanceof Error ? err.name : String(err));
}

console.log(double(21));

Output-nya no user, SyntaxError dan 42. Hapus : number, ?., atau pengecekan instanceof, dan file-nya tidak lagi lolos kompilasi.

Mengaktifkannya

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

Flag individual mengalahkan strict, ke arah mana pun. "strict": true, "strictNullChecks": false mempertahankan semuanya kecuali pengecekan null; "strict": false, "noImplicitAny": true hanya mengaktifkan flag itu saja. strict juga otomatis mengikutsertakanmu dalam pengecekan yang ditambahkan di rilis mendatang, karena flag baru dari keluarga strict ikut bergabung ke kelompok itu.

strict milik TypeScript tidak ada hubungannya dengan direktif "use strict" di JavaScript, yang merupakan mode runtime. TypeScript 7 selalu menghasilkan "use strict" di tempat yang membutuhkannya, dan menyetel alwaysStrict: false adalah error TS5108 (opsi itu sudah dihapus).

Apa yang Ditangkap Setiap Flag

Dua flag yang paling banyak mengubah kode adalah noImplicitAny dan strictNullChecks. Blok ini sengaja melanggar keduanya:

// This does not compile: two strict errors.
function double(x) {
  return x * 2;
}

function findUser(id: number): { name: string } | undefined {
  return id === 1 ? { name: "Ada" } : undefined;
}

const user = findUser(2);
console.log(user.name, double(2));

Blok ini mencetak index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. dan index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. Tanpa strict, kode ini lolos kompilasi lalu crash saat runtime dengan TypeError: Cannot read properties of undefined (reading 'name'). Dengan strict, crash itu berubah menjadi error kompilasi. Perbaikannya ada di blok pertama halaman ini.

strictFunctionTypes: Kenapa Ada

Fungsi yang hanya menangani string tidak boleh dipakai di tempat yang bisa menerima number. Pengecekan di bawah ini diredam dengan @ts-expect-error supaya kamu bisa menjalankannya dan melihat apa yang dicegah oleh error itu:

type Handler = (value: string | number) => void;

const shout = (s: string) => console.log(s.toUpperCase());

// @ts-expect-error strictFunctionTypes rejects this assignment
const handle: Handler = shout;

try {
  handle(42); // the type allows a number, shout cannot take one
} catch (e) {
  console.log(e instanceof Error ? e.message : e); // s.toUpperCase is not a function
}

Tanpa komentar itu, assignment-nya adalah error TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., diikuti Types of parameters 's' and 'value' are incompatible. Ada satu pengecualian yang sengaja dipertahankan: parameter method yang dideklarasikan dengan sintaks method (handle(value: string | number): void di dalam interface) masih dicek dengan cara yang lebih longgar, jadi shout bisa di-assign ke method seperti itu tanpa error.

strictPropertyInitialization

Setiap field class harus mendapat nilai di deklarasinya atau di constructor. Ada tiga cara untuk memenuhinya:

class Account {
  owner: string;                  // assigned in the constructor
  balance = 0;                    // initializer
  history: string[] = [];         // initializer
  lastLogin?: Date;               // optional: may stay undefined
  sessionId!: string;             // "!": assigned later, you promise

  constructor(owner: string) {
    this.owner = owner;
  }
}

const a = new Account("Ada");
a.sessionId = "s-1";
console.log(a);

Output:

Account {
  owner: 'Ada',
  balance: 0,
  history: [],
  lastLogin: undefined,
  sessionId: 's-1'
}

Property lastLogin dan sessionId ada dengan nilai undefined karena field class adalah field JavaScript yang nyata pada target ES2022. ! menghapus pengecekannya tanpa menambah perlindungan apa pun saat runtime, jadi utamakan bentuk lainnya. Flag ini butuh strictNullChecks; mematikan flag itu ikut menonaktifkannya.

Mengaktifkan Strict di Proyek yang Sudah Ada

Mengalihkan codebase besar ke strict sekaligus bisa menghasilkan ratusan error. Karena strict adalah default di TypeScript 7, meng-upgrade proyek yang tsconfig.json-nya tidak pernah menyebut strict akan mengaktifkannya dengan sendirinya; tulis "strict": false kalau kamu butuh perilaku lama selama migrasi. Jalur yang menjaga build tetap hijau:

1. Tambahkan "strict": true dan matikan flag yang paling banyak error-nya, biasanya "strictNullChecks": false dan "noImplicitAny": false.
2. Perbaiki error yang tersisa, lalu aktifkan satu flag lagi dan ulangi.
3. Untuk noImplicitAny, sebagian besar perbaikannya adalah anotasi parameter. Untuk strictNullChecks, tambahkan | undefined di tempat nilai bisa hilang, lalu tangani dengan ?., ?? atau pengecekan if.
4. Kalau sebuah perbaikan harus ditunda, taruh // @ts-expect-error beserta alasannya di baris itu. Tidak seperti @ts-ignore, komentar ini melaporkan error begitu masalahnya hilang, jadi daftarnya menyusut dengan sendirinya.

Jangan memakai as any atau ! untuk meredam error secara massal: masing-masing menyembunyikan tepat bug yang ingin ditemukan oleh flag itu.

Flag Berguna yang Tidak Termasuk dalam Strict

Flag ini terpisah karena menolak kode yang sering kali sebenarnya benar. Banyak proyek tetap mengaktifkannya.

noUncheckedIndexedAccess menangkap paling banyak bug nyata. Kalau flag ini aktif:

const scores = [90, 85];
const d: Record<string, number> = {};

const third: number = scores[2]; // error TS2322: Type 'number | undefined' is not assignable to type 'number'.
const c: number = d["x"];        // same error

const safe = scores[2] ?? 0;     // number
for (const s of scores) {        // for...of is not affected: s is number
    console.log(s);
}

tsc --init di TypeScript 7 mengaktifkan noUncheckedIndexedAccess dan exactOptionalPropertyTypes di konfigurasi yang dihasilkannya, di samping strict.