libgo/go/time/example_test.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package time_test
   6
   7 import (
   8         "fmt"
   9         "time"
  10 )
  11
  12 func expensiveCall() {}
  13
  14 func ExampleDuration() {
  15         t0 := time.Now()
  16         expensiveCall()
  17         t1 := time.Now()
  18         fmt.Printf("The call took %v to run.\n", t1.Sub(t0))
  19 }
  20
  21 func ExampleDuration_Round() {
  22         d, err := time.ParseDuration("1h15m30.918273645s")
  23         if err != nil {
  24                 panic(err)
  25         }
  26
  27         round := []time.Duration{
  28                 time.Nanosecond,
  29                 time.Microsecond,
  30                 time.Millisecond,
  31                 time.Second,
  32                 2 * time.Second,
  33                 time.Minute,
  34                 10 * time.Minute,
  35                 time.Hour,
  36         }
  37
  38         for _, r := range round {
  39                 fmt.Printf("d.Round(%6s) = %s\n", r, d.Round(r).String())
  40         }
  41         // Output:
  42         // d.Round(   1ns) = 1h15m30.918273645s
  43         // d.Round(   1µs) = 1h15m30.918274s
  44         // d.Round(   1ms) = 1h15m30.918s
  45         // d.Round(    1s) = 1h15m31s
  46         // d.Round(    2s) = 1h15m30s
  47         // d.Round(  1m0s) = 1h16m0s
  48         // d.Round( 10m0s) = 1h20m0s
  49         // d.Round(1h0m0s) = 1h0m0s
  50 }
  51
  52 func ExampleDuration_String() {
  53         t1 := time.Date(2016, time.August, 15, 0, 0, 0, 0, time.UTC)
  54         t2 := time.Date(2017, time.February, 16, 0, 0, 0, 0, time.UTC)
  55         fmt.Println(t2.Sub(t1).String())
  56         // Output: 4440h0m0s
  57 }
  58
  59 func ExampleDuration_Truncate() {
  60         d, err := time.ParseDuration("1h15m30.918273645s")
  61         if err != nil {
  62                 panic(err)
  63         }
  64
  65         trunc := []time.Duration{
  66                 time.Nanosecond,
  67                 time.Microsecond,
  68                 time.Millisecond,
  69                 time.Second,
  70                 2 * time.Second,
  71                 time.Minute,
  72                 10 * time.Minute,
  73                 time.Hour,
  74         }
  75
  76         for _, t := range trunc {
  77                 fmt.Printf("d.Truncate(%6s) = %s\n", t, d.Truncate(t).String())
  78         }
  79         // Output:
  80         // d.Truncate(   1ns) = 1h15m30.918273645s
  81         // d.Truncate(   1µs) = 1h15m30.918273s
  82         // d.Truncate(   1ms) = 1h15m30.918s
  83         // d.Truncate(    1s) = 1h15m30s
  84         // d.Truncate(    2s) = 1h15m30s
  85         // d.Truncate(  1m0s) = 1h15m0s
  86         // d.Truncate( 10m0s) = 1h10m0s
  87         // d.Truncate(1h0m0s) = 1h0m0s
  88 }
  89
  90 func ExampleParseDuration() {
  91         hours, _ := time.ParseDuration("10h")
  92         complex, _ := time.ParseDuration("1h10m10s")
  93         micro, _ := time.ParseDuration("1µs")
  94         // The package also accepts the incorrect but common prefix u for micro.
  95         micro2, _ := time.ParseDuration("1us")
  96
  97         fmt.Println(hours)
  98         fmt.Println(complex)
  99         fmt.Printf("There are %.0f seconds in %v.\n", complex.Seconds(), complex)
 100         fmt.Printf("There are %d nanoseconds in %v.\n", micro.Nanoseconds(), micro)
 101         fmt.Printf("There are %6.2e seconds in %v.\n", micro2.Seconds(), micro)
 102         // Output:
 103         // 10h0m0s
 104         // 1h10m10s
 105         // There are 4210 seconds in 1h10m10s.
 106         // There are 1000 nanoseconds in 1µs.
 107         // There are 1.00e-06 seconds in 1µs.
 108 }
 109
 110 func ExampleDuration_Hours() {
 111         h, _ := time.ParseDuration("4h30m")
 112         fmt.Printf("I've got %.1f hours of work left.", h.Hours())
 113         // Output: I've got 4.5 hours of work left.
 114 }
 115
 116 func ExampleDuration_Microseconds() {
 117         u, _ := time.ParseDuration("1s")
 118         fmt.Printf("One second is %d microseconds.\n", u.Microseconds())
 119         // Output:
 120         // One second is 1000000 microseconds.
 121 }
 122
 123 func ExampleDuration_Milliseconds() {
 124         u, _ := time.ParseDuration("1s")
 125         fmt.Printf("One second is %d milliseconds.\n", u.Milliseconds())
 126         // Output:
 127         // One second is 1000 milliseconds.
 128 }
 129
 130 func ExampleDuration_Minutes() {
 131         m, _ := time.ParseDuration("1h30m")
 132         fmt.Printf("The movie is %.0f minutes long.", m.Minutes())
 133         // Output: The movie is 90 minutes long.
 134 }
 135
 136 func ExampleDuration_Nanoseconds() {
 137         u, _ := time.ParseDuration("1µs")
 138         fmt.Printf("One microsecond is %d nanoseconds.\n", u.Nanoseconds())
 139         // Output:
 140         // One microsecond is 1000 nanoseconds.
 141 }
 142
 143 func ExampleDuration_Seconds() {
 144         m, _ := time.ParseDuration("1m30s")
 145         fmt.Printf("Take off in t-%.0f seconds.", m.Seconds())
 146         // Output: Take off in t-90 seconds.
 147 }
 148
 149 var c chan int
 150
 151 func handle(int) {}
 152
 153 func ExampleAfter() {
 154         select {
 155         case m := <-c:
 156                 handle(m)
 157         case <-time.After(10 * time.Second):
 158                 fmt.Println("timed out")
 159         }
 160 }
 161
 162 func ExampleSleep() {
 163         time.Sleep(100 * time.Millisecond)
 164 }
 165
 166 func statusUpdate() string { return "" }
 167
 168 func ExampleTick() {
 169         c := time.Tick(5 * time.Second)
 170         for next := range c {
 171                 fmt.Printf("%v %s\n", next, statusUpdate())
 172         }
 173 }
 174
 175 func ExampleMonth() {
 176         _, month, day := time.Now().Date()
 177         if month == time.November && day == 10 {
 178                 fmt.Println("Happy Go day!")
 179         }
 180 }
 181
 182 func ExampleDate() {
 183         t := time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC)
 184         fmt.Printf("Go launched at %s\n", t.Local())
 185         // Output: Go launched at 2009-11-10 15:00:00 -0800 PST
 186 }
 187
 188 func ExampleNewTicker() {
 189         ticker := time.NewTicker(time.Second)
 190         defer ticker.Stop()
 191         done := make(chan bool)
 192         go func() {
 193                 time.Sleep(10 * time.Second)
 194                 done <- true
 195         }()
 196         for {
 197                 select {
 198                 case <-done:
 199                         fmt.Println("Done!")
 200                         return
 201                 case t := <-ticker.C:
 202                         fmt.Println("Current time: ", t)
 203                 }
 204         }
 205 }
 206
 207 func ExampleTime_Format() {
 208         // Parse a time value from a string in the standard Unix format.
 209         t, err := time.Parse(time.UnixDate, "Sat Mar  7 11:06:39 PST 2015")
 210         if err != nil { // Always check errors even if they should not happen.
 211                 panic(err)
 212         }
 213
 214         // time.Time's Stringer method is useful without any format.
 215         fmt.Println("default format:", t)
 216
 217         // Predefined constants in the package implement common layouts.
 218         fmt.Println("Unix format:", t.Format(time.UnixDate))
 219
 220         // The time zone attached to the time value affects its output.
 221         fmt.Println("Same, in UTC:", t.UTC().Format(time.UnixDate))
 222
 223         // The rest of this function demonstrates the properties of the
 224         // layout string used in the format.
 225
 226         // The layout string used by the Parse function and Format method
 227         // shows by example how the reference time should be represented.
 228         // We stress that one must show how the reference time is formatted,
 229         // not a time of the user's choosing. Thus each layout string is a
 230         // representation of the time stamp,
 231         //      Jan 2 15:04:05 2006 MST
 232         // An easy way to remember this value is that it holds, when presented
 233         // in this order, the values (lined up with the elements above):
 234         //        1 2  3  4  5    6  -7
 235         // There are some wrinkles illustrated below.
 236
 237         // Most uses of Format and Parse use constant layout strings such as
 238         // the ones defined in this package, but the interface is flexible,
 239         // as these examples show.
 240
 241         // Define a helper function to make the examples' output look nice.
 242         do := func(name, layout, want string) {
 243                 got := t.Format(layout)
 244                 if want != got {
 245                         fmt.Printf("error: for %q got %q; expected %q\n", layout, got, want)
 246                         return
 247                 }
 248                 fmt.Printf("%-15s %q gives %q\n", name, layout, got)
 249         }
 250
 251         // Print a header in our output.
 252         fmt.Printf("\nFormats:\n\n")
 253
 254         // A simple starter example.
 255         do("Basic", "Mon Jan 2 15:04:05 MST 2006", "Sat Mar 7 11:06:39 PST 2015")
 256
 257         // For fixed-width printing of values, such as the date, that may be one or
 258         // two characters (7 vs. 07), use an _ instead of a space in the layout string.
 259         // Here we print just the day, which is 2 in our layout string and 7 in our
 260         // value.
 261         do("No pad", "<2>", "<7>")
 262
 263         // An underscore represents a space pad, if the date only has one digit.
 264         do("Spaces", "<_2>", "< 7>")
 265
 266         // A "0" indicates zero padding for single-digit values.
 267         do("Zeros", "<02>", "<07>")
 268
 269         // If the value is already the right width, padding is not used.
 270         // For instance, the second (05 in the reference time) in our value is 39,
 271         // so it doesn't need padding, but the minutes (04, 06) does.
 272         do("Suppressed pad", "04:05", "06:39")
 273
 274         // The predefined constant Unix uses an underscore to pad the day.
 275         // Compare with our simple starter example.
 276         do("Unix", time.UnixDate, "Sat Mar  7 11:06:39 PST 2015")
 277
 278         // The hour of the reference time is 15, or 3PM. The layout can express
 279         // it either way, and since our value is the morning we should see it as
 280         // an AM time. We show both in one format string. Lower case too.
 281         do("AM/PM", "3PM==3pm==15h", "11AM==11am==11h")
 282
 283         // When parsing, if the seconds value is followed by a decimal point
 284         // and some digits, that is taken as a fraction of a second even if
 285         // the layout string does not represent the fractional second.
 286         // Here we add a fractional second to our time value used above.
 287         t, err = time.Parse(time.UnixDate, "Sat Mar  7 11:06:39.1234 PST 2015")
 288         if err != nil {
 289                 panic(err)
 290         }
 291         // It does not appear in the output if the layout string does not contain
 292         // a representation of the fractional second.
 293         do("No fraction", time.UnixDate, "Sat Mar  7 11:06:39 PST 2015")
 294
 295         // Fractional seconds can be printed by adding a run of 0s or 9s after
 296         // a decimal point in the seconds value in the layout string.
 297         // If the layout digits are 0s, the fractional second is of the specified
 298         // width. Note that the output has a trailing zero.
 299         do("0s for fraction", "15:04:05.00000", "11:06:39.12340")
 300
 301         // If the fraction in the layout is 9s, trailing zeros are dropped.
 302         do("9s for fraction", "15:04:05.99999999", "11:06:39.1234")
 303
 304         // Output:
 305         // default format: 2015-03-07 11:06:39 -0800 PST
 306         // Unix format: Sat Mar  7 11:06:39 PST 2015
 307         // Same, in UTC: Sat Mar  7 19:06:39 UTC 2015
 308         //
 309         // Formats:
 310         //
 311         // Basic           "Mon Jan 2 15:04:05 MST 2006" gives "Sat Mar 7 11:06:39 PST 2015"
 312         // No pad          "<2>" gives "<7>"
 313         // Spaces          "<_2>" gives "< 7>"
 314         // Zeros           "<02>" gives "<07>"
 315         // Suppressed pad  "04:05" gives "06:39"
 316         // Unix            "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
 317         // AM/PM           "3PM==3pm==15h" gives "11AM==11am==11h"
 318         // No fraction     "Mon Jan _2 15:04:05 MST 2006" gives "Sat Mar  7 11:06:39 PST 2015"
 319         // 0s for fraction "15:04:05.00000" gives "11:06:39.12340"
 320         // 9s for fraction "15:04:05.99999999" gives "11:06:39.1234"
 321
 322 }
 323
 324 func ExampleParse() {
 325         // See the example for Time.Format for a thorough description of how
 326         // to define the layout string to parse a time.Time value; Parse and
 327         // Format use the same model to describe their input and output.
 328
 329         // longForm shows by example how the reference time would be represented in
 330         // the desired layout.
 331         const longForm = "Jan 2, 2006 at 3:04pm (MST)"
 332         t, _ := time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)")
 333         fmt.Println(t)
 334
 335         // shortForm is another way the reference time would be represented
 336         // in the desired layout; it has no time zone present.
 337         // Note: without explicit zone, returns time in UTC.
 338         const shortForm = "2006-Jan-02"
 339         t, _ = time.Parse(shortForm, "2013-Feb-03")
 340         fmt.Println(t)
 341
 342         // Some valid layouts are invalid time values, due to format specifiers
 343         // such as _ for space padding and Z for zone information.
 344         // For example the RFC3339 layout 2006-01-02T15:04:05Z07:00
 345         // contains both Z and a time zone offset in order to handle both valid options:
 346         // 2006-01-02T15:04:05Z
 347         // 2006-01-02T15:04:05+07:00
 348         t, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05Z")
 349         fmt.Println(t)
 350         t, _ = time.Parse(time.RFC3339, "2006-01-02T15:04:05+07:00")
 351         fmt.Println(t)
 352         _, err := time.Parse(time.RFC3339, time.RFC3339)
 353         fmt.Println("error", err) // Returns an error as the layout is not a valid time value
 354
 355         // Output:
 356         // 2013-02-03 19:54:00 -0800 PST
 357         // 2013-02-03 00:00:00 +0000 UTC
 358         // 2006-01-02 15:04:05 +0000 UTC
 359         // 2006-01-02 15:04:05 +0700 +0700
 360         // error parsing time "2006-01-02T15:04:05Z07:00": extra text: 07:00
 361 }
 362
 363 func ExampleParseInLocation() {
 364         loc, _ := time.LoadLocation("Europe/Berlin")
 365
 366         // This will look for the name CEST in the Europe/Berlin time zone.
 367         const longForm = "Jan 2, 2006 at 3:04pm (MST)"
 368         t, _ := time.ParseInLocation(longForm, "Jul 9, 2012 at 5:02am (CEST)", loc)
 369         fmt.Println(t)
 370
 371         // Note: without explicit zone, returns time in given location.
 372         const shortForm = "2006-Jan-02"
 373         t, _ = time.ParseInLocation(shortForm, "2012-Jul-09", loc)
 374         fmt.Println(t)
 375
 376         // Output:
 377         // 2012-07-09 05:02:00 +0200 CEST
 378         // 2012-07-09 00:00:00 +0200 CEST
 379 }
 380
 381 func ExampleTime_Unix() {
 382         // 1 billion seconds of Unix, three ways.
 383         fmt.Println(time.Unix(1e9, 0).UTC())     // 1e9 seconds
 384         fmt.Println(time.Unix(0, 1e18).UTC())    // 1e18 nanoseconds
 385         fmt.Println(time.Unix(2e9, -1e18).UTC()) // 2e9 seconds - 1e18 nanoseconds
 386
 387         t := time.Date(2001, time.September, 9, 1, 46, 40, 0, time.UTC)
 388         fmt.Println(t.Unix())     // seconds since 1970
 389         fmt.Println(t.UnixNano()) // nanoseconds since 1970
 390
 391         // Output:
 392         // 2001-09-09 01:46:40 +0000 UTC
 393         // 2001-09-09 01:46:40 +0000 UTC
 394         // 2001-09-09 01:46:40 +0000 UTC
 395         // 1000000000
 396         // 1000000000000000000
 397 }
 398
 399 func ExampleTime_Round() {
 400         t := time.Date(0, 0, 0, 12, 15, 30, 918273645, time.UTC)
 401         round := []time.Duration{
 402                 time.Nanosecond,
 403                 time.Microsecond,
 404                 time.Millisecond,
 405                 time.Second,
 406                 2 * time.Second,
 407                 time.Minute,
 408                 10 * time.Minute,
 409                 time.Hour,
 410         }
 411
 412         for _, d := range round {
 413                 fmt.Printf("t.Round(%6s) = %s\n", d, t.Round(d).Format("15:04:05.999999999"))
 414         }
 415         // Output:
 416         // t.Round(   1ns) = 12:15:30.918273645
 417         // t.Round(   1µs) = 12:15:30.918274
 418         // t.Round(   1ms) = 12:15:30.918
 419         // t.Round(    1s) = 12:15:31
 420         // t.Round(    2s) = 12:15:30
 421         // t.Round(  1m0s) = 12:16:00
 422         // t.Round( 10m0s) = 12:20:00
 423         // t.Round(1h0m0s) = 12:00:00
 424 }
 425
 426 func ExampleTime_Truncate() {
 427         t, _ := time.Parse("2006 Jan 02 15:04:05", "2012 Dec 07 12:15:30.918273645")
 428         trunc := []time.Duration{
 429                 time.Nanosecond,
 430                 time.Microsecond,
 431                 time.Millisecond,
 432                 time.Second,
 433                 2 * time.Second,
 434                 time.Minute,
 435                 10 * time.Minute,
 436         }
 437
 438         for _, d := range trunc {
 439                 fmt.Printf("t.Truncate(%5s) = %s\n", d, t.Truncate(d).Format("15:04:05.999999999"))
 440         }
 441         // To round to the last midnight in the local timezone, create a new Date.
 442         midnight := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.Local)
 443         _ = midnight
 444
 445         // Output:
 446         // t.Truncate(  1ns) = 12:15:30.918273645
 447         // t.Truncate(  1µs) = 12:15:30.918273
 448         // t.Truncate(  1ms) = 12:15:30.918
 449         // t.Truncate(   1s) = 12:15:30
 450         // t.Truncate(   2s) = 12:15:30
 451         // t.Truncate( 1m0s) = 12:15:00
 452         // t.Truncate(10m0s) = 12:10:00
 453 }
 454
 455 func ExampleLoadLocation() {
 456         location, err := time.LoadLocation("America/Los_Angeles")
 457         if err != nil {
 458                 panic(err)
 459         }
 460
 461         timeInUTC := time.Date(2018, 8, 30, 12, 0, 0, 0, time.UTC)
 462         fmt.Println(timeInUTC.In(location))
 463         // Output: 2018-08-30 05:00:00 -0700 PDT
 464 }
 465
 466 func ExampleLocation() {
 467         // China doesn't have daylight saving. It uses a fixed 8 hour offset from UTC.
 468         secondsEastOfUTC := int((8 * time.Hour).Seconds())
 469         beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)
 470
 471         // If the system has a timezone database present, it's possible to load a location
 472         // from that, e.g.:
 473         //    newYork, err := time.LoadLocation("America/New_York")
 474
 475         // Creating a time requires a location. Common locations are time.Local and time.UTC.
 476         timeInUTC := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
 477         sameTimeInBeijing := time.Date(2009, 1, 1, 20, 0, 0, 0, beijing)
 478
 479         // Although the UTC clock time is 1200 and the Beijing clock time is 2000, Beijing is
 480         // 8 hours ahead so the two dates actually represent the same instant.
 481         timesAreEqual := timeInUTC.Equal(sameTimeInBeijing)
 482         fmt.Println(timesAreEqual)
 483
 484         // Output:
 485         // true
 486 }
 487
 488 func ExampleTime_Add() {
 489         start := time.Date(2009, 1, 1, 12, 0, 0, 0, time.UTC)
 490         afterTenSeconds := start.Add(time.Second * 10)
 491         afterTenMinutes := start.Add(time.Minute * 10)
 492         afterTenHours := start.Add(time.Hour * 10)
 493         afterTenDays := start.Add(time.Hour * 24 * 10)
 494
 495         fmt.Printf("start = %v\n", start)
 496         fmt.Printf("start.Add(time.Second * 10) = %v\n", afterTenSeconds)
 497         fmt.Printf("start.Add(time.Minute * 10) = %v\n", afterTenMinutes)
 498         fmt.Printf("start.Add(time.Hour * 10) = %v\n", afterTenHours)
 499         fmt.Printf("start.Add(time.Hour * 24 * 10) = %v\n", afterTenDays)
 500
 501         // Output:
 502         // start = 2009-01-01 12:00:00 +0000 UTC
 503         // start.Add(time.Second * 10) = 2009-01-01 12:00:10 +0000 UTC
 504         // start.Add(time.Minute * 10) = 2009-01-01 12:10:00 +0000 UTC
 505         // start.Add(time.Hour * 10) = 2009-01-01 22:00:00 +0000 UTC
 506         // start.Add(time.Hour * 24 * 10) = 2009-01-11 12:00:00 +0000 UTC
 507 }
 508
 509 func ExampleTime_AddDate() {
 510         start := time.Date(2009, 1, 1, 0, 0, 0, 0, time.UTC)
 511         oneDayLater := start.AddDate(0, 0, 1)
 512         oneMonthLater := start.AddDate(0, 1, 0)
 513         oneYearLater := start.AddDate(1, 0, 0)
 514
 515         fmt.Printf("oneDayLater: start.AddDate(0, 0, 1) = %v\n", oneDayLater)
 516         fmt.Printf("oneMonthLater: start.AddDate(0, 1, 0) = %v\n", oneMonthLater)
 517         fmt.Printf("oneYearLater: start.AddDate(1, 0, 0) = %v\n", oneYearLater)
 518
 519         // Output:
 520         // oneDayLater: start.AddDate(0, 0, 1) = 2009-01-02 00:00:00 +0000 UTC
 521         // oneMonthLater: start.AddDate(0, 1, 0) = 2009-02-01 00:00:00 +0000 UTC
 522         // oneYearLater: start.AddDate(1, 0, 0) = 2010-01-01 00:00:00 +0000 UTC
 523 }
 524
 525 func ExampleTime_After() {
 526         year2000 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
 527         year3000 := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)
 528
 529         isYear3000AfterYear2000 := year3000.After(year2000) // True
 530         isYear2000AfterYear3000 := year2000.After(year3000) // False
 531
 532         fmt.Printf("year3000.After(year2000) = %v\n", isYear3000AfterYear2000)
 533         fmt.Printf("year2000.After(year3000) = %v\n", isYear2000AfterYear3000)
 534
 535         // Output:
 536         // year3000.After(year2000) = true
 537         // year2000.After(year3000) = false
 538 }
 539
 540 func ExampleTime_Before() {
 541         year2000 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
 542         year3000 := time.Date(3000, 1, 1, 0, 0, 0, 0, time.UTC)
 543
 544         isYear2000BeforeYear3000 := year2000.Before(year3000) // True
 545         isYear3000BeforeYear2000 := year3000.Before(year2000) // False
 546
 547         fmt.Printf("year2000.Before(year3000) = %v\n", isYear2000BeforeYear3000)
 548         fmt.Printf("year3000.Before(year2000) = %v\n", isYear3000BeforeYear2000)
 549
 550         // Output:
 551         // year2000.Before(year3000) = true
 552         // year3000.Before(year2000) = false
 553 }
 554
 555 func ExampleTime_Date() {
 556         d := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
 557         year, month, day := d.Date()
 558
 559         fmt.Printf("year = %v\n", year)
 560         fmt.Printf("month = %v\n", month)
 561         fmt.Printf("day = %v\n", day)
 562
 563         // Output:
 564         // year = 2000
 565         // month = February
 566         // day = 1
 567 }
 568
 569 func ExampleTime_Day() {
 570         d := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
 571         day := d.Day()
 572
 573         fmt.Printf("day = %v\n", day)
 574
 575         // Output:
 576         // day = 1
 577 }
 578
 579 func ExampleTime_Equal() {
 580         secondsEastOfUTC := int((8 * time.Hour).Seconds())
 581         beijing := time.FixedZone("Beijing Time", secondsEastOfUTC)
 582
 583         // Unlike the equal operator, Equal is aware that d1 and d2 are the
 584         // same instant but in different time zones.
 585         d1 := time.Date(2000, 2, 1, 12, 30, 0, 0, time.UTC)
 586         d2 := time.Date(2000, 2, 1, 20, 30, 0, 0, beijing)
 587
 588         datesEqualUsingEqualOperator := d1 == d2
 589         datesEqualUsingFunction := d1.Equal(d2)
 590
 591         fmt.Printf("datesEqualUsingEqualOperator = %v\n", datesEqualUsingEqualOperator)
 592         fmt.Printf("datesEqualUsingFunction = %v\n", datesEqualUsingFunction)
 593
 594         // Output:
 595         // datesEqualUsingEqualOperator = false
 596         // datesEqualUsingFunction = true
 597 }
 598
 599 func ExampleTime_String() {
 600         timeWithNanoseconds := time.Date(2000, 2, 1, 12, 13, 14, 15, time.UTC)
 601         withNanoseconds := timeWithNanoseconds.String()
 602
 603         timeWithoutNanoseconds := time.Date(2000, 2, 1, 12, 13, 14, 0, time.UTC)
 604         withoutNanoseconds := timeWithoutNanoseconds.String()
 605
 606         fmt.Printf("withNanoseconds = %v\n", string(withNanoseconds))
 607         fmt.Printf("withoutNanoseconds = %v\n", string(withoutNanoseconds))
 608
 609         // Output:
 610         // withNanoseconds = 2000-02-01 12:13:14.000000015 +0000 UTC
 611         // withoutNanoseconds = 2000-02-01 12:13:14 +0000 UTC
 612 }
 613
 614 func ExampleTime_Sub() {
 615         start := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
 616         end := time.Date(2000, 1, 1, 12, 0, 0, 0, time.UTC)
 617
 618         difference := end.Sub(start)
 619         fmt.Printf("difference = %v\n", difference)
 620
 621         // Output:
 622         // difference = 12h0m0s
 623 }
 624
 625 func ExampleTime_AppendFormat() {
 626         t := time.Date(2017, time.November, 4, 11, 0, 0, 0, time.UTC)
 627         text := []byte("Time: ")
 628
 629         text = t.AppendFormat(text, time.Kitchen)
 630         fmt.Println(string(text))
 631
 632         // Output:
 633         // Time: 11:00AM
 634 }
 635
 636 func ExampleFixedZone() {
 637         loc := time.FixedZone("UTC-8", -8*60*60)
 638         t := time.Date(2009, time.November, 10, 23, 0, 0, 0, loc)
 639         fmt.Println("The time is:", t.Format(time.RFC822))
 640         // Output: The time is: 10 Nov 09 23:00 UTC-8
 641 }