دعونا نتعرف على كائن مدمج جديد: التاريخ. يقوم بتخزين التاريخ والوقت ويوفر طرقًا لإدارة التاريخ/الوقت.
على سبيل المثال، يمكننا استخدامه لتخزين أوقات الإنشاء/التعديل، لقياس الوقت، أو فقط لطباعة التاريخ الحالي.
لإنشاء كائن Date جديد، قم باستدعاء new Date() باستخدام إحدى الوسيطات التالية:
new Date()
بدون وسيطات – قم بإنشاء كائن Date للتاريخ والوقت الحاليين:
دع الآن = تاريخ جديد ()؛ تنبيه (الآن)؛ // يعرض التاريخ/الوقت الحالي
new Date(milliseconds)
قم بإنشاء كائن Date بوقت يساوي عدد المللي ثانية (1/1000 من الثانية) التي مرت بعد الأول من يناير عام 1970 بالتوقيت العالمي المنسق+0.
// 0 تعني 01.01.1970 UTC+0 دع Jan01_1970 = تاريخ جديد (0)؛ تنبيه (01_1970) ؛ // أضف الآن 24 ساعة، واحصل على 02.01.1970 UTC+0 دع Jan02_1970 = تاريخ جديد (24 * 3600 * 1000)؛ تنبيه (Jan02_1970)؛
يُطلق على الرقم الصحيح الذي يمثل عدد المللي ثانية التي مرت منذ بداية عام 1970 اسم الطابع الزمني .
إنه تمثيل رقمي خفيف الوزن للتاريخ. يمكننا دائمًا إنشاء تاريخ من الطابع الزمني باستخدام new Date(timestamp) وتحويل كائن Date الحالي إلى طابع زمني باستخدام طريقة date.getTime() (انظر أدناه).
التواريخ قبل 01.01.1970 لها طوابع زمنية سلبية، على سبيل المثال:
// 31 ديسمبر 1969 دع Dec31_1969 = تاريخ جديد(-24 * 3600 * 1000); تنبيه(31_ديسمبر_1969);
new Date(datestring)
إذا كانت هناك وسيطة واحدة، وكانت عبارة عن سلسلة، فسيتم تحليلها تلقائيًا. الخوارزمية هي نفسها التي يستخدمها Date.parse ، وسنغطيها لاحقًا.
Let date = new Date("2017-01-26");
تنبيه (تاريخ)؛
// لم يتم ضبط الوقت، لذا يُفترض أن يكون منتصف الليل بتوقيت جرينتش و
// يتم ضبطه وفقًا للمنطقة الزمنية التي يتم تشغيل الكود فيها
// لذلك يمكن أن تكون النتيجة
// الخميس 26 يناير 2017 الساعة 11:00:00 بتوقيت جرينتش+1100 (التوقيت الصيفي الشرقي لأستراليا)
// أو
// الأربعاء 25 يناير 2017 الساعة 16:00:00 بتوقيت جرينتش-0800 (توقيت المحيط الهادئ) new Date(year, month, date, hours, minutes, seconds, ms)
قم بإنشاء التاريخ باستخدام المكونات المحددة بالمنطقة الزمنية المحلية. فقط الحجتين الأوليين إلزامية.
يجب أن تتكون year من 4 أرقام. من أجل التوافق، يتم أيضًا قبول رقمين ويعتبران 19xx ، على سبيل المثال 98 هو نفس 1998 هنا، ولكن دائمًا ما يتم تشجيع استخدام 4 أرقام.
يبدأ حساب month بالرقم 0 (يناير)، ويصل إلى 11 (ديسمبر).
معلمة date هي في الواقع يوم من الشهر، إذا كانت غائبة، فسيتم افتراض 1 .
إذا كانت hours/minutes/seconds/ms غائبة، فيفترض أنها تساوي 0 .
على سبيل المثال:
تاريخ جديد(2011, 0, 1, 0, 0, 0, 0); // 1 يناير 2011، 00:00:00 تاريخ جديد(2011, 0, 1); // نفس الشيء، الساعات وما إلى ذلك هي 0 افتراضيًا
الدقة القصوى هي 1 مللي ثانية (1/1000 ثانية):
Let date = new Date(2011, 0, 1, 2, 3, 4, 567); تنبيه (التاريخ)؛ // 1.01.2011, 02:03:04.567
هناك طرق للوصول إلى السنة والشهر وما إلى ذلك من كائن Date :
الحصول على سنة كاملة ()
احصل على السنة (4 أرقام)
getMonth ()
احصل على الشهر من 0 إلى 11 .
الحصول على التاريخ ()
احصل على اليوم من الشهر، من 1 إلى 31، اسم الطريقة يبدو غريبًا بعض الشيء.
getHours ()، getMinutes ()، getSeconds ()، getMillithans ()
الحصول على مكونات الوقت المقابلة.
ليس getYear() ولكن getFullYear()
تطبق العديد من محركات JavaScript طريقة غير قياسية getYear() . تم إهمال هذه الطريقة. تقوم بإرجاع سنة مكونة من رقمين في بعض الأحيان. من فضلك لا تستخدمه أبدا. هناك getFullYear() لهذا العام.
بالإضافة إلى ذلك، يمكننا الحصول على يوم من أيام الأسبوع:
احصل على يوم ()
احصل على يوم الأسبوع، من 0 (الأحد) إلى 6 (السبت). اليوم الأول هو دائمًا يوم الأحد، وفي بعض البلدان ليس الأمر كذلك، ولكن لا يمكن تغييره.
تقوم جميع الطرق المذكورة أعلاه بإرجاع المكونات المتعلقة بالمنطقة الزمنية المحلية.
هناك أيضًا نظيراتها من UTC، والتي تُرجع اليوم والشهر والسنة وما إلى ذلك للمنطقة الزمنية UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). ما عليك سوى إدخال "UTC" مباشرة بعد "get" .
إذا تم تغيير المنطقة الزمنية المحلية الخاصة بك بالنسبة إلى التوقيت العالمي المنسق (UTC)، فإن الكود أدناه يعرض ساعات مختلفة:
// التاريخ الحالي اسمحوا التاريخ = تاريخ جديد ()؛ // الساعة في منطقتك الزمنية الحالية تنبيه (date.getHours())؛ // الساعة بالمنطقة الزمنية UTC+0 (توقيت لندن بدون التوقيت الصيفي) تنبيه (date.getUTCHours())؛
إلى جانب الطرق المذكورة، هناك طريقتان خاصتان لا تحتويان على متغير UTC:
احصل على الوقت ()
إرجاع الطابع الزمني للتاريخ - عدد المللي ثانية التي مرت من الأول من يناير عام 1970 بالتوقيت العالمي المنسق+0.
getTimezoneOffset()
إرجاع الفرق بين UTC والمنطقة الزمنية المحلية بالدقائق:
// إذا كنت في المنطقة الزمنية UTC-1، فستكون النتيجة 60 // إذا كنت في المنطقة الزمنية UTC+3، فستكون النتيجة -180 تنبيه (تاريخ جديد ().getTimezoneOffset ())؛
تسمح الطرق التالية بتعيين مكونات التاريخ/الوقت:
setFullYear(year, [month], [date])
setMonth(month, [date])
setDate(date)
setHours(hour, [min], [sec], [ms])
setMinutes(min, [sec], [ms])
setSeconds(sec, [ms])
setMilliseconds(ms)
setTime(milliseconds) (يحدد التاريخ بالكامل بالمللي ثانية منذ 01.01.1970 بالتوقيت العالمي المنسق)
كل واحد منهم باستثناء setTime() لديه متغير UTC، على سبيل المثال: setUTCHours() .
كما نرى، يمكن لبعض التوابع تعيين مكونات متعددة في وقت واحد، على سبيل المثال setHours . لا يتم تعديل المكونات التي لم يتم ذكرها.
على سبيل المثال:
دع اليوم = تاريخ جديد ()؛ today.setHours(0); تنبيه (اليوم)؛ // لا يزال حتى اليوم، ولكن تم تغيير الساعة إلى 0 today.setHours(0, 0, 0, 0); تنبيه (اليوم)؛ // لا يزال اليوم، الآن 00:00:00 حاد.
يعد التصحيح التلقائي ميزة مفيدة جدًا لكائنات Date . يمكننا تعيين قيم خارج النطاق، وسوف تقوم بضبط نفسها تلقائيًا.
على سبيل المثال:
اسمحوا التاريخ = تاريخ جديد (2013، 0، 32)؛ // 32 يناير 2013؟!؟؟ تنبيه (تاريخ)؛ // ... هو 1 فبراير 2013!
يتم توزيع مكونات التاريخ خارج النطاق تلقائيًا.
لنفترض أننا بحاجة إلى زيادة التاريخ "28 فبراير 2016" بمقدار يومين. قد يكون "2 مارس" أو "1 مارس" في حالة السنة الكبيسة. لا نحتاج للتفكير في الأمر. أضف يومين فقط. سيقوم كائن Date بالباقي:
اسمحوا التاريخ = تاريخ جديد (2016، 1، 28)؛ date.setDate(date.getDate() + 2); تنبيه (التاريخ)؛ // 1 مارس 2016
تُستخدم هذه الميزة غالبًا للحصول على التاريخ بعد فترة زمنية معينة. على سبيل المثال، لنحصل على تاريخ "70 ثانية بعد الآن":
اسمحوا التاريخ = تاريخ جديد ()؛ date.setSeconds(date.getSeconds() + 70); تنبيه (التاريخ)؛ // يظهر التاريخ الصحيح
يمكننا أيضًا تعيين قيم صفرية أو حتى سالبة. على سبيل المثال:
اسمحوا التاريخ = تاريخ جديد (2016، 0، 2)؛ // 2 يناير 2016 date.setDate(1); // تعيين اليوم الأول من الشهر تنبيه (التاريخ)؛ date.setDate(0); // الحد الأدنى لليوم هو 1، لذا يُفترض أن اليوم الأخير من الشهر السابق تنبيه (التاريخ)؛ // 31 ديسمبر 2015
عندما يتم تحويل كائن Date إلى رقم، يصبح الطابع الزمني هو نفسه date.getTime() :
اسمحوا التاريخ = تاريخ جديد ()؛ تنبيه(+تاريخ); // عدد المللي ثانية، مثل date.getTime()
التأثير الجانبي المهم: يمكن طرح التواريخ، والنتيجة هي الفرق بينهما في مللي ثانية.
يمكن استخدامه لقياس الوقت:
لنبدأ = تاريخ جديد ()؛ // البدء في قياس الوقت
// قم بالمهمة
لـ (دع i = 0; i < 100000; i++) {
دعني أفعل شيئًا = i * i * i;
}
Let end = new Date(); // نهاية وقت القياس
تنبيه (`استغرقت الحلقة ${end - start} مللي ثانية`)؛ إذا أردنا قياس الوقت فقط، فلن نحتاج إلى كائن Date .
هناك طريقة خاصة Date.now() تُرجع الطابع الزمني الحالي.
إنه يعادل لغويًا new Date().getTime() ، لكنه لا يُنشئ كائن Date وسيطًا. لذلك فهو أسرع ولا يشكل ضغطًا على جمع القمامة.
يتم استخدامه في الغالب للراحة أو عندما يكون الأداء مهمًا، كما هو الحال في الألعاب في JavaScript أو التطبيقات المتخصصة الأخرى.
لذلك ربما يكون هذا أفضل:
لنبدأ = Date.now(); // عدد المللي ثانية من 1 يناير 1970
// قم بالمهمة
لـ (دع i = 0; i < 100000; i++) {
دعني أفعل شيئًا = i * i * i;
}
Let end = Date.now(); // منتهي
تنبيه (`استغرقت الحلقة ${end - start} مللي ثانية`)؛ // اطرح الأرقام وليس التواريخإذا أردنا معيارًا موثوقًا للوظيفة المتعطشة لوحدة المعالجة المركزية (CPU)، فيجب أن نكون حذرين.
على سبيل المثال، دعونا نقيس دالتين تحسبان الفرق بين تاريخين: أيهما أسرع؟
غالبًا ما تسمى قياسات الأداء هذه "المعايير".
// لدينا date1 وdate2، ما هي الدالة الأسرع التي تُرجع الفرق بينهما بالمللي ثانية؟
دالة diffSubtract(date1, date2) {
تاريخ الإرجاع2 - التاريخ1؛
}
// أو
دالة diffGetTime(date1, date2) {
إرجاع date2.getTime() - date1.getTime();
} يقوم هذان الأمران بنفس الشيء تمامًا، لكن أحدهما يستخدم date.getTime() واضحًا للحصول على التاريخ بالمللي ثانية، والآخر يعتمد على تحويل التاريخ إلى رقم. نتيجتهم هي نفسها دائما.
إذن، أيهما أسرع؟
قد تكون الفكرة الأولى هي تشغيلها عدة مرات متتالية وقياس فارق التوقيت. في حالتنا، الوظائف بسيطة جدًا، لذا يتعين علينا القيام بذلك 100000 مرة على الأقل.
دعونا نقيس:
دالة diffSubtract(date1, date2) {
تاريخ الإرجاع2 - التاريخ1؛
}
دالة diffGetTime(date1, date2) {
إرجاع date2.getTime() - date1.getTime();
}
وظيفة مقاعد البدلاء (و) {
دع date1 = تاريخ جديد (0)؛
دع date2 = تاريخ جديد () ؛
لنبدأ = Date.now();
for (let i = 0; i < 100000; i++) f(date1, date2);
إرجاع التاريخ. الآن () - ابدأ؛
}
تنبيه ("وقت diffSubtract:" + bench(diffSubtract) + 'ms' );
تنبيه ("وقت diffGetTime:" + bench(diffGetTime) + 'ms' ); رائع! يعد استخدام getTime() أسرع بكثير! وذلك لأنه لا يوجد تحويل للنوع، ومن الأسهل على المحركات تحسينها.
حسنا، لدينا شيء. لكن هذا ليس معيارًا جيدًا حتى الآن.
تخيل أنه في وقت تشغيل bench(diffSubtract) كانت تفعل شيئًا بالتوازي، وكانت تستهلك الموارد. وبحلول وقت تشغيل bench(diffGetTime) يكون هذا العمل قد انتهى.
سيناريو حقيقي جدًا لنظام تشغيل حديث متعدد العمليات.
ونتيجة لذلك، سيكون المعيار الأول موارد وحدة المعالجة المركزية أقل من الثاني. وقد يؤدي ذلك إلى نتائج خاطئة.
للحصول على قياس أداء أكثر موثوقية، يجب إعادة تشغيل حزمة المعايير بأكملها عدة مرات.
على سبيل المثال، مثل هذا:
دالة diffSubtract(date1, date2) {
تاريخ الإرجاع2 - التاريخ1؛
}
دالة diffGetTime(date1, date2) {
إرجاع date2.getTime() - date1.getTime();
}
وظيفة مقاعد البدلاء (و) {
دع date1 = تاريخ جديد (0)؛
دع date2 = تاريخ جديد () ؛
لنبدأ = Date.now();
for (let i = 0; i < 100000; i++) f(date1, date2);
إرجاع التاريخ. الآن () - ابدأ؛
}
دع الوقت 1 = 0؛
دع الوقت 2 = 0؛
// تشغيل مقاعد البدلاء (diffSubtract) والمقعد (diffGetTime) كل 10 مرات بالتناوب
لـ (دع i = 0; i < 10; i++) {
time1 += bench(diffSubtract);
time2 += bench(diffGetTime);
}
تنبيه ("إجمالي الوقت لـ diffSubtract:" + time1)؛
تنبيه ("إجمالي الوقت لـ diffGetTime:" + time2)؛تبدأ محركات JavaScript الحديثة في تطبيق التحسينات المتقدمة فقط على "التعليمات البرمجية الساخنة" التي يتم تنفيذها عدة مرات (لا داعي لتحسين الأشياء التي نادرًا ما يتم تنفيذها). لذلك، في المثال أعلاه، لم يتم تحسين عمليات التنفيذ الأولى بشكل جيد. قد نرغب في إضافة عملية تسخين:
// تمت إضافته لـ "التسخين" قبل الحلقة الرئيسية
مقاعد البدلاء(diffSubtract);
bench(diffGetTime);
// الآن المعيار
لـ (دع i = 0; i < 10; i++) {
time1 += bench(diffSubtract);
time2 += bench(diffGetTime);
}كن حذرًا عند إجراء القياسات الدقيقة
تقوم محركات JavaScript الحديثة بإجراء العديد من التحسينات. قد يقومون بتعديل نتائج "الاختبارات المصطنعة" مقارنة بـ "الاستخدام العادي"، خاصة عندما نقيس شيئًا صغيرًا جدًا، مثل كيفية عمل المشغل، أو وظيفة مدمجة. لذا، إذا كنت تريد حقًا فهم الأداء، فيرجى دراسة كيفية عمل محرك JavaScript. ومن ثم ربما لن تحتاج إلى معايير دقيقة على الإطلاق.
يمكن العثور على مجموعة المقالات الرائعة حول V8 على https://mrale.ph.
يمكن للطريقة Date.parse(str) قراءة تاريخ من سلسلة.
يجب أن يكون تنسيق السلسلة: YYYY-MM-DDTHH:mm:ss.sssZ ، حيث:
YYYY-MM-DD – هو التاريخ: سنة-شهر-يوم.
يتم استخدام الحرف "T" كمحدد.
HH:mm:ss.sss – هو الوقت: الساعات والدقائق والثواني والميلي ثانية.
يشير الجزء 'Z' الاختياري إلى المنطقة الزمنية بالتنسيق +-hh:mm . حرف واحد Z يعني UTC+0.
من الممكن أيضًا استخدام متغيرات أقصر، مثل YYYY-MM-DD أو YYYY-MM أو حتى YYYY .
يقوم استدعاء Date.parse(str) بتوزيع السلسلة بالتنسيق المحدد وإرجاع الطابع الزمني (عدد المللي ثانية من 1 يناير 1970 UTC+0). إذا كان التنسيق غير صالح، فسيتم إرجاع NaN .
على سبيل المثال:
Let ms = Date.parse('2012-01-26T13:51:50.417-07:00');
تنبيه (مللي ثانية)؛ // 1327611110417 (الطابع الزمني) يمكننا على الفور إنشاء كائن new Date من الطابع الزمني:
Let date = new Date( Date.parse('2012-01-26T13:51:50.417-07:00'));
تنبيه (تاريخ)؛ يتم تمثيل التاريخ والوقت في JavaScript بكائن التاريخ. لا يمكننا إنشاء "التاريخ الوحيد" أو "الوقت الوحيد": تحمل كائنات Date دائمًا كليهما.
يتم حساب الأشهر من الصفر (نعم، شهر يناير شهر صفر).
يتم أيضًا حساب أيام الأسبوع في getDay() من الصفر (أي يوم الأحد).
يقوم Date بتصحيح نفسه تلقائيًا عند تعيين مكونات خارج النطاق. جيد لإضافة/طرح أيام/أشهر/ساعات.
يمكن طرح التواريخ، مع إعطاء الفرق بالمللي ثانية. وذلك لأن Date يصبح الطابع الزمني عند تحويله إلى رقم.
استخدم Date.now() للحصول على الطابع الزمني الحالي بسرعة.
لاحظ أنه على عكس العديد من الأنظمة الأخرى، فإن الطوابع الزمنية في JavaScript تكون بالمللي ثانية، وليس بالثواني.
في بعض الأحيان نحتاج إلى قياسات زمنية أكثر دقة. جافا سكريبت نفسها لا تملك طريقة لقياس الوقت بالميكروثانية (جزء من المليون من الثانية)، ولكن معظم البيئات توفرها. على سبيل المثال، يحتوي المتصفح على Performance.now() الذي يعطي عدد المللي ثانية من بداية تحميل الصفحة بدقة ميكروثانية (3 أرقام بعد النقطة):
تنبيه("بدأ التحميل منذ ${performance.now()}ms`);
// شيء مثل: "بدأ التحميل منذ 34731.26000000001 مللي ثانية"
// .26 ميكروثانية (260 ميكروثانية)
// أكثر من 3 أرقام بعد العلامة العشرية هي أخطاء في الدقة، والأرقام الثلاثة الأولى فقط هي الصحيحة يحتوي Node.js على وحدة microtime وطرق أخرى. من الناحية الفنية، يسمح أي جهاز وبيئة تقريبًا بالحصول على مزيد من الدقة، لكن هذا ليس موجودًا في Date .
الأهمية: 5
قم بإنشاء كائن Date للتاريخ: 20 فبراير 2012، الساعة 3:12 صباحًا. المنطقة الزمنية محلية.
أظهره باستخدام alert .
يستخدم مُنشئ new Date المنطقة الزمنية المحلية. لذا فإن الشيء المهم الوحيد الذي يجب تذكره هو أن الأشهر تبدأ من الصفر.
إذن فبراير لديه الرقم 1.
فيما يلي مثال يحتوي على أرقام كمكونات للتاريخ:
// تاريخ جديد (السنة، الشهر، التاريخ، الساعة، الدقيقة، الثانية، ميلي ثانية) دع d1 = تاريخ جديد(2012, 1, 20, 3, 12); تنبيه (د1)؛
يمكننا أيضًا إنشاء تاريخ من سلسلة، مثل هذا:
// تاريخ جديد (سلسلة البيانات)
Let d2 = new Date("2012-02-20T03:12");
تنبيه (د2)؛الأهمية: 5
اكتب دالة getWeekDay(date) لإظهار أيام الأسبوع بتنسيق قصير: 'MO'، 'TU'، 'WE'، 'TH'، 'FR'، 'SA'، 'SU'.
على سبيل المثال:
اسمحوا التاريخ = تاريخ جديد (2012، 0، 3)؛ // 3 يناير 2012 تنبيه( getWeekDay(date)); // يجب إخراج "TU"
افتح صندوق الرمل مع الاختبارات.
تقوم الطريقة date.getDay() بإرجاع عدد أيام الأسبوع، بدءًا من يوم الأحد.
لنقم بإنشاء مصفوفة من أيام الأسبوع، حتى نتمكن من الحصول على اسم اليوم المناسب من خلال رقمه:
الدالة getWeekDay(التاريخ) {
دع الأيام = ['SU'، 'MO'، 'TU'، 'WE'، 'TH'، 'FR'، 'SA']؛
أيام العودة[date.getDay()];
}
اسمحوا التاريخ = تاريخ جديد (2014، 0، 3)؛ // 3 يناير 2014
تنبيه( getWeekDay(date)); // الابافتح الحل بالاختبارات في وضع الحماية.
الأهمية: 5
الدول الأوروبية لديها أيام الأسبوع تبدأ يوم الاثنين (رقم 1)، ثم الثلاثاء (رقم 2) وحتى الأحد (رقم 7). اكتب دالة getLocalDay(date) التي تُرجع يوم الأسبوع "الأوروبي" date .
اسمحوا التاريخ = تاريخ جديد (2012، 0، 3)؛ // 3 يناير 2012 تنبيه( getLocalDay(date)); // الثلاثاء، يجب أن يظهر 2
افتح صندوق الرمل مع الاختبارات.
الدالة getLocalDay(التاريخ) {
دع اليوم = date.getDay();
إذا (يوم == 0) {// أيام الأسبوع 0 (الأحد) تساوي 7 باللغة الأوروبية
يوم = 7؛
}
يوم العودة؛
}افتح الحل بالاختبارات في وضع الحماية.
الأهمية: 4
قم بإنشاء دالة getDateAgo(date, days) لإرجاع اليوم من الشهر الذي مضى منذ days من date .
على سبيل المثال، إذا كان اليوم هو العشرين، فيجب أن يكون getDateAgo(new Date(), 1) هو التاسع عشر و getDateAgo(new Date(), 2) يجب أن يكون الثامن عشر.
يجب أن تعمل بشكل موثوق لمدة days=365 أو أكثر:
اسمحوا التاريخ = تاريخ جديد (2015، 0، 2)؛ تنبيه( getDateAgo(date, 1) ); // 1، (1 يناير 2015) تنبيه( getDateAgo(date, 2)); // 31، (31 ديسمبر 2014) تنبيه( getDateAgo(date, 365)); // 2، (2 يناير 2014)
ملاحظة: يجب ألا تقوم الوظيفة بتعديل date المحدد.
افتح صندوق الرمل مع الاختبارات.
الفكرة بسيطة: لطرح عدد معين من الأيام من date :
الدالة getDateAgo(التاريخ، الأيام) {
date.setDate(date.getDate() - أيام);
تاريخ الإرجاع.getDate();
} …ولكن يجب ألا تغير الوظيفة date . وهذا أمر مهم، لأن الكود الخارجي الذي يعطينا التاريخ لا يتوقع أن يتغير.
لتنفيذه، دعونا نستنسخ التاريخ، مثل هذا:
الدالة getDateAgo(التاريخ، الأيام) {
Let dateCopy = new Date(date);
dateCopy.setDate(date.getDate() - أيام);
تاريخ الإرجاعCopy.getDate();
}
اسمحوا التاريخ = تاريخ جديد (2015، 0، 2)؛
تنبيه( getDateAgo(date, 1) ); // 1، (1 يناير 2015)
تنبيه( getDateAgo(date, 2)); // 31، (31 ديسمبر 2014)
تنبيه( getDateAgo(date, 365)); // 2، (2 يناير 2014)افتح الحل بالاختبارات في وضع الحماية.
الأهمية: 5
اكتب دالة getLastDayOfMonth(year, month) التي تُرجع اليوم الأخير من الشهر. في بعض الأحيان يكون يوم 30 أو 31 أو حتى 28/29 لشهر فبراير.
حدود:
year - السنة المكونة من أربعة أرقام، على سبيل المثال 2012.
month - شهر، من 0 إلى 11.
على سبيل المثال، getLastDayOfMonth(2012, 1) = 29 (السنة الكبيسة، فبراير).
افتح صندوق الرمل مع الاختبارات.
لنقم بإنشاء تاريخ باستخدام الشهر التالي، ولكن قم بتمرير الصفر باعتباره اليوم:
الدالة getLastDayOfMonth(السنة، الشهر) {
اسمحوا التاريخ = تاريخ جديد (السنة، الشهر + 1، 0)؛
تاريخ الإرجاع.getDate();
}
تنبيه (getLastDayOfMonth(2012, 0) ); // 31
تنبيه (getLastDayOfMonth(2012, 1) ); // 29
تنبيه (getLastDayOfMonth(2013, 1) ); // 28عادةً، تبدأ التواريخ من 1، ولكن من الناحية الفنية يمكننا تمرير أي رقم، وسيقوم التاريخ بتعديل نفسه تلقائيًا. لذلك عندما نتجاوز 0، فهذا يعني "يوم واحد قبل اليوم الأول من الشهر"، وبعبارة أخرى: "آخر يوم من الشهر السابق".
افتح الحل بالاختبارات في وضع الحماية.
الأهمية: 5
اكتب دالة getSecondsToday() تُرجع عدد الثواني من بداية اليوم.
على سبيل المثال، إذا كانت الساعة الآن 10:00 am ، ولم يكن هناك تغيير في التوقيت الصيفي، فحينئذٍ:
getSecondsToday() == 36000 // (3600 * 10)
يجب أن تعمل الوظيفة في أي يوم. وهذا يعني أنه لا ينبغي أن يكون لها قيمة مرمزة "اليوم".
للحصول على عدد الثواني، يمكننا إنشاء تاريخ باستخدام اليوم والوقت الحاليين 00:00:00، ثم طرحه من "الآن".
الفرق هو عدد المللي ثانية من بداية اليوم، والتي يجب أن نقسمها على 1000 لنحصل على الثواني:
الدالة getSecondsToday() {
دع الآن = تاريخ جديد ()؛
// إنشاء كائن باستخدام اليوم/الشهر/السنة الحالية
Let today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
دع الفرق = الآن - اليوم؛ // فرق مللي ثانية
إرجاع Math.round(diff / 1000); // اصنع ثواني
}
تنبيه (getSecondsToday ())؛الحل البديل هو الحصول على الساعات/الدقائق/الثواني وتحويلها إلى ثواني:
الدالة getSecondsToday() {
دع د = تاريخ جديد ()؛
إرجاع d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}
تنبيه (getSecondsToday ())؛الأهمية: 5
قم بإنشاء دالة getSecondsToTomorrow() التي تُرجع عدد الثواني حتى الغد.
على سبيل المثال، إذا كان الآن هو 23:00 ، فحينئذٍ:
getSecondsToTomorrow() == 3600
ملحوظة: يجب أن تعمل الوظيفة في أي يوم، حيث أن كلمة "اليوم" ليست مشفرة.
للحصول على عدد المللي ثانية حتى الغد، يمكننا من "غدًا 00:00:00" طرح التاريخ الحالي.
أولاً، نقوم بإنشاء كلمة "الغد"، ثم نقوم بذلك:
الدالة getSecondsToTomorrow() {
دع الآن = تاريخ جديد ()؛
// تاريخ الغد
دع الغد = تاريخ جديد(now.getFullYear(), now.getMonth(), now.getDate()+1);
دع الفرق = غدا - الآن؛ // الفرق في مللي ثانية
إرجاع Math.round(diff / 1000); // تحويل إلى ثواني
}الحل البديل:
الدالة getSecondsToTomorrow() {
دع الآن = تاريخ جديد ()؛
دع ساعة = now.getHours();
دع الدقائق = now.getMinutes();
دع الثواني = now.getSeconds();
دع TotalSecondsToday = (ساعة * 60 + دقيقة) * 60 + ثانية؛
دع TotalSecondsInADay = 86400؛
إرجاع TotalSecondsInADay - TotalSecondsToday؛
}يرجى ملاحظة أن العديد من البلدان لديها التوقيت الصيفي (DST)، لذلك قد تكون هناك أيام بها 23 أو 25 ساعة. قد نرغب في التعامل مع مثل هذه الأيام بشكل منفصل.
الأهمية: 4
اكتب دالة formatDate(date) التي يجب أن تقوم بتنسيق date كما يلي:
إذا مر منذ date أقل من ثانية واحدة، فسيتم "right now" .
بخلاف ذلك، إذا مر date منذ أقل من دقيقة واحدة، فسيتم "n sec. ago" .
خلاف ذلك، إذا كان أقل من ساعة، ثم "m min. ago" .
بخلاف ذلك، التاريخ الكامل بالتنسيق "DD.MM.YY HH:mm" . وهذا هو: "day.month.year hours:minutes" ، كل ذلك بتنسيق مكون من رقمين، على سبيل المثال 31.12.16 10:00 .
على سبيل المثال:
تنبيه(formatDate(new Date(new Date - 1))); // "الآن" تنبيه(formatDate(new Date(new Date - 30 * 1000))); // "منذ 30 ثانية" تنبيه(formatDate(new Date(new Date - 5 * 60 * 1000))); // "منذ 5 دقائق" // تاريخ الأمس مثل 31.12.16 20:00 تنبيه(formatDate(new Date(new Date - 86400 * 1000)));
افتح صندوق الرمل مع الاختبارات.
للحصول على الوقت من date حتى الآن - دعونا نطرح التواريخ.
تنسيق الوظيفةالتاريخ (التاريخ) {
Let diff = new Date() - date; // الفرق بالمللي ثانية
إذا (فرق <1000) {// أقل من ثانية واحدة
العودة "الآن" ؛
}
Let sec = Math.floor(diff / 1000); // تحويل الفرق إلى ثواني
إذا (ثانية <60) {
العودة ثانية + ' ثانية. منذ'؛
}
دع الحد الأدنى = Math.floor(diff / 60000); // تحويل الفرق إلى دقائق
إذا (دقيقة <60) {
العودة دقيقة + 'دقيقة. منذ'؛
}
// تنسيق التاريخ
// أضف الأصفار البادئة إلى يوم/شهر/ساعة/دقيقة مكونة من رقم واحد
دع د = التاريخ؛
د = [
'0' + د.getDate()،
'0' + (d.getMonth() + 1)،
'' + d.getFullYear ()،
'0' + د.getHours()،
'0' + د.getMinutes()
.map(component => Component.slice(-2)); // خذ آخر رقمين من كل مكون
// انضم إلى المكونات حتى الآن
إرجاع d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}
تنبيه(formatDate(new Date(new Date - 1))); // "الآن"
تنبيه(formatDate(new Date(new Date - 30 * 1000))); // "منذ 30 ثانية"
تنبيه(formatDate(new Date(new Date - 5 * 60 * 1000))); // "منذ 5 دقائق"
// تاريخ الأمس مثل 31.12.2016 الساعة 20:00
تنبيه(formatDate(new Date(new Date - 86400 * 1000)));الحل البديل:
تنسيق الوظيفةالتاريخ (التاريخ) {
دع dayOfMonth = date.getDate();
دع الشهر = date.getMonth() + 1;
دع العام = date.getFullYear();
دع ساعة = date.getHours();
دع الدقائق = date.getMinutes();
Let diffMs = new Date() - date;
دع diffSec = Math.round(diffMs / 1000);
دع diffMin = diffSec / 60;
دع diffHour = diffMin / 60;
// التنسيق
year = year.toString().slice(-2);
الشهر = الشهر < 10 ؟ '0' + شهر: شهر؛
dayOfMonth = dayOfMonth < 10 ؟ '0' + dayOfMonth : dayOfMonth;
الساعة = الساعة < 10 ؟ '0' + ساعة: ساعة؛
الدقائق = الدقائق < 10؟ '0' + دقائق: دقائق؛
إذا (فرق <1) {
العودة "الآن" ؛
} وإلا إذا (diffMin < 1) {
إرجاع `${diffSec} ثانية. منذ
} وإلا إذا (diffHour < 1) {
إرجاع `${diffMin} دقيقة. منذ
} آخر {
إرجاع `${dayOfMonth}.${month}.${year} ${hour}:${Minutes}`
}
}افتح الحل بالاختبارات في وضع الحماية.