1.基础

var name type
var hp int = 100
var hp1 = 100
hp2 := 100 //简化写法

var f float32 = 16777216 // 1 << 24
fmt.Println(f == f+1)    // "true"!

var ch byte = 65 或 var ch byte = '\x41'      //（\x 总是紧跟着长度为 2 的 16 进制数）

var aVar = 10
aVar == 5  // false
aVar == 10 // true
aVar != 5  // true
aVar != 10 // false

i := 0
if b {
    i = 1
}

const (
    a = 1
    b
    c = 2
    d
)
fmt.Println(a, b, c, d) // "1 1 2 2"

type Weekday int

const (
    Sunday Weekday = iota
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

const (
 _   = 1 << (10 * iota)
 KiB // 1024
 MiB // 1048576
 GiB // 1073741824
 TiB // 1099511627776             (exceeds 1 << 32)
 PiB // 1125899906842624
 EiB // 1152921504606846976
 ZiB // 1180591620717411303424    (exceeds 1 << 64)
 YiB // 1208925819614629174706176
)

if condition {
    // do something
} else {
    // do something
}

if err := Connect(); err != nil {
    fmt.Println(err)
    return
}

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

sum := 0
for {
    sum++
    if sum > 100 {
        break
    }
}

for j := 0; j < 5; j++ {
    for i := 0; i < 10; i++ {
        if i > 5 {
            break JLoop
        }
        fmt.Println(i)
    }
}
JLoop:
// ...

var a = "hello"
switch a {
case "hello":
    fmt.Println(1)
case "world":
    fmt.Println(2)
default:
    fmt.Println(0)
}

case 5,10,15

switch {
case x > 0:
    fmt.Println("Positive")
case x < 0:
    fmt.Println("Negative")
default:
    fmt.Println("Zero")
}

switch grade:=90 {
    case grade >90:
        fmt.Println('1')
        fallthrough
    case grade >70:
        fmt.Println('2')
        fallthrough
    case grade >60:
        fmt.Println('3')
    case grade >50:
        fmt.Println('4')
}

    i := 0
Start:
    fmt.Println(i)
    if i > 5 {
        goto End
    } else {
        i += 1
        goto Start
    }
End:

func f2(a int, b byte) (int, bool){

}

// func myFunc(a, b, arg ...int) {}
func Greeting(prefix string, who ...string)
Greeting("hello:", "Joe", "Anna", "Eileen")

package main

import "fmt"

func main() {
 x := min(1, 3, 2, 0)
 fmt.Printf("The minimum is: %d\n", x)
 slice := []int{7,9,3,5,1}
 x = min(slice...)
 fmt.Printf("The minimum in the slice is: %d", x)
}

func min(s ...int) int {
 if len(s)==0 {
  return 0
 }
 min := s[0]
 for _, v := range s {
  if v < min {
   min = v
  }
 }
 return min
}

package main
import "fmt"

func main() {
 function1()
}

func function1() {
 fmt.Printf("In function1 at the top\n")
 defer function2()
 fmt.Printf("In function1 at the bottom!\n")
}

func function2() {
 fmt.Printf("Function2: Deferred until the end of the calling function!")
}
/*
In Function1 at the top
In Function1 at the bottom!
Function2: Deferred until the end of the calling function!
*/

func f() {
 for i := 0; i < 5; i++ {
  defer fmt.Printf("%d ", i)
 }
}
// 4 3 2 1 0

package main

import (
 "io"
 "log"
)

func func1(s string) (n int, err error) {
 defer func() {
  log.Printf("func1(%q) = %d, %v", s, n, err)
 }()
 return 7, io.EOF
}

func main() {
 func1("Go")
}
//Output: 2011/10/04 10:46:11 func1("Go") = 7, EOF

package main

import "fmt"

func main() {
 f()
}
func f() {
 for i := 0; i < 4; i++ {
  g := func(i int) { fmt.Printf("%d ", i) }
  g(i)
  fmt.Printf(" - g is of type %T and has value %v\n", g, g)
 }
}

package main

import "fmt"

func f() (ret int) {
 defer func() {
  ret++
 }()
 return 1
}
func main() {
 fmt.Println(f())
}
// 2

package main

import "fmt"

func main() {
 // make an Add2 function, give it a name p2, and call it:
 p2 := Add2()
 fmt.Printf("Call Add2 for 3 gives: %v\n", p2(3))
 // make a special Adder function, a gets value 2:
 TwoAdder := Adder(2)
 fmt.Printf("The result is: %v\n", TwoAdder(3))
}

func Add2() func(b int) int {
 return func(b int) int {
  return b + 2
 }
}

func Adder(a int) func(b int) int {
 return func(b int) int {
  return a + b
 }
}

func MakeAddSuffix(suffix string) func(string) string {
 return func(name string) string {
  if !strings.HasSuffix(name, suffix) {
   return name + suffix
  }
  return name
 }
}

where := func() {
 _, file, line, _ := runtime.Caller(1)
 log.Printf("%s:%d", file, line)
}
where()
// some code
where()
// some more code
where()

func test(){
    defer func(){
        err:= recover() //内置函数，用来捕获异常
        if err != nil {
            fmt.Println(err)
        }
        
    }()

    num1 := 10
    num := 0
    res := num1/num
}

var intarray [10]int

q := [...]int{1, 2, 3}
// "..."表示数组的长度是根据初始化值的个数来计算

type Currency int

const (
    USD Currency = iota // 美元
    EUR                 // 欧元
    GBP                 // 英镑
    RMB                 // 人民币
)

symbol := [...]string{USD: "$", EUR: "€", GBP: "￡", RMB: "￥"}

fmt.Println(RMB, symbol[RMB]) // "3 ￥"

r := [...]int{99: -1}

//
var team [3]string
team[0] = "hammer"
team[1] = "soldier"
team[2] = "mum"
for k, v := range team {
    fmt.Println(k, v)
}

type IntSlice struct {
    ptr      *int
    len, cap int
}

var mapname map[keytype]valuetype
// - mapname 为 map 的变量名。
// - keytype 为键类型。
// - valuetype 是键对应的值类型。
//[keytype] 和 valuetype 之间允许有空格。

make(map[keytype]valuetype, cap)

mp1 := make(map[int][]int)
mp2 := make(map[int]*[]int)

m := map[int]int{
    0:0,
    1:1,                                  // 最后的逗号是必须的
}
n := map[string]S{
    "a":S{0,1},
    "b":{2,3},                            // 类型名称可省略
}

m[0] = 3                              // 修改m中key为0的值为3
m[4] = 8                              // 添加到m中key为4值为8

a := n["a"]                           // 获取n中key为"a"的值
b, ok := n["c"]                       // 取值, 并通过ok(bool)判断key对应的元素是否存在.

delete(n, "a")                        // 使用内置函数delete删除key为"a"对应的元素.

for k,v :=range m{
    
}

type identifier struct {
    field1 type1
    field2 type2
    ...
}

var p T
var p1 = T{}
var p2 *T = new(T) //结构体指针
var p3 *T = &T{}

var s T
s.a = 5
s.b = 8

//结构体指针的标准方式是`(*s).a = 5`
//但go做了简化，可以直接写`s.a = 5` ,由编译器进行转化



// 或者在声明时就赋值
var p4 = T{5,8}  //要注意顺序
var p5 = T{field1:5,field2:8} 

var t *T
t = new(T)

package main
import "fmt"

type struct1 struct {
    i1  int
    f1  float32
    str string
}

func main() {
    ms := new(struct1)
    ms.i1 = 10
    ms.f1 = 15.5
    ms.str= "Chris"
    fmt.Println(ms) // &{10 15.5 Chris}
}

    ms := &struct1{10, 15.5, "Chris"}
    // 此时 ms 的类型是 *struct1

    ms1 = struct1{i1:10, f1:15.5, str:"Chris"}
    var ms2 struct1
    ms2 = struct1{10, 15.5, "Chris"}

package main

import "fmt"

type innerS struct {
 in1 int
 in2 int
}

type outerS struct {
 b    int
 c    float32
 int  // anonymous field
 innerS //anonymous field
}

func main() {
 outer := new(outerS)
 outer.b = 6
 outer.c = 7.5
 outer.int = 60
 outer.in1 = 5
 outer.in2 = 10

// 使用结构体字面量
outer2 := outerS{6, 7.5, 60, innerS{5, 10}}
}

type A struct {a int}
type B struct {a, b int}

type C struct {A; B}
var c C
//只能用c.A.a 和 c.B.a来调用

type Point struct{ X, Y float64 }

func (p Point) Distance(q Point) float64 {
// calculate distance between p and q
}

p := Point{1, 2}
q := Point{4, 6}
distanceFromP := p.Distance // method value
distance := distanceFromP(q) // Call the method using method value

import "fmt"

type Number struct {
sum int
}

func (n Number) Add(i int) Number {
n.sum += i
//res = n
return n
}

func (np *Number) AddbyPtr(i int) {
np.sum += i
}

func Test() {
a := Number{1}
b := Number{1}
a.Add(1)
fmt.Printf("a: %d\n", a.sum)
b.AddbyPtr(1)
fmt.Printf("b: %d\n", b.sum)

fmt.Println()

c := a
c.Add(1)
fmt.Printf("a: %d\n", a.sum)
fmt.Printf("c: %d\n", c.sum)

e := a.Add(1)
fmt.Printf("e: %d\n", e.sum)

fmt.Println()

d := b
d.AddbyPtr(1)
fmt.Printf("b: %d\n", b.sum)
fmt.Printf("d: %d\n", d.sum)
}

/*
运行结果：
a: 1
b: 2

a: 1
c: 1
e: 2

b: 2
d: 3
*/

type Namer interface {
    Method1(param_list) return_type
    Method2(param_list) return_type
    ...
}

package main

import "fmt"

type Shaper interface {
 Area() float32
}

type Square struct {
 side float32
}

func (sq *Square) Area() float32 {
 return sq.side * sq.side
}

func main() {
 sq1 := new(Square)
 sq1.side = 5

 var areaIntf Shaper
 areaIntf = sq1
 // shorter,without separate declaration:
 // areaIntf := Shaper(sq1)
 // or even:
 // areaIntf := sq1
 fmt.Printf("The square has area: %f\n", areaIntf.Area())
}

package main

import "fmt"

type Shaper interface {
 Area() float32
}

type Square struct {
 side float32
}

func (sq *Square) Area() float32 {
 return sq.side * sq.side
}

type Rectangle struct {
 length, width float32
}

func (r Rectangle) Area() float32 {
 return r.length * r.width
}

func main() {

 r := Rectangle{5, 3} // Area() of Rectangle needs a value
 q := &Square{5}      // Area() of Square needs a pointer
 // shapes := []Shaper{Shaper(r), Shaper(q)}
 // or shorter
 shapes := []Shaper{r, q}
 fmt.Println("Looping through shapes for area ...")
 for n, _ := range shapes {
  fmt.Println("Shape details: ", shapes[n])
  fmt.Println("Area of this shape is: ", shapes[n].Area())
 }
}

type ReadWrite interface {
    Read(b Buffer) bool
    Write(b Buffer) bool
}

type Lock interface {
    Lock()
    Unlock()
}

type File interface {
    ReadWrite
    Lock
    Close()
}

if v, ok := varI.(T); ok {  // checked type assertion
    Process(v)
    return
}
// varI is not of type T

package main

import (
 "fmt"
 "math"
)

type Square struct {
 side float32
}

type Circle struct {
 radius float32
}

type Shaper interface {
 Area() float32
}

func main() {
 var areaIntf Shaper
 sq1 := new(Square)
 sq1.side = 5

 areaIntf = sq1
 // Is Square the type of areaIntf?
 if t, ok := areaIntf.(*Square); ok {
  fmt.Printf("The type of areaIntf is: %T\n", t)
 }
 if u, ok := areaIntf.(*Circle); ok {
  fmt.Printf("The type of areaIntf is: %T\n", u)
 } else {
  fmt.Println("areaIntf does not contain a variable of type Circle")
 }
}

func (sq *Square) Area() float32 {
 return sq.side * sq.side
}

func (ci *Circle) Area() float32 {
 return ci.radius * ci.radius * math.Pi
}

switch t := areaIntf.(type) {
case *Square:
 fmt.Printf("Type Square %T with value %v\n", t, t)
case *Circle:
 fmt.Printf("Type Circle %T with value %v\n", t, t)
case nil:
 fmt.Printf("nil value: nothing to check?\n")
default:
 fmt.Printf("Unexpected type %T\n", t)
}

type Stringer interface {
    String() string
}

if sv, ok := v.(Stringer); ok {
    fmt.Printf("v implements String(): %s\n", sv.String()) // note: sv, not v
}

package main

import (
 "fmt"
)

type List []int

func (l List) Len() int {
 return len(l)
}

func (l *List) Append(val int) {
 *l = append(*l, val)
}

type Appender interface {
 Append(int)
}

func CountInto(a Appender, start, end int) {
 for i := start; i <= end; i++ {
  a.Append(i)
 }
}

type Lener interface {
 Len() int
}

func LongEnough(l Lener) bool {
 return l.Len()*10 > 42
}

func main() {
 // A bare value
 var lst List
 // compiler error:
 // cannot use lst (type List) as type Appender in argument to CountInto:
 //       List does not implement Appender (Append method has pointer receiver)
 // CountInto(lst, 1, 10)
 if LongEnough(lst) { // VALID: Identical receiver type
  fmt.Printf("- lst is long enough\n")
 }

 // A pointer value
 plst := new(List)
 CountInto(plst, 1, 10) // VALID: Identical receiver type
 if LongEnough(plst) {
  // VALID: a *List can be dereferenced for the receiver
  fmt.Printf("- plst is long enough\n")
 }
}

type Any interface {}

var val Any
val = 5
val = str
pers1 := new(Person)
pers1.name = "Rob Pike"
pers1.age = 55
val = pers1

switch t := val.(type) {
case int:
    ...
case string:
    ...
}

type Element interface{}
type Vector struct {
 a []Element
}

func main() {
 var  m Vector
 m.a = append(m.a, 1)
 m.a = append(m.a, 1.1)
 m.a = append(m.a, "hello")
 for i, v := range m.a {
     fmt.Printf("m.a[%d] = %v (%T)\n", i, v, v)
 }

}

var dataSlice []myType = FuncReturnSlice()
var interfaceSlice []interface{} = dataSlice

type iface struct {
    tab  *itab     // 指向类型信息和方法表
    data unsafe.Pointer // 指向实际值的内存
}

var dataSlice []myType = FuncReturnSlice()
var interfaceSlice []interface{} = make([]interface{}, len(dataSlice))
for i, d := range dataSlice {
    interfaceSlice[i] = d
}

// node_structures.go
package main

import "fmt"

type Node struct {
 le   *Node
 data interface{}
 ri   *Node
}

func NewNode(left, right *Node) *Node {
 return &Node{left, nil, right}
}

func (n *Node) SetData(data interface{}) {
 n.data = data
}

func main() {
 root := NewNode(nil, nil)
 root.SetData("root node")
 // make child (leaf) nodes:
 a := NewNode(nil, nil)
 a.SetData("left node")
 b := NewNode(nil, nil)
 b.SetData("right node")
 root.le = a
 root.ri = b
 fmt.Printf("%v\n", root) // Output: &{0x125275f0 root node 0x125275e0}
}

package main

import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("Start")

    fmt.Println("greet start")
    go greet()
    fmt.Println("greet end")

    time.Sleep(2 * time.Second)
    fmt.Println("Main function ends")
}

func greet() {
    // 在新的 goroutine 中执行的函数
    time.Sleep(1 * time.Second)
    fmt.Println("Hello from goroutine")
}

package main

import (
    "fmt"
    "time"
)

var (
    varmap = make(map[int]int, 10)
)

func test(n int) {
    res := 1
    for i := 0; i < n; i++ {
        res += i
    }

    varmap[n] = res
}
func main() {

    for i := 0; i < 100; i++ {
        go test(i)
    }

    time.Sleep(time.Second * 1)
    for k, v := range varmap {
        fmt.Println(k, v)
    }
}

package main

import (
    "fmt"
    "sync"
)

var (
    varmap = make(map[int]int, 10)
    lock   sync.Mutex
)

func test(n int) {
    res := 0
    for i := 1; i < n; i++ {
        res += i
    }
    lock.Lock()
    varmap[n] = res
    lock.Unlock()
}
func main() {
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            test(i)
        }(i)
    }

    wg.Wait() // 等待所有goroutine执行完毕

    lock.Lock()
    for k, v := range varmap {
        fmt.Println(k, v)
    }
    lock.Unlock()
}

var intchan chan int
var mapchan chan map[int]string
var perChan chan *Person
var perChan2 chan Person


//channel 必须初始化才能使用，即make
intchan = make(chan int,3)


//向管道写入数据
intChan<- 10
num := 211
intChan<- num
intChan<- 50
// intChan<- 98//注意点, 当我们给管写入数据时，不能超过其容量

// 看看管道的长度和 cap(容量)
fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

//从管道中读取数据
var num2 int
num2 = <-intChan
fmt.Println("num2=", num2)
fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))
// 2, 3

//在没有使用协程的情况下，如果我们的管道数据已经全部取出，再取就会报告 deadlock
num3 := <-intChan
num4 := <-intChan
num5 := <-intChan
fmt.Println("num3=", num3, "num4=", num4, "num5=", num5)



//关闭管道
close(intChan)
// 关闭后，就不能向管道写入数据，但仍然可以读取管道的数据

var allChan chan interface{}
allChan = make(chan interface{}, 3)
allChan <- 1
allChan <- "hello"
allChan <- true
num := <-allChan
fmt.Println("num=", num)


<-allChan
<-allChan
//struct
type Person struct {
    name string
    age int
}
allChan <- Person{name: "张三", age: 18}

person := <-allChan
fmt.Println("person.name=", person.name) // 报错：person.name undefined (type interface{} has no field or method name)

// 这里需要使用类型断言
a :=person.(Person)
fmt.Println("person.name=", a.name)

ch := make(chan int,10)
for i := 0; i < 10; i++ {
    ch <- i
}

close(ch)

for v := range ch {
    fmt.Println(v)
}



// for {
//     v, ok := <-ch
//     if !ok {
//         break
//     }

//     fmt.Printf("readData 读到数据=%v\n", v)
// }

package main

import "fmt"

func InsertNum(intchan chan int, n int) {
    for i := 1; i <= n; i++ {
        intchan <- i
    }
    close(intchan)
}

func process(intchan chan int, resChan chan map[int]int, exitchan chan bool) {
    for {
        num, ok := <-intchan
        if !ok {
            break
        }
        res := make(map[int]int)
        for i := 1; i <= num; i++ {
            res[num] += i
        }
        resChan <- res
    }
    exitchan <- true
}
func main() {
    n := 2000
    numChan := make(chan int, n)
    resChan := make(chan map[int]int, n)
    exitChan := make(chan bool)
    go InsertNum(numChan, n)
    num := 8
    for i := 0; i < num; i++ {
        go process(numChan, resChan, exitChan)
    }

    for i := 0; i < num; i++ {
        <-exitChan
    }
    close(exitChan)
    close(resChan)
    for i := 0; i < num; i++ {
        for res := range resChan {
            for k, v := range res {
                fmt.Printf("res[%d] = %d\n", k, v)
            }
        }
    }
}