Obter a diferença horária entre duas vezes

Eu sei que posso fazer qualquer coisa e mais algumas datas envolventes com momentjs. Mas, embaraçosamente, estou tendo dificuldade em tentar fazer algo que parece simples: conseguir a diferença entre duas vezes.

Exemplo:

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

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

o que eu tentei:

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  

Eu não entendo o que é esse "10" lá. Eu moro no Brasil, então somos utc-0300, se isso for relevante.

O resultado de moment.duration(now.diff(then))é uma duração com os valores internos corretos:

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

Então, acho que minha pergunta é: como converter um momentjs Duration em um intervalo de tempo? Eu com certeza posso usar

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

mas sinto que há algo mais elegante que estou sentindo falta completamente.

atualização
olhando mais de perto, no exemplo acima nowé:

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

e moment(moment.duration(now.diff(then)))é:

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

Não sei por que o segundo valor está no horário de verão (-0200) ... mas tenho certeza de que não gosto de datas :(

atualização 2

bem, o valor é -0200 provavelmente porque 31/12/1969 era uma data em que o horário de verão estava sendo usado ... então é isso.

Essa abordagem funcionará APENAS quando a duração total for inferior a 24 horas:

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 você tiver 24 horas ou mais, as horas serão redefinidas para zero com a abordagem acima, portanto, não é o ideal.

Se você deseja obter uma resposta válida por períodos de 24 horas ou mais, precisará fazer algo assim:

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"

Observe que estou usando o tempo utc como um atalho. Você poderia puxar para fora d.minutes()e d.seconds()separadamente, mas também teria que zerá-los.

Isso é necessário porque a capacidade de formatar uma durationobjeção não está atualmente no moment.js. Foi solicitado aqui . No entanto, existe um plug-in de terceiros chamado momento-duração-formato, especificamente para esse fim:

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"

Seu problema é passar o resultado de moment.duration () de volta para moment () antes de formatá-lo; isso resulta em moment () interpretando-o como um tempo relativo à época do Unix.

Não fornece exatamente o formato que você está procurando, mas

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

daria a você um formato útil como "40 minutos". Se você realmente gosta dessa formatação específica, precisará criar uma nova string. Uma maneira barata seria

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

onde var diff = moment.duration(now.diff(then)). Isso não fornece o preenchimento zero nos valores de um dígito. Para isso, você pode considerar algo como underscore.string - embora pareça um longo caminho a percorrer apenas para alguns zeros extras. :)

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

Trabalhou para mim

Veja mais em http://momentjs.com/docs/#/displaying/difference/

Se você quiser diferença de dois registros de data e hora no total de dias, horas e minutos, não em meses e anos.

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 contém 2 meses, 23 dias, 23 horas e 20 minutos. Mas precisamos de resultados apenas em dias, horas e minutos, para que a solução simples seja:

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.

O resultado final será: 84 dias, 23 horas, 20 minutos.

Quando você liga diff, o moment.js calcula a diferença em milissegundos. Se os milissegundos forem passados ​​para duration, eles serão usados ​​para calcular a duração correta. Contudo. quando você passa os mesmos milissegundos para moment(), ele calcula a data em milissegundos da (após) época / época unix que é 1º de janeiro de 1970 (meia-noite UTC / GMT). É por isso que você começa 1969 como o ano junto com a hora errada.

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

Então, acho que é assim que você deve fazer, já que o moment.js não oferece formatfunção para duração. Ou você pode escrever um invólucro simples para torná-lo mais fácil / mais bonito.

Isso deve funcionar bem.

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 queremos apenas hh: mm: ss, podemos usar uma função como essa:

//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 isto,

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

    var aa = duration.asHours();

Ao invés de

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

É melhor fazer

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

No ES8, use moment, now e comece a ser objetos 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');

Texto datilografado: a seguir deve funcionar,

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

Eu crio uma função simples com texto datilografado

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)

para gerar 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);
    }

DATA HORÁRIO DE ENTRADA

    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
    }

RESULTADO

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

DIFERENÇA DE TEMPO ÉPOCA USANDO MOMENTOSJS :

Para obter a diferença entre dois tempos da época:

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

Diferença em Horas: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asHours()

Diferença em minutos: moment.duration(moment(moment(1590597744551).diff(moment(1590597909877)))).asMinutes().toFixed()

Nota: você pode remover.toFixed() se precisar de valores precisos.

Código:

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

Consulte o exemplo de trabalho aqui: https://repl.it/repls/MoccasinDearDimension