¿Cómo se obtiene una marca de tiempo en JavaScript?

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

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

preguntado Oct 21 '08, 10:10

30 Respuestas

Corto y elegante:

+ new Date()

Un operador unario como plus desencadena el valueOf método en el Date objeto y devuelve la marca de tiempo (sin ninguna alteración).

Detalles:

En casi todos los navegadores actuales puede utilizar Date.now() para obtener la marca de tiempo UTC en milisegundos; una excepción notable a esto es IE8 y versiones anteriores (ver tabla de compatibilidad).

Sin embargo, puede hacer una calza fácilmente para esto:

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

Para obtener la marca de tiempo segundos, puedes usar:

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

O alternativamente puede usar:

Date.now() / 1000 | 0

Que debería ser un poco más rápido, pero también menos legible (también mira esta respuesta).

Recomendaría usar Date.now() (con cuña de compatibilidad). Es un poco mejor porque es más corto y no crea un nuevo Date objeto. Sin embargo, si no desea una corrección y la máxima compatibilidad, puede usar el método "antiguo" para obtener la marca de tiempo en milisegundos:

new Date().getTime()

Que luego puede convertir a segundos como este:

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

Y también puedes usar el valueOf método que mostramos arriba:

new Date().valueOf()

Marca de tiempo en milisegundos

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

contestado el 30 de mayo de 18 a las 14:05

En caso de que se pregunte acerca de la lógica de plus el signo es: + se usa como toInt() donde descuidará todos los caracteres y devolverá solo números - Umair Riaz

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

respondido 30 nov., 17:22

Esta opción es una mala idea. Se pasa por alto fácilmente, parece un error tipográfico y, en realidad, se basa en un efecto secundario del lenguaje. Veo un código incorrecto. - inanutshellus

@Billy Según recuerdo, calculé la marca de tiempo en las dos soluciones sugeridas 1 millón de veces cada una, y calculé el tiempo de ejecución promedio. Lo ejecuté en Firefox y Chrome, siendo getTime más rápido en ambos navegadores. Dicho esto, incluso si fuera (marginalmente) más lento, elegiría new Date().getTime(). ¡Afortunadamente para mí, la solución más rápida ya es la solución legible! - inanutshellus

De acuerdo con @ FabrícioMatté. El comportamiento unitario del operador puede no ser rudimentario, pero si no lo ha repasado, no espere poder funcionar eficazmente en muchos equipos. - Jason T Featheringham

@Niklaus Eso es porque lo estás concatenando a otra cadena. En ese caso, new Date().toString() se llama. - kirb

por curiosidad cual es el +haciendo el operador para que salga como una cuerda? - Zadubz

JavaScript funciona con la cantidad de milisegundos desde la época, mientras que la mayoría de los otros lenguajes 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 los milisegundos.

Esto le dará una marca de tiempo de 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();

contestado el 31 de mayo de 11 a las 01:05

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

time();

Respondido el 16 de diciembre de 14 a las 16:12

Proporciono múltiples soluciones con descripciones en esta respuesta. No dude en 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: eso podría romper en 2038 y devolver números negativos si hace el |0 magia. Usar Math.floor() en cambio para ese momento

Math.floor() solución:

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

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

new Date/1e3|0

Polyfill para obtener Date.now() trabajando:

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

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 eliminarlo 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 serle útil si necesita realizar operaciones binarias en marcas de tiempo después de que int32 se rompa 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, podría usar $.now() como se describe en Documentos de jQuery lo 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 este respuesta ya que no lo encontré yo mismo.


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

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

Durante esa conversión, se eliminan los decimales, lo que da como resultado el mismo resultado que usar Math.floor() pero usando menos código.

Sin embargo, ten en cuenta: convertirá un doble de 64 bits en un entero de 32 bits. Esto resultará en una pérdida de información cuando se trate de grandes números. Las marcas de tiempo se romperán después de 2038 debido a un desbordamiento de enteros de 32 bits.


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

Respondido 04 Abr '18, 18:04

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

Respondido 21 Oct 08, 17:10

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

var timestamp = $.now();

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

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

respondido 15 mar '13, 18:03

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

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

Respondido el 24 de junio de 16 a las 21:06

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

Respondido el 24 de junio de 16 a las 21:06

Solo para agregar, 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;
}

Respondido el 21 de Septiembre de 12 a las 23:09

Fecha, la 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 de la computadora 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 el 1 de enero de 1970 a las 00:00:00 UTC.
Debido a que 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 necesitas usar:

new Date().getTime();

Respondido 05 Jul 19, 20:07

Rendimiento

Hoy - 2020.04.23 realizo pruebas para las soluciones elegidas. Probé en MacOs High Sierra 10.13.6 en Chrome 81.0, Safari 13.1, Firefox 75.0

Conclusiones

  • solución Date.now() (E) es el más rápido en Chrome y Safari y el segundo más rápido en Firefox y esta es probablemente la mejor opción para una solución rápida entre navegadores
  • solución performance.now() (G), lo que es sorprendente, es más de 100 veces más rápido que otras soluciones en Firefox, pero más lento en Chrome.
  • Las soluciones C, D, F son bastante lentas en todos los navegadores

enter image description here

Detalles

Resultados para chrome

enter image description here

Puede realizar una prueba en su máquina AQUÍ.

El código utilizado en las pruebas se presenta en el siguiente fragmento

function A() {
  return new Date().getTime();
}

function B() {
  return new Date().valueOf();
}

function C() {
  return +new Date();
}

function D() {
  return new Date()*1;
}

function E() {
  return Date.now();
}

function F() {
  return Number(new Date());
}

function G() {
  // this solution returns time counted from loading the page.
  // (and on Chrome it gives better precission)
  return performance.now(); 
}



// TEST

log = (n,f) => console.log(`${n} : ${f()}`);

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
This snippet only presents code used in external benchmark

Respondido el 20 de junio de 20 a las 12:06

Uno que no he visto todavía

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

Otro que no he visto todavía es

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

Respondido 04 Abr '18, 19:04

El Date.getTime() El método se puede utilizar 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 por 1000 para obtener la marca de tiempo de Unix, floor si necesario:

(new Date).getTime() / 1000

El Date.valueOf() El método 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.

contestado el 07 de mayo de 15 a las 12:05

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 un reemplazo para Math.floor() función. También es bueno recordar 1E3 es un equivalente más corto de 1000 (se prefiere la E mayúscula que la minúscula para indicar 1E3 como una constante).

Como resultado, obtienes lo siguiente:

var ts = new Date / 1E3 | 0;

console.log(ts);

respondido 27 mar '18, 09:03

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 Date.now solo da 1436140826653.

Respondido 06 Jul 15, 03:07

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 de UNIX, haga

moment().unix()

También puede convertir tiempos como este:

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

Hago eso 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 su documentos

Respondido 01 Oct 15, 10:10

Solo puedes usar

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

para obtener la marca de tiempo actual. No es necesario hacer nada adicional.

Respondido el 24 de junio de 16 a las 21:06

Aquí hay una función simple para generar una 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())));
}

Respondido 03 Jul 13, 19:07

@ b123400 - Aquí está la versión Lisp: (new (chain (-date) (to-i-s-o-string))). - Inaimathi

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

Respondido el 24 de junio de 16 a las 21:06

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

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

contestado el 09 de mayo de 13 a las 10:05

(Parafraseando mi comentario) Su código tiene un problema: ejecuta el método Date.now en lugar de verificar su compatibilidad primero. En las cejas más antiguas, provocará Date.now no es una función error. - Salman A

Quizás una mejor alternativa sería usar un operador ternario para afirmar que Date.now realmente existe (y es una función), antes de intentar invocarlo: currentTime = typeof Date.now === "function" ? Date.now() : +new Date(). - mgthomas99

Este tiene una solución: que convierte unixtime stamp a tim en js prueba esto

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

Respondido 01 Jul 13, 10:07

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

He aquí un ejemplo:

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

respondido 11 mar '15, 12:03

Estaba a punto de escribir el nuevo objeto Date (). Puede consola log (new Date ()) y luego hojear los métodos relacionados bajo el nuevo objeto / función Date () - sg28

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á usando esto para romper el caché en un entorno de host local. La salida es /dist/css/global.css?v=245521377 dónde 245521377 es la marca de tiempo generada por hrtime().

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

contestado el 29 de mayo de 15 a las 16:05

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

Respondido 09 Oct 15, 05:10

Si es para fines de registro, puede utilizar ISOString

new Date().toISOString()

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

contestado el 18 de mayo de 19 a las 23:05

Para lodash y guion bajo usuarios, uso _.now.

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

respondido 30 mar '15, 11:03

Moment.js puede eliminar gran parte del dolor al tratar con las fechas de Javascript.

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

moment().unix();

respondido 06 mar '15, 03:03

Tenga en cuenta que esto da el número de segundos (no milisegundos) desde la época de UNIX. Si quieres milisegundos, usa moment().valueOf(). Mira mi respuesta. - Completa pila

Al momento de escribir esto, la respuesta principal es de 9 años, y muchas cosas han cambiado desde entonces; no menos importante, tenemos soporte casi universal para una solución no pirateada:

Date.now()

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

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

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

Documentación de MDN en Date.now

Respondido el 14 de diciembre de 17 a las 13:12

forma más sencilla:

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

Respondido 26 Oct 13, 07:10

Sabes donde event viene de. Debe dar una mejor explicación de la forma en que lo resuelve en lugar de escribir una respuesta. ¡Por favor! - alexventuraio

Estaba a punto de escribir el nuevo objeto Date (). Puede consola log (new Date ()) y luego hojear los métodos relacionados bajo el nuevo objeto / función Date () - sg28

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.