init

Author: 2501224066

11.反射Reflection.md

@@ -0,0 +1,162 @@
+## 反射Reflection
+-反射可以大大提高程序的灵活性，使得 `interface{}` 有更大的发挥余地  
+-反射使用 `TypeOf` 和 `ValueOf` 函数从接口中获取目标对象信息  
+-反射会将匿名字段作为独立字段（匿名字段本质）  
+-想要利用反射修改对象状态，前提是 `interface.data` 是 `settable` ，即 `pointer-interface`  
+-通过反射可以 “动态” 调用方法  
+
+    import (
+	    "fmt"
+	    "reflect"
+    )
+
+    type User struct {
+        Id   int
+        Name string
+        Age  int
+    }
+
+    func (u User) Hello() {
+        fmt.Println("Hello World.")
+    }
+
+    func main() {
+        u := User{1, "ok", 12}
+        Info(u)
+    }
+
+    func Info(o interface{}) {
+        //结构名称
+        t := reflect.TypeOf(o)
+        fmt.Println("Type:", t.Name())
+
+        //判断传入参数类型,比如 main() 中使用 Info(&u) 时
+        if k := t.Kind(); k != reflect.Struct {
+            fmt.Println("error")
+            return
+        }
+
+        //字段信息
+        v := reflect.ValueOf(o)
+        fmt.Println("Fields:")
+        for i := 0; i < t.NumField(); i++ {
+            f := t.Field(i)
+            val := v.Field(i).Interface()
+            fmt.Printf("%6s: %v = %v\n", f.Name, f.Type, val)
+        }
+
+        //方法信息
+        for i := 0; i < t.NumMethod(); i++ {
+            m := t.Method(i)
+            fmt.Printf("%6s: %v\n", m.Name, m.Type)
+        }
+    }
+
+嵌套反射获取信息
+
+    import (
+	    "fmt"
+	    "reflect"
+    )
+
+    type User struct {
+        Id   int
+        Name string
+        Age  int
+    }
+
+    type Manager struct {
+        User
+        title string
+    }
+
+    func main() {
+        m := Manager{User: User{1, "Ok", 2}, title: "999"}
+        t := reflect.TypeOf(m)
+
+        fmt.Printf("%#v\n", t.FieldByIndex([]int{0, 1}))
+    }
+
+修改变量
+
+    import (
+	    "fmt"
+	    "reflect"
+    )
+
+    func main() {
+        x := 123
+        v := reflect.ValueOf(&x)
+        v.Elem().SetInt(999)
+
+        fmt.Println(x)
+    }
+
+修改结构值
+
+    import (
+	    "fmt"
+	    "reflect"
+    )
+
+    type User struct {
+        Id   int
+        Name string
+        Age  int
+    }
+
+    func main() {
+        u := User{1, "OK", 2}
+        Set(&u)
+        fmt.Println(u)
+    }
+
+    func Set(o interface{}) {
+        v := reflect.ValueOf(o)
+
+        if v.Kind() == reflect.Ptr && !v.Elem().CanSet() {
+            fmt.Println("error")
+            return
+        } else {
+            v = v.Elem()
+        }
+
+        //判断字段是否存在
+        f := v.FieldByName("Name")
+        if !f.IsValid() {
+            fmt.Println("BAD")
+            return
+        }
+
+        if f.Kind() == reflect.String {
+            f.SetString("BYEBYE")
+        }
+    }
+
+通过反射“动态”调用
+
+    import (
+	    "fmt"
+	    "reflect"
+    )
+
+    type User struct {
+        Id   int
+        Name string
+        Age  int
+    }
+
+    func (u User) Hello(name string) {
+        fmt.Println("Hello", name, ", my name is", u.Name)
+    }
+
+    func main() {
+        u := User{1, "OK", 2}
+        v := reflect.ValueOf(u)
+        //获取方法
+        mv := v.MethodByName("Hello")
+
+        args := []reflect.Value{reflect.ValueOf("joe")}
+        //动态调用
+        mv.Call(args)
+    }

11.接口Interface.md

@@ -0,0 +1,41 @@
+## 接口Interface
+-接口是一个或多个方法签名的集合  
+-只要某个类型拥有该接口的索引方法签名，即算实现该接口，无需显示声明实现了哪个接口，这称为 `Structural Typing`  
+-接口只有方法声明，没有实现，没有数据字段  
+-接口可以匿名嵌入其他接口，，即嵌入到结构中  
+-将对象赋值给接口，会发生拷贝，而接口内部存储的是指向这个复制品的指针，即无法修改复制品的状态，也无法获取指针  
+-只有当接口存储的类型和对象都为 `nil` 时，接口才等于 `nil`  
+-接口调用不会做 `receiver` 的字段转换  
+-接口同样支持匿名字段方法  
+接口也可实现类似 `OOP` 中的多态  
+-空接口可以作为任何类型数据的容器  
+
+    type USB interface {
+        Name() string
+        Connect()
+    }
+
+    type PhoneConnecter struct {
+        name string
+    }
+
+    func (pc PhoneConnecter) Name() string {
+        return pc.name
+    }
+
+    func (pc PhoneConnecter) Connect() {
+        fmt.Println("Connect:", pc.name)
+    }
+
+    func main() {
+        var a USB
+        a = PhoneConnecter{"THINKPAD"}
+        a.Connect()
+    }
+
+## 类型断言
+-通过类型断言的 `pk pattern` 可以批判的接口中的数据类型  
+-使用 `type switch` 则可针对空接口进行比较全面的类型判断  
+
+## 接口转换
+-可以将拥有超集的接口转换为子集的接口  

12.并发Concurrency.md

@@ -0,0 +1,137 @@
+## 并发 `concurrency`
+-从源码解析来看， `goroutine` 只是由官方实现的超级 “线程池” 而已  
+-并发部署并行  
+-并发主要由切换时间片段来实现 “同时” 运行，并行则是直接利用多核实现多线程的运行，但 Go 可以设置使用核数，以发挥多核计算机的能力    
+
+    import (
+        "fmt"
+        "time"
+    )
+
+    func main() {
+        go Go()
+        //等待两秒
+        time.Sleep(2 * time.Second)
+    }
+
+    func Go() {
+        fmt.Println("Go Go Go!!!")
+    }
+
+**`goroutine` 奉行通过通信来共享内存，而不是共享内存来通信**
+## `channel`
+-`channel` 是 `goroutine` 沟通的桥梁，大都是阻塞同步的  
+-通过 `make` 创建， `close` 关闭  
+-`channel` 时引用类型  
+-可以使用 `for range` 来迭代不断操作 `channel`  
+-可以设置单向或双向通道  
+-可以设置缓存大小，在未被填满前不会发生阻塞  
+
+    func main() {
+        c := make(chan bool)
+        go func() {
+            fmt.Println("Go Go Go!!!")
+            c <- true
+            close(c)
+        }()
+        for v := range c {
+            fmt.Println(v)
+        }
+    }
+
+## `select`
+-可处理一个或多个 `channel` 的发送和接收  
+-同时有多个可用的 `channel`是按随机顺序处理  
+-可用空的 `select` 来阻塞 `main` 函数  
+-可设置超时  
+
+    func main() {
+        c1, c2 := make(chan int), make(chan string)
+        o := make(chan bool)
+        go func() {
+            for {
+                select {
+                    case v, ok := <-c1:
+                        if !ok {
+                            o <- true
+                            break
+                        }
+                        fmt.Println("c1:",v)
+                
+                    case v, ok := <-c2:
+                        if !ok {
+                            o <- true
+                            break
+                        }
+                        fmt.Println("c2:",v)		
+                }
+            }
+        }()
+        c1 <- 1
+        c2 <- "hi"
+        c1 <- 3
+        c2 <- "hello"
+
+        close(c1)
+
+        <-o
+    }
+
+`select` 发送 
+
+    func main() {
+        c := make(chan int)
+        go func() {
+            for v := range c {
+                fmt.Println(v)
+            }
+        }()
+
+        for {
+            select {
+            case c <- 0:
+            case c <- 1:
+            }
+        }
+
+    }
+
+`select` 设置超时
+
+    import (
+        "fmt"
+        "time"
+    )
+
+    func main() {
+        c := make(chan bool)
+
+        select {
+        case v:= <-c:
+            fmt.Println(v)
+        case <-time.After(3 * time.Second):
+            fmt.Println("Timeout")
+        }
+    }
+
+课后习题
+
+    var c chan string
+
+    func Pingpang() {
+        i := 0
+        for {
+            fmt.Println(<-c)
+            c <- fmt.Sprintf("From Pingpang: Hi, #%d", i)
+            i++
+        }
+    }
+
+    func main() {
+        c = make(chan string)
+        go Pingpang()
+        for i := 0; i < 10; i++ {
+            c <- fmt.Sprintf("From Pingpang: Hello, #%d", i)
+            fmt.Println(<-c)
+        }
+    }