前言

變量隱藏在 Go 中可能會(huì)令人困惑，讓我們嘗試弄清楚。

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")
	}
}

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

$ go run main.go
All success

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

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")
	}
}

運(yùn)行該代碼：

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

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

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

但是為什么它第一次起作用呢？因?yàn)樵?Go 中，變量是其作用域的本地變量。在第一個(gè)示例中，我們實(shí)際上在 if 范圍內(nèi)隱藏了 err 。

例如：

package main

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

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

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...)
}

起初，它看起來不錯(cuò)。我們從 fmt 包中調(diào)用 Printf 并將 fmt 變量傳遞給它。

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

全局變量

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

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

類型強(qiáng)制

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

package main

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

閉包

使用嵌入式函數(shù)時(shí)，作用域非常重要。函數(shù)中使用且未聲明的任何變量都是對(duì)上層范圍的引用。眾所周知的使用 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.
}

運(yùn)行該代碼：

$ go run main.go
c
c
c

這不是我們真正想要的。這是因?yàn)榉秶淖兞?nbsp;goroutine 中引用的 elem ，因此在短列表中，它將始終顯示最后一個(gè)元素。

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

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)
}

運(yùn)行結(jié)果：

$ go run main.go
a
c
b

2.在本地范圍內(nèi)創(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)
}

運(yùn)行該代碼，可以得到我們想要的結(jié)果：

當(dāng)我們將變量傳遞給函數(shù)時(shí)，我們實(shí)際上將變量的副本發(fā)送給以字符形式接收它的函數(shù)。因?yàn)槊總€(gè) goroutine 都有自己的副本，所以沒有問題。

當(dāng)我們復(fù)制變量時(shí)，我們創(chuàng)建一個(gè)新變量并將 elem 的值分配給它。我們?cè)诿看蔚卸歼@樣做，這意味著對(duì)于每個(gè)步驟，我們都會(huì)創(chuàng)建一個(gè)新變量， goroutine 會(huì)引用該變量。每個(gè) goroutine 都有一個(gè)對(duì)不同變量的引用，并且它也可以正常工作。

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

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)
}

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

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

當(dāng)我們復(fù)制變量時(shí)，和以前一樣：我們創(chuàng)建一個(gè)新變量并將 elem 的值分配給它。在這種情況下，新變量恰好與另一個(gè)變量具有相同的名稱，但想法保持不變：新變量 + 賦值。當(dāng)我們?cè)诜秶鷥?nèi)創(chuàng)建一個(gè)具有相同名稱的新變量時(shí)，我們有效地隱藏了該變量，同時(shí)保持它的值。

:= 的情況

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

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 不會(huì)被遮蔽，它只是被覆蓋。這就是為什么 ok 不能改變類型。但是，在范圍內(nèi)這樣做會(huì)隱藏變量并允許使用不同的類型：

package main

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

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

總結(jié)

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

在 goroutines 的例子中，因?yàn)樗且粋€(gè)簡(jiǎn)單的例子，它的影子更具可讀性，但在更復(fù)雜的情況下，最好使用不同的名稱來確定你正在修改什么。然而，另一方面，尤其是對(duì)于錯(cuò)誤，它是一個(gè)非常強(qiáng)大的工具?；氐轿业牡谝粋€(gè)例子：

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 可以保證以前的錯(cuò)誤不會(huì)受到影響，而如果使用相同的代碼，我們?cè)?nbsp;if 中使用 = 而不是 := ，它不會(huì)隱藏變量而是覆蓋錯(cuò)誤的值。參考鏈接

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

最新評(píng)論