any מול unknown ב-TypeScript: ההבדלים ומתי להשתמש

any ו-unknown מקבלים שניהם כל ערך. ההבדל הוא מה אפשר לעשות עם הערך אחר כך: any מאפשר לעשות כל דבר ולא בודק כלום, ואילו unknown כמעט לא מאפשר לעשות כלום עד שמוכיחים מה הערך.

let a: any = "hello";
let u: unknown = "hello";

console.log(a.toUpperCase()); // HELLO: any allows every operation

// @ts-expect-error: 'u' is of type 'unknown'.
u.toUpperCase();

if (typeof u === "string") {
  console.log(u.toUpperCase()); // HELLO: u is a string inside this block
}

בלי השורה של @ts-expect-error, הקריאה u.toUpperCase() היא שגיאת הקומפילציה TS18046. הבדיקה עם typeof מצמצמת את u ל-string, ובתוך הבלוק הזה כל מתודות המחרוזת זמינות.

any מול unknown במבט אחד

במונחים של תורת הטיפוסים, unknown הוא ה-top type: כל טיפוס ניתן להשמה אליו, והוא ניתן להשמה רק ל-unknown ול-any. any הוא פתח מילוט שניתן להשמה לשני הכיוונים, לכל דבר חוץ מ-never.

any מכבה את בדיקת הטיפוסים

ערך מטיפוס any זוכה לאמון עיוור. הקומפיילר מקבל שגיאות הקלדה, טיפוסים שגויים ומאפיינים חסרים, והטעויות מופיעות במקום זה בזמן ריצה.

const user: any = { name: "Ada" };

const total: number = user.name; // compiles: any is assignable to number
console.log(typeof total);       // string

const city = user.adress;        // typo, still compiles
console.log(city);               // undefined

try {
  console.log(user.address.city); // compiles, throws at runtime
} catch (e) {
  console.log((e as Error).message);
}

הפלט מראה את הבעיה: משתנה עם הערת הטיפוס number מחזיק מחרוזת, והשורה האחרונה זורקת Cannot read properties of undefined (reading 'city'). בנוסף, any מתפשט. user.name הוא any, ולכן כל ערך שמחושב ממנו הוא any, וערך אחד בלי טיפוס יכול לכבות את הבדיקה רחוק מהמקום שבו הוא נכנס.

unknown מחייב לבדוק קודם

עם unknown, הקומפיילר מסרב לכל פעולה עד שהקוד מצמצם את הערך. הצמצום משתמש בבדיקות JavaScript רגילות, ובתוך כל ענף לערך יש את הטיפוס שנבדק.

function describe(value: unknown): string {
  if (typeof value === "string") return `string of length ${value.length}`;
  if (typeof value === "number") return `number ${value.toFixed(2)}`;
  if (Array.isArray(value)) return `array of ${value.length}`;
  if (value instanceof Date) return `date ${value.toISOString()}`;
  if (value === null) return "null";
  if (typeof value === "object" && "id" in value) return `object with id ${String(value.id)}`;
  return typeof value;
}

console.log(describe("hi"));                               // string of length 2
console.log(describe(3.14159));                            // number 3.14
console.log(describe([1, 2, 3]));                          // array of 3
console.log(describe(new Date("2024-03-15T10:30:00Z")));   // date 2024-03-15T10:30:00.000Z
console.log(describe({ id: 7 }));                          // object with id 7
console.log(describe(undefined));                          // undefined

הבדיקה value === null חייבת לבוא לפני בדיקת האובייקט, כי typeof null הוא "object". אחרי "id" in value, TypeScript יודעת שלאובייקט יש מאפיין id מטיפוס unknown, כי שום דבר לא אומר מה הוא מכיל. String() הופך אותו לטקסט באופן מפורש; כדי להשתמש בו כמספר צריך לבדוק אותו קודם עם typeof.

אפשר גם לדלג על הבדיקה עם assertion, value as string, והקומפיילר יקבל את זה. זו הבטחה בלי שום בדיקת זמן ריצה מאחוריה, ולכן עדיף להשתמש בבדיקה אמיתית; ראו type assertions.

ולידציה של JSON עם unknown

JSON.parse מוצהר כמחזיר any, ולכן התוצאה שלו מכבה בשקט את הבדיקה. תנו לתוצאה את הטיפוס unknown וכתבו type guard שבודק את המבנה לפני ששאר הקוד סומך עליו.

interface Settings {
  theme: string;
  fontSize: number;
}

function isSettings(v: unknown): v is Settings {
  return (
    typeof v === "object" && v !== null &&
    "theme" in v && typeof v.theme === "string" &&
    "fontSize" in v && typeof v.fontSize === "number"
  );
}

const inputs = ['{"theme":"dark","fontSize":14}', '{"theme":"dark"}'];

for (const text of inputs) {
  const data: unknown = JSON.parse(text);
  if (isSettings(data)) {
    console.log(`${data.theme} at ${data.fontSize}px`);
  } else {
    console.log("invalid settings:", text);
  }
}

הקלט הראשון מדפיס dark at 14px, והשני נדחה כי חסר בו fontSize. עם any, הקלט השני היה ממשיך הלאה כ-Settings עם fontSize לא מוגדר. לסכמות גדולות, ספריית ולידציה עושה את אותה עבודה ומסיקה את הטיפוס בשבילכם.

noImplicitAny

any לא מגיע רק מאנשים שכותבים אותו. פרמטר בלי הערת טיפוס ובלי הקשר להסיק ממנו יהיה any גם כן. האפשרות noImplicitAny, ש-strict מפעיל, מדווחת על זה כשגיאה:

// This does not compile: x has no type
function double(x) {
  return x * 2;
}

console.log(double(4));

index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type.

התיקון הוא הערת טיפוס, function double(x: number). גם כתיבה מפורשת של x: any עוברת קומפילציה, וזו בדיוק הנקודה: any נשאר גלוי בקוד, ואפשר לחפש אותו ולעבור עליו בסקירת קוד.

איפה any עדיין מתגנב

גם תחת strict, המקורות האלה מייצרים any בלי שהמילה מופיעה בקוד שלכם:

המשתנה של catch הוא unknown תחת strict כי אפשר לזרוק כל דבר, לא רק אובייקטי Error. צמצמו אותו עם e instanceof Error לפני שקוראים את e.message.

מתי any מקובל

any לא אסור, אבל כל שימוש בו הוא נקודה שהקומפיילר כבר לא מגן עליה. שימושים סבירים:

• מיגרציה של בסיס קוד JavaScript, שבה any מסמן את מה שעדיין אין לו טיפוסים.
• קוד שמערכת הטיפוסים לא מסוגלת לבטא היטב, כשהוא קטן ומוסתר מאחורי חתימת פונקציה עם טיפוסים.
• קוד בדיקות שמעביר בכוונה מידע שגוי.

לכל השאר, unknown מכסה את אותו מקרה של "אני לא יודע מה הטיפוס" ושומר על הבדיקות. צוותים רבים אוכפים את זה עם כלל ה-lint @typescript-eslint/no-explicit-any. טיפוס קרוב, Record<string, unknown>, הוא הבחירה הרגילה ל"אובייקט כלשהו עם ערכים לא ידועים".