Golang基础知识小抄

go env

go env -w 变量名=变量值

go env -w GOPROXY=https://goproxy.cn,direct #其中https://goproxy.cn是国内镜像服务器地址

var a int
var s string

a, b := 1, 2 

const(
    english = 0
    math = 1
    chinese = 2
)

func branchIf1() {
    filename := "data/test.txt"

    if text, err := ioutil.ReadFile(filename); err == nil { // if的条件前可以接赋值语句
        fmt.Printf("%s \n", text)

    } else {
        // fmt.Println("Error occurred!", err)
        panic(err) //程序主动调用panic，立即返回函数
    }
}

//case后不需要接break，默认匹配到一个case执行完即会退出switch，不像c++还会往下匹配其它case
func branchSwitch1(variable int) {
    switch {
    case variable > 50:
        fmt.Println("variable>50")
    case variable > 10:
        fmt.Println("variable > 10")
    default:
        fmt.Println("variable <= 10")
    }
}

// 使用 fallthrough 会强制执行后面的 case 语句，fallthrough 不会判断下一条 case 的表达式结果是否为 true。
func branchSwitch2(variable int) {
    switch {
    case variable > 50:
        fmt.Println("variable > 50")
        fallthrough  //匹配到variable > 50后还会执行下一个条件variable < 50对应的代码块
    case variable < 50:
        fmt.Println("fallthrough variable < 50")
    default:
        fmt.Println("variable <= 10")
    }
}

for init; condition; post { }

//将十进制数转为二进制
func convert2bin(n int) string {
    var result string
    for ; n > 0; n /= 2 {
        tmp := n % 2
        result = strconv.Itoa(tmp) + result //strconv.Itoa(tmp)把int类型变量转换成string
    }
    return result
}

for {
    fmt.Println("Forever")
}

//可以在定义函数返回值类型的同时定义返回值的变量
func div2(a, b int) (q int, r int) {
    q = a / b
    r = a % b
    return q, r
}

//一般函数返回值会包含一个error类型的变量，用来告知调用者函数执行是否发生错误
func eval2(a, b int, op string) (int, error) {
    switch op {
    case "+":
        return a + b, nil
    case "-":
        return a - b, nil
    case "*":
        return a * b, nil
    case "/":
        q, _ := div1(a, b) //如果不想用第二个返回值，通过_接收想要忽略的返回值
        return q, nil
    default:
        return 0, fmt.Errorf("Error: Unsupported Operators")

    }
}

//回调函数,函数本身也可以作为函数的参数
func apply(op func(a, b int) int, a, b int) int {
    return op(a, b)
}y也可以名函数

    //匿名函数
    fmt.Println(apply(func(a, b int) int {
        return a + b
    }, 2, 10))

//可变参数列表,numbers可以当作数组
func sum(numbers ...int) (result int) {
    for _, x := range numbers {
        result += x
    }
    return result

}

    //声明数组
    var arr1 [4]int//如果只声明不初始化，则默认认为每个元素取0
    arr2 := [3]int{4, 3, 2}            //通过:=声明数组的话需要初始化
    arr3 := [...]int{4, 2, 4, 2, 1, 6} //编译器
    var grid [4][5]int                 //二维数组：4行5列，4个长度为5的一维数组构成的数组
    fmt.Println(arr1, arr2, arr3, grid)

    //遍历数组,go风格，使用range关键字
    for i, v := range arr3 {
        fmt.Println(i, v)
    }
    //传统风格 C风格
    for i := 0; i < len(arr3); i += 1 {
        fmt.Println(i, arr3[i])
    }
}

func printArray(arr [5]int) {
    arr[0] = 999
    fmt.Println("数组", arr)
}

func printArray1(arr *[5]int) {
    arr[0] = 999
    fmt.Println("数组", arr)
}    //数组类型：值类型，作为参数传递给函数时会进行拷贝
func main(){
    printArray(arr3)
    printArray(arr1)
    fmt.Println(arr3, arr1) //printArray中改变数组的值不影响原来的arr1、arr3的值
    // printArray(arr2) //会报错，[3]int和[5]int是不同的类型

    printArray1(&arr3)
    printArray1(&arr1)
    fmt.Println(arr3, arr1) //arr3、arr1的第一个元素发生了改变
}

/**输出
数组 [999 2 2 1 6]
数组 [999 0 0 0 0]
[4 2 2 1 6] [0 0 0 0 0]
数组 &[999 2 2 1 6]
数组 &[999 0 0 0 0]
[999 2 2 1 6] [999 0 0 0 0]
**/

    //定义Map
    m := map[string]string{
        "GCN":  "图卷积网络",
        "GAT":  "图注意力网络",
        "AGCN": "自适应图卷积网络",
        "HGCN": "双曲图卷积网络",
    }
    m2 := make(map[string]int) //empty map
    var m3 map[string]int      //nil

(base) ➜  testproject git:(master) ✗ go run zaptest.go
zaptest.go:3:8: cannot find package "go.uber.orag/zap" in any of:
        /usr/local/Cellar/go/1.15.3/libexec/src/go.uber.orag/zap (from $GOROOT)
        /Users/zhuge/Projects/Go-Project/tmp/gopathtest/src/go.uber.orag/zap (from $GOPATH)

go build ./... #编译当前目录及子目录下的go文件，不生成可执行文件，全部编译通过则无输出

go install ./... # 编译并生成可执行文件，默认可执行文件存放在$GOPATH/bin

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }

    dst, err := os.Create(dstName)
    if err != nil {
        return
    }

    written, err = io.Copy(dst, src)
    dst.Close()
    src.Close()
    return
}

func CopyFile(dstName, srcName string) (written int64, err error) {
    src, err := os.Open(srcName)
    if err != nil {
        return
    }
    defer src.Close()

    dst, err := os.Create(dstName)
    if err != nil {
        return
    }
    defer dst.Close()

    return io.Copy(dst, src)
}

func writeFile(filename string) {
    // file, err := os.Create(filename)
    file, err := os.OpenFile(filename, os.O_EXCL|os.O_CREATE, 0666)

    if err != nil {
        //类型断言,判断err的错误类型,如果错误类型不是*os.PathError则panic，否则输出错误详细信息
        if pathError, ok := err.(*os.PathError); !ok {
            panic(err)
        } else {
            fmt.Printf("%s, %s, %s \n", pathError.Op, pathError.Path, pathError.Err)
        }
        return
    }
    defer file.Close()
    fibWriter := bufio.NewWriter(file) //使用缓冲区，先让程序将内容写到内存中，到一定阈值再统一写入硬盘，提高文件写入效率
    defer fibWriter.Flush()            //将缓冲区的内容强制写入硬盘
    f := fib()
    for i := 0; i < 30; i += 1 {
        fmt.Fprintln(fibWriter, f())
    }
}

{
    // Use IntelliSense to learn about possible attributes.
    // Hover to view descriptions of existing attributes.
    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Launch Package",
            "type": "go",
            "request": "launch",
            "mode": "auto",
            "program": "${fileDirname}"
        }
    ]
}

go test . #运行当前目录下的测试文件

go test --coverprofile=c.out #启动测试的同时检测代码覆盖率

go tool cover -html=c.out -o coverage.html # 根据c.out生成代码覆盖率报表(coverage.html)

//性能测试
func BenchmarkSubStr(b *testing.B) {
    testStr := "军敌军还有五秒到达战场"
    ans := 10
    for i := 0; i < b.N; i++ {
        if actual := lengthOfLongestSubstring1(testStr); actual != ans {
            if actual := lengthOfLongestSubstring1(testStr); actual != ans {
                b.Errorf("Error occurred: lengthOfLongestSubstring1(%s): got %d, expected %d", testStr, actual, ans)
            }
        }

    }
}

go test -bench . # 运行当前目录下的Benchmark函数

go get golang.org/x/tools/cmd/godoc

godoc -http :6060 #生成文档， 可通过本地服务器查看文档

//queue_test.go
package queue

import "fmt"

func ExampleQueue_Pop() {
    q := &Queue{1}
    q.Push(2)
    fmt.Println(q.Pop())
    fmt.Println(q.Pop())
    //Output:
    //1
    //2
}

package main

import (
    "fmt"
    "time"
)

func main() {
    var a [10]int
    for i := 0; i < 10; i++ {
        go func() { //race condition
            for {
                a[i]++ //使用匿名函数外的i，不安全的行为，因为i对于数组而言可能越界，
//可以在go run命令后加上参数-race检查竞态
                // runtime.Gosched() 

            }
        }()//不传参数

    }
    time.Sleep(time.Minute)
    fmt.Println(a)
}

package main

import (
    "fmt"
)
func main() {
    for i := 0; i < 10; i++ {
        go func(ii int) {
            for {
                fmt.Printf("Goroutine from %d\n", ii)
            }
        }(i)
        time.Sleep(time.Millisecond)
    }
}

package main

import (
    "fmt"
    "time"
)

func main() {
    var a [10]int
    for i := 0; i < 10; i++ {
        go func(ii int) {
            for {
                // fmt.Printf("Goroutine from %d\n", ii)//打印语句会进行协程调度，当前协程会交出控制权
                a[ii]++
                // runtime.Gosched() //协程主动交出控制权

            }
        }(i)

    }
    time.Sleep(time.Millisecond)
    fmt.Println(a)
}

go run -race ... #检测数据访问冲突

package main

import (
    "fmt"
    "time"
)

//=========带缓冲的通道=============
func bufferedChannel2() {
    var channels [10]chan<- int //第二个参数为缓冲区大小/容量，可用于提升性能
    for i := 0; i < 10; i++ {
        channels[i] = createWorker(i)

    }
    for i := 0; i < 10; i++ {
        channels[i] <- i + 'a'
    }
    for i := 0; i < 10; i++ {
        channels[i] <- i + 'A'
    }
    //time.Sleep(time.Millisecond)
}
func createWorker(id int) chan<- int {
    c := make(chan int)
    go worker(id, c)
    return c
}

func worker(id int, c chan int) {
    for {
        fmt.Printf("Worker-----(id, message): (%d, %c)\n", id, <-c)
    }
}

func main() {
    // testChan5()
    bufferedChannel2()
}

func bufferedChannel3() {
    var workers [10]worker
    for i := 0; i < 10; i++ {
        workers[i] = createWorker3(i)

    }
    for i := 0; i < 10; i++ {
        workers[i].channel <- i + 'a'
    }
    for i := 0; i < 10; i++ {
        workers[i].channel <- i + 'A'
    }
    for i := 0; i < 10; i++ {
        <-workers[i].done
    }

    for i := 0; i < 10; i++ {
        <-workers[i].done
    }
}
func createWorker3(id int) worker {
    w := worker{
        channel: make(chan int),
        done:    make(chan bool),
    }
    go doWorker3(id, w)
    return w
}

func doWorker3(id int, w worker) {
    for {
        fmt.Printf("Worker-----(id, message): (%d, %c)\n", id, <-w.channel)
        go func() {
            w.done <- true //这里可以进一步封装
        }()
    }
}

//=====bufferedChannel4
type worker4 struct {
    channel chan int
    done    func()
}

//======wait group=======
func bufferedChannel4() {
    var workers [10]worker4
    var wg sync.WaitGroup

    for i := 0; i < 10; i++ {
        workers[i] = createWorker4(i, &wg)

    }
    wg.Add(20)
    for i := 0; i < 10; i++ {
        workers[i].channel <- i + 'a'
    }
    for i := 0; i < 10; i++ {
        workers[i].channel <- i + 'A'
    }
    wg.Wait() // 一直阻塞到WaitGroup 计数器为0

}
func createWorker4(id int, wg *sync.WaitGroup) worker4 {
    w := worker4{
        channel: make(chan int),
        done: func() {
            wg.Done() //通知WaitGroup计数器，当前子协程已完成->计数器-1
        },
    }
    go doWorker4(id, w)
    return w
}

func doWorker4(id int, w worker4) {
    for {
        fmt.Printf("Worker-----(id, message): (%d, %c)\n", id, <-w.channel)
        w.done()
    }

for{
    data, ok := <- c1
    data, ok := <- c2
    //……
}

select{
    case n := <-c1
        //received data from c1
    case n := <-c2
         //received data from c2
}

go doc -http :8888

//需要注意首字母大小写，决定着字段能否被外部包（包括json.Marsgal)访问
type Order struct { //为结构体打上json tag，tag会被json.Marshal看到
    ID         string       `json:"id"`
    Item       *[]OrderItem `json:"item"`
    Quantity   int          `json:"quantity"`
    TotalPrice string       `json:"total_price"`
}


type OrderItem struct {
    ID    string  `json:"id"`
    Name  string  `json:"name"`
    Price float64 `json:"price"`
}

package main

import (
    "encoding/json"
    "fmt"
)func main(){
    o := Order{
        ID: "no1",
        Item: &[]OrderItem{
            {
                Name:  "book",
                Price: 4.2,
            }, {
                Name:  "course",
                Price: 94.2,
            },
        },
        Quantity: 2,
    }
    fmt.Printf("%+v\n", o)    //%+v 打印结构体
    b, err := json.Marshal(o) //将结构体序列化成可以在网络上传输的字节。（e.g.json格式)
    if err != nil {
        panic(err)
    }
    fmt.Printf("%s\n", b)
}

// Output:
//{"id":"no1","item":{"id":"","name":"book","price":4.2},"quantity":2,"total_price":""}