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

Posted 剑客阿良_ALiang

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了我的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的相关操作还有一定的优化空间。

如果本文对你有用的话,点个赞吧,谢谢!

以上是关于我的Go+语言初体验——语法验证/性能测试篇(直男程序员的真实体验)的主要内容,如果未能解决你的问题,请参考以下文章

我的Go+语言初体验——Go语言总结篇(语法+实际问题解决方案)

我的Go+语言初体验——Go+ 基本语法之 Switch

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习

我的Go+语言初体验——GoPlus基础语法学习