• 基础
• 函数 指针 结构体 接口
• 错误
• 协程
• 通道

基础

$ go version
$ go run main.go
$ go build main.go # 编译二进制执行文件

package main
import (
    "fmt"
    "time"
)

func main() {
    fmt.Println("hello world.")
    // for 循环
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
    // if 判断
    score := 30
    if score >= 30 {
        fmt.Println("30")
    } else if score >= 20 {
        fmt.Println("20")
    } else {
        fmt.Println("other")
    }
    // switch 判断
    switch time.Now().Weekday() {
    case time.Saturday, time.Sunday:
        fmt.Println("周末")
    default:
        fmt.Println("上班")
    }
    t := time.Now()
    switch {
    case t.Hour() < 12:
        fmt.Println("上午")
    default:
        fmt.Println("下午")
    }

    // 一维数组
    b := [5]int{1, 2, 3, 4, 5}
    // 二维数组
    var c [2][3]int
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            c[i][j] = i + j
        }
    }
    // 创建空切片
    s := make([]string, 3)
    // 创建拷贝切片
    c := make([]string, len(s))
    copy(c, s)
    // map 哈希字典
    m := make(map[string]int)
    m["k1"] = 7
    m["k2"] = 13
    delete(m, "k2")
    // range 迭代
    nums := []int{2, 3, 4}
    sum := 0
    for _, num := range nums {
        sum += num
    }
    kvs := map[string]string{"a": "apple", "b": "banana", "c": "orange"}
    for k, v := range kvs {
        fmt.Printf("%s -> %s\n", k, v)
    }
    for i, c := range "iloveu" {
        fmt.Println(i, string(c))
    }
}

函数 指针 结构体 接口

package main
import (
    "fmt"
    "reflect"
)

// 返回多值
func calABCD(a, b int) (int, int, int, int) {
    return a+b, a-b, a*b, a/b
}
// 可变参数
func sum(nums ...int) int {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    return total
}

// 接收指向 int 的指针
func byPointer(iptr *int) {
    *iptr = 0
}

// 定义矩形结构体
type rect struct {
    width, height int
}
// 为 rect 结构体定义计算面积方法 area(), 参数为指针类型
func (r *rect) area() float64 {
    return r.width * r.height
}
// 为 rect 结构体定义计算周长方法 perim(), 参数为值类型
func (r rect) perim() float64 {
    return 2 * (r.width + r.height)
}

// 定义几何图形接口
type geometry interface {
    area() float64
    perim() float64
}
// 计算函数，参数为几何图形接口类型
func measure(g geometry) {
    fmt.Println(reflect.TypeOf(g), g)
    fmt.Println(g.area())
    fmt.Println(g.perim())
}

func main() {
    a, b, c, d := calABCD(200, 100)
    fmt.Println("ab四则计算=", a, b, c, d)
    result = sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    fmt.Println("1-10合计为=", result)

    i := 10
    byPointer(&i)
    fmt.Println("byptr:", i)
    fmt.Println("pointer:", &i)

    r := rect{width: 10, height: 4}
    fmt.Println("area: ", r.area())
    fmt.Println("perim:", r.perim())
    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())
    measure(r) // 用 measure 函数计算矩形面积和周长
}

错误

package main
import (
    "fmt"
    "errors"
)

// 错误结构体
type argError struct {
    arg int
    msg string
}
// 定义结构体的错误函数(实现错误接口)
func (e *argError) Error() string {
    return fmt.Sprintf("%d -> %s", e.arg, e.msg)
}

// 错误返回值的函数
func f1(num int) (int, error) {
    if num < 0 {
        return -1, errors.New("参数错误")
    }
    return 2 * num, nil
}
func f2(num int) (int, error) {
    if num < 0 {
        return -1, &argError{num, "参数不能为负值"}
    }
    return 2 * num, nil
}

func main() {
    // f1
    result, err := f1(10)
    fmt.Println(result, err)
    result, err = f1(-10)
    fmt.Println(result, err)
    // f2
    result, err = f2(10)
    fmt.Println(result, err)
    result, err = f2(-10)
    fmt.Println(result, err)
}

协程

package main
import (
    "os"
    "os/exec"
    "fmt"
    "time"
)

func sayHelo(name string) {
    for i := 1; i <= 5; i++ {
        fmt.Println("Helo", name, ":", i)
    }
}

func main() {
    cmd := exec.Command("clear")
    cmd.Stdout = os.Stdout
    cmd.Run()
    // 同步执行函数
    sayHelo("koma")
    // 异步执行函数
    go sayHelo("xiaoma")
    go sayHelo("iphone")
    go sayHelo("ipad")
    go sayHelo("swiftui")
    // 匿名函数，异步执行
    go func(msg string) {
        fmt.Println("this is a", msg)
    }("lesson")
    // 等待一秒
    time.Sleep(time.Second)
}

通道

package main
import (
    "fmt"
    "strconv"
)

func main() {
    // 定义字符型的通道
    message := make(chan string)
    go func() {
        for i := 1; i <= 3; i++ {
            message <- (strconv.Itoa(i) + ".helo channel.")
        }
    }()
    // 接收通道发送的消息
    result := ""
    result = <-message
    fmt.Println(result)
    result = <-message
    fmt.Println(result)
    result = <-message
    fmt.Println(result)

    // 循环接收通道内容
    message := make(chan string)
    go func() {
        for i := 1; i <= 5; i++ {
            if i == 5 {
                message <- ""
            } else {
                message <- (strconv.Itoa(i) + ".helo channel.")
            }
        }
    }()
    for result := range message {
        if result == "" {
            break
        } else {
            fmt.Println(result)
        }
    }

    // 建立有3个缓冲区的通道，即缓冲区消息达到3个时会阻塞当前线程
    message := make(chan string, 2) // 如果是2的话，系统会报错，因为线程阻塞死锁
    // 发送消息
    message <- "消息1"
    message <- "消息2"
    message <- "消息3"
    // 接收消息
    fmt.Println(<-message)
    fmt.Println(<-message)
    fmt.Println(<-message)
}