Date ב-JavaScript: new Date, עיצוב תאריכים והשוואה

האובייקט Date הוא רגע בזמן

Date ב-JavaScript מייצג רגע יחיד: מבפנים זה פשוט מספר מילישניות מאז 1 בינואר 1970 UTC (ה"Unix epoch"). כל השאר, שנים, חודשים, ימים, אזורי זמן ועיצוב, הוא תצוגה שנבנית מעל המספר הזה.

const now = new Date();
console.log(now);
console.log(now.getTime());

now.getTime() הוא מספר המילישניות הגולמי. כל מה ש-Date עושה, השוואה, הוספת ימים, עיצוב, מסתכם בשינוי המספר הזה ובפירוש מחדש שלו.

שמרו את המודל הזה בראש. Date הוא לא "14 במרץ בפריז". זה רגע אוניברסלי ש_אפשר להציג_ כ-14 במרץ בפריז, או כ-13 במרץ בלוס אנג'לס, תלוי באזור הזמן שדרכו מסתכלים עליו.

יצירת תאריכים

יש ארבע דרכים עיקריות ליצור Date:

const now = new Date();
const fromTimestamp = new Date(1_700_000_000_000);
const fromString = new Date("2026-03-14T09:30:00Z");
const fromParts = new Date(2026, 2, 14, 9, 30);

console.log(now.toISOString());
console.log(fromTimestamp.toISOString());
console.log(fromString.toISOString());
console.log(fromParts.toISOString());

שני דברים שכדאי לשים לב אליהם:

• ה-constructor שמקבל חלקים משתמש בחודשים שמתחילים מאפס. 2 הוא מרץ. ינואר הוא 0. זה מקור קבוע לבאגים של "טעות באחד". בכל שאר ה-API החודשים מתחילים מ-0 גם כן, אז לפחות זה עקבי עם עצמו.
• new Date("2026-03-14") (בלי שעה) מפוענח כחצות UTC. new Date("2026-03-14T09:30") (בלי Z) מפוענח כזמן מקומי. חוסר הסימטריה הזה הוא מלכודת קלאסית.

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

const start = Date.now();
for (let i = 0; i < 1_000_000; i++) {}
const elapsed = Date.now() - start;
console.log(`${elapsed} ms`);

Date.now() הוא הכלי הנכון למדידת זמן שעבר, ל-timeouts ולכל מקרה שבו לא צריך חישובי לוח שנה.

קריאת החלקים של תאריך

כשיש לכם Date, שולפים ממנו רכיבים בעזרת getters. לכל אחד יש שתי גרסאות: זמן מקומי ו-UTC.

const d = new Date("2026-03-14T09:30:00Z");

console.log(d.getFullYear());      // local year
console.log(d.getMonth());         // 0-11, local
console.log(d.getDate());          // day of month, local
console.log(d.getDay());           // day of week, 0=Sunday
console.log(d.getHours());
console.log(d.getMinutes());

console.log(d.getUTCFullYear());
console.log(d.getUTCHours());

הגרסאות המקומיות תלויות במחשב שמריץ את הקוד. אם אתם שומרים או משווים תאריכים בין משתמשים ושרתים, בחרו UTC במפורש, אחרת תרדפו אחרי באגי רפאים. כלל אצבע: השתמשו ב-getters של UTC לכל מה שנכנס למסד נתונים או ללוג, וב-getters המקומיים לכל מה שעומד להיות מוצג לבן אדם.

אל תשתמשו ב-getYear(). זו מתודה ישנה שמחזירה year - 1900 וקיימת רק לצורכי תאימות. תמיד השתמשו ב-getFullYear().

עיצוב לבני אדם

הימנעו מ-date.toString() בכל דבר שחשוב לכם: הפלט שלו תלוי בהגדרות האזוריות ובמנוע. יש שני מעצבים שכדאי להכיר.

למחרוזת תקנית שמיועדת למכונה, השתמשו ב-toISOString():

const d = new Date("2026-03-14T09:30:00Z");
console.log(d.toISOString());

זה הפורמט לשימוש בלוגים, בשמירה ב-JSON או בשליחה ברשת. הוא תמיד ב-UTC ותמיד חד משמעי.

למחרוזת שמוצגת לבני אדם, השתמשו ב-Intl.DateTimeFormat או במתודות toLocale*, שעוטפות אותו:

const d = new Date("2026-03-14T09:30:00Z");

console.log(d.toLocaleDateString("en-US"));
console.log(d.toLocaleDateString("en-GB"));
console.log(d.toLocaleString("fr-FR", { dateStyle: "full", timeStyle: "short" }));

const formatter = new Intl.DateTimeFormat("en-US", {
    year: "numeric",
    month: "long",
    day: "numeric",
    timeZone: "America/New_York",
});
console.log(formatter.format(d));

Intl.DateTimeFormat מטפל בשפות, באזורי זמן ובכל צירוף של שדות שתרצו. פנו אליו לפני שאתם כותבים עיצוב ידני כמו ${year}-${month}-${day}: בניית מחרוזות כזו היא בדיוק המקום שבו מסתתרים באגים של חודש אחד הצידה.

השוואת תאריכים

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

const a = new Date("2026-03-14T09:30:00Z");
const b = new Date("2026-03-14T09:30:00Z");

console.log(a === b);              // false
console.log(a.getTime() === b.getTime());  // true
console.log(+a === +b);            // true - unary + coerces to number

לסידור לפי סדר, אופרטורי ההשוואה עובדים ישירות כי הם ממירים למספרים:

const earlier = new Date("2026-01-01");
const later = new Date("2026-06-01");

console.log(earlier < later);
console.log(later > earlier);

const differenceMs = later - earlier;
const differenceDays = differenceMs / (1000 * 60 * 60 * 24);
console.log(`${differenceDays} days apart`);

חיסור נותן את הפער במילישניות. חלקו ב-1000 * 60 * 60 * 24 כדי לקבל ימים. כתבו את הקבוע הזה במלואו בפעם הראשונה; אחרי זמן מה תזהו את 86_400_000 במבט אחד.

חשבון תאריכים

אין מתודה addDays. הדרך המקובלת היא להשתמש ב-setDate, setMonth וכדומה: הן מקבלות ערכים מחוץ לטווח ומגלגלות אותם נכון:

function addDays(date, days) {
    const result = new Date(date);
    result.setDate(result.getDate() + days);
    return result;
}

const today = new Date("2026-03-14");
console.log(addDays(today, 7).toISOString());
console.log(addDays(today, 30).toISOString());
console.log(addDays(today, -5).toISOString());

שני דברים שכדאי להדגיש:

• new Date(date) מעתיק את התאריך. setDate משנה את האובייקט במקום, אז תמיד העתיקו קודם, אחרת תשנו את הערך של מי שקרא לפונקציה.
• setDate(35) בחודש של 31 ימים עובר אוטומטית לחודש הבא. אותו דבר עם setMonth(14): הוא מקדם את השנה. זה הופך את החישובים להרבה פחות כואבים ממה שהם נראים.

לכל דבר מורכב, ימי עסקים, אירועים חוזרים, משכי זמן שמודעים לחודשים, השתמשו בספרייה (date-fns, Luxon, או ה-API העתידי Temporal). לבנות לבד חישובי לוח שנה מעבר ל"הוספת כמה ימים" זה בור ללא תחתית.

בדיקת מציאות: אזורי זמן

אזורי זמן הם המקור הגדול ביותר לבאגים בתאריכים. הכללים שכדאי להפנים:

• Date שומר רגע ב-UTC. אזור הזמן מוחל רק כשקוראים ממנו חלקים או מעצבים אותו.
• אזור הזמן שבו משתמשים getHours(), getDate() וכדומה הוא אזור הזמן ה_מקומי_ של המחשב שמריץ את הקוד. שרתים ודפדפנים לעיתים קרובות לא מסכימים.
• new Date("2026-03-14") (תאריך בלבד) מפוענח כ-UTC. new Date("2026-03-14T00:00") (עם שעה, בלי אזור) מפוענח כזמן מקומי. new Date(2026, 2, 14) (חלקים) הוא מקומי.

const fromString = new Date("2026-03-14");
const fromParts = new Date(2026, 2, 14);

console.log(fromString.toISOString());
console.log(fromParts.toISOString());

// These may differ by several hours depending on your timezone.

כשצריך אזור זמן מסוים לתצוגה, העבירו timeZone ל-Intl.DateTimeFormat:

const d = new Date("2026-03-14T09:30:00Z");

const tokyo = new Intl.DateTimeFormat("en-US", {
    dateStyle: "short",
    timeStyle: "short",
    timeZone: "Asia/Tokyo",
});
const nyc = new Intl.DateTimeFormat("en-US", {
    dateStyle: "short",
    timeStyle: "short",
    timeZone: "America/New_York",
});

console.log(tokyo.format(d));
console.log(nyc.format(d));

אותו רגע, שתי תצוגות. אובייקט ה-Date עצמו לא השתנה.

דוגמה קטנה שעובדת

נחבר הכל יחד: פונקציה שמעצבת לפני כמה זמן משהו קרה:

function timeAgo(date) {
    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
    if (seconds < 60) return `${seconds}s ago`;

    const minutes = Math.floor(seconds / 60);
    if (minutes < 60) return `${minutes}m ago`;

    const hours = Math.floor(minutes / 60);
    if (hours < 24) return `${hours}h ago`;

    const days = Math.floor(hours / 24);
    return `${days}d ago`;
}

const past = new Date(Date.now() - 3 * 60 * 60 * 1000);
console.log(timeAgo(past));

const older = new Date(Date.now() - 5 * 24 * 60 * 60 * 1000);
console.log(timeAgo(older));

חותמות זמן נכנסות, מחרוזת קריאה יוצאת. זו הצורה של 90% מקוד התאריכים בעולם האמיתי: מחסרים שני רגעים, מחלקים ביחידה, מעגלים ומעצבים.

מה לקחת מכאן

• Date הוא רגע ב-UTC. אזורי זמן נכנסים לתמונה כשקוראים או מעצבים אותו.
• השתמשו ב-Date.now() לחותמות זמן, וב-new Date() לעבודה עם לוח שנה.
• השתמשו ב-toISOString() לשמירה וללוגים, וב-Intl.DateTimeFormat למשתמשים.
• השוו עם getTime() או </>. אף פעם לא ===.
• חודשים מתחילים מ-0. היזהרו ממלכודת הפענוח של מחרוזת תאריך בלבד.
• לחישובי תאריכים רציניים, השתמשו בספרייה.

הבא בתור: URL ו-query strings

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