Obtenez le décalage horaire entre deux heures

Je sais que je peux faire n'importe quoi et quelques dates plus envoûtantes avec momentjs. Mais embarrassant, j'ai du mal à essayer de faire quelque chose qui semble simple: faire la différence entre 2 fois.

Exemple:

var now  = "04/09/2013 15:00:00";
var then = "04/09/2013 14:20:30";

//expected result:
"00:39:30"

ce que j'ai essayé:

var now = moment("04/09/2013 15:00:00");
var then = moment("04/09/2013 14:20:30");

console.log(moment(moment.duration(now.diff(then))).format("hh:mm:ss"))
//outputs 10:39:30  

Je ne comprends pas ce que c'est que "10" là-bas. J'habite au Brésil, nous sommes donc utc-0300 si cela est pertinent.

Le résultat de moment.duration(now.diff(then))est une durée avec les valeurs internes correctes:

 days: 0
 hours: 0
 milliseconds: 0
 minutes: 39
 months: 0
 seconds: 30
 years: 0

Donc, je suppose que ma question est: comment convertir une durée momentjs en un intervalle de temps? Je peux certainement utiliser

duration.get("hours") +":"+ duration.get("minutes") +:+ duration.get("seconds")

mais je sens qu'il y a quelque chose de plus élégant qui me manque complètement.

mise
à jour en regardant de plus près, dans l'exemple ci-dessus nowest:

Tue Apr 09 2013 15:00:00 GMT-0300 (E. South America Standard Time)…}

et moment(moment.duration(now.diff(then)))c'est:

Wed Dec 31 1969 22:39:30 GMT-0200 (E. South America Daylight Time)…}

Je ne sais pas pourquoi la deuxième valeur est en heure d'été (-0200) ... mais je suis sûr que je n'aime pas les dates :(

mise à jour 2

eh bien, la valeur est -0200 probablement parce que le 31/12/1969 était une date où l'heure d'été était utilisée ... c'est donc ça.

Cette approche fonctionnera UNIQUEMENT lorsque la durée totale est inférieure à 24 heures:

var now  = "04/09/2013 15:00:00";
var then = "04/09/2013 14:20:30";

moment.utc(moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"))).format("HH:mm:ss")

// outputs: "00:39:30"

Si vous avez 24 heures ou plus, les heures seront remises à zéro avec l'approche ci-dessus, donc ce n'est pas idéal.

Si vous souhaitez obtenir une réponse valide pour des durées de 24 heures ou plus, vous devrez alors faire quelque chose comme ceci:

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);
var s = Math.floor(d.asHours()) + moment.utc(ms).format(":mm:ss");

// outputs: "48:39:30"

Notez que j'utilise le temps utc comme raccourci. Vous pourriez vous retirer d.minutes()etd.seconds() séparer, mais vous devrez également les zéros.

Cela est nécessaire car la possibilité de formater une durationobjection n'est pas actuellement dans moment.js. Il a été demandé ici . Cependant, il existe un plugin tiers appelé moment-duration-format qui est spécifiquement conçu à cet effet:

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);
var s = d.format("hh:mm:ss");

// outputs: "48:39:30"

Votre problème consiste à transmettre le résultat de moment.duration () à moment () avant de le formater; il en résulte que moment () l'interprète comme un temps par rapport à l'époque Unix.

Il ne vous donne pas exactement le format que vous recherchez, mais

moment.duration(now.diff(then)).humanize()

vous donnerait un format utile comme "40 minutes". Si vous aimez vraiment cette mise en forme spécifique, vous devrez créer vous-même une nouvelle chaîne. Un moyen bon marché serait

[diff.asHours(), diff.minutes(), diff.seconds()].join(':')

où var diff = moment.duration(now.diff(then)). Cela ne vous donne pas le zéro pour les valeurs à un chiffre. Pour cela, vous voudrez peut-être envisager quelque chose comme underscore.string - bien que cela semble être un long chemin à parcourir juste pour quelques zéros supplémentaires. :)

var a = moment([2007, 0, 29]);
var b = moment([2007, 0, 28]);
a.diff(b, 'days') //[days, years, months, seconds, ...]
//Result 1 

Travaillé pour moi

Voir plus dans http://momentjs.com/docs/#/displaying/difference/

Si vous voulez une différence de deux horodatages en jours, heures et minutes uniquement, pas en mois ni en années.

var now  = "01/08/2016 15:00:00";
var then = "04/02/2016 14:20:30";
var diff = moment.duration(moment(then).diff(moment(now)));

diff contient 2 mois, 23 jours, 23 heures et 20 minutes. Mais nous avons besoin de résultats uniquement en jours, heures et minutes, donc la solution simple est:

var days = parseInt(diff.asDays()); //84

var hours = parseInt(diff.asHours()); //2039 hours, but it gives total hours in given miliseconds which is not expacted.

hours = hours - days*24;  // 23 hours

var minutes = parseInt(diff.asMinutes()); //122360 minutes,but it gives total minutes in given miliseconds which is not expacted.

minutes = minutes - (days*24*60 + hours*60); //20 minutes.

Le résultat final sera: 84 jours, 23 heures, 20 minutes.

Lorsque vous appelez diff, moment.js calcule la différence en millisecondes. Si les millisecondes sont passées à duration, il est utilisé pour calculer la durée qui est correcte. Toutefois. lorsque vous passez les mêmes millisecondes au moment(), il calcule la date qui est en millisecondes à partir de (après) l'heure epoch / unix qui est le 1er janvier 1970 (minuit UTC / GMT). C'est pourquoi vous obtenez 1969 comme l'année avec la mauvaise heure.

duration.get("hours") +":"+ duration.get("minutes") +":"+ duration.get("seconds")

Donc, je pense que c'est comme ça que vous devriez le faire car moment.js n'offre pas de formatfonction pour la durée. Ou vous pouvez écrire un simple wrapper pour le rendre plus facile / plus joli.

Cela devrait bien fonctionner.

var now  = "04/09/2013 15:00:00";
var then = "02/09/2013 14:20:30";

var ms = moment(now,"DD/MM/YYYY HH:mm:ss").diff(moment(then,"DD/MM/YYYY HH:mm:ss"));
var d = moment.duration(ms);

console.log(d.days(), d.hours(), d.minutes(), d.seconds());

Si nous voulons seulement hh: mm: ss, nous pouvons utiliser une fonction comme celle-ci:

//param: duration in milliseconds
MillisecondsToTime: function(duration) {
    var seconds = parseInt((duration/1000)%60)
        , minutes = parseInt((duration/(1000*60))%60)
        , hours = parseInt((duration/(1000*60*60))%24)
        , days  = parseInt(duration/(1000*60*60*24));

    var hoursDays = parseInt(days*24);
    hours += hoursDays;
    hours = (hours < 10) ? "0" + hours : hours;
    minutes = (minutes < 10) ? "0" + minutes : minutes;
    seconds = (seconds < 10) ? "0" + seconds : seconds;
    return hours + ":" + minutes + ":" + seconds;
}

Utilisez ceci,

  var duration = moment.duration(endDate.diff(startDate));

    var aa = duration.asHours();

Au lieu de

Math.floor(duration.asHours()) + moment.utc(duration.asMilliseconds()).format(":mm:ss")

Il vaut mieux faire

moment.utc(total.asMilliseconds()).format("HH:mm:ss");

Dans ES8, utilisez moment, now et commencez à être des objets moment.

const duration = moment.duration(now.diff(start));
const timespan = duration.get("hours").toString().padStart(2, '0') +":"+ duration.get("minutes").toString().padStart(2, '0') +":"+ duration.get("seconds").toString().padStart(2, '0');

Typographie: ce qui suit devrait fonctionner,

export const getTimeBetweenDates = ({
  until,
  format
}: {
  until: number;
  format: 'seconds' | 'minutes' | 'hours' | 'days';
}): number => {
  const date = new Date();
  const remainingTime = new Date(until * 1000);
  const getFrom = moment([date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()]);
  const getUntil = moment([remainingTime.getUTCFullYear(), remainingTime.getUTCMonth(), remainingTime.getUTCDate()]);
  const diff = getUntil.diff(getFrom, format);
  return !isNaN(diff) ? diff : null;
};

Je crée une fonction simple avec tapuscrit

const diffDuration: moment.Duration = moment.duration(moment('2017-09-04 12:55').diff(moment('2017-09-02 13:26')));
setDiffTimeString(diffDuration);

function setDiffTimeString(diffDuration: moment.Duration) {
  const str = [];
  diffDuration.years() > 0 ? str.push(`${diffDuration.years()} year(s)`) : null;
  diffDuration.months() > 0 ? str.push(`${diffDuration.months()} month(s)`) : null;
  diffDuration.days() > 0 ? str.push(`${diffDuration.days()} day(s)`) : null;
  diffDuration.hours() > 0 ? str.push(`${diffDuration.hours()} hour(s)`) : null;
  diffDuration.minutes() > 0 ? str.push(`${diffDuration.minutes()} minute(s)`) : null;
  console.log(str.join(', '));
} 
// output: 1 day(s), 23 hour(s), 29 minute(s)

pour générer javascript https://www.typescriptlang.org/play/index.html

InTime = 06: 38, Outtime = 15: 40

 calTimeDifference(){
        this.start = dailyattendance.InTime.split(":");
        this.end = dailyattendance.OutTime.split(":");
        var time1 = ((parseInt(this.start[0]) * 60) + parseInt(this.start[1]))
        var time2 = ((parseInt(this.end[0]) * 60) + parseInt(this.end[1]));
        var time3 = ((time2 - time1) / 60);
        var timeHr = parseInt(""+time3);
        var  timeMin = ((time2 - time1) % 60);
    }

ENTRÉE BASÉE SUR L'HEURE ET LA DATE

    var dt1 = new Date("2019-1-8 11:19:16");
    var dt2 = new Date("2019-1-8 11:24:16");


    var diff =(dt2.getTime() - dt1.getTime()) ;
    var hours = Math.floor(diff / (1000 * 60 * 60));
    diff -= hours * (1000 * 60 * 60);
    var mins = Math.floor(diff / (1000 * 60));
    diff -= mins * (1000 * 60);


    var response = {
        status : 200,
        Hour : hours,
        Mins : mins
    }

PRODUCTION

{
"status": 200,
"Hour": 0,
"Mins": 5
}

DIFFÉRENCE DE TEMPS EPOCH À L'AIDE DE MOMENTJS :

Pour obtenir la différence entre deux époques:

Syntaxe: moment.duration(moment(moment(date1).diff(moment(date2)))).asHours()

Différence d'heures: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asHours()

Différence en minutes: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asMinutes().toFixed()

Remarque: Vous pouvez supprimer .toFixed()si vous avez besoin de valeurs précises.

Code:

const moment = require('moment')

console.log('Date 1',moment(1590597909877).toISOString())
console.log('Date 2',moment(1590597744551).toISOString())
console.log('Date1 - Date 2 time diffrence is : ',moment.duration(moment(moment(1590597909877).diff(moment(1590597744551)))).asMinutes().toFixed()+' minutes')

Reportez-vous à l'exemple de travail ici: https://repl.it/repls/MoccasinDearDimension