Кто-нибудь может связать меня с каким-то учебником, где я могу узнать, как возвращать дни, часы, минуты, секунды в javascript между двумя временными интервалами unix?
У меня есть:
var date_now = unixtimestamp;
var date_future = unixtimestamp;
Я хотел бы вернуться (жить), сколько дней, часов, минут, секунд осталось от date_now до date_future.
Просто выясните разницу в секундах (не забывайте, что временные метки JS фактически измеряются в миллисекундах) и разложите это значение:
// get total seconds between the times
var delta = Math.abs(date_future - date_now) / 1000;
// calculate (and subtract) whole days
var days = Math.floor(delta / 86400);
delta -= days * 86400;
// calculate (and subtract) whole hours
var hours = Math.floor(delta / 3600) % 24;
delta -= hours * 3600;
// calculate (and subtract) whole minutes
var minutes = Math.floor(delta / 60) % 60;
delta -= minutes * 60;
// what left is seconds
var seconds = delta % 60; // in theory the modulus is not required
EDIT скорректирован, потому что я только понял, что исходный код вернул общее количество часов и т.д., а не количество часов, оставшихся после подсчета целых дней.
Здесь, в javascript: (Например, будущая дата - Новый год)
DEMO (обновляется каждую секунду)
var dateFuture = new Date(new Date().getFullYear() +1, 0, 1);
var dateNow = new Date();
var seconds = Math.floor((dateFuture - (dateNow))/1000);
var minutes = Math.floor(seconds/60);
var hours = Math.floor(minutes/60);
var days = Math.floor(hours/24);
hours = hours-(days*24);
minutes = minutes-(days*24*60)-(hours*60);
seconds = seconds-(days*24*60*60)-(hours*60*60)-(minutes*60);
Я называю это "методом снеговика-карла" и считаю его более гибким, когда вам нужны дополнительные временные интервалы, такие как недели, месяцы, годы, столетия... и не нужно слишком много повторяющегося кода:
var d = Math.abs(date_future - date_now) / 1000; // delta
var r = {}; // result
var s = { // structure
year: 31536000,
month: 2592000,
week: 604800, // uncomment row to ignore
day: 86400, // feel free to add your own row
hour: 3600,
minute: 60,
second: 1
};
Object.keys(s).forEach(function(key){
r[key] = Math.floor(d / s[key]);
d -= r[key] * s[key];
});
// for example: {year:0,month:0,week:1,day:2,hour:34,minute:56,second:7}
console.log(r);
Есть FIDDLE/ES6 Version (2018)/TypeScript Version (2019)
Вдохновлен ответом Альнитак.
Обратите внимание, что вычисление только на основе различий не распространяется на все случаи: високосные годы и переход на "летнее время".
Javascript имеет плохую встроенную библиотеку для работы с датами. Я предлагаю вам использовать стороннюю библиотеку javascript, например. MomentJS; вы можете увидеть здесь функцию, которую вы искали.
Лучшая библиотека, которую я знаю для разрыва продолжительности, countdown.js. Он обрабатывает все жесткие случаи, такие как високосные годы и летнее время, как csg, упомянутые, и даже позволяет указывать нечеткие понятия, такие как месяцы и недели. Вот код для вашего дела:
//assuming these are in *seconds* (in case of MS don't multiply by 1000 below)
var date_now = 1218374;
var date_future = 29384744;
diff = countdown(date_now * 1000, date_future * 1000,
countdown.DAYS | countdown.HOURS | countdown.MINUTES | countdown.SECONDS);
alert("days: " + diff.days + " hours: " + diff.hours +
" minutes: " + diff.minutes + " seconds: " + diff.seconds);
//or even better
alert(diff.toString());
Здесь JSFiddle, но он, вероятно, будет работать только в FireFox или в Chrome с отключенной веб-безопасностью, поскольку countdown.js размещенный с текстовым/равным MIME-типом (вы должны обслуживать файл, а не ссылку на countdownjs.org).
function update(datetime = "2017-01-01 05:11:58") {
var theevent = new Date(datetime);
now = new Date();
var sec_num = (theevent - now) / 1000;
var days = Math.floor(sec_num / (3600 * 24));
var hours = Math.floor((sec_num - (days * (3600 * 24)))/3600);
var minutes = Math.floor((sec_num - (days * (3600 * 24)) - (hours * 3600)) / 60);
var seconds = Math.floor(sec_num - (days * (3600 * 24)) - (hours * 3600) - (minutes * 60));
if (hours < 10) {hours = "0"+hours;}
if (minutes < 10) {minutes = "0"+minutes;}
if (seconds < 10) {seconds = "0"+seconds;}
return days+':'+ hours+':'+minutes+':'+seconds;
}
Вот пример кода. Я использовал простые вычисления вместо использования предварительных вычислений, например, 1 день - 86400 секунд. Таким образом, вы можете легко следовать логике.
// Calculate time between two dates:
var date1 = new Date('1110-01-01 11:10');
var date2 = new Date();
console.log('difference in ms', date1 - date2);
// Use Math.abs() so the order of the dates can be ignored and you won't
// end up with negative numbers when date1 is before date2.
console.log('difference in ms abs', Math.abs(date1 - date2));
console.log('difference in seconds', Math.abs(date1 - date2) / 1000);
var diffInSeconds = Math.abs(date1 - date2) / 1000;
var days = Math.floor(diffInSeconds / 60 / 60 / 24);
var hours = Math.floor(diffInSeconds / 60 / 60 % 24);
var minutes = Math.floor(diffInSeconds / 60 % 60);
var seconds = Math.floor(diffInSeconds % 60);
var milliseconds = Math.round((diffInSeconds - Math.floor(diffInSeconds)) * 1000);
console.log('days', days);
console.log('hours', ('0' + hours).slice(-2));
console.log('minutes', ('0' + minutes).slice(-2));
console.log('seconds', ('0' + seconds).slice(-2));
console.log('milliseconds', ('00' + milliseconds).slice(-3));
Используйте библиотеку moment.js, например:
var time = date_future - date_now;
var seconds = moment.duration(time).seconds();
var minutes = moment.duration(time).minutes();
var hours = moment.duration(time).hours();
var days = moment.duration(time).days();
вот код, чтобы найти разницу между двумя датами в днях, часах, минутах, секундах (предполагая, что будущая дата - дата нового года).
var one_day = 24*60*60*1000; // total milliseconds in one day
var today = new Date();
var new_year = new Date("01/01/2017"); // future date
var today_time = today.getTime(); // time in miliiseconds
var new_year_time = new_year.getTime();
var time_diff = Math.abs(new_year_time - today_time); //time diff in ms
var days = Math.floor(time_diff / one_day); // no of days
var remaining_time = time_diff - (days*one_day); // remaining ms
var hours = Math.floor(remaining_time/(60*60*1000));
remaining_time = remaining_time - (hours*60*60*1000);
var minutes = Math.floor(remaining_time/(60*1000));
remaining_time = remaining_time - (minutes * 60 * 1000);
var seconds = Math.ceil(remaining_time / 1000);
let delta = Math.floor(Math.abs(start.getTime() - end.getTime()) / 1000);
let hours = Math.floor(delta / 3600);
delta -= hours * 3600;
let minutes = Math.floor(delta / 60);
delta -= minutes * 60;
let seconds = delta;
if (hours.toString().length === 1) {
hours = '0${hours}';
}
if (minutes.toString().length === 1) {
minutes = '0${minutes}';
}
if (seconds.toString().length === 1) {
seconds = '0${seconds}';
}
const recordingTime = '${hours}:${minutes}:${seconds}';
Короткий и гибкий с поддержкой отрицательных значений, хотя с использованием двух запятых выражений :)
function timeUnitsBetween(startDate, endDate) {
let delta = Math.abs(endDate - startDate) / 1000;
const isNegative = startDate > endDate ? -1 : 1;
return [
['days', 24 * 60 * 60],
['hours', 60 * 60],
['minutes', 60],
['seconds', 1]
].reduce((acc, [key, value]) => (acc[key] = Math.floor(delta / value) * isNegative, delta -= acc[key] * isNegative * value, acc), {});
}
Пример:
timeUnitsBetween(new Date("2019-02-11T02:12:03+00:00"), new Date("2019-02-11T01:00:00+00:00"));
// { days: -0, hours: -1, minutes: -12, seconds: -3 }
Вдохновленный решением RienNeVaPlu.
MomentJS имеет функцию для этого:
const start = moment(j.timings.start);
const end = moment(j.timings.end);
const elapsedMinutes = end.diff(start, "minutes");
мое решение не так ясно, как это, но я приведу его в качестве другого примера
console.log(duration('2019-07-17T18:35:25.235Z', '2019-07-20T00:37:28.839Z'));
function duration(t0, t1){
let d = (new Date(t1)) - (new Date(t0));
let weekdays = Math.floor(d/1000/60/60/24/7);
let days = Math.floor(d/1000/60/60/24 - weekdays*7);
let hours = Math.floor(d/1000/60/60 - weekdays*7*24 - days*24);
let minutes = Math.floor(d/1000/60 - weekdays*7*24*60 - days*24*60 - hours*60);
let seconds = Math.floor(d/1000 - weekdays*7*24*60*60 - days*24*60*60 - hours*60*60 - minutes*60);
let milliseconds = Math.floor(d - weekdays*7*24*60*60*1000 - days*24*60*60*1000 - hours*60*60*1000 - minutes*60*1000 - seconds*1000);
let t = {};
['weekdays', 'days', 'hours', 'minutes', 'seconds', 'milliseconds'].forEach(q=>{ if (eval(q)>0) { t[q] = eval(q); } });
return t;
}