手把手教你写go单元测试

最新推荐文章于 2024-05-15 12:38:59 发布
最新推荐文章于 2024-05-15 12:38:59 发布
阅读量985 收藏 18
点赞数 9
分类专栏： go语言 文章标签： golang 单元测试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vpertj/article/details/137194409
版权

什么是单元测试

​ 在 Go 语言中，单元测试是一种测试方法，用于验证代码的某个独立单元是否按预期功能，它的目的是确保代码的每个组成部分都在独立测试的情况下运行正常。

​ 在我们对项目新增一个新功能时，最好就要养成写单元测试的好习惯，这样可以有助于提高我们代码的质量、可维护性和可靠性。

​ 在 Go 中，单元测试的约定是使用标准库中的 testing 包。测试文件通常以 _test.go 为后缀，然后我们使用 go test ... 配合一些参数去进行测试，Go 测试工具会自动识别并运行这些文件中那点测试样例。

go test 的两种模式
1. 本地模式：执行当前目录下的所有测试用例

​ go test

2. 列表模式：输入一个或多个目录，执行这些目录下的测试用例

​ go test xx/xx

怎么写单元测试

​ 首先，要写单元测试，那么肯定需要一个功能函数。这里我们借用一下之前文章内存缓存系统中使用到的一个功能函数 ParseSize ，它的功能是将用户的输入内存大小，转换为字节数和对应的字符串表示形式，其中还会涉及到一些输入不合法的处理，

​ 本文讲的是如何写单元测试，这里 ParseSize 的源码就直接给大家了，如下：

package util

import (
    "regexp"
    "strconv"
    "strings"
    "time"
)

const (
    B = 1 << (iota * 10)
    KB
    MB
    GB
    TB
    PB
)

const defaultNum = 100

func ParseSize(size string) (int64, string) {
    time.Sleep(time.Nanosecond * 500)

    re, _ := regexp.Compile("[0-9]+")
    unit := string(re.ReplaceAll([]byte(size), []byte("")))
    num, _ := strconv.ParseInt(strings.Replace(size, unit, "", 1), 10, 64)
    unit = strings.ToUpper(unit)

    var byteNum int64 = 0
    switch unit {
    case "B":
        byteNum = num
    case "KB":
        byteNum = num * KB
    case "MB":
        byteNum = num * MB
    case "GB":
        byteNum = num * GB
    case "TB":
        byteNum = num * TB
    case "PB":
        byteNum = num * PB
    default:
        num = 0
    }

    if num == 0 {
        num = 100
        byteNum = num * MB
        unit = "MB"
    }

    sizeStr := strconv.FormatInt(num, 10) + unit
    return byteNum, sizeStr
}

 在项目根目录下创建 util 目录，然后创建 util.go 文件，将上面的代码粘贴进去就行了。

​ 强调一点，上面的 ParseSize 函数的开头，我加了一个睡眠函数，是因为我们的 ParseSize 函数的处理逻辑比较简单，怕执行太快，进行测试时显示时间为 0 ，所以加了个睡眠延迟一点时间，模拟一些比较耗时功能函数。

准备工作

​ 同样，我们先在 util 包下创建 util_test.go 文件。在写单元测试的时候，我们通常有两种方法，一种是在测试函数里面构建匿名结构体来组织数据，另一种就是在提前构建数据。前者就是将构建数据的逻辑写在测试函数里，这里不多做介绍，我们要着重讲的是第二种。

​ 为了方便，我们先定义一个结构体，并将其实例化，用于存放我们的数据：

// 所有的测试用例放在这里头
var commTestData []commStruct

type commStruct struct {
    Group         string // 所属类别
    SizeStr       string // 输入大小
    ExpectSize    int64  // 预期输出大小
    ExpectSizeStr string // 预期输出大小字符串类型
}
  • Group：这个是用于子测试时分类的依据，关于子测试后面会提到，这里先不理会。
  • SizeStr：是对应于我们的 ParseSize 功能函数的输入
  • ExpectSize、ExpectSizeStr：对应于我们的 ParseSize 功能函数的输出

​ 在单元测试中，也有一个 func TestMain(m *testing.M)入口函数，功能和用法于平时我们使用的 main 类似。我们可以在这里面为单元测试做一些准备工作，但需要注意的是：如果我们没有写 TestMain 函数，那么测试工具会直接调用我们的测试函数，但如果我们写了 TestMain 函数，就需要在 TestMain 中通过 m.Run() 显示地调用测试用例：

// 测试用例的入口函数：可以为测试做一些准备工作
func TestMain(m *testing.M) {
    initCommonData()
    m.Run() // 执行测试用例
}

func initCommonData() {
    commTestData = []commStruct{
        {"B", "1b", B, "1B"},
        {"B", "100b", 100 * B, "100B"},
        {"KB", "1kb", KB, "1KB"},
        {"KB", "100KB", 100 * KB, "100KB"},
        {"MB", "1Mb", MB, "1MB"},
        {"GB", "10Gb", 10 * GB, "10GB"},
        {"TB", "1tb", TB, "1TB"},
        {"PB", "10PB", 10 * PB, "10PB"},
        {"unknown", "1G", 100 * MB, "100MB"},
    }
}

上面我们通过 TestMain 函数，提前构建好了测试所需要的数据，避免在不同的测试函数中重复构建测试用例。

功能测试

​ 功能测试是一种验证代码是否按照规范和需求进行工作的测试，它关注于测试单个函数或方法的功能是否正确，以确保其符合预期的行为。

​ 根据它的定义，我们就大概知道该怎么写我们的功能测试了。首先功能测试的函数签名是这样的 func TestFunctionName(t *testing.T)。我们直接在函数里面写逻辑即可，因为有很多组测试样例，所以我们肯定要用 for 循环将所有的样例拿出来，然后一一进行验证，验证的过程就是将该样例的输入拿出来执行一遍功能函数，然后将结果与我们的样例预期结果进行比对即可，如下：

// 功能测试
func TestParseSize(t *testing.T) {
    testData := commTestData
    for _, data := range testData {
        size, sizeStr := ParseSize(data.SizeStr)
        if size != data.ExpectSize || sizeStr != data.ExpectSizeStr {
            t.Errorf("测试结果不符合预期：%+v", data)
        }
    }
}

​ 这样我们就写好了一个具备基本功能的功能测试代码了。我们可以通过命令 go test -v 去执行，输出如下：

$  go test -v
=== RUN   TestParseSize
--- PASS: TestParseSize (0.14s)
PASS
ok      main/util       0.178s

​ 我们一起来看看这个输出：

  1. === RUN TestParseSize：表示正在运行名为 TestParseSize 的测试函数。
  2. --- PASS: TestParseSize (0.14s)：表示测试函数 TestParseSize 成功通过，用时 0.14 秒。PASS 表示测试通过，FAIL 则表示测试失败。
  3. PASS：表示整个测试过程中没有发现错误，所有的测试函数都成功通过。
  4. ok main/util 0.178s：表示测试包 main/util 成功通过，总用时为 0.178 秒。

​ 下面我们再来看看功能测试的子测试。

​ 功能测试的子测试，又可以叫做并发测试，我们可以利用它来加快测试的效率。我们下面以测试样例中的单位，即 group 字段来将测试样例分个组：

testData := make(map[string][]commStruct)
for _, item := range commTestData {
    group := item.Group
    _, ok := testData[group]
    if !ok {
        testData[group] = make([]commStruct, 0)
    }
    testData[group] = append(testData[group], item)
}

​ 有了数据，其实我们的子测试，就相当于对不同组别分别去进行测试。

​ 所以首先要用一个 for 循环拿出不同组别的数据，去分别运行，然后在每个组别运行时，去拿出对应组别的数据去做验证即可，代码如下：

func TestParseSizeSub(t *testing.T) {
    if testing.Short() {
        t.Skip("跳过测试用例 TestParseSizeSub")
    }

    // 按照 group 分个组
    testData := make(map[string][]commStruct)
    for _, item := range commTestData {
        group := item.Group
        _, ok := testData[group]
        if !ok {
            testData[group] = make([]commStruct, 0)
        }
        testData[group] = append(testData[group], item)
    }

    // 分组去测试 测试数据
    for k, _ := range testData {
        t.Run(k, func(t *testing.T) {
            // 下面的子测试样例就会去并行执行：通过睡眠可以看出效果
            t.Parallel()
            for _, data := range testData[k] {
                size, sizeStr := ParseSize(data.SizeStr)
                if size != data.ExpectSize || sizeStr != data.ExpectSizeStr {
                    t.Errorf("测试结果不符合预期：%+v", data)
                }
            }
        })
    }
}

​ 细心的小伙伴一定看到了上面有两个点是我们没讲的：

  1. if testing.Short() 这个是做什么的呢？还记得我们上面介绍参数的时候说过吗，这个参数是用来避免一些不必要的测试的，所以如果我们的测试不需要，就可以使用 short 参数跳过这个子测试。
  2. t.Parallel() 这个就是我们子测试并行测试的关键了，只有加了这行代码，我们的子测试才能进行并行测试。

​ 下面带大家看看t.Parallel() 是不是真的有效果，我们在子测试代码中加入一个睡眠时间，先把 t.Parallel() 注释掉：

for k, _ := range testData {
    t.Run(k, func(t *testing.T) {
        //t.Parallel()
        for _, data := range testData[k] {
            time.Sleep(time.Second)
            size, sizeStr := ParseSize(data.SizeStr)
            if size != data.ExpectSize || sizeStr != data.ExpectSizeStr {
                t.Errorf("测试结果不符合预期：%+v", data)
            }
        }
    })
}

​ 然后执行命令 go test -v，可以观察到子测试的样例每隔一秒才执行一次，最终耗时 9.367 秒。

$  go test -v
=== RUN   TestParseSize
--- PASS: TestParseSize (0.10s)
=== RUN   TestParseSizeSub
=== RUN   TestParseSizeSub/KB
=== RUN   TestParseSizeSub/MB
=== RUN   TestParseSizeSub/GB
=== RUN   TestParseSizeSub/TB
=== RUN   TestParseSizeSub/PB
=== RUN   TestParseSizeSub/unknown
=== RUN   TestParseSizeSub/B
--- PASS: TestParseSizeSub (9.22s)            
    --- PASS: TestParseSizeSub/KB (2.05s)     
    --- PASS: TestParseSizeSub/MB (1.02s)     
    --- PASS: TestParseSizeSub/GB (1.02s)     
    --- PASS: TestParseSizeSub/TB (1.03s)     
    --- PASS: TestParseSizeSub/PB (1.03s)     
    --- PASS: TestParseSizeSub/unknown (1.03s)
    --- PASS: TestParseSizeSub/B (2.04s)      
PASS
ok      main/util       9.367s

​ 我们再把 t.Parallel() 的注释去掉，再执行 go test -v 观察一下：

$  go test -v
=== RUN   TestParseSize
--- PASS: TestParseSize (0.14s)
=== RUN   TestParseSizeSub
=== RUN   TestParseSizeSub/unknown
=== PAUSE TestParseSizeSub/unknown
=== RUN   TestParseSizeSub/B
=== PAUSE TestParseSizeSub/B
=== RUN   TestParseSizeSub/KB
=== PAUSE TestParseSizeSub/KB
=== RUN   TestParseSizeSub/MB
=== PAUSE TestParseSizeSub/MB
=== RUN   TestParseSizeSub/GB
=== PAUSE TestParseSizeSub/GB
=== RUN   TestParseSizeSub/TB
=== PAUSE TestParseSizeSub/TB
=== RUN   TestParseSizeSub/PB
=== PAUSE TestParseSizeSub/PB
=== CONT  TestParseSizeSub/unknown
=== CONT  TestParseSizeSub/GB
=== CONT  TestParseSizeSub/PB
=== CONT  TestParseSizeSub/TB
=== CONT  TestParseSizeSub/KB
=== CONT  TestParseSizeSub/MB
=== CONT  TestParseSizeSub/B
--- PASS: TestParseSizeSub (0.00s)
    --- PASS: TestParseSizeSub/TB (1.03s)
    --- PASS: TestParseSizeSub/B (1.03s)
    --- PASS: TestParseSizeSub/MB (1.03s)
    --- PASS: TestParseSizeSub/PB (1.03s)
    --- PASS: TestParseSizeSub/KB (1.03s)
    --- PASS: TestParseSizeSub/unknown (1.03s)
    --- PASS: TestParseSizeSub/GB (1.03s)
PASS
ok      main/util       1.210s

​ 会发现子测试几乎是同时打印出来的信息，最终耗时 1.120s，这就验证了 t.Parallel() 的作用，也同时验证了功能测试的子测试的作用。

模糊测试

​ 模糊测试是一种随机生成输入数据并将其提供给函数或程序的测试方法，它可以帮助发现潜在的边界情况和异常输入，以检测代码的鲁棒性。

​ 也就是说，模式测试本质上也是功能测试，只不过模糊测试的输入不再是我们提前构建好的数据，而是测试工具根据我们传入的参数类型去帮我们构建各种输入，以此来检测我们的功能函数在这种随机构造的输入情况下，是否还能照常工作。模糊测试的函数签名是func FuzzFunctionName(f *testing.F) {}，如下：

func FuzzParseSize(f *testing.F) {
    // 也就是说，模糊测试，本质上也是一个功能测试。
    // 只是输入的内容不再是 data，而是所谓的 a
    f.Fuzz(func(t *testing.T, a string) {
        size, sizeStr := ParseSize(a)
        if size == 0 || sizeStr == "" {
            t.Errorf("输入异常，导致 parsesize 没拿到正确结果")
        }
    })
}

​ 然后我们可以通过 go test -fuzz FuzzParseSize 命令开启模糊测试，输出如下：

go test -fuzz FuzzParseSize
warning: starting with empty corpus
fuzz: elapsed: 0s, execs: 0 (0/sec), new interesting: 0 (total: 0)
fuzz: elapsed: 3s, execs: 614 (205/sec), new interesting: 7 (total: 7)
fuzz: elapsed: 6s, execs: 4210 (1194/sec), new interesting: 22 (total: 22)
fuzz: elapsed: 9s, execs: 5579 (456/sec), new interesting: 26 (total: 26)
fuzz: elapsed: 12s, execs: 9227 (1221/sec), new interesting: 35 (total: 35)
fuzz: elapsed: 15s, execs: 14480 (1744/sec), new interesting: 44 (total: 44)
fuzz: elapsed: 18s, execs: 16198 (572/sec), new interesting: 49 (total: 49)
......
  1. warning: starting with empty corpus：这是一个警告，表示开始时模糊测试的语料库（corpus）是空的。语料库是用来保存历史模式测试时，出现错误的样例。
  2. elapsed：经过的时间
  3. execs：执行的测试次数（平均每秒执行多少次）
  4. new interesting：新增的随机测试输入个数
  5. total：本次测试的的输入样例个数

​ 运行模糊测试，你会发现根本不会停，只能主动去停止，这也是为什么模糊测试只能同时测试的原因。

​ 还有就是上面提到的预料库，在运行模糊测试时，如果出现了预期之外的错误，那就会将这个样例保存到语料库中，并且在之后每次的模糊测试都会去运行这些出错的样例。语料库也是保存在本地的，会在根目录下生成一个对应的文件去存放。

性能测试

​ 最后我们再来看看性能测试，在进行性能测试之前，我们需要先将 ParseSize 函数中的睡眠函数关掉，避免影响我们的性能测试。因为Sleep() 不仅会让程序睡眠，还会做一些其他处理，会对我们的性能测试产生不小的影响。

​ 待会我们也可以做一个测试，然后进行一个对比。

​ 性能测试写起来条条框框会比较多，它的函数签名是这样的 func BenchmarkFunctionName(b *testing.B) {}我们啥也先不管，先来个 for 循环，然后直接调用我们的 ParseSize 函数：

func BenchmarkParseSize(b *testing.B) {
    for i := 0; i < b.N; i++ {
        ParseSize("1MB")
    }
}

​ 这样，一个简易的性能测试就写完了，我们可以用 go test -bench BenchmarkParseSize，这里先不注释 ParseSize 中的睡眠函数，我们看看效果：

go test -bench BenchmarkParseSize
goos: windows
goarch: amd64
pkg: main/util
cpu: AMD Ryzen 7 4800H with Radeon Graphics
BenchmarkParseSize-16                100          15301008 ns/op
BenchmarkParseSizeSub/B-16           100          14830110 ns/op
BenchmarkParseSizeSub/KB-16          100          15324944 ns/op
BenchmarkParseSizeSub/MB-16          100          15445510 ns/op
BenchmarkParseSizeSub/GB-16          100          14851633 ns/op
BenchmarkParseSizeSub/TB-16          100          15136910 ns/op
BenchmarkParseSizeSub/PB-16          100          15281375 ns/op
BenchmarkParseSizeSub/unknown-16                     100          15188822 ns/op
PASS
ok      main/util       22.495s

​ 再将睡眠函数注释掉，运行同样的命令，看看效果：

go test -bench BenchmarkParseSize                                    
goos: windows
goarch: amd64                                       
pkg: main/util                                      
cpu: AMD Ryzen 7 4800H with Radeon Graphics         
BenchmarkParseSize-16             735984              1603 ns/op
BenchmarkParseSizeSub/B-16        704841              1616 ns/op
BenchmarkParseSizeSub/KB-16       750050              1630 ns/op
BenchmarkParseSizeSub/MB-16       748998              1647 ns/op
BenchmarkParseSizeSub/GB-16       635871              1689 ns/op
BenchmarkParseSizeSub/TB-16       769012              1639 ns/op
BenchmarkParseSizeSub/PB-16       748689              1642 ns/op
BenchmarkParseSizeSub/unknown-16                  770593              1620 ns/op
PASS
ok      main/util       19.901s

​ 我们先来解释一下各个参数代表什么：

  1. goos: windows 和 goarch: amd64：表示你的操作系统和体系结构。
  2. pkg: main/util：表示正在测试的 Go 包的路径。
  3. cpu: AMD Ryzen 7 4800H with Radeon Graphics：表示你的 CPU 信息。
  4. BenchmarkParseSize-16 735984 1603 ns/op：表示运行了 735984 次，平均每次耗时 1603 纳秒
  5. PASS：表示所有的性能测试都通过
  6. ok main/util 19.901s：表示整个测试过程消耗了 19.901 秒。

​ 可以很明显的看到，这里两次测试的平均每次迭代耗时差了很多个数量级，但算上我们的睡眠时间 time.Sleep(time.Nanosecond * 500)，也就 500 ns 而已。之所以会这样是因为 time.Sleep 函数的调用对于测试的结果会产生较大的影响，特别是在精度较高的情况，比如我们这里的纳米级别。 time.Sleep 会导致当前 goroutine 挂起，等待指定的时间再继续执行。在测试中，这样的挂起会导致每次迭代的耗时相对较大，从而影响性能测试的结果。

​ 可能会有人好奇，为什么平均时长差了很多，但是总耗时却差不多。因为在 Go 语言的性能测试中，每个子测试的迭代次数数由测试框架自动决定的，它会根据自己执行时间的变化动态调整迭代次数，以保证测试结果的稳定性和可靠性。我们也可以自己使用 -benchtime t 参数来配置自己想要的运行次数和时间。

​ 下面我们再来看看说说性能测试的子测试。

​ 性能测试的子测试，其实没有啥明确的使用场景，我们下面所举的例子，也只是为了写性能测试子测试而写子测试，能够使用的场景也就是需要分组归类去测试的数据，比如 B、KB、MB 等相同单位的一组去测试。

​ 这样做的好处是啥？有人肯定会觉得，可以像功能测试那样做并行测试。

​ 答案是否定的，性能测试的子测试没有并行机制。我个人觉得这样的好处就是，可以指定只执行对应分组的测试用例，比如我们只需要对某一个单位的大小进行特殊处理，就可以只去执行对应分组的测试用例了。

​ 然后我们来看看怎么写，同样的，需要先对我们的测试样例进行分组，然后在用 for 对不同组别的测试样例分别去运行性能测试函数：

func BenchmarkParseSizeSub(b *testing.B) {
    testData := make(map[string][]commStruct)
    for _, item := range commTestData {
        group := item.Group
        _, ok := testData[group]
        if !ok {
            testData[group] = make([]commStruct, 0)
        }
        testData[group] = append(testData[group], item)
    }

    for k, _ := range testData {
        b.Run(k, func(b *testing.B) {
            for i := 0; i < b.N; i++ {
                ParseSize(testData[k][0].SizeStr)
            }
        })
    }
}

​ 上面代码需要知道的一点，就是在每次运行 b.Run() 的时候，for 循环里的测试次数是测试工具自动决定的，我们只需要调用就可以了。

​ 上面就差不多是性能测试的基本写法了，只不过在一些情况下，比如我们在每次测试时需要去进行一下其他的数据准备，如果不进行一些处理，这些准备数据的时间就可能会导致我们的性能测试偏差较大：

for k, _ := range testData {
    b.Run(k, func(b *testing.B) {
        // case1
        preBenchmark()
        for i := 0; i < b.N; i++ {
            // case2
            preBenchmark1()
            ParseSize(testData[k][0].SizeStr)
        }
    })
}

func preBenchmark1() {
    time.Sleep(10 * time.Second)
}

func preBenchmark2() {
    time.Sleep(time.Nanosecond * 500)
}

​ 在上述代码中，我们通过 preBenchmark1 和 preBenchmark2 函数模拟了准备数据等其他操作的耗时，这里就直接告诉大家解决的方法了：

  • 对于 case1：可以在数据准备完成后，使用b.ResetTimer() 重置计时器
  • 对于case2：可以在准备数据前使用 b.StopTimer() 将计时器暂停，然后在准备好数据后，重新启动计时器 b.StartTimer()，这样就可以减小误差。
for k, _ := range testData {
    b.Run(k, func(b *testing.B) {
        // for 循环外，可以通过 b.ResetTimer() 来重置
        preBenchmark1()
        b.ResetTimer()
        for i := 0; i < b.N; i++ {
            // for 循环内，可以通过 b.StopTimer() 和 b.StartTimer() 配合使用，来跳过我们不想统计的耗时操作。迫不得已不要使用，测试速度慢
            b.StopTimer()
            preBenchmark2()
            b.StartTimer()
            ParseSize(testData[k][0].SizeStr)
        }
    })
}

​ 这里强调一点，上面的解决办法也只能减缓误差，并不能真正避免误差。并且如果你要测试上述代码的话，记得加上-benchtime 限制一下执行次数，否则会等很久。

道长来吃糖
关注
  • 9
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
手把手教你搭建数据驱动测试框架构
02-24
本文来自于testerhome，文章介绍了如何搭建基于SeleniumWebDriver的数据驱动测试框架的相关内容。在自动化测试框架中，数据驱动的意思指定的是测试用例或者说测试套件是由外部数据集合来驱动的框架。这里说的数据集...
​手把手教你如何进行 Golang 单元测试
腾讯技术工程
06-07 3241
作者：stevennzhou，腾讯 PCG 前端开发工程师本篇是对单元测试的一个总结，通过完整的单元测试手把手教学，能够让刚接触单元测试的开发者从整体上了解一个单元测试编写的全过程。最终通...
《分布式对象存储》作者手把手教你写 GO 语言单元测试！
u010042747的博客
01-23 319
第一部分：如何写Go语言单元测试 Go语言内建了单元测试（Unit Test）框架。这是为了从语言层面规范写UT的方式。 Go语言的命名规则会将以_test.go结尾的go文件视作单元测试代码。 当我们用go build构建可执行程序时，这些_test.go文件被排除在构建范围之外。 而当我们用go test来进行单元测试时，这些_test.go文件则会参与构建，且还会提供一个默认的TestMa...
手把手教你使用gtest写单元测试
qq_40989769的博客
05-09 2097
开源框架：gtest，它主要用于写单元测试，检查真自己的程序是否符合预期行为。这不是QA（测试工程师）才学的，也是每个优秀后端开发codoer的必备技能。
【项目】九万字手把手教你写高并发内存池（化简版tcmalloc）
You don't have the guts to be what you wanna be.
01-18 2722
本项目是对于tcmalloc简化之后所形成的版本，如果你找工作不确定做啥项目，可以考虑一下这个项目
手把手教你写一个微信小程序
02-24
现在微信小程序越来越火，用户不需下载安装app即可体验产品，产品推广和运营也比较方便，这些优点使得越来越多的企业选择开发微信小程序，所以会写小程序也成为前端比较重要的技能，今天就来教大家怎么入门微信小...
手把手教你写扩展卡尔曼滤波器.pdf
11-22
扩展卡尔曼滤波器的原理以及C语言实现
golang template: “xxx.html“ is an incomplete or empty template 解决方法
最新发布
05-15 105
这个异常一般是因为在使用 template.New("xxx.html") 时这里的名称非真实存在的视图文件名导致， 这个地方有点坑， 明明ParseFiles函数已经指定了视图路径了，而这里的New里面的名字居然还必须是你后面指定的视图路径中的文件名！
【GoLang基础】panic和recover有什么作用？
玦尘的博客
05-10 502
`panic` 和 `recover` 是 Go 语言中用于处理异常和错误的机制，能够帮助我们应对意外情况并使程序更加健壮。但在编写代码时，应该仔细考虑何时使用 `panic` 和 `recover`，避免滥用，以确保程序的可维护性和稳定性。
GO: json 处理
Big_YiFeng的博客
05-11 599
1、用interface{}需要注意， JSON 里的数字默认都会转成 Golang 的 float64 类型，字符是string,使用方式为。如果不想用结构体，怎么办，如api接收过来的参数，不确定json串里面有什么数据类型，可通过interface{}实现。2、golang 里json不是字符串而是 []byte类型，如果想用字符串可以用string()转。需要引入"encoding/json"包。
Go 语言IO操作(文件&文件内容增、删、改、查、复制。。。)
qq_39335595的博客
05-14 1016
O_RDONLY: 以只读方式打开文件。文件指针可定位于文件的任意位置。当尝试写入时，会返回错误。O_WRONLY: 以只写方式打开文件。即使文件已存在，它也会被截断为零长度，除非同时使用了O_APPEND标志。文件指针总是在文件的开始位置。O_RDWR: 以读写方式打开文件。文件指针可定位于文件的任意位置。同时具有读写能力。O_APPEND: 设置文件指针于文件末尾。所有写入操作都会在文件末尾添加数据，而不是覆盖现有内容。O_CREATE: 如果文件不存在，则创建一个新文件。与O_TRUNC。
golang中三种线程安全的MAP
tiancityycf的专栏
05-11 1807
123456789101112131415161718192021222324252627typestructmu Mutex// 基本上你可以把它看成一个安全的只读的map// 它包含的元素其实也是通过原子操作更新的，但是已删除的entry就需要加锁操作了// 包含需要加锁才能访问的元素// 包括所有在read字段中但未被expunged（删除）的元素以及新加的元素。
golang 反射能否获取到函数参数名字？
雁过留痕
05-11 483
Type是一个接口，函数类型是其中的一种实现，很可惜它没有提供 获取函数参数名字的方法；只能拿到函数参数的个数和参数的类型(Type)。Value，代表了一个变量的值。Type，代表了一总类型。
golang中switch-case及select-cas
iceggy的博客
05-13 220
select 的代码形式和 switch 非常相似， 不过 select 的 case 里的操作语句只能是【IO 操作】golang中case后自带break跳出功能，既：满足case b 执行内容b后自动跳出，不会去走case c。
GO 使用get请求数据
u010373106的博客
05-10 251
使用 Go 语言发送 GET 请求到第三方接口相对简单。你可以使用 Go 标准库中的。
Go语言数值类型教程
Pythonit教程网
05-13 352
Go语言提供了丰富的数值类型，包括整数类型、浮点类型和复数类型。每种类型都有其特定的用途和存储范围。下面将详细介绍这些类型，并附带示例代码。
【Go语言初探】（一）、Linux开发环境建立
weixin_43031313的博客
05-11 550
选择在Windows 11主机上运行的CentOS 7 Linux 虚拟机，虚拟化平台为VMWare Workstation.
c# 手把手教你写modbus
01-21
"c"是英文字母表中的第三个字母。它的发音是/ siː /。在大写形式下，它看起来像一个弯曲的拐杖。在语言上，"c"在不同的单词中可能有不同的发音和用法。 在英语中，"c"常常表示/k/音，例如在单词"cat"和"come"中。另外，它还可以表示/ s /音，如在单词"city"和"ceiling"中。有时，它与其他字母组合在一起形成特定的发音单元，如在"ch"、"ck"和"cqu"中。 "C"在数学中也有特定的用途。它表示罗马数字中的100，在罗马数字系统中是由大写的"C"表示的。此外，在代数中，"c"通常用来表示常数。 此外，"C"也是一种音乐记号，在西方音乐中代表"Do"音。它是一个非常重要的音符，代表着音阶的起始点。 "See"是一个与"C"相关的常见英语单词，意思是看。它常常被用来引导对某物的注意或解释，例如"See that bird over there?" 或者 "I see what you mean." 总而言之，“c"是一个在不同领域中被广泛使用的字母。无论是在语言、数学还是音乐中，都扮演着重要的角色，有着丰富的含义和用途。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

道长来吃糖

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值