restar - sumar dias a una fecha javascript
¿Cómo se obtiene una marca de tiempo en JavaScript? (30)
¿Cómo puedo obtener una marca de tiempo en JavaScript?
Algo similar a la marca de tiempo de Unix, es decir, un solo número que representa la hora y fecha actuales. Ya sea como un número o una cadena.
Corto y elegante:
+ new Date()
Un operador unario como plus activa el método valueOf en el objeto Date y devuelve la marca de tiempo (sin ninguna modificación).
Detalles:
En casi todos los navegadores actuales, puede usar Date.now() para obtener la marca de hora UTC en milisegundos ; una excepción notable a esto es IE8 y anteriores (ver tabla de compatibilidad ).
Sin embargo, puedes hacer fácilmente un calzo para esto:
if (!Date.now) {
Date.now = function() { return new Date().getTime(); }
}
Para obtener la marca de tiempo en segundos , puede utilizar:
Math.floor(Date.now() / 1000)
O alternativamente puedes usar:
Date.now() / 1000 | 0
Lo que debería ser un poco más rápido, pero también menos legible (también vea esta respuesta ).
Recomendaría usar Date.now() (con compatibilidad de compatibilidad). Es un poco mejor porque es más corto y no crea un nuevo objeto Date . Sin embargo, si no desea una compatibilidad de compatibilidad máxima y máxima, puede usar el método "antiguo" para obtener la marca de tiempo en milisegundos :
new Date().getTime()
Que luego puedes convertir en segundos como este:
Math.round(new Date().getTime()/1000)
Y también puedes usar el método valueOf que mostramos anteriormente:
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());
A la hora 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 hacky:
Date.now()
Si desea estar absolutamente seguro de que esto no se interrumpirá en algún navegador antiguo (anterior a la versión 9), puede ponerlo detrás de un cheque, de esta manera:
const currentTimestamp = (!Date.now ? +new Date() : Date.now());
Esto devolverá los milisegundos desde el tiempo de la época, por supuesto, no segundos.
Además de las otras opciones, si desea un formato de fecha ISO, puede obtenerlo directamente
console.log(new Date().toISOString());
Aprendí una manera genial de convertir un objeto Date dado en una marca de tiempo Unix a partir del código fuente de JQuery Cookie el otro día.
Aquí hay un ejemplo:
var date = new Date();
var timestamp = +date;
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())));
}
Cualquier navegador no es compatible con Date.now, puede usar esto para obtener la fecha actual:
currentTime = Date.now() || +new Date()
El código Math.floor(new Date().getTime() / 1000) se puede reducir a new Date / 1E3 | 0 new Date / 1E3 | 0 .
Considera omitir la invocación y uso directo de Date.getTime() | 0 | 0 como reemplazo de la 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);
El método 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 por 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.
En algún momento lo necesito en objetos para llamadas xmlhttp, así que me gusta esto.
timestamp : parseInt(new Date().getTime()/1000, 10)
Esta tiene una solución: la cual convierte el sello de unixtime a tim en js intente esto
var a = new Date(UNIX_timestamp*1000);
var hour = a.getUTCHours();
var min = a.getUTCMinutes();
var sec = a.getUTCSeconds();
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);
}
};
Hoy, 2018.06.27, ofrezco algunas comparaciones 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):
Como observo, Date.now() fue el método más rápido para obtener la marca de tiempo para los tres navegadores. Safari tiene 19.2M operaciones por segundo, Firefox 16.1M, Chrome 7.8M.
La new Date()*1 fue más lenta para Chrome (2.8M) y Firefox (2.6M). El Number(new Date()) fue el más lento para Safari (2.9M).
Por lo tanto, el código JS ganador es Date.now() y el navegador más rápido es Safari (¡2 Date.now() más rápido que Chrome!).
Puede realizar una prueba en su máquina aquí: https://jsperf.com/timestamp-test-x .
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. Así que 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 Unix):
var milliseconds = new Date().getTime();
Me gusta esto, porque es pequeño:
+new Date
También me gusta esto, porque es igual de corto y compatible con los navegadores modernos, y más de 500 personas votaron que es mejor:
Date.now()
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 .
Para usuarios de lodash y underscore , use _.now .
var timestamp = _.now(); // in milliseconds
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, haz
moment().unix()
También puedes convertir tiempos así:
moment(''2015-07-12 14:59:23'', ''YYYY-MM-DD HH:mm:ss'').valueOf()
Hago eso todo el tiempo. No hay 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 docs
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 destruir 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() .
Esperemos que esto ayude, los métodos anteriores pueden funcionar también, pero encontré que este es el enfoque más simple para nuestras necesidades en Node.js.
Solo para agregar, aquí hay una función para devolver una cadena de marca de hora 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;
}
Solo puedes usar
var timestamp = new Date().getTime();
console.log(timestamp);
para obtener la marca de tiempo actual. No hay necesidad de hacer nada extra.
Una que no he visto todavia
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();
forma más sencilla:
var timeStamp=event.timestamp || new Date().getTime();
Moment.js puede abstraer gran parte del dolor al tratar con las fechas de Javascript.
Consulte: http://momentjs.com/docs/#/displaying/unix-timestamp/
moment().unix();
jQuery proporciona su propio método para obtener la marca de tiempo:
var timestamp = $.now();
(además solo implementa (new Date).getTime() expresión)
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 mejor respuesta sin dar crédito.
Solución rápida y sucia:
Date.now() /1000 |0
Advertencia : podría romperse en 2038 y devolver números negativos si haces la magia
|0. UtiliceMath.floor()lugar en ese momento
Math.floor() solución:
Math.floor(Date.now() /1000);
Una alternativa nerd por Derek 朕 會 功夫 tomada de los comentarios debajo de esta respuesta:
new Date/1e3|0
Polyfill para que Date.now() funcione:
Para que funcione en IE, puedes hacer esto (Polyfill desde 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 interrumpa 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é utilizando jQuery, podría usar $.now() tal como se describe en los Documentos de jQuery, lo que hace que el relleno esté obsoleto ya que $.now() hace lo mismo internamente: (new Date).getTime()
Si está contento con la versión de jQuery, considere la posibilidad de actualizar this respuesta ya que no la encontré yo mismo.
Ahora una pequeña explicación de lo que hace |0 :
Proporcionando | , usted le dice al intérprete que haga una operación OR binaria. Las operaciones de bit requieren números absolutos, lo que convierte el resultado decimal de Date.now() / 1000 en un entero.
Durante esa conversión, los decimales se eliminan, lo que da como resultado el mismo resultado que al usar Math.floor() pero al usar menos código.
Sin embargo, tenga cuidado: convertirá un doble de 64 bits en un entero de 32 bits. Esto dará lugar a la pérdida de información cuando se trata de grandes números. Las marcas de tiempo se interrumpirán después de 2038 debido al desbordamiento de enteros de 32 bits.
Para más información sobre Date.now siga este enlace: MDN
La fecha en que el 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 de la configuración del equipo cliente, por lo que no es una marca de tiempo precisa al 100%. Para obtener el mejor resultado, necesita obtener la marca de tiempo del lado del servidor .
De todos modos, mi forma preferida es usar la 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.
Como now () es un método estático de Date, siempre lo usas como Date.now ().
Si utiliza una versión inferior a ES5, Date.now(); no funciona y necesitas usar:
new Date().getTime();
// 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>
console.log(new Date().valueOf()); // returns the number of milliseconds since the epoch
var time = Date.now || function() {
return +new Date;
};
time();
var timestamp = Number(new Date()); // current time as number