Nuestro grupo de especialistas despúes de muchos días de trabajo y recopilación de de información, encontramos la solución, nuestro deseo es que resulte útil para ti en tu trabajo.
Solución:
Día Juliano
El juliano Día es el número de días transcurridos desde el comienzo de un ciclo de 7980 años.
Inventado en 1583 por Joseph Scaliger, el propósito del sistema es facilitar calcular un número entero (número entero) diferencia entre una fecha del calendario y otra fecha del calendario.
El ciclo de 7980 años se obtuvo mediante la combinación de varios ciclos de tiempo tradicionales (ciclo de impuestos solar, lunar y un particular romano) para el cual 7980 fue un múltiplo común.
El punto de partida para el primer ciclo juliano comenzó el 1 de enero de 4713 a. C. al mediodía GMT y finalizará el 22 de enero de 3268 al mediodía GMT, exactamente 7980 días completos después.
Como ejemplo, el número de días julianos para el 1 de enero de 2016 fue 2,457,389, que es el número de días desde el 1 de enero de 4713 AC en ese día.
Como calcularlo
Como sabemos que el tiempo Unix es el número de segundos desde las 00:00:00 UTC, 1 de enero de 1970, sin contar los segundos intercalares, y también llamado Época, podemos usar algunas matemáticas para calcular el Día Juliano cuando ya tenemos Unix. tiempo.
GMT y UTC comparten la misma hora actual en la práctica, por lo que para esto, no debería haber diferencia.
Para empezar, necesitamos saber la cantidad de días desde que comenzó el ciclo juliano hasta que comenzaron las marcas de tiempo de Unix.
En otras palabras, el número de días desde el 1 de enero de 4713 a.C. a las 12:00:00 GMT hasta el 1 de enero de 1970 a las 00:00:00 UTC.
Teniendo este número de días establecido, que nunca cambia, podemos simplemente agregar el número de días desde el 1 de enero de 1970 hasta hoy, que es lo que Javascript devuelve de todos modos, para obtener el día juliano.
Sin sumar todos esos años, sino simplemente buscando en la web, nos dice que la diferencia de días entre el año 4713 a.C. y 1970 d.C. es 2440588 días, y debido a que el Ciclo Juliano comenzó al mediodía, no a la medianoche, tenemos que reste exactamente medio día, por lo que es 2440587,5 días.
Entonces lo que tenemos ahora es 2440587.5 days + UNIX TIME in days === Julian Day
Con algunas matemáticas simples podemos calcular que un día tiene 86,400 segundos de duración, y la marca de tiempo de Unix está en milisegundos cuando se usa Javascript, por lo que UNIX TIME / 86400000 nos daría el número de días desde el jueves 1 de enero de 1970 hasta hoy.
Ahora, solo para el día, queríamos el número total de días, y no la fracción, y podemos redondearlo al cierre del día completo, haciendo algo como
Math.floor((UNIX TIME / 86400000) + 2440587.5);
Fecha de Julian
A veces, en la programación, una “Fecha Juliana” ha llegado a significar el número de días desde que comenzó el año, por ejemplo, el 1 de junio de 2016 sería 152 días en ese año, etc.
El uso correcto de “Fecha juliana” es un día juliano con una marca de tiempo agregada como una fracción del día.
Tomando el ejemplo en la parte superior de esta respuesta, donde el 1 de enero de 2016 fue el día juliano 2,457,389, podemos agregar un tiempo a eso.
El día juliano comienza al mediodía, sin tiempo fraccionario agregado, por lo que a la medianoche sería 2457389.5 y a las 18:00, o seis horas después del mediodía, sería 2457389.25, agregando “medio día”, “cuarto de día”, etc.
Calculándolo, de nuevo
Esto significa que 0.1 Fecha Juliana es lo mismo que 24 horas divididas por 10, o 24 / 10 === 2.4 hours, o en otras palabras, las marcas de tiempo del día juliano son fraccionales con decimales (una décima parte de un día, etc.).
Veamos algunas funciones de Javascript, en primer lugar el Date constructor.
Javascript solo tiene acceso a la hora local en la computadora en la que se ejecuta, por lo que cuando lo hacemos new Date() no crea necesariamente una fecha UTC, incluso si la hora UNIX está en UTC, new Date le da la cantidad de segundos desde la época hasta la hora local que tiene su computadora, y no toma en consideración su zona horaria.
Sin embargo, Javascript tiene Date.UTC, que devolvería la fecha en formato UTC, verifiquemos la diferencia, y esto, por supuesto, diferirá según la zona horaria en la que haya configurado el sistema local.
var regular_date = new Date(2016, 1, 1, 0, 0, 0);
var UTC_date = Date.UTC(2016, 1, 1, 0, 0, 0);
var difference = UTC_date - regular_date;
document.body.innerHTML = 'The difference between your local time and UTC is ' +(difference/1000)+ ' seconds';Recuerde la parte al comienzo de este capítulo, aproximadamente 0.1 Fecha Juliana es lo mismo que 24 horas divididas por 10, o 24 / 10 === 2.4 hours, bueno, 2.4 horas son 144 minutos, y ahora veamos rápidamente Javascripts getTimezoneOffset() método, dicen los docs
El método getTimezoneOffset () devuelve el desplazamiento de la zona horaria de UTC, en minutos, para la configuración regional actual.
Entonces, devuelve el desplazamiento para la zona horaria del sistema en minutos, eso es interesante ya que la mayoría de los métodos de JavaScript que tratan con fechas devuelven milisegundos.
Sabemos que 1/10 de un día son 144 minutos, por lo que 10/10, o un día completo, serían 1440 minutos, por lo que podríamos usar algunas matemáticas para contrarrestar la zona horaria de los sistemas locales, expresada en minutos, y dividirla por la cantidad de minutos en un día, para obtener el valor fraccionario correcto
Entonces ahora tenemos
2440587.5 days + UNIX TIME in days === Julian Day
y sabemos que el constructor de Javascripts Date realmente no usa UTC para la fecha actual, sino la hora del sistema, por lo que tenemos que tener
TIMEZONEOFFSET / 1440
uniéndolos juntos obtendríamos
(JAVASCRIPT TIME / 86400000) - (TIMEZONEOFFSET / 1440) + 2440587.5
// ^^ days since epoch ^^ ^^ subtract offset ^^ ^^days from 4713 B.C. to 1970 A.D.
Traducir eso a javascript sería
var date = new Date(); // a new date
var time = date.getTime(); // the timestamp, not neccessarely using UTC as current time
var julian_day = (time / 86400000) - (date.getTimezoneOffset()/1440) + 2440587.5);
Ahora bien, esto es lo que deberíamos usar para obtener el Julian Día también, tomando medidas para eliminar el desplazamiento de la zona horaria y, por supuesto, sin la parte de tiempo fraccional del Julian Fecha.
Haríamos esto simplemente redondeándolo al entero más cercano
var julian_date = Math.floor((time / 86400000) - (date.getTimezoneOffset()/1440) + 2440587.5));
Y es hora de mi respuesta original a esta pregunta, antes de hacer esta edición extremadamente larga para explicar por qué este es el enfoque correcto, después de las quejas en el campo de comentarios.
Date.prototype.getJulian = function()
return Math.floor((this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5);
var today = new Date(); //set any date
var julian = today.getJulian(); //get Julian counterpart
console.log(julian).as-console-wrapper top:0Y el mismo con la parte fracional
Date.prototype.getJulian = function()
return (this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5;
var today = new Date(); //set any date
var julian = today.getJulian(); //get Julian counterpart
console.log(julian).as-console-wrapper top: 0 Y para terminar, un ejemplo que muestra por qué
new Date().getTime()/86400000 + 2440587.5
no funciona, al menos no si la hora de su sistema está configurada en una zona horaria con un desplazamiento, es decir, cualquier otra cosa que no sea GMT
// the correct approach
Date.prototype.getJulian = function()
return (this / 86400000) - (this.getTimezoneOffset() / 1440) + 2440587.5;
// the simple approach, that does not take the timezone into consideration
Date.prototype.notReallyJulian = function()
return this.getTime()/86400000 + 2440587.5;
// --------------
// remember how 18:00 should return a fractional 0.25 etc
var date = new Date(2016, 0, 1, 18, 0, 0, 0);
// ^ ^ ^ ^ ^ ^ ^
// year month date hour min sec milli
var julian = date.getJulian(); //get Julian date
var maybe = date.notReallyJulian(); // not so much
console.log(julian); // always returns 2457389.25
console.log(maybe); // returns different fractions, depending on timezone offset.as-console-wrapper top: 0 new Date().getTime()/86400000 + 2440587.5
obtendrá la marca de tiempo de Unix, la convertirá a días y agregará el JD de 1970-01-01, que es la época de la marca de tiempo de Unix.
Esto es lo que los astrónomos llaman fecha juliana. Está bien definido. Dado que ni la marca de tiempo de Unix ni JD tienen en cuenta los segundos intercalares, eso no reduce la precisión. Tenga en cuenta que JD no necesita estar en la zona horaria UTC (pero generalmente lo está). Esta respuesta le da el JD en la zona horaria UTC.
Según wikipedia:
a = (14 - month) / 12
y = year + 4800 - a
m = month + 12a - 3
JDN = day + (153m + 2) / 5 + 365y + y/4 - y/100 + y/400 - 32045
Si tiene un problema más específico con la implementación, proporcione esos detalles en la pregunta para que podamos ayudarlo más.
NOTA: Esto no es correcto porque los “soportes de suelo” en Wiki se olvidaron aquí.
Las fórmulas correctas son:
a = Int((14 - Month) / 12)
y = Year + 4800 - a
m = Month + 12 * a - 3
JDN = Day + Int((153 * m + 2) / 5) + 365 * y + Int(y / 4) - Int(y / 100) + Int(y / 400) - 32045
valoraciones y comentarios
Te invitamos a añadir valor a nuestro contenido colaborando tu experiencia en las anotaciones.