טיפוסים ב-TypeScript: string, number, boolean ועוד

טיפוסים ב-TypeScript מתארים איזה סוג ערך משתנה יכול להחזיק. כותבים טיפוס אחרי נקודתיים, let name: string, והקומפיילר דוחה כל קוד ששם שם ערך מהסוג הלא נכון. הטיפוסים הבסיסיים הם שבעת הפרימיטיביים של JavaScript, ובנוסף טיפוסי אובייקט למערכים ולאובייקטים.

let title: string = "TypeScript";
let version: number = 7;
let isStrict: boolean = true;
let big: bigint = 9007199254740993n;
let id: symbol = Symbol("id");
let nothing: null = null;
let notSet: undefined = undefined;

let scores: number[] = [90, 72, 85];
let user: { name: string; age: number } = { name: "Ada", age: 36 };

console.log(title, version, isStrict, big, id);
console.log(nothing, notSet);
console.log(scores, user);

הערות הטיפוס נבדקות בזמן קומפילציה ואז מוסרות. התוכנית שרצה היא JavaScript רגיל.

הטיפוסים הפרימיטיביים

שמות הטיפוסים כתובים באותיות קטנות. typeof בזמן ריצה מחזיר את אותן מילים עבור רובם, ולכן typeof x === "number" היא הדרך לבדוק את הטיפוס הפרימיטיבי של ערך בזמן שהתוכנית רצה.

הערות טיפוס

הערת טיפוס היא : Type אחרי משתנה, פרמטר או רשימת הפרמטרים של פונקציה. בפרמטרים הערות הטיפוס הכי חשובות, כי TypeScript לא יכולה לנחש מה הקורא יעביר.

function describe(name: string, age: number, admin: boolean): string {
    return `${name} (${age})${admin ? " [admin]" : ""}`;
}

let label: string = describe("Ada", 36, true);
console.log(label); // Ada (36) [admin]

// Without an annotation, TypeScript infers the type from the value:
let count = 10; // count: number
count = count + 1;
console.log(count); // 11

כשמשתנה מאותחל באותה שורה, הערת הטיפוס בדרך כלל מיותרת: ל-let count = 10 כבר יש את הטיפוס number. הכללים להשמטת טיפוסים נמצאים בעמוד הסקת טיפוסים.

טיפוס שגוי הוא שגיאת קומפילציה

השימו ערך מהטיפוס הלא נכון והקומפיילר עוצר לפני שמשהו רץ:

// This does not compile: a string is not a number.
let port: number = 8080;
port = "3000";
console.log(port);

הקומפיילר מדפיס:

index.ts(3,1): error TS2322: Type 'string' is not assignable to type 'number'.

התיקון הוא להמיר את הערך, port = Number("3000"), או לשנות את הערת הטיפוס אם המשתנה באמת אמור להחזיק טקסט.

number: אין טיפוס של מספר שלם

JavaScript שומרת כל מספר כערך נקודה צפה של 64 ביט, ולכן ל-TypeScript יש טיפוס number אחד. מספרים שלמים מדויקים עד Number.MAX_SAFE_INTEGER (2 ** 53 - 1). מעבר לזה, השתמשו ב-bigint.

let price: number = 19.99;
let quantity: number = 3; // also number: no int type

console.log(Number.isInteger(quantity)); // true
console.log(Number.isInteger(price));    // false
console.log(Math.trunc(7 / 2));          // 3 (integer division)
console.log(0.1 + 0.2);                  // 0.30000000000000004

console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 (wrong)

let exact: bigint = 9007199254740991n + 2n;
console.log(exact); // 9007199254740993n

// @ts-expect-error: bigint and number cannot be mixed
const mixed = () => exact + 1;
console.log(exact + BigInt(1), Number(exact)); // 9007199254740994n 9007199254740992

bigint ו-number לא מתערבבים: exact + 1 היא שגיאת קומפילציה (TS2365: Operator '+' cannot be applied to types 'bigint' and '1'., כש-'1' הוא טיפוס הליטרל של ה-1), ואם היא הייתה רצה, גם TypeError בזמן ריצה. המירו צד אחד במפורש עם BigInt(1) או Number(exact), בידיעה ש-Number מעגל ערכים שמעבר לטווח הבטוח.

אם אתם רוצים טיפוס שמקבל רק מספרים שלמים, TypeScript לא יכולה לבטא את זה לערכים שרירותיים. בצעו ולידציה עם Number.isInteger במקום שבו הערך נכנס לתוכנית.

boolean

ל-boolean יש בדיוק שני ערכים, true ו-false. ערכים שהם רק truthy (1, "yes") הם לא בוליאניים, ולכן הפכו אותם לבוליאני עם Boolean(x) או x !== 0.

let loggedIn: boolean = false;
const items: string[] = ["a", "b"];

const hasItems: boolean = items.length > 0;
const hasName: boolean = Boolean("Ada");

console.log(loggedIn, hasItems, hasName); // false true true

null ו-undefined

כש-strict פעיל (ברירת המחדל מאז TypeScript 6.0), null ו-undefined הם טיפוסים נפרדים ואינם חלק מ-string, number או מכל טיפוס אחר. משתנה שעשוי להיות ריק אומר את זה עם union:

let nickname: string | undefined;
console.log(nickname); // undefined

nickname = "Ace";
console.log(nickname.toUpperCase()); // ACE

let middleName: string | null = null;
console.log(middleName ?? "(none)"); // (none)

קריאת מאפיין של ערך שעשוי להיות undefined היא שגיאת קומפילציה עד שבודקים אותו. העמוד null ו-undefined מכסה את הבדיקות, את ?. ואת ??.

מבט מהיר על מערכים ואובייקטים

כל מה שאינו פרימיטיבי הוא טיפוס אובייקט. שלוש הצורות שפוגשים ראשונות:

let tags: string[] = ["ts", "js"];               // array of strings
let point: { x: number; y: number } = { x: 1, y: 2 }; // object with two number properties
let greet: (name: string) => string = (n) => `hi ${n}`; // function type

לכל אחת יש עמוד משלה: מערכים, tuples (מערכים באורך קבוע), טיפוסי אובייקט וטיפוסי פונקציה.

string, number, boolean מול String, Number, Boolean

השמות באות גדולה הם הטיפוסים של אובייקטי העטיפה של JavaScript (new String("x")), ולא של ערכים רגילים. כתבו הערות טיפוס עם השמות באותיות קטנות.

// This does not compile: String (the wrapper) is not string (the primitive).
const wrapped: String = "text";
const plain: string = wrapped;
console.log(plain);

index.ts(3,7): error TS2322: Type 'String' is not assignable to type 'string'.
  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.

שנו את String ל-string בשורה הראשונה והבלוק ירוץ. אותו דבר חל על Number, Boolean, Symbol ו-BigInt. (Object הוא מקרה אחר: הוא מקבל כמעט כל ערך, כולל פרימיטיביים; ראו טיפוסי אובייקט.)

טיפוסים מובנים נוספים

עוד כמה טיפוסים מופיעים מוקדם. לכל אחד יש עמוד משלו.