package main

import (
	"fmt"
	"io/ioutil"
	"log"
)

func main() {

	f, err := ioutil.TempFile("", "")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	if _, err := f.Write([]byte("Hello World\n")); err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("All success")
	}
}

請注意，我們首先從 TempFile 函數(shù)創(chuàng)建了兩個變量： f 和 err 。然后我們調用 Write 丟棄寫入的字節(jié)數(shù)。我們讓函數(shù)在 if 語句中調用它。讓我們編譯，它工作正常。

$ go run main.go
All success

現(xiàn)在，與 if 之外的 Write 調用相同的代碼：

package main

import (
	"fmt"
	"io/ioutil"
	"log"
)

func main() {

	f, err := ioutil.TempFile("", "")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	// if _, err := f.Write([]byte("Hello World\n")); err != nil {
	// 	log.Fatal(err)
	// } else {
	// 	fmt.Println("All success")
	// }

	_, err := f.Write([]byte("Hello World\n"))
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("All success")
	}
}

運行該代碼：

$ go run main.go
# command-line-arguments
./main.go:23:9: no new variables on left side of :=

所以發(fā)生了什么事？

請注意，我們使用 := 調用 Write ，這意味著我們創(chuàng)建了一個新變量 err 。在第二個例子中，很明顯， err 已經(jīng)存在，所以我們不能重新聲明它。

但是為什么它第一次起作用呢？因為在 Go 中，變量是其作用域的本地變量。在第一個示例中，我們實際上在 if 范圍內隱藏了 err 。

例如：

package main

func main() {
	var err error
	_ = err
	var err error
	_ = err
}

這顯然會失敗，但是，如果我們限定第二個 err ，它會起作用！

package main

func main() {
	var err error
	_ = err
	{
		var err error
		_ = err
	}
}

包隱藏

考慮以下代碼：

package main

import "fmt"

func Debugf(fmt string, args ...interface{}) {
	fmt.Printf(fmt, args...)
}

起初，它看起來不錯。我們從 fmt 包中調用 Printf 并將 fmt 變量傳遞給它。

函數(shù)聲明中的 fmt 字符串實際上隱藏了包，現(xiàn)在“只是”一個變量。編譯器會抱怨：我們需要使用不同的變量名來保存對 fmt 包的訪問。

全局變量

需要考慮的是，一個函數(shù)已經(jīng)是一個“子作用域”，它是全局作用域內的一個作用域。這意味著您在函數(shù)中聲明的任何變量都可以在全局范圍內隱藏某些內容。

正如我們之前看到的，變量可以映射包，全局變量和函數(shù)的概念是相同的。

類型強制

就像我們可以用變量或函數(shù)來映射一個包一樣，我們也可以用任何類型的新變量來映射一個變量。陰影變量不需要來自同一類型。這個例子編譯得很好：

package main

func main() {
	var a string
	_ = a
	{
		var a int
		_ = a
	}
}

閉包

使用嵌入式函數(shù)時，作用域非常重要。函數(shù)中使用且未聲明的任何變量都是對上層范圍的引用。眾所周知的使用 goroutine 的例子：

package main

import (
	"fmt"
	"time"
)

func main() {
	for _, elem := range []byte{'a', 'b', 'c'} {
		go func() {
			fmt.Printf("%c\n", elem)
		}()
	}
	time.Sleep(1e9) // Sleeping to give time to the goroutines to be executed.
}

運行該代碼：

$ go run main.go
c
c
c

這不是我們真正想要的。這是因為范圍改變了 goroutine 中引用的 elem ，因此在短列表中，它將始終顯示最后一個元素。

為了避免這種情況，有兩種解決方案：

1.將變量傳遞給函數(shù)

package main

import (
	"fmt"
	"time"
)

func main() {
	for _, elem := range []byte{'a', 'b', 'c'} {
		go func(char byte) {
			fmt.Printf("%c\n", char)
		}(elem)
	}
	time.Sleep(1e9)
}

運行結果：

$ go run main.go
a
c
b

2.在本地范圍內創(chuàng)建變量的副本

package main

import (
	"fmt"
	"time"
)

func main() {
	for _, elem := range []byte{'a', 'b', 'c'} {
		char := elem
		go func() {
			fmt.Printf("%c\n", char)
		}()
	}
	time.Sleep(1e9)
}

運行該代碼，可以得到我們想要的結果：

當我們將變量傳遞給函數(shù)時，我們實際上將變量的副本發(fā)送給以字符形式接收它的函數(shù)。因為每個 goroutine 都有自己的副本，所以沒有問題。

當我們復制變量時，我們創(chuàng)建一個新變量并將 elem 的值分配給它。我們在每次迭代中都這樣做，這意味著對于每個步驟，我們都會創(chuàng)建一個新變量， goroutine 會引用該變量。每個 goroutine 都有一個對不同變量的引用，并且它也可以正常工作。

現(xiàn)在，我們知道我們可以隱藏變量，為什么還要更改名稱呢？我們可以簡單地使用相同的名稱，因為它會影響上層范圍：

package main

import (
	"fmt"
	"time"
)

func main() {
	for _, elem := range []byte{'a', 'b', 'c'} {
		go func(elem byte) {
			fmt.Printf("%c\n", elem)
		}(elem)
	}
	time.Sleep(1e9)
}

package main

import (
	"fmt"
	"time"
)

func main() {
	for _, elem := range []byte{'a', 'b', 'c'} {
		elem := elem
		go func() {
			fmt.Printf("%c\n", elem)
		}()
	}
	time.Sleep(1e9)
}

當我們將變量傳遞給函數(shù)時，會發(fā)生同樣的事情，我們將變量的副本傳遞給函數(shù)，該函數(shù)以名稱 elem 和正確的值獲取它。

在這個范圍內，由于變量被遮蔽，我們無法從上層范圍影響元素，所做的任何更改都將僅在此范圍內應用。

當我們復制變量時，和以前一樣：我們創(chuàng)建一個新變量并將 elem 的值分配給它。在這種情況下，新變量恰好與另一個變量具有相同的名稱，但想法保持不變：新變量 + 賦值。當我們在范圍內創(chuàng)建一個具有相同名稱的新變量時，我們有效地隱藏了該變量，同時保持它的值。

:= 的情況

當 := 與多個返回函數(shù)（或類型斷言、通道接收和映射訪問）一起使用時，我們可以在 2 個語句中得到 3 個變量：

package main

func main() {
	var iface interface{}

	str, ok := iface.(string)
	if ok {
		println(str)
	}
	buf, ok := iface.([]byte)
	if ok {
		println(string(buf))
	}
}

在這種情況下， ok 不會被遮蔽，它只是被覆蓋。這就是為什么 ok 不能改變類型。但是，在范圍內這樣做會隱藏變量并允許使用不同的類型：

package main

func main() {
	var m = map[string]interface{}{}

	elem, ok := m["test"]
	if ok {
		str, ok := elem.(string)
		if ok {
			println(str)
		}
	}
}

總結

隱藏可能非常有用，但需要牢記以避免意外行為。它當然是基于案例的，它通常有助于提高可讀性和安全性，但也可以減少它。

在 goroutines 的例子中，因為它是一個簡單的例子，它的影子更具可讀性，但在更復雜的情況下，最好使用不同的名稱來確定你正在修改什么。然而，另一方面，尤其是對于錯誤，它是一個非常強大的工具?；氐轿业牡谝粋€例子：

package main

import (
	"io/ioutil"
	"log"
)

func main() {
	f, err := ioutil.TempFile("", "")
	if err != nil {
		log.Fatal(err)
	}
	defer f.Close()

	if _, err := f.Write([]byte("hello world\n")); err != nil {
		err = nil
	}
	// err is still the one form TempFile
}

在這種情況下，在 if 中隱藏 err 可以保證以前的錯誤不會受到影響，而如果使用相同的代碼，我們在 if 中使用 = 而不是 := ，它不會隱藏變量而是覆蓋錯誤的值。參考鏈接

到此這篇關于詳解Go語言中的作用域和變量隱藏的文章就介紹到這了,更多相關Go語言作用域變量隱藏內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: