blob: 50fd93441f477e636e4a0274b09448717ceddff5 [file] [log] [blame]
// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file contains examples to embed in the Go 1 release notes document.
package main
import (
"errors"
"flag"
"fmt"
"log"
"os"
"path/filepath"
"testing"
"time"
"unicode"
)
func main() {
flag.Parse()
stringAppend()
mapDelete()
mapIteration()
multipleAssignment()
structEquality()
compositeLiterals()
runeType()
errorExample()
timePackage()
walkExample()
osIsExist()
}
var timeout = flag.Duration("timeout", 30*time.Second, "how long to wait for completion")
func init() {
// canonicalize the logging
log.SetFlags(0)
}
func mapDelete() {
m := map[string]int{"7": 7, "23": 23}
k := "7"
delete(m, k)
if m["7"] != 0 || m["23"] != 23 {
log.Fatal("mapDelete:", m)
}
}
func stringAppend() {
greeting := []byte{}
greeting = append(greeting, []byte("hello ")...)
greeting = append(greeting, "world"...)
if string(greeting) != "hello world" {
log.Fatal("stringAppend: ", string(greeting))
}
}
func mapIteration() {
m := map[string]int{"Sunday": 0, "Monday": 1}
for name, value := range m {
// This loop should not assume Sunday will be visited first.
f(name, value)
}
}
func f(string, int) {
}
func assert(t bool) {
if !t {
log.Panic("assertion fail")
}
}
func multipleAssignment() {
sa := []int{1, 2, 3}
i := 0
i, sa[i] = 1, 2 // sets i = 1, sa[0] = 2
sb := []int{1, 2, 3}
j := 0
sb[j], j = 2, 1 // sets sb[0] = 2, j = 1
sc := []int{1, 2, 3}
sc[0], sc[0] = 1, 2 // sets sc[0] = 1, then sc[0] = 2 (so sc[0] = 2 at end)
assert(i == 1 && sa[0] == 2)
assert(j == 1 && sb[0] == 2)
assert(sc[0] == 2)
}
func structEquality() {
type Day struct {
long string
short string
}
Christmas := Day{"Christmas", "XMas"}
Thanksgiving := Day{"Thanksgiving", "Turkey"}
holiday := map[Day]bool{
Christmas: true,
Thanksgiving: true,
}
fmt.Printf("Christmas is a holiday: %t\n", holiday[Christmas])
}
func compositeLiterals() {
type Date struct {
month string
day int
}
// Struct values, fully qualified; always legal.
holiday1 := []Date{
Date{"Feb", 14},
Date{"Nov", 11},
Date{"Dec", 25},
}
// Struct values, type name elided; always legal.
holiday2 := []Date{
{"Feb", 14},
{"Nov", 11},
{"Dec", 25},
}
// Pointers, fully qualified, always legal.
holiday3 := []*Date{
&Date{"Feb", 14},
&Date{"Nov", 11},
&Date{"Dec", 25},
}
// Pointers, type name elided; legal in Go 1.
holiday4 := []*Date{
{"Feb", 14},
{"Nov", 11},
{"Dec", 25},
}
// STOP OMIT
_, _, _, _ = holiday1, holiday2, holiday3, holiday4
}
func runeType() {
// STARTRUNE OMIT
delta := 'δ' // delta has type rune.
var DELTA rune
DELTA = unicode.ToUpper(delta)
epsilon := unicode.ToLower(DELTA + 1)
if epsilon != 'δ'+1 {
log.Fatal("inconsistent casing for Greek")
}
// ENDRUNE OMIT
}
// START ERROR EXAMPLE OMIT
type SyntaxError struct {
File string
Line int
Message string
}
func (se *SyntaxError) Error() string {
return fmt.Sprintf("%s:%d: %s", se.File, se.Line, se.Message)
}
// END ERROR EXAMPLE OMIT
func errorExample() {
var ErrSyntax = errors.New("syntax error")
_ = ErrSyntax
se := &SyntaxError{"file", 7, "error"}
got := fmt.Sprint(se)
const expect = "file:7: error"
if got != expect {
log.Fatalf("errorsPackage: expected %q got %q", expect, got)
}
}
// sleepUntil sleeps until the specified time. It returns immediately if it's too late.
func sleepUntil(wakeup time.Time) {
now := time.Now() // A Time.
if !wakeup.After(now) {
return
}
delta := wakeup.Sub(now) // A Duration.
fmt.Printf("Sleeping for %.3fs\n", delta.Seconds())
time.Sleep(delta)
}
func timePackage() {
sleepUntil(time.Now().Add(123 * time.Millisecond))
}
func walkExample() {
// STARTWALK OMIT
markFn := func(path string, info os.FileInfo, err error) error {
if path == "pictures" { // Will skip walking of directory pictures and its contents.
return filepath.SkipDir
}
if err != nil {
return err
}
log.Println(path)
return nil
}
err := filepath.Walk(".", markFn)
if err != nil {
log.Fatal(err)
}
// ENDWALK OMIT
}
func initializationFunction(c chan int) {
c <- 1
}
var PackageGlobal int
func init() {
c := make(chan int)
go initializationFunction(c)
PackageGlobal = <-c
}
func BenchmarkSprintf(b *testing.B) {
// Verify correctness before running benchmark.
b.StopTimer()
got := fmt.Sprintf("%x", 23)
const expect = "17"
if expect != got {
b.Fatalf("expected %q; got %q", expect, got)
}
b.StartTimer()
for i := 0; i < b.N; i++ {
fmt.Sprintf("%x", 23)
}
}
func osIsExist() {
name := "go1.go"
f, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0600)
if os.IsExist(err) {
log.Printf("%s already exists", name)
}
_ = f
}