JavaScript에서 두 날짜 사이의 일수는 어떻게 알 수 있습니까?

JavaScript에서 두 날짜 사이의 일수는 어떻게 알 수 있습니까? 예를 들어, 입력 상자에 두 개의 날짜가 주어지면 :

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

<script>
  alert(datediff("day", first, second)); // what goes here?
</script>

다음은 질문에 제시된대로 문제를 해결하기위한 개념 증명으로 빠르고 더러운 구현입니다 datediff. 그것은 두 날짜 사이의 경과 된 밀리 초를 빼서 얻을 수 있다는 사실에 의존합니다.이 숫자는 기본 숫자 값 (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"/>

이름에 "UTC"가없는 "일반"날짜 API는 사용자 브라우저의 현지 시간대에서 작동하므로 일반적으로 사용자가 아닌 시간대에 있으면 문제가 발생할 수 있습니다. 코드가 일광 절약 시간 전환을 처리해야합니다. Date 객체 및 해당 메서드에 대한 설명서를주의 깊게 읽어야하며,보다 복잡한 작업에 대해서는 날짜 조작에보다 안전하고 강력한 API를 제공하는 라이브러리를 사용하는 것이 좋습니다.

• 숫자와 날짜-MDN JavaScript 안내서
• Date -MDN JavaScript 참조

_{또한, 설명을 위해 스 니펫은 간결성 을 위해 window오브젝트 에서 이름 지정된 액세스를 사용 하지만 프로덕션에서는 getElementById 와 같은 표준화 된 API 또는 일부 UI 프레임 워크 를 사용해야합니다 .}

이 글을 쓰는 시점에서 다른 답변 중 하나만 DST (일광 절약 시간) 전환을 올바르게 처리합니다. 캘리포니아에 위치한 시스템의 결과는 다음과 같습니다.

                                        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

Math.round올바른 결과를 반환 하지만 다소 복잡하다고 생각합니다. 대신 DST가 시작되거나 종료 될 때 UTC 오프셋에 대한 변경 사항을 명시 적으로 설명함으로써 정확한 산술을 사용할 수 있습니다.

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

설명

Date객체가 현지 시간이 아닌 UTC로 내부적으로 시간을 저장 하기 때문에 JavaScript 날짜 계산이 까다 롭습니다 . 예를 들어, 2013 년 3 월 10 일 12:00 AM 태평양 표준시 (UTC-08 : 00)는 2013 년 3 월 10 일 오전 8시 (UTC) 오전 3/11/2013 12:00 오전 태평양 표준시 일광 절약 시간 ( UTC-07 : 00)은 2013 년 3 월 11 일 7:00 AM UTC로 저장됩니다. 이 날 자정부터 자정까지의 현지 시간은 UTC로 23 시간입니다.

현지 시간으로 하루를 24 시간 이상 가질 수 있지만 UTC로 하루는 항상 정확히 24 시간입니다. ¹daysBetween 위 의 방법은 treatAsUTC빼고 나누기 전에 먼저 현지 시간을 UTC 자정으로 조정하도록 호출하여이 사실 을 이용합니다.

^{1. JavaScript는 윤초를 무시합니다.}

두 날짜의 차이를 얻는 가장 쉬운 방법은 다음과 같습니다.

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

차이 일을 얻습니다 (또는 하나 또는 둘 다 구문 분석 할 수없는 경우 NaN). 구문 분석 날짜는 밀리 초 단위로 결과를 제공했으며 하루 단위로 결과를 24 * 60 * 60 * 1000으로 나누어야합니다.

일, 시간, 분, 초 및 밀리 초로 나누려면 다음을 수행하십시오.

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

제임스 버전의 리팩토링 된 버전은 다음과 같습니다.

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

moment.js 라이브러리 ( http://momentjs.com/docs/#/displaying/difference/ )를 사용하는 것이 좋습니다 . 일광 절약 시간을 정확하게 처리하며 일반적으로 작업하기에 좋습니다.

예:

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

계속해서이 작은 유틸리티 를 가져 오면이 기능을 찾을 수 있습니다. 다음은 간단한 예입니다.

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

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. 시작일 설정
2. 종료일 설정
3. 차이 계산
4. 밀리 초를 일로 변환

업데이트 : 이것이 귀하의 질문의 일부는 아니라는 것을 알고 있지만 일반적으로 바닐라 JavaScript에서 날짜 계산이나 조작을 수행하지 말고 date-fns 또는 moment.js 와 같은 라이브러리를 사용하는 것이 좋습니다 .

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>

JS의 날짜 값은 날짜 시간 값입니다.

따라서 직접 날짜 계산이 일치하지 않습니다.

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

예를 들어 두 번째 날짜를 변환해야합니다.

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

이 방법은 두 날짜 모두에서 밀을자를 수 있습니다.

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

UTC 시간을 사용하여 DST, Math.ceil, Math.floor 등을 제거하는 것이 좋습니다.

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

이 예는 차이가 109 일입니다. 24*60*60*1000밀리 초 단위의 하루입니다.

주어진 두 날짜 사이의 날짜를 계산하려면 다음 코드를 사용할 수 있습니다. 여기에서 사용하는 날짜는 2016 년 1 월 1 일과 2016 년 12 월 31 일입니다.

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>

다음 공식을 사용하여 다른 TZ에서 휴식하는 두 날짜 사이의 완전한 증거 일 차이를 계산할 수 있습니다.

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

두 날짜에 계산을 원할 때이 질문을 찾았지만 날짜에는 시간과 분 값이 있으며 요구 사항에 맞게 @ michael-liu의 답변을 수정했으며 테스트를 통과했습니다.

DIFF 일 2012-12-31 23:00및 2013-01-01 01:001 (2시간) DIFF 일 같아야 2012-12-31 01:00하고 2013-01-01 23:001 (46시간)를 같아야

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

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

jsfiddle 예제 :)

나는 솔루션은 내가 사용하는 것이 100 % 정확하지 생각 CEIL 대신 바닥 , 라운드 의지 작업을하지만 올바른 작동하지 않습니다.

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

DatePicker 위젯에서 formatDate 를 사용하는 것은 어떻습니까? 이를 사용하여 날짜를 타임 스탬프 형식 (01/01/1970 이후 밀리 초)으로 변환 한 다음 간단한 빼기를 수행 할 수 있습니다.

이것은 가장 우아한 해결책은 아니지만 비교적 간단한 코드로 질문에 대답하는 것 같습니다. 다음과 같은 것을 사용할 수 없습니다 :

function dayDiff(startdate, enddate) {
  var dayCount = 0;

  while(enddate >= startdate) {
    dayCount++;
    startdate.setDate(startdate.getDate() + 1);
  }

return dayCount; 
}

이것은 날짜 객체를 매개 변수로 전달한다고 가정합니다.

유닉스 타임 스탬프가 두 개인 경우이 기능을 사용할 수 있습니다 (명확성을 위해 조금 더 자세하게 표시).

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

예:

daysBetween(1096580303, 1308713220); // 2455

밀리 초를 사용할 때주의하십시오 .

date.getTime는 () (밀리 초)을 반환하고 일을 밀리 초 단위로 수학 연산은 포함 할 필요

• 일광 절약 시간제 (DST)
• 두 날짜가 같은 시간인지 확인 (시간, 분, 초, 밀리 초)
• diff가 필요한 일의 행동을 확인하십시오 : 2016 년 9 월 19 일-2016 년 9 월 29 일 = 1 일 또는 2 일 차이?

위의 의견의 예는 지금까지 https://stackoverflow.com/a/11252167/2091095 에서 찾은 최고의 솔루션 입니다. 그러나 모든 요일을 계산하려면 결과에 +1 을 사용하십시오 .

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;

Angular에서도 같은 문제가있었습니다. 다른 사람이 첫 번째 날짜를 덮어 쓰므로 사본을 작성합니다. 두 날짜 모두 시간이 00:00:00이어야합니다 (분명히)

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

아래 코드를 사용하여 뉴스 게시물의 게시 날짜 기능을 실험했습니다. 게시 날짜와 현재 날짜를 기준으로 분, 시간 또는 일 또는 연도를 계산합니다.

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

날짜가있는 DateArray를 원하면 다음을 시도하십시오.

<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

두 날짜 사이의 날짜를 계산하는 간단한 방법은 시간 구성 요소, 즉시, 분, 초 및 밀리 초를 0으로 설정 한 다음 시간을 빼고 하루의 밀리 초로 다이빙하는 것입니다.

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

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

간단하고 정교합니다. 이 기능은 업데이트 시간을 위해 1 초마다 호출됩니다.

const year = (new Date().getFullYear());
const bdayDate = new Date("04,11,2019").getTime();  //mmddyyyy

// countdown
let timer = setInterval(function() {

// get today's date
const today = new Date().getTime();

// get the difference
const diff = bdayDate - today;

// math
let days = Math.floor(diff / (1000 * 60 * 60 * 24));
let hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
let minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
let seconds = Math.floor((diff % (1000 * 60)) / 1000);

}, 1000);

더 나은 솔루션

시간 부분 무시

두 날짜가 모두 같은 경우 0을 반환합니다.

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

1970-01-01 이전 및 2038-01-19 이후 날짜의 기여

function DateDiff(aDate1, aDate2) {
  let dDay = 0;
  this.isBissexto = (aYear) => {
    return (aYear % 4 == 0 && aYear % 100 != 0) || (aYear % 400 == 0);
  };
  this.getDayOfYear = (aDate) => {
    let count = 0;
    for (let m = 0; m < aDate.getUTCMonth(); m++) {
      count += m == 1 ? this.isBissexto(aDate.getUTCFullYear()) ? 29 : 28 : /(3|5|8|10)/.test(m) ? 30 : 31;
    }
    count += aDate.getUTCDate();
    return count;
  };
  this.toDays = () => {
    return dDay;
  };
  (() => {
    let startDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate1.toISOString()) : new Date(aDate2.toISOString());
    let endDate = aDate1.getTime() <= aDate2.getTime() ? new Date(aDate2.toISOString()) : new Date(aDate1.toISOString());
    while (startDate.getUTCFullYear() != endDate.getUTCFullYear()) {
      dDay += (this.isBissexto(startDate.getFullYear())? 366 : 365) - this.getDayOfYear(startDate) + 1;
      startDate = new Date(startDate.getUTCFullYear()+1, 0, 1);
    }
    dDay += this.getDayOfYear(endDate) - this.getDayOfYear(startDate);
  })();
}

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

UnderscoreJS를 사용하여 차이를 형식화하고 계산할 수 있습니다.

데모 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>