restar obtener horas hora habiles fechas fecha entre dias con comparar calcular actual javascript date

horas - obtener fecha y hora actual javascript



¿Cómo obtengo el número de días entre dos fechas en JavaScript? (30)

¿Cómo obtengo el número de días entre dos fechas en JavaScript? Por ejemplo, dadas dos fechas en cuadros de entrada:

<input id="first" value="1/1/2000"/> <input id="second" value="1/1/2001"/> <script> alert(datediff("day", first, second)); // what goes here? </script>


¿Qué hay de usar formatDate desde el widget DatePicker? Podría usarlo para convertir las fechas en formato de marca de tiempo (milisegundos desde 01/01/1970) y luego hacer una simple resta.


Al momento de escribir esto, solo una de las otras respuestas maneja correctamente las transiciones DST (horario de verano). Aquí están los resultados de un sistema ubicado en California:

1/1/2013- 3/10/2013- 11/3/2013- User Formula 2/1/2013 3/11/2013 11/4/2013 Result --------- --------------------------- -------- --------- --------- --------- Miles (d2 - d1) / N 31 0.9583333 1.0416666 Incorrect some Math.floor((d2 - d1) / N) 31 0 1 Incorrect fuentesjr Math.round((d2 - d1) / N) 31 1 1 Correct toloco Math.ceiling((d2 - d1) / N) 31 1 2 Incorrect N = 86400000

Aunque Math.round devuelve los resultados correctos, creo que es un poco torpe. En cambio, al dar cuenta explícita de los cambios en el desplazamiento UTC cuando comienza o termina el horario de verano, podemos usar la aritmética exacta:

function treatAsUTC(date) { var result = new Date(date); result.setMinutes(result.getMinutes() - result.getTimezoneOffset()); return result; } function daysBetween(startDate, endDate) { var millisecondsPerDay = 24 * 60 * 60 * 1000; return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay; } alert(daysBetween($(''#first'').val(), $(''#second'').val()));

Explicación

Los cálculos de fecha de JavaScript son complicados porque los objetos Date almacenan las horas internamente en UTC, no en la hora local. Por ejemplo, 3/10/2013 12:00 AM, hora estándar del Pacífico (UTC-08: 00) se almacena como 3/10/2013 8:00 AM UTC, y 3/11/2013 12:00 AM, hora del Pacífico ( UTC-07: 00) se almacena como 3/11/2013 7:00 AM UTC. ¡En este día, de medianoche a medianoche, la hora local es de solo 23 horas en UTC!

Aunque un día en la hora local puede tener más o menos de 24 horas, un día en UTC es siempre exactamente 24 horas. 1 El método daysBetween que se muestra arriba aprovecha este hecho llamando primero a treatAsUTC para ajustar ambas horas locales a la medianoche UTC, antes de restar y dividir.

1. JavaScript ignora los segundos de salto.


Aquí hay una implementación rápida y sucia de datediff , como prueba de concepto para resolver el problema como se presenta en la pregunta. Se basa en el hecho de que puede obtener los milisegundos transcurridos entre dos fechas restándolos, lo que los obliga a ingresar en su valor de número primitivo (milisegundos desde principios de 1970).

// new Date("dateString") is browser-dependent and discouraged, so we''ll write // a simple parse function for U.S. date format (which does no error checking) function parseDate(str) { var mdy = str.split(''/''); return new Date(mdy[2], mdy[0]-1, mdy[1]); } function datediff(first, second) { // Take the difference between the dates and divide by milliseconds per day. // Round to nearest whole number to deal with DST. return Math.round((second-first)/(1000*60*60*24)); } alert(datediff(parseDate(first.value), parseDate(second.value)));

<input id="first" value="1/1/2000"/> <input id="second" value="1/1/2001"/>

Debe tener en cuenta que las API de fecha "normales" (sin "UTC" en el nombre) operan en la zona horaria local del navegador del usuario, por lo que, en general, podría tener problemas si su usuario se encuentra en una zona horaria que no. espere, y su código tendrá que lidiar con las transiciones del horario de verano. Debería leer detenidamente la documentación del objeto Date y sus métodos, y para cualquier cosa más complicada, considere utilizar una biblioteca que ofrezca API más seguras y potentes para la manipulación de fechas.

Además, para fines de ilustración, el fragmento de código utiliza el acceso con nombre en el objeto de window por brevedad, pero en producción debe usar API estandarizadas como getElementById , o más probablemente, un marco de UI.


Continuaría y tomaría esta pequeña utilidad y en ella encontrará funciones para usted. Aquí hay un breve ejemplo:

<script type="text/javascript" src="date.js"></script> <script type="text/javascript"> var minutes = 1000*60; var hours = minutes*60; var days = hours*24; var foo_date1 = getDateFromFormat("02/10/2009", "M/d/y"); var foo_date2 = getDateFromFormat("02/12/2009", "M/d/y"); var diff_date = Math.round((foo_date2 - foo_date1)/days); alert("Diff date is: " + diff_date ); </script>


Creo que las soluciones no son correctas al 100%. Usaré ceil en lugar de piso . La ronda funcionará, pero no es la operación correcta.

function dateDiff(str1, str2){ var diff = Date.parse(str2) - Date.parse(str1); return isNaN(diff) ? NaN : { diff: diff, ms: Math.ceil(diff % 1000), s: Math.ceil(diff / 1000 % 60), m: Math.ceil(diff / 60000 % 60), h: Math.ceil(diff / 3600000 % 24), d: Math.ceil(diff / 86400000) }; }


Encontré esta pregunta cuando quiero hacer un cálculo en dos fechas, pero la fecha tiene un valor de horas y minutos, modifiqué la respuesta de @ michael-liu para que se ajustara a mi requerimiento y aprobó mi examen.

los días de diferencia 2012-12-31 23:00 y 2013-01-01 01:00 deben ser iguales a 1. (2 horas) los días de diferencia 2012-12-31 01:00 y 2013-01-01 23:00 deben ser iguales a 1. (46 horas)

function treatAsUTC(date) { var result = new Date(date); result.setMinutes(result.getMinutes() - result.getTimezoneOffset()); return result; } var millisecondsPerDay = 24 * 60 * 60 * 1000; function diffDays(startDate, endDate) { return Math.floor(treatAsUTC(endDate) / millisecondsPerDay) - Math.floor(treatAsUTC(startDate) / millisecondsPerDay); }


Es mejor deshacerse de DST, Math.ceil, Math.floor, etc. utilizando los tiempos UTC:

var firstDate = Date.UTC(2015,01,2); var secondDate = Date.UTC(2015,04,22); var diff = Math.abs((firstDate.valueOf() - secondDate.valueOf())/(24*60*60*1000));

Este ejemplo da diferencia 109 días. 24*60*60*1000 es un día en milisegundos.


Es posible calcular una diferencia de días de prueba completa entre dos fechas que descansan en diferentes TZ utilizando la siguiente fórmula:

var start = new Date(''10/3/2015''); var end = new Date(''11/2/2015''); var days = (end - start) / 1000 / 60 / 60 / 24; console.log(days); // actually its 30 ; but due to daylight savings will show 31.0xxx // which you need to offset as below days = days - (end.getTimezoneOffset() - start.getTimezoneOffset()) / (60 * 24); console.log(days);


La forma más fácil de obtener la diferencia entre dos fechas:

var diff = Math.floor(( Date.parse(str2) - Date.parse(str1) ) / 86400000);

Obtiene la diferencia de días (o NaN si uno o ambos no pudieron ser analizados). La fecha de análisis dio el resultado en milisegundos y para obtenerlo por día, debe dividirlo por 24 * 60 * 60 * 1000

Si lo quieres dividido por días, horas, minutos, segundos y milisegundos:

function dateDiff( str1, str2 ) { var diff = Date.parse( str2 ) - Date.parse( str1 ); return isNaN( diff ) ? NaN : { diff : diff, ms : Math.floor( diff % 1000 ), s : Math.floor( diff / 1000 % 60 ), m : Math.floor( diff / 60000 % 60 ), h : Math.floor( diff / 3600000 % 24 ), d : Math.floor( diff / 86400000 ) }; }

Aquí está mi versión refactorizada de la versión de James:

function mydiff(date1,date2,interval) { var second=1000, minute=second*60, hour=minute*60, day=hour*24, week=day*7; date1 = new Date(date1); date2 = new Date(date2); var timediff = date2 - date1; if (isNaN(timediff)) return NaN; switch (interval) { case "years": return date2.getFullYear() - date1.getFullYear(); case "months": return ( ( date2.getFullYear() * 12 + date2.getMonth() ) - ( date1.getFullYear() * 12 + date1.getMonth() ) ); case "weeks" : return Math.floor(timediff / week); case "days" : return Math.floor(timediff / day); case "hours" : return Math.floor(timediff / hour); case "minutes": return Math.floor(timediff / minute); case "seconds": return Math.floor(timediff / second); default: return undefined; } }


La forma sencilla de calcular días entre dos fechas es eliminar ambos componentes de tiempo, es decir, configurar las horas, minutos, segundos y milisegundos a 0 y luego restar su tiempo y sumergirlo en milisegundos por valor de un día.

var firstDate= new Date(firstDate.setHours(0,0,0,0)); var secondDate= new Date(secondDate.setHours(0,0,0,0)); var timeDiff = firstDate.getTime() - secondDate.getTime(); var diffDays =timeDiff / (1000 * 3600 * 24);


Los valores de fecha en JS son valores de fecha y hora.

Por lo tanto, los cálculos de fecha directos son inconsistentes:

(2013-11-05 00:00:00) - (2013-11-04 10:10:10) < 1 day

por ejemplo tenemos que convertir de 2ª fecha:

(2013-11-05 00:00:00) - (2013-11-04 00:00:00) = 1 day

El método podría ser truncar los molinos en ambas fechas:

var date1 = new Date(''2013/11/04 00:00:00''); var date2 = new Date(''2013/11/04 10:10:10''); //less than 1 var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from.. var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from.. var daysDiff = end - start; // exact dates console.log(daysDiff); date2 = new Date(''2013/11/05 00:00:00''); //1 var start = Math.floor(date1.getTime() / (3600 * 24 * 1000)); //days as integer from.. var end = Math.floor(date2.getTime() / (3600 * 24 * 1000)); //days as integer from.. var daysDiff = end - start; // exact dates console.log(daysDiff);


Para calcular días entre 2 fechas determinadas, puede usar el siguiente código. Las fechas que utilizo aquí son el 1 de enero de 2016 y el 31 de diciembre de 2016

var day_start = new Date("Jan 01 2016"); var day_end = new Date("Dec 31 2016"); var total_days = (day_end - day_start) / (1000 * 60 * 60 * 24); document.getElementById("demo").innerHTML = Math.round(total_days);

<h3>DAYS BETWEEN GIVEN DATES</h3> <p id="demo"></p>


Puede que esta no sea la solución más elegante, pero parece responder la pregunta con un código de código relativamente simple, creo. ¿No puedes usar algo como esto?

function dayDiff(startdate, enddate) { var dayCount = 0; while(enddate >= startdate) { dayCount++; startdate.setDate(startdate.getDate() + 1); } return dayCount; }

Esto es asumiendo que usted está pasando objetos de fecha como parámetros.


Puede usar UnderscoreJS para formatear y calcular la diferencia.

Demostración https://jsfiddle.net/sumitridhal/8sv94msp/

var startDate = moment("2016-08-29T23:35:01"); var endDate = moment("2016-08-30T23:35:01"); console.log(startDate); console.log(endDate); var resultHours = endDate.diff(startDate, ''hours'', true); document.body.innerHTML = ""; document.body.appendChild(document.createTextNode(resultHours));

body { white-space: pre; font-family: monospace; }

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.5.1/moment.min.js"></script>


Recomiendo usar la biblioteca moment.js ( http://momentjs.com/docs/#/displaying/difference/ ). Maneja el horario de verano correctamente y, en general, es fantástico trabajar con él.

Ejemplo:

var start = moment("2013-11-03"); var end = moment("2013-11-04"); end.diff(start, "days") 1


Si quieres tener un DateArray con fechas prueba esto:

<script> function getDates(startDate, stopDate) { var dateArray = new Array(); var currentDate = moment(startDate); dateArray.push( moment(currentDate).format(''L'')); var stopDate = moment(stopDate); while (dateArray[dateArray.length -1] != stopDate._i) { dateArray.push( moment(currentDate).format(''L'')); currentDate = moment(currentDate).add(1, ''days''); } return dateArray; } </script>

DebugSnippet


Si tiene dos marcas de tiempo de Unix, puede usar esta función (hecha un poco más detallada para mayor claridad):

// Calculate number of days between two unix timestamps // ------------------------------------------------------------ var daysBetween = function(timeStampA, timeStampB) { var oneDay = 24 * 60 * 60 * 1000; // hours * minutes * seconds * milliseconds var firstDate = new Date(timeStampA * 1000); var secondDate = new Date(timeStampB * 1000); var diffDays = Math.round(Math.abs((firstDate.getTime() - secondDate.getTime())/(oneDay))); return diffDays; };

Ejemplo:

daysBetween(1096580303, 1308713220); // 2455


Solo obtuve dos marcas de tiempo en milisegundos, así que tengo que hacer algunos pasos adicionales con moment.js para obtener los días intermedios.

const getDaysDiff = (fromTimestamp, toTimestamp) => { // set timezone offset with utcOffset if needed let fromDate = moment(fromTimestamp).utcOffset(8); let toDate = moment(toTimestamp).utcOffset(8); // get the start moment of the day fromDate.set({''hour'':0, ''minute'': 0, ''second'': 0, ''millisecond'': 0}); toDate.set({''hour'':0, ''minute'': 0, ''second'': 0, ''millisecond'': 0}); let diffDays = toDate.diff(fromDate, ''days''); return diffDays; } getDaysDiff(1528889400000, 1528944180000)// 1


Tenga cuidado al utilizar milisegundos .

Date.getTime () devuelve milisegundos y hacer operaciones matemáticas con milisegundos requiere incluir

  • Horario de verano (DST)
  • comprobando si ambas fechas tienen la misma hora (horas, minutos, segundos, milisegundos)
  • asegúrese de que se requiere el comportamiento de la diferencia de días: 19 de septiembre de 2016 - 29 de septiembre de 2016 = 1 o 2 días de diferencia

El ejemplo del comentario anterior es la mejor solución que encontré hasta ahora https://.com/a/11252167/2091095 . Pero use +1 para su resultado si desea que cuente todos los días involucrados.

function treatAsUTC(date) { var result = new Date(date); result.setMinutes(result.getMinutes() - result.getTimezoneOffset()); return result; } function daysBetween(startDate, endDate) { var millisecondsPerDay = 24 * 60 * 60 * 1000; return (treatAsUTC(endDate) - treatAsUTC(startDate)) / millisecondsPerDay; } var diff = daysBetween($(''#first'').val(), $(''#second'').val()) + 1;


Tuve el mismo problema en Angular. Yo hago la copia porque de lo contrario él sobrescribirá la primera fecha. Ambas fechas deben tener hora 00:00:00 (obviamente)

/* * Deze functie gebruiken we om het aantal dagen te bereken van een booking. * */ $scope.berekenDagen = function () { $scope.booking.aantalDagen=0; /*De loper is gelijk aan de startdag van je reservatie. * De copy is nodig anders overschijft angular de booking.van. * */ var loper = angular.copy($scope.booking.van); /*Zolang de reservatie beschikbaar is, doorloop de weekdagen van je start tot einddatum.*/ while (loper < $scope.booking.tot) { /*Tel een dag op bij je loper.*/ loper.setDate(loper.getDate() + 1); $scope.booking.aantalDagen++; } /*Start datum telt natuurlijk ook mee*/ $scope.booking.aantalDagen++; $scope.infomsg +=" aantal dagen: "+$scope.booking.aantalDagen; };


Una mejor solución por

Ignorando parte del tiempo

devolverá 0 si ambas fechas son iguales.

function dayDiff(firstDate, secondDate) { firstDate = new Date(firstDate); secondDate = new Date(secondDate); if (!isNaN(firstDate) && !isNaN(secondDate)) { firstDate.setHours(0, 0, 0, 0); //ignore time part secondDate.setHours(0, 0, 0, 0); //ignore time part var dayDiff = secondDate - firstDate; dayDiff = dayDiff / 86400000; // divide by milisec in one day console.log(dayDiff); } else { console.log("Enter valid date."); } } $(document).ready(function() { $(''input[type=datetime]'').datepicker({ dateFormat: "mm/dd/yy", changeMonth: true, changeYear: true }); $("#button").click(function() { dayDiff($(''#first'').val(), $(''#second'').val()); }); });

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" href="//code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css"> <script src="//code.jquery.com/ui/1.12.1/jquery-ui.js"></script> <input type="datetime" id="first" value="12/28/2016" /> <input type="datetime" id="second" value="12/28/2017" /> <input type="button" id="button" value="Calculate">


Utilicé el siguiente código para experimentar la funcionalidad de la fecha de publicación de una publicación de noticias. Calculo el minuto o la hora o el día o el año según la fecha de publicación y la fecha actual.

var startDate= new Date("Mon Jan 01 2007 11:00:00"); var endDate =new Date("Tue Jan 02 2007 12:50:00"); var timeStart = startDate.getTime(); var timeEnd = endDate.getTime(); var yearStart = startDate.getFullYear(); var yearEnd = endDate.getFullYear(); if(yearStart == yearEnd) { var hourDiff = timeEnd - timeStart; var secDiff = hourDiff / 1000; var minDiff = hourDiff / 60 / 1000; var hDiff = hourDiff / 3600 / 1000; var myObj = {}; myObj.hours = Math.floor(hDiff); myObj.minutes = minDiff if(myObj.hours >= 24) { console.log(Math.floor(myObj.hours/24) + "day(s) ago") } else if(myObj.hours>0) { console.log(myObj.hours +"hour(s) ago") } else { console.log(Math.abs(myObj.minutes) +"minute(s) ago") } } else { var yearDiff = yearEnd - yearStart; console.log( yearDiff +" year(s) ago"); }


Utilizando Moment.js

var future = moment(''05/02/2015''); var start = moment(''04/23/2015''); var d = future.diff(start, ''days''); // 9 console.log(d);

<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.17.1/moment-with-locales.min.js"></script>


Versión Bookmarklet de otras respuestas, que le solicita ambas fechas:

javascript:(function() { var d = new Date(prompt("First Date or leave blank for today?") || Date.now()); prompt("Days Between", Math.round( Math.abs( (d.getTime() - new Date(prompt("Date 2")).getTime()) /(24*60*60*1000) ) )); })();


Date.prototype.days = function(to) { return Math.abs(Math.floor(to.getTime() / (3600 * 24 * 1000)) - Math.floor(this.getTime() / (3600 * 24 * 1000))) } console.log(new Date(''2014/05/20'').days(new Date(''2014/05/23''))); // 3 days console.log(new Date(''2014/05/23'').days(new Date(''2014/05/20''))); // 3 days


function timeDifference(date1, date2) { var oneDay = 24 * 60 * 60; // hours*minutes*seconds var oneHour = 60 * 60; // minutes*seconds var oneMinute = 60; // 60 seconds var firstDate = date1.getTime(); // convert to milliseconds var secondDate = date2.getTime(); // convert to milliseconds var seconds = Math.round(Math.abs(firstDate - secondDate) / 1000); //calculate the diffrence in seconds // the difference object var difference = { "days": 0, "hours": 0, "minutes": 0, "seconds": 0, } //calculate all the days and substract it from the total while (seconds >= oneDay) { difference.days++; seconds -= oneDay; } //calculate all the remaining hours then substract it from the total while (seconds >= oneHour) { difference.hours++; seconds -= oneHour; } //calculate all the remaining minutes then substract it from the total while (seconds >= oneMinute) { difference.minutes++; seconds -= oneMinute; } //the remaining seconds : difference.seconds = seconds; //return the difference object return difference; } console.log(timeDifference(new Date(2017,0,1,0,0,0),new Date()));


function validateDate() { // get dates from input fields var startDate = $("#startDate").val(); var endDate = $("#endDate").val(); var sdate = startDate.split("-"); var edate = endDate.split("-"); var diffd = (edate[2] - sdate[2]) + 1; var leap = [ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]; var nonleap = [ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 ]; if (sdate[0] > edate[0]) { alert("Please enter End Date Year greater than Start Date Year"); document.getElementById("endDate").value = ""; diffd = ""; } else if (sdate[1] > edate[1]) { alert("Please enter End Date month greater than Start Date month"); document.getElementById("endDate").value = ""; diffd = ""; } else if (sdate[2] > edate[2]) { alert("Please enter End Date greater than Start Date"); document.getElementById("endDate").value = ""; diffd = ""; } else { if (sdate[0] / 4 == 0) { while (sdate[1] < edate[1]) { diffd = diffd + leap[sdate[1]++]; } } else { while (sdate[1] < edate[1]) { diffd = diffd + nonleap[sdate[1]++]; } } document.getElementById("numberOfDays").value = diffd; } }


const startDate = ''2017-11-08''; const endDate = ''2017-10-01''; const timeDiff = (new Date(startDate)) - (new Date(endDate)); const days = timeDiff / (1000 * 60 * 60 * 24)

  1. Establecer fecha de inicio
  2. Fijar fecha de finalización
  3. Calcular diferencia
  4. Convertir milisegundos a días

function formatDate(seconds, dictionary) { var foo = new Date; var unixtime_ms = foo.getTime(); var unixtime = parseInt(unixtime_ms / 1000); var diff = unixtime - seconds; var display_date; if (diff <= 0) { display_date = dictionary.now; } else if (diff < 60) { if (diff == 1) { display_date = diff + '' '' + dictionary.second; } else { display_date = diff + '' '' + dictionary.seconds; } } else if (diff < 3540) { diff = Math.round(diff / 60); if (diff == 1) { display_date = diff + '' '' + dictionary.minute; } else { display_date = diff + '' '' + dictionary.minutes; } } else if (diff < 82800) { diff = Math.round(diff / 3600); if (diff == 1) { display_date = diff + '' '' + dictionary.hour; } else { display_date = diff + '' '' + dictionary.hours; } } else { diff = Math.round(diff / 86400); if (diff == 1) { display_date = diff + '' '' + dictionary.day; } else { display_date = diff + '' '' + dictionary.days; } } return display_date; }


var start= $("#firstDate").datepicker("getDate"); var end= $("#SecondDate").datepicker("getDate"); var days = (end- start) / (1000 * 60 * 60 * 24); alert(Math.round(days));

ejemplo de jsfiddle :)