GO语言基础笔记(九):工程实践

2024-01-01 19:43:50

单元测试(Unit Testing)

????????单元测试是指对软件中的最小可测试单元进行检查和验证。在Go语言中,可以使用内置的testing包来进行单元测试。进行单元测试时,您应该关注以下几个要点:

  • 测试代码的独立性:确保每个测试用例都是独立的,不依赖于其他测试。
  • 边界条件的测试:不仅要测试常规条件,也要测试边界和异常情况。
  • 使用表驱动测试:这种方法可以让您用不同的输入重复测试同一功能。

1. 测试代码的独立性

????????在单元测试中,每个测试用例应该是独立的,这意味着一个测试用例不应该依赖于其他测试用例的状态或结果。这样做的目的是为了保证测试结果的一致性,确保我们能准确地定位问题。

package mypackage

import "testing"

func TestFunctionA(t *testing.T) {
    // 初始化环境
    // 执行测试
    // 断言结果
}

func TestFunctionB(t *testing.T) {
    // 初始化环境
    // 执行测试
    // 断言结果
}

2. 边界条件的测试?

????????测试不仅应涵盖常规条件,还要包括边界和异常情况。这有助于确保您的代码在各种情况下都能正常工作。

func TestMyFunction_WithBoundaryValue(t *testing.T) {
    result := MyFunction(边界值)
    if result != 期望的结果 {
        t.Errorf("期望得到 %v,但得到了 %v", 期望的结果, result)
    }
}

3. 使用表驱动测试?

????????表驱动测试是一种结构化的测试方法,可以用不同的测试数据多次运行同一个测试逻辑。

func TestMyFunction(t *testing.T) {
    var tests = []struct {
        input    输入类型
        expected 输出类型
    }{
        {输入值1, 期望值1},
        {输入值2, 期望值2},
        // 更多测试用例
    }

    for _, tt := range tests {
        testname := fmt.Sprintf("%v", tt.input)
        t.Run(testname, func(t *testing.T) {
            result := MyFunction(tt.input)
            if result != tt.expected {
                t.Errorf("输入 %v,期望得到 %v,实际得到 %v", tt.input, tt.expected, result)
            }
        })
    }
}

????????在这个例子中,我们定义了一个结构体数组,其中包含了不同的测试用例。然后我们遍历这些测试用例,对每个用例运行相同的测试逻辑。

????????以上就是Go语言中单元测试的一些关键点和示例。希望这些能帮助您更好地理解并实践Go语言的单元测试。继续努力,不断提高!

代码组织(Code Organization)

????????代码组织是指如何合理安排代码结构,使其清晰、易于维护。在Go语言中,一般遵循以下原则:

  • 按功能划分包(package):相关的功能应该放在同一个包中。
  • 避免循环依赖:确保包之间的依赖是单向的,不形成循环。
  • 合理利用接口(interface):接口可以帮助解耦,使各个部分更容易独立变化。

1. 按功能划分包(package)

????????在Go中,将相关的功能组织到同一个包中是一种常见的做法。每个包应该有一个单一的职责,包中的所有代码都应该服务于这个职责。

????????假设您正在开发一个网络应用,您可以将HTTP处理相关的代码放在一个包中,数据库操作相关的代码放在另一个包中。

// http 包处理所有HTTP请求和响应
package http

import "net/http"

func HandleRequest(w http.ResponseWriter, r *http.Request) {
    // HTTP请求处理逻辑
}

// db 包负责数据库交互
package db

import "database/sql"

func QueryDatabase(query string) *sql.Rows {
    // 数据库查询逻辑
}

2. 避免循环依赖

????????循环依赖会导致编译错误,并且使得代码结构复杂化。在Go中,包之间的依赖应该是单向的。

????????假设有两个包AB,如果A依赖于B,那么B就不应该依赖于A

// 包A
package A

import "B"

func FunctionA() {
    B.FunctionB()
}

// 包B
package B

// 注意:这里没有导入包A,避免循环依赖
func FunctionB() {
    // 实现逻辑
}

3. 合理利用接口(interface)

????????接口是Go语言的核心概念之一。通过定义接口,可以使各个组件之间解耦,更容易进行替换和测试。

package storage

// Storer 接口定义了存储行为
type Storer interface {
    Store(data string) error
}

// FileStorer 实现了 Storer 接口,使用文件系统进行存储
type FileStorer struct{}

func (f *FileStorer) Store(data string) error {
    // 文件存储逻辑
}

// MemoryStorer 实现了 Storer 接口,使用内存进行存储
type MemoryStorer struct{}

func (m *MemoryStorer) Store(data string) error {
    // 内存存储逻辑
}

????????在这个例子中,我们定义了一个Storer接口,它有一个Store方法。然后我们提供了两种实现:FileStorerMemoryStorer。这样,我们可以根据需要替换不同的存储策略,而不影响使用这些策略的代码。?

模块化(Modularization)

????????模块化是指将系统分解为多个模块,每个模块实现特定的功能。在Go中,模块化可以通过创建不同的包(package)来实现。您应该注意:

  • 明确每个包的职责。
  • 保持模块间的低耦合性。
  • 通过导出和非导出标识符控制访问权限。

1. 明确每个包的职责

????????在Go中,一个包应该代表一个单一的、明确的功能模块。这意味着包内的所有代码都应该服务于一个共同的目标。

????????假设您正在开发一个电商应用,您可能需要一个处理订单的包和一个处理用户账户的包。

// orders 包处理订单相关的逻辑
package orders

// ProcessOrder 处理订单
func ProcessOrder(orderID int) {
    // 订单处理逻辑
}

// users 包处理用户账户相关的逻辑
package users

// CreateUser 创建新用户
func CreateUser(username string) {
    // 用户创建逻辑
}

2. 保持模块间的低耦合性

????????低耦合性是指各个模块之间相互独立,减少了模块间的依赖。这样的设计使得每个模块都可以独立地进行更改和维护。

????????在电商应用中,订单处理模块不应直接依赖于用户账户模块的内部实现。

package orders

import "users"

// ProcessOrder 使用了 users 包的接口,而不是具体实现
func ProcessOrder(orderID int, userID int) {
    user := users.GetUser(userID)
    // 使用 user 进行订单处理
}

3. 通过导出和非导出标识符控制访问权限

在Go中,通过大写字母开头的标识符实现导出(公开),这意味着其他包可以访问这些标识符。小写字母开头的标识符是非导出(私有)的,只能在同一包内访问。

示例说明:

合理地使用导出和非导出标识符,可以控制包的内部实现细节,只向外界暴露必要的接口。

package users

// CreateUser 是导出的,可以被其他包调用
func CreateUser(username string) {
    // 实现细节
}

// hashPassword 是非导出的,只能在 users 包内部使用
func hashPassword(password string) string {
    // 密码哈希逻辑
}

????????以上示例展示了如何在Go中实现模块化。明确的职责分配、低耦合性设计和合理的访问权限控制,这些都是构建模块化系统的关键。遵循这些原则,您将能够创建出更加健壯、易于维护和扩展的Go应用。

依赖管理(Dependency Management)

????????Go语言自1.11版本起引入了模块支持(Go Modules),这是Go语言的官方依赖管理系统。使用Go Modules可以轻松地管理项目的依赖。关键步骤包括:

  • 使用go mod init创建新模块。
  • 使用go get获取依赖。
  • 使用go.modgo.sum文件管理依赖。

使用 go mod init 创建新模块

????????当您开始一个新项目或将现有项目转移到 Go Modules 管理时,首先需要初始化模块。

????????在项目根目录下运行以下命令:

go mod init github.com/用户名/仓库名

使用 go get 获取依赖

??go get 命令用于下载项目依赖的模块到本地。

????????假设您想要获取 github.com/gin-gonic/gin 这个 HTTP web 框架,您可以运行:

go get github.com/gin-gonic/gin

????????这个命令会下载 gin 并更新 go.modgo.sum 文件。

使用 go.modgo.sum 文件管理依赖

???go.mod 文件包含了项目所需的依赖信息,而 go.sum 文件包含了依赖的特定版本的校验和(checksums),用于确保依赖的完整性和一致性。

??go.mod 文件示例:

module github.com/用户名/仓库名

go 1.16

require (
    github.com/gin-gonic/gin v1.6.3
    // 其他依赖
)

???go.sum 文件示例

github.com/gin-gonic/gin v1.6.3 h1:... // 校验和
github.com/gin-gonic/gin v1.6.3/go.mod h1:... // 校验和

其他常用命令

  • go list -m all:列出当前模块的所有依赖。
  • go build:构建项目时,会自动下载依赖到本地。
  • go mod tidy:清理未使用的依赖。

这个Go语言系列 就先到这吧。

文章来源:https://blog.csdn.net/weixin_44120785/article/details/135326826
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。