Como você começa um timestamp em JavaScript?

StackOverflow https://stackoverflow.com/questions/221294

Pergunta

Como posso obter um timestamp em JavaScript?

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

Foi útil?

Solução

Short & Snazzy: 

+ new Date()

Um operador unária como plus desencadeia o método valueOf no objecto Date e devolve a data e hora (sem qualquer alteração).

Detalhes:

Em quase todos os navegadores atuais você pode usar Date.now() para obter o carimbo de hora UTC em milissegundos ; uma notável exceção a isso é IE8 e anteriores (ver compatibilidade mesa ) .

Você pode facilmente fazer uma correção para isso, porém: 

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

O que deve ser um pouco mais rápido, mas também menos legível (ver 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 quer um calço e máximo de compatibilidade, você pode usar o método "velho" para obter o timestamp em milissegundos : 

new Date().getTime()

O que você pode, então, converter para segundos como esta: 

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

E você pode também usar o método valueOf que nós 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());

Outras dicas

Eu como esta, porque é pequeno: 

+new Date

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

Date.now()

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

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

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

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

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

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

time();

I fornecer várias soluções com descrições desta resposta. Sinta-se livre para fazer perguntas se alguma coisa não está clara
PS:. Tristemente alguém fundiu esta a resposta de topo sem dar crédito

Rápido e solução suja: 

Date.now() /1000 |0

Aviso : é pode pausa em 2038 e retornar números negativos se você fazer a mágica |0. Use Math.floor() não por esse tempo

solução Math.floor(): 

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

Alguns alternativa nerd por Derek ? ? ?? retirados dos comentários abaixo esta resposta: 

new Date/1e3|0

Polyfill para obter Date.now() de trabalho:

Para fazê-lo funcionar no IE você poderia fazer isso (Polyfill de MDN ): 

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

Se você não se preocupam com o ano / dia da semana / horário de verão você pode tira-lo fora e usar isto depois de 2038: 

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

Alguns saída de como vai ficar: 

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 ele vai quebrar o horário de verão, mas dependendo do que você estão construindo isso pode ser útil para você, se você precisa fazer binário operações em timestamps após int32 vai quebrar em 2038.

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

Se você apenas quer saber o tempo relativo do ponto de quando o código foi executado através de primeira você poderia usar algo como isto: 

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

No caso de você estiver usando jQuery, você poderia usar $.now() conforme descrito no do jQuery Docs que torna o polyfill obsoleta, pois $.now() faz internamente a mesma coisa: (new Date).getTime()

Se você está apenas feliz com a versão do jQuery considerar upvoting esta resposta desde que eu não encontrá-lo eu mesmo.

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

Ao fornecer |, você diz ao intérprete para fazer um binário OR operação. operações de bits requerem números absolutos que transforma o resultado decimal de Date.now() / 1000 para um número inteiro.

Durante a conversão, os decimais são removidos, resultando no mesmo resultado utilizando como Math.floor() mas utilizando menos código.

Apesar de ser avisados: que irá converter um pouco 64 double para um inteiro de 32 bits. Isto irá resultar em perda de informações ao lidar com grandes números. Timestamps vai quebrar depois do estouro 2038 devido a 32 bit inteiro.

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

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

jQuery fornece seu próprio método para obter o carimbo do tempo: 

var timestamp = $.now();

(além de apenas implementos expressão (new Date).getTime())

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

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

Só para acrescentar-se, aqui está uma função para retornar uma seqüência 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 dateformat ISO, você começa pode obtê-lo diretamente 

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

Data , um objeto nativo em JavaScript é a nossa forma de obter todos os dados sobre o tempo.

Basta ter cuidado em JavaScript o timestamp depende do conjunto computador cliente, por isso não é 100% timestamp preciso. Para obter o melhor resultado, você precisa para obter o timestamp do do lado do servidor .

De qualquer forma, a minha maneira preferida é usar baunilha. Esta é uma forma comum de fazê-lo em JavaScript: 

Date.now(); //return 1495255666921

Em MDN é mencionado como abaixo:

O Date.now () retorna o número de milissegundos decorridos desde 01 de janeiro de 1970 00:00:00 UTC.
Porque agora () é um método estático de Data, você sempre usá-lo como Date.now ().

Se você usar uma versão abaixo ES5, Date.now(); não funciona e você precisa usar: 

new Date().getTime();

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

O método Date.getTime() pode ser usado com um pouco ajustar:

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

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

(new Date).getTime() / 1000

O método Date.valueOf() é funcionalmente equivalente a Date.getTime(), o que faz com que seja possível usar operações aritméticas sobre objecto data para atingir resultados idênticos. Na minha opinião, esta abordagem afeta a legibilidade.

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

Considere pular direto getTime() invocação e uso | 0 como um substituto para Math.floor() função. Também é bom lembrar 1E3 é um equivalente mais curto para 1000 (maiúsculas E é preferível do que letras minúsculas para indicar 1E3 como uma constante).

Como resultado, você obter o seguinte: 

var ts = new Date / 1E3 | 0;

console.log(ts);

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

moment().valueOf()

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

moment().unix()

Você também pode converter vezes assim: 

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.js no browser: 

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

Para obter mais detalhes, incluindo outras formas de instalar e utilizar MomentJS, ver a sua docs

Aqui é 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())));
}


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

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.

Para um timestamp com resolução de microsegundos, há performance.now : 

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

Isto pode por exemplo rendimento 1436140826653.139, enquanto Date.now só dá 1436140826653.

Hoje - 2018/06/27 I fornecer alguma comparação tempo para soluções js puros. Isto pode ser útil para pessoas que quero ficar / hora medida em JS em forma de luz / eficiente (ex. Para aplicações em tempo real, como simulações, jogos etc).

Testado em MacOs High Sierra 10.13.3 no Chrome 67.0.3396.99 (64-bit), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64 bits). No abaixo imagem eu te mostrar resultados para navegador mais rápido (Safari):

enter descrição da imagem aqui

Como eu observar o Date.now() era o método mais rápido para obter timestamp para todos os três browsers. Safari tem operações 19.2M por segundo, Firefox 16.1M, Chrome 7,8 milhões.

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

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

Você pode executar o teste em sua máquina aqui: https://jsperf.com/timestamp-test-x .

Qualquer navegadores não suportados Date.now, você pode usar isso para obter o tempo atual data: 

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

Este tem uma solução: que converte unix timestamp de vez em js tentar este 

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

Eu aprendi uma maneira muito legal de conversão de um determinado objeto de data para um timestamp Unix a partir do código fonte de JQuery biscoito no outro dia.

Aqui está um exemplo: 

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

Se quiser uma maneira básica para gerar um timestamp em 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 o cache busto em um ambiente de localhost. A saída é /dist/css/global.css?v=245521377 onde 245521377 é o timestamp gerado por hrtime().

Esperemos que esta ajuda, os métodos acima trabalho pode também, mas eu achei que este seja a abordagem mais simples para as nossas necessidades em 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);
            }
};

Para lodash e sublinhado usuários, o uso _.now. 

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

Moment.js pode abstrair um monte de dor de lidar com datas Javascript.

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

moment().unix();

Como da escrita deste, a resposta de topo é de 9 anos, e muita coisa mudou desde então - não menos importante, temos o apoio quase universal para uma solução não-hacky: 

Date.now()

Se você quiser ser absolutamente certo de que isso não vai quebrar em algum antigo (pré IE9) navegador, você pode colocá-lo atrás de um cheque, assim: 

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

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

MDN Documentação sobre Date.now

forma mais simples: 

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

em algum momento eu preciso dele em objetos para chamadas XMLHTTP, então eu faço assim. 

timestamp : parseInt(new Date().getTime()/1000, 10)
Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top