Go语言：利用 TDD 测试驱动开发帮助理解数组与动态数组（切片）的区别

于 2023-03-20 17:54:00 发布
阅读量75 收藏
点赞数
文章标签： 驱动开发 tdd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mercury_cc/article/details/130120774
版权

2023-03-29 更新

经过一段时间的学习与实践，针对 Golang 语言基础的 TDD 驱动开发测试训练已经告一段落，接下来会在此基础上继续使用 TDD 来构建应用程序 。

博主前一部分的代码Github先贴下面👇以供参考

https://github.com/slowlydance2me/My_Golang_Study.git

Array VS Slice

数组允许你以特定的顺序在变量中存储相同类型的多个元素。
对于数组来说，最常见的就是迭代数组中的元素。
我们创建一个 Sum 函数，它使用 for 来循环获取数组中的元素并返回所有元素的总和。

先写测试(array)

利用 TDD 思想我们需要先写测试函数
先创建一个  sum_test.go 文件
在 sum_test.go 中： 
package main

import "testing"

func TestSum(t *testing.T) {

    numbers := [5]int{1, 2, 3, 4, 5}

    got := Sum(numbers)
    want := 15

    if want != got {
        t.Errorf("got %d want %d given, %v", got, want, numbers)
    }
}

数组的容量是我们在声明它时指定的固定值。我们可以通过两种方式初始化数组：

 关于其他引用类型的介绍参考👈

 在错误信息中打印函数的输入有时很有用。

我们使用 %v(默认输出格式)占位符来打印输入，它非常适用于展示数组。

运行测试

我们创建一个Sum.go文件，不着急补全，我们先写个框架，让它编译通过

package main

func Sum(numbers [5]int) (sum int) {
    return 0
}

这时测试还会失败，不过会返回明确的错误信息：

sum_test.go:13: got 0 want 15 given, [1 2 3 4 5]

这个时候把代码补充完整，使得它能够通过测试：

func Sum(numbers [5]int) int {
    sum := 0
    for i := 0; i < 5; i++ {
        sum += numbers[i]
    }
    return sum
}

可以使用 取下标 也就是 array[index] 语法来获取数组中指定索引对应的值。

在本例中我们使用 for 循环分 5 次取出数组中的元素并与 sum 变量求和。

重构一(改进代码)

我们可以使用 range 语法来让函数变得更加整洁。

func Sum(numbers [5]int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}

range 会迭代数组，每次迭代都会返回数组元素的索引和值。我们选择使用 '_' 空白标志符 来忽略索引。

数组和它的类型

数组有一个有趣的属性，它的大小也属于类型的一部分，如果你尝试将 [4]int 作为 [5]int 类型的参数传入函数，是不能通过编译的。
它们是不同的类型，就像尝试将 string 当做 int 类型的参数传入函数一样。
因为这个原因，所以数组比较笨重，大多数情况下我们都不会使用它。
Go 的切片(slice)类型不会将集合的长度保存在类型中，因此它的尺寸可以是不固定的。
下面我们会完成一个动态长度的 Sum

先写测试(slice)

我们会使用 切片类型，它可以接收不同大小的切片集合。语法上和数组非常相似，只是在声明的时候不指定长度：

func TestSum(t *testing.T) {

    t.Run("collection of 5 numbers", func(t *testing.T) {
        numbers := [5]int{1, 2, 3, 4, 5}

        got := Sum(numbers)
        want := 15

        if got != want {
            t.Errorf("got %d want %d given, %v", got, want, numbers)
        }
    })

    t.Run("collection of any size", func(t *testing.T) {
        numbers := []int{1, 2, 3}

        got := Sum(numbers)
        want := 6

        if got != want {
            t.Errorf("got %d want %d given, %v", got, want, numbers)
        }
    })

}

运行测试

当然会编译出错：

 

同样先使用最少的代码来让失败的测试先跑起来

这时我们可以选择一种解决方案：
  • 修改现有的 API，将 Sum 函数的参数从数组改为切片。如果这么做我们就有可能会影响使用这个 API 的人，因为我们的 其他 测试不能编译通过。
  • 创建一个新函数。

根据目前的情况，并没有人使用我们的函数，所以选择修改原来的函数。

func Sum(numbers []int) int {
    sum := 0
    for _, number := range numbers {
        sum += number
    }
    return sum
}

如果你运行测试，它们还是不能编译通过，你必须把之前测试代码中的数组换成切片

 再把 Sum 补充完整，使得它能够通过测试：

事实证明，这里需要我们做的只是修复编译器错误，然后测试就通过了。

重构二

我们已经重构了 Sum 函数把参数从数组改为切片。注意不要在重构以后忘记维护你的测试代码。

func TestSum(t *testing.T) {

    t.Run("collection of 5 numbers", func(t *testing.T) {
        numbers := []int{1, 2, 3, 4, 5}

        got := Sum(numbers)
        want := 15

        if got != want {
            t.Errorf("got %d want %d given, %v", got, want, numbers)
        }
    })

    t.Run("collection of any size", func(t *testing.T) {
        numbers := []int{1, 2, 3}

        got := Sum(numbers)
        want := 6

        if got != want {
            t.Errorf("got %d want %d given, %v", got, want, numbers)
        }
    })

}
质疑测试的价值是非常重要的。测试并不是越多越好，而是尽可能的使你的代码更加健壮。
太多的测试会增加维护成本，因为 维护每个测试都是需要成本的。
在本例中，针对该函数写两个测试其实是多余的，因为切片尺寸并不影响函数的运行。
  Go 有内置的计算测试 覆盖率的工具，它能帮助你发现没有被测试过的区域。
我们不需要追求 100% 的测试覆盖率，它只是一个供你获取测试覆盖率的方式。
只要你严格遵循 TDD 规范，那你的测试覆盖率就会很接近 100%。
运行：
  
go test -cover

你会看到：

 现在删除一个测试，然后再次运行。

新的想法

这回我们需要一个 SumAll 函数，它接受多个切片，并返回由每个切片元素的总和组成的新切片。

 先写测试

func TestSumAll(t *testing.T) {

    got := SumAll([]int{1,2}, []int{0,9})
    want := []int{3, 9}

    if got != want {
        t.Errorf("got %v want %v", got, want)
    }
}

运行测试

 先使用最少的代码来让失败的测试先跑起来

我们需要定义满足测试要求的 SumAll。
我们可以写一个 可变参数 的函数： 
func SumAll(numbersToSum ...[]int) (sums []int) {
    return
}

这时运行测试会报编译时错误：

./sum_test.go:26:9: invalid operation: got != want (slice can only be compared to nil)

在 Go 中不能对切片使用等号运算符。你可以写一个函数迭代每个元素来检查它们的值。

但是一种比较简单的办法是使用 reflect.DeepEqual，它在判断两个变量是否相等时十分有用。

func TestSumAll(t *testing.T) {

    got := SumAll([]int{1,2}, []int{0,9})
    want := []int{3, 9}

    if !reflect.DeepEqual(got, want) {
        t.Errorf("got %v want %v", got, want)
    }
}

确保你已经在文件头部 import reflect，这样你才能使用 DeepEqual 方法。

需要注意的是 reflect.DeepEqual 不是「类型安全」的，所以有时候会发生比较怪异的行为。

为了看到这种行为，暂时将测试修改为：

func TestSumAll(t *testing.T) {

    got := SumAll([]int{1,2}, []int{0,9})
    want := "bob"

    if !reflect.DeepEqual(got, want) {
        t.Errorf("got %v want %v", got, want)
    }
}
这里我们尝试比较 slice 和 string。这显然是不合理的，但是却通过了编译！所以使用 reflect.DeepEqual 比较简洁但是在使用时需多加小心。
  sum_test.go:30: got [] want [3 9]
将代码补充完整使函数能够测试通过
我们需要做的就是迭代可变参数，使用 Sum 计算每个参数的总和并把结果放入函数返回的切片中。 
func SumAll(numbersToSum ...[]int) (sums []int) {
    lengthOfNumbers := len(numbersToSum)
    sums = make([]int, lengthOfNumbers)

    for i, numbers := range numbersToSum {
        sums[i] = Sum(numbers)
    }

    return
}
我们学到了很多新东西。
这里有一种创建切片的新方式。make 可以在创建切片的时候指定我们需要的长度和容量。
我们可以使用切片的索引访问切片内的元素，使用 = 对切片元素进行赋值。
  现在应该可以测试通过。

重构三

顺便说一下，切片有容量的概念。如果你有一个容量为 2 的切片，但使用 mySlice[10]=1 进行赋值，会报运行时错误。
不过你可以使用 append  函数，它能为切片追加一个新值。 
func SumAll(numbersToSum ...[]int) []int {
    var sums []int
    for _, numbers := range numbersToSum {
        sums = append(sums, Sum(numbers))
    }

    return sums
}
在这个实现中，我们不用担心切片元素会超过容量。我们开始使用空切片(在函数签名中定义)，在每次计算完切片的总和后将结果添加到切片中。
接下来的工作是把 SumAll 变成 SumAllTails

还有一个新想法

先写测试

func TestSumAllTails(t *testing.T) {
    got := SumAllTails([]int{1,2}, []int{0,9})
    want := []int{2, 9}

    if !reflect.DeepEqual(got, want) {
        t.Errorf("got %v want %v", got, want)
    }
}

运行测试

./sum_test.go:26:9: undefined: SumAllTails

先使用最少的代码来让失败的测试先跑起来

把函数名称改为 SumAllTails 并重新运行测试

sum_test.go:30: got [3 9] want [2 9]

将代码补充完整使函数能够测试通过

func SumAllTails(numbersToSum ...[]int) []int {
    var sums []int
    for _, numbers := range numbersToSum {
        tail := numbers[1:]
        sums = append(sums, Sum(tail))
    }

    return sums
}

我们可以使用语法 slice[low:high] 获取部分切片。如果在冒号的一侧没有数字就会一直取到最边缘的元素。

在我们的函数中，我们使用 numbers[1:] 取到从索引 1 到最后一个元素。

重构四

这次没有太多需要重构的地方。
我们只需要想到：
如果传入一个空切片会怎样？空切片的「尾部」是什么呢，如果我们在空数组上使用 myEmptySlice[1:]会发生什么？

先写测试

func TestSumAllTails(t *testing.T) {

    t.Run("make the sums of some slices", func(t *testing.T) {
        got := SumAllTails([]int{1,2}, []int{0,9})
        want := []int{2, 9}

        if !reflect.DeepEqual(got, want) {
            t.Errorf("got %v want %v", got, want)
        }
    })

    t.Run("safely sum empty slices", func(t *testing.T) {
        got := SumAllTails([]int{}, []int{3, 4, 5})
        want :=[]int{0, 9}

        if !reflect.DeepEqual(got, want) {
            t.Errorf("got %v want %v", got, want)
        }
    })

}

运行测试 

会报 panic

panic: runtime error: slice bounds out of range [recovered]
panic: runtime error: slice bounds out of range
值得注意的是，该函数 编译通过 了，但是在运行时出现错误。
编译时错误是我们的朋友，因为它帮助我们让程序可以工作。
运行时错误是我们的敌人，因为它影响我们的用户。
将代码补充完整使函数能够测试通过 
func SumAllTails(numbersToSum ...[]int) []int {
    var sums []int
    for _, numbers := range numbersToSum {
        if len(numbers) == 0 {
            sums = append(sums, 0)
        } else {
            tail := numbers[1:]
            sums = append(sums, Sum(tail))
        }
    }

    return sums
}

重构五

我们的测试代码有一部分是重复的，我们可以把它放到另一个函数中复用。

func TestSumAllTails(t *testing.T) {

    checkSums := func(t *testing.T, got, want []int) {
        if !reflect.DeepEqual(got, want) {
            t.Errorf("got %v want %v", got, want)
        }
    }

    t.Run("make the sums of tails of", func(t *testing.T) {
        got := SumAllTails([]int{1, 2}, []int{0, 9})
        want := []int{2, 9}
        checkSums(t, got, want)
    })

    t.Run("safely sum empty slices", func(t *testing.T) {
        got := SumAllTails([]int{}, []int{3, 4, 5})
        want := []int{0, 9}
        checkSums(t, got, want)
    })

}

这样使用起来更加方便，而且还能增加代码的类型安全性。如果一个粗心的开发者使用 checkSums(t, got, "dave") 是不能通过编译的

总结

我们学习了：
  • 数组
  • 切片
  • 多种方式的切片初始化
  • 切片的容量是 固定 的，但是你可以使用 append 从原来的切片中创建一个新切片
  • 如何获取部分切片
  • 使用 len 获取数组和切片的长度
  • 使用测试代码覆盖率的工具
  • reflect.DeepEqual 的妙用和对代码类型安全性的影响
数组和切片的元素可以是任何类型，包括数组和切片自己。如果需要你可以定义 [][]string
Mercury_cc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【golang】切片
fsx2550553488的博客
05-06 743
基本概念 切片看上去是一个可变长度的数组，实际上底层是一个结构体。结构体包含三个基本元素：1，指针（*[]type），指向一个连续的内存空间，也就是一个数组； 2，元素个数（len），可以访问的元素的个数；3，指针指向的数组的空间的长度（cap） 其中，len个元素会被初始化为默认零值，未初始化的元素不可访问。切片结构体详解如下图： 代码 func TestSliceInit(t *testing.T) { // var s0 []int //如果声明时不赋值，此时切片中...
Golang中 map的key可以用数组array类型吗？map的key可以用切片slice类型吗？为什么slice、map、function不能直接用==比较？
Mark66890620
01-06 2298
golang 中 map 的 key 必须是可以比较的，再简单点也就是说，map的key是可以使用 == 运算符进行比较的。 因slice，map，function 不可以比较，所以不能作为key 所以 数字、string、bool、array数组、channel、指针可以，以及 包含前面类型的 struct。 ...
golang中如何比较struct,slice,map是否相等以及几种对比方法的区别
铁柱的博客
07-29 4266
对比两个struct或者map，slice是否相等是大家经常会有的需求，想必大家也都接触过很多对比的方式，比如等。这么多种对比方式，适用场景和优缺点都有哪些呢？为什么可以用==，有的却不可以呢？除了这三个，还有其他的方式可以判断相等吗？问题多多，且一起研究研究。Golang几种对象比较方法我们发现对比的两个结构是否相等，方式很多，效率也有高有低。选择合适自己需求的最重要。相对来说，cmp包是要更安全且可操作性更强一点，主要是看大家的喜好了。end。...
面试官：两个nil比较结果是什么？
qq_39397165的博客
04-25 420
背景哈喽，大家好，我是asong。前几天在一个交流群里看到了一道非常有意思的面试题，今天把它分享出来，我们先来看一下这个道题：fmt.Println(nil==nil) 两个nil的比较...
两个nil比较结果是什么
weixin_41882200的博客
06-07 368
背景 哈喽，大家好，我是asong。前几天在一个交流群里看到了一道非常有意思的面试题，今天把它分享出来，我们先来看一下这个道题： fmt.Println(nil== nil) 两个nil的比较结果是什么？ true、false、还是无法编译？大家先思考着，文中揭晓答案。 Go中nil的定义 在Go官方文档中，对nil的定义如下： // nil is a predeclared identifier representing the zero value for a // pointer, channel,
go-tdd:Go中的示例测试驱动开发
05-14
Go中的示例测试驱动开发此回购是对Multy-Currency Money示例的改编，从Kent Beck的Example Test-Driven Development by Example到Go编程语言。 这个想法是通过提交将实现分开，并尽可能遵循本书中描述的工作，但有...
TDD:Java 中测试驱动开发 (TDD) 的实现
06-01
TDD周期TDD推荐的周期有五个阶段： 1. écrire un premier test ;2. vérifier qu'il échoue (car le code qu'il teste n'existe pas), afin de vérifier que le test est valide ;3. écrire juste le code ...
TDD测试驱动开发
02-15
TDD 测试驱动开发 测试驱动开发的艺术 Lasse Koskela 带目录结构
flaskr-tdd：Flaskr：Flask，测试驱动开发（TDD）和JavaScript简介
02-05
无论如何，我想通过添加测试驱动开发（TDD），一些JavaScript和部署使本教程更进一步。 这篇文章就是该教程。 请享用。 另外，如果您一般不熟悉Flask和/或Web开发，那么掌握以下基本概念很重要： GET和POST请求...
测试驱动开发（TDD）入门
03-23
测试驱动开发，英文全称Test-DrivenDevelopment（简称TDD），是由KentBeck先生在极限编程（XP）中倡导的开发方法。以其倡导先写测试程序，然后编码实现其功能得名。本文不打算扯过多 测试驱动开发（TDD）入门 测试...
golang数组与切片
qq_34814562的博客
04-22 140
数组 切片 数组 固定长度的特定类型元素组成的序列，与c语言区别，golang中的数组是值类型的. func main () { arr := [2]int{1, 2} passArr(arr) fmt.Println(arr[0], " ", arr[1]) } func passArr(arr [2]int) { arr[0] = 10 fmt.Println(arr[0], " ", arr[1]) } 值传递，在子方法中修改数组，不会影响原数组的数据。copy副本的..
go int 最大值_深挖Go系列之灵活的slice
weixin_32172693的博客
11-28 200
Dig101: dig more, simplified more and know moreSlice 作为 go 常用的数据类型，在日常编码中非常常见。相对于数组的定长不可变，slice 使用起来就灵活了许多。文章目录0x01 slice 到底是什么？0x02 slice 能比较么？0x03 花样的切片操作0x04 append 时发生了什么？0x05 append 内部优化扩容的策...
《Go语言学习笔记》 - 第五章 - 切片
来自东印度的人
05-07 330
3. 切片 3.1 切片的概念 Go语言中切片是对数组的抽象，切片（Slice）是一个拥有相同类型元素的可变长度的序列。它是基于数组类型做的一层封装。它非常灵活，支持自动扩容。 3.2 切片的操作 3.2.1 切片的创建 切片的创建与数组有所不同，切片是引用类型，它的创建需要用到内置函数 make ，函数make 接受一个类型、一个长度和一个可选的容量参数。调用 make 时，内部会分配一个数组，...
[Golang]也许有你不知道的，Array和Slice(2)
Sunface撩技术
03-06 2249
这文章分为三部分，第一、二部分分别详细讲述golang中的array与slice，第三部分则讨论slice的使用与技巧。这文章不是教程，需要基本的golang知识。    关于第一、二部分，这里有一篇文章比我叙述得更好（自备爬梯）：http://blog.golang.org/go-slices-usage-and-internals    看过这文章的朋友可以直接忽略此文一二部分。
Golang中的array与slice（2）
7
08-28 9976
这文章分为三部分，第一、二部分分别详细讲述golang中的array与slice，第三部分则讨论slice的使用与技巧。这文章不是教程，需要基本的golang知识。     关于第一、二部分，这里有一篇文章比我叙述得更好（自备爬梯）：http://blog.golang.org/go-slices-usage-and-internals     看过这文章的朋友可以直接忽略此文一二部分。
Go 学习笔记（28）— nil（nil 不能比较、不是关键字或保留字、nil 没有默认类型、不同类型的 nil 指针是一样的、不同类型的 nil 是不能比较的、相同类型的 nil 可能也无法比较）
wohu1104的专栏
05-08 1437
在 Go 语言中，布尔类型的零值（初始值）为 false ，数值类型的零值为 0，字符串类型的零值为空字符串 ""，而指针、切片、映射、通道、函数和接口的零值则是 nil 。 nil 是 Go 语言中一个预定义好的标识符，有过其他编程语言开发经验的开发者也许会把 nil 看作其他语言中的 null （ NULL ），其实这并不是完全正确的，因为 Go 语言中的 nil 和其他语言中的 nul...
go slice 类型用法
u011714033的博客
05-05 477
[//注释] <> (go 切片用法) 字面量 make() append() copy() range len() cap() nil == 例子 package main import ( "fmt" ) func main() { //字面量 var s0 []int //s0: nil var s1 = []int{0, 1, 2} //...
TDD测试驱动开发技术
最新发布
04-20
TDD是测试驱动开发的缩写，是一种敏捷软件开发的方法论。TDD的基本思想是先写一个单元测试，然后编写生产代码，使其通过这个测试。这样一来，我们就可以保证生产代码一定是可测试的、可维护的。同时，TDD也可以帮助...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值