+new Date

Date.now()

O JavaScript trabalha com o número de milisegundos desde a época, enquanto a maioria das outras línguas trabalha com os segundos. Você poderia trabalhar com milisegundos, mas assim que você passa um valor para dizer PHP, as funções nativas PHP provavelmente falham. Para ter a certeza que uso sempre os segundos, não os milissegundos.

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

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

Isto dar-lhe-á os milisegundos desde a época (e não a data-limite 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 fundiu isso com a resposta superior sem dar crédito.

Solução rápida e suja:

Date.now() /1000 |0

Aviso: Elepode partir em 2038 e devolver números negativos se você fizer a magia |0. Use Math.floor() em vez disso por isso tempo

Math.floor() solução:

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

Uma alternativa nerd, de Derek 朕會功夫, tirada dos comentários abaixo desta resposta.:

new Date/1e3|0

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

Para o pôr a funcionar, pode fazer isto (Polifill de MDN):

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

Se não se importar com o ano / Dia da semana / horário de verão, pode removê-lo e usá-lo depois 2038:

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

Algum resultado de como vai parecer:

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 vai quebrar o horário de verão, mas dependendo do que você estão a construir isto pode ser-lhe útil se precisar de fazer binário as operações em intervalos de tempo após int32 vão quebrar em 2038.

Isto também irá devolver valores negativos, mas apenas se o utilizador desse PC você está executando o seu código está mudando o relógio do PC pelo menos para 31 de dezembro do ano anterior ano.

Se você só quer saber o tempo relativo desde o momento em que o código foi executado pela primeira vez, você poderia usar algo assim:

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

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

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

Durante essa conversão, as casas decimais são removidas, resultando no mesmo resultado que a utilização de Math.floor(), mas utilizando menos código.

Seja avisado: ele vai converter um 64 bits o dobro para um inteiro de 32 bits. Isto resultará em perda de informação ao lidar com números enormes. Os intervalos de tempo irão quebrar após 2038 devido ao excesso de 32 bits inteiros.

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

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

jQuery fornece o seu próprio método para obter o timestamp:

var timestamp = $.now();

^{(além disso, apenas implementa a expressão (new Date).getTime())}

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

Só para somar, aqui está uma função para devolver uma string 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;
}

Para além das outras opções, se quiser um dateformat ISO, pode obtê-lo directamente

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

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

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

A Date.getTime() o método pode ser utilizado com um pequeno ajuste:

O valor devolvido pelo método getTime é o número de milisegundos Desde 1 de janeiro de 1970 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 a utilização de operadores aritméticos no objecto date para obter resultados idênticos. Na minha opinião, esta abordagem afecta a legibilidade.}

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

Considere saltar directamente getTime() invocação e utilização | 0 em substituição de Math.floor() função. Também é bom lembrar que 1E3 é um equivalente mais curto para 1000 (maiúsculas e são preferidas do que minúsculas para indicar 1E3 como uma constante).

Como resultado, obtém o seguinte:

var ts = new Date / 1E3 | 0;

console.log(ts);

Date o objecto nativo em JavaScript é a forma como obtemos todos os dados sobre o tempo.

Apenas tenha cuidado em JavaScript o timestamp é depende da configuração do computador do cliente, para que não seja 100% preciso timestamp. Para obter o melhor resultado, você precisa obter o timestamp do servidor-side .

Date.now(); //return 1495255666921

Na MDN é mencionado como abaixo:

A Data.agora () o método devolve o número de milisegundos decorridos desde 1 de janeiro de 1970 00: 00: 00 UTC.
Porque agora () é um método estático de data, você sempre usá-lo como data.agora().

Se utilizar uma versão abaixo do ES5, {[2] } não funciona e tem de usar:

new Date().getTime();

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

Recomendo vivamente a utilização de moment.js. Para obter o número de milissegundos desde a época 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 tempos como este:

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

Para utilizar moment.js no navegador:

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

Para mais detalhes, incluindo outras formas de instalar e utilizar o Momentj, ver os seus documentos

Só pode utilizar

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

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

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

Quaisquer navegadores não suportados Data.agora, você pode usar isso para obter a hora atual:

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

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

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

Se quiser uma forma básica de gerar um timestamp no nó.js isto funciona bem.

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

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

Aprendi uma maneira muito fixe de converter um dado objecto de data para um timestamp do Unix a partir do código fonte do Cookie JQuery no outro dia.

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

Para os utilizadoreslodash e sublinhado , use _.now.

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

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

Um momento.js {[4] } pode abstrair muita da dor em lidar com datas Javascript.

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

moment().unix();

A partir de escrever isto, a resposta principal tem 9 anos, e muita coisa mudou desde então-não menos importante, temos um apoio quase universal para uma solução não-hacky:

Date.now()

Se você quiser ter a certeza absoluta de que isto não vai quebrar em algum navegador antigo (pré-ie9), você pode colocá-lo atrás de uma verificação, assim:

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

Isto vai devolver os milissegundos desde o tempo da época, claro, não segundos.

Documentação MDN em Data.agora.

Mais simples:

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

Hoje - 2018.06.27 eu forneço alguma comparação de tempo para soluções js puras. Isto pode ser útil para as pessoas que querem obter / medir o tempo em JS de forma leve / eficiente (por exemplo. para aplicações em tempo real, como simulações, jogos, etc.)

Testado em MacOs High Sierra 10.13.3 em cromo 67.0.3396.99 (64-bit), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64-bit). Na imagem abaixo, mostrar-lhe-ei os resultados do navegador mais rápido (Safari):

Enquanto observo o {[[0]} foi o método mais rápido para obter o timestamp para todos os três navegadores. Safari tem 19,2 M de operações por segundo, Firefox 16,1 M, cromo 7,8 M.

O new Date()*1 foi mais lento para o cromado (2,8 M) e para o Firefox (2,6 M). O Number(new Date()) foi mais lento para Safari (2,9 M).

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

Pode fazer um teste na sua máquina aqui: https://jsperf.com/timestamp-test-x.

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