Moment: Duração faltando recursos

+1 neste pedido

@llacroix , você estaria interessado em escrever uma solicitação pull para isso?

Provavelmente sim, vou tentar encontrar tempo para isso. Adicioná-lo aos momentos provavelmente economizará tempo para mim e para os outros no longo prazo. Atualmente isso me obriga a criar algum tipo de bagunça em todos os lugares e não é perfeito. Corrigir momentjs parece mais apropriado.

Mas provavelmente devemos discutir um pouco mais sobre que tipo de formato deve ser feito. Por exemplo, os valores 0 devem ser exibidos ou não.

4 hours 20 seconds ou 0 days 4 hours 0 minutes 20 seconds

Os meses seriam 30 dias, um ano 365.

E quais formatos diferentes de ano, mês, semana, dia, minuto, segundo e milissegundo devem existir.

1 para isto
Mas sim, a formatação é um problema chave aqui. Humanizar e formatar são definitivamente necessários.
Algumas sugestões para humanizar o comportamento:
// 1:30
duration.humanize ();
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

Se redondo não for definido explicitamente, acho que a unidade mais alta cujo valor é zero e todas as unidades menores do que deve ser omitida.

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

Além disso, o separador "e" deve ser usado para a última junção, precedido por espaços em branco
2 meses 6 dias 7 horas e 36 minutos

É assim que eu imagino que a função deve se comportar por padrão

Aqui está minha sugestão para a assinatura e implementação.

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 @sylvainpolletvillard sugeriu, podemos adicionar um parâmetro para cortar os valores zerados. Talvez algo assim.

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

Também podemos adicionar um parâmetro para o sufixo 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 isso com certa facilidade para o inglês, mas concatenar todas essas strings corretamente em todos os idiomas diferentes será muito complicado.

Provavelmente teremos que criar callbacks para linguagens para concatenar strings. Essas regras provavelmente serão muito complexas (estou olhando para você, húngaro ).

Acho que a melhor maneira de passar esses valores seria algo como o seguinte.

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

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

Então a tradução em inglês seria algo assim:

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

Ao todo, isso se torna uma adição incrivelmente complexa que exigiria 33 funções de tradução e um monte de código a mais no núcleo. Além disso, não tenho certeza de quantas vezes ele seria usado, por isso estou adicionando todo esse inchaço para todos os outros.

Talvez seja melhor mudar para um plugin?

Voltando à discussão sobre a formatação da duração, acho que seria ótimo se algo assim fosse possível -

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...  

Talvez fornecendo um parâmetro booleano no método de formato para determinar se os valores 0 foram mostrados ou não?

CLDR tem um esquema de formatação de lista e dados, que pode ser usado para muitos idiomas, provavelmente muitos idiomas ainda precisariam de retornos de chamada personalizados:

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

Sou bonita para a função de formato. Já que implementar a tradução de vários idiomas pode ser bastante difícil. O uso de formatos deve ser muito fácil de implementar.

Vamos dizer que você quer

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 секунд

Não há necessidade de callbacks especiais, mas apenas strings de formato especial.

Os métodos propostos duration.countdown() e duration.countdown(1) são exatamente o que estou procurando (ou seja, o que estou fazendo agora em meu próprio código).

Enquanto isso, há uma maneira de estender o protótipo de duração?

O protótipo de duração é exposto por meio de moment.duration.fn semelhante a moment.fn .

Tenho trabalhado em algo semelhante no ano passado em # 143 / # 192. Tim sugeriu um plugin, mas nunca me dei ao trabalho de fazê-lo.

Eu estava prestes a reiniciar meu trabalho. Tive que atualizar para novos conceitos como objetos de duração etc ... Fui este ticket e outros. Agora estou lutando para saber se ainda é necessário e, se sim, como devemos implementá-lo.

Não quero pisar no sapato de ninguém para que saibamos se posso ajudar. Quem está trabalhando nesse problema agora?

Meu código foi capaz de formatar unidades consecutivas e unidades não consecutivas assim:

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

Ele não manipulava unidades que não estavam em ordem como 'days years' . Ele também não tratou de remover valores zero.

Isso parece incrível, exatamente o tipo de coisa que eu esperava!

Esse é definitivamente um recurso necessário para todos.

Preciso disso!

Como uma possível solução temporária para alguns de vocês, criei um plug-in simples que permite usar countdown.js diretamente do Moment:

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

Ele passa por todas as opções de contagem regressiva que você passa, como quais unidades usar e com quanta precisão (você pode olhar os documentos da contagem regressiva). De qualquer forma, o plugin está aqui: https://github.com/icambron/moment-countdown

@icambron obrigado pelo seu país! É muito útil!

Acabei de começar a usar o moment.js e rapidamente me deparei com esse problema exato. Este é o código que usei para resolvê-lo:

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 deste código:

• usa o mesmo formato de caracteres conforme descrito em: http://momentjs.com/docs/#/displaying/format/
• produz quantos zeros à esquerda você quiser para qualquer atributo da duração, por exemplo:

d=moment.duration({hours:1,minutes:1,seconds:1});
d.format('HHH:mm:ss');
"001:01:01"

• se você omitir um caractere em seu modelo de entrada e o valor do caractere subsequente for maior do que o máximo normal, ele adiciona o anterior a ele, por exemplo:

d=moment.duration({days:1, hours:1, minutes: 1});
d.format('H:mm:ss');
"25:01:00"

Possíveis problemas:

• usa Math.floor em valores obtidos de asXxxx, por exemplo:

Math.floor(moment.duration(milliseconds)).asHours()

• isso significa que se houver, por exemplo, valores para minutos ou segundos na duração, mas você solicitar a função de formato para horas, ela não será arredondada para cima, ela sempre será arredondada para baixo.

+1 para este pedido

Pessoalmente, acho que faz mais sentido implementar o método .format() que ter algumas regras sofisticadas para .humanize() ou criar um método .countdown() . 95% dos problemas podem ser resolvidos com .format() .

Eu concordo que .humanize() deve oferecer mais precisão, mas deve ser um recurso diferente.

A duração da formatação é obrigatória. Deve ser fácil traduzir os segundos em uma string formatada.

Tento o código estralítico, mas:
d = momento.duração ({dias: 1, horas: 1, minutos: 1}); d.formato ('DH: mm: ss');
"1 -215: 01: 00"

+1 para format()

Como um caso de uso, durações usadas em exames de cronometragem (3 horas) podem ser formatadas facilmente como hh: mm (: ss) ou assim, o que seria muito mais fácil. No momento, é muito difícil fazer o mesmo no Moment até que eu me envolva no vanilla js :)

+1 formato de duração!

aqui está a solução rápida que usei:

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 () também

Qual é o status deste PR? Está longe?

Eu estive ausente por um tempo ... Quase um ano que criei esta edição. Vou dar uma chance. Vou fazer o fork do momento js e atualizar este problema assim que tiver algo para testar / revisar. Tenho que me preparar para um exame em dois dias. Portanto, é improvável que algo apareça em dois dias. Dito isso, estarei trabalhando nisso.

@llacroix Obrigado :)

: +1: para duration.format ()

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

Formato de duração +1.

+1 duration.format

+1 duration.format

Eu realmente precisava de uma formatação de duração abrangente, então revisei os threads aqui e no StackOverflow e sentei hoje para implementá-la.

Ainda estou trabalhando em alguns pequenos detalhes, mas o núcleo está pronto e sólido. Pegarei o código, as especificações e os exemplos postados aqui nos próximos dias. A ideia básica é que você pode ter qualquer duração arbitrária e formatá-la com uma string semelhante às strings de formato de data de momento, por exemplo. duration.format ("d [d] hh: mm: ss") -> 2d 03:47:24

Você também pode definir a precisão decimal arbitrária no valor final, por exemplo. duration.format ("h [hrs]", 3) -> 42.384 hrs

+1 para duration.format

Publiquei meu plugin moment.duration.format:
https://github.com/jsmreese/moment-duration-format

Casos de teste e alguns exemplos estão no projeto.
Meu plugin depende de lodash e underscore.string.

+1 duration.format ()

Este tíquete foi aberto há mais de um ano. Duvido que algum dia seja implementado.

@ Maxwell2022 Postei um plugin moment.duration.format há uma semana ou mais:
https://github.com/jsmreese/moment-duration-format

Será que isso funciona para você?

+1 para isso também. Parece uma omissão muito perceptível em uma biblioteca abrangente.

https://github.com/rmm5t/jquery-timeago pode ser um bom modelo de como podemos implementar isso no Moment ...

@schmod Eu postei um plugin moment.duration.format no mês passado:
https://github.com/jsmreese/moment-duration-format

Isso funciona para seus casos de uso?

: +1:!

Isso funcionaria para mim (mas não funcionaria por durações> 24h):

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

@jsmreese seu https://github.com/jsmreese/moment-duration-format ser dependente do LoDash é um verdadeiro obstáculo. Já usamos o sublinhado e não posso justificar uma mudança para o LoDash apenas por esse pequeno recurso. Se seu plugin fosse independente de ambos, isso o tornaria uma opção mais viável para muitas pessoas, eu acho.

@wleeper Concordo absolutamente.

Acontece que meu ambiente usa LoDash e Underscore.String, então usei métodos dessas bibliotecas - eu precisava da minha primeira versão há alguns meses e só queria implementá-la e colocá-la em prática.

Vou remover essas dependências em breve.

@wleeper Underscore e LoDash devem ser intercompatíveis. Contanto que @jsmreese não esteja usando nada que não esteja na compilação Underscore do LoDash, você deve ser capaz de usar o plugin como está sem nenhum problema.

@ Chall8908 É isso, e @wleeper está certo - eu _estou_ usando recursos do LoDash que não fazem parte da construção do Underscore.

Removi a dependência Underscore.String e estou trabalhando na compatibilidade de Underscore.

Embora o plug-in de formato de duração de momento resolva um desses problemas, acho que precisamos de uma abordagem que funcione em todas as localidades (o que é, reconhecidamente, muito mais difícil).

Acho que precisamos trabalhar na implementação do # 1241, o que abriria muitas portas em termos de renderização de datas legíveis, datas relativas, durações e listas em localidades. formatDuration seria bastante trivial de implementar se o Moment tivesse acesso aos dados da linguagem CLDR.

A biblioteca Globalize da jQuery está trabalhando para lidar com muitos dos mesmos problemas e parece lógico colaborar com eles. O Twitter também já tem uma biblioteca muito abrangente que faz muito esse tipo de coisa ...

OK, aqui está uma API implementável em cima do CLDR. O que você acha?

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: qual é a unidade mínima a usar. min: dias, significa não dizer horas, minutos, segundos, mas arredondado para dias se a duração for menor que um dia
• max: qual é a unidade máxima a ser usada. max: dias, significa não usar meses e anos, mas sim o respectivo número de dias
• comprimento: tamanho dos tokens: dia vs d para inglês
• abs: futuro / passado independente

: +1: +1

: +1:

+1 duration.format

+1 duration.format

+1

+1

+1

Gostaria que isso exibisse o tempo de execução de algo.

+1

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

Momento-duração-formato versão 1.2.1 é publicado no NPM.
É funcional no Node.js e no navegador.
Ele depende do Lo-Dash ou do Underscore, mas agora foi testado e funcional com ambos.
A dependência Underscore.String original foi removida.

Vou publicar esta versão no Bower assim que os problemas de registro / cancelamento de registro do pacote Bower atual forem resolvidos.

+1 para formato de duração

Adoraria que isso se tornasse parte da biblioteca.

+1

+1

+1

: +1:

+1 para duration.format ()

+1

Ah, sim, eu definitivamente estaria dentro, pelo menos para ser capaz de fazer moment.duration(3, 'seconds').get('ss') para produzir com valores zero à esquerda.

Qual é o estado desta solicitação? Que ajuda é necessária para progredir nisso?

@oncletom
Isso existe: https://github.com/jsmreese/moment-duration-format/
E pode fazer o que quiser, se não se importar com a dependência de Lo-Dash ou Underscore.
Algum dia, em breve, vou arranjar um tempo para remover essa dependência ...

ficou surpreso que https://github.com/jsmreese/moment-duration-format/ não está em stdlib quando humanize está. Acho que isso viola o princípio da menor surpresa. No mínimo, voltar a um formato numérico simples deve ser possível:

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

Por enquanto estou usando:

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

Adoraria ver isso em breve como parte do moment.js

+1

+1

Em uma nota relacionada, duration.toString() retorna [Object object] . Não deveria retornar humanize() ?

O +1 adoraria ter mais controle sobre isso.

+1

Acabou de publicar o formato de duração do momento 1.3.0, que remove a dependência anterior do Lo-Dash ou do Underscore. Agora, a única dependência é o próprio Moment.js.

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

@jsmreese Bom homem! : cervejas:

@jsmreese cool. !
Por que isso não fez parte do próprio moment.js, não entendi. humanizar não é tão útil sem precisão, por que eu iria querer arredondar 1h e 30minutos para 1 hora? .. Não há caso de uso para isso.

+1, o plugin de jsmreese funciona brilhantemente, mas seria bom se fizesse parte do moment.js.

+1. Esse recurso deve estar dentro e fora humanizado.

+1 para duration.format

@jsmreese publicou seu plugin há cerca de um ano, e esta edição foi aberta há dois anos. @timrwood @ichernev Podemos colocar isso na biblioteca principal do moment.js?

+1

+1

: +1: para duration.format

+1

: +1:

+1

Qual é o status atual disso?

Talvez o mantenedor esteja esperando até atingirmos 1000, ou a véspera de ano novo? @icambron

@gkatsanos - Não sou mais ativo em ajudar a manter o Moment (e sempre fui apenas um ajudante), mas minha recomendação é uma solicitação de pull bem testada. Certamente há alguém solicitando isso e realmente quer codificá-lo.

@icambron já existe como um plugin .. o que há mais para fazer?
quem é o mantenedor btw?

@icambron pode apontar para o plugin?

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

e parece ser um plugin muito bem formado. exceto o fato de que depende de lodash vez de underscore , existem outras coisas que impedem torná-lo como PR .. parece ser a porta de lodash para underscore não deve ser tão difícil. / cc @jsmreese

@alexanderbeletsky @gkatsanos Na verdade, removi a lodash ou underscore há um tempo.

Um dos maiores obstáculos para o meu plug-in ser incluído no núcleo do Moment.js é a falta de suporte total a i18n.

E essa é uma grande preocupação para mim, pessoalmente. Os vários idiomas suportados são uma grande coisa para mim, e eu odiaria chegar a uma situação em que o recurso A funcione em qualquer idioma, mas o recurso B é apenas em inglês.

@jsmreese talvez se criar algumas tarefas bem definidas em seu repositório, do que exatamente precisa ser feito - eu definitivamente pularia para ajudar.

@mattgrande @alexanderbeletsky Os tokens de formato já são personalizáveis ​​e o modelo de formato é arbitrário, então isso não é um problema.

Os modelos de formato padrão não são localizados de forma alguma, e você não pode localizar o ponto decimal ou adicionar qualquer tipo de formatação de número localizado aos valores. Isso é tudo o que está faltando na minha cabeça.

: +1:

+1 duration.format!

muuuito .... qual é o problema com isso?

Estou apenas entrando para observar algumas coisas, já que há um milhão de comentários aqui. Não sou o mantenedor e não sou mais ativo neste projeto, mas tenho quase certeza de duas coisas:

1. Pessoal, você pode apenas usar o plugin de @jsmreese . Parece ótimo! Plugins são coisas boas! ( @jsmreese , se você quiser, pode adicioná-lo à lista de plug-ins do Moment na documentação com um PR aqui: https://github.com/moment/momentjs.com)
2. Não será incluído no núcleo do Moment até que alguém a) ​​internacionalize-o, b) integre os testes nos testes do Moment ec) submeta um PR. Definitivamente não vai

+1 duration.format

+1 duration.format!

+1 duration.format

+1 duration.format. Nosso caso é que queremos fornecer uma função onde se possa passar uma quantidade de segundos e uma string que os formate. No momento, estamos fazendo isso com moment.startof ("w"). Add ("s", nrOfSeconds) .format (customFormatString);

Infelizmente, na semana passada, isso gerou um erro, pois startof ("w") é domingo e no domingo era horário de verão, então faltou uma hora. Claro que podemos verificar isso com isDSTShifted (), mas ainda seria incrível não ter que converter uma duração em uma data apenas para formatá-la.

+1 duration.format

+1 duration.format

+1 para duration.format

+1 para duration.format

Podemos fechar isso porque, aparentemente, ninguém que marcou com +1 realmente lê este tópico?

Na quarta-feira, 10 de junho de 2015, 08:30 SamFromDaUk [email protected] escreveu:

+1 para duration.format

-
Responda a este e-mail diretamente ou visualize-o no GitHub
https://github.com/moment/moment/issues/463#issuecomment -110751635.

OU, consertar?

George, acho que aqueles que estão adicionando +1 estão discordando implicitamente e
simplesmente deseja esses recursos.

Se as notificações estão irritando você, considere cancelar a inscrição
fio.
Em 11 de junho de 2015, 00:07, "George Katsanos" [email protected] escreveu:

OU, consertar?

-
Responda a este e-mail diretamente ou visualize-o no GitHub
https://github.com/moment/moment/issues/463#issuecomment -110767322.

Todo o motivo pelo qual o github não tem um recurso de voto (no meu entendimento) é porque ele desencoraja a discussão.

Você pode discordar implicitamente o quanto quiser, isso não é útil. Se você discordar, isso é ótimo, leia o tópico e forneça seus argumentos (especificamente, quaisquer novos argumentos ou quaisquer pontos que você acha que foram mal considerados).

Ainda estou inscrito porque _ acho_ que ainda há alguns argumentos interessantes a serem apresentados, estou ansioso para ouvi-los, mas a equipe não deve ceder à mera pressão dos colegas.

Posso confirmar que o plugin @icambron mencionado acima funciona.

Se você for como eu, você quer um .fromNow() com saída mais ampla (como a contagem regressiva de envio da Amazon). Veja como fazer isso:

// 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"

Sim, também devo deixar claro - moment.duration (). format () funciona com este plugin: https://github.com/jsmreese/moment-duration-format

se você estiver usando meteoro, vá para oaf:moment-duration-format

Isso não parece estar funcionando para mim, estou usando o momento .diff entre duas vezes, o que funciona, o problema é quando é entre "pm" e "am", digamos que estou viajando às 21h e pousando 2h, devo obter o tempo correto.

@ Markj89 você precisa abrir um tópico stackoverflow.

+1

+1

+1

: +1:

1 em fechar este assunto. usar o plugin é uma solução sólida.

+1

+1

+1 em .format()

+1, ainda não implementado após 4 anos? : D

+1

Btw. Eu acho que deveria ser possível analisar o formato humanizado também. Por exemplo, não é tão difícil analisar 7 days and 5 hours ...

Só queria enfatizar que o plugin de @jsmreese funcionou muito bem!

: +1:

+1 duration.format

Formato de duração +1

+1 duration.format

+1 duration.format

: +1:

Vou encerrar em favor de # 1048. Isso não significa que acabou, nós apenas tivemos dois problemas que já existem há vários anos e ambos se resumem a 'fazer formatação de duração'. O outro explica isso mais claramente.

+1 duration.format

+1 duration.format

+1

Use .localeData (). RelativeTime (45, true, 'mm') e obtenha 45 minutos e assim por diante;)

1 Falamos muito sobre isso e ainda não foi implementado. Existe até um pacote separado para este https://github.com/jsmreese/moment-duration-format

para exibir a duração em qualquer formato, basta converter a duração em ms e depois em momento:
moment(duration.as('milliseconds')).format('HH:mm:ss')

Obrigado! Isso está nos documentos? Eu não vi isso ...

Isso não está nos documentos porque não funciona. É um hack que usa a época unix para interpretar os milissegundos como um ponto no tempo desde a época. Portanto, ele não funciona se sua duração for de 24 horas ou mais.

Algumas coisas sobre este código:

1. Um token hh é um token destinado a ser usado com AM / PM, então sua duração será de até 12

2. Mesmo se você usar um token HH, que vai até 23, sua duração não pode ser maior do que 23: 59: 59.999, pois as coisas passarão para a próxima data

3. Enquanto este código é escrito, ele só funcionará em um servidor que esteja em UTC. Qualquer navegador em um fuso horário diferente produzirá resultados inesperados.

Se você deseja usar este hack, ele deve ser escrito como:

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

Mas, como indiquei, isso só funcionará se sua duração for inferior a 24 horas. Acima disso, de volta à estaca zero.

Obrigado. Levei um tempo hoje para descobrir que se pode concatenar .minutes() com .seconds() . Pode me chamar de estúpido, mas não era óbvio para mim pelos documentos qual a diferença entre .seconds() e .asSeconds() imediatamente ... Mas agora vejo que está realmente lá! :)

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

Vou ficar com este método.

@elasticsteve Provavelmente, você também desejará adicionar um zero à esquerda à parte dos segundos, se for menor que dez. :piscadela:

@butterflyhug @elasticsteve essa é realmente a principal razão pela qual eu queria usar format . no meu caso é um simples contador de tempo curto, então a solução de @maggiepint é suficiente para minhas necessidades.
moment.utc(duration.asMilliseconds()).format('HH:mm:ss')

@sagivo bom ponto! Agora, a solução @maggiepint parece mais atraente. Meu servidor é UTC de qualquer maneira.

Claro, eu entendo totalmente. Eu também usei esse hack no código de produção. Mas eu não o recomendaria como uma solução geral (exceto alguns casos de uso específicos), porque há muitas situações em que falha muito. (Por exemplo, durações negativas são outro caso de falha importante que não foi explicitamente mencionado ainda.)

+1

+1 duration.format () !!!!!!!!!

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1

+1 durações difíceis de depurar

+1

Você pode facilmente fazer 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.

Solicite um usuário do twitter @Toon_Ladyboy

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

Você pode facilmente fazer 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.

Feio, mas eficaz.

2019, ainda precisa desse recurso.

Um parâmetro simples em humanizar, .eg humanize(precise: true) , que contornasse todos os arredondamentos, seria o suficiente para deixar todos felizes. Além disso, o arredondamento é a parte difícil de implementar. O resto é simplesmente converter uma duração como qualquer outra formatação feita com format ().

Existe um ótimo método moment chamado fromNow() que retornará a hora de uma hora específica em uma boa forma legível por humanos, como este:

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

Ou se você quiser entre duas datas específicas, pode usar:

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

Retirado do Docs:

• fromNow()
• from()

Isso pode ser reaberto? Esta é uma funcionalidade muito básica.

No meu caso, encontrei um pacote que resolveu meus problemas:
https://github.com/EvanHahn/HumanizeDuration.js

Talvez seja útil para outra pessoa também. :)

Julho de 2019 e este recurso ainda não está disponível.

Julho de 2019 e este recurso ainda não está disponível.

Ainda não experimentei, mas acabei de perceber isso!
npm install moment-duration-format

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

Ainda faltam oficialmente este recurso em setembro de 2019

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

Também gostaria de ter esse recurso

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

Caso alguém esteja se perguntando por que isso foi fechado: https://github.com/moment/moment/issues/463#issuecomment -228543000

Isso não é de forma alguma o ideal, mas acabei fazendo algo assim como uma solução alternativa. Eu tinha um objeto duration com uma contagem regressiva para desconectar o usuário após inatividade e queria formatar o tempo 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');
}

Uma solução hacky minha:

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

Eu uso o seguinte método, pode ser útil para outra pessoa :)

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

(Eu uso apenas para formatar durações entre 00:00 e 23:59)

Ainda preciso disso

Esses 'get' ajudam a formatar da maneira que você quiser:

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

O que eu trabalho:

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

Julho de 2019 e este recurso ainda não está disponível.

Ainda não experimentei, mas acabei de perceber isso!
npm install moment-duration-format

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

Isso funciona perfeitamente bem :)

O jogo acabou :)

Obrigado, aprecio isso !!!

De: Aleksey Makas [email protected]
Enviado: sexta-feira, 9 de outubro de 2020 11h03
Para: momento / momento [email protected]
Cc: Douglas Aguiar [email protected] ; Comentário [email protected]
Assunto: Re: [momento / momento] Duração faltando recursos (# 463)

O jogo acabou :)

-
Você está recebendo isso porque comentou.
Responda a este e-mail diretamente, visualize-o no GitHub https://github.com/moment/moment/issues/463#issuecomment-706200427 ou cancele a inscrição https://github.com/notifications/unsubscribe-auth/AGD22DRNGNIQMOJFQY7VW3DSJ4J4VANCNFSLAM4ABR .