¿Cómo puedo obtener una marca de tiempo en JavaScript?

Algo similar a marca de tiempo Unix, es decir, un solo número que representa la hora y fecha actuales. Ya sea como un número o una cadena.

4220
pupeno 21 oct. 2008 a las 13:29

29 respuestas

Esto 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);
            }
};
13
Ronnie Royston 9 oct. 2015 a las 02:03

Forma más simple:

var timeStamp=event.timestamp || new Date().getTime();
8
Vicky Gonsalves 26 oct. 2013 a las 03:51

Al momento de escribir esto, la respuesta principal tiene 9 años, y muchas cosas han cambiado desde entonces, entre otras cosas, tenemos un soporte casi universal para una solución no hacky:

Date.now()

Si desea estar absolutamente seguro de que esto no se romperá en algún navegador antiguo (anterior a 9), puede ponerlo detrás de un cheque, así:

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

Esto devolverá los milisegundos desde el tiempo de la época, por supuesto, no segundos.

Documentación de MDN en Date.now

9
Olemak 14 dic. 2017 a las 10:09

Moment.js puede abstraer mucho del dolor al tratar con las fechas de Javascript.

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

moment().unix();
10
Rimian 6 mar. 2015 a las 00:33

Fecha , un objeto nativo en JavaScript es la forma en que obtenemos todos los datos sobre el tiempo.

Solo tenga cuidado en JavaScript, la marca de tiempo depende del conjunto del equipo cliente, por lo que no es una marca de tiempo 100% precisa. Para obtener el mejor resultado, debe obtener la marca de tiempo del lado del servidor .

De todos modos, mi forma preferida es usar vainilla. Esta es una forma común de hacerlo en JavaScript:

Date.now(); //return 1495255666921

En MDN se menciona a continuación:

El método Date.now () devuelve el número de milisegundos transcurridos desde 1 de enero de 1970 00:00:00 UTC.
Como now () es un método estático de Date, siempre lo usa como Date.now ().

Si usa una versión inferior a ES5, Date.now(); no funciona y debe usar:

new Date().getTime();
40
Alireza 5 jul. 2019 a las 17:58

Aprendí una forma realmente genial de convertir un objeto Date dado a una marca de tiempo Unix del código fuente de JQuery Cookie el otro día.

Este es un ejemplo:

var date = new Date();
var timestamp = +date;
14
george 11 mar. 2015 a las 09:52

Solo puedes usar

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

Para obtener la marca de tiempo actual. No es necesario hacer nada extra.

21
Ruslan López 24 jun. 2016 a las 18:48

Proporciono múltiples soluciones con descripciones en esta respuesta. Siéntase libre de hacer preguntas si algo no está claro
PD: lamentablemente alguien fusionó esto con la respuesta principal sin dar crédito.


Solución rápida y sucia:

Date.now() /1000 |0

Advertencia : podría romper en 2038 y devolver números negativos si realiza la magia |0. Utilice Math.floor() en su lugar para ese momento

solución Math.floor():

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

Alguna alternativa nerd por Derek 朕 會 功夫 tomado de los comentarios debajo de esta respuesta:

new Date/1e3|0

Polyfill para que Date.now() funcione:

Para que funcione en IE, puede hacer esto (Polyfill de MDN):

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

Si no le importa el año / día de la semana / horario de verano, puede quitarlo y usarlo después de 2038:

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

Algunos resultados de cómo se verá:

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 )

Por supuesto, romperá el horario de verano, pero dependiendo de lo que esté construyendo, esto podría ser útil si necesita realizar operaciones binarias en las marcas de tiempo después de que int32 se romperá en 2038.

Esto también devolverá valores negativos, pero solo si el usuario de esa PC en la que está ejecutando su código está cambiando el reloj de su PC al menos al 31 de diciembre del año anterior.


Si solo desea saber el tiempo relativo desde el momento en que se ejecutó el código primero, puede usar algo como esto:

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

En caso de que esté usando jQuery, puede usar $.now() como se describe en Documentos de jQuery que hace que el polyfill sea obsoleto ya que $.now() internamente hace lo mismo: (new Date).getTime()

Si está contento con la versión de jQuery, considere votar a favor esta respuesta ya que no la encontré yo mismo.


Ahora una pequeña explicación de lo que hace |0:

Al proporcionar |, le dice al intérprete que haga una operación OR binaria. Las operaciones de bit requieren números absolutos que convierten el resultado decimal de Date.now() / 1000 en un entero.

Durante esa conversión, se eliminan los decimales, lo que resulta en el mismo resultado que con Math.floor() pero con menos código.

Tenga cuidado: convertirá un doble de 64 bits a un entero de 32 bits. Esto dará como resultado la pérdida de información cuando se trate de grandes cantidades. Las marcas de tiempo se romperán después de 2038 debido al desbordamiento de enteros de 32 bits.


Para obtener más información sobre Date.now, siga este enlace: Date.now() @ MDN

130
mgthomas99 4 abr. 2018 a las 15:46

El código Math.floor(new Date().getTime() / 1000) se puede acortar a new Date / 1E3 | 0.

Considere omitir directamente getTime() invocación y uso | 0 como reemplazo de Función Math.floor(). También es bueno recordar que 1E3 es un equivalente más corto para 1000 (se prefiere E mayúscula que minúscula para indicar 1E3 como una constante).

Como resultado obtienes lo siguiente:

var ts = new Date / 1E3 | 0;

console.log(ts);
25
Valentin 27 mar. 2018 a las 06:08

Para lodash y subrayado, use _.now.

var timestamp = _.now(); // in milliseconds
12
Muhammad Reda 30 mar. 2015 a las 08:40

Uno que aún no he visto

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

Otro que aún no he visto es

var _ = require('lodash'); // from here https://lodash.com/docs#now
_.now();
29
mgthomas99 4 abr. 2018 a las 16:10

Este tiene una solución: que convierte la marca de tiempo de Unix a hora en js intente esto

var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();
14
Anoop P S 1 jul. 2013 a las 06:47
var timestamp = Number(new Date()); // current time as number
88
aemkei 21 oct. 2008 a las 13:00
// 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>
20
Ruslan López 24 jun. 2016 a las 18:47

Además de las otras opciones, si desea un formato de fecha ISO, puede obtenerlo directamente

console.log(new Date().toISOString());
43
Ruslan López 24 jun. 2016 a las 18:59

Recomiendo usar moment.js. Para obtener el número de milisegundos desde la época de UNIX, haga

moment().valueOf()

Para obtener el número de segundos desde la época UNIX, haga

moment().unix()

También puedes convertir tiempos así:

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

Lo hago todo el tiempo. Sin juego de palabras.

Para usar moment.js en el navegador:

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

Para obtener más detalles, incluidas otras formas de instalar y usar MomentJS, consulte sus documentos

22
FullStack 1 oct. 2015 a las 07:28

jQuery proporciona su propio método para obtener la marca de tiempo:

var timestamp = $.now();

(además solo implementa la expresión (new Date).getTime())

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

61
VisioN 15 mar. 2013 a las 14:19

JavaScript funciona con la cantidad de milisegundos desde la época, mientras que la mayoría de los otros idiomas funcionan con los segundos. Podría trabajar con milisegundos, pero tan pronto como pase un valor para decir PHP, las funciones nativas de PHP probablemente fallarán. Entonces, para estar seguro, siempre uso los segundos, no milisegundos.

Esto le dará una marca de tiempo Unix (en segundos):

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

Esto le dará los milisegundos desde la época (no la marca de tiempo de Unix):

var milliseconds = new Date().getTime();
271
Peter Mortensen 30 may. 2011 a las 21:12

Si desea una forma básica de generar una marca de tiempo en Node.js, esto funciona bien.

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

Nuestro equipo está utilizando esto para reventar el caché en un entorno localhost. La salida es /dist/css/global.css?v=245521377 donde 245521377 es la marca de tiempo generada por hrtime().

Espero que esto ayude, los métodos anteriores también pueden funcionar, pero descubrí que este es el enfoque más simple para nuestras necesidades en Node.js.

14
Kevin Leary 29 may. 2015 a las 13:40

Si es para fines de registro, puede usar ISOString

new Date().toISOString()

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

12
cenkarioz 18 may. 2019 a las 20:43

Solo para sumar, aquí hay una función para devolver una cadena de marca de tiempo en Javascript. Ejemplo: 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;
}
41
live-love 21 sep. 2012 a las 19:46

Aquí hay una función simple para generar la marca de tiempo en el 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())));
}
20
VisioN 3 jul. 2013 a las 15:10

Para una marca de tiempo con resolución de microsegundos, hay performance.now:

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

Esto podría, por ejemplo, producir 1436140826653.139, mientras que Date.now solo da 1436140826653.

21
iter 6 jul. 2015 a las 00:01

El Date.getTime() se puede usar con un pequeño ajuste:

El valor devuelto por el método getTime es el número de milisegundos desde el 1 de enero de 1970 a las 00:00:00 UTC.

Divida el resultado entre 1000 para obtener la marca de tiempo de Unix, floor si es necesario:

(new Date).getTime() / 1000

El método Date.valueOf() es funcionalmente equivalente a Date.getTime(), lo que hace posible utilizar operadores aritméticos en el objeto de fecha para lograr resultados idénticos. En mi opinión, este enfoque afecta la legibilidad.

27
Salman A 7 may. 2015 a las 09:10
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
45
Ruslan López 24 jun. 2016 a las 18:48

Cualquier navegador no compatible con Date.now, puede usar esto para obtener la fecha y hora actual:

currentTime = Date.now() || +new Date()
16
mr.boyfox 9 may. 2013 a las 06:53

Hoy - 2018.06.27 Proporciono alguna comparación de tiempo para soluciones js puras. Esto puede ser útil para las personas que desean obtener / medir el tiempo en JS de manera ligera / eficiente (por ejemplo, para aplicaciones en tiempo real como simulaciones, juegos, etc.)

Probado en MacOs High Sierra 10.13.3 en Chrome 67.0.3396.99 (64 bits), Safari 11.0.3 (13604.5.6), Firefox 59.0.2 (64 bits). En la siguiente captura de pantalla, te muestro los resultados para el navegador más rápido (Safari):

enter image description here

Como observo, Date.now() fue el método más rápido para obtener la marca de tiempo de los tres navegadores. Safari tiene 19.2 millones de operaciones por segundo, Firefox 16.1 millones, Chrome 7.8 millones.

El new Date()*1 fue más lento para Chrome (2.8M) y Firefox (2.6M). El Number(new Date()) fue el más lento para Safari (2.9M).

Entonces, el código JS ganador es Date.now() y el navegador más rápido es Safari (¡2 veces más rápido que Chrome!).

Puede realizar pruebas en su máquina aquí: https://jsperf.com/timestamp-test-x.

21
Kamil Kiełczewski 27 jun. 2018 a las 16:59
var time = Date.now || function() {
  return +new Date;
};

time();
144
Martin Tournoij 16 dic. 2014 a las 13:31

Me gusta esto, porque es pequeño:

+new Date

También me gusta esto, porque es igual de corto y es compatible con los navegadores modernos, y más de 500 personas votaron que es mejor:

Date.now()
507
xer0x 30 nov. 2017 a las 19:23