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

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(hour*secondsPerHour + min*secondsPerMinute + 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}}