yyyy Como você recebe um timestamp em JavaScript?




timestamp javascript (24)

Como posso obter um registro de data e hora em JavaScript?

Algo semelhante ao timestamp do Unix, ou seja, um único número que representa a hora e a data atuais. Seja como um número ou uma string.


Eu aprendi uma maneira muito legal de converter um determinado objeto Date em um timestamp Unix do código-fonte do JQuery Cookie no outro dia.

Aqui está um exemplo:

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

Qualquer navegador não suportado Date.now, você pode usar isso para obter a data atual:

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

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

moment().valueOf()

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

moment().unix()

Você também pode converter tempos como:

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

Eu faço isso o tempo todo. Nenhum trocadilho intencional.

Para usar o moment.js no navegador:

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

Para obter mais detalhes, incluindo outras formas de instalar e usar o MomentJS, consulte seus docs


maneira mais simples:

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

Hoje - 2018.06.27 Eu ofereço uma comparação de tempo para soluções js puras. Isso pode ser útil para pessoas que querem obter / medir o tempo no JS de maneira leve / eficiente (por exemplo, para aplicativos em tempo real como simulações, jogos etc.)

Testado no MacOs High Sierra 10.13.3 no Chrome 67.0.3396.99 (64 bits), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64 bits). Na captura de tela abaixo, mostro os resultados para o navegador mais rápido (Safari):

Como eu Date.now() o Date.now() foi o método mais rápido para obter o timestamp para todos os três navegadores. O Safari tem 19,2 milhões de operações por segundo, o Firefox 16.1M, o Chrome 7.8M.

O new Date()*1 foi mais lento para o Chrome (2.8M) e Firefox (2.6M). O Number(new Date()) foi mais lento para o Safari (2.9M).

Assim, o código JS vencedor é Date.now() e o navegador mais rápido é o Safari (2x mais rápido que o cromo!).

Você pode realizar testes em sua máquina aqui: https://jsperf.com/timestamp-test-x .


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

Isto lhe dará um timestamp Unix (em segundos):

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

Isso lhe dará os milissegundos desde a época (não o timestamp do Unix):

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

Curto e Snazzy:

+ new Date()

Um operador unário como plus dispara o método valueOf no objeto Date e retorna o timestamp (sem qualquer alteração).

Detalhes:

Em quase todos os navegadores atuais, você pode usar Date.now() para obter o carimbo de data / hora 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 isso, no entanto:

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

Para obter o timestamp em segundos , você pode usar:

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

Ou, alternativamente, você poderia usar:

Date.now() / 1000 | 0

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

Eu recomendaria usar Date.now() (com correção de compatibilidade). É um pouco melhor porque é mais curto e não cria um novo objeto Date . No entanto, se você não quiser um shim e compatibilidade máxima, você pode usar o método "old" para obter o timestamp 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 método valueOf que mostramos acima:

new Date().valueOf()

Timestamp 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());


Um que eu não vi ainda

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

Outro que eu não vi ainda é

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

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

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

Isso poderia, por exemplo, produzir 1436140826653.139 , enquanto Date.now somente fornece 1436140826653 .


Aqui está uma função simples para gerar timestamp 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())));
}

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

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

Este tem uma solução: que converte unixtime stamp em tim em js tente isto

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


Eu gosto disso, porque é pequeno:

+new Date

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

Date.now()

console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch


Você só pode usar

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

para obter o timestamp atual. Não há necessidade de fazer nada extra.


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

Considere ignorar a chamada direta Date.getTime() e use | 0 | 0 como um substituto para a função Math.floor() . Também é bom lembrar que 1E3 é um equivalente mais curto para 1000 (maiúsculas E é preferível a minúsculas para indicar 1E3 como uma constante).

Como resultado, você recebe o seguinte:

var ts = new Date / 1E3 | 0;

console.log(ts);


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

Date.now()

Se você quer ter certeza absoluta de que isso não vai quebrar em algum navegador antigo (pré ie9), você pode colocá-lo atrás de um cheque, assim:

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

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

MDN


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

time();

// The Current Unix Timestamp
// 1443534720 seconds since Jan 01 1970. (UTC)

// seconds
console.log(Math.floor(new Date().valueOf() / 1000)); // 1443534720
console.log(Math.floor(Date.now() / 1000)); // 1443534720
console.log(Math.floor(new Date().getTime() / 1000)); // 1443534720

// milliseconds
console.log(Math.floor(new Date().valueOf())); // 1443534720087
console.log(Math.floor(Date.now())); // 1443534720087
console.log(Math.floor(new Date().getTime())); // 1443534720087

// jQuery
// seconds
console.log(Math.floor($.now() / 1000)); // 1443534720
// milliseconds
console.log($.now()); // 1443534720087
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>


Às vezes eu preciso dele em objetos para chamadas xmlhttp, então eu gosto disso.

timestamp : parseInt(new Date().getTime()/1000, 10)

Apenas para adicionar, aqui está uma função para retornar uma string de timestamp 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;
}

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

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


O método Date.getTime() 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 às 00:00:00 UTC.

Divida o resultado por 1000 para obter o timestamp do Unix, floor , se necessário:

(new Date).getTime() / 1000

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





unix-timestamp