כמעט כל סוג של יישום שנכתב ב-JavaScript עובד עם זמנים או תאריכים בתפקיד כלשהו. בהתחלה, זה היה מוגבל ל-Date API המובנה. API זה כולל פונקציונליות בסיסית, אך מוגבל למדי במה שהוא יכול לעשות. ספריות צד שלישי כמו Moment.js, ומאוחר יותר ממשקי API מובנים כמו ממשקי ה-API Intl וה-Temporal API החדש, מוסיפים גמישות הרבה יותר לעבודה עם זמנים ותאריכים. עלייתו ונפילתו של Moment.js Moment.js היא ספריית JavaScript עם כלי עזר רבי עוצמה לעבודה עם זמנים ותאריכים. הוא כולל תכונות חסרות מה-Date API הבסיסי, כגון מניפולציה של אזור זמן, והופך פעולות נפוצות רבות לפשוטות יותר. Moment כולל גם פונקציות לעיצוב תאריכים ושעות. היא הפכה לספרייה בשימוש נרחב ביישומים רבים ושונים. עם זאת, ל-Moment היה גם חלק מהנפקות. זוהי ספרייה גדולה, ויכולה להוסיף משמעותית לגודל החבילה של אפליקציה. מכיוון שהספרייה אינה תומכת ברעד עצים (תכונה של מצרפים מודרניים שיכולים להסיר חלקים שאינם בשימוש בספריות), כל ספריית Moment כלולה גם אם אתה משתמש רק באחת או שתיים מהפונקציות שלה. בעיה נוספת עם Moment היא העובדה שהאובייקטים שהוא יוצר ניתנים לשינוי. לקריאה לפונקציות מסוימות על אובייקט Moment יש תופעות לוואי ומשנה את הערך של אותו אובייקט. זה יכול להוביל להתנהגות בלתי צפויה או באגים. בשנת 2020, מנהלי מומנט החליטו להעביר את הספרייה למצב תחזוקה. לא מתבצע פיתוח פיצ'ר חדש, והמנהלים ממליצים לא להשתמש בו לפרויקטים חדשים. ישנן ספריות תאריכים אחרות של JavaScript, כמו date-fns, אבל יש שחקן חדש בעיר, API המובנה ישירות ב-JavaScript: Temporal. זהו תקן חדש שממלא את החורים של ה-Date API המקורי וכן פותר חלק מהמגבלות שנמצאות ב-Moment ובספריות אחרות. מה זה זמני? Temporal הוא API חדש של זמן ותאריך שמתווסף לתקן ECMAScript, המגדיר JavaScript מודרני. החל ממרץ 20266, היא הגיעה לשלב 4 בתהליך TC39 (הוועדה המפקחת על הצעות ותוספות לשפת JavaScript), והיא תיכלל בגרסה הבאה של מפרט ECMAScript. זה כבר יושם במספר דפדפנים: Chrome 144+ ו-Firefox 139+, כאשר Safari צפוי להגיע בקרוב. Polyfill זמין גם עבור דפדפנים ו-Node.js שאינם נתמכים. ה-API הזמני יוצר אובייקטים שבדרך כלל מייצגים רגעים בזמן. אלה יכולים להיות חותמות משרה מלאה ותאריך באזור זמן נתון, או שהם יכולים להיות מופע כללי של זמן "שעון קיר" ללא כל מידע על אזור זמן או תאריך. חלק מהמאפיינים העיקריים של Temporal כוללים:
זמנים עם או בלי תאריכים. אובייקט זמני יכול לייצג זמן מסוים בתאריך מסוים, או זמן ללא כל מידע על תאריך. ניתן לייצג גם תאריך מסוים, ללא זמן. תמיכה באזור זמן. אובייקטים זמניים מודעים לחלוטין לאזור זמן וניתן להמיר אותם על פני אזורי זמן שונים. Moment תומך גם באזורי זמן, אך הוא דורש את ספריית אזור הזמן הנוספת. ללא שינוי. ברגע שנוצר אובייקט זמני, לא ניתן לשנותו. המרות אריתמטיות של זמן או אזור זמן אינן משנות את האובייקט הבסיסי. במקום זאת, הם יוצרים אובייקט זמני חדש. אינדקס מבוסס 1. מקור נפוץ לבאגים עם ה-Date API (כמו גם עם Moment) הוא שחודשים מאופסים באינדקס. זה אומר שינואר הוא חודש 0, ולא חודש 1 כפי שכולנו מבינים בחיים האמיתיים. זמני מתקן זאת על ידי שימוש באינדקס מבוסס 1 - ינואר הוא חודש 1. הוא מובנה בדפדפן. מאחר ש-Temporal הוא API בדפדפן עצמו, הוא לא מוסיף דבר לגודל החבילה של האפליקציה שלך.
חשוב גם לציין שה-Date API לא נעלם. בזמן ש-Temporal מחליף את ה-API הזה, הוא לא מוסר או מוציא אותו משימוש. יישומים רבים יישברו אם דפדפנים יסירו לפתע את ה-Date API. עם זאת, זכור גם ש-Moment נחשב כעת לפרויקט מדור קודם במצב תחזוקה. בהמשך המאמר, נסתכל על כמה "מתכונים" להעברת קוד מבוסס-מומנט ל-Temporal API החדש. בואו נתחיל לשחזר! יצירת אובייקטי תאריך וזמן לפני שנוכל לתפעל תאריכים ושעות, עלינו ליצור אובייקטים המייצגים אותם. כדי ליצור אובייקט Moment המייצג את התאריך והשעה הנוכחיים, השתמש בפונקציית הרגע. const now = moment(); console.log(עכשיו); // רגע<2026-02-18T21:26:29-05:00>
כעת ניתן לעצב או לבצע מניפולציה של אובייקט זה לפי הצורך.
// המר ל-UTC //אזהרה: זה משנה את האובייקט Moment ומעביר אותו למצב UTC! console.log(now.utc()); // רגע<2026-02-19T02:26:29Z>
// הדפס מחרוזת מעוצבת - שים לב שהיא משתמשת בזמן UTC כעת console.log(now.format('MM/DD/YYYY hh:mm:ss a')); // 02/19/2026 02:27:07 בבוקר
הדבר העיקרי שיש לזכור לגבי מומנט הוא שאובייקט Moment כולל תמיד מידע על השעה והתאריך. אם אתה צריך לעבוד רק עם מידע על זמן, זה בדרך כלל בסדר, אבל זה יכול לגרום להתנהגות בלתי צפויה במצבים כמו שעון קיץ או שנים מעוברות, שבהם התאריך יכול להשפיע על חישובי הזמן. הזמני גמיש יותר. ניתן ליצור אובייקט המייצג את התאריך והשעה הנוכחיים על ידי יצירת אובייקט Temporal.Instant. זה מייצג נקודת זמן המוגדרת על ידי הזמן מאז "העידן" (חצות UTC ב-1 בינואר 1970). Temporal יכול להתייחס לרגע זה בזמן עם דיוק ברמה של ננו-שנייה. const now = Temporal.Now.instant();
// ראה ננו-שניות גולמיות מאז התקופה console.log(now.epochNanoseconds); // 1771466342612000000n
// פורמט עבור UTC console.log(now.toString()); // 2026-02-19T01:55:27.844Z
// פורמט עבור אזור זמן מסוים console.log(now.toString({ timeZone: 'America/New_York' })); // 2026-02-18T20:56:57.905-05:00
ניתן ליצור אובייקטים Temporal.Instant גם עבור זמן ותאריך ספציפיים על ידי שימוש בשיטה מ סטטית.
const myInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
// עצב את האינסטנט באזור הזמן המקומי. שימו לב שזה רק שולט // העיצוב - הוא לא משנה את האובייקט כמו moment.utc. console.log(myInstant.toString({ timeZone: 'America/New_York' })); // 2026-02-18T21:10:00-05:00
אתה יכול גם ליצור סוגים אחרים של אובייקטים זמניים, כולל:
Temporal.PlainDate: תאריך ללא מידע זמן. Temporal.PlainTime: שעה ללא מידע על תאריך. Temporal.ZonedDateTime: תאריך ושעה באזור זמן מסוים.
לכל אחד מאלה יש מתודה מאת שניתן לקרוא לה עם אובייקט המציין את התאריך ו/או השעה, או מחרוזת תאריך לניתוח. // רק דייט const today = Temporal.PlainDate.from({ שנה: 2026, month: 2, // שים לב שאנו משתמשים ב-2 עבור פברואר יום: 18 }); console.log(today.toString()); // 2026-02-18
// רק זמן const lunchTime = Temporal.PlainTime.from({ שעה: 12 }); console.log(lunchTime.toString()); // 12:00:00
// תאריך ושעה באזור הזמן המזרחי של ארה"ב const dueAt = Temporal.ZonedDateTime.from({ אזור זמן: 'אמריקה/ניו_יורק', שנה: 2026, חודש: 3, יום: 1, שעה: 12, דקה: 0, שניה: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[אמריקה/ניו_יורק]
ניתוח כיסינו יצירה פרוגרמטית של מידע על תאריך ושעה. עכשיו בואו נסתכל על ניתוח. ניתוח הוא תחום אחד שבו Moment גמיש יותר מה-Temporal API המובנה. אתה יכול לנתח מחרוזת תאריך על ידי העברתה לפונקציית הרגע. עם ארגומנט בודד, Moment מצפה למחרוזת תאריך ISO, אבל אתה יכול להשתמש בפורמטים חלופיים אם אתה מספק ארגומנט שני המציין את פורמט התאריך שבו נעשה שימוש.
const isoDate = moment('2026-02-21T09:00:00'); const formattedDate = moment('2/21/26 9:00:00', 'M/D/YY h:mm:ss');
console.log(isoDate); // רגע<2026-02-21T09:00:00-05:00>
console.log(formattedDate); // רגע<2026-02-21T09:00:00-05:00>
בגרסאות ישנות יותר, Moment יעשה את הניחוש הטוב ביותר לנתח כל מחרוזת תאריך בפורמט שרירותי. זה עלול להוביל לתוצאות בלתי צפויות. לדוגמה, האם 02-03-2026 הוא 2 בפברואר או 3 במרץ? מסיבה זו, גרסאות חדשות יותר של Moment מציגות אזהרת ביטול בולטת אם היא נקראת ללא מחרוזת תאריך בפורמט ISO (אלא אם כן ניתן גם הארגומנט השני עם הפורמט הרצוי). Temporal ינתח רק מחרוזת תאריך בפורמט ספציפי. המחרוזת חייבת להיות תואמת לפורמט ISO 8601 או הסיומת שלו, RFC 9557. אם מחרוזת תאריך שאינה תואמת מועברת לשיטת מ-, Temporal תשליך RangeError.
// שימוש במחרוזת תאריך RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[America/New_York]'); console.log(myDate.toString({ timeZone: 'America/New_York' })); // 2026-02-21T09:00:00-05:00
// שימוש במחרוזת תאריך לא ידועה const otherDate = Temporal.Instant.from('2/21/26 9:00:00'); // RangeError: שגיאה זמנית: תו לא חוקי בזמן ניתוח ערך השנה.
הדרישות המדויקות של מחרוזת התאריך תלויות באיזה סוג של אובייקט זמני אתה יוצר. בדוגמה לעיל, Temporal.Instant דורש ISO מלאמחרוזת תאריך 8601 או RFC 9557 המציינת את התאריך והשעה עם היסט של אזור זמן, אך ניתן גם ליצור אובייקטים של PlainDate או PlainTime באמצעות רק תת-קבוצה של פורמט התאריך. const myDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); // 2026-02-21
const myTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
שים לב שהמחרוזות האלה עדיין חייבות להתאים לפורמט הצפוי, אחרת תיגרם שגיאה.
// שימוש במחרוזות זמן שאינן תואמות. כל אלה יזרקו RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00 AM');
טיפ מקצוען: טיפול במחרוזות שאינן ISO מכיוון ש-Temporal נותן עדיפות לאמינות, הוא לא ינסה לנחש את הפורמט של מחרוזת כמו 02-01-2026. אם מקור הנתונים שלך משתמש במחרוזות כאלה, תצטרך לעשות קצת מניפולציה של מחרוזת כדי לסדר מחדש את הערכים למחרוזת ISO כמו 2026-02-01 לפני שתנסה להשתמש בה עם Temporal.
עיצוב ברגע שיש לך אובייקט Moment או Temporal, סביר להניח שתרצה להמיר אותו למחרוזת מעוצבת בשלב מסוים. זה מקרה שבו רגע הוא קצת יותר קצר. אתה קורא לשיטת הפורמט של האובייקט עם מחרוזת של אסימונים שמתארים את פורמט התאריך הרצוי. const date = רגע();
console.log(date.format('MM/DD/YYYY')); // 22/02/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 בפברואר 2026, 20:18:30 בערב
מצד שני, Temporal דורש ממך להיות קצת יותר מילולי. לאובייקטים זמניים, כגון Instant, יש שיטת toLocaleString שמקבלת אפשרויות עיצוב שונות שצוינו כמאפיינים של אובייקט.
const date = Temporal.Now.instant();
// ללא ארגומנטים, נקבל את פורמט ברירת המחדל עבור המקום הנוכחי console.log(date.toLocaleString()); // 22/02/2026, 20:23:36 (בהנחה שהמקום הוא en-US)
// העבר אפשרויות עיצוב ליצירת מחרוזת פורמט מותאמת אישית console.log(date.toLocaleString('en-US', { חודש: 'ארוך', יום: 'מספרי', שנה: 'מספרי', שעה: '2-ספרתי', דקה: '2 ספרתי' })); // 22 בפברואר 2026 בשעה 20:23
// העבר רק את השדות הרצויים במחרוזת הפורמט console.log(date.toLocaleString('en-US', { חודש: 'קצר', יום: 'מספרי' })); // 22 בפברואר
עיצוב תאריך זמני משתמש למעשה בממשק ה-API Intl.DateTimeFormat (שכבר זמין בדפדפנים מודרניים) מתחת למכסה המנוע. זה אומר שאתה יכול ליצור אובייקט רב פעמי DateTimeFormat עם אפשרויות העיצוב המותאמות אישית שלך, ואז להעביר אובייקטים זמניים לשיטת הפורמט שלו. בגלל זה, זה לא תומך בפורמטים מותאמים אישית של תאריך כמו Moment. אם אתה צריך משהו כמו 'Q1 2026' או עיצוב מיוחד אחר, ייתכן שתצטרך קוד עיצוב תאריך מותאם אישית או להגיע לספריית צד שלישי. const formatter = new Intl.DateTimeFormat('en-US', { חודש: '2-ספרתי', יום: '2-ספרתי', שנה: 'מספרי' });
const date = Temporal.Now.instant(); console.log(formatter.format(date)); // 22/02/2026
אסימוני העיצוב של Moment הם פשוטים יותר לכתיבה, אך הם אינם ידידותיים לאזור. הפורמט מחרוזת "קוד קשיח" דברים כמו סדר חודש/יום. היתרון בשימוש באובייקט תצורה, כפי שעושה טמפורל, הוא שהוא יתאים אוטומטית לכל מקום נתון וישתמש בפורמט הנכון. const date = Temporal.Now.instant();
const formatOptions = { חודש: 'מספרי', יום: 'מספרי', שנה: 'מספרי' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/2/2026
console.log(date.toLocaleString('en-GB', formatOptions)); // 22/02/2026
חישובי תאריכים ביישומים רבים, תצטרך בסופו של דבר לבצע כמה חישובים בתאריך. ייתכן שתרצה להוסיף או להחסיר יחידות זמן (ימים, שעות, שניות וכו'). לדוגמה, אם יש לך את התאריך הנוכחי, ייתכן שתרצה להציג למשתמש את התאריך בעוד שבוע. לאובייקטים של רגע יש שיטות כמו חיבור וחיסור שמבצעות את הפעולות הללו. פונקציות אלו לוקחות ערך ויחידה, לדוגמה: add(7, 'days'). הבדל אחד חשוב מאוד בין Moment לטמפורלי, לעומת זאת, הוא שכאשר מבצעים חישובי תאריך אלה, האובייקט הבסיסי משתנה והערך המקורי שלו אובד. const now = moment();
console.log(עכשיו); // רגע<2026-02-24T20:08:36-05:00>
const nextWeek = now.add(7, 'ימים'); console.log(בשבוע הבא); // רגע<2026-03-03T20:08:36-05:00>
// Gotcha - האובייקט המקורי עבר מוטציה console.log(עכשיו); // רגע<2026-03-03T20:08:36-05:00>
כדי להימנע מאובדן התאריך המקורי, אתה יכול לקרוא לשכפול באובייקט Moment כדי ליצור עותק. const עכשיו= רגע(); const nextWeek = now.clone().add(7, 'ימים');
console.log(עכשיו); // רגע<2026-02-24T20:12:55-05:00>
console.log(בשבוע הבא); // רגע<2026-03-03T20:12:55-05:00>
מצד שני, אובייקטים זמניים הם בלתי ניתנים לשינוי. לאחר שיצרת אובייקט כמו Instant, PlainDate וכן הלאה, הערך של האובייקט הזה לעולם לא ישתנה. לאובייקטים זמניים יש גם שיטות חיבור וחיסור. Temporal הוא קצת בררן לגבי יחידות זמן שניתן להוסיף לאילו סוגי אובייקטים. לדוגמה, לא ניתן להוסיף ימים לאינסטנט:
const now = Temporal.Now.instant(); const nextWeek = now.add({ days: 7 }); // RangeError: שגיאה זמנית: היחידה הגדולה ביותר לא יכולה להיות יחידת תאריך
הסיבה לכך היא שאובייקטים מיידיים מייצגים נקודת זמן ספציפית ב-UTC והם אגנוסטיים ללוח השנה. מכיוון שאורך היום יכול להשתנות בהתאם לכללי אזור הזמן כגון שעון קיץ, חישוב זה אינו זמין ב-Instant. עם זאת, אתה יכול לבצע פעולה זו על סוגים אחרים של אובייקטים, כגון PlainDateTime: const now = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = now.add({ days: 7 });
// שימו לב שה-PlainDateTime המקורי נשאר ללא שינוי console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 3/3/2026, 20:23:59
אתה יכול גם לחשב כמה זמן יש בין שני אובייקטים רגע או זמני. עם פונקציית ה-Diff של Moment, אתה צריך לספק יחידה לפירוט, אחרת היא תחזיר את ההפרש באלפיות השנייה. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date2.diff(date1)); // 91800000
console.log(date2.diff(date1, 'ימים')); // 1
כדי לעשות זאת עם אובייקט זמני, אתה יכול להעביר אובייקט זמני אחר לשיטות עד או מאז שלו. פעולה זו מחזירה אובייקט Temporal.Duration המכיל מידע על הפרש הזמן. לאובייקט Duration יש מאפיינים עבור כל רכיב בהפרש, והוא יכול גם ליצור מחרוזת משך ISO 8601 המייצגת את הפרש הזמן.
const date1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const date2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
// LargestUnit מציין את יחידת הזמן הגדולה ביותר לייצג // בחישוב משך הזמן const diff = date2.since(date1, { largestUnit: 'day' });
console.log(diff.days); // 1
console.log(diff.hours); // 1
console.log(diff.minutes); // 30
console.log(diff.toString()); // P1DT1H30M // (מחרוזת משך ISO 8601: יום אחד, שעה אחת, 30 דקות)
השוואת תאריכים ושעות Moment ו-Temporal שניהם מאפשרים לך להשוות תאריכים ושעות כדי לקבוע מה יבוא לפני השני, אך לנקוט גישות שונות עם ה-API. Moment מספק שיטות כגון isBefore, isAfter ו-isSame כדי להשוות בין שני אובייקטים של Moment. const date1 = moment('2026-02-21T09:00:00'); const date2 = moment('2026-02-22T10:30:00');
console.log(date1.isBefore(date2)); // נכון
Temporal משתמש בשיטת השוואה סטטית כדי לבצע השוואה בין שני אובייקטים מאותו סוג. הוא מחזיר -1 אם התאריך הראשון בא לפני השני, 0 אם הם שווים, או 1 אם התאריך הראשון מגיע אחרי השני. הדוגמה הבאה מראה כיצד להשוות שני אובייקטים של PlainDate. שני הארגומנטים של Temporal.PlainDate.compare חייבים להיות אובייקטים של PlainDate.
const date1 = Temporal.PlainDate.from({ year: 2026, month: 2, day: 24 }); const date2 = Temporal.PlainDate.from({ year: 2026, month: 3, day: 24 });
// date1 בא לפני תאריך2, אז -1 console.log(Temporal.PlainDate.compare(date1, date2));
// שגיאה אם ננסה להשוות בין שני אובייקטים מסוגים שונים console.log(Temporal.PlainDate.compare(date1, Temporal.Now.instant())); // TypeError: שגיאה זמנית: שדות PlainDate לא חוקיים סופקו.
בפרט, זה מקל על מיון מערך של אובייקטים זמניים באופן כרונולוגי. // מערך של אובייקטים Temporal.PlainDate const תאריכים = [ ... ];
// השתמש ב-Temporal.PlainDate.compare כפונקציית ההשוואה dates.sort(Temporal.PlainDate.compare);
המרות אזור זמן ספריית הליבה Moment אינה תומכת בהמרות של אזור זמן. אם אתה צריך את הפונקציונליות הזו, אתה צריך גם להתקין את חבילת הרגע-זמן. חבילה זו אינה ניתנת לטלטול עצים, ולכן יכולה להוסיף משמעותית לגודל החבילה שלך. לאחר שהתקנת מומנט-זמן, תוכל להמיר אובייקטים של Moment לאזורי זמן שונים בשיטת tz. כמו בפעולות אחרות של Moment, זה משנה את הבסיסלְהִתְנַגֵד. // בהנחה של שעון מזרח ארה"ב const now = moment(); console.log(עכשיו); // רגע<2026-02-28T20:08:20-05:00>
// המר לזמן האוקיינוס השקט. // הזמן המזרחי המקורי אבד. now.tz('אמריקה/לוס_אנג'לס'); console.log(עכשיו); // רגע<2026-02-28T17:08:20-08:00>
פונקציונליות אזור הזמן מובנית ב-Temporal API בעת שימוש באובייקט Temporal.ZonedDateTime. אובייקטים אלה כוללים שיטה withTimeZone המחזירה ZonedDateTime חדש המייצג את אותו רגע בזמן, אך באזור הזמן שצוין. // שוב, בהנחה של שעון מזרח ארה"ב const now = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28/02/2026, 8:12:02 PM EST
// המר לזמן האוקיינוס השקט const nowPacific = now.withTimeZone('America/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
// האובייקט המקורי נשאר ללא שינוי console.log(now.toLocaleString()); // 28/02/2026, 8:12:02 PM EST
הערה: הערכים המעוצבים המוחזרים על ידי toLocaleString הם, כפי שהשם מרמז, תלויי מיקום. הקוד לדוגמה פותח ב-en-US, כך שהפורמט הוא כזה: 28/2/2026, 17:12:02 PST. במקום אחר, זה עשוי להיות שונה. לדוגמה, באזור en-GB, תקבל משהו כמו 28/2/2026, 17:12:02 GMT-8. Refactoring בעולם האמיתי נניח שאנו בונים אפליקציה לתזמון אירועים על פני אזורי זמן. חלק מהאפליקציה הזו היא פונקציה, getEventTimes, שלוקחת מחרוזת ISO 8601 המייצגת את השעה והתאריך של האירוע, אזור זמן מקומי ואזור זמן יעד. הפונקציה יוצרת מחרוזות זמן ותאריך מעוצבות עבור האירוע בשני אזורי הזמן. אם הפונקציה מקבלת מחרוזת קלט שאינה מחרוזת שעה/תאריך חוקית, היא תגרום לשגיאה. הנה היישום המקורי, באמצעות Moment (המחייב גם שימוש בחבילת רגע-זמן).
ייבוא רגע מ'מומנט-זמן';
function getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, YYYY, h:mm:ss a z';
// 1. צור את הרגע הראשוני באזור הזמן של המשתמש const eventTime = moment.tz( inputString, moment.ISO_8601, // צפו למחרוזת ISO 8601 true, // ניתוח קפדני userTimeZone );
// זרוק שגיאה אם ה-inputString לא מייצג תאריך חוקי if (!eventTime.isValid()) { throw new Error('קלט תאריך/שעה לא חוקי'); }
// 2. חשב את זמן היעד // קריטי: עלינו לשכפל, או ש-'eventTime' משתנה לנצח! const targetTime = eventTime.clone().tz(targetTimeZone);
החזר { מקומי: eventTime.format(timeFormat), target: targetTime.format(timeFormat), }; }
const לוח זמנים = getEventTimes( '2026-03-05T15:00-05:00', 'אמריקה/ניו_יורק', 'אירופה/לונדון', );
console.log(schedule.local); // 5 במרץ 2026, 15:00:00 PM EST
console.log(schedule.target); // 5 במרץ 2026, 20:00:00 בערב GMT
בדוגמה זו, אנו משתמשים בפורמט תאריך צפוי של ISO 8601, המובנה בצורה מועילה ב-Moment. אנחנו גם משתמשים בניתוח קפדני, מה שאומר ש-Moment לא ינסה לנחש עם מחרוזת תאריך שאינה תואמת לפורמט. אם תעבור מחרוזת תאריך שאינה ISO, זה יגרום לאובייקט תאריך לא חוקי, ואנחנו זורקים שגיאה. היישום הזמני נראה דומה, אך יש לו כמה הבדלים עיקריים.
function getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. נתח את הקלט ישירות ל-Instant, ואז צור // ZonedDateTime באזור המשתמש. const instant = Temporal.Instant.from(inputString); const eventTime = instant.toZonedDateTimeISO(userTimeZone);
// 2. המר לאזור היעד // זה מחזיר אוטומטית אובייקט חדש; 'eventTime' בטוח. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. עיצוב באמצעות Intl (מובנה) const options = { שנה: 'מספרי', חודש: 'קצר', יום: 'מספרי', שעה: 'מספרי', דקה: '2-ספרתי', שנייה: '2-ספרתי', timeZoneName: 'קצר' };
החזר { מקומי: eventTime.toLocaleString(navigator.language, options), target: targetTime.toLocaleString(navigator.language, options) }; }
const לוח זמנים = getEventTimes( '2026-03-05T15:00-05:00', 'אמריקה/ניו_יורק', 'אירופה/לונדון', );
console.log(schedule.local); // 5 במרץ 2026, 15:00:00 PM EST
console.log(schedule.target); // 5 במרץ 2026, 20:00:00 PM GMT
עם Moment, עלינו לציין במפורש מחרוזת פורמט עבור מחרוזות התאריך המתקבלות. ללא קשר למיקום המשתמש או המקום, זמני האירוע יהיו תמיד בפורמט 5 במרץ 2026, 3:00:00אחר הצהריים EST. כמו כן, אנחנו לא צריכים לזרוק במפורש חריג. אם מחרוזת לא חוקית תועבר ל-Temporal.Instant.from, Temporal יזרוק לנו את החריגה. דבר אחד שיש לציין הוא שגם עם ניתוח קפדני, גרסת ה-Moment עדיין מקלה יותר. זמני דורש היסט של אזור הזמן בסוף המחרוזת. כדאי גם לשים לב שמכיוון שאנו משתמשים ב-navigator.language, קוד זה יפעל רק בסביבת דפדפן, מכיוון שהנווט אינו מוגדר בסביבת Node.js. ההטמעה הזמנית משתמשת במקום הנוכחי של הדפדפן (navigator.language), כך שהמשתמש יקבל אוטומטית זמני אירועים בפורמט הזמן המקומי שלו. במקום בארה"ב, זהו 5 במרץ 2026, 15:00:00 EST. עם זאת, אם המשתמש נמצא בלונדון, למשל, זמני האירועים יהיו בפורמט 5 במרץ 2026, 15:00:00 GMT-5. סיכום
פעולה Moment.js זמני זמן נוכחי רגע() Temporal.Now.zonedDateTimeISO() ניתוח ISO moment(str) Temporal.Instant.from(str) הוסף זמן .add(7, 'ימים') (מוטציה) .add({ days: 7 }) (אובייקט חדש) הבדל .diff(אחר, 'שעות') .מאז(אחר).שעות אזור זמן .tz('אזור/שם') .withTimeZone('Zone/Name')
במבט ראשון, ההבדל עשוי להיות מעט שונה (ובמקרה של Temporal, לפעמים יותר מילולי וקפדני יותר), אך ישנם מספר יתרונות מרכזיים לשימוש בטמפורל על פני Moment.js:
להיות יותר מפורש פירושו פחות הפתעות ובאגים לא מכוונים. הרגע עשוי להיראות מקל יותר, אך הוא כרוך ב"ניחושים", שלעיתים עלול לגרום לתאריכים שגויים. אם אתה נותן ל-Temporal משהו לא חוקי, זה משליך שגיאה. אם הקוד פועל, אתה יודע שיש לך תאריך חוקי. מומנט יכול להוסיף גודל משמעותי לחבילת האפליקציה, במיוחד אם אתה משתמש בחבילת אזור הזמן. זמני לא מוסיף דבר (ברגע שהוא נשלח בדפדפני היעד שלך). אי-שינוי נותנת לך את הביטחון שלעולם לא תאבד או תחליף נתונים בעת ביצוע המרות ופעולות של תאריכים. ייצוגים שונים של זמן (Instant, PlainDateTime, ZonedDateTime) בהתאם לדרישות שלך, כאשר Moment הוא תמיד מעטפת סביב חותמת זמן UTC. Temporal משתמש בממשקי ה-API Intl עבור עיצוב תאריך, מה שאומר שאתה יכול לקבל עיצוב מודע למיקום ללא צורך לציין במפורש אסימונים.
הערות על הפוליפיל כפי שצוין קודם לכן, קיים Polyfill Temporal זמין, המופץ כחבילת npm בשם @js-temporal/polyfill. אם אתה רוצה להשתמש בטמפורל היום, תזדקק ל-polyfill זה כדי לתמוך בדפדפנים כמו Safari שעדיין לא שלחו את ה-API. החדשות הרעות עם זה הן שזה יוסיף לגודל החבילה שלך. החדשות הטובות הן שזה עדיין מוסיף משמעותית פחות מרגע או רגע-זמן. להלן השוואה של גדלי החבילות כפי שדווח על ידי Bundlephobia.com, אתר אינטרנט המציג מידע על גדלי חבילות npm (לחץ על כל שם חבילה כדי לראות את ניתוח Bundlephobia):
חבילה ממוזער ממוזער ו-gzipped @js-temporal/polyfill 154.1 קילובייט 44.1 קילובייט רגע 294.4 קילובייט 75.4 קילובייט רגע-זמן 1 MB 114.2 קילובייט
ל-polyfill היו בעבר כמה בעיות ביצועים סביב שימוש בזיכרון, ובזמן הכתיבה, הוא נחשב במצב אלפא. בגלל זה, ייתכן שלא תרצה להשתמש בו בייצור עד שהוא יגיע למצב בוגר יותר. החדשות הטובות האחרות הן שבתקווה שלא יהיה צורך ב-polyfill עוד הרבה זמן (אלא אם כן תצטרך לתמוך בדפדפנים ישנים יותר, כמובן). בזמן הכתיבה, Temporal נשלחה בכרום, Edge ו-Firefox. זה עדיין לא ממש מוכן בספארי, אם כי נראה שהוא זמין עם דגל זמן ריצה בתצוגה המקדימה העדכנית של הטכנולוגיה.
