如何计算两个日期之间的天数

package main
import (

"fmt"

"time"

)
// 计算两个日期之间的天数差

func daysBetweenDates(date1, date2 string) (int, error) {

// 定义日期格式

const layout = "2006-01-02"
// 解析第一个日期

t1, err := time.Parse(layout, date1)

if err != nil {

return 0, err

}
// 解析第二个日期

t2, err := time.Parse(layout, date2)

if err != nil {

return 0, err

}
// 计算日期差

duration := t2.Sub(t1)
// 转换为天数

days := int(duration.Hours() / 24)
return days, nil

}
func main() {

date1 := "2008-08-08"

date2 := "2089-10-01"
days, err := daysBetweenDates(date1, date2)

if err != nil {

fmt.Println("Error:", err)

return

}
fmt.Printf("Days between %s and %s: %d\n", date1, date2, days)

}

// sec returns the time's seconds since Jan 1 year 1.

func (t Time) sec() int64 {

if t.wall&hasMonotonic != 0 {

return wallToInternal + int64(t.wall<<1>>(nsecShift+1))

}

return t.ext

}

func parse(layout, value string, defaultLocation, local *Location) (Time, error) {

alayout, avalue := layout, value

rangeErrString := "" // set if a value is out of range

amSet := false       // do we need to subtract 12 from the hour for midnight?

pmSet := false       // do we need to add 12 to the hour?

// Time being constructed.

var (

year       int

month      int = -1

day        int = -1

yday       int = -1

hour       int

min        int

sec        int

nsec       int

z          *Location

zoneOffset int = -1

zoneName   string

)
// Each iteration processes one std value.

for {

var err error

prefix, std, suffix := nextStdChunk(layout)

stdstr := layout[len(prefix) : len(layout)-len(suffix)]

value, err = skip(value, prefix)

if err != nil {

return Time{}, newParseError(alayout, avalue, prefix, value, "")

}

if std == 0 {

if len(value) != 0 {

return Time{}, newParseError(alayout, avalue, "", value, ": extra text: "+quote(value))

}

break

}

layout = suffix

var p string

hold := value

switch std & stdMask {

case stdYear:

if len(value) < 2 {

err = errBad

break

}

p, value = value[0:2], value[2:]

year, err = atoi(p)

if err != nil {

break

}

if year >= 69 { // Unix time starts Dec 31 1969 in some time zones

year += 1900

} else {

year += 2000

}

case stdLongYear:

if len(value) < 4 || !isDigit(value, 0) {

err = errBad

break

}

p, value = value[0:4], value[4:]

year, err = atoi(p)

case stdMonth:

month, value, err = lookup(shortMonthNames, value)

month++

case stdLongMonth:

month, value, err = lookup(longMonthNames, value)

month++

case stdNumMonth, stdZeroMonth:

month, value, err = getnum(value, std == stdZeroMonth)

if err == nil && (month <= 0 || 12 < month) {

rangeErrString = "month"

}

case stdWeekDay:

// Ignore weekday except for error checking.

_, value, err = lookup(shortDayNames, value)

case stdLongWeekDay:

_, value, err = lookup(longDayNames, value)

case stdDay, stdUnderDay, stdZeroDay:

if std == stdUnderDay && len(value) > 0 && value[0] == ' ' {

value = value[1:]

}

day, value, err = getnum(value, std == stdZeroDay)

// Note that we allow any one- or two-digit day here.

// The month, day, year combination is validated after we've completed parsing.

case stdUnderYearDay, stdZeroYearDay:

for i := 0; i < 2; i++ {

if std == stdUnderYearDay && len(value) > 0 && value[0] == ' ' {

value = value[1:]

}

}

yday, value, err = getnum3(value, std == stdZeroYearDay)

// Note that we allow any one-, two-, or three-digit year-day here.

// The year-day, year combination is validated after we've completed parsing.

case stdHour:

hour, value, err = getnum(value, false)

if hour < 0 || 24 <= hour {

rangeErrString = "hour"

}

case stdHour12, stdZeroHour12:

hour, value, err = getnum(value, std == stdZeroHour12)

if hour < 0 || 12 < hour {

rangeErrString = "hour"

}

case stdMinute, stdZeroMinute:

min, value, err = getnum(value, std == stdZeroMinute)

if min < 0 || 60 <= min {

rangeErrString = "minute"

}

case stdSecond, stdZeroSecond:

sec, value, err = getnum(value, std == stdZeroSecond)

if err != nil {

break

}

if sec < 0 || 60 <= sec {

rangeErrString = "second"

break

}

// Special case: do we have a fractional second but no

// fractional second in the format?

if len(value) >= 2 && commaOrPeriod(value[0]) && isDigit(value, 1) {

_, std, _ = nextStdChunk(layout)

std &= stdMask

if std == stdFracSecond0 || std == stdFracSecond9 {

// Fractional second in the layout; proceed normally

break

}

// No fractional second in the layout but we have one in the input.

n := 2

for ; n < len(value) && isDigit(value, n); n++ {

}

nsec, rangeErrString, err = parseNanoseconds(value, n)

value = value[n:]

}

case stdPM:

if len(value) < 2 {

err = errBad

break

}

p, value = value[0:2], value[2:]

switch p {

case "PM":

pmSet = true

case "AM":

amSet = true

default:

err = errBad

}

case stdpm:

if len(value) < 2 {

err = errBad

break

}

p, value = value[0:2], value[2:]

switch p {

case "pm":

pmSet = true

case "am":

amSet = true

default:

err = errBad

}

case stdISO8601TZ, stdISO8601ColonTZ, stdISO8601SecondsTZ, stdISO8601ShortTZ, stdISO8601ColonSecondsTZ, stdNumTZ, stdNumShortTZ, stdNumColonTZ, stdNumSecondsTz, stdNumColonSecondsTZ:

if (std == stdISO8601TZ || std == stdISO8601ShortTZ || std == stdISO8601ColonTZ) && len(value) >= 1 && value[0] == 'Z' {

value = value[1:]

z = UTC

break

}

var sign, hour, min, seconds string

if std == stdISO8601ColonTZ || std == stdNumColonTZ {

if len(value) < 6 {

err = errBad

break

}

if value[3] != ':' {

err = errBad

break

}

sign, hour, min, seconds, value = value[0:1], value[1:3], value[4:6], "00", value[6:]

} else if std == stdNumShortTZ || std == stdISO8601ShortTZ {

if len(value) < 3 {

err = errBad

break

}

sign, hour, min, seconds, value = value[0:1], value[1:3], "00", "00", value[3:]

} else if std == stdISO8601ColonSecondsTZ || std == stdNumColonSecondsTZ {

if len(value) < 9 {

err = errBad

break

}

if value[3] != ':' || value[6] != ':' {

err = errBad

break

}

sign, hour, min, seconds, value = value[0:1], value[1:3], value[4:6], value[7:9], value[9:]

} else if std == stdISO8601SecondsTZ || std == stdNumSecondsTz {

if len(value) < 7 {

err = errBad

break

}

sign, hour, min, seconds, value = value[0:1], value[1:3], value[3:5], value[5:7], value[7:]

} else {

if len(value) < 5 {

err = errBad

break

}

sign, hour, min, seconds, value = value[0:1], value[1:3], value[3:5], "00", value[5:]

}

var hr, mm, ss int

hr, _, err = getnum(hour, true)

if err == nil {

mm, _, err = getnum(min, true)

}

if err == nil {

ss, _, err = getnum(seconds, true)

}

zoneOffset = (hr*60+mm)*60 + ss // offset is in seconds

switch sign[0] {

case '+':

case '-':

zoneOffset = -zoneOffset

default:

err = errBad

}

case stdTZ:

// Does it look like a time zone?

if len(value) >= 3 && value[0:3] == "UTC" {

z = UTC

value = value[3:]

break

}

n, ok := parseTimeZone(value)

if !ok {

err = errBad

break

}

zoneName, value = value[:n], value[n:]
case stdFracSecond0:

// stdFracSecond0 requires the exact number of digits as specified in

// the layout.

ndigit := 1 + digitsLen(std)

if len(value) < ndigit {

err = errBad

break

}

nsec, rangeErrString, err = parseNanoseconds(value, ndigit)

value = value[ndigit:]
case stdFracSecond9:

if len(value) < 2 || !commaOrPeriod(value[0]) || value[1] < '0' || '9' < value[1] {

// Fractional second omitted.

break

}

// Take any number of digits, even more than asked for,

// because it is what the stdSecond case would do.

i := 0

for i+1 < len(value) && '0' <= value[i+1] && value[i+1] <= '9' {

i++

}

nsec, rangeErrString, err = parseNanoseconds(value, 1+i)

value = value[1+i:]

}

if rangeErrString != "" {

return Time{}, newParseError(alayout, avalue, stdstr, value, ": "+rangeErrString+" out of range")

}

if err != nil {

return Time{}, newParseError(alayout, avalue, stdstr, hold, "")

}

}

if pmSet && hour < 12 {

hour += 12

} else if amSet && hour == 12 {

hour = 0

}
// Convert yday to day, month.

if yday >= 0 {

var d int

var m int

if isLeap(year) {

if yday == 31+29 {

m = int(February)

d = 29

} else if yday > 31+29 {

yday--

}

}

if yday < 1 || yday > 365 {

return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year out of range")

}

if m == 0 {

m = (yday-1)/31 + 1

if int(daysBefore[m]) < yday {

m++

}

d = yday - int(daysBefore[m-1])

}

// If month, day already seen, yday's m, d must match.

// Otherwise, set them from m, d.

if month >= 0 && month != m {

return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year does not match month")

}

month = m

if day >= 0 && day != d {

return Time{}, newParseError(alayout, avalue, "", value, ": day-of-year does not match day")

}

day = d

} else {

if month < 0 {

month = int(January)

}

if day < 0 {

day = 1

}

}
// Validate the day of the month.

if day < 1 || day > daysIn(Month(month), year) {

return Time{}, newParseError(alayout, avalue, "", value, ": day out of range")

}
if z != nil {

return Date(year, Month(month), day, hour, min, sec, nsec, z), nil

}
if zoneOffset != -1 {

t := Date(year, Month(month), day, hour, min, sec, nsec, UTC)

t.addSec(-int64(zoneOffset))
// Look for local zone with the given offset.

// If that zone was in effect at the given time, use it.

name, offset, _, _, _ := local.lookup(t.unixSec())

if offset == zoneOffset && (zoneName == "" || name == zoneName) {

t.setLoc(local)

return t, nil

}
// Otherwise create fake zone to record offset.

zoneNameCopy := cloneString(zoneName) // avoid leaking the input value

t.setLoc(FixedZone(zoneNameCopy, zoneOffset))

return t, nil

}
if zoneName != "" {

t := Date(year, Month(month), day, hour, min, sec, nsec, UTC)

// Look for local zone with the given offset.

// If that zone was in effect at the given time, use it.

offset, ok := local.lookupName(zoneName, t.unixSec())

if ok {

t.addSec(-int64(offset))

t.setLoc(local)

return t, nil

}
// Otherwise, create fake zone with unknown offset.

if len(zoneName) > 3 && zoneName[:3] == "GMT" {

offset, _ = atoi(zoneName[3:]) // Guaranteed OK by parseGMT.

offset *= 3600

}

zoneNameCopy := cloneString(zoneName) // avoid leaking the input value

t.setLoc(FixedZone(zoneNameCopy, offset))

return t, nil

}
// Otherwise, fall back to default.

return Date(year, Month(month), day, hour, min, sec, nsec, defaultLocation), nil

}

func Date(year int, month Month, day, hour, min, sec, nsec int, loc *Location) Time {

if loc == nil {

panic("time: missing Location in call to Date")

}

// Normalize month, overflowing into year.

m := int(month) - 1

year, m = norm(year, m, 12)

month = Month(m) + 1
// Normalize nsec, sec, min, hour, overflowing into day.

sec, nsec = norm(sec, nsec, 1e9)

min, sec = norm(min, sec, 60)

hour, min = norm(hour, min, 60)

day, hour = norm(day, hour, 24)
// Compute days since the absolute epoch.

d := daysSinceEpoch(year)
// Add in days before this month.

d += uint64(daysBefore[month-1])

if isLeap(year) && month >= March {

d++ // February 29

}
// Add in days before today.

d += uint64(day - 1)
// Add in time elapsed today.

abs := d * secondsPerDay

abs += uint64(hoursecondsPerHour + minsecondsPerMinute + sec)
unix := int64(abs) + (absoluteToInternal + internalToUnix)
// Look for zone offset for expected time, so we can adjust to UTC.

// The lookup function expects UTC, so first we pass unix in the

// hope that it will not be too close to a zone transition,

// and then adjust if it is.

_, offset, start, end, _ := loc.lookup(unix)

if offset != 0 {

utc := unix - int64(offset)

// If utc is valid for the time zone we found, then we have the right offset.

// If not, we get the correct offset by looking up utc in the location.

if utc < start || utc >= end {

_, offset, _, _, _ = loc.lookup(utc)

}

unix -= int64(offset)

}
t := unixTime(unix, int32(nsec))

t.setLoc(loc)

return t

}

func unixTime(sec int64, nsec int32) Time {

return Time{uint64(nsec), sec + unixToInternal, Local}

}