Golang spew.Printf函数代码示例

func worker(done chan bool) {
	spew.Printf("working...\n")
	time.Sleep(time.Second)
	spew.Printf("done!\n")

	done <- true
}

func main() {
	nums := []int{2, 3, 4}

	// for ... range は for の中で initialize できない。
	sum := 0
	for _, num := range nums {
		sum += num
	}
	spew.Printf("sum: %#+v\n", sum)

	// ちなみにここでも num をまた宣言 & 代入してるけど、これは OK である。
	// 新規 + 既存 := で多値を受け取る場合は、既存変数を再宣言 & 再代入しても
	// エラーにはならない。なお、同一スコープな否ならアドレス番地は同じになっている。
	//  [Go言語で複数戻り値の受け取りで既存変数の再宣言？ - taknb2nchのメモ]
	//  http://d.hatena.ne.jp/taknb2nch/20140819/1408421727
	for i, num := range nums {
		if num == 3 {
			spew.Printf("index: %#+v\n", i)
		}
	}

	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		spew.Printf("%#+v -> %#+v\n", k, v)
	}

	for i, c := range "号号" {
		spew.Printf("%#+v -> %#+v\n", i, c)
	}
}

func main() {
	res := plus(1, 2)
	spew.Printf("1 + 2 = %#+v\n", res)

	res = plusPlus(1, 2, 3)
	spew.Printf("1 + 2 + 3 = %#+v\n", res)
}

func main() {
	c1 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c1 <- "result 1"
	}()

	select {
	case res := <-c1:
		spew.Printf("%#+v\n", res)

	case <-time.After(time.Second * 1):
		spew.Printf("timeout 1\n")
	}

	c2 := make(chan string, 1)
	go func() {
		time.Sleep(time.Second * 2)
		c2 <- "result 2"
	}()

	select {
	case res := <-c2:
		spew.Printf("%#+v\n", res)
	case <-time.After(time.Second * 3):
		spew.Printf("timeout 2\n")
	}
}

func main() {
	timer1 := time.NewTimer(time.Second * 2)
	// Timer 構造体のポインタが返ってくる様子。
	spew.Printf("%#+v\n", timer1)

	// 経過した時の時刻が入るっぽいな。
	ret := <-timer1.C
	spew.Printf("%#+v\n", ret)
	fmt.Println("Timer 1 expired", ret)

	timer2 := time.NewTimer(time.Second)
	go func() {
		<-timer2.C
		fmt.Println("Timer 2 expired")
	}()

	// stop2 := timer2.Stop()
	// if stop2 {
	// 	spew.Printf("%#+v\n", stop2)
	// 	fmt.Println("Timer 2 stopped")
	// }

	// ゴルーチンの終了を待ったら当然結果が出力されるし、
	// timer2 は expired しちゃってるから Stop() も動作しない。
	// time.Sleep(time.Second * 3)
	// こうでよくね。
	if timer2.Stop() {
		fmt.Println("Timer 2 stopped")
	}
}

func main() {

	apiUser := os.Getenv(ApiUser)
	apiKey := os.Getenv(ApiKey)

	id := 12345

	client := slclient.NewSoftLayerClient(apiUser, apiKey)

	virtualGuestService, err := client.GetSoftLayer_Virtual_Guest_Service()

	if err != nil {
		fmt.Println(err)
		return
	} else {
		fmt.Println("No error found in client.GetSoftLayer_Virtual_Guest_Service()")
	}

	virtualGuest, err := virtualGuestService.GetObject(id)

	if err != nil {
		fmt.Println("errors:", err)
		return
	} else {
		fmt.Println("No error found in virtualGuestService.GetObject(id)")
	}

	spew.Printf("virtualGuest =%#+v\n", virtualGuest)

	vgPowerState, err := virtualGuestService.GetPowerState(id)

	spew.Printf("vgPowerState =%#+v\n", vgPowerState)
}

func sum(nums ...int) {
	spew.Printf("nums: %#+v\n", nums)
	total := 0
	for _, num := range nums {
		total += num
	}
	spew.Printf("total: %#+v\n\n", total)
}

func main() {
	a, b := vals()
	spew.Printf("a: %#+v\n", a)
	spew.Printf("b: %#+v\n", b)

	_, c := vals()
	spew.Printf("c: %#+v\n", c)
}

func main() {
	// int
	var i int = 1
	var pi *int = &i

	// string
	var str string = "hello, world."
	var pstr *string = &str

	// array
	var ary [2]int = [2]int{1, 2}
	var pary *[2]int = &ary

	// slice
	var slc []int = []int{10, 20}
	var pslc *[]int = &slc

	// これは分かる。
	spew.Println("int")
	spew.Printf("i = %#+v, &i = %#+v, pi = %#+v, *pi = %#+v\n\n", i, &i, pi, *pi)

	spew.Println("string")
	spew.Printf("str = %#+v, &str = %#+v, pstr = %#+v, *pstr = %#+v\n\n", str, &str, pstr, *pstr)

	spew.Println("array")
	spew.Printf("ary = %#+v, &ary = %#+v, pary = %#+v, *pary = %#+v\n\n", ary, &ary, pary, *pary)

	spew.Println("slice")
	spew.Printf("slc = %#+v, &slc = %#+v, pslc = %#+v, *pslc = %#+v\n\n", slc, &slc, pslc, *pslc)

	// 解せぬ。
	spew.Println("string[n]")
	// &str[0]: cannot take the address of str[0] // 文字列の要素をアドレス番地 + 添字で求められないのは仕様である、といった感じであろうか？
	// pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // 上と同様。
	// *pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // なぜだ。
	spew.Printf("str[0] = %#+v\n\n", str[0])

	spew.Println("array[n]")
	// *pary[0]: invalid indirect of pary[0] (type int) // なぜだ。
	spew.Printf("ary[0] = %#+v, &ary[0] = %#+v, pary[0] = %#+v\n\n", ary[0], &ary[0], pary[0])

	spew.Println("slice[n]")
	// pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // スライスはそれ自体がすでにどこかのアドレス番地の参照先のはず。スライスのポインタはダブルポインタ的な感じなので、アドレス番地 + 添字で求められないのは仕様である、といった感じだろうか？
	// *pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // なぜだ。
	spew.Printf("slc[0] = %#+v, &slc[0] = %#+v\n\n", slc[0], &slc[0])

	// できるじゃん。
	spew.Println("(*string)[n]")
	spew.Printf("(*pstr)[0] = %#+v\n\n", (*pstr)[0])

	spew.Println("(*array)[n]")
	spew.Printf("(*pary)[0] = %#+v\n\n", (*pary)[0])

	spew.Println("(*pscl)[n]")
	spew.Printf("(*pslc)[0] = %#+v\n\n", (*pslc)[0])
}

func main() {
	messages := make(chan string, 2)

	messages <- "buffered"
	messages <- "channel"

	spew.Printf("%#+v\n", &messages)
	spew.Printf("%#+v\n", <-messages)
	spew.Printf("%#+v\n", <-messages)
}

func main() {
	strs := []string{"c", "a", "b"}
	sort.Strings(strs)
	spew.Printf("Strings: %#+v\n", strs)

	ints := []int{7, 2, 4}
	sort.Ints(ints)
	spew.Printf("Intss: %#+v\n", ints)

	s := sort.IntsAreSorted(ints)
	spew.Printf("Sorted: %#+v\n", s)
}

func main() {
	i := 1
	spew.Printf("initial: %#+v\n", i)

	zeroval(i)
	spew.Printf("zeroval: %#+v\n", i)

	zeroptr(&i)
	spew.Printf("zeroptr: %#+v\n", i)

	spew.Printf("pointer: %#+v\n", &i)
}

func main() {
	//* key / varlue ペアを設定するために、'''os.Setenv''' を使います。key から value を取得するために '''os.Getenv''' を使います。環境に key が存在しない場合は空文字が返ります。
	os.Setenv("FOO", "1")
	spew.Printf("FOO: %#+v\n", os.Getenv("FOO"))
	spew.Printf("BAR: %#+v\n", os.Getenv("BAR"))
	spew.Printf("$PGUSER: %#+v\n", os.Getenv("PGUSER"))

	//* '''os.Environ''' を使うと、環境内の全ての key / value ペアがリストされます。これは '''key=value''' という形式の文字列スライスです。ここで私達は全ての key を出力しています。
	spew.Println()
	for _, e := range os.Environ() {
		pair := strings.Split(e, "=") // e: "key=value" --- strings.Split() ---> pair:["key", "value"]
		spew.Println(pair[0])
	}
}

func getStat() {
	sTime := time.Now()

	defer func() {
		if e := recover(); e != nil {
			statsdIncrement("error")
			logInfo(0, sTime, "Error getting stat: %s", e.(error).Error())
		}
		statsdTiming(sTime, "done")
	}()

	nsInfo, err := asInfo(*cfg.aspk_node, *cfg.asinfo_port)
	if err != nil {
		logInfo(0, sTime, "Error getting node stat: %s", err.Error())
		statsdIncrement("error")
	} else {
		for nsName, nsStat := range *nsInfo {
			for key, val := range *nsStat {
				if *cfg.stdout {
					spew.Printf("%s.%s = %s\n", nsName, key, val)
				}
				if isIn(key, cfg.metric) {
					num, ok := a2i(val)
					if ok {
						statsdGauge(num, "%s.%s", nsName, key)
					}
				}
			}
		}
	}
}

func dumpBloblets(dir *directory, indent int) (int, int64, int64) {
	var numBloblets int = 0
	var totalSize int64 = 0
	var minCompressedSize int64 = math.MaxInt64
	if dir.bloblet != nil {
		cr := compressedSize(dir.bloblet)
		minCompressedSize = cr
		if details {
			fmt.Printf(strings.Repeat(" ", indent))
			spew.Printf("Bloblet @ %s of size %d, compressed size %d\n", dir.bloblet.path, dir.bloblet.size, cr)
		}
		totalSize += dir.bloblet.size
		numBloblets++

	}

	for _, child := range dir.children {
		n, t, c := dumpBloblets(child, indent+2)
		numBloblets += n
		totalSize += t
		if c < minCompressedSize {
			minCompressedSize = c
		}
	}

	return numBloblets, totalSize, minCompressedSize
}