Vamos conhecer um novo objeto integrado: Date. Ele armazena a data, hora e fornece métodos para gerenciamento de data/hora.
Por exemplo, podemos usá-lo para armazenar tempos de criação/modificação, para medir o tempo ou apenas para imprimir a data atual.
Para criar um novo objeto Date , chame new Date() com um dos seguintes argumentos:
new Date()
Sem argumentos – crie um objeto Date para a data e hora atuais:
deixe agora = new Date(); alerta(agora); //mostra a data/hora atual
new Date(milliseconds)
Crie um objeto Date com o tempo igual ao número de milissegundos (1/1000 de segundo) decorridos após 1º de janeiro de 1970 UTC+0.
// 0 significa 01.01.1970 UTC+0 deixe Jan01_1970 = nova data (0); alerta(Jan01_1970); // agora adicione 24 horas, obtenha 02.01.1970 UTC+0 deixe Jan02_1970 = nova data (24 * 3600 * 1000); alerta(Jan02_1970);
Um número inteiro que representa o número de milissegundos que se passaram desde o início de 1970 é chamado de timestamp .
É uma representação numérica leve de uma data. Sempre podemos criar uma data a partir de um carimbo de data/hora usando new Date(timestamp) e converter o objeto Date existente em um carimbo de data/hora usando o método date.getTime() (veja abaixo).
Datas anteriores a 01/01/1970 possuem carimbos de data e hora negativos, por exemplo:
// 31 de dezembro de 1969 deixe 31 de dezembro de 1969 = nova data (-24 * 3600 * 1000); alerta (31 de dezembro de 1969);
new Date(datestring)
Se houver um único argumento e for uma string, ele será analisado automaticamente. O algoritmo é o mesmo que Date.parse usa, abordaremos isso mais tarde.
deixe data = nova data("2017/01/26");
alerta(data);
// A hora não está definida, então presume-se que seja meia-noite GMT e
// é ajustado de acordo com o fuso horário em que o código é executado
//Então o resultado poderia ser
// Quinta-feira, 26 de janeiro de 2017 11:00:00 GMT+1100 (horário de verão do leste da Austrália)
// ou
// Quarta, 25 de janeiro de 2017 16:00:00 GMT-0800 (horário padrão do Pacífico) new Date(year, month, date, hours, minutes, seconds, ms)
Crie a data com os componentes fornecidos no fuso horário local. Apenas os dois primeiros argumentos são obrigatórios.
O year deve ter 4 dígitos. Para compatibilidade, 2 dígitos também são aceitos e considerados 19xx , por exemplo, 98 é o mesmo que 1998 aqui, mas é altamente recomendável usar sempre 4 dígitos.
A contagem month começa em 0 (janeiro) até 11 (dezembro).
O parâmetro date é na verdade o dia do mês; se estiver ausente, será assumido 1 .
Se hours/minutes/seconds/ms estiverem ausentes, eles serão considerados iguais a 0 .
Por exemplo:
nova Data(2011, 0, 1, 0, 0, 0, 0); // 1º de janeiro de 2011, 00:00:00 nova Data(2011, 0, 1); // o mesmo, horas etc são 0 por padrão
A precisão máxima é de 1 ms (1/1000 seg):
deixe data = nova Data(2011, 0, 1, 2, 3, 4, 567); alerta(data); // 1.01.2011, 02:03:04.567
Existem métodos para acessar o ano, mês e assim por diante a partir do objeto Date :
getAnoFull()
Obtenha o ano (4 dígitos)
getMês()
Obtenha o mês, de 0 a 11 .
getData()
Obtenha o dia do mês, de 1 a 31, o nome do método parece um pouco estranho.
getHours(), getMinutes(), getSeconds(), getMilliseconds()
Obtenha os componentes de tempo correspondentes.
Não getYear() , mas getFullYear()
Muitos mecanismos JavaScript implementam um método não padrão getYear() . Este método está obsoleto. Às vezes, ele retorna um ano de 2 dígitos. Por favor, nunca use isso. Existe getFullYear() para o ano.
Além disso, podemos obter um dia da semana:
getDia()
Obtenha o dia da semana, de 0 (domingo) a 6 (sábado). O primeiro dia é sempre domingo, em alguns países não é assim, mas não pode ser alterado.
Todos os métodos acima retornam os componentes relativos ao fuso horário local.
Existem também suas contrapartes UTC, que retornam dia, mês, ano e assim por diante para o fuso horário UTC+0: getUTCFullYear(), getUTCMonth(), getUTCDay(). Basta inserir o "UTC" logo após "get" .
Se o seu fuso horário local for alterado em relação ao UTC, o código abaixo mostrará horários diferentes:
//data atual deixe data = new Data(); // a hora no seu fuso horário atual alerta(data.getHours()); // a hora no fuso horário UTC+0 (horário de Londres sem horário de verão) alerta(data.getUTCHours());
Além dos métodos fornecidos, existem dois métodos especiais que não possuem variante UTC:
getTime()
Retorna o carimbo de data/hora da data – um número de milissegundos passados desde 1º de janeiro de 1970 UTC+0.
getTimezoneOffset()
Retorna a diferença entre UTC e o fuso horário local, em minutos:
// se você estiver no fuso horário UTC-1, gera 60 // se você estiver no fuso horário UTC+3, gera -180 alerta(new Date().getTimezoneOffset() );
Os seguintes métodos permitem definir componentes de data/hora:
setFullYear(year, [month], [date])
setMonth(month, [date])
setDate(date)
setHours(hour, [min], [sec], [ms])
setMinutes(min, [sec], [ms])
setSeconds(sec, [ms])
setMilliseconds(ms)
setTime(milliseconds) (define a data inteira em milissegundos desde 01.01.1970 UTC)
Cada um deles, exceto setTime() tem uma variante UTC, por exemplo: setUTCHours() .
Como podemos ver, alguns métodos podem definir vários componentes ao mesmo tempo, por exemplo setHours . Os componentes que não são mencionados não são modificados.
Por exemplo:
deixe hoje = new Date(); hoje.setHours(0); alerta(hoje); // ainda hoje, mas a hora foi alterada para 0 hoje.setHours(0, 0, 0, 0); alerta(hoje); // ainda hoje, agora 00:00:00 em ponto.
A autocorreção é um recurso muito útil dos objetos Date . Podemos definir valores fora do intervalo e ele se ajustará automaticamente.
Por exemplo:
deixe data = nova data(2013, 0, 32); // 32 de janeiro de 2013?!? alerta(data); // ...é 1º de fevereiro de 2013!
Os componentes de data fora do intervalo são distribuídos automaticamente.
Digamos que precisamos aumentar a data “28 de fevereiro de 2016” em 2 dias. Pode ser “2 de março” ou “1 de março” no caso de ano bissexto. Não precisamos pensar sobre isso. Basta adicionar 2 dias. O objeto Date fará o resto:
deixe data = nova data(2016, 1, 28); data.setDate(data.getDate() + 2); alerta(data); // 1º de março de 2016
Esse recurso é frequentemente usado para obter a data após um determinado período de tempo. Por exemplo, vamos obter a data para “70 segundos depois de agora”:
deixe data = new Data(); date.setSeconds(date.getSeconds() + 70); alerta(data); //mostra a data correta
Também podemos definir valores zero ou até negativos. Por exemplo:
deixe data = nova data(2016, 0, 2); // 2 de janeiro de 2016 data.setData(1); //define o dia 1 do mês alerta(data); data.setData(0); // min dia é 1, então o último dia do mês anterior é assumido alerta(data); // 31 de dezembro de 2015
Quando um objeto Date é convertido em número, ele se torna o carimbo de data/hora igual a date.getTime() :
deixe data = new Data(); alerta(+data); // o número de milissegundos, igual a date.getTime()
O efeito colateral importante: as datas podem ser subtraídas, o resultado é a diferença em ms.
Isso pode ser usado para medições de tempo:
vamos começar = new Date(); //começa a medir o tempo
//fazer o trabalho
para (seja i = 0; i < 100000; i++) {
deixe fazerAlguma Coisa = i * i * i;
}
deixe terminar = new Data(); //fim do tempo de medição
alert( `O loop demorou ${end - start} ms` ); Se quisermos apenas medir o tempo, não precisamos do objeto Date .
Existe um método especial Date.now() que retorna o carimbo de data/hora atual.
É semanticamente equivalente a new Date().getTime() , mas não cria um objeto Date intermediário. Portanto, é mais rápido e não pressiona a coleta de lixo.
É usado principalmente por conveniência ou quando o desempenho é importante, como em jogos em JavaScript ou outros aplicativos especializados.
Então isso provavelmente é melhor:
vamos começar = Date.now(); // contagem de milissegundos a partir de 1º de janeiro de 1970
//fazer o trabalho
para (seja i = 0; i < 100000; i++) {
deixe fazerAlguma Coisa = i * i * i;
}
deixe terminar = Date.now(); // feito
alert( `O loop demorou ${end - start} ms` ); // subtrai números, não datasSe quisermos um benchmark confiável de funções que exigem muita CPU, devemos ter cuidado.
Por exemplo, vamos medir duas funções que calculam a diferença entre duas datas: qual é mais rápida?
Tais medições de desempenho são frequentemente chamadas de “benchmarks”.
// temos data1 e data2, qual função retorna mais rápido a diferença em ms?
function diffSubtract(data1, data2) {
data de retorno2 - data1;
}
// ou
function diffGetTime(data1, data2) {
retornar data2.getTime() - data1.getTime();
} Esses dois fazem exatamente a mesma coisa, mas um deles usa um date.getTime() explícito para obter a data em ms, e o outro depende de uma transformação de data em número. O resultado deles é sempre o mesmo.
Então, qual é mais rápido?
A primeira ideia pode ser executá-los várias vezes seguidas e medir a diferença horária. Para o nosso caso as funções são muito simples, então temos que fazer isso pelo menos 100.000 vezes.
Vamos medir:
function diffSubtract(data1, data2) {
data de retorno2 - data1;
}
function diffGetTime(data1, data2) {
retornar data2.getTime() - data1.getTime();
}
banco de funções(f) {
deixe data1 = nova data (0);
deixe data2 = nova data();
vamos começar = Date.now();
for (seja i = 0; i < 100000; i++) f(data1, data2);
retornar Date.now() - início;
}
alert('Tempo de diffSubtract: ' + bench(diffSubtract) + 'ms' );
alert('Hora do diffGetTime: ' + bench(diffGetTime) + 'ms' ); Uau! Usar getTime() é muito mais rápido! Isso porque não há conversão de tipo, é muito mais fácil para os motores otimizarem.
Ok, temos algo. Mas isso ainda não é uma boa referência.
Imagine que no momento da execução bench(diffSubtract) a CPU estivesse fazendo algo em paralelo e consumindo recursos. E no momento da execução bench(diffGetTime) esse trabalho já terminou.
Um cenário bastante real para um sistema operacional multiprocesso moderno.
Como resultado, o primeiro benchmark terá menos recursos de CPU que o segundo. Isso pode levar a resultados errados.
Para um benchmarking mais confiável, todo o pacote de benchmarks deve ser executado várias vezes.
Por exemplo, assim:
function diffSubtract(data1, data2) {
data de retorno2 - data1;
}
function diffGetTime(data1, data2) {
retornar data2.getTime() - data1.getTime();
}
banco de funções(f) {
deixe data1 = nova data (0);
deixe data2 = nova data();
vamos começar = Date.now();
for (seja i = 0; i < 100000; i++) f(data1, data2);
return Date.now() - início;
}
deixe tempo1 = 0;
deixe tempo2 = 0;
// executa bench(diffSubtract) e bench(diffGetTime) cada 10 vezes alternadas
for (seja i = 0; i < 10; i++) {
time1 += banco(diffSubtract);
time2 += banco(diffGetTime);
}
alert('Tempo total para diffSubtract: ' + time1 );
alert('Tempo total para diffGetTime: ' + time2 );Os mecanismos JavaScript modernos começam a aplicar otimizações avançadas apenas ao “código ativo” que é executado muitas vezes (sem necessidade de otimizar coisas raramente executadas). Portanto, no exemplo acima, as primeiras execuções não estão bem otimizadas. Podemos querer adicionar uma corrida de aquecimento:
// adicionado para "aquecimento" antes do loop principal
banco(diffSubtract);
banco(diffGetTime);
// agora benchmark
for (seja i = 0; i < 10; i++) {
time1 += banco(diffSubtract);
time2 += banco(diffGetTime);
}Tenha cuidado ao fazer microbenchmarking
Os mecanismos JavaScript modernos realizam muitas otimizações. Eles podem ajustar os resultados de “testes artificiais” em comparação com o “uso normal”, especialmente quando comparamos algo muito pequeno, como o funcionamento de um operador ou uma função integrada. Portanto, se você deseja realmente entender o desempenho, estude como funciona o mecanismo JavaScript. E então você provavelmente não precisará de microbenchmarks.
O excelente pacote de artigos sobre o V8 pode ser encontrado em https://mrale.ph.
O método Date.parse(str) pode ler uma data de uma string.
O formato da string deve ser: YYYY-MM-DDTHH:mm:ss.sssZ , onde:
YYYY-MM-DD – é a data: ano-mês-dia.
O caractere "T" é usado como delimitador.
HH:mm:ss.sss – é o tempo: horas, minutos, segundos e milissegundos.
A parte opcional 'Z' denota o fuso horário no formato +-hh:mm . Uma única letra Z significaria UTC+0.
Variantes mais curtas também são possíveis, como YYYY-MM-DD ou YYYY-MM ou mesmo YYYY .
A chamada para Date.parse(str) analisa a string no formato fornecido e retorna o carimbo de data/hora (número de milissegundos desde 1º de janeiro de 1970 UTC+0). Se o formato for inválido, retorna NaN .
Por exemplo:
deixe ms = Date.parse('2012-01-26T13:51:50.417-07:00');
alerta(ms); // 1327611110417 (carimbo de data/hora) Podemos criar instantaneamente um new Date a partir do carimbo de data/hora:
deixe data = nova Data( Date.parse('2012-01-26T13:51:50.417-07:00') );
alerta(data); Data e hora em JavaScript são representadas pelo objeto Date. Não podemos criar “apenas data” ou “apenas hora”: objetos Date sempre carregam ambos.
Os meses são contados a partir do zero (sim, janeiro é um mês zero).
Os dias da semana em getDay() também são contados a partir de zero (domingo).
Date se corrige automaticamente quando componentes fora do intervalo são definidos. Bom para adicionar/subtrair dias/meses/horas.
As datas podem ser subtraídas, dando a diferença em milissegundos. Isso ocorre porque uma Date se torna o carimbo de data/hora quando convertida em um número.
Use Date.now() para obter rapidamente o carimbo de data/hora atual.
Observe que, diferentemente de muitos outros sistemas, os carimbos de data/hora em JavaScript estão em milissegundos, não em segundos.
Às vezes precisamos de medições de tempo mais precisas. O JavaScript em si não tem como medir o tempo em microssegundos (1 milionésimo de segundo), mas a maioria dos ambientes fornece isso. Por exemplo, o navegador possui performance.now() que fornece o número de milissegundos desde o início do carregamento da página com precisão de microssegundos (3 dígitos após o ponto):
alert(`Carregamento iniciado há ${performance.now()}ms atrás`);
// Algo como: "O carregamento começou há 34731,26000000001ms"
// 0,26 é microssegundos (260 microssegundos)
// mais de 3 dígitos após a vírgula são erros de precisão, apenas os 3 primeiros estão corretos Node.js possui módulo microtime e outras formas. Tecnicamente, quase qualquer dispositivo e ambiente permite obter mais precisão, mas não está em Date .
importância: 5
Crie um objeto Date para a data: 20 de fevereiro de 2012, 3h12. O fuso horário é local.
Mostre-o usando alert .
O new Date usa o fuso horário local. Portanto, a única coisa importante a lembrar é que os meses começam do zero.
Então fevereiro tem o número 1.
Aqui está um exemplo com números como componentes de data:
//nova Data(ano, mês, data, hora, minuto, segundo, milissegundo) seja d1 = nova data (2012, 1, 20, 3, 12); alerta(d1);
Também poderíamos criar uma data a partir de uma string, assim:
//nova data(datastring)
deixe d2 = nova data("2012-02-20T03:12");
alerta(d2);importância: 5
Escreva uma função getWeekDay(date) para mostrar o dia da semana em formato abreviado: 'MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'.
Por exemplo:
deixe data = nova data(2012, 0, 3); // 3 de janeiro de 2012 alerta(getWeekDay(data)); // deve gerar "TU"
Abra uma sandbox com testes.
O método date.getDay() retorna o número do dia da semana, começando no domingo.
Vamos criar um array de dias da semana, para que possamos obter o nome correto do dia pelo seu número:
function getWeekDay(data) {
deixe dias = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
return dias[date.getDay()];
}
deixe data = nova data(2014, 0, 3); // 3 de janeiro de 2014
alerta(getWeekDay(data)); //FRAbra a solução com testes em uma sandbox.
importância: 5
Os países europeus têm dias da semana que começam na segunda-feira (número 1), depois terça-feira (número 2) e até domingo (número 7). Escreva uma função getLocalDay(date) que retorne o dia da semana “europeu” para date .
deixe data = nova data(2012, 0, 3); // 3 de janeiro de 2012 alerta(getLocalDay(data)); // terça-feira, deve mostrar 2
Abra uma sandbox com testes.
function getLocalDay(data) {
deixe dia = date.getDay();
if (day == 0) { // dia da semana 0 (domingo) é 7 na Europa
dia = 7;
}
dia de retorno;
}Abra a solução com testes em uma sandbox.
importância: 4
Crie uma função getDateAgo(date, days) para retornar o dia do mês days atrás a partir da date .
Por exemplo, se hoje é dia 20, então getDateAgo(new Date(), 1) deve ser 19 e getDateAgo(new Date(), 2) deve ser 18.
Deve funcionar de forma confiável por days=365 ou mais:
deixe data = nova data(2015, 0, 2); alerta(getDateAgo(data, 1)); // 1, (1º de janeiro de 2015) alert(getDateAgo(data, 2)); // 31, (31 de dezembro de 2014) alert(getDateAgo(data, 365)); // 2, (2 de janeiro de 2014)
PS A função não deve modificar a date fornecida.
Abra uma sandbox com testes.
A ideia é simples: subtrair um determinado número de dias da date :
function getDateAgo(data, dias) {
date.setDate(date.getDate() - dias);
retornar data.getDate();
} …Mas a função não deve mudar date . Isso é importante porque o código externo que nos dá a data não espera que ela mude.
Para implementá-lo vamos clonar a data, assim:
function getDateAgo(data, dias) {
deixe dateCopy = new Date(data);
dateCopy.setDate(date.getDate() - dias);
return dateCopy.getDate();
}
deixe data = nova data(2015, 0, 2);
alerta(getDateAgo(data, 1)); // 1, (1º de janeiro de 2015)
alert(getDateAgo(data, 2)); // 31, (31 de dezembro de 2014)
alert(getDateAgo(data, 365)); // 2, (2 de janeiro de 2014)Abra a solução com testes em uma sandbox.
importância: 5
Escreva uma função getLastDayOfMonth(year, month) que retorne o último dia do mês. Às vezes é 30, 31 ou até 28/29 de fevereiro.
Parâmetros:
year – ano de quatro dígitos, por exemplo 2012.
month – mês, de 0 a 11.
Por exemplo, getLastDayOfMonth(2012, 1) = 29 (ano bissexto, fevereiro).
Abra uma sandbox com testes.
Vamos criar uma data usando o próximo mês, mas passar zero como dia:
function getLastDayOfMonth(ano, mês) {
deixe data = nova Data(ano, mês + 1, 0);
retornar data.getDate();
}
alerta(getLastDayOfMonth(2012, 0)); //31
alerta(getLastDayOfMonth(2012, 1)); //29
alerta(getLastDayOfMonth(2013, 1)); //28Normalmente as datas começam em 1, mas tecnicamente podemos passar qualquer número, a data se ajustará automaticamente. Então quando passamos 0, então significa “um dia antes do 1º dia do mês”, ou seja: “o último dia do mês anterior”.
Abra a solução com testes em uma sandbox.
importância: 5
Escreva uma função getSecondsToday() que retorne o número de segundos desde o início de hoje.
Por exemplo, se agora fossem 10:00 am e não houvesse mudança de horário de verão, então:
getSecondsToday() == 36000 // (3600 * 10)
A função deve funcionar em qualquer dia. Ou seja, não deve ter um valor codificado de “hoje”.
Para obter o número de segundos, podemos gerar uma data usando o dia e hora atuais 00:00:00 e depois subtrair de “agora”.
A diferença é o número de milissegundos desde o início do dia, que devemos dividir por 1000 para obter os segundos:
function getSecondsToday() {
deixe agora = new Date();
// cria um objeto usando o dia/mês/ano atual
deixe hoje = new Date(now.getFullYear(), now.getMonth(), now.getDate());
deixe diff = agora - hoje; // ms diferença
retornar Math.round(diff/1000); //faz segundos
}
alerta(getSecondsToday());Uma solução alternativa seria obter horas/minutos/segundos e convertê-los em segundos:
function getSecondsToday() {
deixe d = nova Data();
return d.getHours() * 3600 + d.getMinutes() * 60 + d.getSeconds();
}
alerta(getSecondsToday());importância: 5
Crie uma função getSecondsToTomorrow() que retorne o número de segundos até amanhã.
Por exemplo, se agora são 23:00 , então:
getSecondsToTomorrow() == 3600
PS A função deve funcionar a qualquer dia, o “hoje” não está codificado.
Para obter o número de milissegundos até amanhã, podemos subtrair de “amanhã 00:00:00” a data atual.
Primeiro, geramos esse “amanhã” e depois fazemos:
function getSecondsToTomorrow() {
deixe agora = new Date();
//data de amanhã
deixe amanhã = new Date(now.getFullYear(), now.getMonth(), now.getDate()+1);
deixe diff = amanhã - agora; //diferença em ms
retornar Math.round(diff/1000); //converte para segundos
}Solução alternativa:
function getSecondsToTomorrow() {
deixe agora = new Date();
deixe hora = agora.getHours();
deixe minutos = now.getMinutes();
deixe segundos = now.getSeconds();
deixe totalSecondsToday = (hora * 60 + minutos) * 60 + segundos;
deixe totalSecondsInADay = 86400;
retornar totalSecondsInADay - totalSecondsToday;
}Observe que muitos países têm horário de verão (DST), portanto pode haver dias com 23 ou 25 horas. Podemos querer tratar esses dias separadamente.
importância: 4
Escreva uma função formatDate(date) que deve formatar date da seguinte forma:
Se desde date passou menos de 1 segundo, então "right now" .
Caso contrário, se desde date passou menos de 1 minuto, então "n sec. ago" .
Caso contrário, se for menos de uma hora, então "m min. ago" .
Caso contrário, a data completa no formato "DD.MM.YY HH:mm" . Ou seja: "day.month.year hours:minutes" , tudo em formato de 2 dígitos, por exemplo 31.12.16 10:00 .
Por exemplo:
alerta(formatoData(nova Data(nova Data - 1))); // "agora mesmo" alerta(formatoDate(nova Data(nova Data - 30 * 1000)) ); // "30 segundos atrás" alerta(formatoDate(nova Data(nova Data - 5 * 60 * 1000)) ); // "5 minutos atrás" // data de ontem como 31.12.16 20:00 alert( formatDate(nova Data(nova Data - 86400 * 1000)) );
Abra uma sandbox com testes.
Para obter o tempo desde date até agora – vamos subtrair as datas.
function formatoData(data) {
deixe diff = new Date() - data; //a diferença em milissegundos
if (diff < 1000) { // menos de 1 segundo
retorne 'agora mesmo';
}
deixe sec = Math.floor (diff / 1000); //converte diferença para segundos
if (seg <60) {
retornar seg + ' seg. atrás';
}
deixe min = Math.floor(diff/60000); //converte diferença para minutos
se (min <60) {
retornar min + 'min. atrás';
}
//formata a data
// adiciona zeros à esquerda para dia/mês/horas/minutos de um único dígito
seja d = data;
d = [
'0' + d.getDate(),
'0' + (d.getMonth() + 1),
'' + d.getFullYear(),
'0' + d.getHoras(),
'0' + d.getMinutos()
].map(componente => componente.slice(-2)); // pega os 2 últimos dígitos de cada componente
// junta os componentes na data
return d.slice(0, 3).join('.') + ' ' + d.slice(3).join(':');
}
alerta(formatoData(nova Data(nova Data - 1))); // "agora mesmo"
alerta(formatoDate(nova Data(nova Data - 30 * 1000)) ); // "30 segundos atrás"
alerta(formatoDate(nova Data(nova Data - 5 * 60 * 1000)) ); // "5 minutos atrás"
// data de ontem como 31/12/2016 20:00
alert( formatDate(nova Data(nova Data - 86400 * 1000)) );Solução alternativa:
function formatoData(data) {
deixe dayOfMonth = date.getDate();
deixe mês = data.getMonth() + 1;
deixe ano = data.getFullYear();
deixe hora = date.getHours();
deixe minutos = date.getMinutes();
deixe diffMs = new Date() - data;
deixe diffSec = Math.round(diffMs / 1000);
deixe diffMin = diffSec / 60;
deixe diffHour = diffMin / 60;
//formatação
ano = ano.toString().slice(-2);
mês = mês <10? '0' + mês: mês;
diaDoMês = diaDoMês < 10 ? '0' + diaDoMês: diaDoMês;
hora = hora <10? '0' + hora: hora;
minutos = minutos <10? '0' + minutos: minutos;
if (diffSec < 1) {
retorne 'agora mesmo';
} else if (diffMin < 1) {
retornar `${diffSec} seg. atrás`
} else if (diffHour < 1) {
retorne `${diffMin} min. atrás`
} outro {
return `${diaOfMês}.${mês}.${ano} ${hora}:${minutos}`
}
}Abra a solução com testes em uma sandbox.