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