Question

我开始工作几周了，而且（再一次）我偶然发现了一些对我来说很奇怪的事情：

// Not working
a := 1
{
    a, b := 2, 3
}

// Works
a := 1
a, b := 2, 3

ReadFdf.java

我想同时分配两个变量。一个已经宣布，在一个优越的范围，另一个不是。

它不起作用：编译器尝试重新声明前一个变量。但是，如果在同一范围内声明此变量，则它可以正常工作。

为什么？

Answer 1

您遇到的情况通常称为"variable shadowing"。当:=与内部作用域中的任何变量一起使用时，包括if和for等语句，尽管缺少大括号，新的值和类型与该变量相关联：

n := "Example"
//Prints the string variable `n` to standard output and
// returns the number of bytes written in int variable `n` and
// an error indicator in error variable `err`.
if n, err := fmt.Println(n); err != nil {
    panic(err)
} else {
    fmt.Println(n, "bytes written")
}

//Prints the string variable `n` to standard output.
fmt.Printf("n = %q\n", n)

输出：

Example
8 bytes written
n = "Example"

有几种不同的方法可以解决这个问题：

在使用之前声明您需要的变量，并使用=
使用不同的变量名称
创建一个新范围并保存变量的值以供以后访问，根据需要使用变量名称:=，并在范围结束之前恢复该值;因为你正在创建另一个变量

相反的效果也会发生，你在内部范围内声明某些东西并且没有意识到：

if _, err := fmt.Println(n); err != nil {
    panic(err)
} else {
    fmt.Println(n, "bytes written")
}

//undefined: err
if _, err = fmt.Println(n); err != nil {
    //undefined: err
    panic(err)
}

还有一些不同的方法可以解决这个问题：

在使用之前声明您需要的变量，并使用=
分隔第一个:=和if语句，因此变量声明为预期;这允许您在该范围的上下文中使用=来表示该变量的所有其他实例以及它所包含的任何范围
将=的所有实例更改为:=以修复错误

请注意，当函数返回多个值时，您可能会在最后两种情况下遇到变量阴影问题，但可以按照上面的说明解决。

Try both examples on the Go Playground.

您的上一个示例说明了声明和初始化新变量b的组合，同时还为现有变量a分配了值。没有创建新范围，因此您不会隐藏原始变量a，您可以verify by printing the address of a after each assignment (but before the next declaration/assignment)：

a := 1
fmt.Println(&a)
a, b := 2, 3
fmt.Println(&a)
a = b          // avoids a "declared but not used" error for `b`

当然，如果您没有声明b，那么您将收到编译器的错误，即:=左侧没有新变量用于第二个声明，是一种迂回的方式，说你试图在同一范围内宣布a两次。

请注意，如果仔细应用，这个想法也可用于查找被遮蔽的变量。例如，示例中的“不工作”代码为print different addresses for a，具体取决于内部范围内的a是否已声明：

a := 1
{
    fmt.Println(&a)    // original `a`
    a, b := 2, 3
    fmt.Println(&a)    // new `a`
    a = b              // avoids a "declared but not used" error for `b`
}
fmt.Println(&a)        // original `a`

Answer 2

根据 golang the documentation：

块中声明的标识符可以在内部块中重新声明。

这正是您的示例所显示的内容，a在括号内重新声明，因为'：='，并且从未使用过。

解决方案是声明两个变量然后使用它：

var a, b int
{
    b, a = 2, 3
    fmt.Println(b)
}
fmt.Println(a)

Answer 3

你的问题有两个部分：
第一部分：
=只是作业：=是为函数块（非全局）中的新变量（至少一个新变量）定义和赋值，工作样本：

package main

import (
    "fmt"
)

func main() {
    var u1 uint32      //declare a variable and init with 0
    u1 = 32            //assign its value
    var u2 uint32 = 32 //declare a variable and assign its value at once
    //declare a new variable with defining data type:
    u3 := uint32(32)        //inside the function block this is equal to: var u3 uint32 = 32
    fmt.Println(u1, u2, u3) //32 32 32
    //u3 := 20//err: no new variables on left side of :=
    u3 = 20
    fmt.Println(u1, u2, u3)       //32 32 20
    u3, str4 := 100, "str"        // at least one new var
    fmt.Println(u1, u2, u3, str4) //32 32 100 str
}

第二部分：
块中声明的标识符可以在内部块中重新声明这里有4个不同的工作样本用于变量范围和阴影：

限制变量范围的简单方法：

package main
import "fmt"
func main() {
    i := 1
    j := 2
    //new scope :
    {
        i := "hi" //new local var
        j++
        fmt.Println(i, j) //hi 3
    }
    fmt.Println(i, j) //1 3
}

使用函数调用限制变量范围：

package main
import "fmt"
func fun(i int, j *int) {
    i++                //+nice: use as local var without side effect
    *j++               //+nice: intentionally use as global var
    fmt.Println(i, *j) //11 21
}
func main() {
    i := 10 //scope: main
    j := 20
    fun(i, &j)
    fmt.Println(i, j) //10 21
}

在声明中使用短手赋值：

package main
import "fmt"
func main() {
    i := 10 //scope: main
    j := 4
    for i := 'a'; i < 'b'; i++ {
        fmt.Println(i, j) //97 4
    }
    fmt.Println(i, j) //10 4

    if i := "test"; len(i) == j {
        fmt.Println(i, j) // i= test , j= 4
    } else {
        fmt.Println(i, j) //test 40
    }
    fmt.Println(i, j) //10 4
}

影响全球变种：

package main
import "fmt"
var i int = 1 //global
func main() {
    j := 2
    fmt.Println(i, j) //1 2
    i := 10           //Shadowing global var
    fmt.Println(i, j) //10 2
    fun(i, j)         //10 2
}
func fun(i, j int) {
    //i := 100   //no new variables on left side of :=
    fmt.Println(i, j) //10 2
}

Answer 4

简而言之：由于a, b = 2, 3的意思是“同时分配”和a, b := 2, 3的意思是“同时声明并分配”，因此您需要分配一个并声明并分配另一个，解决方案是声明其他，并同时分配两者：

a := 1
{
    var b int
    a, b = 2, 3
}

Golang混合分配和声明

4 个答案: