go语言的变量声明并赋值运算符(:=)

基本功能

声明并且赋值一个变量，其好处是不需要写var三个字母，另外不需要写类型，go语言会自动根据赋值的内容确定类型(但是这一点我不觉得是优点，因为就不知道变量的类型是什么了)。

格式:
var := value

使用限制
不能在函数外面使用，即不能用来声明全局变量。

== 例子 1

$ cat main.c
package main

import "fmt"

func main() {
    a := 100
    fmt.Printf("&a=%p\n", &a);
}

$ go build && main
&a=0xc42000e260

声明并赋值变量a

== 例子 2

$ cat main.c
package main

import "fmt"

func main() {
    var a int = 100
    fmt.Printf("&a=%p\n", &a);
    a := 100
    fmt.Printf("&a=%p\n", &a);
}

$ go build && main
# main
./main.go:8: no new variables on left side of :=

第8行声明并赋值变量a失败，因为变量a已经在第6行声明过了。

== 例子 3

$ cat main.c
package main

import "fmt"

var a int = 100

func main() {
    fmt.Printf("&a=%p\n", &a);
    a := 100 
    fmt.Printf("&a=%p\n", &a);
}

$ go build && main
&a=0x4f8018
&a=0xc42000e268

虽然在第5行有声明了一个全局变量a，在第9行依然可以声明并赋值变量a，此时的a和全部变量a不是一个变量，打出来的地址不相同。

== 例子 4

$ cat main.c
package main

import "fmt"

func main() {
    a := 100 
    fmt.Printf("&a=%p\n", &a);
    {
        a := 100 
        fmt.Printf("&a=%p\n", &a);
    }
}

$ go build && main
&a=0xc420058168
&a=0xc420058198

第6行声明并赋值了一个函数变量a，在第9行声明并赋值了一个块变量a，他们是两个不同的变量。

总结v:=value的用法

1. go在当前名字域范围内搜索变量v
   • 如果已经找到v那么报错：no new variables on left side of :=
   • 如果没有找到，那么在当前名字域范围内定义变量v
2. go并不在当前名字域的外层来搜搜变量
   • 如果是直接的引用或者赋值除外，e.g., v=value, or w=v
3. 当前名字域包括函数域，或者块域

多变量的声明赋值

== 例子1

$ cat main.c
package main

import "fmt"

func foo() (int, int) {
    return 100, 200
}

func main() {
    a, b := foo()
    fmt.Printf("&a=%p, &b=%p\n", &a, &b);
}

$ go build && main
&a=0xc420058168, &b=0xc420058190

同时声明并赋值两个变量。

== 例子 2

$ cat main.c
package main

import "fmt"

func foo() (int, int) {
    return 100, 200
}

func main() {
    var a int = 0;
    fmt.Printf("&a=%p\n", &a);
    a, b := foo()
    fmt.Printf("&a=%p, &b=%p\n", &a, &b);
}

$ go build && main
&a=0xc42000e260
&a=0xc42000e260, &b=0xc42000e280

第10行已经声明了变量a，第12行就不在重新定义变量a，只定义了变量b；可以看到两个a打印出来的是同一个。

== 例子 3

$ cat main.c
package main

import "fmt"

func foo() (int, int) {
    return 100, 200
}

func main() {
    var a int = 0;
    var b int = 0;
    fmt.Printf("&a=%p\n", &a);
    a, b := foo()
    fmt.Printf("&a=%p, &b=%p\n", &a, &b);
}

$ go build && main
# simple
./main.go:13: no new variables on left side of :=

第13行声明的变量a和b在前面均已经声明过，没有新的变量。

总结多声明赋值v1,v2,v3,:=value1,value2,value3,操作的用法

1. 对多变量的赋值至少有一个是新变量。
   • 对新变量在当前名字域创建变量
   • 对老变量则使用已经存在的老变量，注意老变量也必须是在当前名字域内的老变量，不含外层变量。

package main

import "fmt"

func foo() (int, int) {
    return 100, 200
}

var b int = 0;
func main() {
    var a int = 0;
    fmt.Printf("&a=%p, &b=%p\n", &a, &b);
    a, b := foo()
    fmt.Printf("&a=%p, &b=%p\n", &a, &b);
}

$ go build && main
&a=0xc42006a018, &b=0x516b98
&a=0xc42006a018, &b=0xc42006a048

第11行声明了变量a，在第13行声明变量a和b的时候，因为a在第11行已经声明过了，所以这里不再定义新的变量a，而变量b虽然在第9行声明了全局变量，但是根据声明并赋值运算符(:=)的规则，在此并不会检测全局变量区，而只在当前名字域(即函数main)范围内查找b，结果是没有定义，所以在此会定义一个新变量b，这个变量b和全局变量b不是同一个变量。

结论

1. 声明并赋值运算符(:=)左边至少得有一个变量是没有定义的。
2. 左边变量有没有定义的标准是在当前名字域范围内，即当前语句块，或者当前函数；而不管是否在外层名字域范围内已经定义。