I have been fighting with this for a bit now. I’m trying to convert epoch to a date object. The epoch is sent to me in UTC. Whenever you pass new Date()
an epoch, it assumes it’s local epoch. I tried creating a UTC object, then using setTime()
to adjust it to the proper epoch, but the only method that seems useful is toUTCString()
and strings don’t help me. If I pass that string into a new date, it should notice that it’s UTC, but it doesn’t.
new Date( new Date().toUTCString() ).toLocaleString()
My next attempt was to try to get the difference between local current epoch and UTC current epoch, but I wasn’t able to get that either.
new Date( new Date().toUTCString() ).getTime() - new Date().getTime()
It’s only giving me very small differences, under 1000, which is in milliseconds.
Any suggestions?
This question is related to
javascript
date
utc
epoch
To convert the current epoch time in [ms] to a 24-hour time. You might need to specify the option to disable 12-hour format.
$ node.exe -e "var date = new Date(Date.now()); console.log(date.toLocaleString('en-GB', { hour12:false } ));"
2/7/2018, 19:35:24
or as JS:
var date = new Date(Date.now());
console.log(date.toLocaleString('en-GB', { hour12:false } ));
// 2/7/2018, 19:35:24
console.log(date.toLocaleString('en-GB', { hour:'numeric', minute:'numeric', second:'numeric', hour12:false } ));
// 19:35:24
Note: The use of en-GB
here, is just a (random) choice of a place using the 24 hour format, it is not your timezone!
The Easiest Way
If you have the unix epoch in milliseconds, in my case - 1601209912824
const dateObject = new Date(milliseconds)
const humanDateFormat = dateObject.toString()
Sun Sep 27 2020 18:01:52 GMT+0530 (India Standard Time)
const dateObject = new Date(milliseconds)
const humanDateFormat = dateObject.toUTCString()
If you prefer to resolve timestamps and dates conversions from and to UTC and local time without libraries like moment.js, take a look at the option below.
For applications that use UTC timestamps, you may need to show the date in the browser considering the local timezone and daylight savings when applicable. Editing a date that is in a different daylight savings time even though in the same timezone can be tricky.
The Number
and Date
extensions below allow you to show and get dates in the timezone of the timestamps. For example, lets say you are in Vancouver, if you are editing a date in July or in December, it can mean you are editing a date in PST or PDT.
I recommend you to check the Code Snippet down below to test this solution.
Conversions from milliseconds
Number.prototype.toLocalDate = function () {
var value = new Date(this);
value.setHours(value.getHours() + (value.getTimezoneOffset() / 60));
return value;
};
Number.prototype.toUTCDate = function () {
var value = new Date(this);
value.setHours(value.getHours() - (value.getTimezoneOffset() / 60));
return value;
};
Conversions from dates
Date.prototype.getUTCTime = function () {
return this.getTime() - (this.getTimezoneOffset() * 60000);
};
Usage
// Adds the timezone and daylight savings if applicable
(1499670000000).toLocalDate();
// Eliminates the timezone and daylight savings if applicable
new Date(2017, 6, 10).getUTCTime();
See it for yourself
// Extending Number_x000D_
_x000D_
Number.prototype.toLocalDate = function () {_x000D_
var value = new Date(this);_x000D_
_x000D_
value.setHours(value.getHours() + (value.getTimezoneOffset() / 60));_x000D_
_x000D_
return value;_x000D_
};_x000D_
_x000D_
Number.prototype.toUTCDate = function () {_x000D_
var value = new Date(this);_x000D_
_x000D_
value.setHours(value.getHours() - (value.getTimezoneOffset() / 60));_x000D_
_x000D_
return value;_x000D_
};_x000D_
_x000D_
// Extending Date_x000D_
_x000D_
Date.prototype.getUTCTime = function () {_x000D_
return this.getTime() - (this.getTimezoneOffset() * 60000);_x000D_
};_x000D_
_x000D_
// Getting the demo to work_x000D_
document.getElementById('m-to-local-button').addEventListener('click', function () {_x000D_
var displayElement = document.getElementById('m-to-local-display'),_x000D_
value = document.getElementById('m-to-local').value,_x000D_
milliseconds = parseInt(value);_x000D_
_x000D_
if (typeof milliseconds === 'number')_x000D_
displayElement.innerText = (milliseconds).toLocalDate().toISOString();_x000D_
else_x000D_
displayElement.innerText = 'Set a value';_x000D_
}, false);_x000D_
_x000D_
document.getElementById('m-to-utc-button').addEventListener('click', function () {_x000D_
var displayElement = document.getElementById('m-to-utc-display'),_x000D_
value = document.getElementById('m-to-utc').value,_x000D_
milliseconds = parseInt(value);_x000D_
_x000D_
if (typeof milliseconds === 'number')_x000D_
displayElement.innerText = (milliseconds).toUTCDate().toISOString();_x000D_
else_x000D_
displayElement.innerText = 'Set a value';_x000D_
}, false);_x000D_
_x000D_
document.getElementById('date-to-utc-button').addEventListener('click', function () {_x000D_
var displayElement = document.getElementById('date-to-utc-display'),_x000D_
yearValue = document.getElementById('date-to-utc-year').value || '1970',_x000D_
monthValue = document.getElementById('date-to-utc-month').value || '0',_x000D_
dayValue = document.getElementById('date-to-utc-day').value || '1',_x000D_
hourValue = document.getElementById('date-to-utc-hour').value || '0',_x000D_
minuteValue = document.getElementById('date-to-utc-minute').value || '0',_x000D_
secondValue = document.getElementById('date-to-utc-second').value || '0',_x000D_
year = parseInt(yearValue),_x000D_
month = parseInt(monthValue),_x000D_
day = parseInt(dayValue),_x000D_
hour = parseInt(hourValue),_x000D_
minute = parseInt(minuteValue),_x000D_
second = parseInt(secondValue);_x000D_
_x000D_
displayElement.innerText = new Date(year, month, day, hour, minute, second).getUTCTime();_x000D_
}, false);
_x000D_
<link href="https://cdnjs.cloudflare.com/ajax/libs/semantic-ui/2.2.11/semantic.css" rel="stylesheet"/>_x000D_
_x000D_
<div class="ui container">_x000D_
<p></p>_x000D_
_x000D_
<h3>Milliseconds to local date</h3>_x000D_
<input id="m-to-local" placeholder="Timestamp" value="0" /> <button id="m-to-local-button">Convert</button>_x000D_
<em id="m-to-local-display">Set a value</em>_x000D_
_x000D_
<h3>Milliseconds to UTC date</h3>_x000D_
<input id="m-to-utc" placeholder="Timestamp" value="0" /> <button id="m-to-utc-button">Convert</button>_x000D_
<em id="m-to-utc-display">Set a value</em>_x000D_
_x000D_
<h3>Date to milliseconds in UTC</h3>_x000D_
<input id="date-to-utc-year" placeholder="Year" style="width: 4em;" />_x000D_
<input id="date-to-utc-month" placeholder="Month" style="width: 4em;" />_x000D_
<input id="date-to-utc-day" placeholder="Day" style="width: 4em;" />_x000D_
<input id="date-to-utc-hour" placeholder="Hour" style="width: 4em;" />_x000D_
<input id="date-to-utc-minute" placeholder="Minute" style="width: 4em;" />_x000D_
<input id="date-to-utc-second" placeholder="Second" style="width: 4em;" />_x000D_
<button id="date-to-utc-button">Convert</button>_x000D_
<em id="date-to-utc-display">Set the values</em>_x000D_
_x000D_
</div>
_x000D_
Epoch time is in seconds from Jan. 1, 1970. date.getTime()
returns milliseconds from Jan. 1, 1970, so.. if you have an epoch timestamp, convert it to a javascript timestamp by multiplying by 1000.
function epochToJsDate(ts){
// ts = epoch timestamp
// returns date obj
return new Date(ts*1000);
}
function jsDateToEpoch(d){
// d = javascript date obj
// returns epoch timestamp
return (d.getTime()-d.getMilliseconds())/1000;
}
@Amjad, good idea, but a better implementation would be:
Date.prototype.setUTCTime = function(UTCTimestamp) {
var UTCDate = new Date(UTCTimestamp);
this.setUTCFullYear(UTCDate.getFullYear(), UTCDate.getMonth(), UTCDate.getDate());
this.setUTCHours(UTCDate.getHours(), UTCDate.getMinutes(), UTCDate.getSeconds(), UTCDate.getMilliseconds());
return this.getTime();
}
Considering, you have epoch_time
available,
// for eg. epoch_time = 1487086694.213
var date = new Date(epoch_time * 1000); // multiply by 1000 for milliseconds
var date_string = date.toLocaleString('en-GB'); // 24 hour format
It's easy, new Date()
just takes milliseconds, e.g.
new Date(1394104654000)
> Thu Mar 06 2014 06:17:34 GMT-0500 (EST)
And just for the logs, I did this using Moment.js library, which I was using for formatting anyway.
moment.utc(1234567890000).local()
>Fri Feb 13 2009 19:01:30 GMT-0430 (VET)
function ToLocalDate (inDate) {
var date = new Date();
date.setTime(inDate.valueOf() - 60000 * inDate.getTimezoneOffset());
return date;
}
EDIT
var utcDate = new Date(incomingUTCepoch);
var date = new Date();
date.setUTCDate(utcDate.getDate());
date.setUTCHours(utcDate.getHours());
date.setUTCMonth(utcDate.getMonth());
date.setUTCMinutes(utcDate.getMinutes());
date.setUTCSeconds(utcDate.getSeconds());
date.setUTCMilliseconds(utcDate.getMilliseconds());
EDIT fixed
Addition to the above answer by @djechlin
d = '1394104654000';
new Date(parseInt(d));
converts EPOCH time to human readable date. Just don't forget that type of EPOCH time must be an Integer.
Epoch time (i.e. Unix Epoch time) is nearly always the number of seconds that have expired since 1st Jan 1970 00:00:00 (UTC time), not the number of milliseconds which some of the answers here have implied.
https://en.wikipedia.org/wiki/Unix_time
Therefore, if you have been given a Unix Epoch time value it will probably be in seconds, and will look something like 1547035195
. If you want to make this human readable in JavaScript, you need to convert the value to milliseconds, and pass that value into the Date(value)
constructor, e.g.:
const unixEpochTimeMS = 1547035195 * 1000;
const d = new Date(unixEpochTimeMS);
// Careful, the string output here can vary by implementation...
const strDate = d.toLocaleString();
You don't need to do the d.setUTCMilliseconds(0)
step in the accepted answer because the JavaScript Date(value)
constructor takes a UTC value in milliseconds (not a local time).
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#Syntax
Also note that you should avoid using the Date(...)
constructor that takes a string datetime representation, this is not recommended (see the link above).
var myDate = new Date( your epoch date *1000);
source - https://www.epochconverter.com/programming/#javascript
Are you just asking to convert a UTC string to a "local" string? You could do:
var utc_string = '2011-09-05 20:05:15';
var local_string = (function(dtstr) {
var t0 = new Date(dtstr);
var t1 = Date.parse(t0.toUTCString().replace('GMT', ''));
var t2 = (2 * t0) - t1;
return new Date(t2).toString();
})(utc_string);
The simplest solution I've found to this, is:
var timestamp = Date.now(), // returns milliseconds since epoch time
normalisedTime = new Date(timestamp);
Notice this doesn't have the * 1000
at the end of new Date(timestamp)
statement as this (for me anyway!) always seems to give out the wrong date, ie instead of giving the year 2019 it gives the year as 51015, so just bear that in mind.
Source: Stackoverflow.com