标签 单元测试 下的文章

单测时尽量用fake object

本文永久链接 – https://tonybai.com/2023/04/20/provide-fake-object-for-external-collaborators

1. 单元测试的难点:外部协作者(external collaborators)的存在

单元测试是软件开发的一个重要部分,它有助于在开发周期的早期发现错误,帮助开发人员增加对生产代码正常工作的信心,同时也有助于改善代码设计。Go语言从诞生那天起就内置Testing框架(以及测试覆盖率计算工具),基于该框架,Gopher们可以非常方便地为自己设计实现的package编写测试代码。

注:《Go语言精进之路》vol2中的第40条到第44条有关于Go包内、包外测试区别、测试代码组织、表驱动测试、管理外部测试数据等内容的系统地讲解,感兴趣的童鞋可以读读。

不过即便如此,在实际开发工作中,大家发现单元测试的覆盖率依旧很低,究其原因,排除那些对测试代码不作要求的组织,剩下的无非就是代码设计不佳,使得代码不易测;或是代码有外部协作者(比如数据库、redis、其他服务等)。代码不易测可以通过重构来改善,但如果代码有外部协作者,我们该如何对代码进行测试呢,这也是各种编程语言实施单元测试的一大共同难点

为此,《xUnit Test Patterns : Refactoring Test Code》一书中提供了Test Double(测试替身)的概念专为解决此难题。那么什么是Test Double呢?我们接下来就来简单介绍一下Test Double的概念以及常见的种类。

2. 什么是Test Double?

测试替身是在测试阶段用来替代被测系统依赖的真实组件的对象或程序(如下图),以方便测试,这些真实组件或程序即是外部协作者(external collaborators)。这些外部协作者在测试环境下通常很难获取或与之交互。测试替身可以使开发人员或QA专业人员专注于新的代码而不是代码与环境集成。

测试替身是通用术语,指的是不同类型的替换对象或程序。目前xUnit Patterns至少定义了五种类型的Test Doubles:

  • Test stubs
  • Mock objects
  • Test spies
  • Fake objects
  • Dummy objects

这其中最为常用的是Fake objects、stub和mock objects。下面逐一说说这三种test double:

2.1 fake object

fake object最容易理解,它是被测系统SUT(System Under Test)依赖的外部协作者的“替身”,和真实的外部协作者相比,fake object外部行为表现与真实组件几乎是一致的,但更简单也更易于使用,实现更轻量,仅用于满足测试需求即可。

fake object也是Go testing中最为常用的一类fake object。以Go的标准库为例,我们在src/database/sql下面就看到了Go标准库为进行sql包测试而实现的一个database driver:

// $GOROOT/src/database/fakedb_test.go

var fdriver driver.Driver = &fakeDriver{}

func init() {
    Register("test", fdriver)
}

我们知道一个真实的sql数据库的代码量可是数以百万计的,这里不可能实现一个生产级的真实SQL数据库,从fakedb_test.go源文件的注释我们也可以看到,这个fakeDriver仅仅是用于testing,它是一个实现了driver.Driver接口的、支持少数几个DDL(create)、DML(insert)和DQL(selet)的toy版的纯内存数据库:

// fakeDriver is a fake database that implements Go's driver.Driver
// interface, just for testing.
//
// It speaks a query language that's semantically similar to but
// syntactically different and simpler than SQL.  The syntax is as
// follows:
//
//  WIPE
//  CREATE|<tablename>|<col>=<type>,<col>=<type>,...
//    where types are: "string", [u]int{8,16,32,64}, "bool"
//  INSERT|<tablename>|col=val,col2=val2,col3=?
//  SELECT|<tablename>|projectcol1,projectcol2|filtercol=?,filtercol2=?
//  SELECT|<tablename>|projectcol1,projectcol2|filtercol=?param1,filtercol2=?param2

与此类似的,Go标准库中还有net/dnsclient_unix_test.go中的fakeDNSServer等。此外,Go标准库中一些以mock做前缀命名的变量、类型等其实质上是fake object。

我们再来看第二种test double: stub。

2.2 stub

stub显然也是一个在测试阶段专用的、用来替代真实外部协作者与SUT进行交互的对象。与fake object稍有不同的是,stub是一个内置了预期值/响应值且可以在多个测试间复用的替身object。

stub可以理解为一种fake object的特例。

注:fakeDriver在sql_test.go中的不同测试场景中时而是fake object,时而是stub(见sql_test.go中的newTestDBConnector函数)。

Go标准库中的net/http/httptest就是一个提供创建stub的典型的测试辅助包,十分适合对http.Handler进行测试,这样我们无需真正启动一个http server。下面就是基于httptest的一个测试例子:

// 被测对象 client.go

package main

import (
    "bytes"
    "net/http"
)

// Function that uses the client to make a request and parse the response
func GetResponse(client *http.Client, url string) (string, error) {
    req, err := http.NewRequest("GET", url, nil)
    if err != nil {
        return "", err
    }

    resp, err := client.Do(req)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()

    buf := new(bytes.Buffer)
    _, err = buf.ReadFrom(resp.Body)
    if err != nil {
        return "", err
    }

    return buf.String(), nil
}

// 测试代码 client_test.go

package main

import (
    "net/http"
    "net/http/httptest"
    "testing"
)

func TestClient(t *testing.T) {
    // Create a new test server with a handler that returns a specific response
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.WriteHeader(http.StatusOK)
        w.Write([]byte(`{"message": "Hello, world!"}`))
    }))
    defer server.Close()

    // Create a new client that uses the test server
    client := server.Client()

    // Call the function that uses the client
    message, err := GetResponse(client, server.URL)

    // Check that the response is correct
    expected := `{"message": "Hello, world!"}`
    if message != expected {
        t.Errorf("Expected response %q, but got %q", expected, message)
    }

    // Check that no errors were returned
    if err != nil {
        t.Errorf("Unexpected error: %v", err)
    }
}

在这个例子中,我们要测试一个名为GetResponse的函数,该函数通过client向url发送Get请求,并将收到的响应内容读取出来并返回。为了测试这个函数,我们需要“建立”一个与GetResponse进行协作的外部http server,这里我们使用的就是httptest包。我们通过httptest.NewServer建立这个server,该server预置了一个返回特定响应的HTTP handler。我们通过该server得到client和对应的url参数后,将其传给被测目标GetResponse,并将其返回的结果与预期作比较来完成这个测试。注意,我们在测试结束后使用defer server.Close()来关闭测试服务器,以确保该服务器不会在测试结束后继续运行。

httptest还常用来做http.Handler的测试,比如下面这个例子:

// handler.go

package main

import (
    "bytes"
    "io"
    "net/http"
)

func AddHelloPrefix(w http.ResponseWriter, r *http.Request) {
    b, err := io.ReadAll(r.Body)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }
    w.Write(bytes.Join([][]byte{[]byte("hello, "), b}, nil))
    w.WriteHeader(http.StatusOK)
}

// handler_test.go

package main

import (
    "net/http"
    "net/http/httptest"
    "strings"
    "testing"
)

func TestHandler(t *testing.T) {
    r := strings.NewReader("world!")
    req, err := http.NewRequest("GET", "/test", r)
    if err != nil {
        t.Fatal(err)
    }

    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(AddHelloPrefix)
    handler.ServeHTTP(rr, req)

    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }

    expected := "hello, world!"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

在这个例子中,我们创建一个新的http.Request对象,用于向/test路径发出GET请求。然后我们创建一个新的httptest.ResponseRecorder对象来捕获服务器的响应。 我们定义一个简单的HTTP Handler(被测函数): AddHelloPrefix,该Handler会在请求的内容之前加上”hello, “并返回200 OK状态代码作为响应体。之后,我们在handler上调用ServeHTTP方法,传入httptest.ResponseRecorder和http.Request对象,这会将请求“发送”到处理程序并捕获响应。最后,我们使用标准的Go测试包来检查响应是否具有预期的状态码和正文。

在这个例子中,我们利用net/http/httptest创建了一个测试服务器“替身”,并向其“发送”间接预置信息的请求以测试Go中的HTTP handler。这个过程中其实并没有任何网络通信,也没有http协议打包和解包的过程,我们也不关心http通信,那是Go net/http包的事情,我们只care我们的Handler是否能按逻辑运行。

fake object与stub的优缺点基本一样。多数情况下,大家也无需将这二者划分的很清晰

2.3 mock object

和fake/stub一样,mock object也是一个测试替身。通过上面的例子我们看到fake建立困难(比如创建一个近2千行代码的fakeDriver),但使用简单。而mock object则是一种建立简单,使用简单程度因被测目标与外部协作者交互复杂程度而异的test double,我们看一下下面这个例子:

// db.go 被测目标

package main

// Define the `Database` interface
type Database interface {
    Save(data string) error
    Get(id int) (string, error)
}

// Example functions that use the `Database` interface
func saveData(db Database, data string) error {
    return db.Save(data)
}

func getData(db Database, id int) (string, error) {
    return db.Get(id)
}

// 测试代码

package main

import (
    "testing"

    "github.com/stretchr/testify/assert"
    "github.com/stretchr/testify/mock"
)

// Define a mock struct that implements the `Database` interface
type MockDatabase struct {
    mock.Mock
}

func (m *MockDatabase) Save(data string) error {
    args := m.Called(data)
    return args.Error(0)
}

func (m *MockDatabase) Get(id int) (string, error) {
    args := m.Called(id)
    return args.String(0), args.Error(1)
}

func TestSaveData(t *testing.T) {
    // Create a new mock database
    db := new(MockDatabase)

    // Expect the `Save` method to be called with "test data"
    db.On("Save", "test data").Return(nil)

    // Call the code that uses the database
    err := saveData(db, "test data")

    // Assert that the `Save` method was called with the correct argument
    db.AssertCalled(t, "Save", "test data")

    // Assert that no errors were returned
    assert.NoError(t, err)
}

func TestGetData(t *testing.T) {
    // Create a new mock database
    db := new(MockDatabase)

    // Expect the `Get` method to be called with ID 123 and return "test data"
    db.On("Get", 123).Return("test data", nil)

    // Call the code that uses the database
    data, err := getData(db, 123)

    // Assert that the `Get` method was called with the correct argument
    db.AssertCalled(t, "Get", 123)

    // Assert that the correct data was returned
    assert.Equal(t, "test data", data)

    // Assert that no errors were returned
    assert.NoError(t, err)
}

在这个例子中,被测目标是两个接受Database接口类型参数的函数:saveData和getData。显然在单元测试阶段,我们不能真正为这两个函数传入真实的Database实例去测试。

这里,我们没有使用fake object,而是定义了一个mock object:MockDatabase,该类型实现了Database接口。然后我们定义了两个测试函数,TestSaveData和TestGetData,它们分别使用MockDatabase实例来测试saveData和getData函数。

在每个测试函数中,我们对MockDatabase实例进行设置,包括期待特定参数的方法调用,然后调用使用该数据库的代码(即被测目标函数saveData和getData)。然后我们使用github.com/stretchr/testify中的assert包,对代码的预期行为进行断言。

注:除了上述测试中使用的AssertCalled方法外,MockDatabase结构还提供了其他方法来断言方法被调用的次数、方法被调用的顺序等。请查看github.com/stretchr/testify/mock包的文档,了解更多信息。

3. Test Double有多种,选哪个呢?

从mock object的例子来看,测试代码的核心就是mock object的构建与mock object的方法的参数和返回结果的设置,相较于fake object的简单直接,mock object在使用上较为难于理解。而且对Go语言来说,mock object要与接口类型联合使用,如果被测目标的参数是非接口类型,mock object便“无从下嘴”了。此外,mock object使用难易程度与被测目标与外部协作者的交互复杂度相关。像上面这个例子,建立mock object就比较简单。但对于一些复杂的函数,当存在多个外部协作者且与每个协作者都有多次交互的情况下,建立和设置mock object就将变得困难并更加难于理解。

mock object仅是满足了被测目标对依赖的外部协作者的调用需求,比如设置不同参数传入下的不同返回值,但mock object并未真实处理被测目标传入的参数,这会降低测试的可信度以及开发人员对代码正确性的信心。

此外,如果被测函数的输入输出未发生变化,但内部逻辑发生了变化,比如调用的外部协作者的方法参数、调用次数等,使用mock object的测试代码也需要一并更新维护。

而通过上面的fakeDriver、fakeDNSSever以及httptest应用的例子,我们看到:作为test double,fake object/stub有如下优点:

  • 我们与fake object的交互方式与与真实外部协作者交互的方式相同,这让其显得更简单,更容易使用,也降低了测试的复杂性;
  • fake objet的行为更像真正的协作者,可以给开发人员更多的信心;
  • 当真实协作者更新时,我们不需要更新使用fake object时设置的expection和结果验证条件,因此,使用fake object时,重构代码往往比使用其他test double更容易。

不过fake object也有自己的不足之处,比如:

  • fake object的创建和维护可能很费时,就像上面的fakeDriver,源码有近2k行;
  • fake object可能无法提供与真实组件相同的功能覆盖水平,这与fake object的提供方式有关。
  • fake object的实现需要维护,每当真正的协作者更新时,都必须更新fake object。

综上,测试的主要意义是保证SUT代码的正确性,让开发人员对自己编写的代码更有信心,从这个角度来看,我们在单测时应首选为外部协作者提供fake object以满足测试需要

4. fake object的实现和获取方法

随着技术的进步,fake object的实现和获取日益容易。

我们可以借助类似ChatGPT/copilot的工具快速构建出一个fake object,即便是几百行代码的fake object的实现也很容易。

如果要更高的可信度和更高的功能覆盖水平,我们还可以借助docker来构建“真实版/无阉割版”的fake object。

借助github上开源的testcontainers-go可以更为简便的构建出一个fake object,并且testcontainer提供了常见的外部协作者的封装实现,比如:MySQL、Redis、Postgres等。

以测试redis client为例,我们使用testcontainer建立如下测试代码:

// redis_test.go

package main

import (
    "context"
    "fmt"
    "testing"

    "github.com/go-redis/redis/v8"
    "github.com/testcontainers/testcontainers-go"
    "github.com/testcontainers/testcontainers-go/wait"
)

func TestRedisClient(t *testing.T) {
    // Create a Redis container with a random port and wait for it to start
    req := testcontainers.ContainerRequest{
        Image:        "redis:latest",
        ExposedPorts: []string{"6379/tcp"},
        WaitingFor:   wait.ForLog("Ready to accept connections"),
    }
    ctx := context.Background()
    redisC, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
        ContainerRequest: req,
        Started:          true,
    })
    if err != nil {
        t.Fatalf("Failed to start Redis container: %v", err)
    }
    defer redisC.Terminate(ctx)

    // Get the Redis container's host and port
    redisHost, err := redisC.Host(ctx)
    if err != nil {
        t.Fatalf("Failed to get Redis container's host: %v", err)
    }
    redisPort, err := redisC.MappedPort(ctx, "6379/tcp")
    if err != nil {
        t.Fatalf("Failed to get Redis container's port: %v", err)
    }

    // Create a Redis client and perform some operations
    client := redis.NewClient(&redis.Options{
        Addr: fmt.Sprintf("%s:%s", redisHost, redisPort.Port()),
    })
    defer client.Close()

    err = client.Set(ctx, "key", "value", 0).Err()
    if err != nil {
        t.Fatalf("Failed to set key: %v", err)
    }

    val, err := client.Get(ctx, "key").Result()
    if err != nil {
        t.Fatalf("Failed to get key: %v", err)
    }

    if val != "value" {
        t.Errorf("Expected value %q, but got %q", "value", val)
    }
}

运行该测试将看到类似如下结果:

$go test
2023/04/15 16:18:20 github.com/testcontainers/testcontainers-go - Connected to docker:
  Server Version: 20.10.8
  API Version: 1.41
  Operating System: Ubuntu 20.04.3 LTS
  Total Memory: 10632 MB
2023/04/15 16:18:21 Failed to get image auth for docker.io. Setting empty credentials for the image: docker.io/testcontainers/ryuk:0.3.4. Error is:credentials not found in native keychain

2023/04/15 16:19:06 Starting container id: 0d8341b2270e image: docker.io/testcontainers/ryuk:0.3.4
2023/04/15 16:19:10 Waiting for container id 0d8341b2270e image: docker.io/testcontainers/ryuk:0.3.4
2023/04/15 16:19:10 Container is ready id: 0d8341b2270e image: docker.io/testcontainers/ryuk:0.3.4
2023/04/15 16:19:28 Starting container id: 999cf02b5a82 image: redis:latest
2023/04/15 16:19:30 Waiting for container id 999cf02b5a82 image: redis:latest
2023/04/15 16:19:30 Container is ready id: 999cf02b5a82 image: redis:latest
PASS
ok      demo    73.262s

我们看到建立这种真实版的“fake object”的一大不足就是依赖网络下载container image且耗时过长,在单元测试阶段使用还是要谨慎一些。testcontainer更多也会被用在集成测试或冒烟测试上。

一些开源项目,比如etcd,也提供了用于测试的自身简化版的实现(embed)。这一点也值得我们效仿,在团队内部每个服务的开发者如果都能提供一个服务的简化版实现,那么对于该服务调用者来说,它的单测就会变得十分容易。

5. 参考资料

  • 《xUnit Test Patterns : Refactoring Test Code》- https://book.douban.com/subject/1859393/
  • Test Double Patterns – http://xunitpatterns.com/Test%20Double%20Patterns.html
  • The Unit in Unit Testing – https://www.infoq.com/articles/unit-testing-approach/
  • Test Doubles — Fakes, Mocks and Stubs – https://blog.pragmatists.com/test-doubles-fakes-mocks-and-stubs-1a7491dfa3da

“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

聊聊Go语言的全局变量

本文永久链接 – https://tonybai.com/2023/03/22/global-variable-in-go

注:上面篇首配图的底图由百度文心一格生成。

C语言是Go语言的先祖之一,Go继承了很多C语言的语法与表达方式,这其中就包含了全局变量,虽然Go在其语法规范中并没有直接给出全局变量的定义。但是已经入门Go的童鞋都知道,在Go中包的导出变量(exported variable)起到的就是全局变量的作用。Go包导出变量与C的全局变量在优缺点与使用方式也有相似之处。

我是C程序员出身,对全局变量并不陌生,因此学习Go语言全局变量时,也没有太多Gap。不过来自其他语言(比如Java)的童鞋在学习Go全局变量时可能会觉得别扭,在全局变量的使用方式的理解方面也久久不能到位。

在这一篇中,我们就来聊聊Go语言的全局变量,和大家一起系统地理解一下。

一. Go中的全局变量

全局变量是一个可以在整个程序中被访问和修改的变量,不管它在哪里被定义。不同的编程语言有着不同的声明和使用全局变量的方式。

在Python中,你可以在module的任何地方声明一个全局变量。就像下面示例中的globvar。但是如果你想给它重新赋值,则需要在函数中使用global关键字。

globvar = 0

def set_globvar_to_one():
  global globvar # 要给全局变量globvar赋值
  globvar = 1

def print_globvar():
  print(globvar) # 读取全局变量globvar时无需global关键字

set_globvar_to_one()
print_globvar() # 打印1

Java中没有全局变量的概念,但你却可以使用一个类的public静态变量来模拟全局变量的作用,因为这样的public类静态变量可以被任何其他类在任何地方访问到。比如下面Java代码中globalVar:

public class GlobalExample {

  // 全局变量
  public static int globalVar = 10;

  // 全局常量
  public static final String GLOBAL_CONST = "Hello";

}

在Go中,全局变量指的是在包的最顶层声明的头母大写的导出变量,这样这个变量在整个Go程序的任何角落都可以被访问和修改,比如下面示例代码中foo包的变量Global:

package foo

var Global = "myvalue" // Go全局变量

package bar

import "foo"

func F1() {
    println(foo.Global)
    foo.Global = "another value"
}

foo.Global可以被任何导入foo包的其他包所读取和修改,就像上面代码F1中对它的那些操作。

即便是全局变量,按Go语法规范,上述Global变量的作用域也是package block的,而非universe block的,关于Go标识符的作用域,Go语言第一课专栏第11讲有系统详细地说明。

Go导出变量在Go中既然充当着全局变量的角色,它也就有了和其他语言全局变量一样的优劣势。接下来我们就来看看全局变量的优点与不足。

二. 全局变量的优缺点

俗话说:既然存在就有存在的“道理”!我们不去探讨“存在即合理”在哲学层面是否正确,我们先来看看全局变量的存在究竟能带来哪些好处。

1. 全局变量的优点

  • 首先,全局变量易于访问

全局变量的定义决定了它可以在程序的任何地方被访问。无论是在函数、方法、循环体内、深度缩进的条件语句块内部,全局变量都可以被直接访问到。这为减少函数参数个数带来一定“便利”,同时也省去了确定参数类型、实施参数传递的“烦恼”。

破壁人:全局变量容易被意外修改或被局部变量遮蔽,从而导致意想不到的问题。

  • 其次,全局变量易于共享数据

由于易于访问的特性,全局变量常用于在程序的不同部分之间共享数据,比如配置项数据、命令行标志(cmd flag)等。又由于全局变量的生命周期与程序的整个生命周期等同,不会因为函数调用结束而销毁,也不会被GC掉,可以始终存在并保持其值。因此全局变量被用作共享数据时,开发人员也不会有担心全局变量所在内存“已被回收”的心智负担。

破壁人: 并发的多线程或多协程(包括goroutine)访问同一个全局变量时需要考虑“数据竞争”问题。

  • 最后,全局变量让代码显得更为简洁

Go全局变量只需要在包的顶层声明一次即可,之后便可以在程序的任何地方对其进行访问和修改。对于声明全局变量的包的维护者而言,这样的代码再简洁不过了!

破壁人: 多处访问和修改全局变量的代码都与全局变量产生了直接的数据耦合,降低了可维护性和扩展性。

在上面的说明中,我针对全局变量的每条优点都写了一条“破壁人”观点,把这些破壁观点聚拢起来,就构成了全局变量的缺点集合,我们继续来看一下。

2. 全局变量的缺点

  • 首先,全局变量容易被意外修改或被局部变量遮蔽

前面提到,全局变量易于访问,这意味着所有地方都可能会直接访问或修改全局变量。任何一个位置改变了全局变量,都可能会以意想不到的方式影响着另外一个使用它的函数。这将导致针对这些函数的测试更为困难,全局变量的存在让各个测试之间隔离性不好,测试用例执行过程中如果修改了全局变量,测试执行结束前可能都需要将全局变量恢复到之前的状态,以尽可能保证对其他测试用例的干扰最小,下面是一个示例:

var globalVar int

func F1() {
    globalVar = 5
}

func F2() {
    globalVar = 6
}

func TestF1(t *testing) {
    old := globalVar
    F1()
    // assert the result
    ... ...
    globalVar = old // 恢复globalVar
}

func TestF2(t *testing) {
    old := globalVar
    F2()
    // assert the result
    ... ...
    globalVar = old // 恢复globalVar
}

此外,全局变量十分容易被函数、方法、循环体的同名局部变量所遮蔽(shadow),导致一些奇怪难debug的问题,尤其是与Go的短变量声明语法结合使用时

go vet支持对代码的静态分析,不过变量遮蔽检查的功能需要额外安装:

$go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow@latest
$go vet -vettool=$(which shadow)
  • 其次,并发条件下,对全局变量的访问存在“数据竞争”问题

如果你的程序存在多个goroutine对全局变量的并发读写,那么“数据竞争”问题便不可避免。你需要使用额外的同步手段对全局变量进行保护,比如互斥锁、读写锁、原子操作等。

同理,没有同步手段保护的全局变量也限制了单元测试的并行执行能力(-paralell)。

  • 最后,全局变量在带来代码简洁性的同时,更多带来的是对扩展和复用不利的耦合性

全局变量让程序中所有访问和修改它的代码对其产生了数据耦合,全局变量的细微变化都将对这些代码产生影响。这样,如果要复用或扩展这些依赖全局变量的代码将变得十分困难。比如:若要对它们进行并行化执行,需要考虑其耦合的全局变量是否支持同步手段。若要复用其中的代码逻辑到其他程序中,可能还需要在新程序中创建一个新的全局变量。

我们看到,Go全局变量有优点,更有一堆不足,那么我们在实际生产编码过程中到底该如何对待全局变量呢?我们继续往下看。

三. Go全局变量的使用惯例与替代方案

到底Go语言是如何对待全局变量的?我翻了翻标准库来看看Go官方团队是如何对待全局变量的,我得到的结论是尽量少用

Go标准库中的全局变量用了“不少”,但绝大多数都是全局的“哨兵”错误变量,比如:

// $GOROOT/src/io/io.go
var ErrShortWrite = errors.New("short write")

// ErrShortBuffer means that a read required a longer buffer than was provided.
var ErrShortBuffer = errors.New("short buffer")

// EOF is the error returned by Read when no more input is available.
// (Read must return EOF itself, not an error wrapping EOF,
// because callers will test for EOF using ==.)
// Functions should return EOF only to signal a graceful end of input.
// If the EOF occurs unexpectedly in a structured data stream,
// the appropriate error is either ErrUnexpectedEOF or some other error
// giving more detail.
var EOF = errors.New("EOF")

// ErrUnexpectedEOF means that EOF was encountered in the
// middle of reading a fixed-size block or data structure.
var ErrUnexpectedEOF = errors.New("unexpected EOF")
... ...

关于错误处理中的“哨兵”错误处理模式,可以参考我的Go语言第一课专栏。更多Go错误处理模式在专栏中有系统讲解。

这些ErrXXX全局变量虽说是被定义为了“变量(Var)”,但Go开源许久以来,大家已经达成默契:这些ErrXXX变量仅是“只读”的,没人会对其进行任何修改操作。到这里有初学者可能会问:那为什么不将它们定义为常量呢?那是因为Go语言对常量的类型是有要求的:

Go常量有布尔常量、rune常量、整数常量、浮点常量、复数常量和字符串常量。

其他类型均不能被定义为常量。而errors.New返回的动态类型为errors.errorString结构体类型的指针,显然也不在常量类型范围之内。

除了ErrXXX这类全局变量外,Go标准库中其他全局变量就很少了。一个典型的全局变量是http.DefaultServeMux:

// $GOROOT/src/net/http/server.go

// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

// NewServeMux allocates and returns a new ServeMux.
func NewServeMux() *ServeMux { return new(ServeMux) }

http包是Go早期就携带的高频使用的包,我猜早期实现时出于某种原因定义了全局变量DefaultServeMux,后期可能由于兼容性原因保留了该全局变量,但从代码逻辑来看,去掉也不会有任何影响。

通过http包的DefaultServeMux、defaultServeMux和NewServeMux等逻辑,我们也可以看出Go语言采用的替代全局变量的方案,那就是“封装”。以http.ServeMux为例(我们假设删除掉DefaultServeMux这个全局变量,用包级非导出变量defaultServeMux替代它)。

http包定义了ServeMux类型以及相应方法用于处理HTTP请求的多路复用,但http包并未直接定义一个ServerMux的全局变量(我们假设删除了DefaultServeMux变量),而是定义了一个包级非导出变量defaultServeMux作为默认的Mux。

http包仅导出两个函数Handle和HandleFunc供调用者注册http请求路径与对应的handler(下面代码中的DefaultServeMux可换成defaultServeMux):

// $GOROOT/src/net/http/server.go

// Handle registers the handler for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func Handle(pattern string, handler Handler) { DefaultServeMux.Handle(pattern, handler) }

// HandleFunc registers the handler function for the given pattern
// in the DefaultServeMux.
// The documentation for ServeMux explains how patterns are matched.
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
    DefaultServeMux.HandleFunc(pattern, handler)
}

这样http完全不需要暴露Mux实现的细节,调用者也无需依赖一个全局变量,这个方案将原先的对全局变量的数据耦合转换为对http包的行为耦合。

类似的作法我们在标准库log包中也能看到,log包定义了包级变量std用作默认的Logger,但对外仅暴露Printf等系列打印函数,这些函数的实现会使用包级变量std的相应方法:

// $GOROOT/src/log/log.go

// Print calls Output to print to the standard logger.
// Arguments are handled in the manner of fmt.Print.
func Print(v ...any) {
    if std.isDiscard.Load() {
        return
    }
    std.Output(2, fmt.Sprint(v...))
}

// Printf calls Output to print to the standard logger.
// Arguments are handled in the manner of fmt.Printf.
func Printf(format string, v ...any) {
    if std.isDiscard.Load() {
        return
    }
    std.Output(2, fmt.Sprintf(format, v...))
}

// Println calls Output to print to the standard logger.
// Arguments are handled in the manner of fmt.Println.
func Println(v ...any) {
    if std.isDiscard.Load() {
        return
    }
    std.Output(2, fmt.Sprintln(v...))
}
... ...

注:其他语言可能有一些其他的替代全局变量的方案,比如Java的依赖注入。

四. 小结

综上,全局变量虽然有易于访问、易于共享、代码简洁等优点,但相较于其带来的意外修改、并发数据竞争、更高的耦合性等弊端而言,Go开发者选择了“尽量少用全局变量”的最佳实践。

此外,在Go中最常见的替代全局变量的方案就是封装,这个大家可以通过阅读标准库的典型源码慢慢体会。

注:本文部分内容来自于New Bing的Chat功能(据说是基于GPT-4大语言模型)生成的答案。


“Gopher部落”知识星球旨在打造一个精品Go学习和进阶社群!高品质首发Go技术文章,“三天”首发阅读权,每年两期Go语言发展现状分析,每天提前1小时阅读到新鲜的Gopher日报,网课、技术专栏、图书内容前瞻,六小时内必答保证等满足你关于Go语言生态的所有需求!2023年,Gopher部落将进一步聚焦于如何编写雅、地道、可读、可测试的Go代码,关注代码质量并深入理解Go核心技术,并继续加强与星友的互动。欢迎大家加入!

img{512x368}
img{512x368}

img{512x368}
img{512x368}

著名云主机服务厂商DigitalOcean发布最新的主机计划,入门级Droplet配置升级为:1 core CPU、1G内存、25G高速SSD,价格5$/月。有使用DigitalOcean需求的朋友,可以打开这个链接地址:https://m.do.co/c/bff6eed92687 开启你的DO主机之路。

Gopher Daily(Gopher每日新闻)归档仓库 – https://github.com/bigwhite/gopherdaily

我的联系方式:

  • 微博(暂不可用):https://weibo.com/bigwhite20xx
  • 微博2:https://weibo.com/u/6484441286
  • 博客:tonybai.com
  • github: https://github.com/bigwhite

商务合作方式:撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。

如发现本站页面被黑,比如:挂载广告、挖矿等恶意代码,请朋友们及时联系我。十分感谢! Go语言第一课 Go语言精进之路1 Go语言精进之路2 Go语言编程指南
商务合作请联系bigwhite.cn AT aliyun.com

欢迎使用邮件订阅我的博客

输入邮箱订阅本站,只要有新文章发布,就会第一时间发送邮件通知你哦!

这里是 Tony Bai的个人Blog,欢迎访问、订阅和留言! 订阅Feed请点击上面图片

如果您觉得这里的文章对您有帮助,请扫描上方二维码进行捐赠 ,加油后的Tony Bai将会为您呈现更多精彩的文章,谢谢!

如果您希望通过微信捐赠,请用微信客户端扫描下方赞赏码:

如果您希望通过比特币或以太币捐赠,可以扫描下方二维码:

比特币:

以太币:

如果您喜欢通过微信浏览本站内容,可以扫描下方二维码,订阅本站官方微信订阅号“iamtonybai”;点击二维码,可直达本人官方微博主页^_^:
本站Powered by Digital Ocean VPS。
选择Digital Ocean VPS主机,即可获得10美元现金充值,可 免费使用两个月哟! 著名主机提供商Linode 10$优惠码:linode10,在 这里注册即可免费获 得。阿里云推荐码: 1WFZ0V立享9折!


View Tony Bai's profile on LinkedIn
DigitalOcean Referral Badge

文章

评论

  • 正在加载...

分类

标签

归档



View My Stats