网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

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

2020-06-10 02:58:44 admin 488

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. 左边变量有没有定义的标准是在当前名字域范围内，即当前语句块，或者当前函数；而不管是否在外层名字域范围内已经定义。

转载文章，原文链接： go语言的变量声明并赋值运算符(:=)

关键字词go 运算符

分享到：

上一篇：go语言得到子程序的返回值

下一篇：golang读取外部命令的屏幕输出

如需留言，请登录，没有账号？请注册

0 条评论 0 人参与

网站首页 返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

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

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

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

zhou 2年前

zhou 2年前

zhou 2年前

zhou 2年前

武云 2年前

网站首页返回列表像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。