@קומפיונט כתב בGitHub Copilot עכשיו בחינם:

ואגב, למי שלא אוהב לשתף קטעי קוד שלו עם GitHub

כמובן שזה רלוונטי רק למי שמשקיע בקוד שלו ולא נותן ל-AI לחבר בשבילו הכל...
(סליחה, לא שלטתי בעצמי, יש לי הרבה קיטור לשחרר נגד אנשים שעושים שימוש יתר ולא נכון ב-AI...)

הטייפ השולל: never

נחזור שוב ל-never לכמה רגעים
הטייפ never הוא סט בלי חברים, טייפ ששום ערך לא יכול להיות בו חבר.
נמצא שלא יקרה אף פעם שלערך אמיתי יהיה טייפ never
אם כן לְמָה זה טייפ שימושי?

שלילת מצב

אחד מהשימושים של טייפ זה הוא לסמן ל-TS שמצב מסויים אמור להיות בלתי אפשרי, ולקבל אישור מ-TS שזה באמת בלתי אפשרי
למשל: אם רוצים לוודא שב-switch עברנו על כל האפשרויות ולא פיספסנו אחד מהם בטעות אפשר לכתוב ככה:

type Color = 'red' | 'blue' | 'green'

function handleColor(color: Color) {
  switch (color) {
    case 'red':
      // ...
      break
    case 'blue':
      // ...
      break
    case 'green':
      // ...
      break
    default:
      throw new Error('Impossible!')
  }
}

פה אנחנו בודקים בזמן ריצה שלא הגענו לענף הבלתי אפשרי

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

type Color = 'red' | 'blue' | 'green'

function handleColor(color: Color) {
  switch (color) {
    case 'red':
      // ...
      break
    case 'blue':
      // ...
      break
    case 'green':
      // ...
      break
    default:
      const _test:never = color
      throw new Error('Impossible!')
  }
}

עיין שורה 15. אנחנו מצהירים ל-TS שבשלב הזה מיצינו את כל הערכים האפשריים ש-color יכול לקבל ופה הטייפ חייב להיות never, כלומר זה לא יקרה אף פעם
(להבין יותר איך זה עובד, כדאי להכיר את המושג narrowing, בקיצור נמרץ: מנוע TS עוקב אחרי משתנים תוך כדי זרימת הקוד וכאשר הוא רואה ביטויים מסויימים בקוד, הוא מבין אותם ומוציא מתוך ה-union של הטייפ של המשתנים את אותם הטייפים שהקוד שולל, ובהקשר שלנו, בכל ענף של ה-switch, מנוע TS יכיר בעובדה שהטייפ של color הוא רק הערך שאותו ענף מטפל, ובענף default הטייפ הוא האפשרויות שה-switch לא מיצה)
ברגע שנוסיף עוד אפשרות ל-union של Color נקבל מיד אזהרה שהמשתנה _test קיבל ערך שהטייפ שלו הוא לא never

שלילת ערך

אבל השימוש שמעניין אותנו יותר פה הוא השימוש השני,
כאשר יוצרים טייפ חדש באמצעות ביטוי עם תנאי, ורוצים שענף אחד של התנאי לא יחזיר שום טייפ, או יותר נכון: יחזיר טייפ ריק, במקום כזה בא never לידי שימוש
נדגים את זה על ידי ה-helper המובנה - Exclude
(helper הוא פונקציה שעוזר לבניית טייפ שמבוסס על טייפ קיים. נזכיר: פונקציה ב-TS == ‏generic)
הטייפ Exclude מגיע מובנה ב-TS ושימושו הוא כאשר רוצים ליצור מ-union קיים, טייפ שדומה למקור רק שחסר ממנו אחד או יותר ערכים.
למשל:

type Weekday = 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | 'friday' | 'saturday'
type Workday = Exclude<Weekday, 'friday' | 'saturday'>

כפי שאפשר לראות: ה"פונקציה" Exclude מקבלת כפרמטר ראשון את הטייפ המקורי ובפרמטר השני union של טייפים (או טייפ יחיד) לחסר מהטייפ המקורי.

איך הוא עובד?
הנה קוד המקור

type Exclude<T, U> = T extends U ? never : T

להבין את זה צריך להקדים עוד דבר אחד: ביטוי של תנאי שמריצים על union עובד על כל אבר של ה-union בנפרד
בתיעוד של TS קוראים לזה: Distributive Conditional Types
כלומר זה עובד כמו הקוד פסואודו הבא:

function Conditional(source: Union, condition: Type => Bool, resultIfTrue: Type => Type, resultIfFalse: Type => Type) {
  const runConditional = (type: Type) => {
    if (condition(type)) {
      return resultIfTrue(type)
    } else {
      return resultIfFalse(type)
    }
  }
  return source.split('|').map(runConditional).join('|')
}

function Exclude(source: Union, exclusions: Union) {
  return Conditional(source, t => t.extends(exclusions), t => t, t => never)
}

Exclude(Weekday, 'friday' | 'saturday') // 'sunday' | 'monday' | 'tuesday' | 'wednesday' | 'thursday' | never | never

מקווה שהפסאודו קוד מובן
רק מזכיר שוב כמה נקודות שכבר הזכרנו:

• בדיקת extends בודק עם הצד שמאלי כולו כלול בתוך הסט שהצד הימני מייצג
• פעולת union עם never - כמוהו כמו אי-פעולה. הוספת סט ריק לסט המקורי לא מוסיף שום דבר, לכן בתוצאה של Exclude אפשר להשמיט את ה-never בלי שום השלכה

הערה בענין מילת extends

בדרך אגב, כמה אנשים שאלו שאלה זו: למה המצב שבו טייפ אחד כלול לגמרי בתוך טייפ אחר נקרא בלע"ז extends, הרי המשמעות של extend בלע"ז הוא "הרחבה" ופה מדובר על הצרה?!
התשובה לזה לכאורה (וכן הסכים לזה מתכנת אחר שדיבר איתי על זה) שהמילה "הרחבה" בהקשר זה לא מדבר על הסט שהוא תוצאה מהגדרת הטייפ אלא על הגדרת הטייפ עצמו,
ככל שאתה יותר מאריך בהגדרת הטייפ, כך אתה שולל יותר ויותר מועמדים פוטנציאליים.
לדוגמה: טייפ unknown הוא הטייפ הכי גדול מצד אחד, כי הוא כולל כל הערכים האפשריים, ומצד שני הגדרתו הוא הכי קצר: אין שום הגדרה, כל מה שזז נכנס לתוך הטייפ הזה. ברגע שמרחיבים את ההגדרה, למשל מוסיפים תנאי שיש לו מתודה פלונית, אתה מצר את מעגל החברים בטייפ

"פונקציית" Omit

עכשיו נוכל להסביר את הטייפ Omit שבו סיימנו את הפוסט הראשון, וזה אמור להיות מובן בקלות כעת

הפונקציה מקבלת בפרמטר הראשונה אובייקט, ובשנייה, union של מפתחות שאתה רוצה להשמיט ממנו
דוגמה לשימוש (מתוך התיעוד הרשמי):

type Todo = {
  title: string
  description: string
  completed: boolean
  createdAt: number
}
 
type TodoPreview = Omit<Todo, "description">;

שיניתי קצת מהמקור בתיעוד של TS ממילת המפתח interface למילת type רק לשם העקביות כי לא הצגנו interface במאמר זה - יש הבדל קטן בין השניים אבל זה נושא לשיחה אחרת ולא חשוב כעת
פה אני רוצה להתמקד על האינטואיציות המרכזיות ולא על פרטים קטנים

והנה קוד המקור של Omit

type Omit<T, K extends keyof any> = { [P in Exclude<keyof T, K>]: T[P]; }

ננתח את זה לחלקים:

הפרמטרים

Omit<T, K extends keyof any>

הפונקציה מקבלת שני פרמטרים, הראשון ברור. זה יכול להיות כל טייפ שהוא. השני מוגבל לקבל רק טייפ שמקיים בעצמו התנאי extends keyof any
מה זה keyof any? זו דרך קצרה להגיד כל טייפ שחוקי להשתמש בו כמפתח של אובייקט כלשהו, שזה כהיום: string | number | symbol. אז הפרמטר השני הוא טייפ שמורכב רק מדברים שמותרים במפתח אובייקט

ה-body של הפונקציה

{ [P in Exclude<keyof T, K>]: T[P]; }

יש פה שימוש בכמה דברים שהסברנו כבר למעלה, נתחיל מהפנים לחוץ:

• keyof T = מחזיר union של כל המפתחות של שדות בטייפ T
• Exclude<keyof T, K>‎ = מוציא מתוך זה את השמות של השדות שאתה רוצה להשמיט בטייפ הסופי
• מיפוי [P in Exclude<keyof T, K>] מריץ לולאה על כל חבר מבודד מתוך ה-union שהתקבל מהשלב הקודם כאשר הטייפ המבודד מיוצג על ידי המשתנה P
• { [P in Exclude<keyof T, K>]: T[P]; } = מייצג טייפ שבו עבור כל P בלולאה, יש שדה בשם P וערך מהטייפ T[P] = כלומר הטייפ המקורי של שדה זו בטייפ המקורי

פסואודו קוד

והנה פסאודו קוד לקינוח:

function Omit(t: Type, u: UnionOfKeys) {
  const res = {}
  for (key of Omit(Keyof(t), u).split('|')) {
    res[key] = t[key]
  }
  return res
}

פשוט ביותר!

הנושא המקורי (אחרי כל ההקדמות הארוכות)

נחזור לנושא המקורי שהצגתי בכותרת
(אם חיכית בקוצר רוח לחלק זה, זה באמת לא כל כך מרעיש עולמות... מצטער...)

ולשם הקדמה אביא את הטריגר שהביא אותי להבנה זו:
מישהו שאל: איך אפשר ליצור טייפ שבו מותרים רק שדה x ו-y ולא שום שדה נוסף

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

type HasFoo = { foo: string }

גם אובייקט שיש לו שדה bar יכול להיות חבר בקובצת HasFoo

const hasBar = { bar: 1, foo: 'foo' } 
const test:HasFoo = hasBar // no error

Object literal may only specify known properties
אם הייתי כותב בקיצור בקטע הנ"ל:

const test:HasFoo = { bar: 1, foo: 'foo' }

הייתי מקבל שגיאה זו: Object literal may only specify known properties, and 'bar' does not exist in type 'HasFoo'.(2353)
אל תתנו לשגיאה זו להטעות אותך! העובדה ש-HasFoo לא מצהיר על שדה bar לא מונע מחברי הסט לשאת שדות נוספות!
ההתרעה של TS הוא מסיבה אחרת: מכיון שהמשתנה היחיד שקיבל את הערך של { bar: 1, foo: 'foo' } יש לו טייפ שלא כולל את השדה bar, יוצא שבפועל אין דרך להשתמש בשדה bar. כי הגישה דרך משתנה test אסור כי השדה לא כלול בטייפ שלו. רוב הסיכויים הם שקוד כזה הוא שגיאה של המתכנת, לכן TS מתריע.
לעומת זאת, בדוגמה שהבאתי, ששמרתי את הערך בתוך משתנה אחר לפני ההשמה ל-test, אין על מה להתריע מכיון ששדה bar נשאר נגיש דרך משתנה hasBar

נחזור לשאלה: איך אפשר לשלול שדות לא מוצהרות מטייפ

ספוילר: התשובה היא שאי אפשר. וזה מתועד בתשובות ב-stack overflow ו-issues בגיטהאב

אבל אני כעקשן ניסתי בכל זאת לפתור את זה על ידי הטייפ הבא:

type T = {
    x: string
    y: number
}

type Exact<T> = {
    [K in keyof any]?: K extends keyof T ? T[K] : never
}

מקווה שכעת קל לכם להבין את הקוד

בתרגום לאנגלית, זה אומר ככה:
בטייפ Exact<T>‎: קח את הטייפ של כל מפתח חוקי אפשרי (keyof any), עבור כל חבר מתוך מרכיביו בלולאה ותבדוק אם הוא מתוך המפתחות של T, אם כן, הערך של המפתח בתוך התוצאה צריך להיות כמו ב-T (המקור); אחרת הטייפ צריך להיות never - דבר שכמובן לא יכול להיות
לכאורה יצא לנו טייפ שאוסר מפתחות מיותרות

התשובה היא מה שכתבתי בכותרת: "טייפ X לא זהה ל-union של כל הערכים האפשריים שהטייפ כולל"

כלומר, הלולאה של K in keyof any שמפרק את keyof any למרכיביו, ומעביר כל מרכיב בודד בלולאה, לא מפרק את הטייפ string לכל מחרוזת אפשרית. בהקשר זה string הוא אטומי. כמו"כ number.

היה אפשר לחשוב אחרת, כי סה"כ הטייפ string הוא סה"כ סט שמחובר מכל המחרוזות האפשריים ביקום. אבל לצערנו TS לא מסתכל על זה ככה. אלא מתייחסים ל-string כאטום. ולכן בלולאה K in keyof any יש התייחסות רק ל-string ו-number ו-symbol ולא לערכים הפרטיים שמרכיבים אותם. כמובן, אם ככה, ההמצאה שלי לא תעבוד כי התנאי K extends keyof T אף פעם לא יתקיים

השלכה נוספת

עוד דבר שאנשים מבקשים מפעם לפעם (עיין דברי ימי שאלות SO ואישיו-אים של GH) הוא טייפ שמייצג כל מחרוזת אפשרית חוץ ממחרוזות ידועות לשמצה. למשל

type NotWeekday = Exclude<string, Weekday>

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

type Exclude<T, U> = T extends U ? never : T

הטייפ מתבסס על העובדה שלפני בדיקת התנאי יש פירוק של T למרכיביו ובדיקת התנאי רץ על כל מרכיב בנפרד (Distributive Conditional Types)
אבל לצערנו, הטייפ string הוא אטומי. הוא לא מתפרק לכל המחרוזות שמרכיבים אותו. לכן התנאי T extends U אף פעם לא מתקיים

---

תם ולא נשלם

קשה לייעץ בפרטות
באופן כללי מאוד (לענ"ד),
העבודות הכי נפוצות והכי נגישות למתחילים הם פיתוח אתרים, זה נכון בין למשרות מסודרות בין לפרילנסינג
בפיתוח אתרים יש צד שרת וצד לקוח, על פי רוב לאנשים יש נטייה יותר לצד זה או השני אבל הכי כדאי ללמוד שניהם
הטכנולוגיות העיקריות שצריך ללמוד עבור צד לקוח זה HTML ו-CSS, ושפת javascript, ואז כדאי ללמוד פריימוורק אחד (אני אישית ממליץ על VUE עבור מתחילים, אבל אפשר ללמוד גם ריאקט או אנגולר)
עבור צד שרת צריך ללמוד או nodejs או php (יש עוד הרבה שפות אבל אלו הכי פופולאריות ונגישות היום. אפשר להוסיף במקום שלישי גם פייתון). ב-php מומלץ לעבוד עם פריימוורק כמו laraval. אני ממליץ לעבוד עם PHP ו-laravel כך יהיה לך הכי קל להקים אתר שלם מקצועי עם הכי מעט עבודה
כדאי גם ללמוד קצת על מסדי נתונים ו-SQL

צריך לזכור שעבודה בתכנות פירושו למידה מתמדת. אף פעם לא גומרים ללמוד, אבל צריך לעבור מינימום למידה בסיסי של הנ"ל כדי להתחיל בפיתוח full stack דהיינו גם צד שרת וגם צד לקוח

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

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

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

אני מתלבט אם לצחוק או לבכות או להתעלם במשיכת כתפיים

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

הודעות

א. תודה לכל מי שטרח להשאיר לי משוב, אם בצורת הצבעה על הפוסט ואם בערוצים פרטיים (כמה חברים כתבו אלי בערוצים אחרים), אני מעריך את זה!
ב. לכל מי שהתקשה להבין את הפוסט הקודם:
אל תאשים את עצמך. זה לא היה פוסט קל להבנה! כתבתי דברים בקיצור, ולפעמים השמטתי לגמרי הסברים נחוצים.
הנושא עצמו מאוד תיאורטי, וגם הדוגמאות לא היו ממש מעשיות.
אני מתנצל. (אנסה להבא להביא דוגמאות יותר מעשיות)
ולמי שלא התקשה כלל: או שיש לך הכירות קודמת עם הנושא, או שאתה מוכשר, או שלא הבנת באמת
ג. חשוב להבהיר! אין שום צורך להכיר את כל התוכן התיאורטי שכתבתי כדי לקבל תועלת מ-TS. גם אם הנושא לא מושך אותך או אפילו דוחה אותך, אני עדיין ממליץ בחום להשתמש ב-TS כי אפשר לקבל רוב התועלת בלי להבין את הרקע התיאורטי. הפוסט שלי חשוב למי שרוצה ליצור טייפים. רוב הזמן אתה צורך טייפים שאחרים כתבו ולא יוצר טייפים חדשים. וגם רוב הטייפים שתיצור יהיו פשוטים בלי צורך בידע תיאורטי עמוק.
ד. העירו לי על כמה דברים שלא הסברתי די הצורך בפוסט הקודם ואנסה להבהיר אותם כאן

מה זה טייפ?

(הרחבה של הקטע "מה זה טייפ" בפוסט הקודם)

התפקיד של טייפים בשפות תכנות זהה לכל השפות: בהנתן ערך כלשהו, המתכנת רוצה לדעת בצורה סטטית (כלומר, בלי להריץ את התוכנה בפועל) איזה פעולות זמינים לו על ערך זה, איך מותר להשתמש בערך.
אבל יש הבדל מהותי בין ההתעסקות עם טייפים בשפות סטטיות (statically typed) "קלאסיות" (JAVA, C++, C#, etc) לטייפים ב-TS
כי בשפות קלאסיות אין עיסוק ישיר עם טייפים עצמם. עוסקים עם קלאסים, שהם "תבניות" או "אב טיפוס" לערכים, קלאס מגדיר איזה שדות הערך חייב להכיל, ובאיזה פעולות הוא צריך לתמוך. וכתוצאה נוצר "טייפ" (שהוא הסט של כל הערכים האפשריים שמתאימים לתבנית) אבל אין עיסוק ישיר עם טייפים עצמם
ב-TS יש עיסוק ישיר עם טייפים עצמם. מחברים טייפים אחד לשני, מחסרים טייפים אחד מהשני, בונים טייפים מטייפים אחרים, דברים שלא קיימים בשפות קלאסיות.
בשפה קלאסית אין מושג של literal type (הטייפ של ערך literal, סט בעל ערך יחיד). כי כל טייפ הוא תוצאה מהצהרה של קלאס שהוא תבנית להרבה ערכים כי העיקר של הטייפ הוא הפעולות שזמינים עליו.
לא כן ב-TS שאפשר לעסוק ישירות עם המושג טייפ.
לכן חשוב לחשוב על טייפים ב-TS כסטים, במקום כתבניות כמו בשפות קלאסיות

GENERICS

הדוגמה שהבאתי בפוסט הקודם לא היה מספיק ברור וגם לא כל כך מעשי
אביא דוגמה מעשי ביותר
נגיד שאתה בונה קליינט ל-API
אתה יודע שה-API המדובר תמיד מחזיר תשובות בתבנית זה:

type ApiResponse = {
  success: boolean
  data: object | undefined
  error: string | undefined
}

השימוש ככה:

type User = { ... }
type Transaction = { ... } 

class ApiClient {
  // users
  getUserById(id: number): ApiResponse { ... }
  updateUser(newUser: User): ApiResponse { ... }
  // transactions
  listTransactions(userId: number): ApiResponse { ... }
  // ...
}

const apiClient = new ApiClient

const res: ApiResponse = apiClient.getUserById(id)

if (res.success) {
  const user = res.data
  // do something with user
} else {
  console.error(error)
}

הבעיה בקוד הזה הוא שבשורה 18, הדבר היחיד ש-TS יודע על המשתנה user הוא שזה מסוג object אבל הוא לא יודע איזה סוג אובייקט.
דרך אחת לטפל בזה הוא להצהיר על טייפ בשם UserApiResponse ושם להצהיר על הטייפ המלא של שדה data
הבעיה היא שצריך לחזור שוב ושוב על הצהרה זו לכל סוג של XXXApiResponse
אפשרות אחרת הוא להצהיר שהטייפ של res.data הוא User

const user = res.data as User

אבל בצורה זו מאבדים את הבטחת האבטחה של TS וצריך לסמוך על המתכנת שהצהיר נכון על הטייפ
הפתרון הוא להשתמש ב-generic שהוא "טייפ בונה טייפים"
ככה:

type ApiResponse<T> = {
  success: boolean
  data: T | undefined
  error: string | undefined
}

type User = { ... }
type Transaction = { ... } 

class ApiClient {
  // users
  getUserById(id: number): ApiResponse<User> { ... }
  updateUser(newUser: User): ApiResponse<User> { ... }
  // transactions
  listTransactions(userId: number): ApiResponse<Transaction[]> { ... }
  // ...
}

const apiClient = new ApiClient

const res: ApiResponse = apiClient.getUserById(id)

if (res.success) {
  const user = res.data
  // user is type User
} else {
  console.error(error)
}

בפסאודו קוד ההצהרה דומה לקוד כזה:

const ApiResponse = function(T: type): type {
  return new Type(`{
    success: boolean
    data: ${T} | undefined
    error: string | undefined
  }`)
}

תנאים

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

אני רוצה להביא דוגמה מעשית פשוטה שבונה על הדוגמה הקודמת

נגיד שה-API מחזיר לפעמים אובייקט יחיד ולפעמים מערך
אם הוא מחזיר מערך אז יש שדות נוספות בתשובה
אולי נגיד שדה count שמחזיר כמה אובייקטים יש בסה"כ
איך נגדיר type כזה?

type BaseApiResponse<T> = {
  success: boolean
  data: T | undefined
  error: string | undefined
}

type ApiResponse<T> = T extends any[] ? BaseApiResponse<T> & { count: number } : BaseApiResponse<T>

אפשר לתרגם את זה לקוד פסאודו זה:

function ApiResponse(T: type): type {
  const base = `{
    success: boolean
    data: ${T} | undefined
    error: string | undefined
  }`
  if (T instanceof Array(any)) {
    return `base & { count: number }`
  } else {
    return base
  }
}

Mapped Types

הבאנו למעלה דוגמה שהיא גם מסובכת מדי וגם לא כל כך מעשי לשימוש יומיומי
אני רוצה להביא דוגמה נורמלית מתוך הטייפים המובנים (TS מגיע עם "ספרייה סטנדרטית" של טייפים מובנים)
נבנה על הדוגמה הקודמת שלנו של קליינט API
אז אתה רוצה להגדיר שהפונקציה updateUser מקבל אובייקט מסוג User אבל בשונה מ-User, כל השדות הם אופציונליות. (כי מי שרוצה לעדכן רק שדה אחת לא צריך לשלוח את כל השדות)

אז אפשר לכתוב טייפ חדש

type User = {
  name: string
  foo: string
  bar: number
}

type UserUpdate = {
  name?: string
  foo?: string
  bar?: number 
}

אבל זה בזבוז נייר דיו וביטים, וכמובן זה לא DRY מה שאמור לזעזע כל מתכנת ששוה משהו

הפתרון הוא:

  updateUser(newUser: Partial<User>): ApiResponse<User> { ... }

השתמשנו ב-helper (כך נקראים "פקונציות" אלו שעוזרים לבניית טייפים מבוססים טייפים קיימים) בשם Partial שלוקח טייפ ומחזיר טייפ עם אותם שדות, רק שכולם נהיים אופציונליים
איך עובד ה-helper הזה?
נסתכל בקוד המקור:

type Partial<T> = { [P in keyof T]?: T[P] | undefined; }

מילת המפתח in עובד ככה: עבור כל חבר ב-union שצד הימני מייצג, הוא מריץ את הביטוי שאחרי הנקדותיים כאשר המשתנה P מייצג את החבר הזה מה-union

שימו לב לתחביר שלא הצגנו מקודם: T[P] - זה אינדוקס בטייפ שעובד בדיוק כמו אינדוקס אובייקט רגיל. T[P] הוא הטייפ של שדה P בתוך טייפ T

נתרגם את זה לפסאודו קוד:

function keyOf(o: object): union {
    return new Union(Object.keys(o))
}

function Partial(T: type): type {
    const res = {}
    for (const P in keyOf(T)) {
        res[P] = T[P] | undefined
    }
    return res
}

(סליחה. בפסאודו קוד הזה השתמשתי במוסכמות אחרות מהקטעים הקודמים. בקודמים יצרתי טייפ על ידי העברת מחרוזת ל"בנאי של הטייפ" - כביכול. הפעם לשם נוחות התייחסתי לטייפ כאובייקט. זה רק פסאודו קוד כמובן ואני מקווה שהכוונה ברורה)

@dovid אמר בשאלה פילוסופית עד איזו רמה של מיקרו אופטימיזציה האדם מצווה לדקדק:

@ארכיטקט אני חושב שמתחילים צריכים להיות פאנטים

אם מותר לי להוסיף (מקווה שזו הבהרה ולא סילוף):
גם כאן קודם כל להיות פנאטי על ניפוי באגים ואז על קוד קריא ובנוי טוב ורק אח"כ על ביצועים

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

@davidnead אמר בדרוש מתכנת מנוסה למענה על שאלות גם מחוץ לגבולות הפורום:

מעט חסד, שבדרך כלל לא דורש ממנו הרבה

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

יש כמה יתרונות בעזרה דרך הפורום שאין בעזרה בפרטי,

• אין לחץ. אתה מחליט מתי ועל מה לענות וממה להתעלם
• יש מוטיבציה לכתוב משהו איכותי ומושקע, ומקבלים הכרה על ההשקעה, הדבר הזה גורם שלפעמים הרווח לעוזר יכול לעלות על הרווח לנעזר. אני אישית הרווחתי המון מהעזרה דרך הפורום, כאשר (לענ"ד) רוב התועלת לא הייתי מקבל מלענות בפרטי.

הנה תכונה בוורד שמאוד לא מוכר.

מה עושים אם צריך להעתיק מתוך קובץ וורד כמה קטעים לא רצופים?

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

דוגמא:

אבל מה תעשה אם זה קובץ ארוך ארוך ארוך? זה כבר נהיה מאוד מסורבל לעבוד כך.

בשביל זה יש את ה-"spike". זה כמו לוח שני (לא קשור ללוח העיקרי) שאפשר להוסיף לו דברים. צורת העבודה כך:

• ctrl+f3 חותך את הטקסט הנבחר מהמסמך ומוסיפו ל-spike
• ctrl+shift+f3 מרוקן את ה-spike ומדביקו לתוך המסמך איפה שהסמן נמצא
• אם רוצים להדביק בלי לרוקן את ה-spike, כותבים SPIKE בתוך המסמך איפה שרוצים להדביק ושוב לוחצים F3. (ביאור הדברים: ה-spike הוא טקסט אוטומטי בתוך וורד, כתיבה של השם של הטקסט האוטומטי ולחיצת F3, מחליף את השם בטקסט האוטומטי)

מתחת לשטח ה-spike הוא טקסט אוטומטי, אפשר לראות את זה פה (במארגן של חלקים מהירים - אין לי מושג איך הם קוראים לזה בעברית...):

הוספה:
זה נמצא גם פה:

כאן ניתן להגיב על מדריך: שורת הפקודה

@חוקר אמר באיך כותבים ומדפיסים בצבע לבן בוורד:

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

@יעקב-ישראל אמר באיך כותבים ומדפיסים בצבע לבן בוורד:

חיבור כל ארבעת הצבעים לא אמור ליצור לבן ?

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

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

צבעי המסך (RGB) הם מקורות אור - כל אחד מוסיף טווח תדרים מסויים.
צבעי המדפסת (CMY) הם מסנני אור - כל אחד מוריד טווח תדרים מסויים

חיבור צבעי המסך (RGB), מייצרים אור לבן.
חיבור צבעי המדפסת (CMY), זה אומר בעצם לסנן את כל האור: מייצר שחור.

(ע"ע)

תגובה: למה אין עדיין פורום מחשבים חרדי מקצועי??

@nigun אמר בלמה אין עדיין פורום מחשבים חרדי מקצועי??:

כלל ראשון: שליטה טובה באנגלית חובה

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

כל אחד מוזמן לכתוב את הכללים שלו...

הכי קל להסביר הוא בצורת משל לצינור מים

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

(אני לא מומחה לרשתות לכן אולי פיספסתי קצת את הנקודה, אבל כך אני מבין)

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

@ארכיטקט מקובלנו מפי רבותינו:
על שלושה דברים הקוד עומד: על התקינות, על הקריאות, ועל הביצועים. ובסדר הזה דייקא.

מצאתי במגילה עתיקה הכתובה בלשון לעז:

Make It Work Make It Right Make It Fast

עוד מקובלנו מפי רבותינו:
מיטוב שלא במקום צוואר בקבוק, בזבוז אנרגיה

ע"ע https://en.wikipedia.org/wiki/Program_optimization#When_to_optimize

זקן מדע המחשבים דונלד קנות' אמר:

We should forget about small efficiencies, say about 97% of the time: premature optimization is the root of all evil. Yet we should not pass up our opportunities in that critical 3%

@ארכיטקט אמר בהתקנתי Visual Studio 2022 כאן המקום למי שיודע דברים חשובים על IDE בכלל - דברים ששינו לי את החיים:

כל אחד שגילה משהו באיזה שהוא IDE פופולרי וזה שינה את חייו, אולי להעלות ולשתף את זה כאן

אני תמיד נופל בטעות של המחשבה ש"כולם כבר יודעים". אז הנה מה שעולה לי בראש כרגע על VSCODE - כמה קיצורים ותכונות שימושיות. (VSCODE ראוי לשם IDE?)

• הקיצור ctrl+d - אני משתמש בו בתדירות. זה מוצא ומדגיש ("בוחר") את המופע הבא של הטקסט המודגש (או המילה הנוכחית אם אין משהו מודגש). כל לחיצה נוספת מדגישה עוד מופע ועוד מופע, ואז אפשר לערוך את כולם ביחד.

• alt+shift+i - אם יש שורות מרובות בבחירה, זה הופך את הבחירה מבחירה אחת גדולה על כל הטווח לבחירות מרובות - אחת לכל שורה. ממש שימושי אם רוצים להוסיף משהו בסוף/תחילת כל שורה וכדומה.

• alt+shift+ או alt+shift+ - משכפל את האיזור המודגש (או השורה הנוחכית) למעלה או למטה

• ctrl+enter / ctrl+shift+enter -- יורד (עולה) שורה בלי לשבור את השורה הנכחית

תמיד תהיתם איך ממעגלים חשמליים זעירים מגיעים למשחק טטריס?
בדיוק בשבילך קיים קורס חינמי באתר קמפוסIL שיקח אותך ממעגלים חשמליים זעירים עד למשחק טטריס.
הקורס מושקע מאוד. כחלק מהקורס אתם בונים מחשב מהמסד עד הטפחות (למעט החומרה...). עבור סימלוט המחשב משתמשים בתוכנות ייעודיות שנבנו במיוחד עבור הקורס.
עברתי בינתיים על חלק א מהקורס ומאוד נהניתי. ממליץ מאוד.

https://campus.gov.il/course/huji-acd-huji-nand2tetris

@chv אני לא כל כך מסכים לגישה הזאת של "יש לך את זה" "תלך כבר מהתחלה על הכי גבוה שאתה חולם".
אני מכיר אנשים שהגישה הזאת עובדת אצלם.
מצד שני מי שלא ניחון בבטחון עצמי "בריא מאוד" כן יכול לקבל המון תועלת מקצת שפשוף בסביבה פחות מחייבת מאשר העולם האמיתי עם דדליינים וכו'.
כמובן שאם יש הצעה פחות מחייבת ועם כסף אז ברור שצריך לקבל אותו. אבל דברים כאלו לא גדלים באילנות.

@אינטרקום אמר בבקשה | מדריכים בJS:

נו.. מעולה... איפה אתה גר??

אני בירושלים. אם זה מתאים לך שלח לי מייל. (אני לא מבטיח לך שום דבר, אבל בטח נוכל להיפגש ולדבר)

@dovid אמר בתכנות | איך להתחיל?:

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

אה, תודה על המילים האלו!
זה מזכיר לי נושא חשוב מאוד.

על כל מתכנת מצויין יש 10 בינונים ו-100 לא טובים. (כמובן שאין אף אחד מהמאה בשיחה זו. איכשהו זה תמיד מישהו אחר ולא אנחנו... )
יש טווח עצום של רמות מהגרועים ביותר עד המצויינים ביותר.

מה מבדיל בין המצויין לבינוני והגרוע? (חוץ מיכולות שכליות)

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

נראה לי שחלק מההבדל הוא היכולת לדעת מה אתה לא יודע. אם תדע מה אתה לא יודע תמיד תלמד ותשאף ליותר.

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

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

@שוהם307

איזה שימושים עושים עם JS

בעיקר אתרי אינטרנט - גם צד הלקוח וגם צד השרת. (בצד לקוח אין כמעט שפות אחרות, בצד השרת JS היא (אחת מתוך כמה) מהשפות הפופולאריות ביותר היום
אין כמעט תוכנות דסקטופ שכתבות ב-JS (למעט אלה שמבוססים על electron שהוא בעצם דפדפן שמציג תוכנה אחת)

ומה נרוויח שנלמד את זה

JS היא השפה הכי פופולארית היום מבחינת כמות האנשים שמתכנתים בה ומשרות פנוייות.

חוץ מזה יש בו כמה יתרונות:

• אפשר לראות תוצאות אחרי שורות בודדות של קוד.
• היא קיימת בכל דפדפן, לא צריך שום התקנה להתנסות בה
• אני אישית סבור שהיא פשוטה יותר מפייתון (רבים יחלקו עלי מן הסתם), קלה יותר ללימוד מ-#C, ואם כן אחרי שהורדנו את שתי המתחרים העקריים מהשולחן לא נשארו בעצם מתחרים.

עוד נקודה:
כל שפה שתלמד תכניס לך מושגים חדשים שירחיבו את האופקים שלך. גם אם בסוף לא תעשה שימוש בשפה לא הפסדת מללמוד אותה.