Days between dates: Difference between revisions

To demonstrate one of the numerous ways this can be done.

<br><br>

 

=={{header|Ada}}==

with Ada.Text_IO;

with Ada.Integer_Text_IO;

Put_Days_Between ("2090-01-01", "2098-12-25", "Future");

Put_Days_Between ("1902-01-01", "2098-12-25", "Long span");

 

{{out}}

Days between 2090-01-01 and 2098-12-25 is 3280 days -- Future

Days between 1902-01-01 and 2098-12-25 is 71947 days -- Long span</pre>

 

=={{header|AppleScript}}==

 

considering numeric strings -- Allows for leading zeros having been omitted.

if (date1 = date2) then return date1 & " and " & date2 & " are the same date"

return daysBetweenDates("2020-04-11", "2001-01-01") & linefeed & ¬

daysBetweenDates("2020-04-11", "2020-04-12") & linefeed & ¬

 

{{output}}

Or, composing a function from reusable generics, and drawing on NSISO8601DateFormatter:

 

use framework "Foundation"

use scripting additions

set my text item delimiters to dlm

str

{{Out}}

<pre>2020-04-11 -> 2001-01-01 -> -7040 days

{{trans|Ruby}}

 

a: to :date.format: "dd/MM/yyyy" startDate

b: to :date.format: "dd/MM/yyyy" endDate

"days between the two dates:"

daysBetweenDates "01/01/2019" "19/10/2019"

 

{{out}}

 

<pre>days between the two dates: 291</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f DAYS_BETWEEN_DATES.AWK

BEGIN {

return(result)

}

{{out}}

<pre>

 

=={{header|C}}==

#include<stdbool.h>

#include<string.h>

return 0;

}

Output :

<pre>

Days Difference : 335

</pre>

 

=={{header|C++}}==

{{trans|c}}

#include <iostream>

 

 

return 0;

{{out}}

<pre>Days difference : 335</pre>

===Alternative using Boost===

{{libheader|Boost}}

#include <iostream>

#include <boost/date_time/gregorian/gregorian.hpp>

}

return EXIT_SUCCESS;

 

{{out}}

</pre>

 

using System.Globalization;

 

return (int)(b - a).TotalDays;

}

{{out}}

<pre>

{{works with|GnuCOBOL}}

 

*> Tectonics: cobc -xj days-between.cob

 

 

goback.

 

{{out}}

07267

07267</pre>

 

=={{header|D}}==

import std.stdio;

 

auto diff = toDate - fromDate;

writeln("Number of days between ", fromDate, " and ", toDate, ": ", diff.total!"days");

{{out}}

<pre>Number of days between 2019-Jan-01 and 2019-Oct-07: 279</pre>

{{libheader| System.SysUtils}}

{{Trans|C#}}

program Days_between_dates;

 

Writeln(DaysBetween('1970-01-01', '2019-10-18'));

readln;

{{out}}

<pre>18187</pre>

=={{header|Erlang}}==

 

-module(daysbetween).

 

{{out}}

erlang shell:

 

=={{header|F_Sharp|F#}}==

// Days between dates: Nigel Galloway. June 3rd., 2021

let n,g=System.DateTime.Parse("1792-9-22"),System.DateTime.Parse("1805-12-31")

printfn "There are %d days between %d-%d-%d and %d-%d-%d" (g-n).Days n.Year n.Month n.Day g.Year g.Month g.Day

{{out}}

<pre>

=={{header|Factor}}==

Factor supports the addition and subtraction of timestamps and durations with the <code>time+</code> and <code>time-</code> words.

 

: days-between ( ymd-str ymd-str -- n )

 

"2019-01-01" "2019-09-30" days-between .

{{out}}

<pre>

272

273

</pre>

 

See Frink's [https://frinklang.org/#DateTimeHandling Date/Time Handling] documentation to see how easy it is to work with dates, times, timezones, calendrical systems, and even leap seconds correctly and easily.

 

d2 = # 2020-12-06 #

 

{{out}}

</pre>

 

 

 

=={{header|Go}}==

 

import (

days = daysBetween(date1, date2)

fmt.Printf("There are %d days between %s and %s\n", days, date1, date2)

 

{{out}}

=={{header|Groovy}}==

{{trans|Kotlin}} {{trans|Java}}

 

def fromDate = LocalDate.parse("2019-01-01")

def toDate = LocalDate.parse("2019-10-19")

def diff = fromDate - toDate

{{out}}

<pre>Number of days between 2019-01-01 and 2019-10-19: 291</pre>

 

=={{header|Haskell}}==

import Data.Time.Calendar (diffDays)

import Data.Time.Format (parseTimeM,defaultTimeLocale)

 

stringToDay :: String -> Maybe Day

{{out}}

 

=={{header|J}}==

=={{header|Java}}==

{{trans|Kotlin}}

import java.time.temporal.ChronoUnit;

 

System.out.printf("Number of days between %s and %s: %d\n", fromDate, toDate, diff);

}

{{out}}

<pre>Number of days between 2019-01-01 and 2019-10-19: 291</pre>

 

=={{header|Julia}}==

 

@show Day(DateTime("2019-09-30") - DateTime("2019-01-01"))

@show Day(DateTime("2029-03-29") - DateTime("2019-03-29"))

<pre>

Day(DateTime("2019-09-30") - DateTime("2019-01-01")) = 272 days

 

=={{header|Kotlin}}==

import java.time.temporal.ChronoUnit

 

val diff = ChronoUnit.DAYS.between(fromDate, toDate)

println("Number of days between $fromDate and $toDate: $diff")

{{out}}

<pre>Number of days between 2019-01-01 and 2019-10-19: 291</pre>

=={{header|Lua}}==

This uses os.difftime to compare two Epoch times. Not to be used with dates before 1970.

 

-- Convert date string as YYYY-MM-DD to Epoch time.

local d2 = parseDate(io.read())

local diff = math.ceil(os.difftime(d2, d1) / SECONDS_IN_A_DAY)

{{out}}

<pre>Enter date 1: 1970-01-01

Enter date 2: 2019-10-02

There are 18171 days between these dates.</pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

<pre>Quantity[60, "Days"]

 

=={{header|Nim}}==

 

proc daysBetween(date1, date2: string): int64 =

 

for (date1, date2) in Dates:

 

{{out}}

Days between 1902-01-01 and 1968-12-25: 24465

Days between 2090-01-01 and 2098-12-25: 3280</pre>

 

=={{header|Perl}}==

Would not reinvent this wheel.

use Date::Calc qw(Delta_Days);

 

say Delta_Days(2000,1,1, 2100,1,1); # another, with one extra leap day

say Delta_Days(2020,1,1, 2019,10,1); # backwards in time

{{out}}

<pre>427

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins<span style="color: #0000FF;">\<span style="color: #004080;">timedate<span style="color: #0000FF;">.<span style="color: #000000;">e</span>

<span style="color: #000080;font-style:italic;">-- specify as many or as few permitted formats as you like:</span>

<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"1970-01-01"<span style="color: #0000FF;">,</span> <span style="color: #008000;">"2019/10/18"<span style="color: #0000FF;">)</span>

<span style="color: #000000;">test<span style="color: #0000FF;">(<span style="color: #008000;">"1970-01-01"<span style="color: #0000FF;">,</span> <span style="color: #008000;">"18/10/2019"<span style="color: #0000FF;">)

As shown, timedate_diff() can optionally round to the nearest whole number of days [else omit DT_DAY].<br>

Note that elapsed() assumes all years are exactly 365 days, and in no way takes leap years into consideration

 

=={{header|PicoLisp}}==

(abs (- ($dat A "-") ($dat B "-"))) )

(println (diffDates "2019-1-1" "2019-9-30"))

{{out}}

<pre>

</pre>

 

 

=={{header|Python}}==

 

#!/usr/bin/python

two = sys.argv[2]

print diff(one,two)

 

{{out}}

272

</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

Dates are first class objects in Raku and may have arithmetic in days done directly on them.

 

say Date.new('2019-03-01') - Date.new('2019-02-01');

say Date.new('2019-02-29') + 30;

 

 

<pre>272

<br>days since the beginning of the Gregorian calendar, &nbsp; and &nbsp; '''I''' &nbsp; which is the option that indicates the date is in

<br>the &nbsp; '''ISO''' &nbsp; (International Standards Organization standard 8601:2004) &nbsp; format.

parse arg $1 $2 . /*get 2 arguments (dates) from the C.L.*/

say abs( date('B',$1,"I") - date('B',$2,"I") ) ' days between ' $1 " and " $2

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> 2019-10-02 &nbsp; 2000-01-01 </tt>}}

<pre>

 

Also, more informative error messages are generated.

parse arg $.1 $.2 _ . 1 . . xtra /*obtain two arguments from the C.L. */

seps= '/-\'; yr.= .; mon.= .; dd.= . /*define the defaults for both dates. */

if length(yr.a)==2 then yr.a= left( date('S'), 2)yr.a /*2 dig yy ?*/

if yr.a==. | mon.a==. | dd.a==. then call serDAT /*validate. */

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> * &nbsp; 2000-1-1 </tt>}}

 

 

=={{header|Ring}}==

load "stdlib.ring"

 

? "Days between " + DaysBetween[n][1] + " and " + DaysBetween[n][2] + ": " + diffdays(date4,date3)

next

{{out}}

<pre>

Days between 1902-01-01 and 1968-12-25: 0

Days between 2090-01-01 and 2098-12-25: 3280

</pre>

 

=={{header|Ruby}}==

 

d1, d2 = Date.parse("2019-1-1"), Date.parse("2019-10-19")

p (d1 - d2).to_i # => -291

p (d2 - d1).to_i # => 291

 

=={{header|Rust}}==

// chrono = "0.4"

 

std::process::exit(1);

}

 

{{out}}

days_between_dates 2020-01-01 2020-09-06

249

</pre>

 

=={{header|Scala}}==

 

/*Inspired by the Python version of the algorithm and the discussion here

 

}

{{out}}

<pre>

3280

71947

</pre>

 

=={{header|Sidef}}==

 

func days_diff(a,b) {

var days = days_diff(date1, date2)

 

{{out}}

<pre>

=={{header|Swift}}==

 

 

func daysFromTimeInterval(_ interval: Double) -> Int {

let days = daysFromTimeInterval(DateInterval(start: start, end: end).duration)

 

 

{{out}}

{{works with|Bourne Again Shell}}

 

leap() {

local -i year

 

days_between 1970-01-01 2019-12-04

 

{{Out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Module Module1

End Sub

 

{{out}}

<pre>18187</pre>

 

=={{header|Wren}}==

{{libheader|Wren-date}}

 

var datePairs = [

["2020-02-29", "2020-03-01"]

]

for (dates in datePairs) {

var date1 = Date.parse(dates[0])

var date2 = Date.parse(dates[1])

var days = (date2 - date1).days

System.print("Days between %(date1) and %(date2) = %(days)")

 

{{out}}

Days between 2019-03-29 and 2029-03-29 = 3653

Days between 2020-02-29 and 2020-03-01 = 1

</pre>

 

=={{header|zkl}}==

today:=TD.parseDate("--"); // "yyyy-mm-dd" and variations --> (y,m,d)

// or Time.Clock.UTC --> (y,m,d,h,m,s)

TD.toYMDString(today.xplode()), // to(y,m,d) not to((y,m,d))

TD.toYMDString(then.xplode()),

{{out}}

<pre>