Existe-t-il un moyen d'utiliser la méthode moment.js format sur des objets de durée? Je ne le trouve nulle part dans les documents et il ne semble pas être un attribut sur les objets de durée.

J'aimerais pouvoir faire quelque chose comme:

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

De plus, s'il existe d'autres bibliothèques pouvant facilement accueillir ce type de fonctionnalité, je serais intéressé par les recommandations.

Merci!

Nous envisageons d'ajouter une sorte de formatage aux durées dans moment.js. Voir https://github.com/timrwood/moment/issues/463

Quelques autres bibliothèques qui pourraient aider sont http://countdownjs.org/ et 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);

Jetez un œil au JSFiddle

convertir la durée en ms puis en moment:

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

Utilisez ce plugin Moment Duration Format .

Exemple:

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

Utilisez cette ligne de code:

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

Le meilleur scénario pour mon cas d'utilisation particulier était:

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

Cela améliore la réponse de @ Wilson car il n'accède pas à la propriété interne privée _data.

Vous n'avez pas besoin de .format. Utilisez des durées comme celle-ci:

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

J'ai trouvé cette solution ici: https://github.com/moment/moment/issues/463

ÉDITER:

Et avec rembourrage pour les secondes, les minutes et les heures:

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

J'utilise:

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

Et je reçois "09:30" dans var str.

si diff est un moment

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

Si vous êtes prêt à utiliser une autre bibliothèque javascript, numeral.js peut formater les secondes comme suit (l'exemple est pour 1000 secondes):

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

J'utilise la fonction de formatage classique dans ces cas:

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

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

Ceci est un hack car le différentiel horaire est traité comme une date standard, une date précoce, mais cela n'a pas d'importance pour notre objectif et vous n'avez pas besoin de plugin

Si toutes les heures doivent être affichées (plus de 24) et si "0" avant les heures n'est pas nécessaire, le formatage peut être effectué avec une courte ligne de code:

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

Basé sur la réponse 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

Pour formater la durée du moment en chaîne

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

si vous utilisez angulaire, ajoutez ceci à vos filtres:

.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 ': '')
    }
})

exemple d'utilisation

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

Ma solution qui n'implique aucune autre bibliothèque et qui fonctionne avec 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))

Et le javascript natif?

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

Utiliser le format moment-durée .

Cadre client (ex: React)

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

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

Serveur (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}`);

Tirages:

2 jours 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

Vous pouvez utiliser numeral.js pour formater votre durée:

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

Cela peut être utilisé pour obtenir les deux premiers caractères en heures et les deux derniers en minutes. La même logique peut être appliquée aux secondes.

/**
     * 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()est obsolète. Vous pouvez utiliser moment.utc(4366589).format("HH:mm:ss")pour obtenir la réponse souhaitée.

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>

Comment utiliser correctement les durées de moment.js? | Utilisez moment.duration () dans le code

Vous devez d'abord importer momentet moment-duration-format.

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

Ensuite, utilisez la fonction de durée. Appliquons l'exemple ci-dessus: 28800 = 8 h.

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

EllEh bien, vous n'avez pas d'erreur de type ci-dessus. 🤔Avez-vous une bonne valeur à 8h00? Non…, la valeur que vous obtenez est de 8 h 00. Le format Moment.js ne fonctionne pas comme il est censé le faire.

💡La solution consiste à transformer les secondes en millisecondes et à utiliser le temps UTC.

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

Très bien, nous obtenons 8h00 maintenant. Si vous voulez 8 h au lieu de 8 h pour le temps intégral, nous devons faire RegExp

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

J'avais besoin de le faire pour le travail comme une exigence pour afficher les heures dans ce format. Au début, j'ai essayé cela.

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

Cependant, plus de 24 heures et les heures sont remises à 0. Mais les minutes et les secondes étaient précises. J'ai donc utilisé uniquement cette partie pour les minutes et les secondes.

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

Maintenant, tout ce dont j'ai besoin est le nombre total d'heures.

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

Et pour obtenir ce format que nous voulons tous, il suffit de le coller ensemble.

var formatted = hours + ":" + minutesSeconds

si totalMillisecondsc'est 894600000cela reviendra 249:30:00.

J'espère que cela a aidé. Laissez des questions dans les commentaires. ;)

Si vous utilisez Angular> 2, j'ai créé un Pipe inspiré par @ 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 : "");
  }
}

Cela fonctionne pour moi:

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