Moment: Duración faltan características

Creado en 10 oct. 2012  ·  186Comentarios  ·  Fuente: moment/moment

Estoy trabajando en un proyecto y momentjs es realmente útil para la manipulación de fechas, así que gracias por eso.

Para darle un ejemplo, estamos haciendo una especie de tienda para boletos de avión. La función duration.humanize() es demasiado imprecisa para nosotros.

Por ejemplo, al salir a las 12:00 y aterrizar a las 13:30. Lo redondeará a 2 horas. Pero necesitamos algún tipo de granularidad que falta en momentjs.

humanizar podría por defecto a 1 nivel de precisión a partir del valor más alto.

// 1:30
duration.humanize()
2 hour
duration.humanize({precision: 2})
1 hour 30 minutes
duration.humanize({precision: 3})
1 hour 30 minutes 0 seconds

El segundo problema es cuando existe el número 0. Momentjs lo traduce como "unos segundos". No estoy tan seguro de cómo se podría lograr, pero sería genial tener algún tipo de formateo.

// 3 days and 0 minutes
duration.format('D [and] M')
> 3 days and 0 minutes
duration.format('H [and] M')
> 72 hours and 0 minutes
duration.format('H [and] m')
> 72 hours and few minutes

De esa forma, se podría asignar el valor más alto en el formato. Entonces, incluso si hay 1 año, el formato nos dice cómo mostrarlo correctamente. Estaría feliz de presionar un compromiso para eso porque es muy útil y tener que hacerlo a mano cuando momentjs ya maneja la localización se siente mal.

New Feature

Comentario más útil

2019, todavía necesita esta función.

Todos 186 comentarios

+1 en esta solicitud

@llacroix , ¿estaría interesado en escribir una solicitud de extracción para esto?

Sí, probablemente, intentaré encontrar tiempo para eso. Agregarlo a momentjs probablemente nos ahorrará tiempo a mí y a otros a largo plazo. Actualmente esto me obliga a crear algún tipo de desorden en todas partes y no es perfecto. Arreglar momentjs parece más apropiado.

Pero probablemente deberíamos discutir un poco más sobre qué tipo de formato debería hacerse. Por ejemplo, si se muestran 0 valores o no.

4 hours 20 seconds o 0 days 4 hours 0 minutes 20 seconds

Los meses serían 30 días, un año 365.

Y qué formatos deben existir además del año, mes, semana, día, minuto, segundo y milisegundo.

+1 para esto
Pero sí, el formateo es un problema clave aquí. Definitivamente, tanto humanizar como formatear son necesarios.
Algunas sugerencias para humanizar el comportamiento:
// 1:30
duración.humanizar ();
1 hora 30 minutos
duration.humanize ({round: "hours"})
2 horas
duration.humanize ({round: "minutes"})
1 hora 30 minutos
duration.humanize ({round: "seconds"})
1 hora 30 minutos 0 segundos

Si la ronda no se define explícitamente, creo que debe omitirse la unidad más alta cuyo valor es cero y todas las unidades más pequeñas que él.

// 1 hora 0 minutos 45 segundos
duration.humanize () -> 1 hora
// 1 hora 1 minutos 0 segundos
duration.humanize () -> 1 hora y 1 minuto
// 1 hora 1 minutos 10 segundos
duration.humanize () -> 1 hora 1 minuto y 10 segundos

Además, el separador "y" debe usarse para la última combinación, precedido por espacios en blanco
2 meses 6 días 7 horas y 36 minutos

Así es como me imagino que la función debería comportarse por defecto

Aquí está mi sugerencia para la firma y la implementación.

var duration = moment.duration({
    hours : 1,
    minutes : 0,
    seconds : 20,
    milliseconds : 0
});
duration.countdown(); // 1 hour 0 minutes 20 seconds
duration.countdown(1); // 1 hour
duration.countdown(2); // 1 hour and 0 minutes
duration.countdown(3); // 1 hour 0 minutes and 20 seconds

Como sugirió @sylvainpolletvillard , es posible que deseemos agregar un parámetro para recortar los valores cero. Quizás algo como esto.

duration.countdown(3); // 1 hour 0 minutes and 1 second
duration.countdown(3, true); // 1 hour

También es posible que deseemos agregar un parámetro para el sufijo como moment.fromNow(Boolean) .

duration.countdown(3); // 1 hour 0 minutes and 1 second ago
duration.countdown(3, null, true); // 1 hour ago

Podemos construir esto con cierta facilidad para el inglés, pero concatenar todas estas cadenas correctamente en todos los idiomas diferentes será muy complicado.

Probablemente tendremos que crear devoluciones de llamada para que los lenguajes concatenen cadenas ellos mismos. Estas reglas probablemente serán muy complejas (te estoy mirando, húngaro ).

Creo que la mejor forma de pasar estos valores sería algo como lo siguiente.

var keys    = [     "h",        "mm",          "s"],
    values  = [       1,           0,           20],
    strings = ["1 hour", "0 minutes", "20 seconds"];

lang.countdown(keys, values, strings, addSuffix);

Entonces la traducción al inglés sería algo como esto:

lang.countdown = function (keys, values, strings, addSuffix) {
    var i, output = "";

    for (i = 0; i < strings.length; i++) {
        if (i === strings.length - 1 && strings.length > 1) {
            output += "and ";
        }
        output += strings[i] + " ";
    }
    if (addSuffix) {
        output += "ago";
    }
}

Con todo, esto se convierte en una adición increíblemente compleja que requeriría 33 funciones de traducción y mucho más código en el núcleo. Además, no estoy seguro de la frecuencia con la que se usaría, por lo que agrega toda esa hinchazón para todos los demás.

¿Quizás sería mejor mover esto a un complemento?

Volviendo a la discusión sobre el formato de la duración, creo que sería genial si algo como esto fuera posible:

moment.duration(9483000).format('d h m s') // 1 day 2 hours 20 minutes 30 seconds  
moment.duration(9483000).format('h m s') // 26 hours 20 minutes 30 seconds 
//etc...  

¿Quizás proporcionar un parámetro booleano en el método de formato para determinar si se muestran valores 0 o no?

CLDR tiene un esquema de formato de lista y datos, que podrían usarse para muchos idiomas, aunque probablemente muchos idiomas aún necesitarían devoluciones de llamada personalizadas:

http://cldr.unicode.org/development/development-process/design-proposals/list-formatting

Soy bonita para la función de formato. Dado que implementar la traducción de varios idiomas puede ser bastante difícil. El uso de formatos debería ser bastante fácil de implementar.

Digamos que quieres

moment.duration(9483000).format('d h m s') // 1 day 2 hours 20 minutes and 30 seconds  
// English  => 'd h m [and] s' 1 day 2 hours 20 minutes and 30 seconds
// French   => 'd, h, m [et] s'   1 jour, 2 heures, 20 minutes et 30 secondes
// Russian  => 'd h m [и] s'   1 день 2 часа 30 минут и 30 секунд

No se necesitan devoluciones de llamada especiales, sino solo cadenas de formato especial.

Los métodos propuestos duration.countdown() y duration.countdown(1) son exactamente lo que estoy buscando (es decir, lo que estoy haciendo ahora en mi propio código).

Mientras tanto, ¿hay alguna forma de ampliar el prototipo de Duración?

El prototipo de duración se expone a través de moment.duration.fn similar a moment.fn .

He estado trabajando en algo similar el año pasado en # 143 / # 192. Tim sugirió un complemento, pero nunca me tomé el tiempo para hacerlo.

Estaba a punto de reiniciar mi trabajo. Tuve que actualizar a nuevos conceptos como objetos de duración, etc ... Yo era este ticket y otros. Ahora estoy luchando sobre si todavía es necesario y, en caso afirmativo, ¿cómo deberíamos implementarlo?

No quiero pisar los zapatos, así que sepa si puedo ayudar. ¿Quién está trabajando en ese tema en este momento?

Mi código pudo formatear en unidades consecutivas y unidades no consecutivas como esa:

test.equal(moment([2012, 0, 1]).diff([2011, 0, 1], 'years\\y'), "1y");
test.equal(moment([2012, 0, 1]).diff([2011, 0, 1], 'months[m]'), "12m");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'months [months] days [days]'), "50 months 19 days");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'years \\y months \\M days \\d'), "4 y 2 M 19 d");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'years[y] days[d]'), "4y 80d");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'years [years] weeks [weeks]'), "4 years 11 weeks");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'years\\y weeks\\w [and] days [days]'), "4y 11w and 3 days");
test.equal(moment([2016, 0, 20]).diff([2011, 10, 1], 'days\\d'), "1541d");

No manejaba unidades que no estaban en orden como 'days years' . Tampoco manejó la eliminación de valores cero.

¡Se ve increíble, exactamente el tipo de cosas que esperaba!

Esta es definitivamente una característica necesaria para todos.

¡Necesito esto!

Como posible solución provisional para algunos de ustedes, he creado un complemento simple que les permite usar countdown.js directamente desde Moment:

moment("1982-5-25").countdown().toString(); // => '30 years, 10 months, 14 days, 2 hours, 23 minutes, and 50 seconds'

Pasa a través de cualquier opción de Countdown que le pase, como qué unidades usar y con cuánta precisión (puede consultar los documentos de Countdown). De todos modos, el complemento está aquí: https://github.com/icambron/moment-countdown

@icambron ¡ gracias por tu contribución! ¡Es muy útil!

Acabo de comenzar a usar moment.js y rápidamente encontré este problema exacto. Este es el código que usé para resolverlo:

moment.duration.fn.format = function (input) {
    var output = input;
    var milliseconds = this.asMilliseconds();
    var totalMilliseconds = 0;
    var replaceRegexps = {
        years: /Y(?!Y)/g,
        months: /M(?!M)/g,
        weeks: /W(?!W)/g,
        days: /D(?!D)/g,
        hours: /H(?!H)/g,
        minutes: /m(?!m)/g,
        seconds: /s(?!s)/g,
        milliseconds: /S(?!S)/g
    }
    var matchRegexps = {
        years: /Y/g,
        months: /M/g,
        weeks: /W/g,
        days: /D/g,
        hours: /H/g,
        minutes: /m/g,
        seconds: /s/g,
        milliseconds: /S/g
    }
    for (var r in replaceRegexps) {
        if (replaceRegexps[r].test(output)) {
            var as = 'as'+r.charAt(0).toUpperCase() + r.slice(1);
            var value = new String(Math.floor(moment.duration(milliseconds - totalMilliseconds)[as]()));
            var replacements = output.match(matchRegexps[r]).length - value.length;
            output = output.replace(replaceRegexps[r], value);

            while (replacements > 0 && replaceRegexps[r].test(output)) {
                output = output.replace(replaceRegexps[r], '0');
                replacements--;
            }
            output = output.replace(matchRegexps[r], '');

            var temp = {};
            temp[r] = value;
            totalMilliseconds += moment.duration(temp).asMilliseconds();
        }
    }
    return output;
}

Características de este código:

d=moment.duration({hours:1,minutes:1,seconds:1});
d.format('HHH:mm:ss');
"001:01:01"
  • si omite un carácter en su plantilla de entrada, y el valor del carácter siguiente es mayor que su máximo habitual, le agrega el anterior, por ejemplo:
d=moment.duration({days:1, hours:1, minutes: 1});
d.format('H:mm:ss');
"25:01:00"

Posibles problemas:

  • usa Math.floor en valores obtenidos de asXxxx, por ejemplo:
Math.floor(moment.duration(milliseconds)).asHours()
  • esto significará que si, por ejemplo, hay valores para minutos o segundos en la duración, pero le preguntas a la función de formato por horas, entonces no redondeará hacia arriba, siempre redondeará hacia abajo.

+1 para esta solicitud

Personalmente, creo que tiene más sentido implementar el método .format() que tener algunas reglas sofisticadas para .humanize() o crear un método .countdown() . El 95% de los problemas se pueden resolver con .format() .

Estoy de acuerdo en que .humanize() debería ofrecer más precisión, pero debería ser una característica diferente.

La duración del formateo es imprescindible. Debería ser fácil traducir segundos en una cadena formateada.

Probé el código stralytic pero:
d = moment.duration ({días: 1, horas: 1, minutos: 1}); d.format ('DH: mm: ss');
"1-215: 01: 00"

+1 por format()

Como caso de uso, las duraciones utilizadas en los exámenes de cronometraje (3 horas) se pueden formatear fácilmente como hh: mm (: ss) más o menos, lo que sería mucho, mucho más fácil. En este momento, es bastante difícil hacer lo mismo en Moment hasta que incursione en vanilla js :)

Formato de duración +1!

aquí está la solución rápida que utilicé:

moment.duration.fn.format = function(){
    str = ""
    if(this.days() > 1) str = str + Math.floor(this.days()) + "d "
    if(this.hours() > 1) str = str + Math.floor(this.hours()) + "h "
    if(this.minutes() > 1) str = str + Math.floor(this.minutes()) + "m "
    if(this.seconds() > 1) str = str + Math.floor(this.seconds()) + "s "
    return str
    }

: +1: por duration.format()

: +1: para duration.format () también

¿Cuál es el estado de este RP? ¿Está lejos?

Code Bounty

Estuve fuera por un tiempo ... Casi un año que creé este problema. Lo probaré. Bifurcaré moment js y actualizaré este problema tan pronto como tenga algo para probar / revisar. Tengo que prepararme para un examen en dos días. Por lo tanto, es poco probable que se muestre algo en dos días. Dicho esto, estaré trabajando en ello.

@llacroix Gracias :)

: +1: para duración.format ()

 moment.duration.fn.format = function (zeros, twoDigit) {
 var horas = esto.horas (), minutos = esto.minutos (), segundos = esto.segundos ();
 var displayFormat = '', zerosFormat = twoDigit? '00': '0', padLeft = twoDigit? -2: -1;
 if (horas || ceros) {
 displayFormat + = (zerosFormat + horas) .slice (padLeft) + 'h';
 }
 si (minutos || ceros) {
 displayFormat + = (zerosFormat + minutos) .slice (padLeft) + 'min';
 }
 si (segundos || ceros) {
 displayFormat + = (zerosFormat + segundos) .slice (padLeft) + 's';
 }
 return $ .trim (displayFormat);
 }

Formato de duración +1.

+1 duración.formato

+1 duración.formato

Realmente necesitaba un formato de duración completo, así que revisé los hilos aquí y en StackOverflow y me senté hoy para implementarlo.

Todavía estoy trabajando en un par de detalles menores, pero el núcleo está hecho y es sólido. Recibiré el código, las especificaciones y los ejemplos publicados aquí en los próximos días. La idea básica es que puede tener cualquier duración arbitraria y formatearla con una cadena similar a las cadenas de formato de fecha de momento, por ejemplo. duration.format ("d [d] hh: mm: ss") -> 2d 03:47:24

También puede definir precisión decimal arbitraria en el valor final, por ejemplo. duration.format ("h [h]", 3) -> 42,384 h

+1 por formato de duración

He publicado mi complemento moment.duration.format:
https://github.com/jsmreese/moment-duration-format

En el proyecto se encuentran casos de prueba y algunos ejemplos.
Mi complemento depende de lodash y underscore.string.

+1 duración.formato ()

Este boleto se abrió hace más de un año. Dudo que alguna vez se implemente.

@ Maxwell2022 Publiqué un complemento moment.duration.format hace aproximadamente una semana:
https://github.com/jsmreese/moment-duration-format

¿Funcionará para ti?

+1 a esto también. Parece una omisión muy notable en una biblioteca por lo demás completa.

https://github.com/rmm5t/jquery-timeago podría ser una buena plantilla sobre cómo podemos implementar esto en Moment ...

@schmod Publiqué un complemento moment.duration.format el mes pasado:
https://github.com/jsmreese/moment-duration-format

¿Eso funciona para sus casos de uso?

: +1:!

Esto funcionaría para mí (pero no lo haría por> 24 horas de duración):

moment.duration.fn.format = function(format) {
  return moment(this.as('milliseconds')).format(format);
}

@jsmreese su https://github.com/jsmreese/moment-duration-format que depende de LoDash es un verdadero espectáculo. Ya usamos guión bajo, y no puedo justificar un cambio a LoDash solo por esta pequeña característica. Si su complemento fuera independiente de ambos, creo que lo convertiría en una opción más viable para mucha gente.

@wleeper Absolutamente de acuerdo.

Mi entorno usa LoDash y Underscore.String, así que usé métodos de esas bibliotecas; necesitaba mi primera versión hace un par de meses y solo quería implementarla y estar disponible.

Eliminaré esas dependencias en breve.

@wleeper Underscore y LoDash están destinados a ser intercompatibles. Siempre que @jsmreese no esté usando nada que no esté en la compilación de subrayado de LoDash, debería poder usar su complemento tal como está sin ningún problema.

@ chall8908 Eso es lo que pasa, y @wleeper tiene razón: yo _am_ estoy usando características de LoDash que no son parte de la construcción de Underscore.

Eliminé la dependencia de Underscore.String y estoy trabajando en la compatibilidad de Underscore.

Aunque el complemento de formato de duración de momento resuelve uno de estos problemas, creo que necesitamos un enfoque que funcione en todas las configuraciones regionales (lo que, sin duda, es mucho más difícil).

Creo que tenemos que trabajar en la implementación de # 1241, que abriría muchas puertas en términos de representar fechas legibles para humanos, fechas relativas, duraciones y listas en todas las configuraciones regionales. formatDuration sería bastante trivial de implementar si Moment tuviera acceso a los datos del lenguaje CLDR.

La biblioteca Globalize de jQuery está trabajando para abordar muchos de los mismos problemas, y parece lógico colaborar con ellos. Twitter también tiene una biblioteca muy completa que hace mucho de este tipo de cosas ...

Bien, aquí hay una API implementable además de CLDR. ¿Qué piensas?

duration:human(bool) // future/past dep/indep
duration:human({
  with(=min+max): 'hours'|'minutes'|'seconds',
  min: 'hours',
  max: 'days',
  float: bool,
  length: "long|short|narrow",
  abs: bool
})
  • min: cuál es la unidad mínima a utilizar. min: días, significa no decir horas, minutos, segundos, pero redondear a días si la duración es más corta que un día
  • max: cuál es la unidad máxima a utilizar. max: days, significa no usar meses y años, sino el número respectivo de días
  • length: tamaño de las fichas: día vs d para inglés
  • abs: futuro / pasado independiente

: +1: +1

: +1:

+1 duración.formato

+1 duración.formato

+1

+1

+1

Me gustaría que esto muestre el tiempo de ejecución de algo.

+1

https://github.com/jsmreese/moment-duration-format

moment-duration-format versión 1.2.1 se publica en NPM.
Es funcional tanto en Node.js como en el navegador.
Depende de Lo-Dash o Underscore, pero ahora está probado y funciona con ambos.
Se ha eliminado la dependencia de Underscore.String original.

Publicaré esta versión en Bower tan pronto como se resuelvan los problemas actuales de registro / cancelación del registro del paquete Bower.

+1 para formato de duración

Me encantaría que esto se convierta en parte de la biblioteca.

+1

+1

+1

: +1:

+1 para duration.format ()

+1

Oh, sí, definitivamente estaría dentro, al menos para poder hacer moment.duration(3, 'seconds').get('ss') para generar con valores cero a la izquierda.

¿Cuál es el estado de esta solicitud? ¿Qué ayuda se necesita para avanzar en él?

@oncletom
Esto existe: https://github.com/jsmreese/moment-duration-format/
Y puede hacer lo que quiera, si no le importa la dependencia de Lo-Dash o Underscore.
Algún día, pronto, haré algo de tiempo para eliminar esa dependencia ...

me sorprendió que https://github.com/jsmreese/moment-duration-format/ no esté en stdlib cuando humanize está. Siento que viola el principio de mínima sorpresa. Como mínimo, debería ser posible volver a un formato numérico simple:

moment.duration(123, "minutes").format();
// "2:03:00"

Por ahora estoy usando:

moment.utc(moment.duration(300 * 1000).asMilliseconds()).format("HH:mm:ss.SSS")
// 00:05:00.000

Me encantaría ver esto pronto como parte de momentos.js

+1

+1

En una nota relacionada, duration.toString() devuelve [Object object] . ¿No debería devolver humanize() ?

A +1 le encantaría tener más control sobre esto.

+1

Se acaba de publicar el formato de duración de momento 1.3.0, que elimina la dependencia anterior de Lo-Dash o Underscore. Ahora la única dependencia es Moment.js.

https://github.com/jsmreese/moment-duration-format/

@jsmreese ¡ Buen hombre! : cervezas:

@jsmreese genial. !
¿Por qué esto no ha sido parte del mismo moment.js? No lo entiendo. humanizar no es tan útil sin precisión, ¿por qué querría redondear 1h y 30 minutos a 1 hora? .. No hay caso de uso para eso.

+1, el complemento de jsmreese funciona de manera brillante, pero sería bueno si fuera parte de moment.js.

+1. Esta característica debe estar dentro y humanizarse.

+1 por formato de duración

@jsmreese publicó su complemento hace casi un año, y esta edición se abrió hace dos años. @timrwood @ichernev ¿Podemos poner esto en la biblioteca principal de moment.js?

+1

+1

: +1: para formato de duración

+1

: +1:

+1

¿Cuál es el estado actual de esto?

¿Quizás el mantenedor está esperando hasta que lleguemos a las 1000, o la víspera de Año Nuevo? @icambron

@gkatsanos : ya no estoy activo para ayudar a mantener Moment (y siempre fui solo un ayudante), pero mi recomendación es una solicitud de extracción bien probada. Seguramente hay alguien solicitando esto dispuesto a codificarlo.

@icambron esto ya existe como un complemento ... ¿qué más se puede hacer?
¿Quién es el mantenedor por cierto?

@icambron , ¿puedes señalar el complemento?

y parece ser un complemento muy bien formado. excepto el hecho de que depende de lodash lugar de underscore , ¿hay alguna otra cosa que impida hacerlo como PR ... parece ser el puerto de lodash a underscore no debería ser tan difícil. / cc @jsmreese

@gkatsanos @alexanderbeletsky En realidad me quita el lodash o underscore dependencia hace un tiempo.

Uno de los principales obstáculos para que mi complemento se incluya en el núcleo de Moment.js es la falta de compatibilidad completa con i18n.

Y esa es una gran preocupación para mí, personalmente. Los múltiples idiomas admitidos son algo muy importante para mí, y no me gustaría entrar en una situación en la que la función A funciona en cualquier idioma, pero la función B es solo en inglés.

@jsmreese tal vez si crea algunas tareas bien definidas en su repositorio, de qué es exactamente lo que se debe hacer, definitivamente me atrevería a ayudar.

@mattgrande @alexanderbeletsky Las fichas de formato ya son personalizables, y la plantilla de formato es arbitraria, por lo que no es un problema.

Las plantillas de formato predeterminadas no están localizadas de ninguna manera, y no puede localizar el punto decimal ni agregar ningún tipo de formato de número localizado en los valores. Eso es todo lo que me falta en la parte superior de la cabeza.

: +1:

+1 duración.formato!

muuuuuuuuuuuuuuuuuu ... ¿Cuál es el trato con esto?

Simplemente ingresando para señalar algunas cosas, ya que hay como un millón de comentarios aquí. No soy el mantenedor y ya no estoy activo en este proyecto, pero estoy bastante seguro de dos cosas:

  1. Todos, pueden usar el complemento de @jsmreese , si lo desea, puede agregarlo a la lista de complementos de Moment en la documentación con un PR aquí: https://github.com/moment/momentjs.com)
  2. No se incluirá en el núcleo de Moment hasta que alguien a) lo internacionalice, b) integre las pruebas en las pruebas de Moment yc) envíe un PR. Definitivamente no sucederá hasta que alguien haga eso .

+1 duración.formato

+1 duración.formato!

+1 duración.formato

+1 duración.formato. Nuestro caso es que queremos proporcionar una función en la que se pueda pasar una cantidad de segundos y una cadena que los formatee. Ahora mismo lo estamos haciendo con moment.startof ("w"). Add ("s", nrOfSeconds) .format (customFormatString);

Desafortunadamente, la semana pasada, esto produjo un error ya que el inicio de ("w") es el domingo y el domingo era el horario de verano, por lo que nos faltaba una hora. Por supuesto, podemos verificar eso con isDSTShifted (), pero aún sería increíble no tener que convertir una duración en una fecha solo para formatearla.

+1 duración.formato

+1 duración.formato

+1 por duration.format

+1 por formato de duración

¿Podemos cerrar esto ya que aparentemente nadie que hace +1 lee este hilo?

El miércoles, 10 de junio de 2015, 08:30 SamFromDaUk [email protected] escribió:

+1 por formato de duración

-
Responda a este correo electrónico directamente o véalo en GitHub
https://github.com/moment/moment/issues/463#issuecomment -110751635.

¿O arreglarlo?

George, creo que aquellos que están agregando +1 s están implícitamente en desacuerdo, y
simplemente quiero estas características.

Si las notificaciones lo irritan, considere cancelar la suscripción a este
hilo.
El 11 de junio de 2015 a las 00:07, "George Katsanos" [email protected] escribió:

¿O arreglarlo?

-
Responda a este correo electrónico directamente o véalo en GitHub
https://github.com/moment/moment/issues/463#issuecomment -110767322.

La razón por la que github no tiene una función de voto (según tengo entendido) es porque desalienta la discusión.

Puedes estar en desacuerdo implícitamente todo lo que quieras, eso no ayuda. Si no está de acuerdo, eso es genial, lea el hilo y dé sus argumentos (específicamente, cualquier argumento nuevo o cualquier punto que crea que se ha considerado deficientemente).

Todavía estoy suscrito porque creo que quedan algunos argumentos interesantes por hacer, espero escucharlos, pero el equipo no debería ceder ante la mera presión de los compañeros.

Puedo confirmar que el complemento @icambron mencionado anteriormente funciona.

Si eres como yo, quieres un .fromNow() con una salida más amplia (como la cuenta regresiva de envío de Amazon). He aquí cómo hacerlo:

// include the plugin
var cutoffDate = moment().add(3, 'hours'); // some date in the future that we're counting down to
var now = moment();
var output = moment.duration(cutoffDate.diff(now)).format('h [hours] m [minutes] s [seconds]');
// "3 hours 0 minutes 0 seconds"

sí, también dejaré en claro: moment.duration (). format () funciona con este complemento: https://github.com/jsmreese/moment-duration-format

si estás usando meteoro, ve por oaf:moment-duration-format

Esto no parece funcionar para mí, estoy usando moment .diff entre dos horas, lo que funciona, el problema es cuando está entre "pm" y "am", digamos que estoy viajando a las 9 pm y aterrizando 2 am, debería tener la cantidad de tiempo correcta.

@ Markj89 necesitas abrir un tema de stackoverflow.

+1

+1

+1

: +1:

+1 al cerrar este problema. usar el complemento es una solución sólida.

+1

+1

+1 en .format()

+1, ¿aún no se implementó después de 4 años? :RE

+1

Por cierto. Creo que también debería ser posible analizar el formato humanizado. Por ejemplo, no es tan difícil analizar 7 days and 5 hours ...

Sólo quería hacer hincapié en @jsmreese 's plug-in funcionaba muy bien!

: +1:

+1 duración.formato

Formato de duración +1

+1 duración.formato

+1 duración.formato

: +1:

Voy a cerrar esto a favor del # 1048. No significa que se haya ido, solo tuvimos dos problemas que tienen varios años y ambos se reducen a 'hacer formato de duración'. El otro explica esto con mayor claridad.

+1 duración.formato

+1 duración.formato

+1

Use .localeData () .rativeTime (45, true, 'mm') y obtenga 45 minutos, y así sucesivamente;)

+1 Realmente se habla mucho de esto y aún no está implementado. Incluso hay un paquete separado para este https://github.com/jsmreese/moment-duration-format

para mostrar la duración en cualquier formato, simplemente convierta la duración a ms y luego al momento:
moment(duration.as('milliseconds')).format('HH:mm:ss')

¡Gracias! ¿Está esto en los documentos? No lo vi ...

Esto no está en los documentos porque no funciona. Es un truco que usa la época de Unix para interpretar milisegundos como un punto en el tiempo desde la época. Por lo tanto, se desmorona si su duración es de 24 horas o más.

Algunas cosas sobre este código:

  1. Un token hh es un token destinado a usarse con AM / PM, por lo que su duración solo aumentará a 12

  2. Incluso si usa un token HH, que aumentará hasta 23, su duración no puede ser superior a 23: 59: 59.999, ya que las cosas pasarán a la siguiente fecha

  3. A medida que se escribe este código, solo funcionará en un servidor que esté en UTC. Cualquier navegador en una zona horaria diferente producirá resultados inesperados.

Si desea utilizar este truco, debe escribirse como:

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

Pero como señalé, esto solo funcionará si su duración es menor de 24 horas. Sobre eso, volvamos a la casilla 1.

Gracias. Hoy me tomó un tiempo darme cuenta de que se puede concatenar .minutes() con .seconds() . Llámame estúpido, pero no era obvio para mí por los documentos cuál es la diferencia entre .seconds() y .asSeconds() inmediato ... ¡Pero ahora veo que en realidad está ahí! :)

por ejemplo: console.log(duration.minutes()+":"+duration.seconds());

Me quedaré con este método.

@elasticsteve Probablemente también desee agregar un cero a la

@butterflyhug @elasticsteve, esa es en realidad la razón principal por la que quería usar format . en mi caso es un simple contador de tiempo corto, así que la solución de @maggiepint es suficiente para mis necesidades.
moment.utc(duration.asMilliseconds()).format('HH:mm:ss')

@sagivo buen punto! Ahora la solución @maggiepint parece más atractiva. Mi servidor es UTC de todos modos.

Seguro, lo entiendo totalmente. También he usado ese truco en el código de producción. Pero no lo recomendaría como una solución general (aparte de algunos casos de uso específicos), porque hay muchas situaciones en las que falla gravemente. (Por ejemplo, las duraciones negativas son otro caso de falla importante que aún no se ha mencionado explícitamente).

+1

+1 duración.formato () !!!!!!!!!

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1 duraciones difíciles de depurar

+1

Puedes hacer fácilmente algo como:

    var duration = moment().add(5, 'days') -  moment().local();
    var s = Math.floor( (duration/1000) % 60 );
    var m = Math.floor( (duration/1000/60) % 60 );
    var h = Math.floor( (duration/(1000*60*60)) % 24 );
    var d = Math.floor( duration/(1000*60*60*24) );
    return d + ' days ' + h + ' hours ' + m + ' minutes ' + s  + ' seconds before the deadline.';   
    // 4 days 23 hours 59 minutes 59 seconds before the deadline.

Solicitar un usuario twitter @Toon_Ladyboy

Puedes hacer fácilmente algo como:

    var duration = moment().add(5, 'days') -  moment().local();
    var s = Math.floor( (duration/1000) % 60 );
    var m = Math.floor( (duration/1000/60) % 60 );
    var h = Math.floor( (duration/(1000*60*60)) % 24 );
    var d = Math.floor( duration/(1000*60*60*24) );
    return d + ' days ' + h + ' hours ' + m + ' minutes ' + s  + ' seconds before the deadline.';   
    // 4 days 23 hours 59 minutes 59 seconds before the deadline.

Feo, pero efectivo.

2019, todavía necesita esta función.

Un parámetro simple en humanizar, .eg humanize(precise: true) , que eludiría todo el redondeo sería suficiente para hacer felices a todos. Además, el redondeo es la parte difícil de implementar. El resto es simplemente convertir una duración como cualquier otro formato realizado con format ().

Hay un excelente método moment llamado fromNow() que devolverá la hora de una hora específica en una forma agradable y legible por humanos, como esta:

moment('2019-04-30T07:30:53.000Z').fromNow() // an hour ago || a day ago || 10 days ago

O si lo desea entre dos fechas específicas puede usar:

var a = moment([2007, 0, 28]);
var b = moment([2007, 0, 29]);
a.from(b); // "a day ago"

Tomado de los documentos:

¿Se puede reabrir esto? Esta es una funcionalidad muy básica.

En mi caso encontré un paquete que resolvió mis problemas:
https://github.com/EvanHahn/HumanizeDuration.js

Quizás también sea útil para otra persona. :)

Julio de 2019 y esta función aún no está disponible.

Julio de 2019 y esta función aún no está disponible.

No lo he probado todavía, ¡pero me acabo de dar cuenta de esto!
npm install moment-duration-format

https://github.com/jsmreese/moment-duration-format

Septiembre de 2019 todavía extraña oficialmente esta característica

d.format('H:mm:ss');
"1:01:01"

También desearía poder tener esta característica

d.format('D-H:mm:ss'); // existence of D will mod hours to 24
"999-23:59:59"

En caso de que alguien se preguntara por qué se cerró esto: https://github.com/moment/moment/issues/463#issuecomment -228543000

Esto de ninguna manera es ideal, pero terminé haciendo algo como esto como solución. Tenía un objeto duration con una cuenta regresiva para cerrar la sesión del usuario después de la inactividad, y quería formatear el tiempo restante.

// What I did:
private getTimeString(duration: moment.Duration): string {
    const time = moment()
      .seconds(duration.seconds())
      .minutes(duration.minutes());

    return time.format('mm:ss');
}

// What I'd rather do (as many others have mentioned)...
private getTimeString(duration: moment.Duration): string {
    return duration.format('mm:ss');
}

Una solución hacky mía:

import moment from 'moment';

const formatInt = (int: number): string => {
  if (int < 10) {
    return `0${int}`;
  }
  return `${int}`;
};

export const formatDuration = (time: string): string => {
  const seconds = moment.duration(time).seconds();
  const minutes = moment.duration(time).minutes();
  const hours = moment.duration(time).hours();
  if (hours > 0) {
    return `${formatInt(hours)}:${formatInt(minutes)}:${formatInt(seconds)}`;
  }
  if (minutes > 0) {
    return `${formatInt(minutes)}:${formatInt(seconds)}`;
  }
  return `00:${formatInt(seconds)}`;
};

2020

Utilizo el siguiente método, puede ser útil para otra persona :)

function formatDuration(duration, format) {
  const date = moment().startOf('day');
  return date.add(duration).format(format);
}

(Solo uso para formatear duraciones entre 00:00 y 23:59)

Todavía necesito esto

Estos 'get' ayudan a formatear de la manera que desee:

  duration.get('years')
  duration.get('months')
  duration.get('days')
  duration.get('hours')
  duration.get('minutes')
  duration.get('seconds')

Con que trabajo:

const formatDuration = ms => {
  const days = Math.floor(ms / 8.64e7);
  const msOnLastDay = ms - days * 8.64e7;
  return (days < 10 ? "0" + days : days) + ":" + moment.utc(msOnLastDay).format("HH:mm:ss.SSS");
};
formatDuration(5)
"00:00:00:00.005"
formatDuration(500)
"00:00:00:00.500"
formatDuration(50000)
"00:00:00:50.000"
formatDuration(5000000)
"00:01:23:20.000"
formatDuration(500000000)
"05:18:53:20.000"
// for reference
JSON.stringify(moment.duration(500000000)._data, null, 2)
"{
  "milliseconds": 0,
  "seconds": 20,
  "minutes": 53,
  "hours": 18,
  "days": 5,
  "months": 0,
  "years": 0
}"

Julio de 2019 y esta función aún no está disponible.

No lo he probado todavía, ¡pero me acabo de dar cuenta de esto!
npm install moment-duration-format

https://github.com/jsmreese/moment-duration-format

Esto funciona perfectamente bien :)

El juego ha terminado :)

Gracias, lo aprecio !!!


De: Aleksey Makas [email protected]
Enviado: sexta-feira, 9 de outubro de 2020 11:03
Para: momento / momento [email protected]
Cc: Douglas Aguiar [email protected] ; Comentario [email protected]
Asunto: Re: [momento / momento] Funciones faltantes de duración (n. ° 463)

El juego ha terminado :)

-
Estás recibiendo esto porque comentaste.
Responda a este correo electrónico directamente, véalo en GitHub https://github.com/moment/moment/issues/463#issuecomment-706200427 , o cancele la suscripción https://github.com/notifications/unsubscribe-auth/AGD22DRNGNIQMOJFQY7VW3DSJ4J4VANCNLAFSM4ABRU .

¿Fue útil esta página
5 / 5 - 1 calificaciones