JavaScript'te iki tarih arasındaki gün sayısını nasıl alabilirim?

JavaScript'te iki tarih arasındaki gün sayısını nasıl alabilirim? Örneğin, giriş kutularında iki tarih verildi:

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

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

İşte sorunun hızlı ve kirli bir şekilde uygulanması datediff, sorunun soru olarak sunulduğu gibi bir kavram kanıtı olarak. Bu iki tarih arasında geçen milisaniye onları çıkararak elde edebilirsiniz, bu onları ilkel sayı değerlerine (1970 başından beri milisaniye) zorlar.

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

"Normal" Tarih API'larının (adında "UTC" olmadan) kullanıcının tarayıcısının yerel saat diliminde çalıştığının farkında olmalısınız. Bu nedenle, genel olarak, kullanıcınız kullanmadığınız bir saat dilimindeyse sorunlarla karşılaşabilirsiniz. bekliyoruz ve kodunuz Yaz Saati Uygulaması geçişleri ile uğraşmak zorunda kalacaktır. Date nesnesinin ve yöntemlerinin belgelerini dikkatlice okumalısınız ve daha karmaşık her şey için, tarih manipülasyonu için daha güvenli ve güçlü API'ler sunan bir kitaplık kullanmayı kesinlikle düşünün.

• Sayılar ve Tarihler - MDN JavaScript Rehberi
• Date - MDN JavaScript referansı

_{Ayrıca, gösterim amacıyla, snippet , windownesne için kısaltma için adlandırılmış erişim kullanır , ancak üretimde getElementById veya daha büyük olasılıkla bazı UI çerçevesi gibi standart API'ler kullanmanız gerekir .}

Bu yazı itibariyle, diğer yanıtlardan sadece biri DST (gün ışığından yararlanma saati) geçişlerini doğru şekilde işler. California'da bulunan bir sistemde sonuçlar:

                                        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.roundDoğru sonuçları döndürmesine rağmen , bunun biraz tıknaz olduğunu düşünüyorum. Bunun yerine, DST başladığında veya bittiğinde UTC ofsetindeki değişiklikleri açıkça hesaplayarak kesin aritmetiği kullanabiliriz:

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

açıklama

JavaScript tarih hesaplamaları zordur çünkü Datenesneler zamanları yerel saatle değil dahili olarak UTC'de depolar. Örneğin, 3/10/2013 12:00 AM Pasifik Standart Saati (UTC-08: 00) 3/10/2013 8:00 AM UTC ve 3/11/2013 12:00 AM Pasifik Yaz Saati ( UTC-07: 00) 11.03.2013 07:00 UTC olarak saklanır. Bu gün, gece yarısından gece yarısına kadar yerel saat UTC'de sadece 23 saattir!

Yerel saatteki bir günün 24 saatten fazla veya daha az olmasına rağmen, UTC'de bir gün her zaman tam olarak 24 saattir. ¹daysBetween Yukarıda gösterilen metot, birinci arama bu gerçeğinden yararlanır treatAsUTCçıkarılarak ve bölünmeden önce, gece UTC'ye hem yerel zamanları ayarlamak üzere.

^{1. JavaScript artık saniyeleri yok sayar.}

İki tarih arasındaki farkı elde etmenin en kolay yolu:

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

Fark günlerini alırsınız (veya biri veya her ikisi de ayrıştırılamadıysa NaN). Ayrıştırma tarihi sonucu milisaniye cinsinden verdi ve güne almak için 24 * 60 * 60 * 1000'e bölmelisiniz.

Gün, saat, dakika, saniye ve milisaniyeye bölünmesini istiyorsanız:

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

İşte benim James sürümü benim refactored sürümü:

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 kütüphanesini kullanmanızı öneririm ( http://momentjs.com/docs/#/displaying/difference/ ). Yaz saatini doğru bir şekilde işler ve genel olarak çalışmak harikadır.

Misal:

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

Devam edip bu küçük yardımcı programı kaparım ve içinde sizin için işlevler bulacaksınız. Kısa bir örnek:

        <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. Başlangıç ​​tarihini ayarla
2. Bitiş tarihini ayarla
3. Farkı hesapla
4. Milisaniyeyi güne çevir

Güncelleme: Bunun sorularınızın bir parçası olmadığını biliyorum, ancak genel olarak vanilya JavaScript'te herhangi bir tarih hesaplaması veya manipülasyonu yapmanızı ve birçok kenar durumu nedeniyle date-fns veya moment.js gibi bir kütüphane kullanmanızı önermem .

Moment.js kullanma

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'deki tarih değerleri datetime değerleridir.

Dolayısıyla, doğrudan tarih hesaplamaları tutarsızdır:

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

örneğin 2. tarihi de dönüştürmeliyiz:

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

yöntem değirmenleri her iki tarihte de kısaltabilir:

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 saatlerini kullanarak DST, Math.ceil, Math.floor vb.

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

Bu örnek 109 gün fark vermektedir. 24*60*60*1000milisaniye cinsinden bir gündür.

Verilen 2 tarih arasındaki günleri hesaplamak için aşağıdaki kodu kullanabilirsiniz. Burada kullandığım tarihler 01 Ocak 2016 ve 31 Aralık 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>

Aşağıdaki formülü kullanarak farklı TZ'ler arasında kalan iki tarih arasındaki tam kanıt günü farkını hesaplamak mümkündür:

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

İki tarihte bazı hesaplamalar yapmak istediğimde bu soruyu buldum, ancak tarihin saat ve dakika değeri var, @ michael-liu'nun cevabını ihtiyacıma uyacak şekilde değiştirdim ve testimi geçti.

fark gün 2012-12-31 23:00ve 2013-01-01 01:001 eşit olmalıdır. (2 saat) fark gün 2012-12-31 01:00ve 2013-01-01 23:001 eşit olmalıdır (46 saat)

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 örneği :)

Ben çözümler ben kullanırım% 100 doğru olmadığını düşünmeye hücrelerinin, yerine zemin , yuvarlak irade işi ama doğru bir işlem değildir.

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 widget'ından formatDate'i kullanmaya ne dersiniz ? Tarihleri ​​zaman damgası biçiminde (01/01/1970'ten bu yana milisaniye) dönüştürmek ve sonra basit bir çıkarma yapmak için kullanabilirsiniz.

Bu en şık çözüm olmayabilir, ancak soruyu nispeten basit bir kod parçasıyla cevaplamak gibi görünüyor. Böyle bir şey kullanamaz mısın:

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

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

return dayCount; 
}

Bu, tarih nesnelerini parametre olarak geçirdiğinizi varsayar.

İki unix zaman damganız varsa, bu işlevi kullanabilirsiniz (netlik için biraz daha ayrıntılı hale getirin):

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

Misal:

daysBetween(1096580303, 1308713220); // 2455

Milisaniye kullanırken dikkatli olun .

Date.getTime () milisaniye döner ve yapıyor milisaniye ile matematik işlemi dahil etmek gerekir

• Yaz Saati Uygulaması (DST)
• her iki tarihin de aynı saatte olup olmadığını kontrol etme (saat, dakika, saniye, milisaniye)
• günlerin hangi davranışının farklı olduğundan emin olun: 19 Eylül 2016 - 29 Eylül 2016 = 1 veya 2 gün fark?

Yukarıdaki yorumdan örnek şu ana kadar bulduğum en iyi çözümdür: https://stackoverflow.com/a/11252167/2091095 . Ancak , tüm günleri saymak istiyorsanız sonucuna +1 kullanın.

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;

Aynı sorunu Angular'da da yaşadım. Kopyayı yapıyorum çünkü başka ilk tarihin üzerine yazacak. Her iki tarihin de saati 00:00:00 olmalıdır (belli ki)

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

Aşağıdaki kodu bir haber gönderisi için gönderme tarihi işlevini denemek için kullandım.

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

tarih içeren bir DateArray almak istiyorsanız şunu deneyin:

<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

İki tarih arasındaki günleri hesaplamanın basit yolu, saat bileşenlerini, yani saatleri, dakikaları, saniyeleri ve milisaniyeleri 0'a ayarlamak ve sonra zamanlarını çıkarmak ve milisaniye değerinde bir günlük dalış yapmaktır.

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

Basit kolay ve sofistike. Bu işlev, zamanı güncellemek için her 1 saniyede bir çağrılır.

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

Daha İyi Bir Çözüm

Zaman bölümünü göz ardı etme

her iki tarih de aynıysa 0 değerini döndürür.

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 öncesi ve 2038-01-19 sonrası tarih için katkı

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

Farkı biçimlendirmek ve hesaplamak için UnderscoreJS'yi kullanabilirsiniz.

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