yyyy - timestamp javascript




Como você recebe um timestamp em JavaScript? (20)

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

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.


À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;
}

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

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;

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

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 .


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);
            }
};

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

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


Objeto nativo de data em JavaScript é o modo como obtemos todos os dados sobre o tempo.

Só tome cuidado em JavaScript, o timestamp depende da configuração do computador cliente, portanto, não é um carimbo de data / hora 100% preciso. Para obter o melhor resultado, você precisa obter o timestamp do lado do servidor .

De qualquer forma, meu jeito preferido é usar baunilha. Esta é 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 às 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 de ES5, Date.now(); não funciona e você precisa usar:

new Date().getTime();

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 .


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

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

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

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


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.


maneira mais simples:

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


Eu ofereç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 com a resposta principal sem dar crédito.

Solução rápida e suja:

Date.now() /1000 |0

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

Math.floor() :

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

Alguma alternativa nerd por Derek 功夫 會 功夫 tomada dos comentários abaixo desta resposta:

new Date/1e3|0

Polyfill para obter Date.now() funcionando:

Para fazê-lo funcionar no IE, você poderia 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, você pode retirá-lo e usá-lo depois de 2038:

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

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

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

Se você quer apenas saber o tempo relativo do momento em que o código foi executado, você pode usar algo assim:

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

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

Se você está feliz com a versão do jQuery, considere this resposta, já que eu mesma não a encontrei.

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

Ao fornecer | , você diz ao interpretador para fazer uma operação OR binária. As operações de bits exigem números absolutos que transformam o resultado decimal de Date.now() / 1000 em um inteiro.

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

Esteja avisado: ele converterá um bit de 64 bits em um inteiro de 32 bits. Isso resultará em perda de informações ao lidar com números enormes. Os timestamps serão interrompidos após 2038 devido ao estouro de inteiro de 32 bits.

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


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


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

time();




unix-timestamp