Date Difference Calculator

function getDateDiff(d1, d2, isInclusive = false) {
  const start = new Date(d1);
  const end = new Date(d2);
  const diffTime = Math.abs(end - start);
  let diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
  if (isInclusive) diffDays += 1;
  return diffDays;
}

from datetime import datetime

def get_date_diff(start_str, end_str, inclusive=False):
    d1 = datetime.strptime(start_str, '%Y-%m-%d')
    d2 = datetime.strptime(end_str, '%Y-%m-%d')
    delta = abs((d2 - d1).days)
    return delta + 1 if inclusive else delta

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public static long getDaysBetween(LocalDate d1, LocalDate d2, boolean inclusive) {
    long days = ChronoUnit.DAYS.between(d1, d2);
    return inclusive ? Math.abs(days) + 1 : Math.abs(days);
}

package main
import "time"

func GetDaysBetween(t1, t2 time.Time, inclusive bool) int {
    diff := t2.Sub(t1)
    days := int(diff.Hours() / 24)
    if inclusive {
        return days + 1
    }
    return days
}

#include <ctime>
#include <cmath>

double get_days_between(time_t t1, time_t t2, bool inclusive) {
    double seconds = difftime(t2, t1);
    double days = std::abs(seconds) / (60 * 60 * 24);
    return inclusive ? days + 1 : days;
}

use chrono::{NaiveDate};

fn get_days_between(d1: NaiveDate, d2: NaiveDate, inclusive: bool) -> i64 {
    let days = (d2 - d1).num_days().abs();
    if inclusive { days + 1 } else { days }
}

using System;

public static int GetDaysBetween(DateTime d1, DateTime d2, bool inclusive) {
    int days = Math.Abs((d2 - d1).Days);
    return inclusive ? days + 1 : days;
}

function getDaysBetween($d1, $d2, $inclusive = false) {
    $date1 = new DateTime($d1);
    $date2 = new DateTime($d2);
    $days = $date1->diff($date2)->days;
    return $inclusive ? $days + 1 : $days;
}

import Foundation

func getDaysBetween(d1: Date, d2: Date, inclusive: Bool) -> Int {
    let days = Calendar.current.dateComponents([.day], from: d1, to: d2).day ?? 0
    return inclusive ? abs(days) + 1 : abs(days)
}

import java.time.LocalDate
import java.time.temporal.ChronoUnit

fun getDaysBetween(d1: LocalDate, d2: LocalDate, inclusive: Boolean): Long {
    val days = ChronoUnit.DAYS.between(d1, d2)
    return if (inclusive) Math.abs(days) + 1 else Math.abs(days)
}