Otra forma de crear una fecha en JavaScript es indicando el número de milisegundos transcurridos desde las 12 de la madrugada del 1 de enero de 1970 (en formato horario UTC):
var objFecha2 = new Date(1308079282000);
// Devuelve "Tue Jun 14 20:21:22 UTC+0100 2011"
alert( objFecha2 );
El texto mostrado puede variar dependiendo del navegador web usado.
Usar UTC nos resultará útil cuando la página web es accesible desde diferentes partes del mundo, y por alguna razón necesitamos tener en cuenta una hora global.
Los formatos horarios UTC y GMT tienen los mismos valores, por lo tanto es lo mismo decir 'UTC+2' que 'GMT+2', por ejemplo. La diferencia entre ellas es la forma que usan para calcular el tiempo, siendo más preciso UTC.
Puedes averiguar cuál es tu zona horaria desde este enlace.
Vea también: [ Crear fechas en JavaScript ]
Aparte de los métodos vistos anteriormente disponemos de los siguientes, con los que podemos obtener datos de una fecha creada en formato UTC:
- getUTCDate(): devuelve el día del mes (1 a 31).
- getUTCDay(): devuelve el día de la semana (0 a 6).
- getUTCFullYear(): cuatro dígitos del año.
- getUTCHours(): hora en formato 24h (0 a 23).
- getUTCMilliseconds(): milisegundos de la fecha especificada (0 a 999).
- getUTCMinutes(): devuelve los minutos (0 a 59).
- getUTCMonth(): devuelve el mes (desde 0 hasta 11).
- getUTCSeconds(): devuelve el número de segundos (0 a 59).
var objFecha = new Date(2011, 5, 14, 20, 21, 22);
// Devuelve: "14/5/2011"
alert( objFecha.getUTCDate() + "/" + objFecha.getUTCMonth() + "/" + objFecha.getUTCFullYear() );
// Devuelve: "19:21:22"
alert( objFecha.getUTCHours()+ ":" + objFecha.getUTCMinutes() + ":" + objFecha.getUTCSeconds() );
Observa que en el segundo caso el método getUTCHours() devuelve una hora menos que la definida al crear el Objeto Date(): esto es así porque mi sistema operativo está configurado para la zona horaria UTC+1, con lo cual está a una hora de más sobre la hora mundial UTC, y por lo tanto hay que restarla.
Por dicho motivo, si ejecutas el código JavaScript anterior es posible que obtengas un resultado diferente dependiendo de la zona horaria para la que esté configurado tu sistema operativo.
En todo caso, debes tener claro que con estos métodos estamos trabajando con formato horario UTC, y la hora no tiene que coincidir obligatoriamente con la hora local en que nos encontremos.
Otros métodos del Objeto Date() con los que podemos obtener información en formato UTC son:
- getTime(): devuelve el número de milisegundos transcurridos desde el las 12 de la madrugada del 1 de enero 1970 (UTC).
parse(): devuelve el número de milisegundos transcurridos desde las 12 de la madrugada del 1 de enero 1970 (UTC) de una fecha pasada como parámetro en formato de cadena. En caso de que la cadena no pueda convertirse se devuelve NaN (no es un número).
Si en la cadena no indicamos una zona horaria (UTC, UTC+1...) se usará la configurada en el sistema operativo.
Al contrario que como sucede con getTime() no es necesario crear un objeto de tipo Date() para usar parse().
UTC(): devuelve el número de milisegundos transcurridos desde las 12 de la madrugada del día 1 de enero 1970, en formato horario UTC+0, de una fecha pasada como parámetro indicando por separado y en el siguiente orden: año, mes, día, horas, minutos, segundos, milisegundos.
No es necesario crear un Objeto Date() para usar este método.
var objFecha = new Date(2011, 4, 14, 20, 21, 22);
// Devuelve: 1305400882000
alert( objFecha.getTime() );
// Devuelve: 1305327600000
alert( Date.parse("May 14, 2011") );
// Devuelve: 1305331200000
alert( Date.parse("May 14, 2011 UTC") );
// Devuelve: 1305400882000
alert( Date.parse("May 14, 2011 20:21:22") );
// Devuelve: 1305404482000
alert( Date.parse("May 14, 2011 20:21:22 UTC") );
// Devuelve: 1305404482000
alert( Date.UTC(2011, 4, 14, 20, 21, 22) );
Si no posees aún muchos conocimientos en programación y simplemente te encuentras aprendiendo a programar en JavaScript, te recomiendo que de momento uses los métodos de la sección anterior en lugar de los UTC.
Vea también: [ Obtener datos de una fecha ]
Para modificar fechas en formato UTC ya creadas disponemos de los siguientes métodos:
- setUTCDate(): establece el día del mes (1 a 31).
- setUTCFullYear(): cuatro dígitos del año.
- setUTCHours(): hora en formato 24h (0 a 23).
- setUTCMilliseconds(): milisegundos de la fecha especificada (0 a 999).
- setUTCMinutes(): establece los minutos (0 a 59).
- setUTCMonth(): establece el mes (desde 0 hasta 11).
- setUTCSeconds(): establece el número de segundos (0 a 59).
var objFecha = new Date(2000, 1, 1, 12, 00, 00);
objFecha.setUTCDate(14);
objFecha.setUTCMonth(11);
objFecha.setUTCFullYear(2011);
objFecha.setUTCHours(20);
objFecha.setUTCMinutes(21);
objFecha.setUTCSeconds(22);
// Devuelve: "Wed Dec 14 20:21:22 UTC 2011"
alert( objFecha );
Vea también: [ Modificar fechas ]
El método getTimezoneOffset() devuelve la diferencia entre la hora mundial y la hora local (configurada en el sistema operativo).
Por ejemplo, si tu zona horaria es UTC+2 o GMT+2 (son lo mismo) se devolvería -120.
Para sumar o restar un intervalo de tiempo a una fecha en JavaScript, en primer lugar debemos obtener el número de milisegundos transcurridos desde las 12 de la madrugada del 1 de enero de 1970 (formato horario UTC) usando el método getTime(), y a continuación realizar la operación deseada usando setTime().
A la hora de realizar cálculos con milisegundos hemos de tener en cuenta que:
- 1 segundo -> 1000 milisegundos.
- 1 minuto -> 60 * 1.000 = 60.000 milisegundos.
- 1 hora -> 60 * 60.000 = 3.600.000 milisegundos.
- 1 día -> 24 * 3.600.000 = 86.400.000 milisegundos.
Veamos unos ejemplos:
// Crear un objeto de tipo fecha:
var objFecha = new Date(2011, 4, 10, 15, 00, 00);
// Obtener el número de milisegundos de la fecha:
var milisegundos = objFecha.getTime();
// Sumar 2 horas. Devuelve: '10/4/2011 - 17:0:0':
objFecha.setTime( milisegundos + (2 * 3600000) );
// Sumar 2 días. Devuelve '12/4/2011 - 15:0:0':
objFecha.setTime( milisegundos + (2 * 86400000) );
// Restar 3 días. Devuelve '7/4/2011 - 15:0:0':
objFecha.setTime( milisegundos - (3 * 86400000) );
Observa que las operaciones con setTime() las estamos realizando con respecto a la primera fecha, que es con la que hemos usado getTime().
Para averiguar la diferencia entre dos fechas tenemos que obtener los milisegundos de cada una de ellas (desde las 12 de la madrugada del 1 de enero de 1970 (formato horario UTC) usando el método getTime() y después hallar la diferencia, para finalmente calcular de cuántos segundos, minutos, días, etc. se trata.
Aquí tienes un ejemplo:
// Crear dos objetos de tipo fecha:
var objFecha1 = new Date( 2011, 4, 1 );
var objFecha2 = new Date( 2011, 4, 30 );
// Obtener el número de milisegundos de cada una:
var milisegundos1 = objFecha1.getTime();
var milisegundos2 = objFecha2.getTime();
var dif = null;
// Obtener la diferencia en milisegundos entre ambas fechas, la
// fecha inicial no puede ser mayor que la final:
if( milisegundos2 >= milisegundos1 )
dif = milisegundos2 - milisegundos1;
if( dif == null )
document.body.innerHTML += "La fecha inicial es mayor que la final.";
else
{
var segundos = dif / 1000;
var minutos = dif / 60000;
var horas = dif / 3600000;
var dias = dif / 86400000;
document.body.innerHTML += "Entre ambas fechas hay una diferencia de [" + dif + "] milisegundos.<br />";
document.body.innerHTML += "Entre ambas fechas hay una diferencia de [" + segundos + "] segundos.<br />";
document.body.innerHTML += "Entre ambas fechas hay una diferencia de [" + minutos + "] minutos.<br />";
document.body.innerHTML += "Entre ambas fechas hay una diferencia de [" + horas + "] horas.<br />";
document.body.innerHTML += "Entre ambas fechas hay una diferencia de [" + dias + "] días.<br />";
}
Como resultado obtendríamos:
