type DockerCli struct {
	configFile         *configfile.ConfigFile
	in                 *streams.In
	out                *streams.Out
	err                io.Writer
	client             client.APIClient
	serverInfo         ServerInfo
	clientInfo         *ClientInfo
	contentTrust       bool
	contextStore       store.Store
	currentContext     string
	dockerEndpoint     docker.Endpoint
	contextStoreConfig store.Config
}

package main

import (
	"context"
	"fmt"

	"github.com/docker/docker/api/types"
	"github.com/docker/docker/client"
)

func getContainerList() error {
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		panic(err)
	}

	opts := types.ContainerListOptions{}
	opts.All = true

	containers, err := cli.ContainerList(context.Background(), opts)
	if err != nil {
		panic(err)
	}

	for _, container := range containers {
		fmt.Printf("%s %s\n", container.ID[:10], container.Image)
	}
	return err
}

func getImageList() error {
	cli, err := client.NewClientWithOpts(client.FromEnv)
	if err != nil {
		panic(err)
	}

	images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
	if err != nil {
		panic(err)
	}

	for _, image := range images {
		fmt.Printf("%s ", image.ID)
		for _, val := range image.RepoTags {
			fmt.Printf("%s \n", val)
		}
	}

	return err
}

func main() {
	getContainerList()
	getImageList()
}

type Daemon struct {
	ID                string
	repository        string
	containers        container.Store
	containersReplica container.ViewDB
	execCommands      *exec.Store
	imageService      *images.ImageService
	idIndex           *truncindex.TruncIndex
	configStore       *config.Config
	statsCollector    *stats.Collector
	defaultLogConfig  containertypes.LogConfig
	RegistryService   registry.Service
	EventsService     *events.Events
	netController     libnetwork.NetworkController
	volumes           *volumesservice.VolumesService
	discoveryWatcher  discovery.Reloader
	...
}

package main

import (
	"io/ioutil"
	"log"
)

func saveString(fileName string, str string) error {
	err := ioutil.WriteFile(fileName, []byte(str), 0600)
	return err
}

func main() {
	if err := saveString("english.txt", "Hello"); err != nil {
		log.Fatal(err)
	}
	if err := saveString("hindi.txt", "Namaste"); err != nil {
		log.Fatal(err)
	}
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func awardPrize() {
	switch rand.Intn(3) + 1 {
	case 1:
		fmt.Println("You win a cruise!")
	case 2:
		fmt.Println("You win a car!")
	case 3:
		fmt.Println("You win a goat!")
	default:
		panic("invalid door number")
	}
}

func main() {
	rand.Seed(time.Now().Unix())
	awardPrize()
}

package main

import (
	"fmt"
	"unicode/utf8"
)

func main() {

	asciiString := "ABCDE"
	utf8String := "БГДЖИ"

	fmt.Println("Byte lengths:")
	fmt.Println(len(asciiString))
	fmt.Println(len(utf8String))

	fmt.Println("Rune lengths:")
	fmt.Println(utf8.RuneCountInString(asciiString))
	fmt.Println(utf8.RuneCountInString(utf8String))

	fmt.Println("Slice operator on bytes:")
	asciiBytes := []byte(asciiString)
	utf8Bytes := []byte(utf8String)
	asciiBytesPartial := asciiBytes[3:]
	utf8BytesPartial := utf8Bytes[3:]
	fmt.Println(string(asciiBytesPartial))
	fmt.Println(string(utf8BytesPartial))

	fmt.Println("Slice operator on runes:")
	asciiRunes := []rune(asciiString)
	utf8Runes := []rune(utf8String)
	asciiRunesPartial := asciiRunes[3:]
	utf8RunesPartial := utf8Runes[3:]
	fmt.Println(string(asciiRunesPartial))
	fmt.Println(string(utf8RunesPartial))

	fmt.Println("Range on bytes:")
	for index, currentByte := range asciiBytes {
		fmt.Printf("%d: %s\n", index, string(currentByte))
	}
	for index, currentByte := range utf8Bytes {
		fmt.Printf("%d: %s\n", index, string(currentByte))
	}

	fmt.Println("Range on string:")
	for position, currentRune := range asciiString {
		fmt.Printf("%d: %s\n", position, string(currentRune))
	}
	for position, currentRune := range utf8String {
		fmt.Printf("%d: %s\n", position, string(currentRune))
	}
}

package main

import (
	"fmt"
	"time"
)

func sendLetters(channel chan string) {
	time.Sleep(1 * time.Second)
	channel <- "a"
	time.Sleep(1 * time.Second)
	channel <- "b"
	time.Sleep(1 * time.Second)
	channel <- "c"
	time.Sleep(1 * time.Second)
	channel <- "d"
}

func main() {
	fmt.Println(time.Now())
	channel := make(chan string, 3)// 大小为3的缓冲区
	go sendLetters(channel)
	time.Sleep(5 * time.Second)
	fmt.Println(<-channel, time.Now())
	fmt.Println(<-channel, time.Now())
	fmt.Println(<-channel, time.Now())
	fmt.Println(<-channel, time.Now())
	fmt.Println(time.Now())
}

select {
    case <-ch1:
        // 如果从 ch1 信道成功接收数据，则执行该分支代码
    case ch2 <- 1:
        // 如果成功向 ch2 信道成功发送数据，则执行该分支代码
    default:
        // 如果上面都没有成功，则进入 default 分支处理流程
}

package main

import (
	"fmt"
	"time"
)

func main() {
	ch1 := make(chan string)

	go func() {
		for {
			time.Sleep(time.Second * 2)
			ch1 <- "hhhhhh"
		}
	}()

	for {
		select {
		case str := <-ch1:
			fmt.Println("receive str", str)
		case <-time.After(time.Second * 5): //超时处理
			fmt.Println("timeout!!")
		}
	}
}

fmt.Printf("%08b\n", 1)
fmt.Printf("%08b\n", 127)

fmt.Printf("%08o\n", 9)

package main

import (
	"fmt"
	"os"
)

func main() {
	file, err := os.OpenFile(os.Args[1], os.O_CREATE | os.O_RDWR, os.FileMode(0644))	
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}

	len, err := file.Write([]byte("hhhhh"))
	if err != nil {
		fmt.Println(err)
		file.Close()
		os.Exit(1)
	}

	file.Close()
	fmt.Println(len)
}

package main

import (
	"log"
	"os"
	"text/template"
)

func main() {
	/*
	在main中，我们调用text/template包的New函数，该函数返回一个指向新Template值的指针。
	然后我们调用Template上的Parse方法，并将字 符串"Here's my template!\n"传递给它。
	Parse使用字符串参数作为模板的文本。Parse返回模板和一个error值。我们将模板存储在tmpl变量中
	*/
	text := "Here's my template\n"
	tmpl, err := template.New("Text").Parse(text)
	if err != nil {
		log.Fatal(err)
	}

	err = tmpl.Execute(os.Stdout, nil) //将模版写入终端

	if err != nil {
		log.Fatal(err)
	}
}

package io // import "io"

type Writer interface {
	Write(p []byte) (n int, err error)
}

package main

import (
	"log"
	"os"
	"text/template"
)

type mySt struct {
	Name string
	Age int
}

func execTemplate(text string, data interface{}) {
	tmpl, err := template.New("Text").Parse(text)
	if err != nil {
		log.Fatal(err)
	}

	err = tmpl.Execute(os.Stdout, data) 

	if err != nil {
		log.Fatal(err)
	}
}

func main() {
	execTemplate("hhh {{.}}\n", "abc")
	execTemplate("hhh {{if.}} run {{end}} hhh\n", true)
	execTemplate("hhh {{if.}} run {{end}} hhh\n", false)
	execTemplate("hhh {{range.}} run{{.}} {{end}}\n", []int{1, 2, 3})
	execTemplate("hhh {{.Name}}  {{.Age}}\n", mySt{ Name:"zeyu", Age:18})
}

package main

import (
	"bufio"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"os"
)

// Guestbook is a struct used in rendering view.html.
type Guestbook struct {
	SignatureCount int //签名总数
	Signatures     []string //签名内容
}

// check calls log.Fatal on any non-nil error.
func check(err error) {
	if err != nil {
		log.Fatal(err)
	}
}

// viewHandler reads guestbook signatures and displays them together
// with a count of all signatures.
func viewHandler(writer http.ResponseWriter, request *http.Request) {
	signatures := getStrings("signatures.txt") //逐行读文件，文件不存在返回空切片
	html, err := template.ParseFiles("view.html") //创建html模版
	check(err)
	guestbook := Guestbook{
		SignatureCount: len(signatures),
		Signatures:     signatures,
	}
	err = html.Execute(writer, guestbook) //将数据插入模版，并写回http.ResponseWriter
	check(err)
}

// newHandler displays a form to enter a signature.
func newHandler(writer http.ResponseWriter, request *http.Request) {
	html, err := template.ParseFiles("new.html")
	check(err)
	err = html.Execute(writer, nil)
	check(err)
}

// createHandler takes a POST request with a signature to add, and
// appends it to the signatures file.
func createHandler(writer http.ResponseWriter, request *http.Request) {
	signature := request.FormValue("signature") //获取html signature表单字段的值
	options := os.O_WRONLY | os.O_APPEND | os.O_CREATE
	file, err := os.OpenFile("signatures.txt", options, os.FileMode(0600))
	check(err)
	_, err = fmt.Fprintln(file, signature) //将值写入signatures.txt
	check(err)
	err = file.Close()
	check(err)
	http.Redirect(writer, request, "/guestbook", http.StatusFound) //将浏览器重定向到 /guestbook
}

// getStrings returns a slice of strings read from fileName, one
// string per line.
func getStrings(fileName string) []string {
	var lines []string
	file, err := os.Open(fileName)
	if os.IsNotExist(err) {
		return nil
	}
	check(err)
	defer file.Close()
	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
		lines = append(lines, scanner.Text())
	}
	check(scanner.Err())
	return lines
}

func main() {
	http.HandleFunc("/guestbook", viewHandler) //查看签名列表的请求
	http.HandleFunc("/guestbook/new", newHandler) //获取html表单的请求
	http.HandleFunc("/guestbook/create", createHandler) //提交表单的请求
	err := http.ListenAndServe("localhost:8080", nil)
	log.Fatal(err)
}

   //string与byte相互转换
message := []byte("Hello")
   fmt.Println(message)
fmt.Println(string([]byte{72, 101, 108, 108, 111}))

package main

import (
	"log"
	"net/http"
)

func write(writer http.ResponseWriter, message string) {
	_, err := writer.Write([]byte(message))
	if err != nil {
		log.Fatal(err)
	}
}

func englishHandler(writer http.ResponseWriter, request *http.Request) {
	write(writer, "Hello, web!")
}
func frenchHandler(writer http.ResponseWriter, request *http.Request) {
	write(writer, "Salut web!")
}
func hindiHandler(writer http.ResponseWriter, request *http.Request) {
	write(writer, "Namaste, web!")
}

func main() {
    /* 针对不同的路径请求调用不同的函数 */
	http.HandleFunc("/hello", englishHandler)
	http.HandleFunc("/salut", frenchHandler)
	http.HandleFunc("/namaste", hindiHandler)
    /* 在8080端口运行web服务 */
	err := http.ListenAndServe("localhost:8080", nil)
	log.Fatal(err)
}

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
)

type Page struct {
	URL  string
	Size int
}

func responseSize(url string, channel chan Page) {
	fmt.Println("Getting", url)
	response, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		log.Fatal(err)
	}
	channel <- Page{URL: url, Size: len(body)}
}

func main() {
	pages := make(chan Page)
	urls := []string{"https://example.com/",
		"https://golang.org/", "https://golang.org/doc"}
	for _, url := range urls {
		go responseSize(url, pages)
	}
	for i := 0; i < len(urls); i++ {
		page := <-pages
		fmt.Printf("%s: %d\n", page.URL, page.Size)
	}
}

package main

import (
	"fmt"
)

func test() {
	fmt.Println("test")
}
func testArg(val int) int {
	fmt.Println("testArg", val)
	return 0
}

//函数变量做另一个函数的参数
func testFunc(val int, myFunc func(int) int) {
	myFunc(val)
}

func main() {
	var myFunc func()
	var myFuncArg func(int) int

	myFunc = test
	myFuncArg = testArg

	myFunc()
	myFuncArg(3)

	testFunc(3, testArg)
}

//join.go
package prose

import "strings"

func JoinWithCommas(phrases []string) string {
	if len(phrases) == 0 {
		return ""
	} else if len(phrases) == 1 {
		return phrases[0]
	} else if len(phrases) == 2 {
		return phrases[0] + " and " + phrases[1]
	} else {
		result := strings.Join(phrases[:len(phrases)-1], ", ")
		result += ", and "
		result += phrases[len(phrases)-1]
		return result
	}
}

//join_test.go
package prose //要测试的包名,这个测试代码相当于和prose同属于一个包

import "testing" //导入testing包

type testData struct {
	list []string
	want string
}

//函数都以Test开头, go test 将检测这些函数
func TestJoinWithCommas(t *testing.T) {
	tests := []testData{
		testData{list: []string{}, want: ""},
		testData{list: []string{"apple"}, want: "apple"},
		testData{list: []string{"apple", "orange"}, want: "apple and orange"},
		testData{list: []string{"apple", "orange", "pear"}, want: "apple, orange, and pear"},
	}
	for _, test := range tests {
		got := JoinWithCommas(test.list)
		if got != test.want {
			t.Errorf("JoinWithCommas(%#v) = \"%s\", want \"%s\"", test.list, got, test.want) //一旦调用testing.T的Error或Errorf则表示失败
		}
	}
}

package main

import (
	"fmt"
	"time"
)

func taskA() {
	for i := 0; i < 50; i++ {
		fmt.Println(`A`,i)
		time.Sleep(time.Microsecond)
	}
}

func taskB() {
	for i := 0; i < 50; i++ {
		fmt.Println(`B`,i)
		time.Sleep(time.Microsecond)
	}
}

func main() {
	go taskA()
	go taskB()
	time.Sleep(time.Second * 5)
}

var myChannel chan int
myChannel = make(chan int)

package main

import (
	"fmt"
	"time"
)

func taskA(myCh chan int) {
	myCh <- 15
}

func main() {
	myCh := make(chan int)
	go taskA(myCh)
	fmt.Println(<-myCh)
}

package main

import (
	"fmt"
)

func taskA(myCh chan int) {
	myCh <- 1
	myCh <- 2
	myCh <- 3
}

func taskB(myCh chan int) {
	myCh <- 4
	myCh <- 5
	myCh <- 6
}

func main() {
	chA := make(chan int)
	chB := make(chan int)

	go taskA(chA)
	go taskB(chB)

	fmt.Println(<- chA)
	fmt.Println(<- chB)

	fmt.Println(<- chA)
	fmt.Println(<- chB)

	fmt.Println(<- chA)
	fmt.Println(<- chB)
    //1 2 3 4 5 6
}

package main

import "fmt"

func test() int {
	fmt.Println("abc")
	defer fmt.Println("000")
	defer fmt.Println("111")
	fmt.Println("def")
	defer fmt.Println("222")
	defer fmt.Println("333")
	return 0
}

func main() {
	test()
}

package main

import (
	"fmt"
)

func testOne() {
	defer fmt.Println("defer one")
	testTwo()
}

func testTwo() {
	defer fmt.Println("defer two")
	panic("die")
}

func main() {
	testOne()	
}

package main

import (
	"fmt"
)

func catchPanic() {
	recover()
}

func testOne() {
	defer catchPanic()
	panic("die")
    fmt.Println("not go there")
}

func main() {
	testOne()	
	fmt.Println("go on")
}

package main

import (
	"fmt"
)

func catchPanic() {
	p := recover() //p是空接口
	if p == nil { //没有panci时返回nil
		return
	}

	err, ok := p.(error)
	if (ok) {
		fmt.Println("catch", err.Error())
	} else {
		panic(p) //未知panic类型,恢复panic
	}
}


func main() {
	defer catchPanic()
	err := fmt.Errorf("wtf")
	panic(err) //传入一个error接口变量
}