How to translate this line of code to human language? - javascript

Hi I'm trying to change this calendar's starting weekday from Sunday to Monday.
But I don't understand what's going on in the var k = ... line. What is this line of code trying to say in human language?
https://codepen.io/xmark/pen/WQaXdv?editors=1010
// June 2018
var k = lastDay_of_LastMonth - firstDay_of_Month+1;
27
//_____________________________________________________________________
// TEST
var lastDay_of_LastMonth = new Date(2018, 5, 0); // May 31st 2018
document.write('Today is: ' + lastDay_of_LastMonth.toLocaleString());
// Today is: 5/31/2018, 12:00:00 AM
var firstDay_of_Month = new Date(2018, 5, 1); // June 1st 2018
firstDay_of_Month."getDay()";
5
// June 2018
var k = lastDay_of_LastMonth - firstDay_of_Month+1;
lastDay_of_LastMonth.setDate(lastDay_of_LastMonth.getDate() - 6);
document.write('<br>X days ago was: ' + lastDay_of_LastMonth.toLocaleString());
// X days ago was: 5/25/2018, 12:00:00 AM
//_____________________________________________________________________
// June 2018
27 = 31 - 5+1;
I see from this thread that this code is calculating (Date - Days), counting days backwards. But I can't understand what it is doing in human language for the calendar code. Shouldn't the math 31-(5+1) = 25 meaning it's going 6 days back in time why do I get the value 27 back?
Subtract days from a date in JavaScript

From the codepen that you attached, the developer is using k to get the days outside of the current month that should come up in the calendar (i.e. if our month is starting on Tuesday then Sunday & Monday are in the previous month, but we need to get the "day of the month numbers" of these days), now they are using k in two occasions:
1: to get the days from the previous month var k = lastDayOfLastMonth - firstDayOfMonth+1;
2: to get the days from the next month:
else if ( i == lastDateOfMonth ) {
var k=1;
for(dow; dow < 6; dow++) {
html += '<td class="not-current">' + k + '</td>';
k++;
}
}
In the first occasion, they are calculating the difference between the last day of the last month and the first day of this month, the +1 here is because you're working with indexes.
In the second occasion, it's safe to say that every month has 1-6, so they loop up to 6 to fill up the last week in the calendar.

Order of operations in this language gives equal precedence to the addition and subtraction operators.
In other words, it uses PEMDAS.
So it'll do 31-5: 26
Then 26 + 1: 27

Related

JS Check Date is Within 6 Months of Today

I am using Bootstrap Datepicker, and based on the date selection I need to display a message to the user.
I have never used the Date Constructor before so it's very new to me.
What I need to do is the following;
allow user to select a date
display a message / alert based of the logic below
If their selected date is within the last 6 months of today, they quality for discount.
If their selected date doesn't fall within the last 6 months of today, they don't.
Although it's not working correctly have created a fiddle here.
Any help would be appreciated. Code also below;
HTML
<input type="text" class="form-control" id="datepicker" placeholder="Year Graduated" value="" data-date-format="dd/mm/yyyy">
<p id="rate"></p>
JS
function compareDate() {
// get date from datepicker
var dateEntered = $("#datepicker").datepicker("getDate");
dateEntered = new Date(dateEntered).getTime();
//alert("date entered: " + dateEntered);
// set todays date
var now = new Date();
// set date six months before today
var sixMonthBeforeNow = new Date(now).setTime(now.getTime() - 3 * 28 * 24 * 60 * 60);
//alert("six months before: " + sixMonthBeforeNow);
// if date entered is within six months from today
if (dateEntered > sixMonthBeforeNow) {
alert("You qualify for the discount rate.");
$("#rate").html('discount rate');
}
// if date entered is over six months from today
if (dateEntered < sixMonthBeforeNow) {
alert("you graduated more than six months ago");
$("#rate").html('no discount');
}
}
$("#datepicker").datepicker({
weekStart: 1,
daysOfWeekHighlighted: "6,0",
autoclose: true,
todayHighlight: true
});
$("#datepicker").change(function() {
compareDate();
});
Note: I'd prefer not to use any other 3rd party JS library / plugin.
Just change your sixMonthBeforeNow with the below code, that should work.
var sixMonthBeforeNow = new Date(now).setMonth(now.getMonth() - 6);
You need to be careful with date arithmetic because it's not symmetric due to the uneven length of months, so you need rules to deal with it. E.g. what date is exactly 6 months before 31 August?
Before answering, consider:
28 February plus 6 months is 28 August
1 March plus 6 months is 1 September.
So what date is 6 months before 29, 30 and 31 August? Is it 28 February or 1 March?
Similar issues arise for any last day of a month where the month 6 months previous doesn't have 31 days. Should the limit be the 30th of the month or the 1st of the following month? When you've answered that question, then you can devise an algorithm to deliver the right answer and then the code to implement it.
If you want such cases to set the date to the end of the month 6 months before, then you can check the month resulting from subtracting 6 months and if it's not 6, set it to the last day of the previous month, e.g.
function sixMonthsPrior(date) {
// Copy date so don't affect original
var d = new Date(date);
// Get the current month number
var m = d.getMonth();
// Subtract 6 months
d.setMonth(d.getMonth() - 6);
// If the new month number isn't m - 6, set to last day of previous month
// Allow for cases where m < 6
var diff = (m + 12 - d.getMonth()) % 12;
if (diff < 6) d.setDate(0)
return d;
}
// Helper to format the date
function formatDate(d) {
return d.toLocaleString(undefined, {day:'2-digit', month:'short', year:'numeric'});
}
// Tests
[ new Date(2018, 7,31), // 31 Aug 2018
new Date(2018, 8, 1), // 1 Sep 2018
new Date(2018,11,31), // 31 Dec 2018
new Date(2019, 2,31) // 31 Mar 2019
].forEach( d => console.log(formatDate(d) + ' => ' + formatDate(sixMonthsPrior(d))));
If that is't the logic you wish to apply, you need to say what is.
PS. You can also implement the above logic by just comparing the start and end dates (day number). If they're different, it must have rolled over a month so set to 0.

How to reliably implement 'next' / 'previous' month

This has been asked (badly) before - I don't think the answer in that post really addressed the issue, and then it went stale. I'm going to attempt to ask it again with a clearer demonstration of the issue.
The implementation of Javascript Date.setMonth() appears not to follow the principle of least surprise. Try this in a browser console:
d = new Date('2017-08-31') // Set to last day of August
d.getMonth() // 7 - months are zero-based
d.setMonth(8) // Try to set the month to 8 (September)
d.getMonth() // 9 - October. WTF Javascript?
Similarly:
d = new Date('2017-10-31')
d.getMonth() // 9
d.setMonth(8)
d.getMonth() // 9 (still?)
Firefox on Linux appears even worse - sometimes returning a date in October, and a result from getMonth() which doesn't match that month!
My question (and I think that of the OP from that linked question) is how to consistently implement a 'next' / 'prev' month function in, e.g. a datepicker? Is there a well known way of doing this which doesn't surprise the user by, for example, skipping September when they start on August 31st and click 'next'? Going from January 31st is even more unpredictable currently - you will end up on either March 2nd or March 3rd, depending on whether it's a leap year or not!
My personal view is that the least surprise would be to move to the last day of the next / previous month. But that requires the setMonth() implementation to care about the number of days in the months in question, not just add / subtract a fixed duration. According to this thread, the moment.js approach is to add / subtract the number of milliseconds in 30 days, which suggests that library would be prone to the same inconsistencies.
It's all simple and logic. Lets take your example and go see what id does.
So the first line
d = new Date('2017-08-31') // Set to last day of August
console.log(d); // "2017-08-31T00:00:00.000Z"
console.log(d.getMonth()); // 7 - months are zero-based
So all good so far. Next step: Your comment says it: // Try to set the month to 8 (September) So it's not done with trying. You either set it to september or you don't. In your example you set it to October. Explanation further down.
d = new Date('2017-08-31') // Set to last day of August
console.log(d); // "2017-08-31T00:00:00.000Z"
console.log(d.getMonth()); // 7 - months are zero-based
d.setMonth(8) // Try to set the month to 8 (September)
console.log(d); // but now I see I was wrong it is (October)
So the good question is WHY? From MDN
Note: Where Date is called as a constructor with more than one
argument, if values are greater than their logical range (e.g. 13 is
provided as the month value or 70 for the minute value), the adjacent
value will be adjusted. E.g. new Date(2013, 13, 1) is equivalent to
new Date(2014, 1, 1), both create a date for 2014-02-01 (note that the
month is 0-based). Similarly for other values: new Date(2013, 2, 1, 0,
70) is equivalent to new Date(2013, 2, 1, 1, 10) which both create a
date for 2013-03-01T01:10:00.
So that sayd September has only 30 Days but the Date Object has 31. This is why it gives you October and not September.
The simplest will be to take the date you have and set it to first day of month. Something like so:
var d = new Date('2017-08-31') // Set to last day of August
// simplest fix take the date you have and set it to first day of month
d = new Date(d.getFullYear(), d.getMonth(), 1);
console.log(d); // "2017-08-31T00:00:00.000Z"
console.log(d.getMonth()); // 7 - months are zero-based
d.setMonth(8) // Set the month to 8 (September)
console.log(d.getMonth()); // get 8 it is (September)
If setMonth is used when adding and subtracting months, then if the date of the start month doesn't exist in the end month, the extra days cause the date to "roll over" to the next month, so 31 March minus 1 month gives 2 or 3 March.
A simple algorithm is to test the start date and end date and if they differ, set the end date to 0 so it goes to the last day of the previous month.
One issue with this is that subtracting 1 month twice may not give the same result as subtracting 2 months once. 31 March 2017 minus one month gives 28 Feb, minus another month gives 28 Jan. Subtract 2 months from 31 March and you get 31 Jan.
C'est la vie.
function addMonths(date, num) {
var d = date.getDate();
date.setMonth(date.getMonth() + num);
if (date.getDate() != d) date.setDate(0);
return date;
}
// Subtract one month from 31 March
var a = new Date(2017,2,31);
console.log(addMonths(a, -1).toString()); // 28 Feb
// Add one month to 31 January
var b = new Date(2017,0,31);
console.log(addMonths(b, 1).toString()); // 28 Feb
// 29 Feb plus 12 months
var c = new Date(2016,1,29)
console.log(addMonths(c, 12).toString()); // 28 Feb
// 29 Feb minus 12 months
var c = new Date(2016,1,29)
console.log(addMonths(c, -12).toString()); // 28 Feb
// 31 Jul minus 1 month
var d = new Date(2016,6,31)
console.log(addMonths(d, -1).toString()); // 30 Jun
Since getMonth() returns an integer number, you can simply implement a generator over the date object, that sets the month + 1 or - 1 so long as your not at month 11 or month 0 respectively.
function nextMonth(dateObj) {
var month = dateObj.getMonth();
if(month != 11) dateObj.setMonth(month + 1);
return dateObj;
}
function prevMonth(dateObj) {
var month = dateObj.getMonth();
if(month != 0) dateObj.setMonth(month - 1);
return dateObj;
}
If you want to match the days in the previous month you can use an object lookup table.
Now, for your last day of the month problem:
function getLastDayofMonth(month) {
var lookUp = {
0:31,
1:28,
2:30,
3:31
};
return lookUp[month];
}
//and then a revised version
function nextMonth(dateObj) {
var month = dateObj.getMonth();
var day = dateObj.getDate();
if(month != 12) dateObj.setMonth(month + 1);
if(getLastDayofMonth(month)<day)dateObj.setDate(getLastDayofMonth(month));
return dateObj;
}
This should work for incrementing the month, you can use a similar strategy to decrement.
// isLeapYear :: Number -> Boolean
const isLeapYear = ((err) => {
return yr => {
// check for the special years, see https://www.wwu.edu/skywise/leapyear.html
if (yr === 0) {
throw err;
}
// after 8 AD, follows 'normal' leap year rules
let passed = true;
// not technically true as there were 13 LY BCE, but hey.
if (yr === 4 || yr < 0 || (yr % 4)) {
passed = false;
} else {
if (yr % 400) {
if (!(yr % 100)) {
passed = false;
}
}
}
return passed;
};
})(new Error('Year zero does not exist, refers to 1 BCE'));
const daysInMonth = [
31,
28,
31,
30,
31,
30,
31,
31,
30,
31,
30,
31
];
// isLastDay :: Number, Number -> Boolean
const isLastDay = (d, m, y) => {
let dm = isLeapYear(y) && m === 1 ? 29 : daysInMonth(m);
return dm === d;
};
// getLastDay :: Number, Number -> Number
const getLastDay = (m, y) => isLeapYear(y) && m === 1 ? 29 : daysInMonth[m];
// incMonth :: Date -> Date
const incMonth = d => {
let dd = new Date(d.getTime());
let day = dd.getDate();
let month = dd.getMonth() + 1;
dd.setDate(5); // should avoid edge-case shenanigans
dd.setMonth(month);
let year = dd.getFullYear();
if (isLastDay(day, month, year)) day = getLastDay(month, year);
dd.setDate(day);
return dd;
};
This was the solution I came up with, which seems small and reliable as far as I can tell. It doesn't need any extra data structures, and relies on setDate(0) to select the last day of the month in the edge cases. Otherwise it leaves the date alone, which is the behaviour I wanted. It also handles wrapping round from one year to the next (in either direction):
function reallySetMonth(dateObj, targetMonth) {
const newDate = new Date(dateObj.setMonth(targetMonth))
if (newDate.getMonth() !== ((targetMonth % 12) + 12) % 12) { // Get the target month modulo 12 (see https://stackoverflow.com/a/4467559/1454454 for details about modulo in Javascript)
newDate.setDate(0)
}
return newDate
}
Note I've only tested this with targetMonth being either one higher or lower than the current month, since I'm using it with 'next' / 'back' buttons. It would need testing further user with arbitrary months.

How to get the difference of two dates in mm-dd-hh format in Javascript

I can get the difference between two dates using moment.js or plain js.
in moment.js
var a = moment(timestamp1);
var b = moment(timestamp2);
var month =a.diff(b, 'month');
var day =a.diff(b, 'day') - month;
var year =a.diff(b, 'hours');
month returns month , days return difference in days . But I want the answer in
MM-DD-hh format for example 2 months 12 days 5 hours . I can not convert the day directly cause there is other issues like leap year . Is there any other way then going all out and calculating everything ? I am doing this in angular js if that is of any help
Getting the precise difference between two dates is not simple as years, months, and days have different lengths. Also, adding is not necessarily symmetric with subtraction, e.g. is 30 April plus one month is 30 May, but is 31 May plus one month 30 June or 1 July? Similar with 29 Feb plus or minus 1 year.
The following tries to deal with those issues, so that if adding a month rolls over an extra month, the date is returned to the last day of the previous month. Hopefully the comments are sufficient, if not, ask for clarification.
The dateDiff function returns an array of the values for years, months, days, etc. To get MM-DD-hh, just get that and format it any way you want. I've included a small formatting function that just prints out the non–zero components.
// Simple calculation of days between two dates based on time value
function getDaysDiff(start, end) {
return ((parseStringUTC(end) - parseStringUTC(start))/8.64e7).toFixed(2);
}
// Expects input in ISO8601 format: yyyy-mm-ddThh:mm:ss.sssZ
// Always expects UTC
function parseStringUTC(s) {
s = s.split(/\D/);
s[6] = s[6]? ('0.'+ s[6]) * 1000 : 0;
return new Date(Date.UTC(s[0],--s[1],s[2],s[3]||0,s[4]||0,s[5]||0,s[6]||0));
}
/* Get the difference between two dates in years, months, days,
** hours, minutes and seconds.
**
** Difference is values to add to earlier date to reach later date.
**
** Does not consider daylight saving changes so may be incorrect by offset
** difference over daylight saving boundaries, so use UTC values (pass
** values as date.toISOString() or format like ISO 8601 UTC)
**
** #param {string} d0 - earlier date in format y-m-d h:m:s, can also be
** yyyy-mm-ddThh:mm:ssZ, the timezone offset is ignored
** the string is not validated
** #param {string} d1 - later date in same format as above. If d1 is earlier
** than d0, results are unreliable.
** #returns {Array} values for years, months, days, hours, minutes and
** seconds (milliseconds as decimal part of seconds)
*/
function dateDiff(d0,d1) {
var s = d0.split(/\D/);
var e = d1.split(/\D/);
// Calculate initial values for components,
// Time component is optional, missing values treated as zero
var ms = (e[6]||0) - (s[6]||0);
var sec = (e[5]||0) - (s[5]||0);
var min = (e[4]||0) - (s[4]||0);
var hr = (e[3]||0) - (s[3]||0);
var day = e[2] - s[2];
var mon = e[1] - s[1];
var yr = e[0] - s[0];
// Borrowing to resolve -ve values.
if (ms < 0) { // ms borrow from sec
ms += 1000;
--sec;
}
if (sec < 0) { // sec borrows from min
sec += 60;
--min;
}
if (min < 0) { // min borrows from hr
min += 60;
--hr;
}
if (hr < 0) { // hr borrows from day
hr += 24;
--day;
}
// Day borrows from month, a little complex but not too hard
if (day < 0) {
var prevMonLen = new Date(e[0], e[1]-1, 0).getDate();
// If the start date is less than the number of days in the previous month,
// set days to previous month length + current diff days value
// Note that current diff days may have had a day borrowed, so don't use end date - start date
// Otherwise, if the start date is equal to or greater than the number of
// days in the previous month, just set to end date. That's because adding
// 1 month to 30 Jan should be last day in Feb (i.e. 28 or 29), not 2 or 1 March
// respectively, which is what happens if adding 1 month to a Date object for 30 Jan.
// Similarly, 31 May + 1 month should be 30 June, not 1 July.
day = s[2] < prevMonLen? prevMonLen + day : +e[2];
--mon;
}
if (mon < 0) { // mon borrows from yr
mon += 12;
--yr;
}
// If days >= number of days in end month and end date is last day
// of month, zero mon and add one to month
// If then months = 12, zero and add one to years
var endMonLen = new Date(e[0], e[1], 0).getDate();
if (day >= endMonLen && s[2] > e[2] && e[2] == endMonLen) {
day = 0;
++mon;
if (mon == 12) {
mon = 0;
++yr;
}
}
return [yr,mon,day,hr,min,+(sec + '.' + ('00'+ms).slice(-3))];
}
/* Format output from dateDiff function, e.g. 3years, 2 days, 23.12 seconds
**
** #param {Array} v - values array in order years, months, days, hours, minutes
** seconds (milliseconds as decimal part of seconds)
** #returns {string} Values with their names appended. Adds "s" to values other
** than 1, zero values omitted, e.g. "0 months" not returned.
*/
function formatOutput(v) {
var values = ['year','month','day','hour','minute','second']
return v.reduce(function (s, x, i) {
s += x? (s.length? ' ' : '') +
(i == 5? x.toFixed(3) : x) + ' ' + values[i] + (x==1?'':'s'):'';
return s;
}, '');
}
// Tests, focus on February
var dates = [
['2016-01-31','2016-03-01'], // 1 month 1 day - 31 Jan + 1 month = 29 Feb
['2016-01-29','2016-03-01'], // 1 month 1 day - 29 Jan + 1 month = 29 Feb
['2016-01-27','2016-03-01'], // 1 month 3 days - 27 Jan + 1 month = 27 Feb
['2016-01-27','2016-03-29'], // 2 months 2 days - 27 Jan + 2 month = 27 Mar
['2016-01-29','2016-03-27'], // 1 month 27 days - 29 Jan + 1 month = 29 Feb
['2015-12-31','2016-01-30'], // 30 days - 31 Dec + 30 days = 30 Jan
['2015-12-27','2016-01-30'], // 1 month 3 days - 27 Dec + 1 month = 27 Jan
['2016-02-29','2017-02-28'], // 1 year could also be 11 months 30 days
// since 29 Feb + 11 months = 28 Feb, but 28 Feb is last day of month
// so roll over to full year
// Both work, but 1 year is more logical
['1957-12-04','2016-02-20'], // 58 years 2 months 16 days
['2000-02-29','2016-02-28'], // 15 years 11 months 30 days
// Not full year as Feb 2016 has 29 days
['2000-02-28','2016-02-28'], // 16 years
['2000-02-28','2016-02-29'], // 16 years 1 day
['2016-02-28T23:52:19.212Z','2016-12-02T01:48:57.102Z'] // 9 months 3 days 1 hour 56 minutes 37.899 seconds
];
var arr = [];
dates.forEach(function(a) {
arr.push(a[0] + ' to ' + a[1] + '<br>' + formatOutput(dateDiff(a[0], a[1])));
});
document.write(arr.join('<br>'));
table {
border-collapse:collapse;
border-left: 1px solid #bbbbbb;
border-top: 1px solid #bbbbbb;
}
input {
width: 12em;
}
input.bigGuy {
width: 32em;
}
td {
border-right: 1px solid #bbbbbb;
border-bottom: 1px solid #bbbbbb;
}
td:nth-child(1) { text-align: right; }
<form onsubmit="this.doCalc.onclick(); return false;">
<table>
<tr>
<td width="250"><label for="startDate">Start date (yyyy-mm-dd)</label>
<td><input name="startDate" id="startDate" value="2012-08-09T22:15:03.22" size="25">
<tr>
<td><label for="endDate">End date (yyyy-mm-dd)</label>
<td><input name="endDate" id="endDate" value="2013-08-13T12:10:03.22" size="25">
<tr>
<td><label for="dateDifference">Date difference: </label>
<td><input name="dateDifference" readonly class="bigGuy">
<tr>
<td><label for="daysDifference">Days difference: </label>
<td><input name="daysDifference" readonly>
<tr>
<td>
<input type="button" value="Calc date difference" name="doCalc2" onclick="
this.form.dateDifference.value = formatOutput(dateDiff(this.form.startDate.value, this.form.endDate.value));
this.form.daysDifference.value = getDaysDiff(this.form.startDate.value, this.form.endDate.value) + ' days';
">
<td><input type="reset">
</table>
</form>
Some things to note:
31 May to 30 June is 1 month. It doesn't make sense for it to be 1 July.
In a leap year, 31 Jan to 29 Feb is 1 month, to 28 Feb 2016 is 28 days.
Not in a leap year, 31 Jan to 28 Feb is 1 month.
29 Feb 2016 to 28 Feb 2017 is 1 year, since 28 Feb is the last day of the month
29 Feb 2016 to 28 Feb 2020 is 3 years, 11 months and 30 days since 28 Feb is not the last day of the month in 2020.
This solution can be implemented entirely without using Date objects, I've just used it for convenience for getting the days in a month, but an alternative that doesn't use a Date is about 4 lines of code.
var date1 = new Date("4/14/2016");
var date2 = new Date("10/16/2016");
var timeDiff = Math.abs(date2.getTime() - date1.getTime());
var newDate = new Date(timeDiff);
alert(newDate);
alert("Month " + (newDate.getUTCMonth() + 1));
alert("Date " + newDate.getUTCDate());
alert("Hour " + newDate.getUTCHours());
you cannot convert a difference (diff result is a number) to MM-DD-hh format, because some months are 30 day length, the others are 31 day length.
It could be calculated from start and end datetime.
There's a similar function what you are looking for, but not exact
moment("2010-01-01").from("2010-12-01")
result: a year ago
moment("2010-01-01").from("2010-12-01", true)
result: a year

Week number in US format

I know how to get a week number for a ISO format. There are some nice questions and answers about this.
I would like now to know how to find the week number in the US format. The US week number rules says the week 1 is always the week containing the 1st of january, so I'm safe in January. But how to know the week number of 1st of march of a given year?
Teoretically I imagine it has to take into account which day in the week the year starts, find out the length of that years februari and iterate untill I reach the right day, adding weeks to it.
In my logic should be something like:
function getUSweekNumber(y, m, d) {
var firstOfJanuary = new Date(y, 0, 1);
var dayOfWeek = firstOfJanuary.getDay() || 7;
var weekNr = 1;
for (var i = 0; i < m; i++) {
var daysInMonth = new Date(y, i + 1, 0).getDate();
weekNr += parseInt(daysInMonth / 7, 10);
dayOfWeek += daysInMonth % 7;
}
weekNr += parseInt((dayOfWeek + d) / 7, 10);
return weekNr;
}
but I get wrong results:
console.log(getUSweekNumber(2015, 0, 1)); // 1
console.log(getUSweekNumber(2015, 0, 15)); // 3
console.log(getUSweekNumber(2015, 7, 1)); // 32 <- wrong, whould be 31
What am I missing? Is there a better way?
jsFiddle: https://jsfiddle.net/Lqghrvw0/2/
A one line solution
It appears that the selected answer might have a bug. For example, when given the date 30-DEC-2015 it should return 1 because that week contains 1-JAN-2016. Yet, the function instead returns 53.
So the problem is how to handle the final days from the previous year that fall within the first week of the current year?
One possible way to deal with it is to adjust the target date so that it always starts on the last day of the week rather than any day of the week. And this can be done by using the day value (0-6) as an offset like so:
var endDate = targetDate.getUTCDate() + 6 - targetDate.getUTCDay();
This works for USA week numbering and could also be made to work with ISO-8601 week numbering with minor modifications (not shown). We can then plug this snippet into a one line solution like so:
var weeks=Math.ceil((((d.setUTCDate(d.getUTCDate()+6-d.getUTCDay())-d.setUTCMonth(0,1))/86400000)+d.getUTCDay()+1)/7);
And our function simply becomes:
function getWeekUS( date ) {
var d = new Date( date );
return Math.ceil(((( d.setUTCDate( d.getUTCDate() + 6 - d.getUTCDay()) - d.setUTCMonth( 0, 1 )) / 86400000 ) + d.getUTCDay() + 1 ) / 7 );
}
Explained:
We first make a copy of the date to avoid altering the original. We then add an offset so the target date falls on the last day of the week. Then we set the date to 1-JAN and find the difference between that and the target date. We divide that number by 8640000 (24*60*60*1000) to convert milliseconds to days. Finally, we add the starting date offset and then divide by 7 to get weeks.
And now our function returns the correct week for edge cases like 30-DEC-2015.
Your approach with a loop seems somewhat complicated. Your initial thinking that you need the day of the week is good, but you do not use it correctly.
The US week starts on a sunday, and the first week is the week of January 1st. Let's take a closer look of the first week of 2015:
| 28 | 29 | 30 | 31 | 1 | 2 | 3 |
| Su | Mo | Tu | We | Th | Fr | Sa |
For ease of computing, we want to shift the week, so that the first 7 days are week 1. How do we do that? Well, by using the day of the week. Because Sunday is already day 0, we don't need to alter it in any way. If January 1st is on a Sunday, we don't need to shift the week.
We can easily compute the amount of days between two dates. Because of daylight saving, we have to round the number we get, and since we don't shift the clock with more than 12 hours, we are fine normalizing that way. Then we just need to divide the number by 7 to get the week number.
function getUSweekNumber(y, m, d) {
//January 1st this year
var beginOfThisYear = new Date(y, 0, 1);
var dayOfWeek = beginOfThisYear.getDay();
//January 1st next year
var beginOfNextYear = new Date(y+1, 0, 1);
var dayOfWeekNextYear = beginOfNextYear.getDay();
//Provided date
var currentDay = new Date(y, m, d);
var oneDay = 1000 * 60 * 60 * 24;
var numberOfDays = 1 + Math.round((currentDay.getTime() - beginOfThisYear.getTime()) / oneDay);
var weekNr;
if( currentDay.getTime() >= beginOfNextYear.getTime() - (oneDay * dayOfWeekNextYear) ) {
//First week of next year
weekNr = 1;
} else {
//Shift week so 1-7 are week 1, then get week number
weekNr = Math.ceil((numberOfDays + dayOfWeek) / 7);
}
return weekNr;
}
console.log(getUSweekNumber(2015, 0, 1)); // 1
console.log(getUSweekNumber(2015, 0, 15)); // 3
console.log(getUSweekNumber(2015, 7, 1)); // 31
console.log(getUSweekNumber(2015, 11, 27)); //1
use http://momentjs.com. They define the method week:
function getUSweekNumber(y, m, d) {
var date = moment({ year: y, month: m, day: d });
return date.week();
}

Javascript repeating days counter

I need a JavaScript function that returns the number of days remaining from a particular date of every year.
I found the following code, but how can I make it repeatable for every year, instead of changing the year in the function manually?
function daysUntil(year, month, day) {
var now = new Date(),
dateEnd = new Date(year, month - 1, day), // months are zero-based
days = (dateEnd - now) / 1000/60/60/24; // convert milliseconds to days
return Math.round(days);
}
daysUntil(2013, 10, 26);
I think my question above is not clear enough, i need to show days remaining in 26th October. So this starts again every year on 27th October. I don't need a loop for that.
"how can i make it repeatable for every year, instead of changing the year in function manually?"
Well you can't do literally every year to infinity, but you can easily add a loop to get a specific range of years:
var d;
for (var y = 2013; y < 2099; y++) {
d = daysUntil(y, 10, 26);
// do something with d, e.g.,
console.log(d);
}
UPDATE: You added this detail to your question:
"I think my question above is not clear enough, i need to show days remaining in 26th October. So this starts again every year on 27th October. I don't need a loop for that."
OK, that's still not very clear, but I think you're saying that your input would be just the day and month and you want to calculate the number of days until the next time that day/month rolls around, e.g., the number of days until your next birthday. If so, perhaps something like this:
function daysUntil(month, day) {
var now = new Date(),
currentYear = now.getFullYear(),
dateEnd = new Date(currentYear, month - 1, day); // months are zero-based
if (dateEnd - now < 0) // have we already passed that date this year?
dateEnd.setFullYear(currentYear + 1);
return Math.ceil((dateEnd - now) / 1000/60/60/24);
}
console.log(daysUntil(10,11)); // 365 - results from today, Oct 11
console.log(daysUntil(10,26)); // 15
console.log(daysUntil(7,7)); // 269

Categories