I built a script to put versions on some data my website fetches, but since users from all over the world use it Date.now() returns different results according to the timezone the user is in.
Is there an alternative to Date.now() or an option I overlooked that can standardize this?
Edit: This is what I need the date for:
function timeDB(){
let unix_timestamp = Date.now();
var date = new Date(unix_timestamp);
var hours = date.getHours();
var year = date.getFullYear();
var month = date.getMonth()+1;
var day = date.getDate();
if ( month <10){
year = year*10;
}
if ( day <10){
month = month*10;
}
if ( hours <10){
day = day*10;
}
var formattedTime = year + '' + month + '' + day + '' + hours;
return formattedTime;
}
This formated time will then be used as a version in my DB, so I need a universal timestamp.
Date.now returns an offset in milliseconds from 1970-01-01 UTC, it's unaffected by timezones or daylight saving, however it is affected by the accuracy of the host system's clock.
For a "universal" timestamp, you should use Universal Coordinated Time (UTC) values. You can build your own string using getUTC* methods such as getUTCFullYear, getUTCMonth, etc. or just use the string returned by toISOString and reformat the parts to suit.
If you just want YYYY MM DD HH then you can use a very simple function, the values are already zero padded strings so no need for the * 10 trick:
function timeDB(date = new Date()) {
return date.toISOString().split(/\D/).splice(0,4).join('');
}
console.log(timeDB());
There are many questions and answers already on how to format a date.
However, if you just want a unique value for versioning and only using current dates, then just using the value returned by Date.now should be sufficient. It's only 3 digits longer and you can trim it to 10 digits if you wish:
String(Date.now()).slice(0,10);
That effectively gives you a timestamp in seconds since the (fairly common) epoch of 1970-01-01 and is easily turned back into a date.
If your environment is properly configured to know its timezone (most browsers are) then all you need to do is add the timezone offset to your timestamp:
Date.now() + new Date().getTimezoneOffset() * 60 * 1000
I think you need UTC version of date and time so your code should be
function timeDB(){
let unix_timestamp = Date.now();
var date = new Date(unix_timestamp);
var hours = date.getUTCHours();
var year = date.getUTCFullYear();
var month = date.getUTCMonth()+1;
var day = date.getUTCDate();
if ( month <10){
year = year*10;
}
if ( day <10){
month = month*10;
}
if ( hours <10){
day = day*10;
}
var formattedTime = year + '' + month + '' + day + '' + hours;
return formattedTime;
}
This is will return the same values regardless the country is served from.
The problem is that this program will only work in Chrome, no matter what date format I use or when I parsed the dates using , it would return NaN.
The program converts the two dates (constant and a certain holiday) into milliseconds from Jan 1st, 1970. The dates are compared and subtracted. Then they are divided and rounded into seconds until the date. The problem, I believe lies when the dates are set. I do NOT want to mess with timezones.
jQuery in the answer is fine. Regex's are fine, but I don't understand them.
If the answer could have a working proof, that would be cool. Thanks!
The html is (all that matters)
<p id="output">
</p>
The code is
$(document).ready(function() {
var date = new Date();
var year = date.getFullYear();
console.log(year + "-12-25");
var christmasdate = new Date(year + "-12-24 24:00:00");
$("#output").css("font-size","20px");
$("#output").html("If this lasts more than a second, something is wrong.");
setInterval(function() {
date = new Date();
var curr_time = date.getTime();
var xmas_time = christmasdate.getTime();
var time_left = Math.round((xmas_time - curr_time) / 1000);
var output;
if (time_left < 0) {
output = "Christmas was " + Math.abs(time_left) + " seconds ago."
}
else {
output = "There is " + time_left + " seconds until christmas eve.";
}
if (time_left == 1) {
output = "There is " + time_left + "second until christmas eve.";
}
$("#output").html(output);
var bodyheight = $(document).height();
var allheight = $("body").height();
$("h2").css("margin-top",(bodyheight / 2) - (allheight / 2))
}, 1000);
});
The link is http://jsbin.com/suyedol/5/edit.
From MDN:
Because of the variances in parsing of date strings, it is recommended to always manually parse strings as results are inconsistent, especially across different ECMAScript implementations where strings like "2015-10-12 12:00:00" may be parsed to as NaN, UTC or local timezone.
But instead of
var christmasdate = new Date(year + "-12-24 24:00:00");
You could instead use:
var christmasdate = new Date(year,11,24,24,0,0);
Which Safari computed as
Mon Dec 25 2017 00:00:00 GMT-0500 (EST)
Your computation of christmas in the current year seems overly complex and error prone. You certainly should not be using the Date constructor to parse strings (or Date.parse, they are equivalent for parsing).
Consider the following, which creates a date for 00:00:00 on Christmas morning in the current year.
var christmas = new Date();
christmas.setHours(0,0,0,0);
christmas.setMonth(11,25);
console.log(christmas.toString());
I'd like to get a Date object which is 30 minutes later than another Date object. How do I do it with JavaScript?
Using a Library
If you are doing a lot of date work, you may want to look into JavaScript date libraries like Datejs or Moment.js. For example, with Moment.js, this is simply:
var newDateObj = moment(oldDateObj).add(30, 'm').toDate();
Vanilla Javascript
This is like chaos's answer, but in one line:
var newDateObj = new Date(oldDateObj.getTime() + diff*60000);
Where diff is the difference in minutes you want from oldDateObj's time. It can even be negative.
Or as a reusable function, if you need to do this in multiple places:
function addMinutes(date, minutes) {
return new Date(date.getTime() + minutes*60000);
}
And just in case this is not obvious, the reason we multiply minutes by 60000 is to convert minutes to milliseconds.
Be Careful with Vanilla Javascript. Dates Are Hard!
You may think you can add 24 hours to a date to get tomorrow's date, right? Wrong!
addMinutes(myDate, 60*24); //DO NOT DO THIS
It turns out, if the user observes daylight saving time, a day is not necessarily 24 hours long. There is one day a year that is only 23 hours long, and one day a year that is 25 hours long. For example, in most of the United States and Canada, 24 hours after midnight, Nov 2, 2014, is still Nov 2:
const NOV = 10; //because JS months are off by one...
addMinutes(new Date(2014, NOV, 2), 60*24); //In USA, prints 11pm on Nov 2, not 12am Nov 3!
This is why using one of the afore-mentioned libraries is a safer bet if you have to do a lot of work with this.
Below is a more generic version of this function that I wrote. I'd still recommend using a library, but that may be overkill/impossible for your project. The syntax is modeled after MySQL DATE_ADD function.
/**
* Adds time to a date. Modelled after MySQL DATE_ADD function.
* Example: dateAdd(new Date(), 'minute', 30) //returns 30 minutes from now.
* https://stackoverflow.com/a/1214753/18511
*
* #param date Date to start with
* #param interval One of: year, quarter, month, week, day, hour, minute, second
* #param units Number of units of the given interval to add.
*/
function dateAdd(date, interval, units) {
if(!(date instanceof Date))
return undefined;
var ret = new Date(date); //don't change original date
var checkRollover = function() { if(ret.getDate() != date.getDate()) ret.setDate(0);};
switch(String(interval).toLowerCase()) {
case 'year' : ret.setFullYear(ret.getFullYear() + units); checkRollover(); break;
case 'quarter': ret.setMonth(ret.getMonth() + 3*units); checkRollover(); break;
case 'month' : ret.setMonth(ret.getMonth() + units); checkRollover(); break;
case 'week' : ret.setDate(ret.getDate() + 7*units); break;
case 'day' : ret.setDate(ret.getDate() + units); break;
case 'hour' : ret.setTime(ret.getTime() + units*3600000); break;
case 'minute' : ret.setTime(ret.getTime() + units*60000); break;
case 'second' : ret.setTime(ret.getTime() + units*1000); break;
default : ret = undefined; break;
}
return ret;
}
Working jsFiddle demo.
var d1 = new Date (),
d2 = new Date ( d1 );
d2.setMinutes ( d1.getMinutes() + 30 );
alert ( d2 );
var oldDateObj = new Date();
var newDateObj = new Date();
newDateObj.setTime(oldDateObj.getTime() + (30 * 60 * 1000));
console.log(newDateObj);
var now = new Date();
now.setMinutes(now.getMinutes() + 30); // timestamp
now = new Date(now); // Date object
console.log(now);
Maybe something like this?
var d = new Date();
var v = new Date();
v.setMinutes(d.getMinutes()+30);
console.log(v)
I always create 7 functions, to work with date in JS:
addSeconds, addMinutes, addHours, addDays, addWeeks, addMonths, addYears.
You can see an example here: http://jsfiddle.net/tiagoajacobi/YHA8x/
How to use:
var now = new Date();
console.log(now.addMinutes(30));
console.log(now.addWeeks(3));
These are the functions:
Date.prototype.addSeconds = function(seconds) {
this.setSeconds(this.getSeconds() + seconds);
return this;
};
Date.prototype.addMinutes = function(minutes) {
this.setMinutes(this.getMinutes() + minutes);
return this;
};
Date.prototype.addHours = function(hours) {
this.setHours(this.getHours() + hours);
return this;
};
Date.prototype.addDays = function(days) {
this.setDate(this.getDate() + days);
return this;
};
Date.prototype.addWeeks = function(weeks) {
this.addDays(weeks*7);
return this;
};
Date.prototype.addMonths = function (months) {
var dt = this.getDate();
this.setMonth(this.getMonth() + months);
var currDt = this.getDate();
if (dt !== currDt) {
this.addDays(-currDt);
}
return this;
};
Date.prototype.addYears = function(years) {
var dt = this.getDate();
this.setFullYear(this.getFullYear() + years);
var currDt = this.getDate();
if (dt !== currDt) {
this.addDays(-currDt);
}
return this;
};
One line code
var afterSomeMinutes = new Date(new Date().getTime() + minutes * 60000);
where minutes is a number
Stop using Moment.js
As recommended by other great answers, in most cases it's best to use a library when dealing dates. However, it's important to know that as of September 2020 Moment.js is considered legacy and should no longer be used in new projects.
Quoting Moment's statement in their official docs:
We would like to discourage Moment from being used in new projects going forward. [...] We now generally consider Moment to be a legacy project in maintenance mode. It is not dead, but it is indeed done.
Modern libraries
Below are alternatives recommended by Moment.
Luxon
Luxon can be thought of as the evolution of Moment. It is authored by Isaac Cambron, a long-time contributor to Moment. Please read Why does Luxon exist? and the For Moment users pages in the Luxon documentation.
Locales: Intl provided
Time Zones: Intl provided
import {DateTime} from 'luxon'
function addMinutes(date, minutes) {
return DateTime.fromJSDate(date).plus({minutes}).toJSDate()
}
Day.js
Day.js is designed to be a minimalist replacement for Moment.js, using a similar API. It is not a drop-in replacement, but if you are used to using Moment's API and want to get moving quickly, consider using Day.js.
Locales: Custom data files that can be individually imported
Time Zones: Intl provided, via a plugin
import dayjs from 'dayjs'
function addMinutes(date, minutes) {
return dayjs(date).add(minutes, 'minutes').toDate()
}
date-fns
Date-fns offers a series of functions for manipulating JavaScript Date objects. For more details, scroll to "Why date-fns?" on the date-fns home page.
Locales: Custom data files that can be individually imported
Time Zones: Intl provided, via a separate companion library
import {addMinutes} from 'date-fns'
function addMinutesDemo(date, minutes) {
return addMinutes(date, minutes)
}
js-Joda
js-Joda is a JavaScript port of Java's Three-Ten Backport, which is the base for JSR-310 implementation of the Java SE 8 java.time package. If you are familiar with java.time, Joda-Time, or Noda Time, you will find js-Joda comparable.
Locales: Custom data files via add-on module
Time Zones: Custom data files via add-on module
import {LocalDateTime, nativeJs, convert} from '#js-joda/core'
function addMinutes(date, minutes) {
return convert(
LocalDateTime.from(
nativeJs(date)
).plusMinutes(minutes)
).toDate()
}
One-liner no utilities:
new Date(+new Date() + 60000*15) // +15 minutes
The easiest way to solve is the to recognize that in javascript dates are just numbers. It starts 0 or 'Wed Dec 31 1969 18:00:00 GMT-0600 (CST). Every 1 represents a millisecond. You can add or subtract milliseconds by getting the value and instantiating a new date using that value. You can manage it pretty easy with that mind.
const minutesToAdjust = 10;
const millisecondsPerMinute = 60000;
const originalDate = new Date('11/20/2017 10:00 AM');
const modifiedDate1 = new Date(originalDate.valueOf() - (minutesToAdjust * millisecondsPerMinute));
const modifiedDate2 = new Date(originalDate.valueOf() + (minutesToAdjust * millisecondsPerMinute));
console.log(originalDate); // Mon Nov 20 2017 10:00:00 GMT-0600 (CST)
console.log(modifiedDate1); // Mon Nov 20 2017 09:50:00 GMT-0600 (CST)
console.log(modifiedDate2); // Mon Nov 20 2017 10:10:00 GMT-0600 (CST)
This is what I do which seems to work quite well:
Date.prototype.addMinutes = function(minutes) {
var copiedDate = new Date(this.getTime());
return new Date(copiedDate.getTime() + minutes * 60000);
}
Then you can just call this like this:
var now = new Date();
console.log(now.addMinutes(50));
You should get the value of the current date to get the date with (ms) and add (30 * 60 *1000) to it. Now you have (current date + 30 min) with ms
console.log('with ms', Date.now() + (30 * 60 * 1000))
console.log('new Date', new Date(Date.now() + (30 * 60 * 1000)))
it is simple as it is;
let initial_date = new Date;
let added30Min = new Date(initial_date.getTime() + (30*60*1000));
Here is the ES6 version:
let getTimeAfter30Mins = () => {
let timeAfter30Mins = new Date();
timeAfter30Mins = new Date(timeAfter30Mins.setMinutes(timeAfter30Mins.getMinutes() + 30));
};
Call it like:
getTimeAfter30Mins();
Here is my one-liner:
console.log('time: ', new Date(new Date().valueOf() + 60000))
I feel many of the answers here are lacking a creative component, very much needed for time travel computations. I present my solution for a temporal translation of 30 minutes.
(jsfiddle here)
function fluxCapacitor(n) {
var delta,sigma=0,beta="ge";
(function(K,z){
(function(a,b,c){
beta=beta+"tT";
switch(b.shift()) {
case'3':return z('0',a,c,b.shift(),1);
case'0':return z('3',a,c,b.pop());
case'5':return z('2',a,c,b[0],1);
case'1':return z('4',a,c,b.shift());
case'2':return z('5',a,c,b.pop());
case'4':return z('1',a,c,b.pop(),1);
}
})(K.pop(),K.pop().split(''),K.pop());
})(n.toString().split(':'),function(b,a,c,b1,gamma){
delta=[c,b+b1,a];sigma+=gamma?3600000:0;
beta=beta+"im";
});
beta=beta+"e";
return new Date (sigma+(new Date( delta.join(':')))[beta]());
}
You could do this:
let thirtyMinutes = 30 * 60 * 1000; // convert 30 minutes to milliseconds
let date1 = new Date();
let date2 = new Date(date1.getTime() + thirtyMinutes);
console.log(date1);
console.log(date2);
Here is the IsoString version:
console.log(new Date(new Date().setMinutes(new Date().getMinutes() - (30))).toISOString());
var add_minutes = function (dt, minutes) {
return new Date(dt.getTime() + minutes*60000);
}
console.log(add_minutes(new Date(2014,10,2), 30).toString());
One way to 'add' 30 minutes is to create a second date object (mostly for demonstration) and set the minutes to minutes + 30. This will account for adjusting the hour as well if the first time is less than 30 minutes from the next hour. (i.e., 4:45 to 5:15)
const first = new Date();
console.log("first date :", first.toString());
const second = new Date(first);
const newMinutes = second.getMinutes() + 30;
console.log("new minutes:", newMinutes);
second.setMinutes(newMinutes);
console.log("second date:", second.toString());
I know that the topic is way too old. But I am pretty sure that there are some developpers who still need this, so I made this simple script for you.
I hope you enjoy it!
Hello back, It's 2020 and I've added some modification hope it will help a lot better now!
Hello again, It is 2022 and I came back again to fix some issues and give a better naming for the methods & functions.
function addTimeToDate(addedTime, date){
let generatedTime = date.getTime();
if(addedTime.seconds) generatedTime += 1000 * addedTime.seconds; //check for additional seconds
if(addedTime.minutes) generatedTime += 1000* 60 * addedTime.minutes;//check for additional minutes
if(addedTime.hours) generatedTime += 1000 * 60 * 60 * addedTime.hours;//check for additional hours
return new Date(generatedTime);
}
Date.prototype.addTime = function(addedTime){
return addTimeToDate(addedTime, this);
}
let futureDate = new Date().addTime({
hours: 16, //Adding one hour
minutes: 45, //Adding fourty five minutes
seconds: 0 //Adding 0 seconds return to not adding any second so we can remove it.
});
<button onclick="console.log(futureDate)">Travel to the future</button>
Use an existing library known to handle the quirks involved in dealing with time calculations. My current favorite is moment.js.
<script src="//cdnjs.cloudflare.com/ajax/libs/moment.js/2.13.0/moment.js"></script>
<script>
var now = moment(); // get "now"
console.log(now.toDate()); // show original date
var thirty = moment(now).add(30,"minutes"); // clone "now" object and add 30 minutes, taking into account weirdness like crossing DST boundries or leap-days, -minutes, -seconds.
console.log(thirty.toDate()); // show new date
</script>
Other solution:
var dateAv = new Date();
var endTime = new Date(dateAv.getFullYear(), dateAv.getMonth(), dateAv.getDate(), dateAv.getHours(), dateAv.getMinutes() + 30);
let d = new Date();
d.setMinutes(d.getMinutes() + 30);
// console.log(d)
For the lazy like myself:
Kip's answer (from above) in coffeescript, using an "enum", and operating on the same object:
Date.UNIT =
YEAR: 0
QUARTER: 1
MONTH: 2
WEEK: 3
DAY: 4
HOUR: 5
MINUTE: 6
SECOND: 7
Date::add = (unit, quantity) ->
switch unit
when Date.UNIT.YEAR then #setFullYear(#getFullYear() + quantity)
when Date.UNIT.QUARTER then #setMonth(#getMonth() + (3 * quantity))
when Date.UNIT.MONTH then #setMonth(#getMonth() + quantity)
when Date.UNIT.WEEK then #setDate(#getDate() + (7 * quantity))
when Date.UNIT.DAY then #setDate(#getDate() + quantity)
when Date.UNIT.HOUR then #setTime(#getTime() + (3600000 * quantity))
when Date.UNIT.MINUTE then #setTime(#getTime() + (60000 * quantity))
when Date.UNIT.SECOND then #setTime(#getTime() + (1000 * quantity))
else throw new Error "Unrecognized unit provided"
# # for chaining
Just another option, which I wrote:
DP_DateExtensions Library
It's overkill if this is all the date processing that you need, but it will do what you want.
Supports date/time formatting, date math (add/subtract date parts), date compare, date parsing, etc. It's liberally open sourced.
simply you can use this code with momnet library:
console.log(moment(moment()).add(30,"minutes").format('MM/DD/YYYY hh:mm:ss'));
var myDate= new Date();
var MyNewDate = new Date
(myDate.getFullYear(),myDate.getMonth(),myDate.getDate(),myDate.getMinutes()+10,01,01)
const MINUTE = 60 * 1000;
new Date(Date.parse(yourDate) + numOfMins * MINUTE)
I am sure that a lot of people asked this question but when I checked the answers it seems to me that they are wrong that what I found
var startDate = new Date(Date.parse(startdate));
//The start date is right lets say it is 'Mon Jun 30 2014 00:00:00'
var endDate = new Date(startDate.getDate() + 1);
// the enddate in the console will be 'Wed Dec 31 1969 18:00:00' and that's wrong it should be 1 july
I know that .getDate() return from 1-31 but Does the browser or the javascript increase only the day without updating the month and the year ?
and in this case Should I write an algorithm to handle this ? or there is another way ?
Note that Date.getDate only returns the day of the month. You can add a day by calling Date.setDate and appending 1.
// Create new Date instance
var date = new Date()
// Add a day
date.setDate(date.getDate() + 1)
JavaScript will automatically update the month and year for you.
EDIT:
Here's a link to a page where you can find all the cool stuff about the built-in Date object, and see what's possible: Date.
The Date constructor that takes a single number is expecting the number of milliseconds since December 31st, 1969.
Date.getDate() returns the day index for the current date object. In your example, the day is 30. The final expression is 31, therefore it's returning 31 milliseconds after December 31st, 1969.
A simple solution using your existing approach is to use Date.getTime() instead. Then, add a days worth of milliseconds instead of 1.
For example,
var dateString = 'Mon Jun 30 2014 00:00:00';
var startDate = new Date(dateString);
// seconds * minutes * hours * milliseconds = 1 day
var day = 60 * 60 * 24 * 1000;
var endDate = new Date(startDate.getTime() + day);
JSFiddle
Please note that this solution doesn't handle edge cases related to daylight savings, leap years, etc. It is always a more cost effective approach to instead, use a mature open source library like moment.js to handle everything.
There is issue of 31st and 28th Feb with getDate() I use this function getTime and 24*60*60*1000 = 86400000
Use this function:
function incrementDate(dateInput,increment) {
var dateFormatTotime = new Date(dateInput);
var increasedDate = new Date(dateFormatTotime.getTime() +(increment *86400000));
return increasedDate;
}
Example as below:
var dateWith31 = new Date("2017-08-31");
var dateWith29 = new Date("2016-02-29");
var amountToIncreaseWith = 1; //Edit this number to required input
console.log(incrementDate(dateWith31,amountToIncreaseWith));
console.log(incrementDate(dateWith29,amountToIncreaseWith));
function incrementDate(dateInput,increment) {
var dateFormatTotime = new Date(dateInput);
var increasedDate = new Date(dateFormatTotime.getTime() +(increment *86400000));
return increasedDate;
}
use this i think it is useful for you
var endDate=startDate.setDate(startDate.getDate() + 1);
I think what you are looking for is:
startDate.setDate(startDate.getDate() + 1);
Also, you can have a look at Moment.js
A javascript date library for parsing, validating, manipulating, and formatting dates.
var datatoday = new Date();
var datatodays = datatoday.setDate(new Date(datatoday).getDate() + 1);
todate = new Date(datatodays);
console.log(todate);
This will help you...
add one day in javascript in one line
NB: if you want to add a specific number of days ... just replace 1 with the number of days you want
new Date(new Date().setDate(new Date().getDate() + 1))
console.log(new Date(new Date().setDate(new Date().getDate() + 1)))
i know it's been long time since this is posted but here's my answer
function addDays(date, n)
{
const oneDayInMs = 86400 * 1000;
return new Date(Date.parse(date) + (n * oneDayInMs));
}
addDays(new Date(), 1);
Just for the sake of adding functions to the Date prototype:
In a mutable fashion / style:
Date.prototype.addDays = function(n) {
this.setDate(this.getDate() + n);
};
// Can call it tomorrow if you want
Date.prototype.nextDay = function() {
this.addDays(1);
};
Date.prototype.addMonths = function(n) {
this.setMonth(this.getMonth() + n);
};
Date.prototype.addYears = function(n) {
this.setFullYear(this.getFullYear() + n);
}
// etc...
var currentDate = new Date();
currentDate.nextDay();
If you don't mind using a library, DateJS (https://github.com/abritinthebay/datejs/) would make this fairly easy. You would probably be better off with one of the answers using vanilla JavaScript however, unless you're going to take advantage of some other DateJS features like parsing of unusually-formatted dates.
If you're using DateJS a line like this should do the trick:
Date.parse(startdate).add(1).days();
You could also use MomentJS which has similar features (http://momentjs.com/), however I'm not as familiar with it.
The below will add a single day to a current time. I believe this will handle daylight saving times, etc.
function increment_date (date) {
let old_date = new Date (date);
date.setDate (old_date.getDate() + 1);
while (date.getDate() == old_date.getDate()) {
date.setHours (date.getHours() + 1);
}
date.setHours (0);
}