Quase qualquer tipo de aplicativo escrito em JavaScript funciona com horas ou datas de alguma forma. No início, isso estava limitado à API Date integrada. Esta API inclui funcionalidades básicas, mas é bastante limitada no que pode fazer. Bibliotecas de terceiros, como Moment.js, e APIs integradas posteriores, como as APIs Intl e a nova API Temporal, adicionam muito mais flexibilidade ao trabalho com horários e datas. A ascensão e queda do Moment.js Moment.js é uma biblioteca JavaScript com utilitários poderosos para trabalhar com horas e datas. Inclui recursos ausentes da API de data básica, como manipulação de fuso horário, e simplifica muitas operações comuns. O Moment também inclui funções para formatação de datas e horas. Tornou-se uma biblioteca amplamente utilizada em muitas aplicações diferentes. No entanto, o Moment também teve sua cota de problemas. É uma biblioteca grande e pode aumentar significativamente o tamanho do pacote de um aplicativo. Como a biblioteca não suporta trepidação de árvore (um recurso dos empacotadores modernos que podem remover partes não utilizadas das bibliotecas), toda a biblioteca Moment está incluída mesmo se você usar apenas uma ou duas de suas funções. Outro problema do Moment é o fato de que os objetos que ele cria são mutáveis. Chamar certas funções em um objeto Moment tem efeitos colaterais e altera o valor desse objeto. Isso pode levar a comportamentos inesperados ou bugs. Em 2020, os mantenedores do Moment decidiram colocar a biblioteca em modo de manutenção. Nenhum desenvolvimento de novos recursos está sendo feito e os mantenedores recomendam não usá-lo para novos projetos. Existem outras bibliotecas de data JavaScript, como date-fns, mas há um novo player na cidade, uma API incorporada diretamente no JavaScript: Temporal. É um novo padrão que preenche as lacunas da API Date original e também resolve algumas das limitações encontradas no Moment e em outras bibliotecas. O que é temporal? Temporal é uma nova API de hora e data adicionada ao padrão ECMAScript, que define o JavaScript moderno. Em março de 20266, atingiu o Estágio 4 do processo TC39 (o comitê que supervisiona propostas e adições à linguagem JavaScript) e será incluído na próxima versão da especificação ECMAScript. Já foi implementado em vários navegadores: Chrome 144+ e Firefox 139+, com o Safari esperado em breve. Um polyfill também está disponível para navegadores não suportados e Node.js. A API Temporal cria objetos que, geralmente, representam momentos no tempo. Podem ser carimbos de tempo integral e de data em um determinado fuso horário ou podem ser uma instância genérica de horário de “relógio de parede” sem qualquer fuso horário ou informação de data. Algumas das principais características do Temporal incluem:
Horas com ou sem datas. Um objeto Temporal pode representar uma hora específica em uma data específica ou uma hora sem qualquer informação de data. Uma data específica, sem hora, também pode ser representada. Suporte a fuso horário. Os objetos temporais reconhecem totalmente o fuso horário e podem ser convertidos em diferentes fusos horários. O Moment também oferece suporte a fusos horários, mas requer a biblioteca adicional de fuso horário. Imutabilidade. Depois que um objeto Temporal é criado, ele não pode ser alterado. As conversões aritméticas de tempo ou de fuso horário não modificam o objeto subjacente. Em vez disso, eles geram um novo objeto Temporal. Indexação baseada em 1. Uma fonte comum de bugs na API Date (assim como no Moment) é que os meses são indexados em zero. Isso significa que janeiro é o mês 0, e não o mês 1, como todos entendemos na vida real. Temporal corrige isso usando indexação baseada em 1 – janeiro é o mês 1. Ele está embutido no navegador. Como o Temporal é uma API no próprio navegador, ele não acrescenta nada ao tamanho do pacote do seu aplicativo.
Também é importante observar que a API Date não irá desaparecer. Embora Temporal substitua esta API, ela não está sendo removida ou obsoleta. Muitos aplicativos quebrariam se os navegadores removessem repentinamente a API Date. No entanto, lembre-se também de que o Moment agora é considerado um projeto legado em modo de manutenção. No restante do artigo, veremos algumas “receitas” para migrar código baseado em Moment para a nova API Temporal. Vamos começar a refatorar! Criando objetos de data e hora Antes de podermos manipular datas e horas, temos que criar objetos que as representem. Para criar um objeto Moment representando a data e hora atuais, use a função moment. const agora = momento(); console.log(agora); // Momento<2026-02-18T21:26:29-05:00>
Este objeto agora pode ser formatado ou manipulado conforme necessário.
//converte para UTC //aviso: Isso altera o objeto Moment e o coloca no modo UTC! console.log(agora.utc()); // Momento<2026-02-19T02:26:29Z>
// imprime uma string formatada - observe que agora ela está usando o horário UTC console.log(now.format('MM/DD/AAAA hh:mm:ss a')); // 19/02/2026 02:27:07
A principal coisa a lembrar sobre Moment é que um objeto Moment sempre inclui informações sobre a hora e a data. Se você só precisa trabalhar com informações de horário, isso geralmente é bom, mas pode causar um comportamento inesperado em situações como horário de verão ou anos bissextos, onde a data pode afetar os cálculos de horário. Temporal é mais flexível. Você pode criar um objeto que representa a data e hora atuais criando um objeto Temporal.Instant. Isto representa um ponto no tempo definido pelo tempo desde “a época” (meia-noite UTC de 1º de janeiro de 1970). Temporal pode fazer referência a esse instante no tempo com precisão de nanossegundos. const agora = Temporal.Now.instant();
// vê nanossegundos brutos desde a época console.log(now.epochNanoseconds); //1771466342612000000n
//formato para UTC console.log(now.toString()); //2026-02-19T01:55:27.844Z
//formato para um fuso horário específico console.log(now.toString({ fuso horário: 'América/Nova_Iorque' })); // 2026-02-18T20:56:57.905-05:00
Os objetos Temporal.Instant também podem ser criados para uma hora e data específicas usando o método estático from.
const meuInstant = Temporal.Instant.from('2026-02-18T21:10:00-05:00');
//Formate o instante no fuso horário local. Observe que isso controla apenas // a formatação - ela não altera o objeto como moment.utc faz. console.log(myInstant.toString({timeZone: 'América/Nova_Iorque' })); // 2026-02-18T21:10:00-05:00
Você também pode criar outros tipos de objetos temporais, incluindo:
Temporal.PlainDate: Uma data sem informação de hora. Temporal.PlainTime: Uma hora sem informação de data. Temporal.ZonedDateTime: uma data e hora em um fuso horário específico.
Cada um deles possui um método from que pode ser chamado com um objeto especificando a data e/ou hora, ou uma string de data para analisar. // Apenas um encontro const hoje = Temporal.PlainDate.from({ ano: 2026, mês: 2, // observe que estamos usando 2 para fevereiro dia: 18 }); console.log(hoje.toString()); // 18/02/2026
// Só um tempo const LunchTime = Temporal.PlainTime.from({ hora: 12 }); console.log(lunchTime.toString()); // 12:00:00
// Uma data e hora no fuso horário do leste dos EUA const dueAt = Temporal.ZonedDateTime.from({ Fuso horário: 'América/Nova_Iorque', ano: 2026, mês: 3, dia: 1, hora: 12, minuto: 0, segundo: 0 }); console.log(dueAt.toString()); // 2026-03-01T12:00:00-05:00[América/Nova_Iorque]
Análise Abordamos a criação programática de informações de data e hora. Agora vamos dar uma olhada na análise. A análise é uma área em que o Moment é mais flexível do que a API Temporal integrada. Você pode analisar uma string de data passando-a para a função moment. Com um único argumento, o Moment espera uma string de data ISO, mas você pode usar formatos alternativos se fornecer um segundo argumento especificando o formato de data que está sendo usado.
const isoDate = momento('2026-02-21T09:00:00'); const data formatada = momento('21/02/26 9:00:00', 'M/D/AA h:mm:ss');
console.log(isoDate); // Momento<2026-02-21T09:00:00-05:00>
console.log(dataformatada); // Momento<2026-02-21T09:00:00-05:00>
Em versões mais antigas, o Moment faria o melhor palpite para analisar qualquer sequência de data formatada arbitrariamente. Isso pode levar a resultados imprevisíveis. Por exemplo, 02-03-2026 é 2 de fevereiro ou 3 de março? Por esse motivo, as versões mais recentes do Moment exibem um aviso de descontinuação proeminente se for chamado sem uma string de data formatada em ISO (a menos que o segundo argumento com o formato desejado também seja fornecido). Temporal analisará apenas uma sequência de data formatada especificamente. A string deve ser compatível com o formato ISO 8601 ou sua extensão, RFC 9557. Se uma string de data não compatível for passada para um método from, Temporal lançará um RangeError.
// Usando uma string de data RFC 9557 const myDate = Temporal.Instant.from('2026-02-21T09:00:00-05:00[América/Nova_Iorque]'); console.log(myDate.toString({ fuso horário: 'América/Nova_Iorque' })); //2026-02-21T09:00:00-05:00
//Usando uma string de data desconhecida const otherDate = Temporal.Instant.from('21/02/26 9:00:00'); // RangeError: Erro temporal: Caractere inválido ao analisar o valor do ano.
Os requisitos exatos da string de data dependem do tipo de objeto Temporal que você está criando. No exemplo acima, Temporal.Instant requer um ISO completoString de data 8601 ou RFC 9557 especificando a data e a hora com um deslocamento de fuso horário, mas você também pode criar objetos PlainDate ou PlainTime usando apenas um subconjunto do formato de data. const minhaDate = Temporal.PlainDate.from('2026-02-21'); console.log(myDate.toString()); //2026-02-21
const meuTime = Temporal.PlainTime.from('09:00:00'); console.log(myTime.toString()); // 09:00:00
Observe que essas strings ainda devem estar em conformidade com o formato esperado ou um erro será gerado.
// Usando strings de tempo não compatíveis. Tudo isso gerará um RangeError. Temporal.PlainTime.from('9:00'); Temporal.PlainTime.from('9:00:00');
Dica profissional: Manipulação de strings não ISO Como o Temporal prioriza a confiabilidade, ele não tentará adivinhar o formato de uma string como 01/02/2026. Se sua fonte de dados usar essas strings, você precisará fazer alguma manipulação de string para reorganizar os valores em uma string ISO como 2026-02-01 antes de tentar usá-la com Temporal.
Formatação Depois de ter um objeto Moment ou Temporal, você provavelmente desejará convertê-lo em uma string formatada em algum momento. Este é um exemplo em que Moment é um pouco mais conciso. Você chama o método de formato do objeto com uma sequência de tokens que descreve o formato de data desejado. const data = momento();
console.log(data.format('MM/DD/AAAA')); // 22/02/2026
console.log(date.format('MMMM Do YYYY, h:mm:ss a')); // 22 de fevereiro de 2026, 20h18h30
Por outro lado, Temporal exige que você seja um pouco mais detalhado. Objetos temporais, como Instant, possuem um método toLocaleString que aceita várias opções de formatação especificadas como propriedades de um objeto.
data const = Temporal.Now.instant();
// sem argumentos, obteremos o formato padrão para a localidade atual console.log(date.toLocaleString()); // 22/02/2026, 20:23:36 (assumindo a localidade en-US)
//passa opções de formatação para gerar uma string de formato personalizado console.log(date.toLocaleString('en-US', { mês: 'longo', dia: 'numérico', ano: 'numérico', hora: '2 dígitos', minuto: '2 dígitos' })); // 22 de fevereiro de 2026 às 20h23
//passa apenas os campos que você deseja na string de formato console.log(date.toLocaleString('en-US', { mês: 'curto', dia: 'numérico' })); // 22 de fevereiro
A formatação de data temporal, na verdade, usa a API Intl.DateTimeFormat (que já está disponível em navegadores modernos) nos bastidores. Isso significa que você pode criar um objeto DateTimeFormat reutilizável com suas opções de formatação personalizada e, em seguida, passar objetos Temporais para seu método de formatação. Por causa disso, ele não oferece suporte a formatos de data personalizados como o Moment. Se precisar de algo como 'Q1 2026' ou outra formatação especializada, você pode precisar de algum código de formatação de data personalizado ou procurar uma biblioteca de terceiros. formatador const = new Intl.DateTimeFormat('en-US', { mês: '2 dígitos', dia: '2 dígitos', ano: 'numérico' });
data const = Temporal.Now.instant(); console.log(formatter.format(data)); // 22/02/2026
Os tokens de formatação do Moment são mais simples de escrever, mas não são compatíveis com o local. As strings de formato “código rígido” coisas como ordem mês/dia. A vantagem de usar um objeto de configuração, como o Temporal faz, é que ele se adaptará automaticamente a qualquer localidade e usará o formato correto. data const = Temporal.Now.instant();
const formatoOptions = { mês: 'numérico', dia: 'numérico', ano: 'numérico' };
console.log(date.toLocaleString('en-US', formatOptions)); // 22/02/2026
console.log(date.toLocaleString('en-GB', formatOptions)); //22/02/2026
Cálculos de data Em muitas aplicações, você precisará realizar alguns cálculos em uma data. Você pode adicionar ou subtrair unidades de tempo (dias, horas, segundos, etc.). Por exemplo, se você tiver a data atual, talvez queira mostrar ao usuário a data daqui a 1 semana. Objetos de momento possuem métodos como adição e subtração que executam essas operações. Estas funções recebem um valor e uma unidade, por exemplo: add(7, 'days'). Uma diferença muito importante entre Momento e Temporal, entretanto, é que ao realizar esses cálculos de data, o objeto subjacente é modificado e seu valor original é perdido. const agora = momento();
console.log(agora); // Momento<2026-02-24T20:08:36-05:00>
const próxima semana = agora.add(7, 'dias'); console.log(próxima semana); // Momento<2026-03-03T20:08:36-05:00>
// Entendi - o objeto original sofreu mutação console.log(agora); // Momento<2026-03-03T20:08:36-05:00>
Para evitar perder a data original, você pode chamar clone no objeto Moment para criar uma cópia. const agora= momento(); const nextWeek = now.clone().add(7, 'dias');
console.log(agora); // Momento<2026-02-24T20:12:55-05:00>
console.log(próxima semana); // Momento<2026-03-03T20:12:55-05:00>
Por outro lado, os objetos temporais são imutáveis. Depois de criar um objeto como Instant, PlainDate e assim por diante, o valor desse objeto nunca mudará. Objetos temporais também possuem métodos de adição e subtração. Temporal é um pouco exigente sobre quais unidades de tempo podem ser adicionadas a quais tipos de objetos. Por exemplo, você não pode adicionar dias a um Instant:
const agora = Temporal.Now.instant(); const nextWeek = now.add({ dias: 7 }); // RangeError: Erro temporal: a maior unidade não pode ser uma unidade de data
Isso ocorre porque os objetos Instant representam um ponto específico no tempo em UTC e são independentes de calendário. Como a duração de um dia pode mudar com base nas regras de fuso horário, como o horário de verão, esse cálculo não está disponível em um Instant. Você pode, no entanto, executar esta operação em outros tipos de objetos, como PlainDateTime: const agora = Temporal.Now.plainDateTimeISO(); console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
const nextWeek = now.add({ dias: 7 });
// Observe que o PlainDateTime original permanece inalterado console.log(now.toLocaleString()); // 24/02/2026, 20:23:59
console.log(nextWeek.toLocaleString()); // 03/03/2026, 20:23:59
Você também pode calcular quanto tempo existe entre dois objetos Moment ou Temporais. Com a função diff do Moment, você precisa fornecer uma unidade de granularidade, caso contrário ela retornará a diferença em milissegundos. const data1 = momento('2026-02-21T09:00:00'); const data2 = momento('2026-02-22T10:30:00');
console.log(data2.diff(data1)); //91800000
console.log(data2.diff(data1, 'dias')); //1
Para fazer isso com um objeto Temporal, você pode passar outro objeto Temporal para seus métodos Until ou Since. Isso retorna um objeto Temporal.Duration contendo informações sobre a diferença horária. O objeto Duration possui propriedades para cada componente da diferença e também pode gerar uma string de duração ISO 8601 representando a diferença horária.
const data1 = Temporal.PlainDateTime.from('2026-02-21T09:00:00'); const data2 = Temporal.PlainDateTime.from('2026-02-22T10:30:00');
//maiorUnit especifica a maior unidade de tempo a ser representada // no cálculo da duração const diff = data2.since(data1, {maiorUnit: 'dia' });
console.log(diff.dias); //1
console.log(diff.horas); //1
console.log(diff.minutos); //30
console.log(diff.toString()); //P1DT1H30M // (string de duração ISO 8601: 1 dia, 1 hora, 30 minutos)
Comparando datas e horários Moment e Temporal permitem comparar datas e horários para determinar o que vem antes do outro, mas adotam abordagens diferentes com a API. Moment fornece métodos como isBefore, isAfter e isSame para comparar dois objetos Moment. const data1 = momento('2026-02-21T09:00:00'); const data2 = momento('2026-02-22T10:30:00');
console.log(data1.isBefore(data2)); // verdadeiro
Temporal usa um método de comparação estático para realizar uma comparação entre dois objetos do mesmo tipo. Retorna -1 se a primeira data vier antes da segunda, 0 se forem iguais ou 1 se a primeira data vier depois da segunda. O exemplo a seguir mostra como comparar dois objetos PlainDate. Ambos os argumentos para Temporal.PlainDate.compare devem ser objetos PlainDate.
const date1 = Temporal.PlainDate.from({ ano: 2026, mês: 2, dia: 24 }); const date2 = Temporal.PlainDate.from({ ano: 2026, mês: 3, dia: 24 });
//data1 vem antes da data2, então -1 console.log(Temporal.PlainDate.compare(data1, data2));
//Erro se tentarmos comparar dois objetos de tipos diferentes console.log(Temporal.PlainDate.compare(data1, Temporal.Now.instant())); // TypeError: Erro temporal: campos PlainDate inválidos fornecidos.
Em particular, isso facilita a classificação cronológica de uma matriz de objetos temporais. // Uma matriz de objetos Temporal.PlainDate datas constantes = [...];
// usa Temporal.PlainDate.compare como função comparadora datas.sort(Temporal.PlainDate.compare);
Conversões de fuso horário A biblioteca principal do Moment não oferece suporte a conversões de fuso horário. Se precisar dessa funcionalidade, você também precisará instalar o pacote moment-timezone. Este pacote não pode ser abalado em árvore e, portanto, pode aumentar significativamente o tamanho do seu pacote. Depois de instalar o moment-timezone, você pode converter objetos Moment em fusos horários diferentes com o método tz. Tal como acontece com outras operações do Moment, isso altera o subjacenteobjeto. // Assumindo o horário do Leste dos EUA const agora = momento(); console.log(agora); // Momento<2026-02-28T20:08:20-05:00>
// Converte para o horário do Pacífico. // O horário original do Leste foi perdido. now.tz('América/Los_Angeles'); console.log(agora); // Momento<2026-02-28T17:08:20-08:00>
A funcionalidade de fuso horário é incorporada à API Temporal ao usar um objeto Temporal.ZonedDateTime. Esses objetos incluem um método withTimeZone que retorna um novo ZonedDateTime representando o mesmo momento, mas no fuso horário especificado. // Novamente, assumindo o horário do Leste dos EUA const agora = Temporal.Now.zonedDateTimeISO(); console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
// Converte para horário do Pacífico const nowPacific = now.withTimeZone('América/Los_Angeles'); console.log(nowPacific.toLocaleString()); // 28/02/2026, 17:12:02 PST
//O objeto original permanece inalterado console.log(now.toLocaleString()); // 28/02/2026, 20:12:02 EST
Nota: Os valores formatados retornados por toLocaleString são, como o nome indica, dependentes da localidade. O código de amostra foi desenvolvido na localidade en-US, portanto, o formato é assim: 28/02/2026, 17:12:02 PST. Em outra localidade, isso pode ser diferente. Por exemplo, na localidade en-GB, você obteria algo como 28/2/2026, 17:12:02 GMT-8. Uma refatoração do mundo real Suponha que estejamos criando um aplicativo para agendar eventos em diferentes fusos horários. Parte deste aplicativo é uma função, getEventTimes, que utiliza uma string ISO 8601 que representa a hora e a data do evento, um fuso horário local e um fuso horário de destino. A função cria strings formatadas de hora e data para o evento em ambos os fusos horários. Se a função receber uma string de entrada que não seja uma string de hora/data válida, ocorrerá um erro. Aqui está a implementação original, usando Moment (também exigindo o uso do pacote moment-timezone).
importar momento de 'moment-timezone';
função getEventTimes(inputString, userTimeZone, targetTimeZone) { const timeFormat = 'MMM D, AAAA, h:mm:ss a z';
// 1. Crie o momento inicial no fuso horário do usuário const eventTime = momento.tz( string de entrada, moment.ISO_8601, // Espera uma string ISO 8601 true, // Análise estrita usuárioTimeZone );
// Lança um erro se inputString não representa uma data válida if (!eventTime.isValid()) { throw new Error('Entrada de data/hora inválida'); }
// 2. Calcule o tempo alvo // CRÍTICO: Devemos clonar, ou 'eventTime' mudará para sempre! const targetTime = eventTime.clone().tz(targetTimeZone);
retornar { local: eventTime.format(timeFormat), alvo: targetTime.format(timeFormat), }; }
programação const = getEventTimes( '2026-03-05T15:00-05:00', 'América/Nova_Iorque', 'Europa/Londres', );
console.log(agenda.local); // 5 de março de 2026, 15h00 EST
console.log(schedule.target); // 5 de março de 2026, 20h00 GMT
Neste exemplo, estamos usando um formato de data esperado ISO 8601, que é incorporado de forma útil ao Moment. Também estamos usando análise estrita, o que significa que o Moment não tentará adivinhar uma sequência de data que não corresponda ao formato. Se uma string de data não ISO for passada, isso resultará em um objeto de data inválido e geraremos um erro. A implementação Temporal parece semelhante, mas tem algumas diferenças importantes.
função getEventTimes(inputString, userTimeZone, targetTimeZone) { // 1. Analise a entrada diretamente em um Instant e crie // um ZonedDateTime na zona do usuário. const instantâneo = Temporal.Instant.from(inputString); const eventTime = instantâneo.toZonedDateTimeISO(userTimeZone);
// 2. Converta para a zona de destino // Isso retorna automaticamente um objeto NEW; 'eventTime' é seguro. const targetTime = eventTime.withTimeZone(targetTimeZone);
// 3. Formatar usando Intl (integrado) opções const = { ano: 'numérico', mês: 'curto', dia: 'numérico', hora: 'numérico', minuto: '2 dígitos', segundo: '2 dígitos', timeZoneName: 'curto' };
retornar { local: eventTime.toLocaleString(navigator.idioma, opções), alvo: targetTime.toLocaleString(navigator.idioma, opções) }; }
programação const = getEventTimes( '2026-03-05T15:00-05:00', 'América/Nova_Iorque', 'Europa/Londres', );
console.log(agenda.local); // 5 de março de 2026, 15h00 EST
console.log(schedule.target); // 5 de março de 2026, 20h00 GMT
Com o Moment, temos que especificar explicitamente uma string de formato para as strings de data resultantes. Independentemente da localização ou localidade do usuário, os horários dos eventos sempre serão formatados como 5 de março de 2026, 3:00:00tarde EST. Além disso, não precisamos lançar explicitamente uma exceção. Se uma string inválida for passada para Temporal.Instant.from, Temporal lançará a exceção para nós. Uma coisa a notar é que mesmo com análise rigorosa, a versão do Moment é ainda mais branda. Temporal requer o deslocamento do fuso horário no final da string. Você também deve observar que, como estamos usando navigator.language, esse código só será executado em um ambiente de navegador, pois navigator não está definido em um ambiente Node.js. A implementação Temporal usa a localidade atual do navegador (navigator.language), para que o usuário obtenha automaticamente os horários dos eventos formatados em seu formato de hora local. Na localidade en-US, é 5 de março de 2026, 15h EST. Porém, se o usuário estiver em Londres, por exemplo, os horários do evento serão formatados como 5 de março de 2026, 15h00 GMT-5. Resumo
Ação Momento.js temporal Hora atual momento() Temporal.Now.zonedDateTimeISO() Analisando ISO momento(str) Temporal.Instant.from(str) Adicionar tempo .add(7, 'dias') (mutações) .add({ dias: 7 }) (novo objeto) Diferença .diff(outro, 'horas') .since(other).horas Fuso horário .tz('Zona/Nome') .withTimeZone('Zona/Nome')
À primeira vista, a diferença pode ser uma sintaxe ligeiramente diferente (e no caso do Temporal, às vezes mais detalhada e mais estrita), mas há várias vantagens importantes em usar o Temporal em vez do Moment.js:
Ser mais explícito significa menos surpresas e bugs não intencionais. O momento pode parecer mais brando, mas envolve “adivinhações”, que às vezes podem resultar em datas incorretas. Se você der ao Temporal algo inválido, ocorrerá um erro. Se o código for executado, você sabe que tem uma data válida. O Moment pode adicionar um tamanho significativo ao pacote do aplicativo, especialmente se você estiver usando o pacote moment-timezone. Temporal não adiciona nada (uma vez enviado nos navegadores de destino). A imutabilidade lhe dá a confiança de que você nunca perderá ou substituirá dados ao realizar conversões e operações de data. Diferentes representações de tempo (Instant, PlainDateTime, ZonedDateTime) dependendo de seus requisitos, onde Moment é sempre um wrapper em torno de um carimbo de data/hora UTC. Temporal usa APIs internacionais para formatação de data, o que significa que você pode ter formatação com reconhecimento de localidade sem precisar especificar tokens explicitamente.
Notas sobre o Polyfill Conforme mencionado anteriormente, há um polyfill Temporal disponível, distribuído como um pacote npm denominado @js-temporal/polyfill. Se quiser usar o Temporal hoje, você precisará deste polyfill para oferecer suporte a navegadores como o Safari, que ainda não enviaram a API. A má notícia é que isso aumentará o tamanho do seu pacote. A boa notícia é que ainda acrescenta significativamente menos que momento ou fuso horário. Aqui está uma comparação dos tamanhos dos pacotes relatados pelo Bundlephobia.com, um site que apresenta informações sobre os tamanhos dos pacotes npm (clique no nome de cada pacote para ver a análise do Bundlephobia):
Pacote Minimizado Minificado e compactado @js-temporal/polyfill 154,1 KB 44,1 KB momento 294,4 KB 75,4 KB momento-fuso horário 1MB 114,2 KB
Historicamente, o polyfill também teve alguns problemas de desempenho relacionados ao uso de memória e, no momento em que este artigo foi escrito, era considerado em estado alfa. Por causa disso, você pode não querer usá-lo na produção até atingir um estado mais maduro. A outra boa notícia é que esperamos que o polyfill não seja necessário por muito mais tempo (a menos que você precise oferecer suporte a navegadores mais antigos, é claro). No momento em que este artigo foi escrito, o Temporal estava disponível no Chrome, Edge e Firefox. Ainda não está pronto no Safari, embora pareça estar disponível com um sinalizador de tempo de execução no Technology Preview mais recente.
