carbon

package module
v2.6.15 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 15, 2025 License: MIT Imports: 14 Imported by: 4

README

carbon

Carbon Release Go Test Go Report Card Go Coverage Carbon Doc Awesome HelloGitHub License

English | 简体中文 | 日本語 | 한국어

Introduction

Carbon is a lightweight, semantic, and developer-friendly golang time package that doesn't depend on any third-party package, has 100% unit test coverage, and has been used by docker organization as well as included by awesome-go and hello-github.

docker

Repository

github.com/dromara/carbon

gitee.com/dromara/carbon

gitcode.com/dromara/carbon

Quick Start

Installation

go version >= 1.19

// Via github
go get -u github.com/dromara/carbon/v2
import "github.com/dromara/carbon/v2"

// Via gitee
go get -u gitee.com/dromara/carbon/v2
import "gitee.com/dromara/carbon/v2"

// Via gitcode
go get -u gitcode.com/dromara/carbon/v2
import "gitcode.com/dromara/gitcode/v2"

Carbon was donated to the dromara organization, the repository URL has changed. If the previous repository used was golang-module/carbon, please replace the original repository with the new repository in go.mod, or execute the following command:

go mod edit -replace github.com/golang-module/carbon/v2 = github.com/dromara/carbon/v2

Example Usage

Default timezone is UTC, language locale is English, start day of the week is Monday and weekend days of the week are Saturday and Sunday.

carbon.SetTestNow(carbon.Parse("2020-08-05 13:14:15.999999999"))
carbon.IsTestNow() // true

carbon.Now().ToString() // 2020-08-05 13:14:15.999999999 +0000 UTC
carbon.Yesterday().ToString() // 2020-08-04 13:14:15.999999999 +0000 UTC
carbon.Tomorrow().ToString() // 2020-08-06 13:14:15.999999999 +0000 UTC

carbon.Parse("2020-08-05 13:14:15").ToString() // 2020-08-05 13:14:15 +0000 UTC
carbon.Parse("2022-03-08T03:01:14-07:00").ToString() // 2022-03-08 10:01:14 +0000 UTC

carbon.ParseByLayout("It is 2020-08-05 13:14:15", "It is 2006-01-02 15:04:05").ToString() // 2020-08-05 13:14:15 +0000 UTC
carbon.ParseByFormat("It is 2020-08-05 13:14:15", "\\I\\t \\i\\s Y-m-d H:i:s").ToString() // 2020-08-05 13:14:15 +0000 UTC

carbon.CreateFromDate(2020, 8, 5).ToString() // 2020-08-05 00:00:00 +0000 UTC
carbon.CreateFromTime(13, 14, 15).ToString() // 2020-08-05 13:14:15 +0000 UTC
carbon.CreateFromDateTime(2020, 8, 5, 13, 14, 15).ToString() // 2020-08-05 13:14:15 +0000 UTC
carbon.CreateFromTimestamp(1596633255).ToString() // 2020-08-05 13:14:15 +0000 UTC

carbon.Parse("2020-07-05 13:14:15").DiffForHumans() // 1 month before
carbon.Parse("2020-07-05 13:14:15").SetLocale("zh-CN").DiffForHumans() // 1 月前

carbon.ClearTestNow()
carbon.IsTestNow() // false

For more usage examples, please refer to official document.

For performance test reports, please refer to benchmark report

References

Contributors

Thanks to all the following who contributed to Carbon:

Translators

Ask for help to translate Carbon in other localized languages

How to add new localized language support to carbon

Sponsors

Carbon is a non-commercial open source project. If you want to support Carbon, you can buy a cup of coffee for developer.

Thanks

Carbon had been being developed with GoLand under the free JetBrains Open Source license, I would like to express my thanks here.

JetBrains

License

Carbon is licensed under the MIT License, see the LICENSE file for details.

Documentation

Overview

Package carbon is a simple, semantic and developer-friendly time package for golang.

Index

Examples

Constants

View Source 
const (
	Local = "Local"
	UTC   = "UTC"

	CET  = "CET"
	EET  = "EET"
	EST  = "EST"
	GMT  = "GMT"
	MET  = "MET"
	MST  = "MST"
	UCT  = "MST"
	WET  = "WET"
	Zulu = "Zulu"

	Cuba      = "Cuba"
	Egypt     = "Egypt"
	Eire      = "Eire"
	Greenwich = "Greenwich"
	Iceland   = "Iceland"
	Iran      = "Iran"
	Israel    = "Israel"
	Jamaica   = "Jamaica"
	Japan     = "Japan"
	Libya     = "Libya"
	Poland    = "Poland"
	Portugal  = "Portugal"
	PRC       = "PRC"
	Singapore = "Singapore"
	Turkey    = "Turkey"

	Shanghai   = "Asia/Shanghai"
	Chongqing  = "Asia/Chongqing"
	Harbin     = "Asia/Harbin"
	Urumqi     = "Asia/Urumqi"
	HongKong   = "Asia/Hong_Kong"
	Macao      = "Asia/Macao"
	Taipei     = "Asia/Taipei"
	Tokyo      = "Asia/Tokyo"
	HoChiMinh  = "Asia/Ho_Chi_Minh"
	Hanoi      = "Asia/Hanoi"
	Saigon     = "Asia/Saigon"
	Seoul      = "Asia/Seoul"
	Pyongyang  = "Asia/Pyongyang"
	Bangkok    = "Asia/Bangkok"
	Dubai      = "Asia/Dubai"
	Qatar      = "Asia/Qatar"
	Bangalore  = "Asia/Bangalore"
	Kolkata    = "Asia/Kolkata"
	Mumbai     = "Asia/Mumbai"
	MexicoCity = "America/Mexico_City"
	NewYork    = "America/New_York"
	LosAngeles = "America/Los_Angeles"
	Chicago    = "America/Chicago"
	SaoPaulo   = "America/Sao_Paulo"
	Moscow     = "Europe/Moscow"
	London     = "Europe/London"
	Berlin     = "Europe/Berlin"
	Paris      = "Europe/Paris"
	Rome       = "Europe/Rome"
	Sydney     = "Australia/Sydney"
	Melbourne  = "Australia/Melbourne"
	Darwin     = "Australia/Darwin"
)

timezone constants

View Source 
const (
	January   = time.January
	February  = time.February
	March     = time.March
	April     = time.April
	May       = time.May
	June      = time.June
	July      = time.July
	August    = time.August
	September = time.September
	October   = time.October
	November  = time.November
	December  = time.December
)

month constants

View Source 
const (
	Spring = "Spring"
	Summer = "Summer"
	Autumn = "Autumn"
	Winter = "Winter"
)

season constants

View Source 
const (
	Aries       = "Aries"
	Taurus      = "Taurus"
	Gemini      = "Gemini"
	Cancer      = "Cancer"
	Leo         = "Leo"
	Virgo       = "Virgo"
	Libra       = "Libra"
	Scorpio     = "Scorpio"
	Sagittarius = "Sagittarius"
	Capricorn   = "Capricorn"
	Aquarius    = "Aquarius"
	Pisces      = "Pisces"
)

constellation constants

View Source 
const (
	Monday    = time.Monday
	Tuesday   = time.Tuesday
	Wednesday = time.Wednesday
	Thursday  = time.Thursday
	Friday    = time.Friday
	Saturday  = time.Saturday
	Sunday    = time.Sunday
)

week constants

View Source 
const (
	EpochYear          = 1970
	YearsPerMillennium = 1000
	YearsPerCentury    = 100
	YearsPerDecade     = 10
	QuartersPerYear    = 4
	MonthsPerYear      = 12
	MonthsPerQuarter   = 3
	WeeksPerNormalYear = 52
	WeeksPerLongYear   = 53
	WeeksPerMonth      = 4
	DaysPerLeapYear    = 366
	DaysPerNormalYear  = 365
	DaysPerWeek        = 7
	HoursPerWeek       = 168
	HoursPerDay        = 24
	MinutesPerDay      = 1440
	MinutesPerHour     = 60
	SecondsPerWeek     = 604800
	SecondsPerDay      = 86400
	SecondsPerHour     = 3600
	SecondsPerMinute   = 60
)

number constants

View Source 
const (
	MaxYear       = 9999
	MaxMonth      = 12
	MaxDay        = 31
	MaxHour       = 23
	MaxMinute     = 59
	MaxSecond     = 59
	MaxNanosecond = 999999999
)

max constants

View Source 
const (
	MinYear       = 1
	MinMonth      = 1
	MinDay        = 1
	MinHour       = 0
	MinMinute     = 0
	MinSecond     = 0
	MinNanosecond = 0
)

min constants

View Source 
const (
	AtomLayout     = RFC3339Layout
	ANSICLayout    = time.ANSIC
	CookieLayout   = "Monday, 02-Jan-2006 15:04:05 MST"
	KitchenLayout  = time.Kitchen
	RssLayout      = time.RFC1123Z
	RubyDateLayout = time.RubyDate
	UnixDateLayout = time.UnixDate
	W3cLayout      = RFC3339Layout
	HttpLayout     = "Mon, 02 Jan 2006 15:04:05 GMT"

	RFC1036Layout      = "Mon, 02 Jan 06 15:04:05 -0700"
	RFC1123Layout      = time.RFC1123
	RFC1123ZLayout     = time.RFC1123Z
	RFC2822Layout      = time.RFC1123Z
	RFC3339Layout      = "2006-01-02T15:04:05Z07:00"
	RFC3339MilliLayout = "2006-01-02T15:04:05.999Z07:00"
	RFC3339MicroLayout = "2006-01-02T15:04:05.999999Z07:00"
	RFC3339NanoLayout  = "2006-01-02T15:04:05.999999999Z07:00"
	RFC7231Layout      = "Mon, 02 Jan 2006 15:04:05 MST"
	RFC822Layout       = time.RFC822
	RFC822ZLayout      = time.RFC822Z
	RFC850Layout       = time.RFC850

	ISO8601Layout      = "2006-01-02T15:04:05-07:00"
	ISO8601MilliLayout = "2006-01-02T15:04:05.999-07:00"
	ISO8601MicroLayout = "2006-01-02T15:04:05.999999-07:00"
	ISO8601NanoLayout  = "2006-01-02T15:04:05.999999999-07:00"

	ISO8601ZuluLayout      = "2006-01-02T15:04:05Z"
	ISO8601ZuluMilliLayout = "2006-01-02T15:04:05.999Z"
	ISO8601ZuluMicroLayout = "2006-01-02T15:04:05.999999Z"
	ISO8601ZuluNanoLayout  = "2006-01-02T15:04:05.999999999Z"

	FormattedDateLayout    = "Jan 2, 2006"
	FormattedDayDateLayout = "Mon, Jan 2, 2006"

	DayDateTimeLayout        = "Mon, Jan 2, 2006 3:04 PM"
	DateTimeLayout           = "2006-01-02 15:04:05"
	DateTimeMilliLayout      = "2006-01-02 15:04:05.999"
	DateTimeMicroLayout      = "2006-01-02 15:04:05.999999"
	DateTimeNanoLayout       = "2006-01-02 15:04:05.999999999"
	ShortDateTimeLayout      = "20060102150405"
	ShortDateTimeMilliLayout = "20060102150405.999"
	ShortDateTimeMicroLayout = "20060102150405.999999"
	ShortDateTimeNanoLayout  = "20060102150405.999999999"

	DateLayout           = "2006-01-02"
	DateMilliLayout      = "2006-01-02.999"
	DateMicroLayout      = "2006-01-02.999999"
	DateNanoLayout       = "2006-01-02.999999999"
	ShortDateLayout      = "20060102"
	ShortDateMilliLayout = "20060102.999"
	ShortDateMicroLayout = "20060102.999999"
	ShortDateNanoLayout  = "20060102.999999999"

	TimeLayout           = "15:04:05"
	TimeMilliLayout      = "15:04:05.999"
	TimeMicroLayout      = "15:04:05.999999"
	TimeNanoLayout       = "15:04:05.999999999"
	ShortTimeLayout      = "150405"
	ShortTimeMilliLayout = "150405.999"
	ShortTimeMicroLayout = "150405.999999"
	ShortTimeNanoLayout  = "150405.999999999"

	TimestampLayout      = "unix"
	TimestampMilliLayout = "unixMilli"
	TimestampMicroLayout = "unixMicro"
	TimestampNanoLayout  = "unixNano"
)

layout constants

View Source 
const (
	AtomFormat     = "Y-m-d\\TH:i:sR"
	ANSICFormat    = "D M  j H:i:s Y"
	CookieFormat   = "l, d-M-Y H:i:s Z"
	KitchenFormat  = "g:iA"
	RssFormat      = "D, d M Y H:i:s O"
	RubyDateFormat = "D M d H:i:s O Y"
	UnixDateFormat = "D M  j H:i:s Z Y"
	W3cFormat      = RFC3339Format
	HttpFormat     = "D, d M Y H:i:s \\G\\M\\T"

	RFC1036Format      = "D, d M y H:i:s O"
	RFC1123Format      = "D, d M Y H:i:s Z"
	RFC1123ZFormat     = "D, d M Y H:i:s O"
	RFC2822Format      = "D, d M Y H:i:s O"
	RFC3339Format      = "Y-m-d\\TH:i:sR"
	RFC3339MilliFormat = "Y-m-d\\TH:i:s.uR"
	RFC3339MicroFormat = "Y-m-d\\TH:i:s.vR"
	RFC3339NanoFormat  = "Y-m-d\\TH:i:s.xR"
	RFC7231Format      = "D, d M Y H:i:s Z"
	RFC822Format       = "d M y H:i Z"
	RFC822ZFormat      = "d M y H:i O"
	RFC850Format       = "l, d-M-y H:i:s Z"

	ISO8601Format      = "Y-m-d\\TH:i:sP"
	ISO8601MilliFormat = "Y-m-d\\TH:i:s.uP"
	ISO8601MicroFormat = "Y-m-d\\TH:i:s.vP"
	ISO8601NanoFormat  = "Y-m-d\\TH:i:s.xP"

	ISO8601ZuluFormat      = "Y-m-d\\TH:i:s\\Z"
	ISO8601ZuluMilliFormat = "Y-m-d\\TH:i:s.u\\Z"
	ISO8601ZuluMicroFormat = "Y-m-d\\TH:i:s.v\\Z"
	ISO8601ZuluNanoFormat  = "Y-m-d\\TH:i:s.x\\Z"

	FormattedDateFormat    = "M j, Y"
	FormattedDayDateFormat = "D, M j, Y"

	DayDateTimeFormat        = "D, M j, Y g:i A"
	DateTimeFormat           = "Y-m-d H:i:s"
	DateTimeMilliFormat      = "Y-m-d H:i:s.u"
	DateTimeMicroFormat      = "Y-m-d H:i:s.v"
	DateTimeNanoFormat       = "Y-m-d H:i:s.x"
	ShortDateTimeFormat      = "YmdHis"
	ShortDateTimeMilliFormat = "YmdHis.u"
	ShortDateTimeMicroFormat = "YmdHis.v"
	ShortDateTimeNanoFormat  = "YmdHis.x"

	DateFormat           = "Y-m-d"
	DateMilliFormat      = "Y-m-d.u"
	DateMicroFormat      = "Y-m-d.v"
	DateNanoFormat       = "Y-m-d.x"
	ShortDateFormat      = "Ymd"
	ShortDateMilliFormat = "Ymd.u"
	ShortDateMicroFormat = "Ymd.v"
	ShortDateNanoFormat  = "Ymd.x"

	TimeFormat           = "H:i:s"
	TimeMilliFormat      = "H:i:s.u"
	TimeMicroFormat      = "H:i:s.v"
	TimeNanoFormat       = "H:i:s.x"
	ShortTimeFormat      = "His"
	ShortTimeMilliFormat = "His.u"
	ShortTimeMicroFormat = "His.v"
	ShortTimeNanoFormat  = "His.x"

	TimestampFormat      = "S"
	TimestampMilliFormat = "U"
	TimestampMicroFormat = "V"
	TimestampNanoFormat  = "X"
)

format constants

View Source 
const (
	PrecisionSecond      = "second"
	PrecisionMillisecond = "millisecond"
	PrecisionMicrosecond = "microsecond"
	PrecisionNanosecond  = "nanosecond"
)

timestamp precision constants

View Source 
const Version = "2.6.15"

Version current version

Variables

View Source 
var (
	// DefaultLayout default layout
	DefaultLayout = DateTimeLayout

	// DefaultTimezone default timezone
	DefaultTimezone = UTC

	// DefaultLocale default language locale
	DefaultLocale = "en"

	// DefaultWeekStartsAt default start date of the week
	DefaultWeekStartsAt = Monday

	// DefaultWeekendDays default weekend days of the week
	DefaultWeekendDays = []Weekday{
		Saturday, Sunday,
	}
)
View Source 
var (
	// ErrFailedParse failed to parse error.
	ErrFailedParse = func(value any) error {
		return fmt.Errorf("failed to parse %v as carbon", value)
	}

	// ErrFailedScan failed to scan error.
	ErrFailedScan = func(value any) error {
		return fmt.Errorf("failed to scan %v as carbon", value)
	}

	// ErrInvalidTimestamp invalid timestamp error.
	ErrInvalidTimestamp = func(value string) error {
		return fmt.Errorf("invalid timestamp %v", value)
	}

	// ErrNilLocation nil location error.
	ErrNilLocation = func() error {
		return fmt.Errorf("location cannot be nil")
	}

	// ErrNilLanguage nil language error.
	ErrNilLanguage = func() error {
		return fmt.Errorf("language cannot be nil")
	}

	// ErrInvalidLanguage invalid language error.
	ErrInvalidLanguage = func(lang *Language) error {
		return fmt.Errorf("invalid Language %v", lang)
	}

	// ErrEmptyLocale empty locale error.
	ErrEmptyLocale = func() error {
		return fmt.Errorf("locale cannot be empty")
	}

	// ErrNotExistLocale not exist locale error.
	ErrNotExistLocale = func(locale string) error {
		return fmt.Errorf("locale %q doesn't exist", locale)
	}

	// ErrEmptyResources empty resources error.
	ErrEmptyResources = func() error {
		return fmt.Errorf("resources cannot be empty")
	}

	// ErrEmptyTimezone empty timezone error.
	ErrEmptyTimezone = func() error {
		return fmt.Errorf("timezone cannot be empty")
	}

	// ErrInvalidTimezone invalid timezone error.
	ErrInvalidTimezone = func(timezone string) error {
		return fmt.Errorf("invalid timezone %q, please see the file %q for all valid timezones", timezone, "$GOROOT/lib/time/zoneinfo.zip")
	}

	// ErrEmptyDuration empty duration error.
	ErrEmptyDuration = func() error {
		return fmt.Errorf("duration cannot be empty")
	}

	// ErrInvalidDuration invalid duration error.
	ErrInvalidDuration = func(duration string) error {
		return fmt.Errorf("invalid duration %q", duration)
	}

	// ErrEmptyLayout empty layout error.
	ErrEmptyLayout = func() error {
		return fmt.Errorf("layout cannot be empty")
	}

	// ErrMismatchedLayout mismatched layout error.
	ErrMismatchedLayout = func(value, layout string) error {
		return fmt.Errorf("value %q and layout %q are mismatched", value, layout)
	}

	// ErrEmptyFormat empty format error.
	ErrEmptyFormat = func() error {
		return fmt.Errorf("format cannot be empty")
	}

	// ErrMismatchedFormat mismatched format error.
	ErrMismatchedFormat = func(value, format string) error {
		return fmt.Errorf("value %q and format %q are mismatched", value, format)
	}
)

Functions

func ClearTestNow added in v2.6.5 

func ClearTestNow()

ClearTestNow clears the test Carbon instance for now.

Example 
carbon.SetTestNow(carbon.Parse("2020-08-05"))

fmt.Println(carbon.IsTestNow())

carbon.ClearTestNow()

fmt.Println(carbon.IsTestNow())

Output:

true
false

func IsTestNow added in v2.6.0 

func IsTestNow() bool

IsTestNow reports whether is testing time.

func ResetDefault added in v2.6.1 

func ResetDefault()

ResetDefault resets default.

func SetDefault 

func SetDefault(d Default)

SetDefault sets default.

Example 
defer carbon.ResetDefault()

carbon.SetDefault(carbon.Default{
	Layout:       carbon.DateTimeLayout,
	Timezone:     carbon.PRC,
	Locale:       "zh-CN",
	WeekStartsAt: carbon.Monday,
	WeekendDays: []carbon.Weekday{
		carbon.Saturday, carbon.Sunday,
	},
})

fmt.Println("default layout:", carbon.DefaultLayout)
fmt.Println("default timezone:", carbon.DefaultTimezone)
fmt.Println("default week starts at:", carbon.DefaultWeekStartsAt)
fmt.Println("default weekend days:", carbon.DefaultWeekendDays)
fmt.Println("default locale:", carbon.DefaultLocale)

Output:

default layout: 2006-01-02 15:04:05
default timezone: PRC
default week starts at: Monday
default weekend days: [Saturday Sunday]
default locale: zh-CN

func SetTestNow added in v2.6.0 

func SetTestNow(c *Carbon)

SetTestNow sets a test Carbon instance for now.

Example 
defer carbon.ClearTestNow()

now := carbon.Parse("2020-08-05")
carbon.SetTestNow(now)

fmt.Println(carbon.Now().ToDateString())
fmt.Println(carbon.Yesterday().ToDateString())
fmt.Println(carbon.Tomorrow().ToDateString())
fmt.Println(carbon.Now().DiffForHumans())
fmt.Println(carbon.Yesterday().DiffForHumans())
fmt.Println(carbon.Tomorrow().DiffForHumans())
fmt.Println(carbon.Parse("2020-10-05").DiffForHumans())
fmt.Println(now.DiffForHumans(carbon.Parse("2020-10-05")))

Output:

2020-08-05
2020-08-04
2020-08-06
just now
1 day ago
1 day from now
2 months from now
2 months before

func Sleep added in v2.6.11 

func Sleep(d time.Duration)

Sleep sleeps for the specified duration like time.Sleep.

Example 
fmt.Println("Normal mode sleep:")
c := carbon.NewCarbon()
fmt.Printf("Before sleep: %s\n", c.ToString())

carbon.Sleep(1 * time.Second)
fmt.Printf("After sleep: %s\n", c.ToString())

fmt.Println("\nTest mode sleep:")
testNow := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(testNow)
defer carbon.ClearTestNow()

fmt.Printf("Test time before sleep: %s\n", carbon.Now().ToString())

carbon.Sleep(2 * time.Hour)
fmt.Printf("Test time after sleep: %s\n", carbon.Now().ToString())

carbon.Sleep(30 * time.Minute)
fmt.Printf("Test time after another sleep: %s\n", carbon.Now().ToString())

Output:

Normal mode sleep:
Before sleep: 0001-01-01 00:00:00 +0000 UTC
After sleep: 0001-01-01 00:00:00 +0000 UTC

Test mode sleep:
Test time before sleep: 2020-08-05 13:14:15 +0000 UTC
Test time after sleep: 2020-08-05 15:14:15 +0000 UTC
Test time after another sleep: 2020-08-05 15:44:15 +0000 UTC

Types

type Carbon 

type Carbon struct {
	Error error
	// contains filtered or unexported fields
}

Carbon defines a Carbon struct.

func CreateFromDate 

func CreateFromDate(year, month, day int, timezone ...string) *Carbon

CreateFromDate creates a Carbon instance from a given date.

Example 
fmt.Println(carbon.CreateFromDate(2020, 8, 5).ToString())
fmt.Println(carbon.CreateFromDate(2020, 8, 5, carbon.PRC).ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 00:00:00 +0800 CST

func CreateFromDateMicro 

func CreateFromDateMicro(year, month, day, microsecond int, timezone ...string) *Carbon

CreateFromDateMicro creates a Carbon instance from a given date and microsecond.

Example 
fmt.Println(carbon.CreateFromDateMicro(2020, 8, 5, 999999).ToString())
fmt.Println(carbon.CreateFromDateMicro(2020, 8, 5, 999999, carbon.PRC).ToString())

Output:

2020-08-05 00:00:00.999999 +0000 UTC
2020-08-05 00:00:00.999999 +0800 CST

func CreateFromDateMilli 

func CreateFromDateMilli(year, month, day, millisecond int, timezone ...string) *Carbon

CreateFromDateMilli creates a Carbon instance from a given date and millisecond.

Example 
fmt.Println(carbon.CreateFromDateMilli(2020, 8, 5, 999).ToString())
fmt.Println(carbon.CreateFromDateMilli(2020, 8, 5, 999, carbon.PRC).ToString())

Output:

2020-08-05 00:00:00.999 +0000 UTC
2020-08-05 00:00:00.999 +0800 CST

func CreateFromDateNano 

func CreateFromDateNano(year, month, day, nanosecond int, timezone ...string) *Carbon

CreateFromDateNano creates a Carbon instance from a given date and nanosecond.

Example 
fmt.Println(carbon.CreateFromDateNano(2020, 8, 5, 999999999).ToString())
fmt.Println(carbon.CreateFromDateNano(2020, 8, 5, 999999999, carbon.PRC).ToString())

Output:

2020-08-05 00:00:00.999999999 +0000 UTC
2020-08-05 00:00:00.999999999 +0800 CST

func CreateFromDateTime 

func CreateFromDateTime(year, month, day, hour, minute, second int, timezone ...string) *Carbon

CreateFromDateTime creates a Carbon instance from a given date and time.

Example 
fmt.Println(carbon.CreateFromDateTime(2020, 8, 5, 13, 14, 15).ToString())
fmt.Println(carbon.CreateFromDateTime(2020, 8, 5, 13, 14, 15, carbon.PRC).ToString())

Output:

2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0800 CST

func CreateFromDateTimeMicro 

func CreateFromDateTimeMicro(year, month, day, hour, minute, second, microsecond int, timezone ...string) *Carbon

CreateFromDateTimeMicro creates a Carbon instance from a given date, time and microsecond.

Example 
fmt.Println(carbon.CreateFromDateTimeMicro(2020, 8, 5, 13, 14, 15, 999999).ToString())
fmt.Println(carbon.CreateFromDateTimeMicro(2020, 8, 5, 13, 14, 15, 999999, carbon.PRC).ToString())

Output:

2020-08-05 13:14:15.999999 +0000 UTC
2020-08-05 13:14:15.999999 +0800 CST

func CreateFromDateTimeMilli 

func CreateFromDateTimeMilli(year, month, day, hour, minute, second, millisecond int, timezone ...string) *Carbon

CreateFromDateTimeMilli creates a Carbon instance from a given date, time and millisecond.

Example 
fmt.Println(carbon.CreateFromDateTimeMilli(2020, 8, 5, 13, 14, 15, 999).ToString())
fmt.Println(carbon.CreateFromDateTimeMilli(2020, 8, 5, 13, 14, 15, 999, carbon.PRC).ToString())

Output:

2020-08-05 13:14:15.999 +0000 UTC
2020-08-05 13:14:15.999 +0800 CST

func CreateFromDateTimeNano 

func CreateFromDateTimeNano(year, month, day, hour, minute, second, nanosecond int, timezone ...string) *Carbon

CreateFromDateTimeNano creates a Carbon instance from a given date, time and nanosecond.

Example 
fmt.Println(carbon.CreateFromDateTimeNano(2020, 8, 5, 13, 14, 15, 999999999).ToString())
fmt.Println(carbon.CreateFromDateTimeNano(2020, 8, 5, 13, 14, 15, 999999999, carbon.PRC).ToString())

Output:

2020-08-05 13:14:15.999999999 +0000 UTC
2020-08-05 13:14:15.999999999 +0800 CST

func CreateFromHebrew added in v2.6.11 

func CreateFromHebrew(year, month, day int) *Carbon

CreateFromHebrew creates a Carbon instance from Hebrew date.

Example 
fmt.Println(carbon.CreateFromHebrew(5784, 10, 20).ToDateString())
fmt.Println(carbon.CreateFromHebrew(5784, 5, 1).ToDateString())
fmt.Println(carbon.CreateFromHebrew(5786, 7, 10).ToDateString())

Output:

2023-12-17
2024-07-21
2025-09-18

func CreateFromJulian 

func CreateFromJulian(f float64) *Carbon

CreateFromJulian creates a Carbon instance from Julian Day or Modified Julian Day.

Example 
fmt.Println(carbon.CreateFromJulian(2.460333051563e+06).ToString())
fmt.Println(carbon.CreateFromJulian(60332.551563).ToString())

Output:

2024-01-23 13:14:15 +0000 UTC
2024-01-23 13:14:15 +0000 UTC

func CreateFromLunar 

func CreateFromLunar(year, month, day int, isLeapMonth bool) *Carbon

CreateFromLunar creates a Carbon instance from Lunar date.

Example 
fmt.Println(carbon.CreateFromLunar(2023, 2, 11, false).ToString(carbon.PRC))
fmt.Println(carbon.CreateFromLunar(2023, 2, 11, true).ToString(carbon.PRC))

Output:

2023-03-02 00:00:00 +0800 CST
2023-04-01 00:00:00 +0800 CST

func CreateFromPersian 

func CreateFromPersian(year, month, day int) *Carbon

CreateFromPersian creates a Carbon instance from Persian date.

Example 
fmt.Println(carbon.CreateFromPersian(1178, 10, 11).ToDateString())
fmt.Println(carbon.CreateFromPersian(1402, 10, 11).ToDateString())
fmt.Println(carbon.CreateFromPersian(1403, 5, 15).ToDateString())

Output:

1800-01-01
2024-01-01
2024-08-05

func CreateFromStdTime 

func CreateFromStdTime(stdTime StdTime, timezone ...string) *Carbon

CreateFromStdTime creates a Carbon instance from standard time.Time.

Example 
t1, _ := time.Parse(carbon.DateTimeLayout, "2020-08-05 13:14:15")
fmt.Println(carbon.CreateFromStdTime(t1).ToString())

loc, _ := time.LoadLocation(carbon.PRC)
t2, _ := time.ParseInLocation(carbon.DateTimeLayout, "2020-08-05 13:14:15", loc)
fmt.Println(carbon.CreateFromStdTime(t2).ToString())

Output:

2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0800 CST

func CreateFromTime 

func CreateFromTime(hour, minute, second int, timezone ...string) *Carbon

CreateFromTime creates a Carbon instance from a given time(year, month and day are taken from the current time).

Example 
fmt.Println(carbon.CreateFromTime(13, 14, 15).ToTimeString())
fmt.Println(carbon.CreateFromTime(13, 14, 15, carbon.PRC).ToTimeString())

Output:

13:14:15
13:14:15

func CreateFromTimeMicro 

func CreateFromTimeMicro(hour, minute, second, microsecond int, timezone ...string) *Carbon

CreateFromTimeMicro creates a Carbon instance from a given time and microsecond(year, month and day are taken from the current time).

Example 
fmt.Println(carbon.CreateFromTimeMicro(13, 14, 15, 999999).ToTimeMicroString())
fmt.Println(carbon.CreateFromTimeMicro(13, 14, 15, 999999, carbon.PRC).ToTimeMicroString())

Output:

13:14:15.999999
13:14:15.999999

func CreateFromTimeMilli 

func CreateFromTimeMilli(hour, minute, second, millisecond int, timezone ...string) *Carbon

CreateFromTimeMilli creates a Carbon instance from a given time and millisecond(year, month and day are taken from the current time).

Example 
fmt.Println(carbon.CreateFromTimeMilli(13, 14, 15, 999).ToTimeMilliString())
fmt.Println(carbon.CreateFromTimeMilli(13, 14, 15, 999, carbon.PRC).ToTimeMilliString())

Output:

13:14:15.999
13:14:15.999

func CreateFromTimeNano 

func CreateFromTimeNano(hour, minute, second, nanosecond int, timezone ...string) *Carbon

CreateFromTimeNano creates a Carbon instance from a given time and nanosecond(year, month and day are taken from the current time).

Example 
fmt.Println(carbon.CreateFromTimeNano(13, 14, 15, 999999999).ToTimeNanoString())
fmt.Println(carbon.CreateFromTimeNano(13, 14, 15, 999999999, carbon.PRC).ToTimeNanoString())

Output:

13:14:15.999999999
13:14:15.999999999

func CreateFromTimestamp 

func CreateFromTimestamp(timestamp int64, timezone ...string) *Carbon

CreateFromTimestamp creates a Carbon instance from a given timestamp with second precision.

Example 
fmt.Println(carbon.CreateFromTimestamp(-1).ToString())
fmt.Println(carbon.CreateFromTimestamp(0).ToString())
fmt.Println(carbon.CreateFromTimestamp(1, carbon.PRC).ToString())
fmt.Println(carbon.CreateFromTimestamp(1649735755, carbon.PRC).ToString())

Output:

1969-12-31 23:59:59 +0000 UTC
1970-01-01 00:00:00 +0000 UTC
1970-01-01 08:00:01 +0800 CST
2022-04-12 11:55:55 +0800 CST

func CreateFromTimestampMicro 

func CreateFromTimestampMicro(timestampMicro int64, timezone ...string) *Carbon

CreateFromTimestampMicro creates a Carbon instance from a given timestamp with microsecond precision.

Example 
fmt.Println(carbon.CreateFromTimestampMicro(-1).ToString())
fmt.Println(carbon.CreateFromTimestampMicro(0).ToString())
fmt.Println(carbon.CreateFromTimestampMicro(1, carbon.PRC).ToString())
fmt.Println(carbon.CreateFromTimestampMicro(1649735755981566, carbon.PRC).ToString())

Output:

1969-12-31 23:59:59.999999 +0000 UTC
1970-01-01 00:00:00 +0000 UTC
1970-01-01 08:00:00.000001 +0800 CST
2022-04-12 11:55:55.981566 +0800 CST

func CreateFromTimestampMilli 

func CreateFromTimestampMilli(timestampMilli int64, timezone ...string) *Carbon

CreateFromTimestampMilli creates a Carbon instance from a given timestamp with millisecond precision.

Example 
fmt.Println(carbon.CreateFromTimestampMilli(-1).ToString())
fmt.Println(carbon.CreateFromTimestampMilli(0).ToString())
fmt.Println(carbon.CreateFromTimestampMilli(1, carbon.PRC).ToString())
fmt.Println(carbon.CreateFromTimestampMilli(1649735755981, carbon.PRC).ToString())

Output:

1969-12-31 23:59:59.999 +0000 UTC
1970-01-01 00:00:00 +0000 UTC
1970-01-01 08:00:00.001 +0800 CST
2022-04-12 11:55:55.981 +0800 CST

func CreateFromTimestampNano 

func CreateFromTimestampNano(timestampNano int64, timezone ...string) *Carbon

CreateFromTimestampNano creates a Carbon instance from a given timestamp with nanosecond precision.

Example 
fmt.Println(carbon.CreateFromTimestampNano(-1).ToString())
fmt.Println(carbon.CreateFromTimestampNano(0).ToString())
fmt.Println(carbon.CreateFromTimestampNano(1, carbon.PRC).ToString())
fmt.Println(carbon.CreateFromTimestampNano(1649735755981566888, carbon.PRC).ToString())

Output:

1969-12-31 23:59:59.999999999 +0000 UTC
1970-01-01 00:00:00 +0000 UTC
1970-01-01 08:00:00.000000001 +0800 CST
2022-04-12 11:55:55.981566888 +0800 CST

func EpochValue added in v2.6.7 

func EpochValue() *Carbon

EpochValue returns the unix epoch value of Carbon instance.

Example 
fmt.Println(carbon.EpochValue().ToString())

Output:

1970-01-01 00:00:00 +0000 UTC

func Max 

func Max(c1 *Carbon, c2 ...*Carbon) (c *Carbon)

Max returns the maximum Carbon instance from some given Carbon instances.

Example 
c1 := carbon.Parse("2020-08-01")
c2 := carbon.Parse("2020-08-05")
c3 := carbon.Parse("2020-08-06")
fmt.Println(carbon.Max(c1, c2, c3).ToString())

Output:

2020-08-06 00:00:00 +0000 UTC

func MaxValue added in v2.5.1 

func MaxValue() *Carbon

MaxValue returns the maximum value of Carbon instance.

Example 
fmt.Println(carbon.MaxValue().ToString())

Output:

9999-12-31 23:59:59.999999999 +0000 UTC

func Min 

func Min(c1 *Carbon, c2 ...*Carbon) (c *Carbon)

Min returns the minimum Carbon instance from some given Carbon instances.

Example 
c1 := carbon.Parse("2020-08-01")
c2 := carbon.Parse("2020-08-05")
c3 := carbon.Parse("2020-08-06")
fmt.Println(carbon.Min(c1, c2, c3).ToString())

Output:

2020-08-01 00:00:00 +0000 UTC

func MinValue added in v2.5.1 

func MinValue() *Carbon

MinValue returns the minimum value of Carbon instance.

Example 
fmt.Println(carbon.MinValue().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC

func NewCarbon 

func NewCarbon(stdTime ...StdTime) *Carbon

NewCarbon returns a new Carbon instance.

Example 
loc, _ := time.LoadLocation(carbon.PRC)

t1, _ := time.Parse(carbon.DateTimeLayout, "2020-08-05 13:14:15")
t2, _ := time.ParseInLocation(carbon.DateTimeLayout, "2020-08-05 13:14:15", loc)

fmt.Println("go zero time:", time.Time{}.String())
fmt.Println("go zero time with timezone:", time.Time{}.In(loc).String())
fmt.Println("go valid time:", t1.String())
fmt.Println("go valid time with timezone:", t2.In(loc).String())

fmt.Println("carbon zero time:", carbon.NewCarbon().ToString())
fmt.Println("carbon zero time with timezone:", carbon.NewCarbon().SetLocation(loc).ToString())
fmt.Println("carbon valid time:", carbon.NewCarbon(t1).ToString())
fmt.Println("carbon valid time with timezone:", carbon.NewCarbon(t2).SetLocation(loc).ToString())

Output:

go zero time: 0001-01-01 00:00:00 +0000 UTC
go zero time with timezone: 0001-01-01 08:05:43 +0805 LMT
go valid time: 2020-08-05 13:14:15 +0000 UTC
go valid time with timezone: 2020-08-05 13:14:15 +0800 CST
carbon zero time: 0001-01-01 00:00:00 +0000 UTC
carbon zero time with timezone: 0001-01-01 08:05:43 +0805 LMT
carbon valid time: 2020-08-05 13:14:15 +0000 UTC
carbon valid time with timezone: 2020-08-05 13:14:15 +0800 CST

func Now 

func Now(timezone ...string) *Carbon

Now returns a Carbon instance for now.

Example 
defer carbon.ClearTestNow()

carbon.SetTestNow(carbon.Parse("2020-08-05"))

fmt.Println(carbon.Now().ToString())
fmt.Println(carbon.Now(carbon.PRC).ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 08:00:00 +0800 CST

func Parse 

func Parse(value string, timezone ...string) *Carbon

Parse parses a time string as a Carbon instance by default layouts.

Note: it doesn't support parsing timestamp string.

Example 
fmt.Println(carbon.Parse("2020-8-5").ToString())
fmt.Println(carbon.Parse("2020-8-05").ToString())
fmt.Println(carbon.Parse("2020-08-05").ToString())

fmt.Println(carbon.Parse("2020-8-5 1:2:3").ToString())
fmt.Println(carbon.Parse("2020-08-05 1:2:03").ToString())
fmt.Println(carbon.Parse("2020-08-05 1:02:03").ToString())
fmt.Println(carbon.Parse("2020-08-05 01:02:03").ToString())

fmt.Println(carbon.Parse("2023-01-08T09:02:48").ToString())
fmt.Println(carbon.Parse("2023-1-8T09:02:48").ToString())
fmt.Println(carbon.Parse("2023-01-08T9:2:48").ToString())
fmt.Println(carbon.Parse("2023-01-8T9:2:48").ToString())

fmt.Println(carbon.Parse("0000-01-01 00:00:00").ToString())
fmt.Println(carbon.Parse("0001-01-01 00:00:00").ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 00:00:00 +0000 UTC
2020-08-05 00:00:00 +0000 UTC
2020-08-05 01:02:03 +0000 UTC
2020-08-05 01:02:03 +0000 UTC
2020-08-05 01:02:03 +0000 UTC
2020-08-05 01:02:03 +0000 UTC
2023-01-08 09:02:48 +0000 UTC
2023-01-08 09:02:48 +0000 UTC
2023-01-08 09:02:48 +0000 UTC
2023-01-08 09:02:48 +0000 UTC
0000-01-01 00:00:00 +0000 UTC
0001-01-01 00:00:00 +0000 UTC

func ParseByFormat 

func ParseByFormat(value, format string, timezone ...string) *Carbon

ParseByFormat parses a time string as a Carbon instance by a confirmed format.

Note: If the letter used conflicts with the format sign, please use the escape character "\" to escape the letter

Example 
fmt.Println(carbon.ParseByFormat("2020-08-05", carbon.DateFormat).ToString())
fmt.Println(carbon.ParseByFormat("2020-08-05 13:14:15", carbon.DateTimeFormat, carbon.PRC).ToString())
fmt.Println(carbon.ParseByFormat("2020|08|05 13:14:15", "Y|m|d H:i:s").ToString())

fmt.Println(carbon.ParseByFormat("It is 2020-08-05 13:14:15", "\\I\\t \\i\\s Y-m-d H:i:s").ToString())
fmt.Println(carbon.ParseByFormat("今天是 2020年08月05日13时14分15秒", "今天是 Y年m月d日H时i分s秒").ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 13:14:15 +0800 CST
2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0000 UTC

func ParseByFormats added in v2.6.5 

func ParseByFormats(value string, formats []string, timezone ...string) *Carbon

ParseByFormats parses a time string as a Carbon instance by multiple fuzzy formats.

Note: it doesn't support parsing timestamp string.

Example 
c := carbon.ParseByFormats("2020|08|05 13|14|15", []string{"Y|m|d H|i|s", "y|m|d h|i|s"})
fmt.Println(c.ToString())
fmt.Println(c.CurrentLayout())

Output:

2020-08-05 13:14:15 +0000 UTC
2006|01|02 15|04|05

func ParseByLayout 

func ParseByLayout(value, layout string, timezone ...string) *Carbon

ParseByLayout parses a time string as a Carbon instance by a confirmed layout.

Note: it doesn't support parsing timestamp string.

Example 
fmt.Println(carbon.ParseByLayout("2020-08-05", carbon.DateLayout).ToString())
fmt.Println(carbon.ParseByLayout("2020-08-05 13:14:15", carbon.DateTimeLayout, carbon.PRC).ToString())
fmt.Println(carbon.ParseByLayout("2020|08|05 13:14:15", "2006|01|02 15:04:05").ToString())

fmt.Println(carbon.ParseByLayout("It is 2020-08-05 13:14:15", "It is 2006-01-02 15:04:05").ToString())
fmt.Println(carbon.ParseByLayout("今天是 2020年08月05日13时14分15秒", "今天是 2006年01月02日15时04分05秒").ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 13:14:15 +0800 CST
2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0000 UTC

func ParseByLayouts added in v2.6.5 

func ParseByLayouts(value string, layouts []string, timezone ...string) *Carbon

ParseByLayouts parses a time string as a Carbon instance by multiple fuzzy layouts.

Note: it doesn't support parsing timestamp string.

Example 
c := carbon.ParseByLayouts("2020|08|05 13|14|15", []string{"2006|01|02 15|04|05", "2006|1|2 3|4|5"})
fmt.Println(c.ToString())
fmt.Println(c.CurrentLayout())

Output:

2020-08-05 13:14:15 +0000 UTC
2006|01|02 15|04|05

func SetFormat added in v2.6.0 

func SetFormat(format string) *Carbon

SetFormat sets globally default format.

Example 
defer carbon.SetFormat(carbon.DateTimeFormat)

fmt.Println("current layout:", carbon.SetFormat(carbon.DateTimeFormat).CurrentLayout())
fmt.Println("current layout:", carbon.SetFormat(carbon.TimeFormat).CurrentLayout())

Output:

current layout: 2006-01-02 15:04:05
current layout: 15:04:05

func SetLayout added in v2.6.0 

func SetLayout(layout string) *Carbon

SetLayout sets globally default layout.

Example 
defer carbon.SetLayout(carbon.DateTimeLayout)

fmt.Println("current layout:", carbon.SetLayout(carbon.DateTimeLayout).CurrentLayout())
fmt.Println("current layout:", carbon.SetLayout(carbon.TimeLayout).CurrentLayout())

Output:

current layout: 2006-01-02 15:04:05
current layout: 15:04:05

func SetLocale 

func SetLocale(locale string) *Carbon

SetLocale sets globally default locale.

Example 
defer carbon.SetLocale("en")

carbon.SetLocale("zh-CN")

c := carbon.Parse("2020-08-05")

fmt.Println(c.Constellation())
fmt.Println(c.Season())
fmt.Println(c.ToMonthString())
fmt.Println(c.ToShortMonthString())
fmt.Println(c.ToWeekString())
fmt.Println(c.ToShortWeekString())

Output:

狮子座
夏季
八月
8月
星期三
周三

func SetLocation 

func SetLocation(loc *Location) *Carbon

SetLocation sets globally default location.

Example 
defer carbon.SetLocation(time.UTC)

utcTZ, _ := time.LoadLocation(carbon.UTC)
fmt.Println("UTC zone location:", carbon.SetLocation(utcTZ).Timezone())
fmt.Println("UTC zone name:", carbon.SetLocation(utcTZ).ZoneName())
fmt.Println("UTC zone offset:", carbon.SetLocation(utcTZ).ZoneOffset())

prcTZ, _ := time.LoadLocation(carbon.PRC)
fmt.Println("PRC zone location:", carbon.SetLocation(prcTZ).Timezone())
fmt.Println("PRC zone name:", carbon.SetLocation(prcTZ).ZoneName())
fmt.Println("PRC zone offset:", carbon.SetLocation(prcTZ).ZoneOffset())

japanTZ, _ := time.LoadLocation(carbon.Japan)
fmt.Println("Japan zone location:", carbon.SetLocation(japanTZ).Timezone())
fmt.Println("Japan zone name:", carbon.SetLocation(japanTZ).ZoneName())
fmt.Println("Japan zone offset:", carbon.SetLocation(japanTZ).ZoneOffset())

Output:

UTC zone location: UTC
UTC zone name: UTC
UTC zone offset: 0
PRC zone location: PRC
PRC zone name: LMT
PRC zone offset: 29143
Japan zone location: Japan
Japan zone name: LMT
Japan zone offset: 33539

func SetTimezone 

func SetTimezone(name string) *Carbon

SetTimezone sets globally default timezone.

Example 
defer carbon.SetTimezone(carbon.UTC)

fmt.Println("UTC zone location:", carbon.SetTimezone(carbon.UTC).Timezone())
fmt.Println("UTC zone name:", carbon.SetTimezone(carbon.UTC).ZoneName())
fmt.Println("UTC zone offset:", carbon.SetTimezone(carbon.UTC).ZoneOffset())

fmt.Println("PRC zone location:", carbon.SetTimezone(carbon.PRC).Timezone())
fmt.Println("PRC zone name:", carbon.SetTimezone(carbon.PRC).ZoneName())
fmt.Println("PRC zone offset:", carbon.SetTimezone(carbon.PRC).ZoneOffset())

fmt.Println("Japan zone location:", carbon.SetTimezone(carbon.Japan).Timezone())
fmt.Println("Japan zone name:", carbon.SetTimezone(carbon.Japan).ZoneName())
fmt.Println("Japan zone offset:", carbon.SetTimezone(carbon.Japan).ZoneOffset())

Output:

UTC zone location: UTC
UTC zone name: UTC
UTC zone offset: 0
PRC zone location: PRC
PRC zone name: LMT
PRC zone offset: 29143
Japan zone location: Japan
Japan zone name: LMT
Japan zone offset: 33539

func SetWeekStartsAt 

func SetWeekStartsAt(weekday Weekday) *Carbon

SetWeekStartsAt sets globally default start day of the week.

Example 
defer carbon.SetWeekStartsAt(carbon.Monday)

fmt.Println(carbon.SetWeekStartsAt(carbon.Sunday).WeekStartsAt())
fmt.Println(carbon.SetWeekStartsAt(carbon.Monday).WeekStartsAt())

Output:

Sunday
Monday

func SetWeekendDays added in v2.6.3 

func SetWeekendDays(weekDays []Weekday) *Carbon

SetWeekendDays sets globally default weekend days of the week.

Example 
defer carbon.SetWeekendDays([]carbon.Weekday{
	carbon.Saturday, carbon.Sunday,
})

carbon.SetWeekendDays([]carbon.Weekday{
	carbon.Saturday,
})
fmt.Println(carbon.Parse("2025-04-12").IsWeekend())
fmt.Println(carbon.Parse("2025-04-13").IsWeekend())

carbon.SetWeekendDays([]carbon.Weekday{
	carbon.Sunday,
})
fmt.Println(carbon.Parse("2025-04-12").IsWeekend())
fmt.Println(carbon.Parse("2025-04-13").IsWeekend())

Output:

true
false
false
true

func Tomorrow 

func Tomorrow(timezone ...string) *Carbon

Tomorrow returns a Carbon instance for tomorrow.

Example 
defer carbon.ClearTestNow()

carbon.SetTestNow(carbon.Parse("2020-08-05"))

fmt.Println(carbon.Tomorrow().ToString())
fmt.Println(carbon.Tomorrow(carbon.PRC).ToString())

Output:

2020-08-06 00:00:00 +0000 UTC
2020-08-06 08:00:00 +0800 CST

func Yesterday 

func Yesterday(timezone ...string) *Carbon

Yesterday returns a Carbon instance for yesterday.

Example 
defer carbon.ClearTestNow()

carbon.SetTestNow(carbon.Parse("2020-08-05"))

fmt.Println(carbon.Yesterday().ToString())
fmt.Println(carbon.Yesterday(carbon.PRC).ToString())

Output:

2020-08-04 00:00:00 +0000 UTC
2020-08-04 08:00:00 +0800 CST

func ZeroValue added in v2.6.7 

func ZeroValue() *Carbon

ZeroValue returns the zero value of Carbon instance.

Example 
fmt.Println(carbon.ZeroValue().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC

func (*Carbon) AddCenturies 

func (c *Carbon) AddCenturies(centuries int) *Carbon

AddCenturies adds some centuries.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturies(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturies(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturies(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2120-01-01 13:14:15 +0000 UTC
2220-01-01 13:14:15 +0000 UTC

func (*Carbon) AddCenturiesNoOverflow 

func (c *Carbon) AddCenturiesNoOverflow(centuries int) *Carbon

AddCenturiesNoOverflow adds some centuries without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturiesNoOverflow(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturiesNoOverflow(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturiesNoOverflow(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2120-01-01 13:14:15 +0000 UTC
2220-01-01 13:14:15 +0000 UTC

func (*Carbon) AddCentury 

func (c *Carbon) AddCentury() *Carbon

AddCentury adds one century.

Example 
defer carbon.ClearTestNow()

fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCentury().ToString())

Output:

2120-01-01 13:14:15 +0000 UTC

func (*Carbon) AddCenturyNoOverflow 

func (c *Carbon) AddCenturyNoOverflow() *Carbon

AddCenturyNoOverflow adds one century without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddCenturyNoOverflow().ToString())

Output:

2120-01-01 13:14:15 +0000 UTC

func (*Carbon) AddDay 

func (c *Carbon) AddDay() *Carbon

AddDay adds one day.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddDay().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddDay().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddDay().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddDay().ToDateString())

Output:

2020-01-02
2020-02-29
2020-03-01
2020-12-01

func (*Carbon) AddDays 

func (c *Carbon) AddDays(days int) *Carbon

AddDays adds some days.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddDays(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddDays(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddDays(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddDays(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddDays(2).ToDateString())

Output:

2020-01-01
2020-01-02
2020-01-03
2020-03-03
2020-09-02

func (*Carbon) AddDecade 

func (c *Carbon) AddDecade() *Carbon

AddDecade adds one decade.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecade().ToString())

Output:

2030-01-01 13:14:15 +0000 UTC

func (*Carbon) AddDecadeNoOverflow 

func (c *Carbon) AddDecadeNoOverflow() *Carbon

AddDecadeNoOverflow adds one decade without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecadeNoOverflow().ToString())

Output:

2030-01-01 13:14:15 +0000 UTC

func (*Carbon) AddDecades 

func (c *Carbon) AddDecades(decades int) *Carbon

AddDecades adds some decades.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecades(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecades(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecades(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2030-01-01 13:14:15 +0000 UTC
2040-01-01 13:14:15 +0000 UTC

func (*Carbon) AddDecadesNoOverflow 

func (c *Carbon) AddDecadesNoOverflow(decades int) *Carbon

AddDecadesNoOverflow adds some decades without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecadesNoOverflow(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecadesNoOverflow(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDecadesNoOverflow(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2030-01-01 13:14:15 +0000 UTC
2040-01-01 13:14:15 +0000 UTC

func (*Carbon) AddDuration 

func (c *Carbon) AddDuration(duration string) *Carbon

AddDuration adds duration.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDuration("10h").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDuration("10.5h").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDuration("10m").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddDuration("10.5m").ToString())

Output:

2020-01-01 23:14:15 +0000 UTC
2020-01-01 23:44:15 +0000 UTC
2020-01-01 13:24:15 +0000 UTC
2020-01-01 13:24:45 +0000 UTC

func (*Carbon) AddHour 

func (c *Carbon) AddHour() *Carbon

AddHour adds one hour.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddHour().ToString())

Output:

2020-08-05 14:14:15 +0000 UTC

func (*Carbon) AddHours 

func (c *Carbon) AddHours(hours int) *Carbon

AddHours adds some hours.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddHours(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddHours(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddHours(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 14:14:15 +0000 UTC
2020-01-01 15:14:15 +0000 UTC

func (*Carbon) AddMicrosecond 

func (c *Carbon) AddMicrosecond() *Carbon

AddMicrosecond adds one microsecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddMicrosecond().ToString())

Output:

2020-08-05 13:14:15.000001 +0000 UTC

func (*Carbon) AddMicroseconds 

func (c *Carbon) AddMicroseconds(microseconds int) *Carbon

AddMicroseconds adds some microseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMicroseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMicroseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMicroseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:15.000001 +0000 UTC
2020-01-01 13:14:15.000002 +0000 UTC

func (*Carbon) AddMillisecond 

func (c *Carbon) AddMillisecond() *Carbon

AddMillisecond adds one millisecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddMillisecond().ToString())

Output:

2020-08-05 13:14:15.001 +0000 UTC

func (*Carbon) AddMilliseconds 

func (c *Carbon) AddMilliseconds(milliseconds int) *Carbon

AddMilliseconds adds some milliseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMilliseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMilliseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMilliseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:15.001 +0000 UTC
2020-01-01 13:14:15.002 +0000 UTC

func (*Carbon) AddMinute 

func (c *Carbon) AddMinute() *Carbon

AddMinute adds one minute.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddMinute().ToString())

Output:

2020-08-05 13:15:15 +0000 UTC

func (*Carbon) AddMinutes 

func (c *Carbon) AddMinutes(minutes int) *Carbon

AddMinutes adds some minutes.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMinutes(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMinutes(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddMinutes(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:15:15 +0000 UTC
2020-01-01 13:16:15 +0000 UTC

func (*Carbon) AddMonth 

func (c *Carbon) AddMonth() *Carbon

AddMonth adds one month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddMonth().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddMonth().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddMonth().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddMonth().ToDateString())

Output:

2020-02-01
2020-03-28
2020-03-29
2020-12-30

func (*Carbon) AddMonthNoOverflow 

func (c *Carbon) AddMonthNoOverflow() *Carbon

AddMonthNoOverflow adds one month without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddMonthNoOverflow().ToDateString())

Output:

2020-02-01
2020-03-28
2020-03-29
2020-12-30

func (*Carbon) AddMonths 

func (c *Carbon) AddMonths(months int) *Carbon

AddMonths adds some months.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddMonths(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddMonths(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddMonths(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddMonths(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddMonths(2).ToDateString())

Output:

2020-01-01
2020-02-01
2020-03-01
2020-05-29
2020-10-31

func (*Carbon) AddMonthsNoOverflow 

func (c *Carbon) AddMonthsNoOverflow(months int) *Carbon

AddMonthsNoOverflow adds some months without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddMonthsNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddMonthsNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddMonthsNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddMonthsNoOverflow(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddMonthsNoOverflow(2).ToDateString())

Output:

2020-01-01
2020-02-01
2020-03-01
2020-05-29
2020-10-31

func (*Carbon) AddNanosecond 

func (c *Carbon) AddNanosecond() *Carbon

AddNanosecond adds one nanosecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddNanosecond().ToString())

Output:

2020-08-05 13:14:15.000000001 +0000 UTC

func (*Carbon) AddNanoseconds 

func (c *Carbon) AddNanoseconds(nanoseconds int) *Carbon

AddNanoseconds adds some nanoseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddNanoseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddNanoseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddNanoseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:15.000000001 +0000 UTC
2020-01-01 13:14:15.000000002 +0000 UTC

func (*Carbon) AddQuarter 

func (c *Carbon) AddQuarter() *Carbon

AddQuarter adds one quarter

Example 
fmt.Println(carbon.Parse("2020-01-01").AddQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddQuarter().ToDateString())

Output:

2020-04-01
2020-05-28
2020-05-29
2021-03-02

func (*Carbon) AddQuarterNoOverflow 

func (c *Carbon) AddQuarterNoOverflow() *Carbon

AddQuarterNoOverflow adds one quarter without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddQuarterNoOverflow().ToDateString())

Output:

2020-04-01
2020-05-28
2020-05-29
2021-02-28

func (*Carbon) AddQuarters 

func (c *Carbon) AddQuarters(quarters int) *Carbon

AddQuarters adds some quarters

Example 
fmt.Println(carbon.Parse("2020-01-01").AddQuarters(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddQuarters(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddQuarters(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddQuarters(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddQuarters(2).ToDateString())

Output:

2020-01-01
2020-04-01
2020-07-01
2020-11-29
2021-03-03

func (*Carbon) AddQuartersNoOverflow 

func (c *Carbon) AddQuartersNoOverflow(quarters int) *Carbon

AddQuartersNoOverflow adds quarters without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddQuartersNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddQuartersNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddQuartersNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddQuartersNoOverflow(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddQuartersNoOverflow(2).ToDateString())

Output:

2020-01-01
2020-04-01
2020-07-01
2020-11-29
2021-02-28

func (*Carbon) AddSecond 

func (c *Carbon) AddSecond() *Carbon

AddSecond adds one second.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").AddSecond().ToString())

Output:

2020-08-05 13:14:16 +0000 UTC

func (*Carbon) AddSeconds 

func (c *Carbon) AddSeconds(seconds int) *Carbon

AddSeconds adds some seconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddSeconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddSeconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").AddSeconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:16 +0000 UTC
2020-01-01 13:14:17 +0000 UTC

func (*Carbon) AddWeek 

func (c *Carbon) AddWeek() *Carbon

AddWeek adds one week.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddWeek().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddWeek().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddWeek().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").AddWeek().ToDateString())

Output:

2020-01-08
2020-03-06
2020-03-07
2020-12-07

func (*Carbon) AddWeeks 

func (c *Carbon) AddWeeks(weeks int) *Carbon

AddWeeks adds some weeks.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddWeeks(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddWeeks(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddWeeks(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddWeeks(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").AddWeeks(2).ToDateString())

Output:

2020-01-01
2020-01-08
2020-01-15
2020-03-21
2020-09-14

func (*Carbon) AddYear 

func (c *Carbon) AddYear() *Carbon

AddYear adds one year.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddYear().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddYear().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddYear().ToDateString())

Output:

2021-01-01
2021-02-28
2021-03-01

func (*Carbon) AddYearNoOverflow 

func (c *Carbon) AddYearNoOverflow() *Carbon

AddYearNoOverflow adds one year without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddYearNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").AddYearNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddYearNoOverflow().ToDateString())

Output:

2021-01-01
2021-02-28
2021-02-28

func (*Carbon) AddYears 

func (c *Carbon) AddYears(years int) *Carbon

AddYears adds some years.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddYears(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddYears(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddYears(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddYears(3).ToDateString())

Output:

2020-01-01
2021-01-01
2022-01-01
2023-03-01

func (*Carbon) AddYearsNoOverflow 

func (c *Carbon) AddYearsNoOverflow(years int) *Carbon

AddYearsNoOverflow adds some years without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").AddYearsNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddYearsNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").AddYearsNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").AddYearsNoOverflow(3).ToDateString())

Output:

2020-01-01
2021-01-01
2022-01-01
2023-02-28

func (*Carbon) Age 

func (c *Carbon) Age() int

Age gets age like 18.

Example 
fmt.Println(carbon.Now().AddYears(18).Age())
fmt.Println(carbon.Now().SubYears(18).Age())

Output:

0
18

func (*Carbon) Between 

func (c *Carbon) Between(start *Carbon, end *Carbon) bool

Between reports whether between two times, including the start and end time.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Between(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Between(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Between(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Between(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Between(carbon.Parse("2021-08-05 22:00:00"), carbon.Parse("2019-08-05 22:00:00")))

Output:

true
false
false
false
false

func (*Carbon) BetweenIncludedBoth 

func (c *Carbon) BetweenIncludedBoth(start *Carbon, end *Carbon) bool

BetweenIncludedBoth reports whether between two times, including the start and end time.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedBoth(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedBoth(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedBoth(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedBoth(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedBoth(carbon.Parse("2022-08-05 22:00:00"), carbon.Parse("2021-08-05 22:00:00")))

Output:

true
true
true
true
false

func (*Carbon) BetweenIncludedEnd 

func (c *Carbon) BetweenIncludedEnd(start *Carbon, end *Carbon) bool

BetweenIncludedEnd reports whether between two times, including the end time.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedEnd(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedEnd(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedEnd(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedEnd(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedEnd(carbon.Parse("2022-08-05 22:00:00"), carbon.Parse("2021-08-05 22:00:00")))

Output:

false
true
false
true
false

func (*Carbon) BetweenIncludedStart 

func (c *Carbon) BetweenIncludedStart(start *Carbon, end *Carbon) bool

BetweenIncludedStart reports whether between two times, including the start time.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedStart(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedStart(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedStart(carbon.Parse("2020-08-05 22:00:00"), carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedStart(carbon.Parse("2020-08-05 21:00:00"), carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").BetweenIncludedStart(carbon.Parse("2022-08-05 22:00:00"), carbon.Parse("2021-08-05 22:00:00")))

Output:

false
true
true
false
false

func (*Carbon) Century 

func (c *Carbon) Century() int

Century gets current century like 21.

Example 
fmt.Println(carbon.Parse("1990-08-05").Century())
fmt.Println(carbon.Parse("2021-08-05").Century())

Output:

20
21

func (*Carbon) Closest 

func (c *Carbon) Closest(c1 *Carbon, c2 ...*Carbon) *Carbon

Closest returns the closest Carbon instance from some given Carbon instances.

Example 
c1 := carbon.Parse("2020-08-01")
c2 := carbon.Parse("2020-08-05")
c3 := carbon.Parse("2020-08-06")
fmt.Println(c1.Closest(c2, c3).ToString())
fmt.Println(c2.Closest(c1, c3).ToString())
fmt.Println(c3.Closest(c2, c1).ToString())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-06 00:00:00 +0000 UTC
2020-08-05 00:00:00 +0000 UTC

func (*Carbon) Compare 

func (c *Carbon) Compare(operator string, t *Carbon) bool

Compare compares by an operator.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Compare(">=", carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Compare("<", carbon.Parse("2020-08-05 22:00:00")))

Output:

true
false

func (*Carbon) Constellation 

func (c *Carbon) Constellation() string

Constellation gets constellation name like "Aries", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-01-05").Constellation())
fmt.Println(carbon.Parse("2020-02-05").Constellation())
fmt.Println(carbon.Parse("2020-03-05").Constellation())
fmt.Println(carbon.Parse("2020-04-05").Constellation())
fmt.Println(carbon.Parse("2020-05-05").Constellation())
fmt.Println(carbon.Parse("2020-06-05").Constellation())
fmt.Println(carbon.Parse("2020-07-05").Constellation())
fmt.Println(carbon.Parse("2020-08-05").Constellation())
fmt.Println(carbon.Parse("2020-09-05").Constellation())
fmt.Println(carbon.Parse("2020-10-05").Constellation())
fmt.Println(carbon.Parse("2020-11-05").Constellation())
fmt.Println(carbon.Parse("2020-12-05").Constellation())

Output:

Capricorn
Aquarius
Pisces
Aries
Taurus
Gemini
Cancer
Leo
Virgo
Libra
Scorpio
Sagittarius

func (*Carbon) Copy added in v2.6.0 

func (c *Carbon) Copy() *Carbon

Copy returns a copy of the Carbon instance.

Example 
oldCarbon := carbon.Parse("2020-08-05")
newCarbon := oldCarbon.Copy()

oldCarbon = oldCarbon.AddDay().SetLayout(carbon.DateTimeLayout).SetLocale("zh-CN").SetWeekStartsAt(carbon.Sunday)

fmt.Printf("old time: %s\n", oldCarbon.ToString())
fmt.Printf("new time: %s\n", newCarbon.ToString())

fmt.Printf("old layout: %s\n", oldCarbon.CurrentLayout())
fmt.Printf("new layout: %s\n", newCarbon.CurrentLayout())

fmt.Printf("old locale: %s\n", oldCarbon.Locale())
fmt.Printf("new locale: %s\n", newCarbon.Locale())

fmt.Printf("old week starts at: %s\n", oldCarbon.WeekStartsAt())
fmt.Printf("new week starts at: %s\n", newCarbon.WeekStartsAt())

Output:

old time: 2020-08-06 00:00:00 +0000 UTC
new time: 2020-08-05 00:00:00 +0000 UTC
old layout: 2006-01-02 15:04:05
new layout: 2006-01-02
old locale: zh-CN
new locale: en
old week starts at: Sunday
new week starts at: Monday

func (*Carbon) CurrentLayout added in v2.5.4 

func (c *Carbon) CurrentLayout() string

CurrentLayout returns the layout used for parsing the time string.

Example 
fmt.Println(carbon.Parse("now").CurrentLayout())
fmt.Println(carbon.ParseByLayout("13:14:15", carbon.TimeLayout).CurrentLayout())
fmt.Println(carbon.ParseByLayout("2020-08-05", carbon.DateLayout).CurrentLayout())

Output:

2006-01-02 15:04:05
15:04:05
2006-01-02

func (*Carbon) Date 

func (c *Carbon) Date() (year, month, day int)

Date gets current year, month, and day like 2020, 8, 5.

Example 
year, month, day := carbon.Parse("2020-08-05 13:14:15.999999999").Date()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)

Output:

2020
8
5

func (*Carbon) DateMicro 

func (c *Carbon) DateMicro() (year, month, day, microsecond int)

DateMicro gets current year, month, day and microsecond like 2020, 8, 5, 999999.

Example 
year, month, day, microsecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateMicro()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(microsecond)

Output:

2020
8
5
999999

func (*Carbon) DateMilli 

func (c *Carbon) DateMilli() (year, month, day, millisecond int)

DateMilli gets current year, month, day and millisecond like 2020, 8, 5, 999.

Example 
year, month, day, millisecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateMilli()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(millisecond)

Output:

2020
8
5
999

func (*Carbon) DateNano 

func (c *Carbon) DateNano() (year, month, day, nanosecond int)

DateNano gets current year, month, day and nanosecond like 2020, 8, 5, 999999999.

Example 
year, month, day, nanosecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateNano()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(nanosecond)

Output:

2020
8
5
999999999

func (*Carbon) DateTime 

func (c *Carbon) DateTime() (year, month, day, hour, minute, second int)

DateTime gets current year, month, day, hour, minute, and second like 2020, 8, 5, 13, 14, 15.

Example 
year, month, day, hour, minute, second := carbon.Parse("2020-08-05 13:14:15.999999999").DateTime()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)

Output:

2020
8
5
13
14
15

func (*Carbon) DateTimeMicro 

func (c *Carbon) DateTimeMicro() (year, month, day, hour, minute, second, microsecond int)

DateTimeMicro gets current year, month, day, hour, minute, second and microsecond like 2020, 8, 5, 13, 14, 15, 999999.

Example 
year, month, day, hour, minute, second, microsecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateTimeMicro()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(microsecond)

Output:

2020
8
5
13
14
15
999999

func (*Carbon) DateTimeMilli 

func (c *Carbon) DateTimeMilli() (year, month, day, hour, minute, second, millisecond int)

DateTimeMilli gets current year, month, day, hour, minute, second and millisecond like 2020, 8, 5, 13, 14, 15, 999.

Example 
year, month, day, hour, minute, second, millisecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateTimeMilli()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(millisecond)

Output:

2020
8
5
13
14
15
999

func (*Carbon) DateTimeNano 

func (c *Carbon) DateTimeNano() (year, month, day, hour, minute, second, nanosecond int)

DateTimeNano gets current year, month, day, hour, minute, second and nanosecond like 2020, 8, 5, 13, 14, 15, 999999999.

Example 
year, month, day, hour, minute, second, nanosecond := carbon.Parse("2020-08-05 13:14:15.999999999").DateTimeNano()

fmt.Println(year)
fmt.Println(month)
fmt.Println(day)
fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(nanosecond)

Output:

2020
8
5
13
14
15
999999999

func (*Carbon) Day 

func (c *Carbon) Day() int

Day gets current day like 5.

Example 
fmt.Println(carbon.Parse("2020-08-05").Day())

Output:

5

func (*Carbon) DayOfMonth 

func (c *Carbon) DayOfMonth() int

DayOfMonth gets day of month like 30.

Example 
fmt.Println(carbon.Parse("2020-01-01").DayOfMonth())
fmt.Println(carbon.Parse("2020-01-05").DayOfMonth())
fmt.Println(carbon.Parse("2020-01-31").DayOfMonth())

Output:

1
5
31

func (*Carbon) DayOfWeek 

func (c *Carbon) DayOfWeek() int

DayOfWeek gets day of week like 6, start from 1.

Example 
fmt.Println(carbon.Parse("2020-08-03").DayOfWeek())
fmt.Println(carbon.Parse("2020-08-04").DayOfWeek())
fmt.Println(carbon.Parse("2020-08-05").DayOfWeek())

Output:

1
2
3

func (*Carbon) DayOfYear 

func (c *Carbon) DayOfYear() int

DayOfYear gets day of year like 365.

Example 
fmt.Println(carbon.Parse("2020-01-05").DayOfYear())
fmt.Println(carbon.Parse("2020-02-05").DayOfYear())
fmt.Println(carbon.Parse("2020-03-05").DayOfYear())
fmt.Println(carbon.Parse("2020-04-05").DayOfYear())

Output:

5
36
65
96

func (*Carbon) DaysInMonth 

func (c *Carbon) DaysInMonth() int

DaysInMonth gets total days in month like 30.

Example 
fmt.Println(carbon.Parse("2020-01-05").DaysInMonth())
fmt.Println(carbon.Parse("2020-02-05").DaysInMonth())
fmt.Println(carbon.Parse("2020-03-05").DaysInMonth())
fmt.Println(carbon.Parse("2020-04-05").DaysInMonth())

Output:

31
29
31
30

func (*Carbon) DaysInYear 

func (c *Carbon) DaysInYear() int

DaysInYear gets total days in year like 365.

Example 
fmt.Println(carbon.Parse("2020-08-05").DaysInYear())
fmt.Println(carbon.Parse("2021-08-05").DaysInYear())

Output:

366
365

func (*Carbon) Decade 

func (c *Carbon) Decade() int

Decade gets current decade like 20.

Example 
fmt.Println(carbon.Parse("2010-08-05").Decade())
fmt.Println(carbon.Parse("2011-08-05").Decade())
fmt.Println(carbon.Parse("2020-08-05").Decade())
fmt.Println(carbon.Parse("2021-08-05").Decade())

Output:

10
10
20
20

func (*Carbon) DiffAbsInDays 

func (c *Carbon) DiffAbsInDays(carbon ...*Carbon) int64

DiffAbsInDays gets the difference in days with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInDays(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInDays(carbon.Parse("2020-08-04 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInDays(carbon.Parse("2020-08-06 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInDays(carbon.Parse("2020-08-04 13:00:00")))

Output:

0
0
1
1

func (*Carbon) DiffAbsInDuration 

func (c *Carbon) DiffAbsInDuration(carbon ...*Carbon) Duration

DiffAbsInDuration gets the difference in duration with absolute value.

Example 
defer carbon.ClearTestNow()
now := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(now)

fmt.Println(now.Copy().DiffAbsInDuration(now))
fmt.Println(now.Copy().AddYearsNoOverflow(1).DiffAbsInDuration(now).String())
fmt.Println(now.Copy().SubYearsNoOverflow(1).DiffAbsInDuration(now).String())
fmt.Println(now.Copy().AddMonthsNoOverflow(1).DiffAbsInDuration(now).String())
fmt.Println(now.Copy().SubMonthsNoOverflow(1).DiffAbsInDuration(now).String())
fmt.Println(now.Copy().AddDays(1).DiffAbsInDuration(now).String())
fmt.Println(now.Copy().SubDays(1).DiffAbsInDuration(now).String())

Output:

0s
8760h0m0s
8784h0m0s
744h0m0s
744h0m0s
24h0m0s
24h0m0s

func (*Carbon) DiffAbsInHours 

func (c *Carbon) DiffAbsInHours(carbon ...*Carbon) int64

DiffAbsInHours gets the difference in hours with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInHours(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInHours(carbon.Parse("2020-08-05 14:13:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInHours(carbon.Parse("2020-08-05 12:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInHours(carbon.Parse("2020-08-05 14:14:15")))

Output:

0
0
1
1

func (*Carbon) DiffAbsInMinutes 

func (c *Carbon) DiffAbsInMinutes(carbon ...*Carbon) int64

DiffAbsInMinutes gets the difference in minutes with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMinutes(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMinutes(carbon.Parse("2020-08-05 13:15:10")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMinutes(carbon.Parse("2020-08-05 13:13:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMinutes(carbon.Parse("2020-08-05 13:15:15")))

Output:

0
0
1
1

func (*Carbon) DiffAbsInMonths 

func (c *Carbon) DiffAbsInMonths(carbon ...*Carbon) int64

DiffAbsInMonths gets the difference in months with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMonths(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMonths(carbon.Parse("2020-07-28 13:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMonths(carbon.Parse("2020-09-06 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInMonths(carbon.Parse("2018-08-28 13:14:59")))

Output:

0
0
1
23

func (*Carbon) DiffAbsInSeconds 

func (c *Carbon) DiffAbsInSeconds(carbon ...*Carbon) int64

DiffAbsInSeconds gets the difference in seconds with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInSeconds(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInSeconds(carbon.Parse("2020-08-05 13:14:15.999999")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInSeconds(carbon.Parse("2020-08-05 13:14:20")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInSeconds(carbon.Parse("2020-08-05 13:14:10")))

Output:

0
0
5
5

func (*Carbon) DiffAbsInString 

func (c *Carbon) DiffAbsInString(carbon ...*Carbon) string

DiffAbsInString gets the difference in string with absolute value, i18n is supported.

Example 
defer carbon.ClearTestNow()
now := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(now)

fmt.Println(now.Copy().DiffAbsInString(now))
fmt.Println(now.Copy().AddYearsNoOverflow(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubYearsNoOverflow(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddMonthsNoOverflow(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubMonthsNoOverflow(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddWeeks(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubWeeks(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddDays(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubDays(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddHours(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubHours(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddMinutes(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubMinutes(1).DiffAbsInString(now))
fmt.Println(now.Copy().AddSeconds(1).DiffAbsInString(now))
fmt.Println(now.Copy().SubSeconds(1).DiffAbsInString(now))

Output:

just now
1 year
1 year
1 month
1 month
1 week
1 week
1 day
1 day
1 hour
1 hour
1 minute
1 minute
1 second
1 second

func (*Carbon) DiffAbsInWeeks 

func (c *Carbon) DiffAbsInWeeks(carbon ...*Carbon) int64

DiffAbsInWeeks gets the difference in weeks with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInWeeks(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInWeeks(carbon.Parse("2020-07-28 13:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInWeeks(carbon.Parse("2020-08-12 13:14:15")))

Output:

0
1
1

func (*Carbon) DiffAbsInYears 

func (c *Carbon) DiffAbsInYears(carbon ...*Carbon) int64

DiffAbsInYears gets the difference in years with absolute value.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInYears(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-12-31 13:14:15").DiffAbsInYears(carbon.Parse("2021-01-01 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInYears(carbon.Parse("2021-08-28 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffAbsInYears(carbon.Parse("2018-08-28 13:14:59")))

Output:

0
0
1
1

func (*Carbon) DiffForHumans 

func (c *Carbon) DiffForHumans(carbon ...*Carbon) string

DiffForHumans gets the difference in a human-readable format, i18n is supported.

Example 
defer carbon.ClearTestNow()
now := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(now)

fmt.Println(now.Copy().DiffForHumans(now))
fmt.Println(carbon.Parse("2020-08-03 13:14:15").DiffForHumans())
fmt.Println(carbon.Parse("2020-08-07 13:14:15").DiffForHumans())
fmt.Println(now.Copy().AddYearsNoOverflow(1).DiffForHumans(now))
fmt.Println(now.Copy().SubYearsNoOverflow(1).DiffForHumans(now))
fmt.Println(now.Copy().AddMonthsNoOverflow(1).DiffForHumans(now))
fmt.Println(now.Copy().SubMonthsNoOverflow(1).DiffForHumans(now))
fmt.Println(now.Copy().AddDays(1).DiffForHumans(now))
fmt.Println(now.Copy().SubDays(1).DiffForHumans(now))

Output:

just now
2 days ago
2 days from now
1 year after
1 year before
1 month after
1 month before
1 day after
1 day before

func (*Carbon) DiffInDays 

func (c *Carbon) DiffInDays(carbon ...*Carbon) int64

DiffInDays gets the difference in days.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInDays(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInDays(carbon.Parse("2020-08-04 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInDays(carbon.Parse("2020-08-06 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInDays(carbon.Parse("2020-08-04 13:00:00")))

Output:

0
0
1
-1

func (*Carbon) DiffInDuration 

func (c *Carbon) DiffInDuration(carbon ...*Carbon) Duration

DiffInDuration gets the difference in duration.

Example 
defer carbon.ClearTestNow()
now := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(now)

fmt.Println(now.Copy().DiffInDuration(now))
fmt.Println(now.Copy().AddYearsNoOverflow(1).DiffInDuration(now).String())
fmt.Println(now.Copy().SubYearsNoOverflow(1).DiffInDuration(now).String())
fmt.Println(now.Copy().AddMonthsNoOverflow(1).DiffInDuration(now).String())
fmt.Println(now.Copy().SubMonthsNoOverflow(1).DiffInDuration(now).String())
fmt.Println(now.Copy().AddDays(1).DiffInDuration(now).String())
fmt.Println(now.Copy().SubDays(1).DiffInDuration(now).String())

Output:

0s
-8760h0m0s
8784h0m0s
-744h0m0s
744h0m0s
-24h0m0s
24h0m0s

func (*Carbon) DiffInHours 

func (c *Carbon) DiffInHours(carbon ...*Carbon) int64

DiffInHours gets the difference in hours.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInHours(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInHours(carbon.Parse("2020-08-05 14:13:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInHours(carbon.Parse("2020-08-05 12:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInHours(carbon.Parse("2020-08-05 14:14:15")))

Output:

0
0
-1
1

func (*Carbon) DiffInMinutes 

func (c *Carbon) DiffInMinutes(carbon ...*Carbon) int64

DiffInMinutes gets the difference in minutes.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMinutes(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMinutes(carbon.Parse("2020-08-05 13:15:10")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMinutes(carbon.Parse("2020-08-05 13:13:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMinutes(carbon.Parse("2020-08-05 13:15:15")))

Output:

0
0
-1
1

func (*Carbon) DiffInMonths 

func (c *Carbon) DiffInMonths(carbon ...*Carbon) int64

DiffInMonths gets the difference in months.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMonths(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMonths(carbon.Parse("2020-07-28 13:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMonths(carbon.Parse("2020-09-06 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInMonths(carbon.Parse("2018-08-28 13:14:59")))

Output:

0
0
1
-23

func (*Carbon) DiffInSeconds 

func (c *Carbon) DiffInSeconds(carbon ...*Carbon) int64

DiffInSeconds gets the difference in seconds.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInSeconds(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInSeconds(carbon.Parse("2020-08-05 13:14:15.999999")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInSeconds(carbon.Parse("2020-08-05 13:14:20")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInSeconds(carbon.Parse("2020-08-05 13:14:10")))

Output:

0
0
5
-5

func (*Carbon) DiffInString 

func (c *Carbon) DiffInString(carbon ...*Carbon) string

DiffInString gets the difference in string, i18n is supported.

Example 
defer carbon.ClearTestNow()
now := carbon.Parse("2020-08-05 13:14:15")
carbon.SetTestNow(now)

fmt.Println(now.Copy().DiffInString(now))
fmt.Println(now.Copy().AddYearsNoOverflow(1).DiffInString(now))
fmt.Println(now.Copy().SubYearsNoOverflow(1).DiffInString(now))
fmt.Println(now.Copy().AddMonthsNoOverflow(1).DiffInString(now))
fmt.Println(now.Copy().SubMonthsNoOverflow(1).DiffInString(now))
fmt.Println(now.Copy().AddWeeks(1).DiffInString(now))
fmt.Println(now.Copy().SubWeeks(1).DiffInString(now))
fmt.Println(now.Copy().AddDays(1).DiffInString(now))
fmt.Println(now.Copy().SubDays(1).DiffInString(now))
fmt.Println(now.Copy().AddHours(1).DiffInString(now))
fmt.Println(now.Copy().SubHours(1).DiffInString(now))
fmt.Println(now.Copy().AddMinutes(1).DiffInString(now))
fmt.Println(now.Copy().SubMinutes(1).DiffInString(now))
fmt.Println(now.Copy().AddSeconds(1).DiffInString(now))
fmt.Println(now.Copy().SubSeconds(1).DiffInString(now))

Output:

just now
-1 year
1 year
-1 month
1 month
-1 week
1 week
-1 day
1 day
-1 hour
1 hour
-1 minute
1 minute
-1 second
1 second

func (*Carbon) DiffInWeeks 

func (c *Carbon) DiffInWeeks(carbon ...*Carbon) int64

DiffInWeeks gets the difference in weeks.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInWeeks(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInWeeks(carbon.Parse("2020-07-28 13:14:00")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInWeeks(carbon.Parse("2020-08-12 13:14:15")))

Output:

0
-1
1

func (*Carbon) DiffInYears 

func (c *Carbon) DiffInYears(carbon ...*Carbon) int64

DiffInYears gets the difference in years.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInYears(carbon.Parse("2020-08-05 13:14:15")))
fmt.Println(carbon.Parse("2020-12-31 13:14:15").DiffInYears(carbon.Parse("2021-01-01 13:14:15")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInYears(carbon.Parse("2021-08-28 13:14:59")))
fmt.Println(carbon.Parse("2020-08-05 13:14:15").DiffInYears(carbon.Parse("2018-08-28 13:14:59")))

Output:

0
0
1
-1

func (*Carbon) EndOfCentury 

func (c *Carbon) EndOfCentury() *Carbon

EndOfCentury returns a Carbon instance for end of the century.

Example 
fmt.Println(carbon.NewCarbon().EndOfCentury().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfCentury().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfCentury().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfCentury().ToString())

Output:

0099-12-31 23:59:59.999999999 +0000 UTC
2099-12-31 23:59:59.999999999 +0000 UTC
2099-12-31 23:59:59.999999999 +0000 UTC
2099-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfDay 

func (c *Carbon) EndOfDay() *Carbon

EndOfDay returns a Carbon instance for end of the day.

Example 
fmt.Println(carbon.NewCarbon().EndOfDay().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfDay().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfDay().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfDay().ToString())

Output:

0001-01-01 23:59:59.999999999 +0000 UTC
2020-01-01 23:59:59.999999999 +0000 UTC
2020-08-15 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfDecade 

func (c *Carbon) EndOfDecade() *Carbon

EndOfDecade returns a Carbon instance for end of the decade.

Example 
fmt.Println(carbon.NewCarbon().EndOfDecade().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfDecade().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfDecade().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfDecade().ToString())

Output:

0009-12-31 23:59:59.999999999 +0000 UTC
2029-12-31 23:59:59.999999999 +0000 UTC
2029-12-31 23:59:59.999999999 +0000 UTC
2029-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfHour 

func (c *Carbon) EndOfHour() *Carbon

EndOfHour returns a Carbon instance for end of the hour.

Example 
fmt.Println(carbon.NewCarbon().EndOfHour().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfHour().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfHour().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfHour().ToString())

Output:

0001-01-01 00:59:59.999999999 +0000 UTC
2020-01-01 00:59:59.999999999 +0000 UTC
2020-08-15 12:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfMinute 

func (c *Carbon) EndOfMinute() *Carbon

EndOfMinute returns a Carbon instance for end of the minute.

Example 
fmt.Println(carbon.NewCarbon().EndOfMinute().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfMinute().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfMinute().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfMinute().ToString())

Output:

0001-01-01 00:00:59.999999999 +0000 UTC
2020-01-01 00:00:59.999999999 +0000 UTC
2020-08-15 12:30:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfMonth 

func (c *Carbon) EndOfMonth() *Carbon

EndOfMonth returns a Carbon instance for end of the month.

Example 
fmt.Println(carbon.NewCarbon().EndOfMonth().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfMonth().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfMonth().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfMonth().ToString())

Output:

0001-01-31 23:59:59.999999999 +0000 UTC
2020-01-31 23:59:59.999999999 +0000 UTC
2020-08-31 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfQuarter 

func (c *Carbon) EndOfQuarter() *Carbon

EndOfQuarter returns a Carbon instance for end of the quarter.

Example 
fmt.Println(carbon.NewCarbon().EndOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfQuarter().ToString())

Output:

0001-03-31 23:59:59.999999999 +0000 UTC
2020-03-31 23:59:59.999999999 +0000 UTC
2020-09-30 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfSeason 

func (c *Carbon) EndOfSeason() *Carbon

EndOfSeason returns a Carbon instance for end of the season.

Example 
fmt.Println(carbon.Parse("2020-01-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-02-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-03-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-04-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-05-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-06-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-07-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-08-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-09-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-10-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-11-15").EndOfSeason().ToString())
fmt.Println(carbon.Parse("2020-12-15").EndOfSeason().ToString())

Output:

2020-02-29 23:59:59.999999999 +0000 UTC
2020-02-29 23:59:59.999999999 +0000 UTC
2020-05-31 23:59:59.999999999 +0000 UTC
2020-05-31 23:59:59.999999999 +0000 UTC
2020-05-31 23:59:59.999999999 +0000 UTC
2020-08-31 23:59:59.999999999 +0000 UTC
2020-08-31 23:59:59.999999999 +0000 UTC
2020-08-31 23:59:59.999999999 +0000 UTC
2020-11-30 23:59:59.999999999 +0000 UTC
2020-11-30 23:59:59.999999999 +0000 UTC
2020-11-30 23:59:59.999999999 +0000 UTC
2021-02-28 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfSecond 

func (c *Carbon) EndOfSecond() *Carbon

EndOfSecond returns a Carbon instance for end of the second.

Example 
fmt.Println(carbon.NewCarbon().EndOfSecond().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfSecond().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfSecond().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfSecond().ToString())

Output:

0001-01-01 00:00:00.999999999 +0000 UTC
2020-01-01 00:00:00.999999999 +0000 UTC
2020-08-15 12:30:30.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfWeek 

func (c *Carbon) EndOfWeek() *Carbon

EndOfWeek returns a Carbon instance for end of the week.

Example 
fmt.Println(carbon.NewCarbon().EndOfWeek().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfWeek().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfWeek().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfWeek().ToString())

Output:

0001-01-07 23:59:59.999999999 +0000 UTC
2020-01-05 23:59:59.999999999 +0000 UTC
2020-08-16 23:59:59.999999999 +0000 UTC
2021-01-03 23:59:59.999999999 +0000 UTC

func (*Carbon) EndOfYear 

func (c *Carbon) EndOfYear() *Carbon

EndOfYear returns a Carbon instance for end of the year.

Example 
fmt.Println(carbon.NewCarbon().EndOfYear().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").EndOfYear().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").EndOfYear().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").EndOfYear().ToString())

Output:

0001-12-31 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC
2020-12-31 23:59:59.999999999 +0000 UTC

func (*Carbon) Eq 

func (c *Carbon) Eq(t *Carbon) bool

Eq reports whether equal.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Eq(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Eq(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Eq(carbon.Parse("2020-08-05 23:00:00")))

Output:

false
true
false

func (*Carbon) Farthest 

func (c *Carbon) Farthest(c1 *Carbon, c2 ...*Carbon) *Carbon

Farthest returns the farthest Carbon instance from some given Carbon instances.

Example 
c1 := carbon.Parse("2020-08-01")
c2 := carbon.Parse("2020-08-05")
c3 := carbon.Parse("2020-08-06")
fmt.Println(c1.Farthest(c2, c3).ToString())
fmt.Println(c2.Farthest(c1, c3).ToString())
fmt.Println(c3.Farthest(c1, c2).ToString())

Output:

2020-08-06 00:00:00 +0000 UTC
2020-08-01 00:00:00 +0000 UTC
2020-08-01 00:00:00 +0000 UTC

func (*Carbon) Format 

func (c *Carbon) Format(format string, timezone ...string) string

Format outputs a string by format.

Example 
fmt.Printf("Y-m-d H:i:s format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format(carbon.DateTimeFormat))
fmt.Printf("Y-m-d format: %s\n", carbon.Parse("2020-08-05T13:14:15.999999999+00:00").Format(carbon.DateFormat))
fmt.Printf("Y-m-d H:i:s with PRC timezone format: %s\n", carbon.Parse("2020-08-05", carbon.PRC).Format(carbon.DateTimeFormat, carbon.PRC))
fmt.Printf("Y年m月d日 format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("Y年m月d日"))
fmt.Printf("D format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("D"))
fmt.Printf("l format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("l"))
fmt.Printf("F format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("F"))
fmt.Printf("M format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("M"))
fmt.Printf("j format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("j"))
fmt.Printf("W format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("W"))
fmt.Printf("F format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("F"))
fmt.Printf("N format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("N"))
fmt.Printf("L format: %s\n", carbon.Parse("2020-08-05 01:14:15").Format("L"))
fmt.Printf("L format: %s\n", carbon.Parse("2021-08-05 13:14:15").Format("L"))
fmt.Printf("G format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("G"))
fmt.Printf("S format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("S"))
fmt.Printf("U format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("U"))
fmt.Printf("V format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("V"))
fmt.Printf("X format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("X"))
fmt.Printf("u format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("u"))
fmt.Printf("v format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("v"))
fmt.Printf("x format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("x"))

fmt.Printf("w format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("w"))
fmt.Printf("t format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("t"))
fmt.Printf("z format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.PRC).Format("z"))
fmt.Printf("o format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.PRC).Format("o"))
fmt.Printf("q format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("q"))
fmt.Printf("c format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999").Format("c"))
fmt.Printf("R format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.UTC).Format("R"))
fmt.Printf("R format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.PRC).Format("R"))
fmt.Printf("Q format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.UTC).Format("Q"))
fmt.Printf("Q format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.PRC).Format("Q"))
fmt.Printf("Z format: %s\n", carbon.Parse("2020-08-05 13:14:15.999999999", carbon.PRC).Format("Z"))
fmt.Printf("jK format: %s\n", carbon.Parse("2020-08-05 13:14:15").Format("jK"))
fmt.Printf("jK format: %s\n", carbon.Parse("2020-08-22 13:14:15").Format("jK"))
fmt.Printf("jK format: %s\n", carbon.Parse("2020-08-23 13:14:15").Format("jK"))
fmt.Printf("jK format: %s\n", carbon.Parse("2020-08-31 13:14:15").Format("jK"))

fmt.Printf("timestamp format: %s\n", carbon.Parse("2020-08-05T13:14:15.999999999+00:00").Format(carbon.TimestampFormat))
fmt.Printf("TimestampMilli format: %s\n", carbon.Parse("2020-08-05T13:14:15.999999999+00:00").Format(carbon.TimestampMilliFormat))
fmt.Printf("timestampMicro format: %s\n", carbon.Parse("2020-08-05T13:14:15.999999999+00:00").Format(carbon.TimestampMicroFormat))
fmt.Printf("timestampNano format: %s\n", carbon.Parse("2020-08-05T13:14:15.999999999+00:00").Format(carbon.TimestampNanoFormat))

fmt.Printf("I\\t \\i\\s Y-m-d H:i:s format: %s\n", carbon.Parse("2020-08-31 13:14:15").Format("I\\t \\i\\s Y-m-d H:i:s"))
fmt.Printf("上次打卡时间:Y-m-d H:i:s，请每日按时打卡 format: %s\n", carbon.Parse("2020-08-31 13:14:15").Format("上次打卡时间:Y-m-d H:i:s，请每日按时打卡"))

Output:

Y-m-d H:i:s format: 2020-08-05 13:14:15
Y-m-d format: 2020-08-05
Y-m-d H:i:s with PRC timezone format: 2020-08-05 00:00:00
Y年m月d日 format: 2020年08月05日
D format: Wed
l format: Wednesday
F format: August
M format: Aug
j format: 5
W format: 32
F format: August
N format: 3
L format: 1
L format: 0
G format: 13
S format: 1596633255
U format: 1596633255000
V format: 1596633255000000
X format: 1596633255000000000
u format: 999
v format: 999999
x format: 999999999
w format: 2
t format: 31
z format: PRC
o format: 28800
q format: 3
c format: 21
R format: Z
R format: +08:00
Q format: Z
Q format: +0800
Z format: CST
jK format: 5th
jK format: 22nd
jK format: 23rd
jK format: 31st
timestamp format: 1596633255
TimestampMilli format: 1596633255999
timestampMicro format: 1596633255999999
timestampNano format: 1596633255999999999
I\t \i\s Y-m-d H:i:s format: It is 2020-08-31 13:14:15
上次打卡时间:Y-m-d H:i:s，请每日按时打卡 format: 上次打卡时间:2020-08-31 13:14:15，请每日按时打卡

func (*Carbon) GoString 

func (c *Carbon) GoString() string

GoString implements "fmt.GoStringer" interface for Carbon struct.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").GoString())
fmt.Println(carbon.Parse("2020-08-05 13:14:15", carbon.PRC).GoString())

Output:

time.Date(2020, time.August, 5, 13, 14, 15, 0, time.UTC)
time.Date(2020, time.August, 5, 13, 14, 15, 0, time.Location("PRC"))

func (*Carbon) Gt 

func (c *Carbon) Gt(t *Carbon) bool

Gt reports whether greater than.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gt(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gt(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gt(carbon.Parse("2020-08-05 23:00:00")))

Output:

true
false
false

func (*Carbon) Gte 

func (c *Carbon) Gte(t *Carbon) bool

Gte reports whether greater than or equal.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gte(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gte(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Gte(carbon.Parse("2020-08-05 23:00:00")))

Output:

true
true
false

func (*Carbon) HasError added in v2.6.0 

func (c *Carbon) HasError() bool

HasError reports whether it has error.

Example 
fmt.Println(carbon.NewCarbon().HasError())
fmt.Println(carbon.Parse("").HasError())
fmt.Println(carbon.Now().HasError())
fmt.Println(carbon.Parse("xxx").HasError())

Output:

false
false
false
true

func (*Carbon) Hebrew added in v2.6.11 

func (c *Carbon) Hebrew() *hebrew.Hebrew

Hebrew converts Carbon instance to Hebrew instance.

Example 
fmt.Println(carbon.Parse("2024-01-01").Hebrew().String())
fmt.Println(carbon.Parse("2024-08-05").Hebrew().String())
fmt.Println(carbon.Parse("2025-10-03").Hebrew().String())

Output:

5784-10-20
5784-05-01
5786-07-10

func (*Carbon) Hour 

func (c *Carbon) Hour() int

Hour gets current hour like 13.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Hour())

Output:

13

func (*Carbon) IsAM 

func (c *Carbon) IsAM() bool

IsAM reports whether it is before noon.

Example 
fmt.Println(carbon.Parse("2020-08-08 00:00:00").IsAM())
fmt.Println(carbon.Parse("2020-08-08 12:00:00").IsAM())
fmt.Println(carbon.Parse("2020-08-08 23:59:59").IsAM())

Output:

true
false
false

func (*Carbon) IsApril 

func (c *Carbon) IsApril() bool

IsApril reports whether it is April.

Example 
fmt.Println(carbon.Parse("2020-04-01").IsApril())
fmt.Println(carbon.Parse("2020-05-01").IsApril())

Output:

true
false

func (*Carbon) IsAquarius 

func (c *Carbon) IsAquarius() bool

IsAquarius reports whether is Aquarius.

Example 
fmt.Println(carbon.Parse("2020-01-20").IsAquarius())
fmt.Println(carbon.Parse("2020-08-05").IsAquarius())

Output:

true
false

func (*Carbon) IsAries 

func (c *Carbon) IsAries() bool

IsAries reports whether is Aries.

Example 
fmt.Println(carbon.Parse("2020-04-20").IsTaurus())
fmt.Println(carbon.Parse("2020-08-05").IsTaurus())

Output:

true
false

func (*Carbon) IsAugust 

func (c *Carbon) IsAugust() bool

IsAugust reports whether it is August.

Example 
fmt.Println(carbon.Parse("2020-08-01").IsAugust())
fmt.Println(carbon.Parse("2020-09-01").IsAugust())

Output:

true
false

func (*Carbon) IsAutumn 

func (c *Carbon) IsAutumn() bool

IsAutumn reports whether is autumn.

Example 
fmt.Println(carbon.Parse("2020-01-01").IsAutumn())
fmt.Println(carbon.Parse("2020-09-01").IsAutumn())

Output:

false
true

func (*Carbon) IsCancer 

func (c *Carbon) IsCancer() bool

IsCancer reports whether is Cancer.

Example 
fmt.Println(carbon.Parse("2020-06-22").IsCancer())
fmt.Println(carbon.Parse("2020-08-05").IsCancer())

Output:

true
false

func (*Carbon) IsCapricorn 

func (c *Carbon) IsCapricorn() bool

IsCapricorn reports whether is Capricorn.

Example 
fmt.Println(carbon.Parse("2020-12-22").IsCapricorn())
fmt.Println(carbon.Parse("2020-08-05").IsCapricorn())

Output:

true
false

func (*Carbon) IsDST 

func (c *Carbon) IsDST() bool

IsDST reports whether it is a daylight saving time.

Example 
tzWithDST, tzWithoutDST := "Australia/Sydney", "Australia/Brisbane"
fmt.Println(carbon.Parse("2009-01-01", tzWithDST).IsDST())
fmt.Println(carbon.Parse("2009-01-01", tzWithoutDST).IsDST())

Output:

true
false

func (*Carbon) IsDecember 

func (c *Carbon) IsDecember() bool

IsDecember reports whether it is December.

Example 
fmt.Println(carbon.Parse("2020-12-01").IsDecember())
fmt.Println(carbon.Parse("2020-01-01").IsDecember())

Output:

true
false

func (*Carbon) IsEmpty added in v2.6.5 

func (c *Carbon) IsEmpty() bool

IsEmpty reports whether it is empty value.

Example 
var c *carbon.Carbon
c = nil
fmt.Println(c.IsEmpty())

fmt.Println(carbon.NewCarbon().IsEmpty())
fmt.Println(carbon.Parse("xxx").IsEmpty())
fmt.Println(carbon.Now().IsEmpty())
fmt.Println(carbon.Parse("").IsEmpty())

Output:

false
false
false
false
true

func (*Carbon) IsEpoch added in v2.6.3 

func (c *Carbon) IsEpoch() bool

IsEpoch reports whether it is a unix epoch time(1970-01-01 00:00:00 +0000 UTC).

Example 
fmt.Println(carbon.NewCarbon().IsEpoch())
fmt.Println(carbon.EpochValue().IsEpoch())
fmt.Println(carbon.CreateFromDateTimeNano(1970, 1, 1, 0, 0, 0, 0, carbon.UTC).IsEpoch())
fmt.Println(carbon.CreateFromTimestamp(0).IsEpoch())

fmt.Println(carbon.Parse("").IsEpoch())
fmt.Println(carbon.Parse("xxx").IsEpoch())
fmt.Println(carbon.Now().IsEpoch())

Output:

false
true
true
true
false
false
false

func (*Carbon) IsFebruary 

func (c *Carbon) IsFebruary() bool

IsFebruary reports whether it is February.

Example 
fmt.Println(carbon.Parse("2020-02-01").IsFebruary())
fmt.Println(carbon.Parse("2020-03-01").IsFebruary())

Output:

true
false

func (*Carbon) IsFriday 

func (c *Carbon) IsFriday() bool

IsFriday reports whether it is Friday.

Example 
fmt.Println(carbon.Parse("2025-03-07").IsFriday())
fmt.Println(carbon.Parse("2025-03-08").IsFriday())

Output:

true
false

func (*Carbon) IsFuture 

func (c *Carbon) IsFuture() bool

IsFuture reports whether it is future time.

Example 
fmt.Println(carbon.Yesterday().IsFuture())
fmt.Println(carbon.Now().IsFuture())
fmt.Println(carbon.Tomorrow().IsFuture())
fmt.Println(carbon.Parse("2025-03-01").IsFuture())

Output:

false
false
true
false

func (*Carbon) IsGemini 

func (c *Carbon) IsGemini() bool

IsGemini reports whether is Gemini.

Example 
fmt.Println(carbon.Parse("2020-06-21").IsGemini())
fmt.Println(carbon.Parse("2020-08-05").IsGemini())

Output:

true
false

func (*Carbon) IsInvalid 

func (c *Carbon) IsInvalid() bool

IsInvalid reports whether it is an invalid time.

Example 
fmt.Println(carbon.NewCarbon().IsInvalid())
fmt.Println(carbon.Parse("").IsInvalid())
fmt.Println(carbon.Parse("xxx").IsInvalid())
fmt.Println(carbon.Now().IsInvalid())

Output:

false
true
true
false

func (*Carbon) IsJanuary 

func (c *Carbon) IsJanuary() bool

IsJanuary reports whether it is January.

Example 
fmt.Println(carbon.Parse("2020-01-01").IsJanuary())
fmt.Println(carbon.Parse("2020-02-01").IsJanuary())

Output:

true
false

func (*Carbon) IsJuly 

func (c *Carbon) IsJuly() bool

IsJuly reports whether it is July.

Example 
fmt.Println(carbon.Parse("2020-07-01").IsJuly())
fmt.Println(carbon.Parse("2020-08-01").IsJuly())

Output:

true
false

func (*Carbon) IsJune 

func (c *Carbon) IsJune() bool

IsJune reports whether it is June.

Example 
fmt.Println(carbon.Parse("2020-06-01").IsJune())
fmt.Println(carbon.Parse("2020-07-01").IsJune())

Output:

true
false

func (*Carbon) IsLeapYear 

func (c *Carbon) IsLeapYear() bool

IsLeapYear reports whether it is a leap year.

Example 
fmt.Println(carbon.Parse("2015-01-01").IsLeapYear())
fmt.Println(carbon.Parse("2016-01-01").IsLeapYear())

Output:

false
true

func (*Carbon) IsLeo 

func (c *Carbon) IsLeo() bool

IsLeo reports whether is Leo.

Example 
fmt.Println(carbon.Parse("2020-07-23").IsLeo())
fmt.Println(carbon.Parse("2020-09-01").IsLeo())

Output:

true
false

func (*Carbon) IsLibra 

func (c *Carbon) IsLibra() bool

IsLibra reports whether is Libra.

Example 
fmt.Println(carbon.Parse("2020-09-23").IsLibra())
fmt.Println(carbon.Parse("2020-08-05").IsLibra())

Output:

true
false

func (*Carbon) IsLongYear 

func (c *Carbon) IsLongYear() bool

IsLongYear reports whether it is a long year,

refer to https://en.wikipedia.org/wiki/ISO_8601#Week_dates.

Example 
fmt.Println(carbon.Parse("2015-01-01").IsLongYear())
fmt.Println(carbon.Parse("2016-01-01").IsLongYear())

Output:

true
false

func (*Carbon) IsMarch 

func (c *Carbon) IsMarch() bool

IsMarch reports whether it is March.

Example 
fmt.Println(carbon.Parse("2020-03-01").IsMarch())
fmt.Println(carbon.Parse("2020-04-01").IsMarch())

Output:

true
false

func (*Carbon) IsMay 

func (c *Carbon) IsMay() bool

IsMay reports whether it is May.

Example 
fmt.Println(carbon.Parse("2020-05-01").IsMay())
fmt.Println(carbon.Parse("2020-06-01").IsMay())

Output:

true
false

func (*Carbon) IsMonday 

func (c *Carbon) IsMonday() bool

IsMonday reports whether it is Monday.

Example 
fmt.Println(carbon.Parse("2025-03-03").IsMonday())
fmt.Println(carbon.Parse("2025-03-04").IsMonday())

Output:

true
false

func (*Carbon) IsNil added in v2.6.0 

func (c *Carbon) IsNil() bool

IsNil reports whether it is nil pointer.

Example 
fmt.Println(carbon.NewCarbon().IsNil())
fmt.Println(carbon.Parse("xxx").IsNil())
fmt.Println(carbon.Now().IsNil())
fmt.Println(carbon.Parse("").IsNil())

c := carbon.NewCarbon()
c = nil
fmt.Println(c.IsNil())

Output:

false
false
false
false
true

func (*Carbon) IsNovember 

func (c *Carbon) IsNovember() bool

IsNovember reports whether it is November.

Example 
fmt.Println(carbon.Parse("2020-11-01").IsNovember())
fmt.Println(carbon.Parse("2020-12-01").IsNovember())

Output:

true
false

func (*Carbon) IsNow 

func (c *Carbon) IsNow() bool

IsNow reports whether it is now time.

Example 
fmt.Println(carbon.Yesterday().IsNow())
fmt.Println(carbon.Now().IsNow())
fmt.Println(carbon.Tomorrow().IsNow())
fmt.Println(carbon.Parse("2025-03-01").IsNow())

Output:

false
true
false
false

func (*Carbon) IsOctober 

func (c *Carbon) IsOctober() bool

IsOctober reports whether it is October.

Example 
fmt.Println(carbon.Parse("2020-10-01").IsOctober())
fmt.Println(carbon.Parse("2020-11-01").IsOctober())

Output:

true
false

func (*Carbon) IsPM 

func (c *Carbon) IsPM() bool

IsPM reports whether it is after noon.

Example 
fmt.Println(carbon.Parse("2020-08-08 00:00:00").IsPM())
fmt.Println(carbon.Parse("2020-08-08 12:00:00").IsPM())
fmt.Println(carbon.Parse("2020-08-08 23:59:59").IsPM())

Output:

false
true
true

func (*Carbon) IsPast 

func (c *Carbon) IsPast() bool

IsPast reports whether it is past time.

Example 
fmt.Println(carbon.Yesterday().IsPast())
fmt.Println(carbon.Now().IsPast())
fmt.Println(carbon.Tomorrow().IsPast())
fmt.Println(carbon.Parse("2025-03-01").IsPast())

Output:

true
false
false
true

func (*Carbon) IsPisces 

func (c *Carbon) IsPisces() bool

IsPisces reports whether is Pisces.

Example 
fmt.Println(carbon.Parse("2020-02-19").IsPisces())
fmt.Println(carbon.Parse("2020-08-05").IsPisces())

Output:

true
false

func (*Carbon) IsSagittarius 

func (c *Carbon) IsSagittarius() bool

IsSagittarius reports whether is Sagittarius.

Example 
fmt.Println(carbon.Parse("2020-11-23").IsSagittarius())
fmt.Println(carbon.Parse("2020-08-05").IsSagittarius())

Output:

true
false

func (*Carbon) IsSameCentury 

func (c *Carbon) IsSameCentury(t *Carbon) bool

IsSameCentury reports whether it is same century.

Example 
fmt.Println(carbon.Parse("2020-08-05").IsSameCentury(carbon.Parse("2010-01-01")))
fmt.Println(carbon.Parse("2020-08-05").IsSameCentury(carbon.Parse("2030-12-31")))
fmt.Println(carbon.Parse("2020-08-05").IsSameCentury(carbon.Parse("2100-08-05")))

Output:

true
true
false

func (*Carbon) IsSameDay 

func (c *Carbon) IsSameDay(t *Carbon) bool

IsSameDay reports whether it is same day.

Example 
fmt.Println(carbon.Parse("2020-08-05 00:00:00").IsSameDay(carbon.Parse("2020-08-05 23:59:59")))
fmt.Println(carbon.Parse("2020-08-05 00:00:00").IsSameDay(carbon.Parse("2021-08-05 00:00:00")))
fmt.Println(carbon.Parse("2020-08-05 00:00:00").IsSameDay(carbon.Parse("2020-09-05 00:00:00")))

Output:

true
false
false

func (*Carbon) IsSameDecade 

func (c *Carbon) IsSameDecade(t *Carbon) bool

IsSameDecade reports whether it is same decade.

Example 
fmt.Println(carbon.Parse("2020-08-05").IsSameDecade(carbon.Parse("2020-01-01")))
fmt.Println(carbon.Parse("2020-08-05").IsSameDecade(carbon.Parse("2020-12-31")))
fmt.Println(carbon.Parse("2020-08-05").IsSameDecade(carbon.Parse("2010-08-05")))

Output:

true
true
false

func (*Carbon) IsSameHour 

func (c *Carbon) IsSameHour(t *Carbon) bool

IsSameHour reports whether it is same hour.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameHour(carbon.Parse("2020-08-05 22:59:59")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameHour(carbon.Parse("2021-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameHour(carbon.Parse("2020-09-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameHour(carbon.Parse("2020-08-06 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameHour(carbon.Parse("2020-08-05 23:00:00")))

Output:

true
false
false
false
false

func (*Carbon) IsSameMinute 

func (c *Carbon) IsSameMinute(t *Carbon) bool

IsSameMinute reports whether it is same minute.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameMinute(carbon.Parse("2020-08-05 22:00:59")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameMinute(carbon.Parse("2021-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameMinute(carbon.Parse("2020-08-06 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameMinute(carbon.Parse("2020-08-05 23:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameMinute(carbon.Parse("2020-08-05 22:01:00")))

Output:

true
false
false
false
false

func (*Carbon) IsSameMonth 

func (c *Carbon) IsSameMonth(t *Carbon) bool

IsSameMonth reports whether it is same month.

Example 
fmt.Println(carbon.Parse("2020-08-05").IsSameMonth(carbon.Parse("2020-08-01")))
fmt.Println(carbon.Parse("2020-08-05").IsSameMonth(carbon.Parse("2010-08-05")))
fmt.Println(carbon.Parse("2020-08-05").IsSameMonth(carbon.Parse("2020-09-05")))

Output:

true
false
false

func (*Carbon) IsSameQuarter 

func (c *Carbon) IsSameQuarter(t *Carbon) bool

IsSameQuarter reports whether it is same quarter.

Example 
fmt.Println(carbon.Parse("2020-08-05").IsSameQuarter(carbon.Parse("2020-08-06")))
fmt.Println(carbon.Parse("2020-08-05").IsSameQuarter(carbon.Parse("2010-08-05")))
fmt.Println(carbon.Parse("2020-08-05").IsSameQuarter(carbon.Parse("2010-01-05")))

Output:

true
false
false

func (*Carbon) IsSameSecond 

func (c *Carbon) IsSameSecond(t *Carbon) bool

IsSameSecond reports whether it is same second.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameSecond(carbon.Parse("2020-08-05 22:00:00.999999")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").IsSameSecond(carbon.Parse("2021-08-05 22:00:00")))

Output:

true
false

func (*Carbon) IsSameYear 

func (c *Carbon) IsSameYear(t *Carbon) bool

IsSameYear reports whether it is same year.

Example 
fmt.Println(carbon.Parse("2020-08-05").IsSameYear(carbon.Parse("2010-08-05")))
fmt.Println(carbon.Parse("2020-08-05").IsSameYear(carbon.Parse("2020-01-01")))
fmt.Println(carbon.Parse("2020-08-05").IsSameYear(carbon.Parse("2020-12-31")))

Output:

false
true
true

func (*Carbon) IsSaturday 

func (c *Carbon) IsSaturday() bool

IsSaturday reports whether it is Saturday.

Example 
fmt.Println(carbon.Parse("2025-03-08").IsSaturday())
fmt.Println(carbon.Parse("2025-03-09").IsSaturday())

Output:

true
false

func (*Carbon) IsScorpio 

func (c *Carbon) IsScorpio() bool

IsScorpio reports whether is Scorpio.

Example 
fmt.Println(carbon.Parse("2020-10-24").IsScorpio())
fmt.Println(carbon.Parse("2020-08-05").IsScorpio())

Output:

true
false

func (*Carbon) IsSeptember 

func (c *Carbon) IsSeptember() bool

IsSeptember reports whether it is September.

Example 
fmt.Println(carbon.Parse("2020-09-01").IsSeptember())
fmt.Println(carbon.Parse("2020-10-01").IsSeptember())

Output:

true
false

func (*Carbon) IsSpring 

func (c *Carbon) IsSpring() bool

IsSpring reports whether is spring.

Example 
fmt.Println(carbon.Parse("2020-01-01").IsSpring())
fmt.Println(carbon.Parse("2020-03-01").IsSpring())

Output:

false
true

func (*Carbon) IsSummer 

func (c *Carbon) IsSummer() bool

IsSummer reports whether is summer.

Example 
fmt.Println(carbon.Parse("2020-01-01").IsSummer())
fmt.Println(carbon.Parse("2020-06-01").IsSummer())

Output:

false
true

func (*Carbon) IsSunday 

func (c *Carbon) IsSunday() bool

IsSunday reports whether it is Sunday.

Example 
fmt.Println(carbon.Parse("2025-03-09").IsSunday())
fmt.Println(carbon.Parse("2025-03-10").IsSunday())

Output:

true
false

func (*Carbon) IsTaurus 

func (c *Carbon) IsTaurus() bool

IsTaurus reports whether is Taurus.

func (*Carbon) IsThursday 

func (c *Carbon) IsThursday() bool

IsThursday reports whether it is Thursday.

Example 
fmt.Println(carbon.Parse("2025-03-06").IsThursday())
fmt.Println(carbon.Parse("2025-03-07").IsThursday())

Output:

true
false

func (*Carbon) IsToday 

func (c *Carbon) IsToday() bool

IsToday reports whether it is today.

Example 
fmt.Println(carbon.Yesterday().IsToday())
fmt.Println(carbon.Now().IsToday())
fmt.Println(carbon.Tomorrow().IsToday())
fmt.Println(carbon.Parse("2025-03-01").IsToday())

Output:

false
true
false
false

func (*Carbon) IsTomorrow 

func (c *Carbon) IsTomorrow() bool

IsTomorrow reports whether it is tomorrow.

Example 
fmt.Println(carbon.Yesterday().IsTomorrow())
fmt.Println(carbon.Now().IsTomorrow())
fmt.Println(carbon.Tomorrow().IsTomorrow())
fmt.Println(carbon.Parse("2025-03-01").IsTomorrow())

Output:

false
false
true
false

func (*Carbon) IsTuesday 

func (c *Carbon) IsTuesday() bool

IsTuesday reports whether it is Tuesday.

Example 
fmt.Println(carbon.Parse("2025-03-04").IsTuesday())
fmt.Println(carbon.Parse("2025-03-05").IsTuesday())

Output:

true
false

func (*Carbon) IsValid 

func (c *Carbon) IsValid() bool

IsValid reports whether it is a valid time.

Example 
fmt.Println(carbon.NewCarbon().IsValid())
fmt.Println(carbon.Now().IsValid())
fmt.Println(carbon.Parse("").IsValid())
fmt.Println(carbon.Parse("xxx").IsValid())

Output:

true
true
false
false

func (*Carbon) IsVirgo 

func (c *Carbon) IsVirgo() bool

IsVirgo reports whether is Virgo.

Example 
fmt.Println(carbon.Parse("2020-08-23").IsVirgo())
fmt.Println(carbon.Parse("2020-08-05").IsVirgo())

Output:

true
false

func (*Carbon) IsWednesday 

func (c *Carbon) IsWednesday() bool

IsWednesday reports whether it is Wednesday.

Example 
fmt.Println(carbon.Parse("2025-03-05").IsWednesday())
fmt.Println(carbon.Parse("2025-03-06").IsWednesday())

Output:

true
false

func (*Carbon) IsWeekday 

func (c *Carbon) IsWeekday() bool

IsWeekday reports whether it is weekday.

Example 
fmt.Println(carbon.Parse("2025-03-01").IsWeekday())
fmt.Println(carbon.Parse("2025-03-02").IsWeekday())
fmt.Println(carbon.Parse("2025-03-03").IsWeekday())

Output:

false
false
true

func (*Carbon) IsWeekend 

func (c *Carbon) IsWeekend() bool

IsWeekend reports whether it is weekend.

Example 
fmt.Println(carbon.Parse("2025-03-01").IsWeekend())
fmt.Println(carbon.Parse("2025-03-02").IsWeekend())
fmt.Println(carbon.Parse("2025-03-03").IsWeekend())

Output:

true
true
false

func (*Carbon) IsWinter 

func (c *Carbon) IsWinter() bool

IsWinter reports whether is winter.

Example 
fmt.Println(carbon.Parse("2020-01-01").IsWinter())
fmt.Println(carbon.Parse("2020-05-01").IsWinter())

Output:

true
false

func (*Carbon) IsYesterday 

func (c *Carbon) IsYesterday() bool

IsYesterday reports whether it is yesterday.

Example 
fmt.Println(carbon.Yesterday().IsYesterday())
fmt.Println(carbon.Now().IsYesterday())
fmt.Println(carbon.Tomorrow().IsYesterday())
fmt.Println(carbon.Parse("2025-03-01").IsYesterday())

Output:

true
false
false
false

func (*Carbon) IsZero 

func (c *Carbon) IsZero() bool

IsZero reports whether it is a zero time(0001-01-01 00:00:00 +0000 UTC).

Example 
fmt.Println(carbon.NewCarbon().IsZero())
fmt.Println(carbon.ZeroValue().IsZero())
fmt.Println(carbon.CreateFromDateTimeNano(1, 1, 1, 0, 0, 0, 0, carbon.UTC).IsZero())
fmt.Println(carbon.CreateFromTimestamp(0).IsZero())

fmt.Println(carbon.Parse("").IsZero())
fmt.Println(carbon.Parse("xxx").IsZero())
fmt.Println(carbon.Now().IsZero())

Output:

true
true
true
false
false
false
false

func (*Carbon) Julian 

func (c *Carbon) Julian() *julian.Julian

Julian converts Carbon instance to Julian instance.

Example 
fmt.Println("JD(default precision 6):", carbon.Parse("2024-01-23 13:14:15").Julian().JD())
fmt.Println("MJD(default precision 6):", carbon.Parse("2024-01-23 13:14:15").Julian().MJD())

fmt.Println("JD(specify precision 4):", carbon.Parse("2024-01-23 13:14:15").Julian().JD(4))
fmt.Println("MJD(specify precision 4):", carbon.Parse("2024-01-23 13:14:15").Julian().MJD(4))

Output:

JD(default precision 6): 2.460333051563e+06
MJD(default precision 6): 60332.551563
JD(specify precision 4): 2.4603330516e+06
MJD(specify precision 4): 60332.5516

func (*Carbon) Layout 

func (c *Carbon) Layout(layout string, timezone ...string) string

Layout outputs a string by layout.

Example 
c := carbon.Parse("2020-08-05T13:14:15.999999999+00:00")

fmt.Printf("date layout: %s\n", c.Layout(carbon.DateLayout))
fmt.Printf("time layout: %s\n", c.Layout(carbon.TimeLayout))
fmt.Printf("datetime layout: %s\n", c.Layout(carbon.DateTimeLayout))

fmt.Printf("timestamp layout: %s\n", c.Layout(carbon.TimestampLayout))
fmt.Printf("TimestampMilli layout: %s\n", c.Layout(carbon.TimestampMilliLayout))
fmt.Printf("timestampMicro layout: %s\n", c.Layout(carbon.TimestampMicroLayout))
fmt.Printf("timestampNano layout: %s\n", c.Layout(carbon.TimestampNanoLayout))

Output:

date layout: 2020-08-05
time layout: 13:14:15
datetime layout: 2020-08-05 13:14:15
timestamp layout: 1596633255
TimestampMilli layout: 1596633255999
timestampMicro layout: 1596633255999999
timestampNano layout: 1596633255999999999

func (*Carbon) Locale 

func (c *Carbon) Locale() string

Locale gets locale name like "zh-CN".

Example 
fmt.Println(carbon.Now().SetLocale("en").Locale())
fmt.Println(carbon.Now().SetLocale("zh-CN").Locale())

Output:

en
zh-CN

func (*Carbon) Lt 

func (c *Carbon) Lt(t *Carbon) bool

Lt reports whether less than.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lt(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lt(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lt(carbon.Parse("2020-08-05 23:00:00")))

Output:

false
false
true

func (*Carbon) Lte 

func (c *Carbon) Lte(t *Carbon) bool

Lte reports whether less than or equal.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lte(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lte(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Lte(carbon.Parse("2020-08-05 23:00:00")))

Output:

false
true
true

func (*Carbon) Lunar 

func (c *Carbon) Lunar() *lunar.Lunar

Lunar converts Carbon instance to Lunar instance.

Example 
fmt.Println(carbon.Parse("2023-03-02", carbon.PRC).Lunar().String())
fmt.Println(carbon.Parse("2023-04-01", carbon.PRC).Lunar().String())

Output:

2023-02-11
2023-02-11

func (Carbon) MarshalJSON 

func (c Carbon) MarshalJSON() ([]byte, error)

MarshalJSON implements "json.Marshaler" interface for Carbon struct.

Example 
type User struct {
	Carbon1 carbon.Carbon  `json:"carbon1"`
	Carbon2 *carbon.Carbon `json:"carbon2"`
}

user := User{
	Carbon1: *carbon.Parse("2020-08-05 13:14:15.999999999"),
	Carbon2: carbon.Parse("2020-08-05 13:14:15.999999999"),
}

data, _ := json.Marshal(&user)
fmt.Printf("%s", data)

Output:

{"carbon1":"2020-08-05 13:14:15","carbon2":"2020-08-05 13:14:15"}

func (*Carbon) Microsecond 

func (c *Carbon) Microsecond() int

Microsecond gets current microsecond like 999999.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Microsecond())

Output:

999999

func (*Carbon) Millisecond 

func (c *Carbon) Millisecond() int

Millisecond gets current millisecond like 999.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Millisecond())

Output:

999

func (*Carbon) Minute 

func (c *Carbon) Minute() int

Minute gets current minute like 14.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Minute())

Output:

14

func (*Carbon) Month 

func (c *Carbon) Month() int

Month gets current month like 8.

Example 
fmt.Println(carbon.Parse("2020-01-05").Month())
fmt.Println(carbon.Parse("2020-04-05").Month())
fmt.Println(carbon.Parse("2020-08-05").Month())
fmt.Println(carbon.Parse("2020-11-05").Month())

Output:

1
4
8
11

func (*Carbon) MonthOfYear 

func (c *Carbon) MonthOfYear() int

MonthOfYear gets month of year like 12.

Example 
fmt.Println(carbon.Parse("2020-01-05").MonthOfYear())
fmt.Println(carbon.Parse("2020-02-05").MonthOfYear())
fmt.Println(carbon.Parse("2020-03-05").MonthOfYear())
fmt.Println(carbon.Parse("2020-04-05").MonthOfYear())

Output:

1
2
3
4

func (*Carbon) Nanosecond 

func (c *Carbon) Nanosecond() int

Nanosecond gets current nanosecond like 999999999.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Nanosecond())

Output:

999999999

func (*Carbon) Ne 

func (c *Carbon) Ne(t *Carbon) bool

Ne reports whether not equal.

Example 
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Ne(carbon.Parse("2020-08-05 21:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Ne(carbon.Parse("2020-08-05 22:00:00")))
fmt.Println(carbon.Parse("2020-08-05 22:00:00").Ne(carbon.Parse("2020-08-05 23:00:00")))

Output:

true
false
true

func (*Carbon) Persian 

func (c *Carbon) Persian() *persian.Persian

Persian converts Carbon instance to Persian instance.

Example 
fmt.Println(carbon.Parse("1800-01-01 00:00:00").Persian().String())
fmt.Println(carbon.Parse("2020-08-05 13:14:15").Persian().String())
fmt.Println(carbon.Parse("2024-01-01 00:00:00").Persian().String())

Output:

1178-10-11
1399-05-15
1402-10-11

func (*Carbon) Quarter 

func (c *Carbon) Quarter() (quarter int)

Quarter gets current quarter like 3.

Example 
fmt.Println(carbon.Parse("2020-01-05").Quarter())
fmt.Println(carbon.Parse("2020-04-05").Quarter())
fmt.Println(carbon.Parse("2020-08-05").Quarter())
fmt.Println(carbon.Parse("2020-11-05").Quarter())

Output:

1
2
3
4

func (*Carbon) Scan 

func (c *Carbon) Scan(src any) error

Scan implements "driver.Scanner" interface for Carbon struct.

func (*Carbon) Season 

func (c *Carbon) Season() string

Season gets season name according to the meteorological division method like "Spring", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-01-05").Season())
fmt.Println(carbon.Parse("2020-02-05").Season())
fmt.Println(carbon.Parse("2020-03-05").Season())
fmt.Println(carbon.Parse("2020-04-05").Season())
fmt.Println(carbon.Parse("2020-05-05").Season())
fmt.Println(carbon.Parse("2020-06-05").Season())
fmt.Println(carbon.Parse("2020-07-05").Season())
fmt.Println(carbon.Parse("2020-08-05").Season())
fmt.Println(carbon.Parse("2020-09-05").Season())
fmt.Println(carbon.Parse("2020-10-05").Season())
fmt.Println(carbon.Parse("2020-11-05").Season())
fmt.Println(carbon.Parse("2020-12-05").Season())

Output:

Winter
Winter
Spring
Spring
Spring
Summer
Summer
Summer
Autumn
Autumn
Autumn
Winter

func (*Carbon) Second 

func (c *Carbon) Second() int

Second gets current second like 9.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Second())

Output:

15

func (*Carbon) SetDate 

func (c *Carbon) SetDate(year, month, day int) *Carbon

SetDate sets year, month and day.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDate(2020, 8, 5).ToString())

Output:

2020-08-05 00:00:00 +0000 UTC

func (*Carbon) SetDateMicro 

func (c *Carbon) SetDateMicro(year, month, day, microsecond int) *Carbon

SetDateMicro sets year, month, day and microsecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateMicro(2020, 8, 5, 999999).ToString())

Output:

2020-08-05 00:00:00.999999 +0000 UTC

func (*Carbon) SetDateMilli 

func (c *Carbon) SetDateMilli(year, month, day, millisecond int) *Carbon

SetDateMilli sets year, month, day and millisecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateMilli(2020, 8, 5, 999).ToString())

Output:

2020-08-05 00:00:00.999 +0000 UTC

func (*Carbon) SetDateNano 

func (c *Carbon) SetDateNano(year, month, day, nanosecond int) *Carbon

SetDateNano sets year, month, day and nanosecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateNano(2020, 8, 5, 999999999).ToString())

Output:

2020-08-05 00:00:00.999999999 +0000 UTC

func (*Carbon) SetDateTime 

func (c *Carbon) SetDateTime(year, month, day, hour, minute, second int) *Carbon

SetDateTime sets year, month, day, hour, minute and second.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateTime(2020, 8, 5, 13, 14, 15).ToString())

Output:

2020-08-05 13:14:15 +0000 UTC

func (*Carbon) SetDateTimeMicro 

func (c *Carbon) SetDateTimeMicro(year, month, day, hour, minute, second, microsecond int) *Carbon

SetDateTimeMicro sets year, month, day, hour, minute, second and microsecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateTimeMicro(2020, 8, 5, 13, 14, 15, 999999).ToString())

Output:

2020-08-05 13:14:15.999999 +0000 UTC

func (*Carbon) SetDateTimeMilli 

func (c *Carbon) SetDateTimeMilli(year, month, day, hour, minute, second, millisecond int) *Carbon

SetDateTimeMilli sets year, month, day, hour, minute, second and millisecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateTimeMilli(2020, 8, 5, 13, 14, 15, 999).ToString())

Output:

2020-08-05 13:14:15.999 +0000 UTC

func (*Carbon) SetDateTimeNano 

func (c *Carbon) SetDateTimeNano(year, month, day, hour, minute, second, nanosecond int) *Carbon

SetDateTimeNano sets year, month, day, hour, minute, second and nanosecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetDateTimeNano(2020, 8, 5, 13, 14, 15, 999999999).ToString())

Output:

2020-08-05 13:14:15.999999999 +0000 UTC

func (*Carbon) SetDay 

func (c *Carbon) SetDay(day int) *Carbon

SetDay sets day.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetDay(31).ToString())
fmt.Println(carbon.Parse("2020-02-01").SetDay(31).ToString())
fmt.Println(carbon.Parse("2020-02-28").SetDay(31).ToString())

Output:

2020-01-31 00:00:00 +0000 UTC
2020-03-02 00:00:00 +0000 UTC
2020-03-02 00:00:00 +0000 UTC

func (*Carbon) SetFormat added in v2.6.0 

func (c *Carbon) SetFormat(format string) *Carbon

SetFormat sets format.

Example 
c := carbon.Parse("2020-08-05 13:14:15.999999 +0000 UTC")

fmt.Println("date format:", c.SetFormat(carbon.DateFormat))
fmt.Println("time format:", c.SetFormat(carbon.TimeFormat))
fmt.Println("datetime format:", c.SetFormat(carbon.DateTimeFormat))
fmt.Println("timestamp format:", c.SetFormat(carbon.TimestampFormat))

Output:

date format: 2020-08-05
time format: 13:14:15
datetime format: 2020-08-05 13:14:15
timestamp format: 1596633255

func (*Carbon) SetHour 

func (c *Carbon) SetHour(hour int) *Carbon

SetHour sets hour.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetHour(10).ToString())
fmt.Println(carbon.Parse("2020-02-01").SetHour(24).ToString())
fmt.Println(carbon.Parse("2020-02-28").SetHour(31).ToString())

Output:

2020-01-01 10:00:00 +0000 UTC
2020-02-02 00:00:00 +0000 UTC
2020-02-29 07:00:00 +0000 UTC

func (*Carbon) SetLanguage added in v2.6.0 

func (c *Carbon) SetLanguage(lang *Language) *Carbon

SetLanguage sets language.

Example 
lang := carbon.NewLanguage()

lang.SetLocale("en")
fmt.Println(carbon.Parse("2020-08-05").SetLanguage(lang).ToMonthString())

lang.SetLocale("zh-CN")
fmt.Println(carbon.Parse("2020-08-05").SetLanguage(lang).ToMonthString())

Output:

August
八月

func (*Carbon) SetLayout added in v2.6.0 

func (c *Carbon) SetLayout(layout string) *Carbon

SetLayout sets layout.

Example 
c := carbon.Parse("2020-08-05 13:14:15.999999 +0000 UTC")

fmt.Println("date layout:", c.SetLayout(carbon.DateLayout))
fmt.Println("time layout:", c.SetLayout(carbon.TimeLayout))
fmt.Println("datetime layout:", c.SetLayout(carbon.DateTimeLayout))
fmt.Println("timestamp layout:", c.SetLayout(carbon.TimestampLayout))

Output:

date layout: 2020-08-05
time layout: 13:14:15
datetime layout: 2020-08-05 13:14:15
timestamp layout: 1596633255

func (*Carbon) SetLocale 

func (c *Carbon) SetLocale(locale string) *Carbon

SetLocale sets locale.

Example 
c := carbon.Parse("2020-08-05").SetLocale("zh-CN")

fmt.Println(c.Constellation())
fmt.Println(c.Season())
fmt.Println(c.ToMonthString())
fmt.Println(c.ToShortMonthString())
fmt.Println(c.ToWeekString())
fmt.Println(c.ToShortWeekString())

Output:

狮子座
夏季
八月
8月
星期三
周三

func (*Carbon) SetLocation 

func (c *Carbon) SetLocation(loc *Location) *Carbon

SetLocation sets location.

Example 
defer carbon.SetLocation(time.UTC)

c := carbon.Parse("2020-08-05")

loc, _ := time.LoadLocation(carbon.PRC)
c.SetLocation(loc)
fmt.Println("default location:", carbon.DefaultTimezone)
fmt.Println("zone location:", c.Timezone())
fmt.Println("zone name:", c.ZoneName())
fmt.Println("zone offset:", c.ZoneOffset())

Output:

default location: UTC
zone location: PRC
zone name: CST
zone offset: 28800

func (*Carbon) SetMicrosecond 

func (c *Carbon) SetMicrosecond(microsecond int) *Carbon

SetMicrosecond sets microsecond.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetMicrosecond(100000).ToString())
fmt.Println(carbon.Parse("2020-01-01").SetMicrosecond(999999).ToString())

Output:

2020-01-01 00:00:00.1 +0000 UTC
2020-01-01 00:00:00.999999 +0000 UTC

func (*Carbon) SetMillisecond 

func (c *Carbon) SetMillisecond(millisecond int) *Carbon

SetMillisecond sets millisecond.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetMillisecond(100).ToString())
fmt.Println(carbon.Parse("2020-01-01").SetMillisecond(999).ToString())

Output:

2020-01-01 00:00:00.1 +0000 UTC
2020-01-01 00:00:00.999 +0000 UTC

func (*Carbon) SetMinute 

func (c *Carbon) SetMinute(minute int) *Carbon

SetMinute sets minute.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetMinute(10).ToString())
fmt.Println(carbon.Parse("2020-02-01").SetMinute(24).ToString())
fmt.Println(carbon.Parse("2020-02-28").SetMinute(60).ToString())

Output:

2020-01-01 00:10:00 +0000 UTC
2020-02-01 00:24:00 +0000 UTC
2020-02-28 01:00:00 +0000 UTC

func (*Carbon) SetMonth 

func (c *Carbon) SetMonth(month int) *Carbon

SetMonth sets month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetMonth(2).ToString())
fmt.Println(carbon.Parse("2020-01-30").SetMonth(2).ToString())
fmt.Println(carbon.Parse("2020-01-31").SetMonth(2).ToString())

Output:

2020-02-01 00:00:00 +0000 UTC
2020-03-01 00:00:00 +0000 UTC
2020-03-02 00:00:00 +0000 UTC

func (*Carbon) SetMonthNoOverflow 

func (c *Carbon) SetMonthNoOverflow(month int) *Carbon

SetMonthNoOverflow sets month without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetMonthNoOverflow(2).ToString())
fmt.Println(carbon.Parse("2020-01-30").SetMonthNoOverflow(2).ToString())
fmt.Println(carbon.Parse("2020-01-31").SetMonthNoOverflow(2).ToString())

Output:

2020-02-01 00:00:00 +0000 UTC
2020-02-29 00:00:00 +0000 UTC
2020-02-29 00:00:00 +0000 UTC

func (*Carbon) SetNanosecond 

func (c *Carbon) SetNanosecond(nanosecond int) *Carbon

SetNanosecond sets nanosecond.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetNanosecond(100000000).ToString())
fmt.Println(carbon.Parse("2020-01-01").SetNanosecond(999999999).ToString())

Output:

2020-01-01 00:00:00.1 +0000 UTC
2020-01-01 00:00:00.999999999 +0000 UTC

func (*Carbon) SetSecond 

func (c *Carbon) SetSecond(second int) *Carbon

SetSecond sets second.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetSecond(10).ToString())
fmt.Println(carbon.Parse("2020-02-01").SetSecond(24).ToString())
fmt.Println(carbon.Parse("2020-02-28").SetSecond(60).ToString())

Output:

2020-01-01 00:00:10 +0000 UTC
2020-02-01 00:00:24 +0000 UTC
2020-02-28 00:01:00 +0000 UTC

func (*Carbon) SetTime 

func (c *Carbon) SetTime(hour, minute, second int) *Carbon

SetTime sets hour, minute and second.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetTime(13, 14, 15).ToString())

Output:

2020-08-05 13:14:15 +0000 UTC

func (*Carbon) SetTimeMicro 

func (c *Carbon) SetTimeMicro(hour, minute, second, microsecond int) *Carbon

SetTimeMicro sets hour, minute, second and microsecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetTimeMicro(13, 14, 15, 999999).ToString())

Output:

2020-08-05 13:14:15.999999 +0000 UTC

func (*Carbon) SetTimeMilli 

func (c *Carbon) SetTimeMilli(hour, minute, second, millisecond int) *Carbon

SetTimeMilli sets hour, minute, second and millisecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetTimeMilli(13, 14, 15, 999).ToString())

Output:

2020-08-05 13:14:15.999 +0000 UTC

func (*Carbon) SetTimeNano 

func (c *Carbon) SetTimeNano(hour, minute, second, nanosecond int) *Carbon

SetTimeNano sets hour, minute, second and nanosecond.

Example 
fmt.Println(carbon.Parse("2020-08-05").SetTimeNano(13, 14, 15, 999999999).ToString())

Output:

2020-08-05 13:14:15.999999999 +0000 UTC

func (*Carbon) SetTimezone 

func (c *Carbon) SetTimezone(name string) *Carbon

SetTimezone sets timezone.

Example 
fmt.Println("UTC zone location:", carbon.Now().SetTimezone(carbon.UTC).Timezone())
fmt.Println("UTC zone name:", carbon.Now().SetTimezone(carbon.UTC).ZoneName())
fmt.Println("UTC zone offset:", carbon.Now().SetTimezone(carbon.UTC).ZoneOffset())

fmt.Println("PRC zone location:", carbon.Now().SetTimezone(carbon.PRC).Timezone())
fmt.Println("PRC zone name:", carbon.Now().SetTimezone(carbon.PRC).ZoneName())
fmt.Println("PRC zone offset:", carbon.Now().SetTimezone(carbon.PRC).ZoneOffset())

fmt.Println("Japan zone location:", carbon.Now().SetTimezone(carbon.Japan).Timezone())
fmt.Println("Japan zone name:", carbon.Now().SetTimezone(carbon.Japan).ZoneName())
fmt.Println("Japan zone offset:", carbon.Now().SetTimezone(carbon.Japan).ZoneOffset())

Output:

UTC zone location: UTC
UTC zone name: UTC
UTC zone offset: 0
PRC zone location: PRC
PRC zone name: CST
PRC zone offset: 28800
Japan zone location: Japan
Japan zone name: JST
Japan zone offset: 32400

func (*Carbon) SetWeekStartsAt 

func (c *Carbon) SetWeekStartsAt(weekDay Weekday) *Carbon

SetWeekStartsAt sets start day of the week.

Example 
fmt.Println("week starts at:", carbon.Now().SetWeekStartsAt(carbon.Sunday).WeekStartsAt())
fmt.Println("week starts at:", carbon.Now().SetWeekStartsAt(carbon.Monday).WeekStartsAt())

Output:

week starts at: Sunday
week starts at: Monday

func (*Carbon) SetWeekendDays added in v2.6.3 

func (c *Carbon) SetWeekendDays(weekDays []Weekday) *Carbon

SetWeekendDays sets weekend days of the week.

Example 
wd1 := []carbon.Weekday{
	carbon.Saturday,
}
fmt.Println(carbon.Parse("2025-04-12").SetWeekendDays(wd1).IsWeekend())
fmt.Println(carbon.Parse("2025-04-13").SetWeekendDays(wd1).IsWeekend())

wd2 := []carbon.Weekday{
	carbon.Sunday,
}
fmt.Println(carbon.Parse("2025-04-12").SetWeekendDays(wd2).IsWeekend())
fmt.Println(carbon.Parse("2025-04-13").SetWeekendDays(wd2).IsWeekend())

Output:

true
false
false
true

func (*Carbon) SetYear 

func (c *Carbon) SetYear(year int) *Carbon

SetYear sets year.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetYear(2019).ToString())
fmt.Println(carbon.Parse("2020-01-31").SetYear(2019).ToString())
fmt.Println(carbon.Parse("2020-02-29").SetYear(2019).ToString())

Output:

2019-01-01 00:00:00 +0000 UTC
2019-01-31 00:00:00 +0000 UTC
2019-03-01 00:00:00 +0000 UTC

func (*Carbon) SetYearNoOverflow 

func (c *Carbon) SetYearNoOverflow(year int) *Carbon

SetYearNoOverflow sets year without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SetYearNoOverflow(2019).ToString())
fmt.Println(carbon.Parse("2020-01-31").SetYearNoOverflow(2019).ToString())
fmt.Println(carbon.Parse("2020-02-29").SetYearNoOverflow(2019).ToString())

Output:

2019-01-01 00:00:00 +0000 UTC
2019-01-31 00:00:00 +0000 UTC
2019-02-28 00:00:00 +0000 UTC

func (*Carbon) StartOfCentury 

func (c *Carbon) StartOfCentury() *Carbon

StartOfCentury returns a Carbon instance for start of the century.

Example 
fmt.Println(carbon.NewCarbon().StartOfCentury().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfCentury().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfCentury().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfCentury().ToString())

Output:

0000-01-01 00:00:00 +0000 UTC
2000-01-01 00:00:00 +0000 UTC
2000-01-01 00:00:00 +0000 UTC
2000-01-01 00:00:00 +0000 UTC

func (*Carbon) StartOfDay 

func (c *Carbon) StartOfDay() *Carbon

StartOfDay returns a Carbon instance for start of the day.

Example 
fmt.Println(carbon.NewCarbon().StartOfDay().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfDay().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfDay().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfDay().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-08-15 00:00:00 +0000 UTC
2020-12-31 00:00:00 +0000 UTC

func (*Carbon) StartOfDecade 

func (c *Carbon) StartOfDecade() *Carbon

StartOfDecade returns a Carbon instance for start of the decade.

Example 
fmt.Println(carbon.NewCarbon().StartOfDecade().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfDecade().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfDecade().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfDecade().ToString())

Output:

0000-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC

func (*Carbon) StartOfHour 

func (c *Carbon) StartOfHour() *Carbon

StartOfHour returns a Carbon instance for start of the hour.

Example 
fmt.Println(carbon.NewCarbon().StartOfHour().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfHour().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfHour().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfHour().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-08-15 12:00:00 +0000 UTC
2020-12-31 23:00:00 +0000 UTC

func (*Carbon) StartOfMinute 

func (c *Carbon) StartOfMinute() *Carbon

StartOfMinute returns a Carbon instance for start of the minute.

Example 
fmt.Println(carbon.NewCarbon().StartOfMinute().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfMinute().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfMinute().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfMinute().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-08-15 12:30:00 +0000 UTC
2020-12-31 23:59:00 +0000 UTC

func (*Carbon) StartOfMonth 

func (c *Carbon) StartOfMonth() *Carbon

StartOfMonth returns a Carbon instance for start of the month.

Example 
fmt.Println(carbon.NewCarbon().StartOfMonth().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfMonth().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfMonth().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfMonth().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-08-01 00:00:00 +0000 UTC
2020-12-01 00:00:00 +0000 UTC

func (*Carbon) StartOfQuarter 

func (c *Carbon) StartOfQuarter() *Carbon

StartOfQuarter returns a Carbon instance for start of the quarter.

Example 
fmt.Println(carbon.NewCarbon().StartOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfQuarter().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfQuarter().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-07-01 00:00:00 +0000 UTC
2020-10-01 00:00:00 +0000 UTC

func (*Carbon) StartOfSeason 

func (c *Carbon) StartOfSeason() *Carbon

StartOfSeason returns a Carbon instance for start of the season.

Example 
fmt.Println(carbon.Parse("2020-01-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-02-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-03-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-04-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-05-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-06-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-07-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-08-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-09-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-10-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-11-15").StartOfSeason().ToString())
fmt.Println(carbon.Parse("2020-12-15").StartOfSeason().ToString())

Output:

2019-12-01 00:00:00 +0000 UTC
2019-12-01 00:00:00 +0000 UTC
2020-03-01 00:00:00 +0000 UTC
2020-03-01 00:00:00 +0000 UTC
2020-03-01 00:00:00 +0000 UTC
2020-06-01 00:00:00 +0000 UTC
2020-06-01 00:00:00 +0000 UTC
2020-06-01 00:00:00 +0000 UTC
2020-09-01 00:00:00 +0000 UTC
2020-09-01 00:00:00 +0000 UTC
2020-09-01 00:00:00 +0000 UTC
2020-12-01 00:00:00 +0000 UTC

func (*Carbon) StartOfSecond 

func (c *Carbon) StartOfSecond() *Carbon

StartOfSecond returns a Carbon instance for start of the second.

Example 
fmt.Println(carbon.NewCarbon().StartOfSecond().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfSecond().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfSecond().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfSecond().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-08-15 12:30:30 +0000 UTC
2020-12-31 23:59:59 +0000 UTC

func (*Carbon) StartOfWeek 

func (c *Carbon) StartOfWeek() *Carbon

StartOfWeek returns a Carbon instance for start of the week.

Example 
fmt.Println(carbon.NewCarbon().StartOfWeek().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfWeek().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfWeek().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfWeek().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2019-12-30 00:00:00 +0000 UTC
2020-08-10 00:00:00 +0000 UTC
2020-12-28 00:00:00 +0000 UTC

func (*Carbon) StartOfYear 

func (c *Carbon) StartOfYear() *Carbon

StartOfYear returns a Carbon instance for start of the year.

Example 
fmt.Println(carbon.NewCarbon().StartOfYear().ToString())
fmt.Println(carbon.Parse("2020-01-01 00:00:00").StartOfYear().ToString())
fmt.Println(carbon.Parse("2020-08-15 12:30:30").StartOfYear().ToString())
fmt.Println(carbon.Parse("2020-12-31 23:59:59").StartOfYear().ToString())

Output:

0001-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC
2020-01-01 00:00:00 +0000 UTC

func (*Carbon) StdTime 

func (c *Carbon) StdTime() StdTime

StdTime gets standard time.Time.

Example 
fmt.Println(carbon.Parse("2020-08-05").StdTime().String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).StdTime().String())

Output:

2020-08-05 00:00:00 +0000 UTC
2020-08-05 00:00:00 +0800 CST

func (*Carbon) String 

func (c *Carbon) String() string

String implements "Stringer" interface for Carbon struct.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").String())

Output:

2020-08-05 13:14:15

func (*Carbon) SubCenturies 

func (c *Carbon) SubCenturies(centuries int) *Carbon

SubCenturies subtracts some centuries.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubCenturies(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubCenturies(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubCenturies(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
1920-01-01 13:14:15 +0000 UTC
1820-01-01 13:14:15 +0000 UTC

func (*Carbon) SubCenturiesNoOverflow 

func (c *Carbon) SubCenturiesNoOverflow(centuries int) *Carbon

SubCenturiesNoOverflow subtracts some centuries without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-02-28 13:14:15").SubCenturiesNoOverflow(0).ToString())
fmt.Println(carbon.Parse("2020-02-28 13:14:15").SubCenturiesNoOverflow(1).ToString())
fmt.Println(carbon.Parse("2020-02-28 13:14:15").SubCenturiesNoOverflow(2).ToString())

Output:

2020-02-28 13:14:15 +0000 UTC
1920-02-28 13:14:15 +0000 UTC
1820-02-28 13:14:15 +0000 UTC

func (*Carbon) SubCentury 

func (c *Carbon) SubCentury() *Carbon

SubCentury subtracts one century.

Example 
fmt.Println(carbon.Parse("2020-02-28 13:14:15").SubCentury().ToString())

Output:

1920-02-28 13:14:15 +0000 UTC

func (*Carbon) SubCenturyNoOverflow 

func (c *Carbon) SubCenturyNoOverflow() *Carbon

SubCenturyNoOverflow subtracts one century without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-02-28 13:14:15").SubCenturyNoOverflow().ToString())

Output:

1920-02-28 13:14:15 +0000 UTC

func (*Carbon) SubDay 

func (c *Carbon) SubDay() *Carbon

SubDay subtracts one day.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubDay().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubDay().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubDay().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubDay().ToDateString())

Output:

2019-12-31
2020-02-27
2020-02-28
2020-11-29

func (*Carbon) SubDays 

func (c *Carbon) SubDays(days int) *Carbon

SubDays subtracts some days.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubDays(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubDays(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubDays(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubDays(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubDays(2).ToDateString())

Output:

2020-01-01
2019-12-31
2019-12-30
2020-02-26
2020-08-29

func (*Carbon) SubDecade 

func (c *Carbon) SubDecade() *Carbon

SubDecade subtracts one decade.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecade().ToString())

Output:

2010-01-01 13:14:15 +0000 UTC

func (*Carbon) SubDecadeNoOverflow 

func (c *Carbon) SubDecadeNoOverflow() *Carbon

SubDecadeNoOverflow subtracts one decade without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecadeNoOverflow().ToString())

Output:

2010-01-01 13:14:15 +0000 UTC

func (*Carbon) SubDecades 

func (c *Carbon) SubDecades(decades int) *Carbon

SubDecades subtracts some decades.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecades(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecades(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecades(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2010-01-01 13:14:15 +0000 UTC
2000-01-01 13:14:15 +0000 UTC

func (*Carbon) SubDecadesNoOverflow 

func (c *Carbon) SubDecadesNoOverflow(decades int) *Carbon

SubDecadesNoOverflow subtracts some decades without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecadesNoOverflow(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecadesNoOverflow(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDecadesNoOverflow(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2010-01-01 13:14:15 +0000 UTC
2000-01-01 13:14:15 +0000 UTC

func (*Carbon) SubDuration 

func (c *Carbon) SubDuration(duration string) *Carbon

SubDuration subtracts duration.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDuration("10h").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDuration("10.5h").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDuration("10m").ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubDuration("10.5m").ToString())

Output:

2020-01-01 03:14:15 +0000 UTC
2020-01-01 02:44:15 +0000 UTC
2020-01-01 13:04:15 +0000 UTC
2020-01-01 13:03:45 +0000 UTC

func (*Carbon) SubHour 

func (c *Carbon) SubHour() *Carbon

SubHour subtracts one hour.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubHour().ToString())

Output:

2020-08-05 12:14:15 +0000 UTC

func (*Carbon) SubHours 

func (c *Carbon) SubHours(hours int) *Carbon

SubHours subtracts some hours.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubHours(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubHours(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubHours(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 12:14:15 +0000 UTC
2020-01-01 11:14:15 +0000 UTC

func (*Carbon) SubMicrosecond 

func (c *Carbon) SubMicrosecond() *Carbon

SubMicrosecond subtracts one microsecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubMicrosecond().ToString())

Output:

2020-08-05 13:14:14.999999 +0000 UTC

func (*Carbon) SubMicroseconds 

func (c *Carbon) SubMicroseconds(microseconds int) *Carbon

SubMicroseconds subtracts some microseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMicroseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMicroseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMicroseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:14.999999 +0000 UTC
2020-01-01 13:14:14.999998 +0000 UTC

func (*Carbon) SubMillisecond 

func (c *Carbon) SubMillisecond() *Carbon

SubMillisecond subtracts one millisecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubMillisecond().ToString())

Output:

2020-08-05 13:14:14.999 +0000 UTC

func (*Carbon) SubMilliseconds 

func (c *Carbon) SubMilliseconds(milliseconds int) *Carbon

SubMilliseconds subtracts some milliseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMilliseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMilliseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMilliseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:14.999 +0000 UTC
2020-01-01 13:14:14.998 +0000 UTC

func (*Carbon) SubMinute 

func (c *Carbon) SubMinute() *Carbon

SubMinute subtracts one minute.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubMinute().ToString())

Output:

2020-08-05 13:13:15 +0000 UTC

func (*Carbon) SubMinutes 

func (c *Carbon) SubMinutes(minutes int) *Carbon

SubMinutes subtracts some minutes.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMinutes(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMinutes(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubMinutes(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:13:15 +0000 UTC
2020-01-01 13:12:15 +0000 UTC

func (*Carbon) SubMonth 

func (c *Carbon) SubMonth() *Carbon

SubMonth subtracts one month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubMonth().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubMonth().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubMonth().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubMonth().ToDateString())

Output:

2019-12-01
2020-01-28
2020-01-29
2020-10-30

func (*Carbon) SubMonthNoOverflow 

func (c *Carbon) SubMonthNoOverflow() *Carbon

SubMonthNoOverflow subtracts one month without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubMonthNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubMonthNoOverflow().ToDateString())

Output:

2019-12-01
2020-01-28
2020-01-29
2020-10-30

func (*Carbon) SubMonths 

func (c *Carbon) SubMonths(months int) *Carbon

SubMonths subtracts some months.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubMonths(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubMonths(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubMonths(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubMonths(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubMonths(2).ToDateString())

Output:

2020-01-01
2019-12-01
2019-11-01
2019-11-29
2020-07-01

func (*Carbon) SubMonthsNoOverflow 

func (c *Carbon) SubMonthsNoOverflow(months int) *Carbon

SubMonthsNoOverflow subtracts some months without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubMonthsNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubMonthsNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubMonthsNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubMonthsNoOverflow(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubMonthsNoOverflow(2).ToDateString())

Output:

2020-01-01
2019-12-01
2019-11-01
2019-11-29
2020-06-30

func (*Carbon) SubNanosecond 

func (c *Carbon) SubNanosecond() *Carbon

SubNanosecond subtracts one nanosecond.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubNanosecond().ToString())

Output:

2020-08-05 13:14:14.999999999 +0000 UTC

func (*Carbon) SubNanoseconds 

func (c *Carbon) SubNanoseconds(nanoseconds int) *Carbon

SubNanoseconds subtracts some nanoseconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubNanoseconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubNanoseconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubNanoseconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:14.999999999 +0000 UTC
2020-01-01 13:14:14.999999998 +0000 UTC

func (*Carbon) SubQuarter 

func (c *Carbon) SubQuarter() *Carbon

SubQuarter subtracts one quarter.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubQuarter().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubQuarter().ToDateString())

Output:

2019-10-01
2019-11-28
2019-11-29
2020-08-30

func (*Carbon) SubQuarterNoOverflow 

func (c *Carbon) SubQuarterNoOverflow() *Carbon

SubQuarterNoOverflow subtracts one quarter without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubQuarterNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubQuarterNoOverflow().ToDateString())

Output:

2019-10-01
2019-11-28
2019-11-29
2020-08-30

func (*Carbon) SubQuarters 

func (c *Carbon) SubQuarters(quarters int) *Carbon

SubQuarters subtracts some quarters.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubQuarters(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubQuarters(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubQuarters(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubQuarters(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubQuarters(2).ToDateString())

Output:

2020-01-01
2019-10-01
2019-07-01
2019-05-29
2020-03-02

func (*Carbon) SubQuartersNoOverflow 

func (c *Carbon) SubQuartersNoOverflow(quarters int) *Carbon

SubQuartersNoOverflow subtracts some quarters without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubQuartersNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubQuartersNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubQuartersNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubQuartersNoOverflow(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubQuartersNoOverflow(2).ToDateString())

Output:

2020-01-01
2019-10-01
2019-07-01
2019-05-29
2020-02-29

func (*Carbon) SubSecond 

func (c *Carbon) SubSecond() *Carbon

SubSecond subtracts one second.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").SubSecond().ToString())

Output:

2020-08-05 13:14:14 +0000 UTC

func (*Carbon) SubSeconds 

func (c *Carbon) SubSeconds(seconds int) *Carbon

SubSeconds subtracts some seconds.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubSeconds(0).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubSeconds(1).ToString())
fmt.Println(carbon.Parse("2020-01-01 13:14:15").SubSeconds(2).ToString())

Output:

2020-01-01 13:14:15 +0000 UTC
2020-01-01 13:14:14 +0000 UTC
2020-01-01 13:14:13 +0000 UTC

func (*Carbon) SubWeek 

func (c *Carbon) SubWeek() *Carbon

SubWeek subtracts one week.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubWeek().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubWeek().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubWeek().ToDateString())
fmt.Println(carbon.Parse("2020-11-30").SubWeek().ToDateString())

Output:

2019-12-25
2020-02-21
2020-02-22
2020-11-23

func (*Carbon) SubWeeks 

func (c *Carbon) SubWeeks(weeks int) *Carbon

SubWeeks subtracts some weeks.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubWeeks(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubWeeks(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubWeeks(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubWeeks(3).ToDateString())
fmt.Println(carbon.Parse("2020-08-31").SubWeeks(2).ToDateString())

Output:

2020-01-01
2019-12-25
2019-12-18
2020-02-08
2020-08-17

func (*Carbon) SubYear 

func (c *Carbon) SubYear() *Carbon

SubYear subtracts one year.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubYear().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubYear().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubYear().ToDateString())

Output:

2019-01-01
2019-02-28
2019-03-01

func (*Carbon) SubYearNoOverflow 

func (c *Carbon) SubYearNoOverflow() *Carbon

SubYearNoOverflow subtracts one year without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubYearNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-28").SubYearNoOverflow().ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubYearNoOverflow().ToDateString())

Output:

2019-01-01
2019-02-28
2019-02-28

func (*Carbon) SubYears 

func (c *Carbon) SubYears(years int) *Carbon

SubYears subtracts some years.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubYears(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubYears(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubYears(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubYears(3).ToDateString())

Output:

2020-01-01
2019-01-01
2018-01-01
2017-03-01

func (*Carbon) SubYearsNoOverflow 

func (c *Carbon) SubYearsNoOverflow(years int) *Carbon

SubYearsNoOverflow subtracts some years without overflowing month.

Example 
fmt.Println(carbon.Parse("2020-01-01").SubYearsNoOverflow(0).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubYearsNoOverflow(1).ToDateString())
fmt.Println(carbon.Parse("2020-01-01").SubYearsNoOverflow(2).ToDateString())
fmt.Println(carbon.Parse("2020-02-29").SubYearsNoOverflow(3).ToDateString())

Output:

2020-01-01
2019-01-01
2018-01-01
2017-02-28

func (*Carbon) Time 

func (c *Carbon) Time() (hour, minute, second int)

Time gets current hour, minute, and second like 13, 14, 15.

Example 
hour, minute, second := carbon.Parse("2020-08-05 13:14:15.999999999").Time()

fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)

Output:

13
14
15

func (*Carbon) TimeMicro 

func (c *Carbon) TimeMicro() (hour, minute, second, microsecond int)

TimeMicro gets current hour, minute, second and microsecond like 13, 14, 15, 999999.

Example 
hour, minute, second, microsecond := carbon.Parse("2020-08-05 13:14:15.999999999").TimeMicro()

fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(microsecond)

Output:

13
14
15
999999

func (*Carbon) TimeMilli 

func (c *Carbon) TimeMilli() (hour, minute, second, millisecond int)

TimeMilli gets current hour, minute, second and millisecond like 13, 14, 15, 999.

Example 
hour, minute, second, millisecond := carbon.Parse("2020-08-05 13:14:15.999999999").TimeMilli()

fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(millisecond)

Output:

13
14
15
999

func (*Carbon) TimeNano 

func (c *Carbon) TimeNano() (hour, minute, second, nanosecond int)

TimeNano gets current hour, minute, second and nanosecond like 13, 14, 15, 999999999.

Example 
hour, minute, second, nanosecond := carbon.Parse("2020-08-05 13:14:15.999999999").TimeNano()

fmt.Println(hour)
fmt.Println(minute)
fmt.Println(second)
fmt.Println(nanosecond)

Output:

13
14
15
999999999

func (*Carbon) Timestamp 

func (c *Carbon) Timestamp() int64

Timestamp gets timestamp with second precision like 1596604455.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15", carbon.PRC).Timestamp())
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").Timestamp())

Output:

1577855655
1596633255

func (*Carbon) TimestampMicro 

func (c *Carbon) TimestampMicro() int64

TimestampMicro gets timestamp with microsecond precision like 1596604455000000.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15", carbon.PRC).TimestampMicro())
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").TimestampMicro())

Output:

1577855655000000
1596633255999999

func (*Carbon) TimestampMilli 

func (c *Carbon) TimestampMilli() int64

TimestampMilli gets timestamp with millisecond precision like 1596604455000.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15", carbon.PRC).TimestampMilli())
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").TimestampMilli())

Output:

1577855655000
1596633255999

func (*Carbon) TimestampNano 

func (c *Carbon) TimestampNano() int64

TimestampNano gets timestamp with nanosecond precision like 1596604455000000000.

Example 
fmt.Println(carbon.Parse("2020-01-01 13:14:15", carbon.PRC).TimestampNano())
fmt.Println(carbon.Parse("2020-08-05 13:14:15.999999999").TimestampNano())

Output:

1577855655000000000
1596633255999999999

func (*Carbon) Timezone 

func (c *Carbon) Timezone() string

Timezone gets timezone location like "Asia/Shanghai".

Example 
fmt.Println(carbon.Now().Timezone())
fmt.Println(carbon.Now(carbon.Tokyo).Timezone())
fmt.Println(carbon.Now(carbon.PRC).Timezone())

Output:

UTC
Asia/Tokyo
PRC

func (*Carbon) ToAnsicString 

func (c *Carbon) ToAnsicString(timezone ...string) string

ToAnsicString outputs a string in "Mon Jan _2 15:04:05 2006" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToAnsicString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToAnsicString())

Output:

Wed Aug  5 13:14:15 2020
Wed Aug  5 00:00:00 2020

func (*Carbon) ToAtomString 

func (c *Carbon) ToAtomString(timezone ...string) string

ToAtomString outputs a string in "2006-01-02T15:04:05Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToAtomString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToAtomString())

Output:

2020-08-05T13:14:15Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToCookieString 

func (c *Carbon) ToCookieString(timezone ...string) string

ToCookieString outputs a string in "Monday, 02-Jan-2006 15:04:05 MST" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToCookieString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToCookieString())

Output:

Wednesday, 05-Aug-2020 13:14:15 UTC
Wednesday, 05-Aug-2020 00:00:00 CST

func (*Carbon) ToDateMicroString 

func (c *Carbon) ToDateMicroString(timezone ...string) string

ToDateMicroString outputs a string in "2006-01-02.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateMicroString())

Output:

2020-08-05.999999
2020-08-05

func (*Carbon) ToDateMilliString 

func (c *Carbon) ToDateMilliString(timezone ...string) string

ToDateMilliString outputs a string in "2006-01-02.999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateMilliString())

Output:

2020-08-05.999
2020-08-05

func (*Carbon) ToDateNanoString 

func (c *Carbon) ToDateNanoString(timezone ...string) string

ToDateNanoString outputs a string in "2006-01-02.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateNanoString())

Output:

2020-08-05.999999999
2020-08-05

func (*Carbon) ToDateString 

func (c *Carbon) ToDateString(timezone ...string) string

ToDateString outputs a string in "2006-01-02" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateString())

Output:

2020-08-05
2020-08-05

func (*Carbon) ToDateTimeMicroString 

func (c *Carbon) ToDateTimeMicroString(timezone ...string) string

ToDateTimeMicroString outputs a string in "2006-01-02 15:04:05.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateTimeMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateTimeMicroString())

Output:

2020-08-05 13:14:15.999999
2020-08-05 00:00:00

func (*Carbon) ToDateTimeMilliString 

func (c *Carbon) ToDateTimeMilliString(timezone ...string) string

ToDateTimeMilliString outputs a string in "2006-01-02 15:04:05.999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateTimeMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateTimeMilliString())

Output:

2020-08-05 13:14:15.999
2020-08-05 00:00:00

func (*Carbon) ToDateTimeNanoString 

func (c *Carbon) ToDateTimeNanoString(timezone ...string) string

ToDateTimeNanoString outputs a string in "2006-01-02 15:04:05.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateTimeNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateTimeNanoString())

Output:

2020-08-05 13:14:15.999999999
2020-08-05 00:00:00

func (*Carbon) ToDateTimeString 

func (c *Carbon) ToDateTimeString(timezone ...string) string

ToDateTimeString outputs a string in "2006-01-02 15:04:05" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToDateTimeString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDateTimeString())

Output:

2020-08-05 13:14:15
2020-08-05 00:00:00

func (*Carbon) ToDayDateTimeString 

func (c *Carbon) ToDayDateTimeString(timezone ...string) string

ToDayDateTimeString outputs a string in "Mon, Jan 2, 2006 3:04 PM" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").ToDayDateTimeString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToDayDateTimeString())

Output:

Wed, Aug 5, 2020 1:14 PM
Wed, Aug 5, 2020 12:00 AM

func (*Carbon) ToFormattedDateString 

func (c *Carbon) ToFormattedDateString(timezone ...string) string

ToFormattedDateString outputs a string in "Jan 2, 2006" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToFormattedDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToFormattedDateString())

Output:

Aug 5, 2020
Aug 5, 2020

func (*Carbon) ToFormattedDayDateString 

func (c *Carbon) ToFormattedDayDateString(timezone ...string) string

ToFormattedDayDateString outputs a string in "Mon, Jan 2, 2006" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToFormattedDayDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToFormattedDayDateString())

Output:

Wed, Aug 5, 2020
Wed, Aug 5, 2020

func (*Carbon) ToHttpString added in v2.6.15 

func (c *Carbon) ToHttpString(timezone ...string) string

ToHttpString outputs a string in "Mon, 02 Jan 2006 15:04:05 GMT" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToHttpString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToHttpString())

Output:

Wed, 05 Aug 2020 13:14:15 GMT
Wed, 05 Aug 2020 00:00:00 GMT

func (*Carbon) ToIso8601MicroString 

func (c *Carbon) ToIso8601MicroString(timezone ...string) string

ToIso8601MicroString outputs a string in "2006-01-02T15:04:05.999999-07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601MicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601MicroString())

Output:

2020-08-05T13:14:15.999999+00:00
2020-08-05T00:00:00+08:00

func (*Carbon) ToIso8601MilliString 

func (c *Carbon) ToIso8601MilliString(timezone ...string) string

ToIso8601MilliString outputs a string in "2006-01-02T15:04:05.999-07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601MilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601MilliString())

Output:

2020-08-05T13:14:15.999+00:00
2020-08-05T00:00:00+08:00

func (*Carbon) ToIso8601NanoString 

func (c *Carbon) ToIso8601NanoString(timezone ...string) string

ToIso8601NanoString outputs a string in "2006-01-02T15:04:05.999999999-07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601NanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601NanoString())

Output:

2020-08-05T13:14:15.999999999+00:00
2020-08-05T00:00:00+08:00

func (*Carbon) ToIso8601String 

func (c *Carbon) ToIso8601String(timezone ...string) string

ToIso8601String outputs a string in "2006-01-02T15:04:05-07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601String())

Output:

2020-08-05T13:14:15+00:00
2020-08-05T00:00:00+08:00

func (*Carbon) ToIso8601ZuluMicroString 

func (c *Carbon) ToIso8601ZuluMicroString(timezone ...string) string

ToIso8601ZuluMicroString outputs a string in "2006-01-02T15:04:05.999999Z" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601ZuluMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601ZuluMicroString())

Output:

2020-08-05T13:14:15.999999Z
2020-08-05T00:00:00Z

func (*Carbon) ToIso8601ZuluMilliString 

func (c *Carbon) ToIso8601ZuluMilliString(timezone ...string) string

ToIso8601ZuluMilliString outputs a string in "2006-01-02T15:04:05.999Z" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601ZuluMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601ZuluMilliString())

Output:

2020-08-05T13:14:15.999Z
2020-08-05T00:00:00Z

func (*Carbon) ToIso8601ZuluNanoString 

func (c *Carbon) ToIso8601ZuluNanoString(timezone ...string) string

ToIso8601ZuluNanoString outputs a string in "2006-01-02T15:04:05.999999999Z" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601ZuluNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601ZuluNanoString())

Output:

2020-08-05T13:14:15.999999999Z
2020-08-05T00:00:00Z

func (*Carbon) ToIso8601ZuluString 

func (c *Carbon) ToIso8601ZuluString(timezone ...string) string

ToIso8601ZuluString outputs a string in "2006-01-02T15:04:05Z" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToIso8601ZuluString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToIso8601ZuluString())

Output:

2020-08-05T13:14:15Z
2020-08-05T00:00:00Z

func (*Carbon) ToKitchenString 

func (c *Carbon) ToKitchenString(timezone ...string) string

ToKitchenString outputs a string in "3:04PM" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToKitchenString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToKitchenString())

Output:

1:14PM
12:00AM

func (*Carbon) ToMonthString 

func (c *Carbon) ToMonthString(timezone ...string) string

ToMonthString outputs a string in month layout like "January", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-01-05").ToMonthString())
fmt.Println(carbon.Parse("2020-02-05").ToMonthString())
fmt.Println(carbon.Parse("2020-03-05").ToMonthString())
fmt.Println(carbon.Parse("2020-04-05").ToMonthString())
fmt.Println(carbon.Parse("2020-05-05").ToMonthString())
fmt.Println(carbon.Parse("2020-06-05").ToMonthString())
fmt.Println(carbon.Parse("2020-07-05").ToMonthString())
fmt.Println(carbon.Parse("2020-08-05").ToMonthString())
fmt.Println(carbon.Parse("2020-09-05").ToMonthString())
fmt.Println(carbon.Parse("2020-10-05").ToMonthString())
fmt.Println(carbon.Parse("2020-11-05").ToMonthString())
fmt.Println(carbon.Parse("2020-12-05").ToMonthString())

Output:

January
February
March
April
May
June
July
August
September
October
November
December

func (*Carbon) ToRfc1036String 

func (c *Carbon) ToRfc1036String(timezone ...string) string

ToRfc1036String outputs a string in "Mon, 02 Jan 06 15:04:05 -0700" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc1036String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc1036String())

Output:

Wed, 05 Aug 20 13:14:15 +0000
Wed, 05 Aug 20 00:00:00 +0800

func (*Carbon) ToRfc1123String 

func (c *Carbon) ToRfc1123String(timezone ...string) string

ToRfc1123String outputs a string in "Mon, 02 Jan 2006 15:04:05 MST" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc1123String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc1123String())

Output:

Wed, 05 Aug 2020 13:14:15 UTC
Wed, 05 Aug 2020 00:00:00 CST

func (*Carbon) ToRfc1123zString 

func (c *Carbon) ToRfc1123zString(timezone ...string) string

ToRfc1123zString outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc1123zString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc1123zString())

Output:

Wed, 05 Aug 2020 13:14:15 +0000
Wed, 05 Aug 2020 00:00:00 +0800

func (*Carbon) ToRfc2822String 

func (c *Carbon) ToRfc2822String(timezone ...string) string

ToRfc2822String outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc2822String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc2822String())

Output:

Wed, 05 Aug 2020 13:14:15 +0000
Wed, 05 Aug 2020 00:00:00 +0800

func (*Carbon) ToRfc3339MicroString 

func (c *Carbon) ToRfc3339MicroString(timezone ...string) string

ToRfc3339MicroString outputs a string in "2006-01-02T15:04:05.999999Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc3339MicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc3339MicroString())

Output:

2020-08-05T13:14:15.999999Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToRfc3339MilliString 

func (c *Carbon) ToRfc3339MilliString(timezone ...string) string

ToRfc3339MilliString outputs a string in "2006-01-02T15:04:05.999Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc3339MilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc3339MilliString())

Output:

2020-08-05T13:14:15.999Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToRfc3339NanoString 

func (c *Carbon) ToRfc3339NanoString(timezone ...string) string

ToRfc3339NanoString outputs a string in "2006-01-02T15:04:05.999999999Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc3339NanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc3339NanoString())

Output:

2020-08-05T13:14:15.999999999Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToRfc3339String 

func (c *Carbon) ToRfc3339String(timezone ...string) string

ToRfc3339String outputs a string in "2006-01-02T15:04:05Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc3339String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc3339String())

Output:

2020-08-05T13:14:15Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToRfc7231String 

func (c *Carbon) ToRfc7231String(timezone ...string) string

ToRfc7231String outputs a string in "Mon, 02 Jan 2006 15:04:05 GMT" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc7231String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc7231String())

Output:

Wed, 05 Aug 2020 13:14:15 UTC
Wed, 05 Aug 2020 00:00:00 CST

func (*Carbon) ToRfc822String 

func (c *Carbon) ToRfc822String(timezone ...string) string

ToRfc822String outputs a string in "02 Jan 06 15:04 MST" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc822String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc822String())

Output:

05 Aug 20 13:14 UTC
05 Aug 20 00:00 CST

func (*Carbon) ToRfc822zString 

func (c *Carbon) ToRfc822zString(timezone ...string) string

ToRfc822zString outputs a string in "02 Jan 06 15:04 -0700" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc822zString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc822zString())

Output:

05 Aug 20 13:14 +0000
05 Aug 20 00:00 +0800

func (*Carbon) ToRfc850String 

func (c *Carbon) ToRfc850String(timezone ...string) string

ToRfc850String outputs a string in "Monday, 02-Jan-06 15:04:05 MST" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRfc850String())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRfc850String())

Output:

Wednesday, 05-Aug-20 13:14:15 UTC
Wednesday, 05-Aug-20 00:00:00 CST

func (*Carbon) ToRssString 

func (c *Carbon) ToRssString(timezone ...string) string

ToRssString outputs a string in "Mon, 02 Jan 2006 15:04:05 -0700" format.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRssString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRssString())

Output:

Wed, 05 Aug 2020 13:14:15 +0000
Wed, 05 Aug 2020 00:00:00 +0800

func (*Carbon) ToRubyDateString 

func (c *Carbon) ToRubyDateString(timezone ...string) string

ToRubyDateString outputs a string in "Mon Jan 02 15:04:05 -0700 2006" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToRubyDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToRubyDateString())

Output:

Wed Aug 05 13:14:15 +0000 2020
Wed Aug 05 00:00:00 +0800 2020

func (*Carbon) ToShortDateMicroString 

func (c *Carbon) ToShortDateMicroString(timezone ...string) string

ToShortDateMicroString outputs a string in "20060102.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateMicroString())

Output:

20200805.999999
20200805

func (*Carbon) ToShortDateMilliString 

func (c *Carbon) ToShortDateMilliString(timezone ...string) string

ToShortDateMilliString outputs a string in "20060102.999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateMilliString())

Output:

20200805.999
20200805

func (*Carbon) ToShortDateNanoString 

func (c *Carbon) ToShortDateNanoString(timezone ...string) string

ToShortDateNanoString outputs a string in "20060102.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateNanoString())

Output:

20200805.999999999
20200805

func (*Carbon) ToShortDateString 

func (c *Carbon) ToShortDateString(timezone ...string) string

ToShortDateString outputs a string in "20060102" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateString())

Output:

20200805
20200805

func (*Carbon) ToShortDateTimeMicroString 

func (c *Carbon) ToShortDateTimeMicroString(timezone ...string) string

ToShortDateTimeMicroString outputs a string in "20060102150405.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateTimeMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateTimeMicroString())

Output:

20200805131415.999999
20200805000000

func (*Carbon) ToShortDateTimeMilliString 

func (c *Carbon) ToShortDateTimeMilliString(timezone ...string) string

ToShortDateTimeMilliString outputs a string in "20060102150405.999" layout. 输出 "20060102150405.999" 格式字符串

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateTimeMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateTimeMilliString())

Output:

20200805131415.999
20200805000000

func (*Carbon) ToShortDateTimeNanoString 

func (c *Carbon) ToShortDateTimeNanoString(timezone ...string) string

ToShortDateTimeNanoString outputs a string in "20060102150405.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateTimeNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateTimeNanoString())

Output:

20200805131415.999999999
20200805000000

func (*Carbon) ToShortDateTimeString 

func (c *Carbon) ToShortDateTimeString(timezone ...string) string

ToShortDateTimeString outputs a string in "20060102150405" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortDateTimeString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortDateTimeString())

Output:

20200805131415
20200805000000

func (*Carbon) ToShortMonthString 

func (c *Carbon) ToShortMonthString(timezone ...string) string

ToShortMonthString outputs a string in short month layout like "Jan", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-01-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-02-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-03-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-04-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-05-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-06-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-07-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-08-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-09-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-10-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-11-05").ToShortMonthString())
fmt.Println(carbon.Parse("2020-12-05").ToShortMonthString())

Output:

Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Oct
Nov
Dec

func (*Carbon) ToShortTimeMicroString 

func (c *Carbon) ToShortTimeMicroString(timezone ...string) string

ToShortTimeMicroString outputs a string in "150405.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortTimeMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortTimeMicroString())

Output:

131415.999999
000000

func (*Carbon) ToShortTimeMilliString 

func (c *Carbon) ToShortTimeMilliString(timezone ...string) string

ToShortTimeMilliString outputs a string in "150405.999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortTimeMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortTimeMilliString())

Output:

131415.999
000000

func (*Carbon) ToShortTimeNanoString 

func (c *Carbon) ToShortTimeNanoString(timezone ...string) string

ToShortTimeNanoString outputs a string in "150405.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortTimeNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortTimeNanoString())

Output:

131415.999999999
000000

func (*Carbon) ToShortTimeString 

func (c *Carbon) ToShortTimeString(timezone ...string) string

ToShortTimeString outputs a string in "150405" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToShortTimeString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToShortTimeString())

Output:

131415
000000

func (*Carbon) ToShortWeekString 

func (c *Carbon) ToShortWeekString(timezone ...string) string

ToShortWeekString outputs a string in short week layout like "Sun", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-08-01").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-02").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-03").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-04").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-05").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-06").ToShortWeekString())
fmt.Println(carbon.Parse("2020-08-07").ToShortWeekString())

Output:

Sat
Sun
Mon
Tue
Wed
Thu
Fri

func (*Carbon) ToString 

func (c *Carbon) ToString(timezone ...string) string

ToString outputs a string in "2006-01-02 15:04:05.999999999 -0700 MST" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05 13:14:15").ToString())
fmt.Println(carbon.Parse("2020-08-05 13:14:15", carbon.PRC).ToString())

Output:

2020-08-05 13:14:15 +0000 UTC
2020-08-05 13:14:15 +0800 CST

func (*Carbon) ToTimeMicroString 

func (c *Carbon) ToTimeMicroString(timezone ...string) string

ToTimeMicroString outputs a string in "15:04:05.999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToTimeMicroString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToTimeMicroString())

Output:

13:14:15.999999
00:00:00

func (*Carbon) ToTimeMilliString 

func (c *Carbon) ToTimeMilliString(timezone ...string) string

ToTimeMilliString outputs a string in "15:04:05.999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToTimeMilliString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToTimeMilliString())

Output:

13:14:15.999
00:00:00

func (*Carbon) ToTimeNanoString 

func (c *Carbon) ToTimeNanoString(timezone ...string) string

ToTimeNanoString outputs a string in "15:04:05.999999999" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToTimeNanoString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToTimeNanoString())

Output:

13:14:15.999999999
00:00:00

func (*Carbon) ToTimeString 

func (c *Carbon) ToTimeString(timezone ...string) string

ToTimeString outputs a string in "15:04:05" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToTimeString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToTimeString())

Output:

13:14:15
00:00:00

func (*Carbon) ToUnixDateString 

func (c *Carbon) ToUnixDateString(timezone ...string) string

ToUnixDateString outputs a string in "Mon Jan _2 15:04:05 MST 2006" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToUnixDateString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToUnixDateString())

Output:

Wed Aug  5 13:14:15 UTC 2020
Wed Aug  5 00:00:00 CST 2020

func (*Carbon) ToW3cString 

func (c *Carbon) ToW3cString(timezone ...string) string

ToW3cString outputs a string in "2006-01-02T15:04:05Z07:00" layout.

Example 
fmt.Println(carbon.Parse("2020-08-05T13:14:15.999999999+00:00").ToW3cString())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ToW3cString())

Output:

2020-08-05T13:14:15Z
2020-08-05T00:00:00+08:00

func (*Carbon) ToWeekString 

func (c *Carbon) ToWeekString(timezone ...string) string

ToWeekString outputs a string in week layout like "Sunday", i18n is supported.

Example 
fmt.Println(carbon.Parse("2020-08-01").ToWeekString())
fmt.Println(carbon.Parse("2020-08-02").ToWeekString())
fmt.Println(carbon.Parse("2020-08-03").ToWeekString())
fmt.Println(carbon.Parse("2020-08-04").ToWeekString())
fmt.Println(carbon.Parse("2020-08-05").ToWeekString())
fmt.Println(carbon.Parse("2020-08-06").ToWeekString())
fmt.Println(carbon.Parse("2020-08-07").ToWeekString())

Output:

Saturday
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday

func (*Carbon) UnmarshalJSON 

func (c *Carbon) UnmarshalJSON(src []byte) error

UnmarshalJSON implements "json.Unmarshaler" interface for Carbon struct.

Example 
type User struct {
	Carbon1 carbon.Carbon  `json:"carbon1"`
	Carbon2 *carbon.Carbon `json:"carbon2"`
}

var user User

value := `{"carbon1":"2020-08-05 13:14:15","carbon2":"2020-08-05 13:14:15"}`
_ = json.Unmarshal([]byte(value), &user)

fmt.Println("user.Carbon1:", user.Carbon1.String())
fmt.Println("user.Carbon2:", user.Carbon2.String())

Output:

user.Carbon1: 2020-08-05 13:14:15
user.Carbon2: 2020-08-05 13:14:15

func (Carbon) Value 

func (c Carbon) Value() (driver.Value, error)

Value implements "driver.Valuer" interface for Carbon struct.

func (*Carbon) Week 

func (c *Carbon) Week() int

Week gets current week like 6, start from 0.

Example 
fmt.Println(carbon.Parse("2020-08-03").Week())
fmt.Println(carbon.Parse("2020-08-04").Week())
fmt.Println(carbon.Parse("2020-08-05").Week())
fmt.Println(carbon.Parse("2020-08-09").Week())

Output:

0
1
2
6

func (*Carbon) WeekEndsAt added in v2.6.3 

func (c *Carbon) WeekEndsAt() Weekday

WeekEndsAt returns end day of the week.

Example 
fmt.Println(carbon.Now().SetWeekStartsAt(carbon.Sunday).WeekEndsAt())
fmt.Println(carbon.Now().SetWeekStartsAt(carbon.Monday).WeekEndsAt())

Output:

Saturday
Sunday

func (*Carbon) WeekOfMonth 

func (c *Carbon) WeekOfMonth() int

WeekOfMonth gets week of month like 1.

Example 
fmt.Println(carbon.Parse("2021-07-01").WeekOfMonth())
fmt.Println(carbon.Parse("2021-07-02").WeekOfMonth())
fmt.Println(carbon.Parse("2021-07-03").WeekOfMonth())
fmt.Println(carbon.Parse("2021-07-04").WeekOfMonth())
fmt.Println(carbon.Parse("2021-07-05").WeekOfMonth())
fmt.Println(carbon.Parse("2021-07-06").WeekOfMonth())

Output:

1
1
1
1
2
2

func (*Carbon) WeekOfYear 

func (c *Carbon) WeekOfYear() int

WeekOfYear gets week of year like 1.

refer to https://en.wikipedia.org/wiki/ISO_8601#Week_dates.

Example 
fmt.Println(carbon.Parse("2021-01-01").WeekOfYear())
fmt.Println(carbon.Parse("2021-02-01").WeekOfYear())
fmt.Println(carbon.Parse("2021-03-01").WeekOfYear())
fmt.Println(carbon.Parse("2021-04-01").WeekOfYear())

Output:

53
5
9
13

func (*Carbon) WeekStartsAt added in v2.6.0 

func (c *Carbon) WeekStartsAt() Weekday

WeekStartsAt returns start day of the week.

Example 
fmt.Println(carbon.Now().SetWeekStartsAt(carbon.Sunday).WeekStartsAt())
fmt.Println(carbon.Now().SetWeekStartsAt(carbon.Monday).WeekStartsAt())

Output:

Sunday
Monday

func (*Carbon) Year 

func (c *Carbon) Year() int

Year gets current year like 2020.

Example 
fmt.Println(carbon.Parse("2010-08-05").Year())
fmt.Println(carbon.Parse("2011-08-05").Year())
fmt.Println(carbon.Parse("2020-08-05").Year())
fmt.Println(carbon.Parse("2021-08-05").Year())

Output:

2010
2011
2020
2021

func (*Carbon) ZoneName added in v2.6.0 

func (c *Carbon) ZoneName() string

ZoneName gets timezone name like "CST".

Example 
fmt.Println(carbon.Now().ZoneName())
fmt.Println(carbon.Now(carbon.Tokyo).ZoneName())
fmt.Println(carbon.Now(carbon.PRC).ZoneName())

Output:

UTC
JST
CST

func (*Carbon) ZoneOffset added in v2.6.0 

func (c *Carbon) ZoneOffset() int

ZoneOffset gets timezone offset seconds from the UTC timezone like 28800.

Example 
fmt.Println(carbon.Parse("2020-08-05").ZoneOffset())
fmt.Println(carbon.Parse("2020-08-05", carbon.Tokyo).ZoneOffset())
fmt.Println(carbon.Parse("2020-08-05", carbon.PRC).ZoneOffset())

Output:

0
32400
28800

type Date 

type Date = LayoutType[dateType]

func NewDate 

func NewDate(c *Carbon) *Date

type DateMicro 

type DateMicro = LayoutType[dateMicroType]

func NewDateMicro 

func NewDateMicro(c *Carbon) *DateMicro

type DateMilli 

type DateMilli = LayoutType[dateMilliType]

func NewDateMilli 

func NewDateMilli(c *Carbon) *DateMilli

type DateNano 

type DateNano = LayoutType[dateNanoType]

func NewDateNano 

func NewDateNano(c *Carbon) *DateNano

type DateTime 

type DateTime = LayoutType[datetimeType]

func NewDateTime 

func NewDateTime(c *Carbon) *DateTime

type DateTimeMicro 

type DateTimeMicro = LayoutType[datetimeMicroType]

func NewDateTimeMicro 

func NewDateTimeMicro(c *Carbon) *DateTimeMicro

type DateTimeMilli 

type DateTimeMilli = LayoutType[datetimeMilliType]

func NewDateTimeMilli 

func NewDateTimeMilli(c *Carbon) *DateTimeMilli

type DateTimeNano 

type DateTimeNano = LayoutType[datetimeNanoType]

func NewDateTimeNano 

func NewDateTimeNano(c *Carbon) *DateTimeNano

type Default 

type Default struct {
	Layout       string
	Timezone     string
	Locale       string
	WeekStartsAt Weekday
	WeekendDays  []Weekday
}

type Duration added in v2.6.3 

type Duration = time.Duration

func MaxDuration added in v2.6.2 

func MaxDuration() Duration

MaxDuration returns the maximum value of duration instance.

Example 
fmt.Println(carbon.MaxDuration().Seconds())

Output:

9.223372036854776e+09

func MinDuration added in v2.6.2 

func MinDuration() Duration

MinDuration returns the minimum value of duration instance.

Example 
fmt.Println(carbon.MinDuration().Seconds())

Output:

-9.223372036854776e+09

type FormatType added in v2.6.0 

type FormatType[T FormatTyper] struct {
	*Carbon
}

FormatType defines a FormatType generic struct.

func NewFormatType added in v2.6.0 

func NewFormatType[T FormatTyper](c *Carbon) *FormatType[T]

NewFormatType returns a new FormatType generic instance.

func (FormatType[T]) MarshalJSON added in v2.6.0 

func (t FormatType[T]) MarshalJSON() ([]byte, error)

MarshalJSON implements "json.Marshaler" interface for FormatType generic struct.

Example 
// type RFC3339Type string
//
// func (RFC3339Type) Format() string {
//	return carbon.RFC3339Format
// }
type User struct {
	Customer1 carbon.FormatType[RFC3339Type]  `json:"customer1"`
	Customer2 *carbon.FormatType[RFC3339Type] `json:"customer2"`
}

c := carbon.Parse("2020-08-05 13:14:15.999999999")

user := User{
	Customer1: *carbon.NewFormatType[RFC3339Type](c),
	Customer2: carbon.NewFormatType[RFC3339Type](c),
}

data, _ := json.Marshal(&user)
fmt.Printf("%s", data)

Output:

{"customer1":"2020-08-05T13:14:15Z","customer2":"2020-08-05T13:14:15Z"}

func (*FormatType[T]) Scan added in v2.6.0 

func (t *FormatType[T]) Scan(src any) error

Scan implements "driver.Scanner" interface for FormatType generic struct.

func (*FormatType[T]) String added in v2.6.0 

func (t *FormatType[T]) String() string

String implements "Stringer" interface for FormatType generic struct.

Example 
c := carbon.Parse("2020-08-05 13:14:15.999999999")
fmt.Println(carbon.NewFormatType[RFC3339Type](c).String())

Output:

2020-08-05T13:14:15Z

func (*FormatType[T]) UnmarshalJSON added in v2.6.0 

func (t *FormatType[T]) UnmarshalJSON(src []byte) error

UnmarshalJSON implements "json.Unmarshaler" interface for FormatType generic struct.

Example 
// type RFC3339Type string
//
// func (RFC3339Type) Format() string {
//	return carbon.RFC3339Format
// }

type User struct {
	Customer1 carbon.FormatType[RFC3339Type]  `json:"customer1"`
	Customer2 *carbon.FormatType[RFC3339Type] `json:"customer2"`
}

var user User

value := `{"customer1":"2020-08-05T13:14:15Z","customer2":"2020-08-05T13:14:15Z"}`
_ = json.Unmarshal([]byte(value), &user)

fmt.Println("user.Customer1:", user.Customer1.String())
fmt.Println("user.Customer2:", user.Customer2.String())

Output:

user.Customer1: 2020-08-05T13:14:15Z
user.Customer2: 2020-08-05T13:14:15Z

func (FormatType[T]) Value added in v2.6.0 

func (t FormatType[T]) Value() (driver.Value, error)

Value implements "driver.Valuer" interface for FormatType generic struct.

type FormatTyper added in v2.6.4 

type FormatTyper interface {
	~string
	Format() string
}

FormatTyper defines a FormatTyper interface.

type FrozenNow added in v2.6.3 

type FrozenNow struct {
	// contains filtered or unexported fields
}

FrozenNow defines a FrozenNow struct.

type Language 

type Language struct {
	Error error
	// contains filtered or unexported fields
}

Language defines a Language struct.

func NewLanguage 

func NewLanguage() *Language

NewLanguage returns a new Language instance.

func (*Language) Copy added in v2.6.4 

func (lang *Language) Copy() *Language

Copy returns a new copy of the current Language instance

func (*Language) SetLocale 

func (lang *Language) SetLocale(locale string) *Language

SetLocale sets language locale.

Example 
lang := carbon.NewLanguage()

lang.SetLocale("en")
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).Constellation())
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).Season())
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).DiffForHumans(carbon.Parse("2024-08-05")))
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).ToMonthString())
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).ToShortMonthString())
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).ToWeekString())
fmt.Printf("en:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang).ToShortWeekString())

lang.SetLocale("zh-CN")
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).Constellation())
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).Season())
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).DiffForHumans(carbon.Parse("2024-08-05")))
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).ToMonthString())
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).ToShortMonthString())
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).ToWeekString())
fmt.Printf("zh-CN:%s\n", carbon.Parse("2020-08-05", carbon.PRC).SetLanguage(lang).ToShortWeekString())

Output:

en:Leo
en:Summer
en:4 years before
en:August
en:Aug
en:Wednesday
en:Wed
zh-CN:狮子座
zh-CN:夏季
zh-CN:4 年前
zh-CN:八月
zh-CN:8月
zh-CN:星期三
zh-CN:周三

func (*Language) SetResources 

func (lang *Language) SetResources(resources map[string]string) *Language

SetResources sets language resources.

Example 
resources1 := map[string]string{
	"months":       "Ⅰ月|Ⅱ月|Ⅲ月|Ⅳ月|Ⅴ月|Ⅵ月|Ⅶ月|Ⅷ月|Ⅸ月|Ⅹ月|Ⅺ月|Ⅻ月",
	"short_months": "Ⅰ|Ⅱ|Ⅲ|Ⅳ|Ⅴ|Ⅵ|Ⅶ|Ⅷ|Ⅸ|Ⅹ|Ⅺ|Ⅻ",
}

lang1 := carbon.NewLanguage()
lang1.SetLocale("en").SetResources(resources1)

fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).Constellation())
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).Season())
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).DiffForHumans(carbon.Parse("2024-08-05")))
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).ToMonthString())
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).ToShortMonthString())
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).ToWeekString())
fmt.Printf("lang1:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang1).ToShortWeekString())

resources2 := map[string]string{
	"constellations": "Aries|Taurus|Gemini|Cancer|Leo|Virgo|Libra|Scorpio|Sagittarius|Capricorn|Aquarius|Pisces",
	"seasons":        "spring|summer|autumn|winter",
	"months":         "January|February|March|April|May|June|July|August|September|October|November|December",
	"short_months":   "Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec",
	"weeks":          "Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday",
	"short_weeks":    "Sun|Mon|Tue|Wed|Thu|Fri|Sat",
	"year":           "1 yr|%d yrs",
	"month":          "1 mo|%d mos",
	"week":           "%dw",
	"day":            "%dd",
	"hour":           "%dh",
	"minute":         "%dm",
	"second":         "%ds",
	"now":            "just now",
	"ago":            "%s ago",
	"from_now":       "in %s",
	"before":         "%s before",
	"after":          "%s after",
}

lang2 := carbon.NewLanguage()
lang2.SetResources(resources2)

fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).Constellation())
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).Season())
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).DiffForHumans(carbon.Parse("2024-08-05")))
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).ToMonthString())
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).ToShortMonthString())
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).ToWeekString())
fmt.Printf("lang2:%s\n", carbon.Parse("2020-08-05").SetLanguage(lang2).ToShortWeekString())

Output:

lang1:Leo
lang1:Summer
lang1:4 years before
lang1:Ⅷ月
lang1:Ⅷ
lang1:Wednesday
lang1:Wed
lang2:Leo
lang2:summer
lang2:4 yrs before
lang2:August
lang2:Aug
lang2:Wednesday
lang2:Wed

type LayoutType added in v2.6.0 

type LayoutType[T LayoutTyper] struct {
	*Carbon
}

LayoutType defines a LayoutType generic struct

func NewLayoutType added in v2.6.0 

func NewLayoutType[T LayoutTyper](c *Carbon) *LayoutType[T]

NewLayoutType returns a new LayoutType generic instance.

func (LayoutType[T]) MarshalJSON added in v2.6.0 

func (t LayoutType[T]) MarshalJSON() ([]byte, error)

MarshalJSON implements "json.Marshaler" interface for LayoutType generic struct.

Example 
// type W3CType string
//
// func (W3CType) Layout() string {
//	return carbon.W3cLayout
// }

type User struct {
	Date     carbon.Date                `json:"date"`
	Time     carbon.Time                `json:"time"`
	DateTime carbon.DateTime            `json:"date_time"`
	Customer carbon.LayoutType[W3CType] `json:"customer"`

	CreatedAt *carbon.DateTime `json:"created_at"`
	UpdatedAt *carbon.DateTime `json:"updated_at"`
}

c := carbon.Parse("2020-08-05 13:14:15.999999999")

user := User{
	Date:     *carbon.NewDate(c),
	Time:     *carbon.NewTime(c),
	DateTime: *carbon.NewDateTime(c),
	Customer: *carbon.NewLayoutType[W3CType](c),

	CreatedAt: carbon.NewDateTime(c),
	UpdatedAt: carbon.NewDateTime(c),
}

data, _ := json.Marshal(&user)
fmt.Printf("%s", data)

Output:

{"date":"2020-08-05","time":"13:14:15","date_time":"2020-08-05 13:14:15","customer":"2020-08-05T13:14:15Z","created_at":"2020-08-05 13:14:15","updated_at":"2020-08-05 13:14:15"}

func (*LayoutType[T]) Scan added in v2.6.0 

func (t *LayoutType[T]) Scan(src any) error

Scan implements "driver.Scanner" interface for LayoutType generic struct.

func (*LayoutType[T]) String added in v2.6.0 

func (t *LayoutType[T]) String() string

String implements "Stringer" interface for LayoutType generic struct.

Example 
c := carbon.Parse("2020-08-05 13:14:15.999999999")

fmt.Println("carbon.Date:", carbon.NewDate(c).String())
fmt.Println("carbon.Time:", carbon.NewTime(c).String())
fmt.Println("carbon.DateTime:", carbon.NewDateTime(c).String())
fmt.Println("Customer:", carbon.NewLayoutType[W3CType](c).String())

Output:

carbon.Date: 2020-08-05
carbon.Time: 13:14:15
carbon.DateTime: 2020-08-05 13:14:15
Customer: 2020-08-05T13:14:15Z

func (*LayoutType[T]) UnmarshalJSON added in v2.6.0 

func (t *LayoutType[T]) UnmarshalJSON(src []byte) error

UnmarshalJSON implements "json.Unmarshaler" interface for LayoutType generic struct.

Example 
// type W3CType string
//
// func (W3CType) Layout() string {
//	return carbon.W3cLayout
// }
type User struct {
	Date     carbon.Date                `json:"date"`
	Time     carbon.Time                `json:"time"`
	DateTime carbon.DateTime            `json:"date_time"`
	Customer carbon.LayoutType[W3CType] `json:"customer"`

	CreatedAt *carbon.DateTime `json:"created_at"`
	UpdatedAt *carbon.DateTime `json:"updated_at"`
}

var user User

value := `{"date":"2020-08-05","time":"13:14:15","date_time":"2020-08-05 13:14:15","customer":"2020-08-05T13:14:15Z","created_at":"2020-08-05 13:14:15","updated_at":"2020-08-05 13:14:15"}`
_ = json.Unmarshal([]byte(value), &user)

fmt.Println("user.Date:", user.Date.String())
fmt.Println("user.Time:", user.Time.String())
fmt.Println("user.DateTime:", user.DateTime.String())
fmt.Println("user.Customer:", user.Customer.String())
fmt.Println("user.CreatedAt:", user.CreatedAt.String())
fmt.Println("user.UpdatedAt:", user.UpdatedAt.String())

Output:

user.Date: 2020-08-05
user.Time: 13:14:15
user.DateTime: 2020-08-05 13:14:15
user.Customer: 2020-08-05T13:14:15Z
user.CreatedAt: 2020-08-05 13:14:15
user.UpdatedAt: 2020-08-05 13:14:15

func (LayoutType[T]) Value added in v2.6.0 

func (t LayoutType[T]) Value() (driver.Value, error)

Value implements "driver.Valuer" interface for LayoutType generic struct.

type LayoutTyper added in v2.6.4 

type LayoutTyper interface {
	~string
	Layout() string
}

LayoutTyper defines a LayoutTyper interface

type Location added in v2.6.3 

type Location = time.Location

type StdTime added in v2.6.3 

type StdTime = time.Time

type Time 

type Time = LayoutType[timeType]

func NewTime 

func NewTime(c *Carbon) *Time

type TimeMicro 

type TimeMicro = LayoutType[timeMicroType]

func NewTimeMicro 

func NewTimeMicro(c *Carbon) *TimeMicro

type TimeMilli 

type TimeMilli = LayoutType[timeMilliType]

func NewTimeMilli 

func NewTimeMilli(c *Carbon) *TimeMilli

type TimeNano 

type TimeNano = LayoutType[timeNanoType]

func NewTimeNano 

func NewTimeNano(c *Carbon) *TimeNano

type Timestamp 

type Timestamp = TimestampType[timestampType]

func NewTimestamp 

func NewTimestamp(c *Carbon) *Timestamp

type TimestampMicro 

type TimestampMicro = TimestampType[timestampMicroType]

func NewTimestampMicro 

func NewTimestampMicro(c *Carbon) *TimestampMicro

type TimestampMilli 

type TimestampMilli = TimestampType[timestampMilliType]

func NewTimestampMilli 

func NewTimestampMilli(c *Carbon) *TimestampMilli

type TimestampNano 

type TimestampNano = TimestampType[timestampNanoType]

func NewTimestampNano 

func NewTimestampNano(c *Carbon) *TimestampNano

type TimestampType added in v2.6.0 

type TimestampType[T TimestampTyper] struct {
	*Carbon
}

TimestampType defines a TimestampType generic struct.

func NewTimestampType added in v2.6.0 

func NewTimestampType[T TimestampTyper](c *Carbon) *TimestampType[T]

NewTimestampType returns a new TimestampType generic instance.

func (*TimestampType[T]) Int64 added in v2.6.0 

func (t *TimestampType[T]) Int64() (ts int64)

Int64 returns the timestamp value.

func (TimestampType[T]) MarshalJSON added in v2.6.0 

func (t TimestampType[T]) MarshalJSON() ([]byte, error)

MarshalJSON implements "json.Marshaler" interface for TimestampType generic struct.

func (*TimestampType[T]) Scan added in v2.6.0 

func (t *TimestampType[T]) Scan(src any) (err error)

Scan implements "driver.Scanner" interface for TimestampType generic struct.

func (*TimestampType[T]) String added in v2.6.0 

func (t *TimestampType[T]) String() string

String implements "Stringer" interface for TimestampType generic struct.

func (*TimestampType[T]) UnmarshalJSON added in v2.6.0 

func (t *TimestampType[T]) UnmarshalJSON(src []byte) error

UnmarshalJSON implements "json.Unmarshaler" interface for TimestampType generic struct.

func (TimestampType[T]) Value added in v2.6.0 

func (t TimestampType[T]) Value() (driver.Value, error)

Value implements "driver.Valuer" interface for TimestampType generic struct.

type TimestampTyper added in v2.6.4 

type TimestampTyper interface {
	~int64
	Precision() string
}

TimestampTyper defines a TimestampTyper interface.

type Weekday added in v2.6.3 

type Weekday = time.Weekday

Source Files

View all Source files

Directories

Path Synopsis
Package calendar is part of the carbon package.
 Package calendar is part of the carbon package.
hebrew
julian
Package julian is part of the carbon package.
 Package julian is part of the carbon package.
lunar
Package lunar is part of the carbon package.
 Package lunar is part of the carbon package.
persian
Package persian is part of the carbon package.
 Package persian is part of the carbon package.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.