我的Go+语言初体验——语法验证/性能测试篇（直男程序员的真实体验）

admin • • 程序人生

目录

前言

代码验证

格式转换操作（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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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 usn", 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的相关操作还有一定的优化空间。

如果本文对你有用的话，点个赞吧，谢谢！

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>