标签：生产   type   process   消费者   ica   遍历   元素   must   ks3   

go doc

(walk through) overview of go

.go源文件

// main.go
// 1. .go文件
// 2. utf8编码

package main //包名

import "fmt"   //导入扩展包

func main() {
    fmt.Println("hello")
}

$go run main.go
  
hello

变量

func main() {
    var x int
    var s = "hello" //函数内可省略var关键字
    fmt.Println(x, s)
}
//0 hello

//函数内可省略var关键字
func main() {
    x := 100
    fmt.Println(x)
}
//100

表达式

go有3种流程控制语句

• if

func main() {
    x := -1
    if x > 0 {
        fmt.Println("x")
    } else if x < 0 {
        fmt.Println("-x")
    } else {
        fmt.Println("0")
    }
}

//-x

• switch

func main() {
    x := 0
    switch {
    case x > 0:
        fmt.Println("x")
    case x < 0:
        fmt.Println("-x")
    default:
        fmt.Println(0)
    }
}

//0

func main() {
    for i := 0; i < 5; i++ {
        switch i {
        case 0, 2: //任意命中1个即可
            fmt.Println("even")
            //命中这个分支后， 不需要写break，会被自动break
        case 1, 3:
            fmt.Println("odd")
        default:
            fmt.Println("it is not 0-3")
        }
    }
}

//even
//odd
//even
//odd
//it is not 0-3

• for

//正常的for循环
func main() {
    for i:=0;i<5 ;i++  {
        fmt.Println(i)
    }
}
//0
//1
//2
//3
//4

//相当于while
func main() {
    i := 0
    for i < 5 {
        fmt.Println(i)
        i++
    }
}

//0
//1
//2
//3
//4

//死循环
for{
    
}

// for range遍历返回索引
func main(){
    arr:=[]int{1,2,3}
    for k,v := range arr {
        fmt.Println(k,v)
    }
}

函数

//函数可返回多个值
func div(a int, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("b is 0")
    }
    return a / b, nil
}

func main() {
    res,err:=div(10,0)
    fmt.Println(res,err)
}

//函数是第一类型, 可作为参数或返回值(也可以赋值)
func test(x int) func() {
    return func() {
        println(x)
    }
}

//defer定义延迟调用, 无论函数是否panic,结束时都被执行
func div(x, y int) {
    defer println("div end...")
    fmt.Println(x / y)
}

func main() {
    div(10, 0)
}

//div end...
//panic: runtime error: integer divide by zero

数据

//切片 - 类似动态数组
func main() {
    arr := make([]int, 0, 2)
    for i := 0; i < 5; i++ {
        arr = append(arr, i) //当容量不够时自动重新分配空间扩容
    }
    fmt.Println(arr)
}

//map
func main() {
    m := make(map[string]int)
    m["a"] = 1         //增加/更新元素
    ok, v := m["a"]    //判断是否存在
    fmt.Println(ok, v) //判断存在:1 true
    delete(m, "a")     //删除元素
}

方法

type user struct {
    name string
    age  int
}

type manager struct {
    user
    title string
}

func main() {
    var m manager
    m.name = "mm"
    m.age = 22
    m.title = "CTO"
    fmt.Println(m)
}

//{{mm 22} CTO}

//可以调用父类方法, 实现类似继承的功能
type user struct {
    name string
    age  int
}

func (u *user) toString() string {
    return fmt.Sprintf("%v", u)
}

type manager struct {
    user
    title string
}

func main() {
    var m manager
    m.name = "mm"
    m.age = 22
    m.title = "CTO"
    fmt.Println(m.toString())
}

//&{mm 22}

//可以为任意类型绑定方法

type X int

func (x *X) incr() {
    *x++
}
func main() {
    var x X
    x = 1
    x.incr()
    x.incr()
    fmt.Println(x)
}

//3

接口

type user struct {
    name string
    age  int
}

func (u user) Say() {
    fmt.Printf("%v", u)
}

type people interface {
    Say()
}

func main() {
    var u user
    u.name = "mm"
    u.age = 22

    var p people
    p = u
    p.Say()
}

//空接口可以接受任意类型的值

func test(x interface{}){
    fmt.Println(x)
}

func main() {
    test(10)
    test("mm")
}

并发

整个runtime并发设计, 几乎所有的进程都是以goroutine方式运行
channel与goroutine搭配, 实现通信,替代传统的通过共享内存通信的csp(Communicating Sequential Processes)模型,

// 消费者 
func consumer(data chan int, done chan bool) {
    for x := range data { // 接收数据，直到通道被关闭 
        println("recv:", x)
    }

    done <- true // 通知main，消费结束 
}

// 生产者 
func producer(data chan int) {
    for i := 0; i < 4; i++ {
        data <- i // 发送数据 
    }

    close(data) // 生产结束，关闭通道 
}

func main() {
    done := make(chan bool) // 用于接收消费结束信号 
    data := make(chan int)  // 数据管道 

    go consumer(data, done) // 启动消费者 
    go producer(data)       // 启动生产者 

    <-done // 阻塞，直到消费者发回结束信号 
}

main函数

• 每个程序只能又一个main函数,程序入口
• main函数不支持return, 使用os.Exit返回状态

//main不支持参数，传参使用os.Args
func main() {
    fmt.Println(os.Args)
}

//$: go run main.go 1 2 3
//[/var/folders/4g/nfky9hks3j39qhvz741tmcn40000gn/T/go-build150967295/b001/exe/main 1 2 3]

//main函数不支持返回值

func main() int{
    return 10
}
//$: go run main.go
//# command-line-arguments
//./main.go:3:6: func main must have no arguments and no return values

//main函数返回状态值的方法: os.Exit
func main() {
    fmt.Println("hello")
    os.Exit(-1)
}
//$: go run main.go
//hello
//exit status 255

[go]a tutor of go语法

标签：生产   type   process   消费者   ica   遍历   元素   must   ks3   

原文地址：https://www.cnblogs.com/iiiiiher/p/12255110.html