תיעוד TypeScript
מדריך עיון תמציתי ל-TypeScript, מבוסס דוגמאות. קוראים את המושג, רואים את הקוד, ואז מתרגלים אותו במסלול של Coddy.
להתחיל מסלול TypeScript מודרךצעדים ראשונים
- מה זה TypeScriptTypeScript היא JavaScript עם טיפוסים סטטיים. מסמנים ערכים בטיפוסים, הקומפיילר בודק אותם לפני שהקוד רץ, והפלט הוא JavaScript רגיל שרץ בכל דפדפן וגם ב-Node.js, Deno ו-Bun.
- TypeScript מול JavaScriptTypeScript הוא JavaScript עם מערכת טיפוסים סטטית שנבדקת לפני שהקוד רץ. השוו בין השתיים זו לצד זו: תחביר, מה בודק הטיפוסים תופס, שלב ה-build, מהירות בזמן ריצה, עקומת הלמידה, ואיך מעבירים פרויקט JavaScript.
- התקנת TypeScriptהתקינו TypeScript עם npm כ-dev dependency של הפרויקט, בדקו את הגרסה עם npx tsc --version, צרו tsconfig.json עם tsc --init וקמפלו את הקובץ הראשון. העמוד מכסה גם התקנה גלובלית, pnpm, Yarn ו-Bun, ואת השגיאות שאנשים נתקלים בהן.
- הרצת TypeScriptחמש דרכים להריץ קובץ .ts: לקמפל עם tsc ולהריץ את ה-JavaScript, להריץ ישירות עם node file.ts (type stripping), להשתמש ב-tsx או ב-ts-node, או להשתמש ב-Deno וב-Bun. אילו מהן בודקות טיפוסים, איזה תחביר כל אחת תומכת, ובאיזו לבחור.
- tsconfig.jsontsconfig.json מסמן תיקייה כפרויקט TypeScript וקובע את אפשרויות הקומפיילר. האפשרויות החשובות (target, module, moduleResolution, strict, rootDir, outDir, include, lib, types, noEmit, skipLibCheck), הגדרה מומלצת להתחלה, extends ומה השתנה ב-TypeScript 7.
- TypeScript 7TypeScript 7 הוא הקומפיילר של TypeScript שנכתב מחדש ב-Go כתוכנה native: מהיר בערך פי עשרה, עם אותה פקודת tsc ואותה שפה. מה השתנה למשתמשים (ברירות מחדל חדשות, אפשרויות שהוסרו, ה-API החסר ל-JavaScript), אילו כלים עדיין צריכים את TypeScript 6, ואיך משדרגים.
- הערותTypeScript משתמשת בהערות // ו-/* */ של JavaScript, ובנוסף בהערות JSDoc מסוג /** */ שעורכים מציגים כשמרחפים מעל קוד. היא קוראת גם כמה הערות מיוחדות: @ts-expect-error, @ts-ignore, @ts-nocheck, @ts-check והנחיות /// <reference>.
- TypeScript מול PythonTypeScript ו-Python הן שתיהן שפות עיליות עם garbage collection, אבל TypeScript בודק את הטיפוסים שלו לפני שהקוד רץ, וה-type hints של Python הם אופציונליים ומתעלמים מהם בזמן ריצה. השוואה זו לצד זו של טיפוסים, סביבת ריצה, מהירות, אקוסיסטמות ושימושים, עם אותה תוכנית בשתי השפות.
טיפוסים בסיסיים
- טיפוסים בסיסייםהטיפוסים המובנים של TypeScript: string, number, boolean, bigint, symbol, null ו-undefined, ובנוסף מבט מהיר על מערכים ואובייקטים. איך כותבים הערת טיפוס, למה אין טיפוס של מספר שלם, ולמה כותבים string ולא String.
- הסקת טיפוסיםTypeScript מסיק את רוב הטיפוסים מהערכים שאתם כותבים. למדו מה הוא מסיק עבור משתנים, let מול const, אובייקטים, מערכים וערכי החזרה, איך callbacks מקבלים את הטיפוסים שלהם מההקשר, ואיפה עדיין צריך הערת טיפוס.
- מחרוזותעבודה עם מחרוזות ב-TypeScript: אינטרפולציה עם template literals, מחרוזות מרובות שורות, בדיקה אם מחרוזת מכילה תת-מחרוזת, המתודות הנפוצות והטיפוסים שהן מחזירות, ו-string literal types.
- המרת מחרוזת למספרהמירו מחרוזת למספר ב-TypeScript עם Number(), parseInt(), parseFloat() או + אונרי, ראו איך כל אחת מטפלת בקלטים כמו "42px", "" ו-"1e3", בדקו NaN בבטחה, והמירו מספרים בחזרה למחרוזות.
- מערכיםאיך נותנים טיפוסים למערכים ב-TypeScript: T[] מול Array<T>, מערכים של אובייקטים, מערכים שמחזיקים כמה טיפוסים, מערכים לקריאה בלבד, ומה map, filter, reduce ו-find מחזירות. ובנוסף, המלכודת של includes עם מערכי ליטרלים.
- TuplesTuple ב-TypeScript הוא מערך עם מספר קבוע של איברים שהטיפוסים שלהם ידועים לפי מיקום, כמו [string, number]. למדו את התחביר, איברים עם שמות, איברים אופציונליים ו-rest, tuples לקריאה בלבד ו-as const, החזרת tuples מפונקציות, ובמה tuples שונים ממערכים.
- טיפוסי אובייקטאיך מגדירים טיפוסים לאובייקטים ב-TypeScript: טיפוסי אובייקט inline, מאפיינים אופציונליים עם ?, מאפייני readonly, אובייקטים מקוננים, מתודות, בדיקת מאפיינים עודפים, וההבדל בין object, {} ו-Object.
- Enumsenum ב-TypeScript הוא קבוצה של קבועים עם שמות, כמו enum Direction { Up, Down }. כאן תלמדו על enums מספריים ו-enums של מחרוזות, ל-JavaScript שאליו enum מתקמפל, על מיפוי הפוך, מעבר על enum, const enums, ומתי union של ליטרלים של מחרוזות או אובייקט as const הם הבחירה הטובה יותר.
טיפוסים מיוחדים
- Literal Typesliteral type הוא טיפוס עם ערך אחד בדיוק, כמו "GET" או 404. כאן תלמדו literal types של string, number ו-boolean, unions של literals, למה let מרחיב ו-const לא, מה as const עושה, ו-const type parameters.
- any מול unknownגם any וגם unknown מקבלים כל ערך. any מכבה את בדיקת הטיפוסים עבור הערך, ואילו unknown מחייב לבדוק את הערך לפני שמשתמשים בו. כאן תלמדו את ההבדלים, איך מצמצמים unknown, מה זה noImplicitAny ואיפה any מתגנב לקוד עם טיפוסים.
- הטיפוס nevernever הוא הטיפוס שאין לו ערכים. זה טיפוס ההחזרה של פונקציות שאף פעם לא מסתיימות, הטיפוס שנשאר כש-narrowing פסל כל מקרה, והכלי שמאחורי בדיקות exhaustive ב-switch. כאן תלמדו מאיפה הוא מגיע ובמה הוא שונה מ-void.
- null ו-undefinedעם strictNullChecks, null ו-undefined הם טיפוסים נפרדים ש-TypeScript מחייב אתכם לטפל בהם. כאן תלמדו איך בודקים אותם, optional chaining (?.), סימן השאלה הכפול (??) ו-??=, וההבדל בין מאפיין אופציונלי ל-| undefined.
- Non-Null Assertion (!)סימן קריאה אחרי ערך, כמו user!, הוא האופרטור non-null assertion: הוא מסיר את null ו-undefined מהטיפוס בלי שום בדיקה בזמן ריצה. כאן תלמדו מה x! עושה, את צורות ה-definite assignment let x!: T ו-prop!: T, למה הן מסוכנות, וחלופות בטוחות יותר.
ממשקים וכינויי טיפוס
- Interfacesinterface נותן שם למבנה של אובייקט: אילו מאפיינים יש לו ואילו טיפוסים הם מחזיקים. כאן תלמדו איך מצהירים על interface, מאפיינים אופציונליים ו-readonly, מתודות, index signatures, הרחבה, מימוש במחלקה, declaration merging, interfaces גנריים ואיך נותנים ל-interface ערכי ברירת מחדל.
- Type aliasesType alias נותן שם לכל טיפוס בעזרת מילת המפתח type: מבני אובייקטים, unions, tuples, פונקציות, generics וטיפוסים רקורסיביים. למדו את התחביר, איך נראית כל צורה, ולמה alias הוא רק שם ולא טיפוס חדש ונפרד.
- Interface מול Typeגם interface וגם type יכולים לתאר מבנים של אובייקטים, וברוב המקרים כל אחד מהם עובד. כאן תלמדו את ההבדלים האמיתיים: declaration merging, unions ו-mapped types, extends מול intersections, index signatures מרומזות, דיווח שגיאות וביצועי הקומפיילר, ועוד כלל ברור לבחירה.
- מילת המפתח extendsמילת המפתח extends בונה טיפוס אחד מתוך טיפוס אחר. כאן תלמדו להרחיב interface (אחד או כמה), להרחיב type alias עם &, לדרוס את הטיפוס של מאפיין, להחליף מאפיינים עם Omit, ומה המשמעות של extends במחלקות, באילוצים גנריים וב-conditional types.
- Union typesUnion type כמו string | number פירושו שערך יכול להיות כל אחד מכמה טיפוסים. למדו מה אפשר לעשות עם union (רק מה שכל האיברים תומכים בו), איך מצמצמים אותו, unions של ליטרלים ושל טיפוסי אובייקטים, וההבדל בין (A | B)[] לבין A[] | B[].
- Intersection Typesטיפוס intersection מהצורה A & B מתאר ערך שהוא גם A וגם B בו זמנית, ולכן יש לו כל איבר של שניהם. כאן תלמדו איך משלבים טיפוסי אובייקט עם &, למה מאפיינים מתנגשים הופכים ל-never, איך intersection של unions שומר רק את האיברים המשותפים, ומתי עדיף להשתמש ב-extends.
- Discriminated Unionsdiscriminated union הוא union של טיפוסי אובייקט שחולקים מאפיין תגית ליטרלי, כמו kind או status. בדיקה של התגית מצמצמת את כל האובייקט. כאן תלמדו את הדפוס, צמצום עם switch, בדיקות ממצות עם never, ואיך לתאר תוצאות API, מצב של בקשה ומכונות מצבים.
פונקציות
- פונקציותאיך נותנים טיפוסים לפונקציות ב-TypeScript: הערת טיפוס לכל פרמטר, טיפוס החזרה מפורש או מוסק, void לפונקציות שלא מחזירות כלום, וטיפוסים לפונקציות חץ, ל-function expressions, לפונקציות async ולפרמטר this.
- טיפוסי פונקציותאיך כותבים את הטיפוס של פונקציה ב-TypeScript: תחביר החץ (a: number) => string, type aliases לפונקציות, הגדרת טיפוסים לפונקציות חץ ול-callbacks, חתימות קריאה ובנייה, ולמה הטיפוס Function רופף מדי.
- פרמטרים אופציונלייםסמנו פרמטר ב-TypeScript כאופציונלי עם ?, תנו לו ערך ברירת מחדל, או אספו כל מספר של ארגומנטים עם פרמטר rest. כולל כללי הסדר, השמטה מול undefined, אובייקטי אפשרויות ופרמטרים אופציונליים בטיפוסי פונקציה.
- Function Overloadingfunction overloads ב-TypeScript מאפשרים לפונקציה אחת כמה חתימות קריאה, לכל אחת טיפוס החזרה משלה. כאן תלמדו את התבנית של חתימות overload ומימוש אחד, את הכללים שהקומפיילר בודק, מתי פרמטר union עדיף, ו-overloads במחלקות.
צמצום ובדיקת טיפוסים
- Type narrowingNarrowing הוא הדרך שבה TypeScript הופך טיפוס רחב כמו string | number לטיפוס ספציפי בתוך if, בתוך switch או אחרי return מוקדם. כל צורות הצמצום במקום אחד: typeof, truthiness, שוויון, in, instanceof, השמות, type predicates ו-discriminated unions.
- האופרטור typeofל-typeof יש שני תפקידים ב-TypeScript. בקוד הוא האופרטור של JavaScript שמחזיר בזמן ריצה "string", "number", "object" וכן הלאה, ו-TypeScript מצמצם לפיו. בטיפוס הוא ה-type query שמעתיק את הטיפוס של משתנה, כמו ב-keyof typeof obj וב-ReturnType<typeof fn>.
- האופרטור instanceofinstanceof בודק בזמן ריצה האם אובייקט נוצר ממחלקה מסוימת, ו-TypeScript מצמצם את המשתנה למחלקה הזו. איך זה עובד עם מחלקות משלכם ועם תתי-מחלקות של Error, למה הוא לא יכול לבדוק interfaces או type aliases, ואיפה הוא נותן תשובות מפתיעות.
- Type guardsType guard הוא בדיקה בזמן ריצה ש-TypeScript מבין. למדו את ה-guards המובנים, איך כותבים guard משלכם עם type predicate מהצורה value is Type, איך בודקים אם אובייקט הוא מטיפוס מסוים, פונקציות assertion עם asserts, ואיך מאמתים נתונים מטיפוס unknown.
- Type assertionsמילת המפתח as אומרת ל-TypeScript להתייחס לערך כאל טיפוס אחר. זה לא cast: שום דבר לא מומר ולא נבדק בזמן ריצה. למדו את התחביר של as ושל סוגריים משולשים, מה הקומפיילר מתיר, assertion כפול דרך unknown, ומתי type guard הוא הכלי הטוב יותר.
- האופרטור satisfiesהאופרטור satisfies בודק שערך מתאים לטיפוס בלי לשנות את הטיפוס שהוסק לערך. למדו מה הוא עושה, איך הוא משתווה להערת טיפוס ול-as (אותו אובייקט שנכתב בשלוש דרכים), איך הוא משתלב עם as const, ולמה הוא מתאים לאובייקטי הגדרות.
מחלקות
- מחלקותמחלקות ב-TypeScript הן מחלקות JavaScript עם שדות, מתודות ובנאים שיש להם טיפוסים. כאן תלמדו איך עובדות הצהרות שדות ו-strictPropertyInitialization, איך נותנים טיפוס ל-this, על getters ו-setters, איברים סטטיים, implements, ואיך מחלקה משמשת גם כטיפוס.
- בנאיםאיך נותנים טיפוסים לבנאי של מחלקה ב-TypeScript: פרמטרים עם טיפוסים ופרמטרים אופציונליים, parameter properties כמו constructor(private name: string), סדר האתחול של שדות, overloads של בנאים, קריאות super בתתי-מחלקות, בנאים פרטיים וטיפוסי בנאי עם new.
- מגדירי גישהב-TypeScript יש שלושה מגדירי גישה, public, private ו-protected, ובנוסף readonly. כאן תלמדו מה כל אחד מאפשר, למה private של TypeScript הוא בדיקה של זמן קומפילציה בזמן ששדות #private של JavaScript נאכפים בזמן ריצה, ובמה לבחור.
- ירושהירושת מחלקות ב-TypeScript: extends ו-super, דריסת מתודות עם טיפוסים תואמים, מילת המפתח override ו-noImplicitOverride, איברים מוגנים, הצהרה מחדש על שדות עם declare, ומתי implements הוא הכלי המתאים יותר.
- מחלקות אבסטרקטיותמחלקה אבסטרקטית ב-TypeScript היא מחלקת בסיס שאי אפשר ליצור ממנה מופע, והיא יכולה להשאיר מתודות למימוש בתתי-המחלקות. כאן תלמדו על מתודות ומאפיינים אבסטרקטיים, על תבנית template method, על טיפוסי בנאי אבסטרקטיים ועל המקרים שבהם interface היא הבחירה הטובה יותר.
- Decoratorsdecorators הם פונקציות שעוטפות או מחליפות איברים של מחלקה בעזרת התחביר @. כאן תלמדו את ה-decorators הסטנדרטיים ש-TypeScript תומכת בהם בלי שום דגל (מחלקה, מתודה, getter, שדה ו-accessor), decorator factories, addInitializer, ובמה הם שונים מ-experimentalDecorators הישנים ש-Angular ו-NestJS משתמשים בהם.
גנריקה
- GenericsGenerics מאפשרים לפונקציה, ל-interface, לטיפוס או למחלקה לעבוד עם הרבה טיפוסים ועדיין לשמור על הקשר ביניהם: מה שנכנס קובע מה שיוצא. כאן תלמדו פונקציות גנריות, הסקת ארגומנטי טיפוס, כמה פרמטרי טיפוס, interfaces ומחלקות גנריים, ערכי ברירת מחדל, ומתי לא להשתמש בגנריקס.
- אילוצים גנרייםאילוץ גנרי, T extends Something, מגביל אילו טיפוסים פרמטר טיפוס מקבל ומאפשר לפונקציה להשתמש במה שהאילוץ מבטיח. העמוד עוסק ב-extends עם צורות אובייקט ו-interfaces, ב-K extends keyof T לגישה בטוחה למאפיינים, באילוצים על טיפוסים פרימיטיביים ובשגיאות שתפגשו.
אופרטורי טיפוס
- האופרטור keyofkeyof מקבל טיפוס אובייקט ומחזיר את ה-union של שמות המאפיינים שלו. כאן תלמדו keyof עם interfaces, keyof typeof לאובייקטים רגילים, גישה מוטפסת למאפיינים עם גנריקס, index signatures (string | number), ולמה Object.keys מחזיר string[].
- Indexed Access Typesindexed access type קורא את הטיפוס של מאפיין מתוך טיפוס אחר: Person["age"] הוא number. כאן תלמדו את T["key"], מפתחות מסוג union, T[keyof T], T[number] לאיברי מערך, אינדקסים של tuple, ו-(typeof arr)[number] כדי להפוך מערך const ל-union.
- Mapped Typesmapped type בונה טיפוס אובייקט חדש באמצעות מעבר על מפתחות: { [K in keyof T]: ... }. כאן תלמדו את התחביר, את המודיפיירים readonly ו-? עם + ו--, מיפוי מפתחות מחדש עם as, סינון מפתחות, ואיך Partial, Readonly, Required, Pick ו-Record כתובים.
- Conditional Typesconditional type בוחר אחד משני טיפוסים לפי בדיקה: T extends U ? X : Y. כאן תלמדו את התחביר, איך conditional types מתפזרים על unions (ואיך עוצרים את זה), איך מחלצים טיפוסים עם infer, ואיך כותבים ReturnType בעצמכם.
- Template literal typesTemplate literal types בונים טיפוסי string literal באותו תחביר של גרשיים הפוכים כמו template strings ב-JavaScript: `on${Capitalize<E>}`. למדו את התחביר, איך unions מוכפלים, Uppercase ו-Capitalize, תבניות כמו `${number}px`, getters עם mapped types ופירוק מחרוזות עם infer.
- Branded Typesbranded type הוא פרימיטיבי עם תגית בלתי נראית, כמו string & { readonly __brand: "UserId" }, כך שאי אפשר להעביר UserId במקום שמצפה ל-OrderId. כאן תלמדו איך brands עובדים, פונקציות בנייה שמבצעות ולידציה, עוזר Brand גנרי, brands עם unique symbol ומספרים עם brand.
טיפוסי עזר
- Utility typesכל ה-utility types המובנים של TypeScript במקום אחד: Partial, Required, Readonly, Pick, Omit, Record, Exclude, Extract, NonNullable, Parameters, ReturnType, Awaited, טיפוסי המחרוזות ועוד, כל אחד עם תיאור של שורה אחת ודוגמה להרצה.
- RecordRecord<K, V> הוא טיפוס האובייקט שהמפתחות שלו הם K וכל הערכים שלו הם V. למדו Record עם מפתחות מחרוזת ועם מפתחות איחוד (כל מפתח חובה), Partial<Record>, לולאה על Record עם מפתחות עם טיפוס, המלכודת של מפתח חסר, ומתי להשתמש במקום זאת ב-index signature או ב-Map.
- Partial ו-RequiredPartial<T> הופך כל מאפיין של T לאופציונלי, וזה בדיוק הטיפוס של אובייקט עדכון או patch. למדו את Partial בפונקציות עדכון, למה הוא רדוד, איך כותבים DeepPartial, המלכודת של undefined מפורש, ואת ההפך שלו, Required<T>.
- OmitOmit<T, K> יוצר טיפוס עם כל המאפיינים של T חוץ מהמפתחות K. למדו Omit עם מפתח אחד ועם כמה מפתחות, דריסת טיפוס של מאפיין, הסרת המאפיין בזמן ריצה, Omit מול Exclude ו-Pick, למה Omit מקבל מפתחות שלא קיימים, Omit קפדני, ו-Omit על טיפוסי איחוד.
- PickPick<T, K> יוצר טיפוס עם המאפיינים של T שהמפתחות שלהם נמצאים ב-K בלבד. למדו Pick עם מפתח אחד או כמה מפתחות, איך הוא בודק מפתחות, Pick מול Omit, בחירה מטיפוסים מקוננים, פונקציית pick() עם טיפוסים, ובחירת מאפיינים לפי טיפוס הערך.
- readonly ו-Readonlyהמגדיר readonly וה-utility type Readonly<T> מונעים מקוד לבצע השמה מחדש למאפיינים. למדו מאפייני readonly ושדות מחלקה, Readonly<T>, מערכים לקריאה בלבד (readonly T[] ו-ReadonlyArray), ReadonlyMap ו-ReadonlySet, למה readonly רדוד וקיים רק בזמן קומפילציה, ואיך הוא משתווה ל-Object.freeze ול-as const.
- Exclude ו-ExtractExclude, Extract ו-NonNullable מסננים את האיברים של union type. כאן תלמדו מה כל אחד משאיר ומה הוא מסיר, איך בוחרים איברי union לפי מבנה, איך הם בנויים מ-conditional types, ובמה הם שונים מ-Omit ומ-Pick.
- ReturnType ו-ParametersReturnType, Parameters, ConstructorParameters, InstanceType ו-Awaited מחלצים טיפוסים מפונקציות, ממחלקות ומ-promises. למדו איך משתמשים בהם עם typeof, איך מקבלים את טיפוס התוצאה של פונקציה async, מה קורה עם overloads וגנריקס, ואיך ReturnType בנוי עם infer.
לולאות ואוספים
- לולאותכל הדרכים לכתוב לולאה ב-TypeScript והטיפוסים שכל אחת נותנת: לולאת for הקלאסית, for...of על מערכים, maps ומחרוזות, for...in ומפתחות המחרוזת שלו, forEach (בלי break ובלי await), לולאות מוטפסות על מפתחות של אובייקט, ו-while.
- משפט switchמשפט switch ב-TypeScript: התחביר, איך כל case מצמצם טיפוס union, switch ממצה שלא מתקמפל כשחסר case, התבנית switch (true), נפילה ל-case הבא (fallthrough) ו-scope של בלוקים.
- Mapאיך משתמשים ב-Map ב-TypeScript: יצירת Map<K, V> עם טיפוסים, למה get מחזיר V | undefined, set, has ו-delete, איטרציה לפי סדר ההכנסה, אובייקטים כמפתחות, המרה לאובייקטים ול-JSON ובחזרה, Map מול אובייקט מול Record, והגדרת טיפוסים ל-array.map().
- מילון (Dictionary)ב-TypeScript אין מחלקת dictionary או hashmap; נותנים טיפוס לחיפוש מפתח-ערך עם index signature, עם Record<K, V> או עם Map<K, V>. כאן תלמדו כל אחד מהם, איך בודקים אם מפתח קיים, איך מוסיפים, מוחקים ועוברים על רשומות, ולמה noUncheckedIndexedAccess חשוב למילונים.
אסינכרוניות ושגיאות
- Promisesאיך מגדירים טיפוסים ל-promises ב-TypeScript: הטיפוס Promise<T>, טיפוס ל-new Promise ול-resolve, איך then משנה את הטיפוס, למה catch נותן any, Promise.all עם תוצאות tuple, טיפוסי התוצאה של Promise.allSettled, ועטיפת API מבוסס callback ב-promise עם טיפוס.
- Async/Awaitאיך async ו-await מקבלים טיפוסים ב-TypeScript: פונקציית async מחזירה Promise<T>, await פורס אותו, שגיאות נתפסות עם try/catch, await ברמה העליונה דורש ES module, וההבדל בין המתנה אחד אחרי השני, המתנה במקביל והמלכודת של forEach.
- טיפול בשגיאותטיפול בשגיאות ב-TypeScript: למה המשתנה של catch הוא unknown, איך מצמצמים אותו עם instanceof Error, זריקת שגיאות, כתיבת מחלקות שגיאה מותאמות עם name ו-cause, והדפוס של טיפוס Result לשגיאות צפויות.
- Sleepל-TypeScript אין sleep מובנה, אבל שורה אחת נותנת לכם אחד: פונקציה שמחזירה Promise<void> ש-setTimeout מסיים. למדו איך עושים לה await, איך משהים בתוך לולאות, איך מנסים שוב עם השהיה, איך מבטלים sleep, ולמה אין ב-JavaScript sleep חוסם.
מודולים וכלים
- מודוליםכל קובץ TypeScript עם import או export ברמה העליונה הוא מודול. כאן תלמדו named exports ו-default exports, את import type ו-export type, איך ההגדרה module מחליטה בין פלט ES module ל-CommonJS, ולמה node16 ו-nodenext דורשים סיומת .js ב-imports.
- Namespacesnamespace ב-TypeScript מקבץ ערכים וטיפוסים תחת שם אחד ומתקמפל לאובייקט רגיל. כאן תלמדו את התחביר, איך namespaces מתמזגים זה עם זה ועם פונקציות ומחלקות, למה ES modules החליפו אותם, ואיפה עדיין פוגשים אותם: קבצי הצהרות והרחבה גלובלית.
- קבצי הצהרהקובץ .d.ts מתאר את הטיפוסים של קוד JavaScript בלי להכיל שום חלק ממנו, ומילת המפתח declare עושה את אותו הדבר בתוך קובץ .ts. כאן תלמדו איך קבצי הצהרה נוצרים, איפה חבילות @types נכנסות לתמונה, איך נותנים טיפוסים למודול בלי טיפוסים, ואיך declare global ו-module augmentation מרחיבים טיפוסים קיימים.
- strict modestrict: true ב-tsconfig.json מפעיל משפחה של בדיקות טיפוסים: noImplicitAny, strictNullChecks, strictPropertyInitialization ועוד חמש. ראו מה כל אחת תופסת, איך מפעילים strict mode בפרויקט קיים, ואילו דגלים שימושיים לא כלולים ב-strict.
- JSONJSON.parse מחזיר any, ולכן TypeScript סומך על כל טיפוס שתתנו לתוצאה. כאן תלמדו לתת טיפוס ל-JSON מפוענח, לאמת אותו עם type guard, להפוך דוגמת JSON ל-interface, לייבא קובצי .json, ומה JSON.stringify עושה ל-Dates, ל-Sets ול-undefined.
להעמיק יותר
- שיטות עבודה מומלצותשמונה הרגלים ב-TypeScript שמונעים באגים אמיתיים: להשאיר את strict פעיל, להשתמש ב-unknown במקום any, לתת להסקת הטיפוסים לעבוד, להעדיף unions על פני enums, לבדוק קונפיגורציה עם satisfies, לתאר מצב עם discriminated unions, להימנע מ-! ומ-as, ולהפוך מידע ל-readonly. לכל אחד יש דוגמת לפני ואחרי שאפשר להריץ.
- שאלות לראיון עבודה25 שאלות ראיון על TypeScript עם תשובות קצרות ונכונות וקוד, מסודרות מרמת מתחילים עד מתקדמים: any מול unknown, interface מול type, generics, צמצום טיפוסים, utility types, mapped types ו-conditional types, טיפוסיות מבנית, tsconfig ו-TypeScript 7.
