Go语言编程思想

package main

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

func main() {
    resp, err := http.Get("http://www.imooc.com")
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()

    bytes, _ := ioutil.ReadAll(resp.Body)
    fmt.Printf("%s\n", bytes)
}

package main

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

func retrieve(url string) string {
    resp, err := http.Get(url)
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()

    bytes, _ := ioutil.ReadAll(resp.Body)
    return string(bytes)
}

func main() {
    fmt.Println(retrieve("http://www.imooc.com"))
}

D:.
│  downloader.go   // main函数，使用接口
│  go.mod
│
├─infra      //infra包，基础架构团队，负责网络请求、磁盘读写、数据库等
│       urlretriever.go  // 接口方法的实现
└─testing    //testing包，测试团队
        retriever.go     // 接口方法的实现

#infra/urlretriever.go 文件代码
package infra

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

type Retriever struct{}

// 定义方法
func (Retriever) Get(url string) string { // 接收者(Retriever)里什么也没有，这里不需要定义名字，也用不到
    resp, err := http.Get(url)
    if err != nil {
        panic(err)
    }

    defer resp.Body.Close()

    bytes, _ := ioutil.ReadAll(resp.Body)
    return string(bytes)
}

#testing/retriever.go 文件代码
package testing

type Retriever struct {}

func (Retriever) Get(url string) string {
    return "fake content" // 返回假数据
}

# downloader.go 文件代码
package main

import (
    "fmt"
    "learngo/testing"
)

// 演变1
// 把retriever绑定到 infra.Retriever上，看上去更像是配置还不像逻辑，这里把它提出来写一个函数
// func main() {
//  retriever := infra.Retriever{}
//  fmt.Println(retriever.Get("http://www.imooc.com"))
// }

// 演变2
// retriever逻辑化 var retriever infra.Retriever = getRetriever()
// 缺点 retriever 一定是 infra.Retriever 类型
// func getRetriever() infra.Retriever {
//  return infra.Retriever{}
// }

// func main() {
//  var retriever infra.Retriever = getRetriever()
//  fmt.Println(retriever.Get("http://www.imooc.com"))
// }

// 演变3
// 换一个retriever，使用测试团队的方法
// 要在原来基础上改很多地方
// func getRetriever() testing.Retriever {
//  return testing.Retriever{}
// }

// func main() {
//  var retriever testing.Retriever = getRetriever()
//  fmt.Println(retriever.Get("http://www.imooc.com"))
// }

// 演变4 接口引入
// go语言是强类型的
// 需要代码和逻辑一致
// var retriever ？ = getRetriever() 其中？是一个东西，可以Get(string)的东西
// 这个？问号怎么描述，这就是我们的接口
func getRetriever() retriever {
    return testing.Retriever{} // 测试团队代码通过，可换成正式代码 return infra.Retriever{}
}

// ?Something that can "Get"
type retriever interface { // 这个接口可以Get
    Get(string) string
}
func main() {
    var r retriever = getRetriever() // 这个东西是什么？是getRetriever()
    fmt.Println(r.Get("http://www.imooc.com"))
}

#  retriever/main.go文件
func main() {
    var r Retriever
    r = mock.Retriever{"this is a fake imooc.com"}
    fmt.Printf("%T %v\n", r, r) // 查看r的类型 mock.Retriever {this is a fake imooc.com}

    r = real.Retriever{
        UserAgent: "Mozilla/5.0",
        TimeOut: time.Minute,
    }
    fmt.Printf("%T %v\n", r, r) // real.Retriever {Mozilla/5.0 1m0s}

    //fmt.Println(download(r))
}


# real中Retriever定义成指针类型，通过指针访问Get
#  retriever/real/retriever.go文件
type Retriever struct {
    UserAgent string
    TimeOut   time.Duration
}

func (r *Retriever) Get(url string) string {

#  retriever/main.go文件
func main() {
    var r Retriever
    r = mock.Retriever{"this is a fake imooc.com"}
    fmt.Printf("%T %v\n", r, r) // 查看r的类型 mock.Retriever {this is a fake imooc.com}

    r = &real.Retriever{             //Retriever中Get是指针接收者
        UserAgent: "Mozilla/5.0",
        TimeOut: time.Minute,

    }
    fmt.Printf("%T %v\n", r, r) // 类型指针*real.Retriever 值也是指针&{Mozilla/5.0 1m0s}

    //fmt.Println(download(r))
}

// ReadCloser is the interface that groups the basic Read and Close methods.
type ReadCloser interface {
    Reader
    Closer
}

// WriteCloser is the interface that groups the basic Write and Close methods.
type WriteCloser interface {
    Writer
    Closer
}

// ReadWriteCloser is the interface that groups the basic Read, Write and Close methods.
type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

# retriever/main.go
package main

import (
    "fmt"
    "learngo/retriever/mock"
)

type Retriever interface { // 定义接口Retriever，里面有个Get方法
    Get(url string) string
}

type Poster interface {
    Post(url string,
        form map[string]string) string
}

const url = "http://www.imooc.com"
func download(r Retriever) string { // 使用者，定义函数download，使用接口r的Get方法
    return r.Get(url)
}

func post(poster Poster) {
    poster.Post(url,
     map[string]string {
        "name": "xxx",
        "course": "golang",
     })
}

// 接口组合   组合 Retriever和Poster接口
type RetrieverPoster interface {
    Retriever
    Poster
}
func session(s RetrieverPoster) string {
    s.Post(url, map[string]string {
        "contents": "another faked imooc.com",
    })
    return  s.Get(url)
}

func main() {
    retriever := mock.Retriever{"this is a fake imooc.com"}

    fmt.Println("Try a session")
    fmt.Println(session(&retriever))
}

# 实现者
# retriever/mock/mockretriever.go
package mock

type Retriever struct {
    Contents string  // 内容
}

func (r *Retriever) Get(url string) string { // 实现接口的方法
    return r.Contents
}

func (r *Retriever) Post(url string,
    form map[string]string) string {
        r.Contents = form["contents"]
    return "ok"
}

func adder() func (value int) int {
    sum := 0
    return func(value int) int {
        sum += value
        return sum
    }
}

func main() {
    adder := adder()
    for i := 0; i < 100; i++ {
            fmt.Println(adder(i))
    }
}

package main

import (
    "bufio"
    "fmt"
    "learngo/functional/fib"
    "os"
)

func tryDefer() {
    defer fmt.Println(1) // defer里面相当于有一个栈，先进后出的
    defer fmt.Println(2)
    fmt.Println(3)
    // defer的好处是不怕中间有return, 甚至panic
    panic("error occurred")
    fmt.Println(4)
}

func writeFile(filename string) { // 将斐波那契数列写入到文件
    file, err := os.Create(filename)  // 打开一个文件
    if err != nil {
        panic(err)
    }
    defer file.Close() // 使用defer，函数结束后关闭文件

    // file直接写文件比较慢，这里用 bufio 加载到内存方式
    writer := bufio.NewWriter(file)
    defer writer.Flush() // 保存到文件

    f := fib.Fibonacci()
    for i := 0; i < 20; i++ { //写入前20个
        fmt.Fprintln(writer, f())
    }
}

func main() {
    writeFile("fib.txt")
}

package fib

func Fibonacci() func() int {
    a, b := 0, 1
    return func() int {
        a, b = b, a + b
        return a
    }
}

file, err := os.Open("abc.txt")
if err != nil {
        if pathError, ok := err.(*os.PathError); ok {
               fmt.Println(pathError.Err)
           } else {
               fmt.Println("unknwon error", err)
           }
    }

package main

import (
    "bufio"
    "errors"
    "fmt"
    "learngo/functional/fib"
    "os"
)

func tryDefer() {
    defer fmt.Println(1) // defer里面相当于有一个栈，先进后出的
    defer fmt.Println(2)
    fmt.Println(3)
    // defer的好处是不怕中间有return, 甚至panic
    panic("error occurred")
    fmt.Println(4)
}

func writeFile(filename string) { // 将斐波那契数列写入到文件
    file, err := os.OpenFile(filename, os.O_EXCL|os.O_CREATE, 0666)  // 打开一个文件

    // 自己设置的error
    err = errors.New("this is a custom error")
    // error的处理
    if err != nil {
        // panic(err) // panic比较难看
        // fmt.Println("file already exists")
        // fmt.Println("Error:", err.Error()) // 不加err.Error() 也可以 ，Println会err中的string找到
        // os.OpenFile中返回的error是*PathError。If there is an error, it will be of type *PathError
        if pathError, ok := err.(*os.PathError); !ok {
            panic(err)
        } else {
            fmt.Printf("%s, %s, %s\n", pathError.Op,
            pathError.Path,
            pathError.Err) // open, fib.txt, The file exists.
        }
        return
    }
    defer file.Close() // 使用defer，函数结束后关闭文件

    // file直接写文件比较慢，这里用 bufio 加载到内存方式
    writer := bufio.NewWriter(file)
    defer writer.Flush() // 保存到文件

    f := fib.Fibonacci()
    for i := 0; i < 20; i++ { //写入前20个
        fmt.Fprintln(writer, f())
    }
}

func main() {
    writeFile("fib.txt")
}

// url中显示文件内容
package main

import (
    "io/ioutil"
    "net/http"
    "os"
)

func main() {
    http.HandleFunc("/list/",
        func(writer http.ResponseWriter, request *http.Request) {
            path := request.URL.Path[len("/list/"):] // /list/fib.txt 得到真实文件的路径
            file, err := os.Open(path)
            if err != nil {
                panic(err)
            }
            defer file.Close()

            all, err := ioutil.ReadAll(file)
            if err != nil {
                panic(err)
            }

            writer.Write(all)
        })

    err := http.ListenAndServe(":8888", nil)
    if err != nil {
        panic(err)
    }
}

file, err := os.Open(path)
if err != nil {  // 错误处理，返回错误及http状态
    http.Error(writer,
        err.Error(),
        http.StatusInternalServerError)
    return
}

package filelisting

import (
    "io/ioutil"
    "net/http"
    "os"
)

func HandleFileList(writer http.ResponseWriter,
    request *http.Request) error {
    path := request.URL.Path[len("/list/"):] // /list/fib.txt 得到真实文件的路径
    file, err := os.Open(path)
    if err != nil { // 错误处理，不需要处理err
        return err
    }
    defer file.Close()

    all, err := ioutil.ReadAll(file)
    if err != nil {
        return err
    }

    writer.Write(all)
    return err
}

// url中显示文件内容
package main

import (
    "learngo/errhandling/filelistingserver/filelisting"
    "log"
    "net/http"
    "os"
)

// 统一错误处理
type appHandler func(writer http.ResponseWriter, request *http.Request) error

func errWrapper(handler appHandler) func(http.ResponseWriter, *http.Request) { // 把输入的函数包装成一个输出的函数。 函数式编程，函数即可做参数，也可做返回值
    return func(writer http.ResponseWriter,
        request *http.Request) {
        err := handler(writer, request)
        if err != nil { // 错误处理
            log.Printf("error handing request: %s",
                err.Error()) // 程序记录错误
            code := http.StatusOK
            switch {
            case os.IsNotExist(err): // 文件不存在的错误
                code = http.StatusNotFound
            case os.IsPermission(err): // 没有权限 403
                code = http.StatusForbidden
            default: // 什么都不知道返回 500
                code = http.StatusInternalServerError
            }
            // 参数的意义，1th: 向谁汇报err，这里为writer, 2th: 页面显示的错误信息， 3th: 状态码
            http.Error(writer,
                http.StatusText(code),
                code)
        }
    }
}

func main() {
    http.HandleFunc("/list/", errWrapper(filelisting.HandleFileList)) // 将函数中业务逻辑提出去

    err := http.ListenAndServe(":8888", nil)
    if err != nil {
        panic(err)
    }
}

// url中显示文件内容
package main

import (
    "learngo/errhandling/filelistingserver/filelisting"
    "log"
    "net/http"
    "os"
)

// 统一错误处理
type appHandler func(writer http.ResponseWriter, request *http.Request) error

func errWrapper(handler appHandler) func(http.ResponseWriter, *http.Request) { // 把输入的函数包装成一个输出的函数。 函数式编程，函数即可做参数，也可做返回值
    return func(writer http.ResponseWriter,
        request *http.Request) {
        defer func() { // 当服务发现panic时，拦截保持一下
            if r := recover(); r != nil { // 拦截pannic，不中断程序
                log.Printf("Panic: %v", r)
                http.Error(writer,
                    http.StatusText(http.StatusInternalServerError),
                    http.StatusInternalServerError)
            }
        }()

        err := handler(writer, request)

        if err != nil { // 错误处理
            log.Printf("Error handing request: %s",
                err.Error())
            code := http.StatusOK
            switch {
            case os.IsNotExist(err): // 文件不存在的错误
                code = http.StatusNotFound
            case os.IsPermission(err): // 没有权限 403
                code = http.StatusForbidden
            default: // 什么都不知道返回 500
                code = http.StatusInternalServerError
            }
            // 参数的意义，1th: 向谁汇报err，这里为writer, 2th: 页面显示的错误信息， 3th: 状态码
            http.Error(writer,
                http.StatusText(code),
                code)
        }
    }
}

func main() {
    http.HandleFunc("/", errWrapper(filelisting.HandleFileList)) // 响应/路径

    err := http.ListenAndServe(":8888", nil)
    if err != nil {
        panic(err)
    }
}

package filelisting

import (
    "errors"
    "io/ioutil"
    "net/http"
    "os"
    "strings"
)

const prefix = "/list/"

func HandleFileList(writer http.ResponseWriter,
    request *http.Request) error {
    if strings.Index(
        request.URL.Path, prefix) != 0 { // 判断路径是否匹配
        return errors.New("path must start with " + prefix)
    }
    path := request.URL.Path[len(prefix):] // /list/fib.txt 得到真实文件的路径
    file, err := os.Open(path)
    if err != nil { // 错误处理，不需要处理err
        return err
    }
    defer file.Close()

    all, err := ioutil.ReadAll(file)
    if err != nil {
        return err
    }

    writer.Write(all)
    return err
}

// url中显示文件内容
package main

import (
    "learngo/errhandling/filelistingserver/filelisting"
    "log"
    "net/http"
    "os"
)

// 统一错误处理：
type appHandler func(writer http.ResponseWriter, request *http.Request) error

func errWrapper(handler appHandler) func(http.ResponseWriter, *http.Request) { // 把输入的函数包装成一个输出的函数。 函数式编程，函数即可做参数，也可做返回值
    return func(writer http.ResponseWriter,
        request *http.Request) {
        defer func() { // 指定路径：当服务发现panic时，拦截保持一下
            if r := recover(); r != nil { // 指定路径：拦截pannic，不中断程序
                log.Printf("Panic: %v", r)
                http.Error(writer,
                    http.StatusText(http.StatusInternalServerError),
                    http.StatusInternalServerError)
            }
        }()

        err := handler(writer, request)

        if err != nil { // 统一错误处理：错误处理
            log.Printf("Error handing request: %s",
                err.Error())

            // 区分用户信息：区分给用户看的错误信息
            if userErr, ok := err.(userError); ok {
                http.Error(writer,
                    userErr.Message(),
                    http.StatusBadRequest)
                return
            }
            code := http.StatusOK
            switch {
            case os.IsNotExist(err): // 文件不存在的错误
                code = http.StatusNotFound
            case os.IsPermission(err): // 没有权限 403
                code = http.StatusForbidden
            default: // 什么都不知道返回 500
                code = http.StatusInternalServerError
            }
            // 参数的意义，1th: 向谁汇报err，这里为writer, 2th: 页面显示的错误信息， 3th: 状态码
            http.Error(writer,
                http.StatusText(code),
                code)
        }
    }
}

// 区分用户信息：定义用户错误接口
type userError interface {
    error            // 系统看的信息
    Message() string // 用户看的信息
}

func main() {
    http.HandleFunc("/", errWrapper(filelisting.HandleFileList)) // 统一错误处理|指定路径：将函数中业务逻辑提出去

    err := http.ListenAndServe(":8888", nil)
    if err != nil {
        panic(err)
    }
}

package filelisting

import (
    "io/ioutil"
    "net/http"
    "os"
    "strings"
)

const prefix = "/list/"

// 区分用户信息：定义userError类型
type userError string

func (e userError) Error() string {
    return e.Message()
}

func (e userError) Message() string {
    return string(e)
}

func HandleFileList(writer http.ResponseWriter,
    request *http.Request) error { // 统一错误处理: 业务逻辑
    if strings.Index(
        request.URL.Path, prefix) != 0 { // 匹配路径：判断路径是否匹配
        return userError("path must start with " + prefix) // 区分用户信息：返回用户错误信息类型值
    }
    path := request.URL.Path[len(prefix):] // 匹配路径： /list/fib.txt 得到真实文件的路径
    file, err := os.Open(path)
    if err != nil { // 错误处理，不需要处理err
        return err
    }
    defer file.Close()

    all, err := ioutil.ReadAll(file)
    if err != nil {
        return err
    }

    writer.Write(all)
    return err
}

// learngo/basic/basic/basic.go

package main

import (
  "fmt"
  "math"
)

func triangle() {
  var a, b int = 3, 4
  fmt.Println(calcTriangle(a, b))
}

func calcTriangle(a, b int) int {
  var c int
  c = int(math.Sqrt(float64(a*a + b*b)))
  return c
}
func main() {
  triangle()
}


// learngo/basic/basic/triangle_test.go

package main

import "testing"

func TestTriangle(t *testing.T) {
  tests := []struct{ a, b, c int }{
    {3, 4, 5},
    {5, 12, 13},
    {8, 15, 17},
    {12, 35, 37},
    {30000, 40000, 0},
  }

  for _, tt := range tests {
    if actual := calcTriangle(tt.a, tt.b); actual != tt.c {
      t.Errorf("calcTriangle(%d, %d); got %d; expected %d",
        tt.a, tt.b, actual, tt.c)
    }
  }
}

#进入到被测目录， 执行go test .
cd basic/basic
PS D:\project\learngo\basic\basic> go test .
--- FAIL: TestTriangle (0.00s)
    triangle_test.go:16: calcTriangle(30000, 40000); got 50000; expected 0
FAIL
FAIL    xxx.com/jasper/learngo/basic/basic      0.311s

// leedcode/nonrepeatingsubstr/nonrepeating.go

package main

import "fmt"

func lengthOfNonRepeatingSubStr(s string) int {
  lastOccurred := make(map[rune]int) // 每个字母最后出现的位置
  start := 0                         // 当前找到的最长不含有字符的子串开始
  maxLength := 0                     // 重复子串的最大长度
  // 遍历字符串
  for i, ch := range []rune(s) {

    if lastI, ok := lastOccurred[ch]; ok && lastI >= start { // lastOccurred[ch]可能是不存在的它的值是0，0参与下面的运算是不对的
      start = lastOccurred[ch] + 1
    }

    if i-start+1 > maxLength { // 更新maxLength
      maxLength = i - start + 1
    }

    lastOccurred[ch] = i
  }

  return maxLength
}

func main() {
  fmt.Println(
    lengthOfNonRepeatingSubStr("abccabcbb"))
  fmt.Println(
    lengthOfNonRepeatingSubStr("pwwkewwe"))
  fmt.Println(
    lengthOfNonRepeatingSubStr(""))
  fmt.Println(
    lengthOfNonRepeatingSubStr("b"))
  fmt.Println(
    lengthOfNonRepeatingSubStr("一二三二一"))
}


// leedcode/nonrepeatingsubstr/nonrepeating_test.go

package main

import "testing"

func TestSubstr(t *testing.T) {
  tests := []struct {
    s   string
    ans int
  }{
    // Normal cases 一般例子
    {"abccabcbb", 3},
    {"pwwkewwe", 3},

    // Edg cases 特殊例子
    {"", 0},
    {"b", 1},
    {"bbbb", 1},
    {"abcabcabcd", 4},

    // Chinese support
    {"这里是", 3},
    {"一二三二一", 3},
    {"黑化黑灰化肥黑灰会挥发发灰黑化肥黑灰化肥挥发", 0},
  }

  for _, tt := range tests {
    actual := lengthOfNonRepeatingSubStr(tt.s)
    if actual != tt.ans {
      t.Errorf("got %d for input %s; "+
        "expect %d",
        actual, tt.s, tt.ans)
    }
  }
}

PS D:\project\learngo\basic\basic> cd ..\..\leedcode\nonrepeatingsubstr\

PS D:\project\learngo\leedcode\nonrepeatingsubstr> go test .
--- FAIL: TestSubstr (0.00s)
    nonrepeating_test.go:29: got 7 for input 黑化黑灰化肥黑灰会挥发发灰黑化肥黑灰化肥挥发; expect 0
FAIL
FAIL    xxx.com/jasper/learngo/leedcode/nonrepeatingsubstr      0.245s
FAIL

 // leedcode/nonrepeatingsubstr/nonrepeating_test.go
func BenchmarkSubstr(b *testing.B) {
  // 这里选一个比较难的来示例
  s, ans := "黑化黑灰化肥黑灰会挥发发灰黑化肥黑灰化肥挥发", 7
  for i := 0; i < 13; i++ { // 增加s长度
    s = s + s
  }

  b.Logf("len(s) = %d", len(s)) //查看s的长度 b.Logf()输出日志
  b.ResetTimer() // 重置时间，排除上面准备数据的时间

  for i := 0; i < b.N; i++ { // b.N 系统决定做多少遍
    actual := lengthOfNonRepeatingSubStr(s)
    if actual != ans {
      b.Errorf("got %d for input %s; "+
        "expect %d",
        actual, s, ans)
    }
  }
}

PS D:\project\learngo\leedcode\nonrepeatingsubstr> go test -bench .
goos: windows
goarch: amd64
pkg: xxx.com/jasper/learngo/leedcode/nonrepeatingsubstr
cpu: Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz
BenchmarkSubstr-8            187           6298157 ns/op
--- BENCH: BenchmarkSubstr-8
    nonrepeating_test.go:43: len(s) = 540672
    nonrepeating_test.go:43: len(s) = 540672
    nonrepeating_test.go:43: len(s) = 540672
PASS
ok      xxx.com/jasper/learngo/leedcode/nonrepeatingsubstr      2.121s

# 187次，每次6ms左右

# 跑性能测试的同时，生成cpu耗时二进制文件
go test -bench . -cpuprofile="cpu.out"

# 使用go tool pprof 查看， 在交互式里生成图片查看
go tool pprof cpu.out
(pprof) help
(pprof) web

// leedcode/nonrepeatingsubstr/nonrepeating.go

func lengthOfNonRepeatingSubStr(s string) int {
  // lastOccurred := make(map[rune]int) // 每个字母最后出现的位置
  lastOccurred := make([]int, 0xffff) // 对于字符型map优化的方法，用空间换时间，c++
  // lastOccurred['e'] = 1 // lastOccurred[0x65] = 1
  // lastOccurred['课'] = 6 // lastOccurred[0x8BFE] = 6
  for i := range lastOccurred { // 初始值设置为 -1
    lastOccurred[i] = -1
  }

  start := 0
  maxLength := 0

  for i, ch := range []rune(s) {

    if lastI := lastOccurred[ch]; lastI != -1 && lastI >= start {  // 判断
      start = lastOccurred[ch] + 1
    }

    if i-start+1 > maxLength {
      maxLength = i - start + 1
    }

    lastOccurred[ch] = i
  }

  return maxLength
}

PS D:\project\learngo\leedcode\nonrepeatingsubstr> go test -bench . -cpuprofile="cpu.out"
goos: windows
goarch: amd64
pkg: xxx.com/jasper/learngo/leedcode/nonrepeatingsubstr
cpu: Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz
BenchmarkSubstr-8            435           3457264 ns/op
--- BENCH: BenchmarkSubstr-8
    nonrepeating_test.go:43: len(s) = 540672
    nonrepeating_test.go:43: len(s) = 540672
    nonrepeating_test.go:43: len(s) = 540672
PASS
ok      xxx.com/jasper/learngo/leedcode/nonrepeatingsubstr      2.190s

# 435次，每次3ms左右，快了2倍左右

# 再看一下性能图
go test -bench . -cpuprofile="cpu.out"
go tool pprof cpu.out
(pprof) web

// 修改 leedcode/nonrepeatingsubstr/nonrepeating.go
var lastOccurred = make([]int, 0xffff) // 提到函数外面

func lengthOfNonRepeatingSubStr(s string) int {

# 运行性能测试
go test -bench . -cpuprofile="cpu.out"
go tool pprof cpu.out
(pprof) web

// learngo\errhandling\filelistingserver/errwrapper_test.go

package main

import (
  "errors"
  "fmt"
  "io/ioutil"
  "net/http"
  "net/http/httptest"
  "os"
  "strings"
  "testing"
)

func errPanic(writer http.ResponseWriter, request *http.Request) error { // 输入函数：会panicw信息的函数
  panic(123)
}

// 区分用户信息：定义userError类型
type testingUserError string

func (e testingUserError) Error() string {
  return e.Message()
}

func (e testingUserError) Message() string {
  return string(e)
}
func errUserError(writer http.ResponseWriter, request *http.Request) error { // 输入函数：用户错误信息的函数
  return testingUserError("user error")
}

func errNotFound(writer http.ResponseWriter, request *http.Request) error { // 输入函数：文件不存在错误信息的函数
  return os.ErrNotExist
}

func errPermission(writer http.ResponseWriter, request *http.Request) error { // 输入函数：权限错误信息的函数
  return os.ErrPermission
}

func errUnkown(writer http.ResponseWriter, request *http.Request) error { // 输入函数：500错误信息的函数
  return errors.New("unknown err")
}

func noError(writer http.ResponseWriter, request *http.Request) error { // 输入函数：没有错误信息的函数
  fmt.Fprintln(writer, "no error")
  return nil
}

func TestErrWrapper(t *testing.T) {
  tests := []struct {
    h       appHandler // 输入的是函数
    code    int        // 期望的输出：状态码
    message string     // 期望的输出：信息
  }{
    {errPanic, 500, "Internal Server Error"},
    {errUserError, 400, "user error"},
    {errNotFound, 404, "Not Found"},
    {errPermission, 403, "Forbidden"},
    {errUnkown, 500, "Internal Server Error"},
    {noError, 200, "no error"},
  }

  for _, tt := range tests {
    f := errWrapper(tt.h)
    response := httptest.NewRecorder()
    request := httptest.NewRequest(
      http.MethodGet,
      "http://www.immoc.com",
      nil)
    f(response, request) // 调用出错函数
    b, _ := ioutil.ReadAll(response.Body)
    body := strings.Trim(string(b), "\n") // 把string中的换行去掉
    if response.Code != tt.code ||
      body != tt.message {
      t.Errorf("expect (%d, %s); "+
        "got (%d, %s)",
        tt.code, tt.message,
        response.Code, body)
    }
  }
}


# 查看一下哪些代码没有覆盖到
go test -coverprofile="c.out"
go tool cover -html="c.out"

// 修改 learngo\errhandling\filelistingserver/errwrapper_test.go

package main

import (
  "errors"
  "fmt"
  "io/ioutil"
  "net/http"
  "net/http/httptest"
  "os"
  "strings"
  "testing"
)

func errPanic(writer http.ResponseWriter, request *http.Request) error { // 输入函数：会panicw信息的函数
  panic(123)
}

// 区分用户信息：定义userError类型
type testingUserError string

func (e testingUserError) Error() string {
  return e.Message()
}

func (e testingUserError) Message() string {
  return string(e)
}
func errUserError(writer http.ResponseWriter, request *http.Request) error { // 输入函数：用户错误信息的函数
  return testingUserError("user error")
}

func errNotFound(writer http.ResponseWriter, request *http.Request) error { // 输入函数：文件不存在错误信息的函数
  return os.ErrNotExist
}

func errPermission(writer http.ResponseWriter, request *http.Request) error { // 输入函数：权限错误信息的函数
  return os.ErrPermission
}

func errUnkown(writer http.ResponseWriter, request *http.Request) error { // 输入函数：500错误信息的函数
  return errors.New("unknown err")
}

func noError(writer http.ResponseWriter, request *http.Request) error { // 输入函数：没有错误信息的函数
  fmt.Fprintln(writer, "no error")
  return nil
}

var tests = []struct { // 测试数据共用
  h       appHandler // 输入的是函数
  code    int        // 期望的输出：状态码
  message string     // 期望的输出：信息
}{
  {errPanic, 500, "Internal Server Error"},
  {errUserError, 400, "user error"},
  {errNotFound, 404, "Not Found"},
  {errPermission, 403, "Forbidden"},
  {errUnkown, 500, "Internal Server Error"},
  {noError, 200, "no error"},
}

func TestErrWrapper(t *testing.T) { // 假数据

  for _, tt := range tests {
    f := errWrapper(tt.h)
    response := httptest.NewRecorder() // 提供假数据
    request := httptest.NewRequest(
      http.MethodGet,
      "http://www.immoc.com",
      nil)
    f(response, request) // 调用出错函数
    verifyResponse(
      response.Result(), tt.code, tt.message, t)
  }
}

func TestErrWrapperInServer(t *testing.T) {  // 启一个server，真实url访问请求
  for _, tt := range tests {
    f := errWrapper(tt.h)
    server := httptest.NewServer(
      http.HandlerFunc(f))
    resp, _ := http.Get(server.URL)

    verifyResponse(
      resp, tt.code, tt.message, t)
  }
}

func verifyResponse(resp *http.Response,
  expectCode int, expectMsssage string,
  t *testing.T) {
  b, _ := ioutil.ReadAll(resp.Body)
  body := strings.Trim(string(b), "\n") // 把string中的换行去掉
  if resp.StatusCode != expectCode ||
    body != expectMsssage {
    t.Errorf("expect (%d, %s); "+
      "got (%d, %s)",
      expectCode, expectMsssage,
      resp.StatusCode, body)
  }
}


# 运行测试
PS D:\project\learngo\errhandling\filelistingserver> go test -run="TestErrWrapperInServer$"
2021/11/12 22:26:45 Panic: 123
2021/11/12 22:26:45 Error handing request: user error
2021/11/12 22:26:45 Error handing request: file does not exist
2021/11/12 22:26:45 Error handing request: permission denied
2021/11/12 22:26:45 Error handing request: unknown err
PASS
ok      xxx.com/jasper/learngo/errhandling/filelistingserver    0.302s

func main() {
  for i := 0; i < 1000; i++ {
    go func(i int) {
      for {
        fmt.Println("Hello %d\n", i)
      }
    }(i)
  }
  time.Sleep(time.Microsecond)
}

// goroutine/goroutine.go

package main

import (
  "fmt"
  "time"
)

func main() {
  for i := 0; i < 1000; i++ {
    go func(i int) { // i 引用外面的 i 不安全，这里将 i 传进来
      for { // 反复打印
        fmt.Printf("Hello from goroutine %d\n", i) // 证明很多人打，给它设置一个编号
      }
    }(i)
  }
  // 这里的 main 和 for {} 是并发执行的，还来不及打印就执行完了
  // main 结束了，所有的 goroutine就被杀掉了
  // 给一定时间让 for{} 能打出东西
  time.Sleep(time.Millisecond)
}

// goroutine/goroutine.go

package main

import (
  "fmt"
  "runtime"
  "time"
)

func main() {
  var a [10]int
  for i := 0; i < 10; i++ {
    go func(i int) {
      for {
        a[i]++ // 没有机会协程间切换，就会被一个协程抢掉。不主动交出控制权，就会始终在这个协程中
        runtime.Gosched()
      }
    }(i)
  }
  time.Sleep(time.Millisecond)
  fmt.Println(a)
}

#结果
PS D:\project\learngo> go run .\goroutine\goroutine.go
[854 442 626 625 578 564 640 620 537 589]

func main() {
  var a [10]int
  for i := 0; i < 10; i++ {
    go func() {
      for {
        a[i]++
        runtime.Gosched()
      }
    }() // 解决报错需要固定i值，即把i传进函数中
  }
  time.Sleep(time.Millisecond) // 半包中 i 在这是 i= 10，a[10]是不存在的，无法在闭包中运行
  fmt.Println(a)
}

#检查数据冲突
PS D:\project\learngo> go run  -race .\goroutine\goroutine.go
==================
WARNING: DATA RACE
Read at 0x00c00012c078 by goroutine 7:

package main

import "fmt"

func chanDemo() {
  // 创建channel
  // var c chan int // c == nil ，只是定义了chan，它的值是nil，nil的channel无法使用，但在select中会用到
  c := make(chan int)
  // 发数据
  c <- 1  // 死锁在向chan发送1
  c <- 2
  // 从chan中收数据
  n := <-c
  fmt.Println(n)
}

func main() {
  chanDemo()
}

# 执行报错，死锁
PS D:\project\learngo> go run .\channel\channel.go
fatal error: all goroutines are asleep - deadlock!

goroutine 1 [chan send]:
main.chanDemo()
        D:/project/learngo/channel/channel.go:10 +0x37

func chanDemo() {
  // 创建channel
  // var c chan int // c == nil ，只是定义了chan，它的值是nil，nil的channel无法使用，但在select中会用到
  c := make(chan int)
  go func() {
    for {
      n := <-c
      fmt.Println(n)
    }
  }()
  // 发数据
  c <- 1
  c <- 2
  // 避免来不及打印，main函数先结束了
  time.Sleep(time.Millisecond)
}

func main() {
  chanDemo()
}

// 创建channel/done/done.go

package main

import (
  "fmt"
)

func doWorker(id int, c chan int, done chan bool) {
  for n := range c {
    fmt.Printf("worker %d received %c\n",
      id, n)
    // 通知外部打印完毕，通过通信共享内存
    done <- true
  }
}

type worker struct { // 包装一下2个channel
  in   chan int
  done chan bool
}

func createWorker(id int) worker {
  w := worker{
    in:   make(chan int),
    done: make(chan bool),
  }
  go doWorker(id, w.in, w.done)
  return w
}

func chanDemo() {
  var workers [10]worker    //
  for i := 0; i < 10; i++ { // 开10个work接收channel数据
    workers[i] = createWorker(i)
  }

  // 向10个channel发数据
  for i := 0; i < 10; i++ {
    workers[i].in <- 'a' + i
    <-workers[i].done
  }
  for i := 0; i < 10; i++ {
    workers[i].in <- 'A' + i
    <-workers[i].done
  }

}

func main() {
  chanDemo()
}

#输出，为有顺序打印
PS D:\project\learngo> go run .\channel\done\done.go
worker 0 received a
worker 1 received b
worker 2 received c
worker 3 received d
worker 4 received e
worker 5 received f
worker 6 received g
worker 7 received h
worker 8 received i
worker 9 received j
worker 0 received A
worker 1 received B
worker 2 received C
worker 3 received D
worker 4 received E
worker 5 received F
worker 6 received G
worker 7 received H
worker 8 received I
worker 9 received J

// channel/done/done.go

package main

import (
  "fmt"
)

func doWorker(id int, c chan int, done chan bool) {
  for n := range c {
    fmt.Printf("worker %d received %c\n",
      id, n)
    // 通知外部打印完毕，通过通信共享内存
    go func() { done <- true }() // 并行的done
  }
}

type worker struct { // 包装一下2个channel
  in   chan int
  done chan bool
}

func createWorker(id int) worker {
  w := worker{
    in:   make(chan int),
    done: make(chan bool),
  }
  go doWorker(id, w.in, w.done)
  return w
}

func chanDemo() {
  var workers [10]worker    //
  for i := 0; i < 10; i++ { // 开10个work接收channel数据
    workers[i] = createWorker(i)
  }

  // 向10个channels[i]发数据
  for i, worker := range workers {
    worker.in <- 'a' + i
  }
  for i, worker := range workers {
    worker.in <- 'A' + i
  }

  // 等待所有
  for _, worker := range workers {
    <-worker.done
    <-worker.done
  }
}

func main() {
  chanDemo()
}

// 修改 tree/treentry/entry.go
func main() {
...

  // channel，统计最大的节点树
  c := root.TraversWithChannel()
  maxNode := 0
  for node := range c {
    if node.Value > maxNode {
      maxNode = node.Value
    }
  }
  fmt.Println("Max node value:", maxNode)
}

// 修改添加 tree/traversal.go

func (node *Node) TraversWithChannel() chan *Node {
  out := make(chan *Node)
  go func() {
    node.TraverseFunc(func(n *Node) {
      out <- n
    })
    close(out)
  }()
  return out
}

// 创建select/select.go

package main

import "fmt"

func main() {
  var c1, c2 chan int // c1 and c2 == nil
  // 同时收，谁收的快要谁
  select {  // channel值为nil， 在select中是拿不到数据的，会走default， 这是一个非阻塞式的channel
  case n := <-c1:
    fmt.Println("Received from c1:", n)
  case n := <-c2:
    fmt.Println("Received from c2:", n)
  default:
    fmt.Println("No value received") // No value received
  }
}

// channel/select/select.go

package main

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

func generator() chan int { // 生成channel数据
  out := make(chan int)
  go func() {
    i := 0
    for {
      time.Sleep(time.Duration(rand.Intn(1500)) * time.Millisecond)
      out <- i
      i++
    }
  }()
  return out
}

func worker(id int, c chan int) {
  for n := range c { // 判断channel是否有数据方法2
    fmt.Printf("worker %d received %d\n",
      id, n)
  }
}

func createWorker(id int) chan<- int { // 告知channel是向channel发数据的
  c := make(chan int)
  go worker(id, c)
  return c
}

func main() {
  var c1, c2 = generator(), generator()
  // 同时收，谁收的快要谁
  // 将收过来的 c 送给 worker
  var worker = createWorker(0)
  n := 0
  haseValue := false // 告诉是否有值
  for {
    var activeWorker chan<- int
    if haseValue {  // 有值时，将activeWorker激活
      activeWorker = worker
    }

    select {
    case n = <-c1: // 收数， 但不希望收一个数据再送给channel被阻塞住 w <- n
      haseValue = true //收到值，haseValue为true
    case n = <-c2:
      haseValue = true
    case activeWorker <- n: // 发数据, nil的chanel会被阻塞到
      haseValue = false  // 发送完 haseValue变为fasle
    }
  }
  // time.Sleep()
}

// channel/select/select.go

package main

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

func generator() chan int { // 生成channel数据
  out := make(chan int)
  go func() {
    i := 0
    for {
      time.Sleep(time.Duration(rand.Intn(1500)) * time.Millisecond)
      out <- i
      i++
    }
  }()
  return out
}

func worker(id int, c chan int) {
  for n := range c { // 判断channel是否有数据方法2
    time.Sleep(1 * time.Second) // 等待5秒
    fmt.Printf("worker %d received %d\n",
      id, n)
  }
}

func createWorker(id int) chan<- int { // 告知channel是向channel发数据的
  c := make(chan int)
  go worker(id, c)
  return c
}

func main() {
  var c1, c2 = generator(), generator()
  // 同时收，谁收的快要谁
  // 将收过来的 c 送给 worker
  var worker = createWorker(0)

  // 将收到数据排队，之后再让别人消耗它
  var values  []int

  for {
    var activeWorker chan<- int
    var activeValue int
    if len(values)  >0 {  // 有值时，将activeWorker激活
      activeWorker = worker
      activeValue = values[0]
    }

    select {
    case n := <-c1: // 收数， 但不希望收一个数据再送给channel被阻塞住 w <- n
      values = append(values, n)
    case n := <-c2:
      values = append(values, n)
    case activeWorker <- activeValue: // 发数据, nil的chanel会被阻塞到
      values = values[1:]
    }
  }
  // time.Sleep()

}

// channel/select/select.go
package main

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

func generator() chan int { // 生成channel数据
  out := make(chan int)
  go func() {
    i := 0
    for {
      time.Sleep(time.Duration(rand.Intn(1500)) * time.Millisecond)
      out <- i
      i++
    }
  }()
  return out
}

func worker(id int, c chan int) {
  for n := range c { // 判断channel是否有数据方法2
    time.Sleep(1 * time.Second) // 等待5秒
    fmt.Printf("worker %d received %d\n",
      id, n)
  }
}

func createWorker(id int) chan<- int { // 告知channel是向channel发数据的
  c := make(chan int)
  go worker(id, c)
  return c
}

func main() {
  var c1, c2 = generator(), generator()
  // 同时收，谁收的快要谁
  // 将收过来的 c 送给 worker
  var worker = createWorker(0)

  // 将收到数据排队，之后再让别人消耗它
  var values  []int
  tm := time.After(10 * time.Second)
  tick := time.Tick(time.Second) // 定时功能。这里是每秒种送一个值
  for {
    var activeWorker chan<- int
    var activeValue int
    if len(values)  >0 {  // 有值时，将activeWorker激活
      activeWorker = worker
      activeValue = values[0]
    }

    select {
    case n := <-c1: // 收数， 但不希望收一个数据再送给channel被阻塞住 w <- n
      values = append(values, n)
    case n := <-c2:
      values = append(values, n)
    case activeWorker <- activeValue: // 发数据, nil的chanel会被阻塞到
      values = values[1:]
    case <- time.After(800 * time.Millisecond): // 800毫秒间没有数据打印timeout
      fmt.Println("timeout")
    case <- tick: // 定时器，每隔1秒打印value的长度
      fmt.Println("queue len=", len(values))
    case <-tm:    // 10 秒后结束
      fmt.Println("bye")
      return
    }
  }
  // time.Sleep()

}

#输出
PS D:\project\learngo> go run .\channel\select\select.go
queue len= 3
worker 0 received 0
queue len= 5
worker 0 received 0
queue len= 5
worker 0 received 1
queue len= 10
worker 0 received 1
queue len= 10
worker 0 received 2
queue len= 11
worker 0 received 2
queue len= 12
worker 0 received 3
queue len= 13
worker 0 received 3
queue len= 14
worker 0 received 4
bye

6 5
0 1 0 0 0
0 0 0 1 0
0 1 0 1 0
1 1 1 0 0
0 1 0 0 1
0 1 0 0 0

6 5
0 1 0 0 0
0 0 0 1 0
0 1 0 1 0
1 1 1 0 0
0 1 0 0 1
0 1 0 0 0

res := `{
"data": [
    {
        "synonym":"",
        "weight":"0.6",
        "word": "真丝",
        "tag":"材质"
    },
    {
        "synonym":"",
        "weight":"0.8",
        "word": "韩都衣舍",
        "tag":"品牌"
    },
    {
        "synonym":"连身裙;联衣裙",
        "weight":"1.0",
        "word": "连衣裙",
        "tag":"品类"
    }
]
}`

// json解析
m := make(map[string]interface{})
err := json.Unmarshal([]byte(res), &m)
if err != nil {
        panic(err)
}

fmt.Printf("%+v\n", m) // map[data:[map[synonym: tag:材质 weight:0.6 word:真丝] map[synonym: tag:品牌 weight:0.8 word:韩都衣舍] map[synonym:连身裙;联衣裙 tag:品类 weight:1.0 word:连衣裙]]]

// 取出 "连身裙;联衣裙"
fmt.Printf("%+v\n",m["data"].([]interface{})[2].(map[string]interface{})["synonym"]   ) // 使用type assertion 告诉每个元素的类型

// json解析
m := struct{
        Data []struct{
                Synonym string `json:"synonym"`
        } `json:"data"`
}{}
err := json.Unmarshal([]byte(res), &m)
if err != nil {
        panic(err)
}

fmt.Printf("%+v\n", m.Data[2].Synonym)