Go习惯用法(多值赋值短变量声明赋值简写模式)基础实例

package main 
import "fmt"
func main() {
    var x, y int  // 相同类型变量可以在末尾带上类型
    var a, b int = 1, 2
    var c, d = 3, 4 // 不带类型时，编译器自动推断
    var (  // 不同类型变量声明和隐式初始化
        e int
        f string
        )
    var g int, e int = 6, 7  // 多赋值语句中每个变量后面不能都带上类型
    fmt.Println("x ", x)
    fmt.Println("y ", y)
    fmt.Println("a ", a)
    fmt.Println("b ", b)
    fmt.Println("c ", c)
    fmt.Println("d ", d)
    fmt.Println("e ", e)
    fmt.Println("f ", f)
}

package main 

import "fmt"

func main() {
    var a int = 0
    var b int = 0
    a, b := 1, 2
    fmt.Println("a ", a)
    fmt.Println("b ", b)
}

a, err := f()
if err ! = nil {
    // do something
}
// 此时 err 可以是已存在的 err 变量，只是重新赋值了
b, err := g()

// 推荐写法
import (
    "os"
    "fmt"
)
// 不推荐写法
import "os"
import "fmt"

// 推荐写法
var (
    uploadStatus bool
    downStatus bool
)
// 不推荐写法
var uploadStatus bool
var uploadStatus bool

buffer.go:107: func (b *Buffer) tryGrowByReslice(n int) (int, bool) {
buffer.go:335: func (b *Buffer) ReadByte() (byte , error) {

m := make(map[string] string)
v, ok := m["camera"]
if ok {
    Println("camera exist")
} else {
    Println("camera not exist")
}

c := make(chan int)
go func() {
    c <- 1
    c <- 2
    close(c)
}()
for {
    v, ok := <- c
    if ok {
        Println("v exist")
    } else {
        Println("v not exist")
    }
}
for v := range c {
    Println(v)
}

v, ok = m[key]             // map lookup
v, ok = x.(T)              // type assertion
v, ok = <-ch               // channel receive

v = m[key]                // map查找，失败时返回零值
v = x.(T)                 // type断言，失败时panic异常
v = <-ch                  // 管道接收，失败时返回零值（阻塞不算是失败）
_, ok = m[key]            // map返回2个值
_, ok = mm[""], false     // map返回1个值
_ = mm[""]                // map返回1个值

_, err = io.Copy(dst, src) // 丢弃字节数
_, ok = x.(T)              // 只检测类型，忽略具体值

package main
import "fmt"
func main() {
    var x, y int = 3, 5
    fmt.Printf("befor swap x is %d\n", x)
    fmt.Printf("befor swapy is %d\n", y)
    x, y = swap_value(x, y)
    fmt.Printf("after swap x is %d\n", x)
    fmt.Printf("after swap y is %d\n", y)
    x, y = swap_reference(&x, &y)
    fmt.Printf("after swap_reference x is %d\n", x)
    fmt.Printf("after swap_reference y is %d\n", y)
}
func swap_value(x int, y int) (int, int) {
    var tmp int
    tmp = x
    x = y
    y = tmp
    return x, y
}
func swap_reference(x *int, y *int) (int, int) {
    var tmp int
    tmp = *x
    *x = *y
    *y = tmp
    return *x, *y
}