TypeScript strict mode: מה strict: true מפעיל

strict mode הוא האפשרות "strict": true ב-tsconfig.json. זה מתג אחד לשמונה דגלים של בדיקת טיפוסים, שתופסים any מרומז, null ו-undefined שלא נבדקו, השמות לא בטוחות של פונקציות ושדות מחלקה שלא אותחלו. ב-TypeScript 7, strict מופעל כברירת מחדל. כך נראה קוד שעובר אותו:

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));

הפלט הוא no user, SyntaxError ו-42. הסירו את : number, את ?. או את הבדיקה עם instanceof, והקובץ כבר לא יתקמפל.

איך מפעילים אותו

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

דגלים בודדים גוברים על strict, לשני הכיוונים. "strict": true, "strictNullChecks": false משאיר הכול חוץ מבדיקת null; "strict": false, "noImplicitAny": true מפעיל רק את הדגל הזה. strict גם מצרף אתכם לבדיקות שיתווספו בגרסאות הבאות, כי דגלים חדשים ממשפחת strict מצטרפים לקבוצה.

ל-strict של TypeScript אין שום קשר להוראה "use strict" של JavaScript, שהיא מצב של זמן ריצה. TypeScript 7 תמיד פולט "use strict" איפה שצריך, והגדרת alwaysStrict: false היא השגיאה TS5108 (האפשרות הוסרה).

מה כל דגל תופס

שני הדגלים שמשנים הכי הרבה קוד הם noImplicitAny ו-strictNullChecks. הבלוק הזה שובר את שניהם בכוונה:

// 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));

הוא מדפיס index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. ו-index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. בלי strict, הקוד הזה מתקמפל ואז קורס בזמן ריצה עם TypeError: Cannot read properties of undefined (reading 'name'). עם strict, הקריסה הופכת לשגיאת קומפילציה. התיקונים הם הבלוק הראשון בעמוד הזה.

strictFunctionTypes: למה הוא קיים

אסור להשתמש בפונקציה שמטפלת רק במחרוזות במקום שבו עשויים להגיע מספרים. הבדיקה למטה מושתקת עם @ts-expect-error כדי שתוכלו להריץ אותה ולראות ממה השגיאה מגינה:

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
}

בלי ההערה, ההשמה היא השגיאה TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., ואחריה Types of parameters 's' and 'value' are incompatible. נשאר חריג אחד בכוונה: פרמטרים של מתודות שהוגדרו בתחביר מתודה (handle(value: string | number): void בתוך interface) עדיין נבדקים בדרך המקלה, כך שאפשר היה להשים את shout למתודה כזו בלי שגיאה.

strictPropertyInitialization

כל שדה במחלקה חייב לקבל ערך בהצהרה שלו או בבנאי. שלוש דרכים לעמוד בזה:

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);

פלט:

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

המאפיינים lastLogin ו-sessionId קיימים עם הערך undefined, כי שדות מחלקה הם שדות JavaScript אמיתיים ב-target ES2022. ה-! מסיר את הבדיקה בלי להוסיף שום הגנה בזמן ריצה, אז עדיף להשתמש בצורות האחרות. הדגל הזה צריך את strictNullChecks; כיבוי שלו מכבה גם את זה.

הפעלת strict בפרויקט קיים

העברה של בסיס קוד גדול ל-strict בבת אחת יכולה לייצר מאות שגיאות. מכיוון ש-strict הוא ברירת המחדל ב-TypeScript 7, שדרוג של פרויקט שה-tsconfig.json שלו אף פעם לא הזכיר את strict מפעיל אותו מעצמו; כתבו "strict": false אם אתם צריכים את ההתנהגות הישנה בזמן המעבר. דרך שמשאירה את ה-build ירוק:

1. הוסיפו "strict": true וכבו את הדגלים עם הכי הרבה שגיאות, בדרך כלל "strictNullChecks": false ו-"noImplicitAny": false.
2. תקנו את השגיאות שנשארו, ואז הפעילו עוד דגל אחד וחזרו על התהליך.
3. ב-noImplicitAny, רוב התיקונים הם הערות טיפוס לפרמטרים. ב-strictNullChecks, הוסיפו | undefined איפה שערכים יכולים להיות חסרים, ואז טפלו בזה עם ?., ?? או בדיקת if.
4. איפה שתיקון צריך לחכות, שימו בשורה // @ts-expect-error עם סיבה. בניגוד ל-@ts-ignore, הוא מדווח שגיאה ברגע שהבעיה נעלמת, כך שהרשימה מתקצרת מעצמה.

אל תשתמשו ב-as any או ב-! כדי להשתיק שגיאות בכמויות: כל אחד מהם מסתיר בדיוק את הבאג שהדגל נוסף כדי למצוא.

דגלים שימושיים ש-strict לא כולל

הם נפרדים כי הם דוחים קוד שלעיתים קרובות הוא נכון. פרויקטים רבים מפעילים אותם בכל זאת.

noUncheckedIndexedAccess תופס הכי הרבה באגים אמיתיים. כשהוא מופעל:

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 ב-TypeScript 7 מפעיל את noUncheckedIndexedAccess ואת exactOptionalPropertyTypes בקובץ ההגדרות שהוא יוצר, לצד strict.