Days between dates: Difference between revisions

 

=={{header|11l}}==

R time:strptime(date, ‘%Y-%m-%d’)

 

V date1 = parse_date(‘2019-01-01’)

V date2 = parse_date(‘2019-09-30’)

 

{{out}}

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

TYPE Date=[CARD year BYTE month,day]

Test("2090-01-01","2098-12-25")

Test("1902-01-01","2098-12-25")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Days_between_dates.png Screenshot from Atari 8-bit computer]

 

=={{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}}

=={{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}}

 

=={{header|AutoHotkey}}==

(

1995-11-21|1995-11-21

EnvSub, D2, % D1, days

return D2

{{out}}

<pre>Days between 1995-11-21 and 1995-11-21 : 0 Day(s)

 

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

The <code>date</code> namespace is taken from bqn-libs. <code>DBw</code> is the final function which calculates the proper difference between two date strings.

 

date ← {

o ← 719469

 

S2D←ToI¨ '-'⊸Split

<pre> "2019-09-30" DBw "2019-01-01"

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

 

=={{header|C sharp|C#}}==

using System.Globalization;

 

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

}

{{out}}

<pre>

{{works with|GnuCOBOL}}

 

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

 

 

goback.

 

{{out}}

 

=={{header|Commodore BASIC}}==

100 REM ===============================

110 REM DAYS BETWEEN 2 DATES

9080 G=G+INT((N*306+5)/10)+(D-1)

9090 RETURN

 

 

 

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

 

=={{header|FreeBASIC}}==

Dim As Integer Y1, M1, D1, Y2, M2, D2, G1, G2

Dim As String DaysBetween(7, 2) = {{"1902-01-01","1968-12-25"}, _

Print Using "##### days"; (G2-G1)

Next n

{{out}}

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

 

=={{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}}

<pre>There are 272 days between 2019-01-01 and 2019-09-30.

Or, composing rather than raising errors:

 

import Data.Time.Calendar (diffDays)

import Data.Time.Format (defaultTimeLocale, parseTimeM)

]

)

{{Out}}

<pre>There are 272 days between 2019-01-01 and 2019-09-30.

=={{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|JavaScript}}==

var floor = Math.floor, abs = Math.abs;

var daysBetween = (d1, d2) => floor(abs(new Date(d1) - new Date(d2)) / timeRatio);

 

{{out}}

<pre>Days between 2021-10-27 and 2020-03-03: 603</pre>

 

===Using jq's built-ins===

def days_between(yyyymmddBefore; yyyymmddAfter):

(yyyymmddBefore | strptime("%Y-%m-%d") | mktime) as $before

 

task

{{out}}

<pre>

===From first principles===

'''Adapted from [[#Wren|Wren]]'''

# In general, dates should be valid Julian dates on or after Jan 1, 0001, but

# for the most part, this is not checked, in part because some

| (date | toa) as $date

| days_between($date[0]; $date[1]; $date[2]; $later[0]; $later[1]; $later[2]);

'''The Tasks'''

 

 

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

 

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

{{out}}

<pre>Quantity[60, "Days"]

 

=={{header|Nim}}==

 

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

 

for (date1, date2) in Dates:

 

{{out}}

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

 

=={{header|Python}}==

 

#!/usr/bin/python

two = sys.argv[2]

print diff(one,two)

 

{{out}}

 

=={{header|QB64}}==

'Task

'Calculate the number of days between two dates.

 

 

 

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

 

=={{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}}

 

=={{header|Scala}}==

 

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

 

}

{{out}}

<pre>

=={{header|SenseTalk}}==

SenseTalk supports date and time calculations in many forms, and many different units of time (such as 'days' in this example). Rounding is needed due to daylight savings time changes.

set endDate to "2021-07-14"

 

put (endDate - startDate) rounded to nearest day

{{out}}

<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|Vlang}}==

{{trans|go}}

 

fn days_between(d1 string, d2 string) ?int {

days = days_between(date1, date2)?

println("There are $days days between $date1 and $date2")

{{out}}

<pre>

=={{header|Wren}}==

{{libheader|Wren-date}}

 

var datePairs = [

Date.default = Date.isoDate

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

 

{{out}}

 

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