Como posso obter um carimbo de data / hora em JavaScript?

Algo semelhante ao carimbo de data e hora do Unix , ou seja, um único número que representa a hora e a data atuais. Como um número ou uma sequência.

Curto e Snazzy:

+ new Date()

Um operador unário como plusaciona o valueOfmétodo no Dateobjeto e retorna o carimbo de data / hora (sem nenhuma alteração).

Detalhes:

Em quase todos os navegadores atuais, você pode usar Date.now()para obter o registro de data e hora do UTC em milissegundos ; uma exceção notável a isso é o IE8 e versões anteriores (consulte a tabela de compatibilidade ).

Você pode facilmente fazer uma correção para isso, no entanto:

if (!Date.now) {
    Date.now = function() { return new Date().getTime(); }
}

Para obter o registro de data e hora em segundos , você pode usar:

Math.floor(Date.now() / 1000)

Ou, como alternativa, você pode usar:

Date.now() / 1000 | 0

O que deve ser um pouco mais rápido, mas também menos legível ( veja também esta resposta ).

Eu recomendaria usar Date.now()(com calço de compatibilidade). É um pouco melhor porque é mais curto e não cria um novo Dateobjeto. No entanto, se você não quiser um shim e compatibilidade máxima, poderá usar o método "antigo" para obter o registro de data e hora em milissegundos :

new Date().getTime()

Que você pode converter para segundos como este:

Math.round(new Date().getTime()/1000)

E você também pode usar o valueOfmétodo que mostramos acima:

new Date().valueOf()

Registro de data e hora em milissegundos

var timeStampInMs = window.performance && window.performance.now && window.performance.timing && window.performance.timing.navigationStart ? window.performance.now() + window.performance.timing.navigationStart : Date.now();

console.log(timeStampInMs, Date.now());

Eu gosto disso, porque é pequeno:

+new Date

Eu também gosto disso, porque é igualmente curto e é compatível com navegadores modernos, e mais de 500 pessoas votaram que é melhor:

Date.now()

O JavaScript funciona com o número de milissegundos desde a época, enquanto a maioria dos outros idiomas trabalha com os segundos. Você poderia trabalhar com milissegundos, mas assim que passar um valor para dizer PHP, as funções nativas do PHP provavelmente falharão. Portanto, para ter certeza de que eu sempre uso os segundos, não milissegundos.

Isso fornecerá um carimbo de data / hora do Unix (em segundos):

var unix = Math.round(+new Date()/1000);

Isso fornecerá os milissegundos desde a época (não o carimbo de data e hora do Unix):

var milliseconds = new Date().getTime();

var time = Date.now || function() {
  return +new Date;
};

time();

Eu forneço várias soluções com descrições nesta resposta. Sinta-se à vontade para fazer perguntas se algo não estiver claro.
PS: infelizmente, alguém mesclou isso à resposta principal sem dar crédito.

Solução rápida e suja:

Date.now() /1000 |0

Aviso : pode quebrar em 2038 e retornar números negativos se você fizer a |0mágica. Use em Math.floor()vez disso

Math.floor() solução:

Math.floor(Date.now() /1000);

Alguma alternativa nerd de Derek 功夫 會 功夫 extraída dos comentários abaixo desta resposta:

new Date/1e3|0

Polyfill para começar a Date.now()trabalhar:

Para fazê-lo funcionar no IE, você pode fazer isso (Polyfill do MDN ):

if (!Date.now) {
    Date.now = function now() {
        return new Date().getTime();
    };
}

Se você não se importa com o ano / dia da semana / horário de verão, pode retirá-lo e usá-lo após 2038:

var now = (function () {
    var year = new Date(new Date().getFullYear().toString()).getTime();
    return function () {
        return Date.now() - year
    }
})();

Alguma saída de como será:

new Date()
Thu Oct 29 2015 08:46:30 GMT+0100 (Mitteleuropäische Zeit )
new Date(now())
Thu Oct 29 1970 09:46:30 GMT+0100 (Mitteleuropäische Zeit )

É claro que isso interromperá o horário de verão, mas, dependendo do que você estiver criando, isso poderá ser útil se você precisar executar operações binárias em registros de data e hora após a interrupção do int32 em 2038.

Isso também retornará valores negativos, mas somente se o usuário do PC em que você está executando seu código estiver alterando o relógio do PC pelo menos para 31 de dezembro do ano anterior.

Se você quer apenas saber o tempo relativo a partir do momento em que o código foi executado primeiro, você pode usar algo como isto:

var relativeTime = (function () {
    var start = Date.now();
    return function () {
        return Date.now() - start
    }
})();

Caso esteja usando o jQuery, você pode usar $.now()como descrito nos Documentos do jQuery, o que torna o polyfill obsoleto, pois $.now()internamente faz a mesma coisa:(new Date).getTime()

Se você está feliz com a versão do jQuery, considere a possibilidade de votar nesta resposta, pois eu não a encontrei.

Agora, uma pequena explicação do que |0faz:

Ao fornecer |, você instrui o intérprete a executar uma operação OR binária. As operações de bit requerem números absolutos, que transformam o resultado decimal Date.now() / 1000em um número inteiro.

Durante essa conversão, os decimais são removidos, resultando no mesmo resultado do uso, Math.floor()mas usando menos código.

Esteja avisado: ele converterá um duplo de 64 bits em um inteiro de 32 bits. Isso resultará em perda de informações ao lidar com grandes números. Os carimbos de data / hora serão interrompidos após 2038 devido ao estouro de número inteiro de 32 bits.

Para mais informações sobre Date.nowsiga este link: Date.now()@ MDN

var timestamp = Number(new Date()); // current time as number

O jQuery fornece seu próprio método para obter o registro de data e hora:

var timestamp = $.now();

^{(além de apenas implementar (new Date).getTime()expressão)}

REF: http://api.jquery.com/jQuery.now/

Além das outras opções, se você quiser um ISO com formato de data, poderá obtê-lo diretamente

console.log(new Date().toISOString());

Apenas para adicionar, aqui está uma função para retornar uma string de carimbo de data e hora em Javascript. Exemplo: 15:06:38 PM

function displayTime() {
    var str = "";

    var currentTime = new Date()
    var hours = currentTime.getHours()
    var minutes = currentTime.getMinutes()
    var seconds = currentTime.getSeconds()

    if (minutes < 10) {
        minutes = "0" + minutes
    }
    if (seconds < 10) {
        seconds = "0" + seconds
    }
    str += hours + ":" + minutes + ":" + seconds + " ";
    if(hours > 11){
        str += "PM"
    } else {
        str += "AM"
    }
    return str;
}

Data , um objeto nativo em JavaScript é a maneira como obtemos todos os dados sobre o tempo.

Apenas tenha cuidado no JavaScript, o registro de data e hora depende do conjunto do computador cliente, para que não seja um registro de data e hora 100% exato. Para obter o melhor resultado, você precisa obter o registro de data e hora do lado do servidor .

Enfim, minha maneira preferida é usar baunilha. Essa é uma maneira comum de fazer isso em JavaScript:

Date.now(); //return 1495255666921

No MDN, é mencionado como abaixo:

O método Date.now () retorna o número de milissegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC.
Como now () é um método estático de Date, você sempre o usa como Date.now ().

Se você estiver usando uma versão abaixo do ES5, Date.now();não funcionará e precisará usar:

new Date().getTime();

Um que eu ainda não vi

Math.floor(Date.now() / 1000); // current time in seconds

Outro que eu ainda não vi é

var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();

O Date.getTime()método pode ser usado com um pequeno ajuste:

O valor retornado pelo método getTime é o número de milissegundos desde 1 de janeiro de 1970 00:00:00 UTC.

Divida o resultado por 1000 para obter o registro de data e hora do Unix, floorse necessário:

(new Date).getTime() / 1000

^{O Date.valueOf()método é funcionalmente equivalente a Date.getTime(), o que torna possível usar operadores aritméticos no objeto date para obter resultados idênticos. Na minha opinião, essa abordagem afeta a legibilidade.}

O código Math.floor(new Date().getTime() / 1000)pode ser reduzido para new Date / 1E3 | 0.

Considere pular a getTime()chamada direta e usá-la | 0como um substituto para a Math.floor()função. Também é bom lembrar que 1E3é um equivalente mais curto para 1000(E maiúsculo é preferido que minúsculo para indicar 1E3como constante).

Como resultado, você obtém o seguinte:

var ts = new Date / 1E3 | 0;

console.log(ts);

atuação

Hoje - 2020.04.23 Realizo testes para soluções escolhidas. Testei no MacOs High Sierra 10.13.6 no Chrome 81.0, Safari 13.1, Firefox 75.0

Conclusões

• A solução Date.now()(E) é a mais rápida no Chrome e Safari e a segunda no Firefox, e provavelmente é a melhor opção para uma solução rápida entre navegadores
• A solução performance.now()(G), o que é surpreendente, é mais do que 100x mais rápida que outras soluções no Firefox, mas mais lenta no Chrome
• As soluções C, D, F são bastante lentas em todos os navegadores

Detalhes

Resultados para chrome

Você pode executar o teste em sua máquina AQUI

O código usado nos testes é apresentado no snippet abaixo

function A() {
  return new Date().getTime();
}

function B() {
  return new Date().valueOf();
}

function C() {
  return +new Date();
}

function D() {
  return new Date()*1;
}

function E() {
  return Date.now();
}

function F() {
  return Number(new Date());
}

function G() {
  // this solution returns time counted from loading the page.
  // (and on Chrome it gives better precission)
  return performance.now(); 
}



// TEST

log = (n,f) => console.log(`${n} : ${f()}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);

This snippet only presents code used in external benchmark

Eu recomendo usar moment.js. Para obter o número de milissegundos desde a época do UNIX, faça

moment().valueOf()

Para obter o número de segundos desde a época do UNIX, faça

moment().unix()

Você também pode converter horários da seguinte forma:

moment('2015-07-12 14:59:23', 'YYYY-MM-DD HH:mm:ss').valueOf()

Eu faço isso o tempo todo. Sem trocadilhos.

Para usar moment.jsno navegador:

<script src="moment.js"></script>
<script>
    moment().valueOf();
</script>

Para obter mais detalhes, incluindo outras maneiras de instalar e usar o MomentJS, consulte seus documentos.

Para um registro de data e hora com resolução de microssegundos, há performance.now:

function time() { 
  return performance.now() + performance.timing.navigationStart;
}

Isso poderia, por exemplo 1436140826653.139, render , enquanto Date.nowapenas dá 1436140826653.

Você só pode usar

    var timestamp = new Date().getTime();
    console.log(timestamp);

para obter o registro de data e hora atual. Não há necessidade de fazer nada extra.

Aqui está uma função simples para gerar registro de data e hora no formato: mm / dd / aa hh: mi: ss

function getTimeStamp() {
    var now = new Date();
    return ((now.getMonth() + 1) + '/' +
            (now.getDate()) + '/' +
             now.getFullYear() + " " +
             now.getHours() + ':' +
             ((now.getMinutes() < 10)
                 ? ("0" + now.getMinutes())
                 : (now.getMinutes())) + ':' +
             ((now.getSeconds() < 10)
                 ? ("0" + now.getSeconds())
                 : (now.getSeconds())));
}

Qualquer navegador não suportado Date.now, você pode usá-lo para obter a data e hora atuais:

currentTime = Date.now() || +new Date()

Este aqui tem uma solução: que converte carimbo unixtime para tim em js tente isso

var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();

Aprendi uma maneira muito legal de converter um determinado objeto Date em um carimbo de data / hora Unix a partir do código fonte do JQuery Cookie outro dia.

Aqui está um exemplo:

var date = new Date();
var timestamp = +date;

Se você deseja uma maneira básica de gerar um carimbo de data / hora no Node.js, isso funciona bem.

var time = process.hrtime();
var timestamp = Math.round( time[ 0 ] * 1e3 + time[ 1 ] / 1e6 );

Nossa equipe está usando isso para interromper o cache em um ambiente de host local. A saída é /dist/css/global.css?v=245521377onde 245521377está o registro de data e hora gerado por hrtime().

Espero que isso ajude, os métodos acima também podem funcionar, mas eu achei a abordagem mais simples para as nossas necessidades no Node.js.

Isso parece funcionar.

console.log(clock.now);
// returns 1444356078076

console.log(clock.format(clock.now));
//returns 10/8/2015 21:02:16

console.log(clock.format(clock.now + clock.add(10, 'minutes'))); 
//returns 10/8/2015 21:08:18

var clock = {
    now:Date.now(),
    add:function (qty, units) {
            switch(units.toLowerCase()) {
                case 'weeks'   :  val = qty * 1000 * 60 * 60 * 24 * 7;  break;
                case 'days'    :  val = qty * 1000 * 60 * 60 * 24;  break;
                case 'hours'   :  val = qty * 1000 * 60 * 60;  break;
                case 'minutes' :  val = qty * 1000 * 60;  break;
                case 'seconds' :  val = qty * 1000;  break;
                default       :  val = undefined;  break;
                }
            return val;
            },
    format:function (timestamp){
            var date = new Date(timestamp);
            var year = date.getFullYear();
            var month = date.getMonth() + 1;
            var day = date.getDate();
            var hours = date.getHours();
            var minutes = "0" + date.getMinutes();
            var seconds = "0" + date.getSeconds();
            // Will display time in xx/xx/xxxx 00:00:00 format
            return formattedTime = month + '/' + 
                                day + '/' + 
                                year + ' ' + 
                                hours + ':' + 
                                minutes.substr(-2) + 
                                ':' + seconds.substr(-2);
            }
};

Se for para fins de registro, você pode usar o ISOString

new Date().toISOString()

"2019-05-18T20: 02: 36.694Z"

Para usuários lodash e sublinhado , use _.now.

var timestamp = _.now(); // in milliseconds

O Moment.js pode abstrair muita dor ao lidar com datas Javascript.

Consulte: http://momentjs.com/docs/#/displaying/unix-timestamp/

moment().unix();

No momento em que escrevemos isso, a resposta principal tem 9 anos e muita coisa mudou desde então - não menos importante, temos suporte quase universal para uma solução não-hacky:

Date.now()

Se você quiser ter certeza absoluta de que isso não será interrompido em algum navegador antigo (pré ie9), poderá colocá-lo atrás de uma verificação, como:

const currentTimestamp = (!Date.now ? +new Date() : Date.now());

Isso retornará os milissegundos desde o tempo da época, é claro, não segundos.

Documentação MDN em Date.now

maneira mais simples:

var timeStamp=event.timestamp || new Date().getTime();