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