package main

import "sync"

type Value struct {
    mu sync.Mutex   //無需初始化，聲明就能用
    val int
}

func (v *Value)Incr(){
    defer v.mu.Unlock()
    v.mu.Lock()
    v.val++
}

func main() {
    var i Value
    i.Incr()
}

// A Mutex is a mutual exclusion lock.
// The zero value for a Mutex is an unlocked mutex.
//
// A Mutex must not be copied after first use.
type Mutex struct {
	state int32
	sema  uint32
}

func testNilSlice() {
	var nilSlice []string
    fmt.Println(nilSlice == nil) // true
    fmt.Println(nilSlice[0]) //index out of range
	emptySlice = append(nilSlice, "dd") // append操作會自動擴容
	fmt.Println(nilSlice[0]) //輸出dd
}

type Person {
  Friends []string
}

var f1 []string //nil切片
json1, _ := json.Marshal(Person{Friends: f1})
fmt.Printf("%s\n", json1) //output：{"Friends": null}

f2 := make([]string, 0) //non-nil空切片 ，等價于 f2 := []string{}
json2, _ := json.Marshal(Person{Friends: f2})
fmt.Printf("%s\n", json2) //output: {"Friends": []}

func testNilMap() {
	var m map[string]string
	fmt.Println(m["key"]) //輸出""
    m["key"]="value" //panic: assignment to entry in nil map
}

func NewGet(url string, headers map[string]string) (*http.Request, error) {
	req, err := http.NewRequest(http.MethodGet, url, nil)
	if err != nil {
		return nil, err
	}
	for k, v := range headers {
		req.Header.Set(k, v)
	}
	return req, nil
}

//調(diào)用該方法時如果沒有header，可以傳入一個空的map，例如：
NewGet("http://google.com", map[string]string{})
//也可以直接傳入nil
NewGet("http://google.com", nil)

func addIntegers(c chan int) {
    sum := 0
    t := time.NewTimer(time.Second)
    for {
        select {
            case input := <-c:
                sum = sum + input
            case <-t.C:
                c = nil
                fmt.Println(sum)  // 輸出10
        }
    }
}

func main() {
	c := make(chan int, 1)
	go addIntegers(c)
	for i := 0; i <= 10; i++ {
		c <- i
		time.Sleep(time.Duration(200) * time.Millisecond)
	}
}

type Person struct {
	Name string
	Sex  string
	Age  int
}

var p *Person
fmt.Println(p.Name)  // panic: runtime error: invalid memory address or nil pointer dereference

// [src/builtin/builtin.go](https://golang.org/src/builtin/builtin.go#L98)
//
// nil is a predeclared identifier representing the zero value for a
// pointer, channel, func, interface, map, or slice type.
var nil Type // Type must be a pointer, channel, func, interface, map, or slice type

var nil = errors.New("my god")

a := nil
// cannot declare variable as untyped nil: a
fmt.Println(nil == nil)
// invalid operation: nil == nil (operator == not defined on nil)
fmt.Printf("%T", nil)
// use of untyped nil

var p *int
var i interface{}

fmt.Println(p)      // <nil>
fmt.Println(i)      // <nil>

fmt.Println(p == i) // false

type BusinessError struct {
	error
	errorCode int64
}

func doBusiness() *BusinessError {
	return nil
}

func wrapDoBusiness() error {
	err := doBusiness()
	return err
}

func testError() {
	err := wrapDoBusiness() //這里面拿到的本質上是一個<T:*BusinessError,V:nil>的nil
	fmt.Println(err == nil)
}

type BusinessError struct {
	error
	errorCode int64
}

func doBusiness() *BusinessError {
	return nil
}

func wrapDoBusiness() error {
	err := doBusiness() 
	if err == nil {
		return nil  //如果返回值為nil，直接返回nil，不要做類型轉換
	} else {
		return err
	}
}

func testError() {
	err := wrapDoBusiness()
	fmt.Println(err == nil)
}

var q struct{}
fmt.Println(unsafe.Sizeof(q)) // 0

// 創(chuàng)建 map
m := make(map[int]struct{})
// 賦值
m[1] = struct{}{}
// 判斷 key 鍵存不存在
_, ok := m[1]

waitc := make(chan struct{})

// ...
goroutine 1:
    // 發(fā)送信號: 投遞元素
    waitc <- struct{}
    // 發(fā)送信號: 關閉
    close(waitc)

goroutine 2:
    select {
    // 收到信號，做出對應的動作
    case <-waitc:
    }