乐趣区

关于go:你可能还不知道-golang-的高效编码细节

jiezi

xdm，咱们都晓得 golang 是天生的高并发，高效的编译型语言

可咱们也都可晓得，工具再好，用法不对，全都徒劳，咱们来举 2 个罕用门路来感受一下

struct 和 map 用谁呢？

计算量很小的时候，可能看不出应用 长期 struct 和 map 的耗时差距，然而数量起来了，差距就显著了，且会随着数量越大，差距越发显著

当咱们遇到键和值都能够是固定的时候，咱们抉择 struct 比 抉择 map 的形式 高效多了

  • 咱们模仿循环计算 1 亿 次，看看应用各自的数据结构会耗时多少
  • 循环前计算一下以后工夫
  • 循环后计算一下以后工夫
  • 最初计算两个工夫的差值，此处咱们应用 毫秒为单位
func main() {t1 :=time.Now().UnixNano()/1e6
    for i := 0; i < 100000000; i++ {
        var test struct {
            Name  string
            hobby string
        }
        test.Name = "xiaomotong"
        test.hobby = "program"
    }
    t2 :=time.Now().UnixNano()/1e6
    fmt.Println("t2 - t1 ==", t2-t1)
}

程序运行查看成果：

# go run main.go
t1 ==  1634377149185
t2 ==  1634377149221
t2 - t1 ==  36

应用 struct 的形式，耗时 36 ms，大家感觉这个工夫如何？

咱们一起来看看应用 map 的形式吧

func main() {t1 :=time.Now().UnixNano()/1e6
    fmt.Println("t1 ==", t1)

    for i := 0; i < 100000000; i++ {var test = map[string]interface{}{}
        test["name"] = "xiaomotong"
        test["hobby"] = "program"
    }
    t2 :=time.Now().UnixNano()/1e6
    fmt.Println("t2 ==", t2)
    fmt.Println("t2 - t1 ==", t2-t1)
}

程序运行查看成果：

# go run main.go
t1 ==  1634377365927
t2 ==  1634377373525
t2 - t1 ==  7598

应用 struct 的形式，耗时 7598 ms

应用 map 和 应用 struct 的形式，实现同样数据处理，耗时相差 212 倍 ，就这，咱们平时编码的时候， 对于上述的场景，你会抉择哪种数据结构呢？

为什么上述差距会那么大，起因是

在咱们能够确定字段的状况下，咱们应用 长期的 Struct 在运行期间是不须要动态分配内容的，

可是 map 就不一样，map 还要去查看索引，这一点就十分耗时了

字符串如何拼接是好？

工作中编码 xdm 遇到字符串拼接的状况，都是如何实现的呢？咱们的工具临时提供如下几种：

  • 应用 + 的形式
  • 应用 fmt.Sprintf() 的形式
  • 应用 strings.Join 的形式
  • 应用 buffer 的形式

看到这里，兴许咱们各有各的答案，不过咱们还是来实操一遍，看看他们在雷同字符串拼接状况下，各自的解决耗时如何

用 + 的形式

  • 咱们来计算循环追加 50 万 次字符串，看看耗时多少
func main() {t1 := time.Now().UnixNano() / 1e6
    fmt.Println("t1 ==", t1)

    s := "xiao"
    for i := 0; i < 500000; i++ {s += "motong"}

    t2 := time.Now().UnixNano() / 1e6
    fmt.Println("t2 ==", t2)
    fmt.Println("t2 - t1 ==", t2-t1)
}

程序运行查看成果：

# go run main.go
t1 ==  1634378595642
t2 ==  1634378743119
t2 - t1 ==  147477

看到这个数据 xdm 有没有惊呆了，竟然这么慢，耗时 147477 ms 那可是妥妥的 2 分 27 秒 呀

Go 语言 中应用 + 解决字符串是很耗费性能的，通过数据咱们就可以看进去

应用 fmt.Sprintf() 的形式

func main() {t1 := time.Now().UnixNano() / 1e6
    fmt.Println("t1 ==", t1)

    s := "xiao"
    for i := 0; i < 500000; i++ {s = fmt.Sprintf("%s%s",s,"motong")
    }

    t2 := time.Now().UnixNano() / 1e6
    fmt.Println("t2 ==", t2)
    fmt.Println("t2 - t1 ==", t2-t1)
}

程序运行查看成果：

# go run main.go
t1 ==  1634378977361
t2 ==  1634379240292
t2 - t1 ==  262931

看到这个数据，咱们也惊呆了，竟然耗时 262931 ms，共计 4 分 22 秒，xdm 是不是没有想到 应用 fmt.Sprintf 比 应用 + 还慢

应用 strings.Join 的形式

func main() {t1 := time.Now().UnixNano() / 1e6
   fmt.Println("t1 ==", t1)

   s := []string{}
   s = append(s,"xiao")
   for i := 0; i < 500000; i++ {s = append(s ,"motong")
   }
   strings.Join(s,"")

   t2 := time.Now().UnixNano() / 1e6
   fmt.Println("t2 ==", t2)
   fmt.Println("t2 - t1 ==", t2-t1)
}

程序运行查看成果：

# go run main.go
t1 ==  1634570001216
t2 ==  1634570001294
t2 - t1 ==  78

耗时 142923 ms，共计 78 ms

应用 buffer 的形式

应用 buffer 的形式 应该说是最好的形式，

func main() {t1 := time.Now().UnixNano() / 1e6
    fmt.Println("t1 ==", t1)

    s := bytes.NewBufferString("xiao")
    for i := 0; i < 500000; i++ {s.WriteString("motong")
    }

    t2 := time.Now().UnixNano() / 1e6
    fmt.Println("t2 ==", t2)
    fmt.Println("t2 - t1 ==", t2-t1)
}
# go run main.go
t1 ==  1634378506021
t2 ==  1634378506030
t2 - t1 ==  9

通过下面的数据，咱们看到，拼接同样 50 万次的数据

  • 第一种，应用 + 的形式，须要 147477 ms
  • 第二种，应用 fmt.Sprintf() 的形式，须要 262931 ms
  • 第三种，应用 strings.Join 的形式，须要 78 ms
  • 第四种，应用 buffer 的形式，须要 9ms

应用 buffer 的形式 是 第一种的 16,386 倍，是第二种的 29,214 倍，是第三种的 8 倍多

xdm，如果是遇到下面的场景，你会抉择应用哪一种形式呢，评论区能够一起讨论一下，是否还有更高效的形式

欢送点赞，关注，珍藏

敌人们，你的反对和激励，是我保持分享，提高质量的能源

好了，本次就到这里

技术是凋谢的，咱们的心态，更应是凋谢的。拥抱变动，背阴而生，致力向前行。

我是 阿兵云原生，欢送点赞关注珍藏，下次见~

退出移动版