web-dev-qa-db-fra.com

Javascript retour nombre de jours, heures, minutes, secondes entre deux dates

Est-ce que n'importe qui peut me relier à un tutoriel où je peux trouver comment retourner des jours, des heures, des minutes, des secondes en javascript entre 2 heures-temps unix?

J'ai:

var date_now = unixtimestamp;
var date_future = unixtimestamp;

J'aimerais revenir combien il reste de jours, d’heures, de minutes et de secondes entre date_now et date_future.

javascriptdatetime
41
itsme

Déterminez simplement la différence en secondes (n'oubliez pas que les horodatages JS sont réellement mesurés en millisecondes) et décomposez cette valeur:

// 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's left is seconds
var seconds = delta % 60;  // in theory the modulus is not required

EDITcode ajusté parce que je viens de me rendre compte que le code original renvoyait le nombre total d’heures, etc., et non le nombre d’heures restantes après le comptage des jours entiers.

123
Alnitak

Voici en javascript: (Par exemple, la date future est le jour de l'an)

DÉMO (mises à jour toutes les secondes)

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);
24
jackcogdill

Veuillez noter que le calcul basé uniquement sur les différences ne couvrira pas tous les cas: années bissextiles et commutation de "l'heure d'été".

Javascript a une médiathèque intégrée pour travailler avec les dates. Je vous suggère d'utiliser une bibliothèque javascript tierce, par exemple. MomentJS ; vous pouvez voir ici la fonction que vous recherchiez.

8
csg

La meilleure bibliothèque que je connaisse pour la décomposition de la durée est countdown.js . Il gère tous les cas difficiles tels que les années bissextiles et l'heure d'été comme indiqué par csg , et vous permet même de spécifier des concepts flous tels que des mois et des semaines. Voici le code pour votre cas:

//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());

Voici un JSFiddle , mais cela ne fonctionnerait probablement que dans FireFox ou dans Chrome avec la sécurité Web désactivée, puisque countdown.js est hébergé avec un type MIME text/plain (vous êtes censé servir le fichier , pas de lien vers countdownjs.org).

3
Ohad Schneider

Voici un exemple de code. J'ai utilisé des calculs simples au lieu d'utiliser des précalculs comme 1 jour correspond à 86400 secondes. Ainsi, vous pouvez suivre la logique avec facilité.

// 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));
1
R..
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
M Arfan

Utilisez la bibliothèque moment.js, par exemple:

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();
1
ns16

Court et flexible avec prise en charge des valeurs négatives, bien qu'en utilisant deux expressions de virgule :)

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), {});
}

Exemple:

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 }

Inspiré par RienNeVaPlu͢s solution.

0
icl7126
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}`;
0
Supun Madushanka

voici un code pour trouver la différence entre deux dates en jours, heures, minutes et secondes (en supposant que la date future est la date du nouvel an).

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);
0
Umang Patel

MomentJS a une fonction pour le faire:

const start = moment(j.timings.start);
const end = moment(j.timings.end);
const elapsedMinutes = end.diff(start, "minutes");
0
Bonomi