Existe alguma maneira de usar o método moment.js format em objetos de duração? Não consigo encontrá-lo em nenhum lugar nos documentos e não parece ser um atributo nos objetos de duração.

Eu gostaria de poder fazer algo como:

var diff = moment(end).unix() - moment(start).unix();
moment.duration(diff).format('hh:mm:ss')

Além disso, se houver outras bibliotecas que possam acomodar facilmente esse tipo de funcionalidade, eu estaria interessado em recomendações.

Obrigado!

Estamos pensando em adicionar algum tipo de formatação às durações no momento.js. Consulte https://github.com/timrwood/moment/issues/463

Algumas outras bibliotecas que podem ajudar são http://countdownjs.org/ e https://github.com/icambron/twix.js

// set up
let start = moment("2018-05-16 12:00:00"); // some random moment in time (in ms)
let end = moment("2018-05-16 12:22:00"); // some random moment after start (in ms)
let diff = end.diff(start);

// execution
let f = moment.utc(diff).format("HH:mm:ss.SSS");
alert(f);

Dê uma olhada no JSFiddle

converta a duração para ms e depois para o momento:

moment.utc(duration.as('milliseconds')).format('HH:mm:ss')

Use este plug-in Moment Duration Format .

Exemplo:

moment.duration(123, "minutes").format("h:mm");

Use esta linha de código:

moment.utc(moment.duration(4500, "seconds").asMilliseconds()).format("HH:mm:ss")

var diff = moment(end).unix() - moment(start).unix();
moment.utc(moment.duration(diff).asMilliseconds()).format("HH:mm:ss.SSS");

O melhor cenário para meu caso de uso específico foi:

var duration = moment.duration("09:30"),
    formatted = moment.utc(duration.asMilliseconds()).format("HH:mm");

Isso melhora a resposta de @ Wilson, pois não acessa a propriedade interna privada _data.

Você não precisa do formato. Use durações como esta:

const duration = moment.duration(83, 'seconds');
console.log(duration.minutes() + ':' +duration.seconds());
// output: 1:23

Encontrei esta solução aqui: https://github.com/moment/moment/issues/463

EDITAR:

E com preenchimento por segundos, minutos e horas:

const withPadding = (duration) => {
    if (duration.asDays() > 0) {
        return 'at least one day';
    } else {
        return [
            ('0' + duration.hours()).slice(-2),
            ('0' + duration.minutes()).slice(-2),
            ('0' + duration.seconds()).slice(-2),
        ].join(':')
    }
}

withPadding(moment.duration(83, 'seconds'))
// 00:01:23

withPadding(moment.duration(6048000, 'seconds'))
// at least one day

Eu uso:

var duration = moment.duration("09:30");
var str = moment(duration._data).format("HH:mm");

E eu recebo "09:30" em var str.

se diff é um momento

var diff = moment(20111031) - moment(20111010);
var formated1 = moment(diff).format("hh:mm:ss");
console.log("format 1: "+formated1);

Se você deseja usar uma biblioteca javascript diferente, o numeral.js pode formatar segundos da seguinte maneira (o exemplo é por 1000 segundos):

var string = numeral(1000).format('00:00');
// '00:16:40'

Eu uso a função de formato clássico nesses casos:

var diff = moment(end).unix() - moment(start).unix();

//use unix function instead of difference
moment.unix(diff).format('hh:mm:ss')

Isso é um hack, porque a diferença de horário é tratada como uma data de momento padrão, uma data de época inicial, mas isso não importa para o nosso objetivo e você não precisa de nenhum plugin

Se todas as horas tiverem que ser exibidas (mais de 24) e se '0' antes das horas não for necessário, a formatação poderá ser feita com uma pequena linha de código:

Math.floor(duration.as('h')) + moment.utc(duration.as('ms')).format(':mm:ss')

Com base na resposta de ni-ko-o-kin :

meassurements = ["years", "months", "weeks", "days", "hours", "minutes", "seconds"];
withPadding = (duration) => {
    var step = null;
    return meassurements.map((m) => duration[m]()).filter((n,i,a) => {
        var nonEmpty = Boolean(n);
        if (nonEmpty || step || i >= a.length - 2) {
            step = true;
        }
        return step;
    }).map((n) => ('0' + n).slice(-2)).join(':')
}

duration1 = moment.duration(1, 'seconds');
duration2 = moment.duration(7200, 'seconds');
duration3 = moment.duration(604800, 'seconds');

withPadding(duration1); // 00:01
withPadding(duration2); // 02:00:00
withPadding(duration3); // 01:07:00:00:00

Para formatar a duração do momento para string

var duration = moment.duration(86400000); //value in milliseconds
var hours = duration.hours();
var minutes = duration.minutes();
var seconds = duration.seconds();
var milliseconds = duration.milliseconds();

var date = moment().hours(hours).minutes(minutes).seconds(seconds).millisecond(milliseconds);
if (is12hr){
    return date.format("hh:mm:ss a");
}else{
    return date.format("HH:mm:ss");
}

se você usa angular, adicione isso aos seus filtros:

.filter('durationFormat', function () {
    return function (value) {
        var days = Math.floor(value/86400000);
        value = value%86400000;
        var hours = Math.floor(value/3600000);
        value = value%3600000;
        var minutes = Math.floor(value/60000);
        value = value%60000;
        var seconds = Math.floor(value/1000);
        return (days? days + ' days ': '') + (hours? hours + ' hours ': '') + (minutes? minutes + ' minutes ': '') + (seconds? seconds + ' seconds ': '')
    }
})

exemplo de uso

<div> {{diff | durationFormat}} </div>

Minha solução que não envolve nenhuma outra biblioteca e funciona com diff> 24h

var momentInSeconds = moment.duration(n,'seconds')
console.log(("0" + Math.floor(momentInSeconds.asHours())).slice(-2) + ':' + ("0" + momentInSeconds.minutes()).slice(-2) + ':' + ("0" + momentInSeconds.seconds()).slice(-2))

E o javascript nativo?

var formatTime = function(integer) {
    if(integer < 10) {
        return "0" + integer; 
    } else {
        return integer;
    }
}

function getDuration(ms) {
    var s1 = Math.floor(ms/1000);
    var s2 = s1%60;
    var m1 = Math.floor(s1/60);
    var m2 = m1%60;
    var h1 = Math.floor(m1/60);
    var string = formatTime(h1) +":" + formatTime(m2) + ":" + formatTime(s2);
    return string;
}

Use o formato momento-duração .

Estrutura do Cliente (ex: React)

import moment from 'moment';
import momentDurationFormatSetup from 'moment-duration-format';
momentDurationFormatSetup(moment);

const breakLengthInMinutes = moment.duration(breakLengthInSeconds, 's').format('m');

Servidor (node.js)

const moment = require("moment-timezone");
const momentDurationFormatSetup = require("moment-duration-format");

momentDurationFormatSetup(moment);

const breakLengthInMinutes = moment.duration(breakLengthInSeconds, 's').format('m');

const duration = moment.duration(62, 'hours');
const n = 24 * 60 * 60 * 1000;
const days = Math.floor(duration / n);
const str = moment.utc(duration % n).format('H [h] mm [min] ss [s]');
console.log(`${days > 0 ? `${days} ${days == 1 ? 'day' : 'days'} ` : ''}${str}`);

Impressões:

2 dias 14 h 00 min 00 s

import * as moment from 'moment'
var sleep = require('sleep-promise');

(async function () {
    var t1 = new Date().getTime();
    await sleep(1000); 
    var t2 = new Date().getTime();
    var dur = moment.duration(t2-t1); 
    console.log(`${dur.hours()}h:${dur.minutes()}m:${dur.seconds()}s`);
})();

0h:0m:1s

Você pode usar o numeral.js para formatar sua duração:

numeral(your_duration.asSeconds()).format('00:00:00') // result: hh:mm:ss

Isso pode ser usado para obter os dois primeiros caracteres como horas e os dois últimos como minutos. A mesma lógica pode ser aplicada a segundos.

/**
     * PT1H30M -> 0130
     * @param {ISO String} isoString
     * @return {string} absolute 4 digit number HH:mm
     */

    const parseIsoToAbsolute = (isoString) => {
    
      const durations = moment.duration(isoString).as('seconds');
      const momentInSeconds = moment.duration(durations, 'seconds');
    
      let hours = momentInSeconds.asHours().toString().length < 2
        ? momentInSeconds.asHours().toString().padStart(2, '0') : momentInSeconds.asHours().toString();
        
      if (!Number.isInteger(Number(hours))) hours = '0'+ Math.floor(hours);
    
      const minutes = momentInSeconds.minutes().toString().length < 2
        ? momentInSeconds.minutes().toString().padEnd(2, '0') : momentInSeconds.minutes().toString();
    
      const absolute = hours + minutes;
      return absolute;
    };
    
    console.log(parseIsoToAbsolute('PT1H30M'));

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.24.0/moment-with-locales.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react/16.6.3/umd/react.production.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/16.6.3/umd/react-dom.production.min.js"></script>

moment.duration(x).format()foi descontinuado. Você pode usar moment.utc(4366589).format("HH:mm:ss")para obter a resposta desejada.

console.log(moment.utc(4366589).format("HH:mm:ss"))

<script src="https://momentjs.com/downloads/moment.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

Como usar corretamente as durações de moment.js? | Use moment.duration () no código

Primeiro você precisa importar momente moment-duration-format.

import moment from 'moment';
import 'moment-duration-format';

Então, use a função duration. Vamos aplicar o exemplo acima: 28800 = 8 da manhã.

moment.duration(28800, "seconds").format("h:mm a");

,Bem, você não possui um erro de tipo acima. GetVocê obtém o valor certo às 8:00 da manhã? Não…, o valor que você recebe é 8:00 a. O formato Moment.js não está funcionando como deveria.

SolutionA solução é transformar segundos em milissegundos e usar o horário UTC.

moment.utc(moment.duration(value, 'seconds').asMilliseconds()).format('h:mm a')

Tudo bem, temos 8:00 agora. Se você quer 8 da manhã em vez das 8 da manhã por tempo integral, precisamos fazer o RegExp

const time = moment.utc(moment.duration(value, 'seconds').asMilliseconds()).format('h:mm a');
time.replace(/:00/g, '')

Eu precisava fazer isso para trabalhar como requisito para exibir as horas neste formato. No começo eu tentei isso.

moment.utc(totalMilliseconds).format("HH:mm:ss")

No entanto, qualquer coisa acima de 24 horas e as horas são redefinidas para 0. Mas os minutos e segundos foram precisos. Então eu usei apenas essa parte pelos minutos e segundos.

var minutesSeconds = moment.utc(totalMilliseconds).format("mm:ss")

Agora tudo que eu preciso é o total de horas.

var hours = moment.duration(totalMilliseconds).asHours().toFixed()

E para obter o formato que todos queremos, basta colá-lo.

var formatted = hours + ":" + minutesSeconds

se totalMillisecondsfor 894600000isso retornará 249:30:00.

Espero que tenha ajudado. Deixe qualquer dúvida nos comentários. ;)

Se você usa Angular> 2, criei um Pipe inspirado na resposta @ hai-alaluf.

import {Pipe, PipeTransform} from "@angular/core";

@Pipe({
  name: "duration",
})

export class DurationPipe implements PipeTransform {

  public transform(value: any, args?: any): any {

    // secs to ms
    value = value * 1000;
    const days = Math.floor(value / 86400000);
    value = value % 86400000;
    const hours = Math.floor(value / 3600000);
    value = value % 3600000;
    const minutes = Math.floor(value / 60000);
    value = value % 60000;
    const seconds = Math.floor(value / 1000);
    return (days ? days + " days " : "") +
      (hours ? hours + " hours " : "") +
      (minutes ? minutes + " minutes " : "") +
      (seconds ? seconds + " seconds " : "") +
      (!days && !hours && !minutes && !seconds ? 0 : "");
  }
}

Isso funciona para mim:

moment({minutes: 150}).format('HH:mm') // 01:30