我的Go+语言初体验——语法验证/性能测试篇（直男程序员的真实体验）
目录
前言
代码验证
格式转换操作（go+、go性能对比）
循环操作（Go+、Go性能对比）
排序操作（Go+、Go性能对比）
List comprehension操作（Go+、Go性能对比）
Map键值对调操作（Go+、Go、Python性能对比）
Go+完整测试代码
Go语言完整代码
总结
前言
跟着我的上一个文章：我的Go+语言初体验——环境搭建篇（直男程序员的真实体验）_阿良的博客-CSDN博客
我对Go+语言的部分感兴趣的内容进行了代码实现以及性能测试。我说一下我为什么要测试性能的原因，因为我认为不管语法有多华丽，在语法足够好写的前提下，性能才是关键的指标。
代码验证
在代码验证之前，我先说明一下。Go+的环境以及ide我都部署好了，如果你还没有部署好的话，可以看我上一篇文章，里面有一些部署中的问题解决方法，可以参考。
格式转换操作（go+、go性能对比）
100万次格式转换（由int转为string）效率，代码Go+与Go一致。代码如下：
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test1() {
start := time.Now().UnixMicro()
num := 10
for i := 0; i < 1000000; i++ {
fmt.Sprintf("%d", num)
}
end := time.Now().UnixMicro()
fmt.Printf("格式转换操作 :%d us\n", end-start)
}go+效率截图：
go效率截图：
初步结论：在格式转换操作上，Go+与Go语言基本一致，没什么区别。
循环操作（Go+、Go性能对比）
100万个100以内随机数之和，代码Go+与Go一致。代码如下：
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test2() {
start := time.Now().UnixMicro()
num := 0
for i := 0; i < 1000000; i++ {
num = num + rand.Intn(100)
}
fmt.Println(num)
end := time.Now().UnixMicro()
fmt.Printf("循环操作 :%d us\n", end-start)
}go+效率截图：
go效率截图：
初步结论：在循环操作上，Go+与Go语言基本一致，没什么区别。
排序操作（Go+、Go性能对比）
100万随机数组排序，代码Go+与Go一致。代码如下：
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test3() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Int())
}
start := time.Now().UnixMicro()
sort.Ints(total_arr)
end := time.Now().UnixMicro()
fmt.Printf("排序操作 :%d us\n", end-start)
}go+效率截图：
go效率截图：
初步结论：在排序操作上，Go+与Go语言基本一致，没什么区别。
List comprehension操作（Go+、Go性能对比）
按照官网给出的语法说明，支持数组的链式写法，如下图：
按照同样的功能，我按照Go+语法与Go语法分别写了如下比较代码。功能均是100万100以内随机数组，生成对应2次方的数组。
Go+代码
package main
import (
"container/list"
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test5() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Intn(100))
}
fmt.Println(total_arr.Len())
start := time.Now().UnixMicro()
result_lis := [x*x for x <- total_arr]
end := time.Now().UnixMicro()
fmt.Printf("列表语法操作 :%d us\n", end-start)
fmt.Println(result_lis.Len())
}Go代码
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test5() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Intn(100))
}
fmt.Println(len(total_arr))
start := time.Now().UnixMicro()
result_arr := []int{}
for _, value := range total_arr {
result_arr = append(result_arr, value*value)
}
end := time.Now().UnixMicro()
fmt.Printf("列表语法操作 :%d us\n", end-start)
fmt.Println(len(result_arr))
}Go+语法效率
Go语法效率
初步结论：在使用列表语法后，性能有所下降。
Map键值对调操作（Go+、Go、Python性能对比）
同样是官网给出的语法优化，可以直接将map的键与值进行调换，如下图：
Go+代码
package main
import (
"container/list"
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test6() {
old_map := map[string]int{}
for i := 0; i < 1000000; i++ {
old_map["test"+strconv.Itoa(i)] = i
}
start := time.Now().UnixMicro()
reversedMap := {v: k for k, v <- old_map}
end := time.Now().UnixMicro()
fmt.Printf("map操作 :%d us\n", end-start)
fmt.Println(len(reversedMap))
}Go代码
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test6() {
old_map := map[string]int{}
for i := 0; i < 1000000; i++ {
old_map["test"+strconv.Itoa(i)] = i
}
start := time.Now().UnixMicro()
invMap := make(map[int]string, len(old_map))
for k, v := range old_map {
invMap[v] = k
}
end := time.Now().UnixMicro()
fmt.Printf("map操作 :%d us\n", end-start)
fmt.Println(len(invMap))
}Go+效率如下
Go效率如下
初步结论：当时看到这个数据我是很震惊的，后来于Go+团队沟通后了解到，差距这么大的主要原因在于我的Go代码中。在对invMap进行构建的时候，直接设置了Map的大小。而Go+语法是按照没有初始大小值操作的，也就是说多做了一遍遍历map取长度的操作导致的时间差距。所以我去掉了len(old_map)再执行了一遍。Go效率如下。
初步结论：的确这一次差距不在这么大，但是还是效率低了一点点。同时我也认为这部分语法可以进一步优化。这里也给出Python做相同数据量大小操作的性能情况。python的效率更高一些。
Go+完整测试代码
package main
import (
"container/list"
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test1() {
start := time.Now().UnixMicro()
num := 10
for i := 0; i < 1000000; i++ {
fmt.Sprintf("%d", num)
}
end := time.Now().UnixMicro()
fmt.Printf("格式转换操作 :%d us\n", end-start)
}
func test2() {
start := time.Now().UnixMicro()
num := 0
for i := 0; i < 1000000; i++ {
num = num + rand.Intn(200)
}
fmt.Println(num)
end := time.Now().UnixMicro()
fmt.Printf("循环操作 :%d us\n", end-start)
}
func test3() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Int())
}
start := time.Now().UnixMicro()
sort.Ints(total_arr)
end := time.Now().UnixMicro()
fmt.Printf("排序操作 :%d us\n", end-start)
}
//func test4() {
// rmap := foo.ReverseMap(map[string]int{"Hi": 1, "Hello": 2})
// fmt.Println(rmap)
//}
func test5() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Intn(100))
}
fmt.Println(total_arr.Len())
start := time.Now().UnixMicro()
result_lis := [x*x for x <- total_arr]
end := time.Now().UnixMicro()
fmt.Printf("列表语法操作 :%d us\n", end-start)
fmt.Println(result_lis.Len())
}
func test6() {
old_map := map[string]int{}
for i := 0; i < 1000000; i++ {
old_map["test"+strconv.Itoa(i)] = i
}
start := time.Now().UnixMicro()
reversedMap := {v: k for k, v <- old_map}
end := time.Now().UnixMicro()
fmt.Printf("map操作 :%d us\n", end-start)
fmt.Println(len(reversedMap))
}
func main() {
// test1()
// test2()
// test3()
//test4()
// test5()
test6()
}
Go语言完整代码
package main
import (
"fmt"
"strconv"
//"github.com/goplus/tutorial/14-Using-goplus-in-Go/foo"
"math/rand"
"sort"
"time"
)
func test1() {
start := time.Now().UnixMicro()
num := 10
for i := 0; i < 1000000; i++ {
fmt.Sprintf("%d", num)
}
end := time.Now().UnixMicro()
fmt.Printf("格式转换操作 :%d us\n", end-start)
}
func test2() {
start := time.Now().UnixMicro()
num := 0
for i := 0; i < 1000000; i++ {
num = num + rand.Intn(100)
}
fmt.Println(num)
end := time.Now().UnixMicro()
fmt.Printf("循环操作 :%d us\n", end-start)
}
func test3() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Int())
}
start := time.Now().UnixMicro()
sort.Ints(total_arr)
end := time.Now().UnixMicro()
fmt.Printf("排序操作 :%d us\n", end-start)
}
//func test4() {
// rmap := foo.ReverseMap(map[string]int{"Hi": 1, "Hello": 2})
// fmt.Println(rmap)
//}
func test5() {
total_arr := []int{}
for i := 0; i < 1000000; i++ {
total_arr = append(total_arr, rand.Intn(100))
}
fmt.Println(len(total_arr))
start := time.Now().UnixMicro()
result_arr := []int{}
for _, value := range total_arr {
result_arr = append(result_arr, value*value)
}
end := time.Now().UnixMicro()
fmt.Printf("列表语法操作 :%d us\n", end-start)
fmt.Println(len(result_arr))
}
func test6() {
old_map := map[string]int{}
for i := 0; i < 1000000; i++ {
old_map["test"+strconv.Itoa(i)] = i
}
start := time.Now().UnixMicro()
invMap := make(map[int]string, len(old_map))
for k, v := range old_map {
invMap[v] = k
}
end := time.Now().UnixMicro()
fmt.Printf("map操作 :%d us\n", end-start)
fmt.Println(len(invMap))
}
func main() {
//test1()
//test2()
//test3()
//test4()
//test5()
test6()
}
总结
目前测试的几个优化Go语言的语法，在使用中还是简化了许多的，只是代码性能还是有些许损耗的，但是不是很大。而Go语言代码在Go+中的使用性能基本没有损耗。其中还是要指出几个问题。
1）官网给出的可以在Go中直接使用Go+在github上的远程仓库代码进行直接编译，无法使用。经过和Go+团队的沟通，应该是给出的测试包已经迁移走了，无法使用。我本次测试没来得及上传Github自己的Go+包，所以无法评价是否可用。
2）关于Map的相关操作还有一定的优化空间。
如果本文对你有用的话，点个赞吧，谢谢！
