Go 语言入门很简单:Go 中的作用域和变量隐藏(下)

简介: 变量隐藏在 Go 中可能会令人困惑,让我们尝试弄清楚。

闭包

使用嵌入式函数时,作用域非常重要。函数中使用且未声明的任何变量都是对上层范围的引用。众所周知的使用 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
  1. 在本地范围内创建变量的副本
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 中使用 = 而不是 :=,它不会隐藏变量而是覆盖错误的值。

相关文章
|
8天前
|
存储 Go 索引
go语言中数组和切片
go语言中数组和切片
21 7
|
8天前
|
Go 开发工具
百炼-千问模型通过openai接口构建assistant 等 go语言
由于阿里百炼平台通义千问大模型没有完善的go语言兼容openapi示例,并且官方答复assistant是不兼容openapi sdk的。 实际使用中发现是能够支持的,所以自己写了一个demo test示例,给大家做一个参考。
|
8天前
|
程序员 Go
go语言中结构体(Struct)
go语言中结构体(Struct)
85 71
|
7天前
|
存储 Go 索引
go语言中的数组(Array)
go语言中的数组(Array)
92 67
|
8天前
|
存储 Go
go语言中映射
go语言中映射
25 11
|
10天前
|
Go 索引
go语言for遍历数组或切片
go语言for遍历数组或切片
84 62
|
12天前
|
并行计算 安全 Go
Go语言中的并发编程:掌握goroutines和channels####
本文深入探讨了Go语言中并发编程的核心概念——goroutine和channel。不同于传统的线程模型,Go通过轻量级的goroutine和通信机制channel,实现了高效的并发处理。我们将从基础概念开始,逐步深入到实际应用案例,揭示如何在Go语言中优雅地实现并发控制和数据同步。 ####
|
10天前
|
Go
go语言for遍历映射(map)
go语言for遍历映射(map)
24 12
|
9天前
|
Go 索引
go语言使用索引遍历
go语言使用索引遍历
18 9
|
13天前
|
安全 Serverless Go
Go语言中的并发编程:深入理解与实践####
本文旨在为读者提供一个关于Go语言并发编程的全面指南。我们将从并发的基本概念讲起,逐步深入到Go语言特有的goroutine和channel机制,探讨它们如何简化多线程编程的复杂性。通过实例演示和代码分析,本文将揭示Go语言在处理并发任务时的优势,以及如何在实际项目中高效利用这些特性来提升性能和响应速度。无论你是Go语言的初学者还是有一定经验的开发者,本文都将为你提供有价值的见解和实用的技巧。 ####