Ottieni la differenza di tempo tra due orari

So di poter fare qualsiasi cosa e alcune date più coinvolgenti con momentjs. Ma imbarazzante, sto facendo fatica a provare a fare qualcosa che sembra semplice: ottenere la differenza tra 2 volte.

Esempio:

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

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

cosa ho provato:

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  

Non capisco cosa sia quel "10" lì. Vivo in Brasile, quindi siamo utc-0300 se questo è rilevante.

Il risultato di moment.duration(now.diff(then))è una durata con i valori interni corretti:

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

Quindi, suppongo che la mia domanda sia: come convertire una durata momentjs in un intervallo di tempo? Sono sicuro che posso usare

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

ma sento che c'è qualcosa di più elegante che mi manca completamente.

aggiornamento
guardando più da vicino, nell'esempio sopra nowè:

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

ed moment(moment.duration(now.diff(then)))è:

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

Non sono sicuro del perché il secondo valore sia in Ora legale (-0200) ... ma sono sicuro che non mi piacciono le date :(

aggiornamento 2

bene, il valore è -0200 probabilmente perché il 31/12/1969 era una data in cui veniva utilizzata l'ora legale ... quindi è così.

Questo approccio funzionerà SOLO quando la durata totale è inferiore a 24 ore:

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"

Se hai 24 ore o più, le ore si resetteranno a zero con l'approccio sopra, quindi non è l'ideale.

Se vuoi ottenere una risposta valida per durate di 24 ore o più, dovrai invece fare qualcosa del genere:

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"

Nota che sto usando utc time come scorciatoia. Potresti estrarre d.minutes()e d.seconds()separatamente, ma dovresti anche zeropad.

Ciò è necessario perché la capacità di formattare durationun'obiezione non è attualmente in moment.js. È stato richiesto qui . Tuttavia, esiste un plug-in di terze parti chiamato formato di durata del momento specifico per questo scopo:

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"

Il tuo problema è nel passare il risultato di moment.duration () in moment () prima di formattarlo; ciò si traduce in moment () interpretandolo come un tempo relativo all'epoca di Unix.

Non ti dà esattamente il formato che stai cercando, ma

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

ti darebbe un formato utile come "40 minuti". Se sei davvero appassionato di quella specifica formattazione, dovrai costruire tu stesso una nuova stringa. Un modo economico sarebbe

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

dove var diff = moment.duration(now.diff(then)). Questo non ti dà lo zero padding su valori a cifra singola. Per questo, potresti voler prendere in considerazione qualcosa come underscore.string , anche se sembra una lunga strada da percorrere solo per qualche zero in più. :)

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

Ha funzionato per me

Scopri di più su http://momentjs.com/docs/#/displaying/difference/

Se si desidera la differenza di due timestamp in giorni, ore e minuti totali, non in mesi e anni.

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 contiene 2 mesi, 23 giorni, 23 ore e 20 minuti. Ma abbiamo bisogno di risultati solo in giorni, ore e minuti, quindi la soluzione semplice è:

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.

Il risultato finale sarà: 84 giorni, 23 ore, 20 minuti.

Quando chiami diff, moment.js calcola la differenza in millisecondi. Se i millisecondi vengono passati a duration, viene utilizzato per calcolare la durata che è corretta. Però. quando passi gli stessi millisecondi a moment(), calcola la data che è millisecondi dall'ora (successiva) di epoca / unix che è il 1 gennaio 1970 (mezzanotte UTC / GMT). Questo è il motivo per cui ottieni il 1969 come l'anno insieme all'ora sbagliata.

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

Quindi, penso che sia così che dovresti farlo poiché moment.js non offre formatfunzioni per la durata. Oppure puoi scrivere un semplice wrapper per renderlo più facile / più bello.

Questo dovrebbe funzionare bene.

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

Se vogliamo solo hh: mm: ss, possiamo usare una funzione del genere:

//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;
}

Usa questo,

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

    var aa = duration.asHours();

Invece di

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

È meglio da fare

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

In ES8 usando moment, now e inizia ad essere oggetti 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');

Dattiloscritto: il seguente dovrebbe funzionare,

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;
};

Creo una semplice funzione con dattiloscritto

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)

per generare 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);
    }

INGRESSO BASATO SUL TEMPO DATA

    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
    }

PRODUZIONE

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

DIFFERENZA DEL TEMPO EPOCH UTILIZZANDO MOMENTJS :

Per ottenere la differenza tra due tempi:

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

Differenza in ore: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asHours()

Differenza in minuti: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asMinutes().toFixed()

Nota: è possibile rimuovere .toFixed()se sono necessari valori precisi.

Codice:

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')

Fare riferimento all'esempio di lavoro qui: https://repl.it/repls/MoccasinDearDimension