日本免费高清视频-国产福利视频导航-黄色在线播放国产-天天操天天操天天操天天操|www.shdianci.com

學無先后，達者為師

網站首頁 編程語言 正文

詳解Go語言中的作用域和變量隱藏_Golang

作者：宇宙之一粟 ? 更新時間： 2022-06-26 編程語言

前言

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

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?函數創建了兩個變量：?f?和?err?。然后我們調用?Write?丟棄寫入的字節數。我們讓函數在?if?語句中調用它。讓我們編譯，它工作正常。

$ go run main.go
All success

現在，與?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 :=

所以發生了什么事？

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

但是為什么它第一次起作用呢？因為在 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?變量傳遞給它。

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

全局變量

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

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

類型強制

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

package main

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

閉包

使用嵌入式函數時，作用域非常重要。函數中使用且未聲明的任何變量都是對上層范圍的引用。眾所周知的使用?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.將變量傳遞給函數

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.在本地范圍內創建變量的副本

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

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

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

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

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

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

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

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

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

:= 的情況

當 := 與多個返回函數（或類型斷言、通道接收和映射訪問）一起使用時，我們可以在 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?中使用?=?而不是?:=?，它不會隱藏變量而是覆蓋錯誤的值。參考鏈接

原文鏈接：https://xie.infoq.cn/article/f8dfdc25d65095444269eea19

欄目分類
最近更新