horas - obtener fecha y hora actual javascript

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

Question

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

Answer 1

¿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.

Answer 2

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. ¹ 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.}

Answer 3

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.

• Números y fechas - Guía de JavaScript MDN
• Date - Referencia de JavaScript MDN

_{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.}

Answer 4

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>

Answer 5

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

Answer 6

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

Answer 7

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.

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

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

Answer 12

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>

Answer 13

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.

Answer 14

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>

Answer 15

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

Answer 16

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

Answer 17

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

Answer 18

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

Answer 19

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;

Answer 20

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

Answer 21

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

Answer 22

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

Answer 23

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>

Answer 24

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

Answer 25

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

Answer 26

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

Answer 27

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

Answer 28

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

Answer 29

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

Answer 30

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