在短变量声明中重新声明来自不同块的变量 [英] Redeclare a variable from a different block in a short variable declaration

问题描述

  func f（）（err os）
如何在短变量声明中重新声明变量.Error）{
 proc，err：= os.StartProcess（blah blah blah）
 //新的err屏蔽了返回值？ 
} 
  

有一个关于这个的长线程，以及 issue ，但我很感兴趣的是暂时解决这个问题。

解决方案

短变量声明的Go规范很明确：
$ b

一个简短的变量声明可能是
的redeclare变量，假设它们是最初在同一块中声明的

是相同的类型，并且至少有一个
的非空白变量是新的。

因此，在短变量声明，你不能重新声明原来在不同块中声明的变量。

下面是ho w通过在内部块中声明一个局部变量（ e ）并分配它（ e ）来解决这个限制。添加到在外部块中声明的变量（ err2 ）。

  package （
fmt
os
）
 
 func f（）（err1 os.Error，err2 os .Error）{
 fi，err1：= os.Stat（== err1 os.Error ==）
 _ = fi 
 {
 fi，e：= os .Stat（== e os.Error ==）
 _ = fi 
 err2 = e 
} 
返回
} 
 
 func main（）{
 err1，err2：= f（）
 fmt.Println（f（）err1：，err1）
 fmt.Println（f（）err2： ，err2）
} 
  

输出：

  f（）err1：stat == err1 os.Error ==：no such file or directory 
f（）err2：stat == e os.Error = =：没有这样的文件或目录
  

这里是前面的示例重写为使用显式的变量声明并命名为函数参数，而不是隐式的短变量声明。变量声明总是可以显式编写为常规变量声明或命名函数参数;隐式短变量声明只是常规变量声明的缩写。

  package main 
 
 import（
fmt
os
）
 
 func f（）（err1 os.Error，err2 os.Error）{
 var fi * os .FileInfo 
 fi，err1 = os.Stat（== err1 os.Error ==）
 _ = fi 
 {
 var fi * os.FileInfo 
 fi，err2 = os.Stat（== err2 os.Error ==）
 _ = fi 
} 
 return 
} 
 
 func main（）{
 err1，err2：= f（）
 fmt.Println（f（）err1：，err1）
 fmt.Println（f（）err2： ，err2）
} 
  

输出：

  f（）err1：stat == err1 os.Error ==：没有这样的文件或目录
f（）err2：stat == err2 os.Error == ：没有这样的文件或目录
  

在你的例子中， err 重新声明 err 的返回参数声明;他们在同一个街区。因此，新的 err 不会掩盖返回参数 err 。

How can I redeclare a variable from a different block in a short variable declaration?

func f() (err os.Error) {
    proc, err := os.StartProcess(blah blah blah)
    // the new err masks the return value?
}

There's a long thread about this, and an issue, but I'm interested in how to work around this for the time being.

解决方案

The Go specification for short variable declarations is clear:

a short variable declaration may redeclare variables provided they were originally declared in the same block with the same type, and at least one of the non-blank variables is new.

Therefore, in a short variable declaration, you can't redeclare variables originally declared in a different block.

Here's an example of how to get around this restriction by declaring a local variable (e) in the inner block and assigning it (e) to a variable (err2) declared in an outer block.

package main

import (
    "fmt"
    "os"
)

func f() (err1 os.Error, err2 os.Error) {
    fi, err1 := os.Stat("== err1 os.Error ==")
    _ = fi
    {
        fi, e := os.Stat("== e os.Error ==")
        _ = fi
        err2 = e
    }
    return
}

func main() {
    err1, err2 := f()
    fmt.Println("f() err1:", err1)
    fmt.Println("f() err2:", err2)
}

Output:

f() err1: stat == err1 os.Error ==: no such file or directory
f() err2: stat == e os.Error ==: no such file or directory

Here's the previous example rewritten to use explicit regular variable declarations and named function parameters rather than implicit short variable declarations. Variable declarations can always be written explicitly as regular variable declarations or named function parameters; implicit short variable declarations are merely a shorthand for regular variable declarations.

package main

import (
    "fmt"
    "os"
)

func f() (err1 os.Error, err2 os.Error) {
    var fi *os.FileInfo
    fi, err1 = os.Stat("== err1 os.Error ==")
    _ = fi
    {
        var fi *os.FileInfo
        fi, err2 = os.Stat("== err2 os.Error ==")
        _ = fi
    }
    return
}

func main() {
    err1, err2 := f()
    fmt.Println("f() err1:", err1)
    fmt.Println("f() err2:", err2)
}

Output:

f() err1: stat == err1 os.Error ==: no such file or directory
f() err2: stat == err2 os.Error ==: no such file or directory

In your example, the short variable declaration of err redeclares the return parameter declaration of err; they are in the same block. Therefore, the new err does not mask the return parameter err.

这篇关于在短变量声明中重新声明来自不同块的变量的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！