8种超简单的Golang生成随机字符串方式-低调大师

8种超简单的Golang生成随机字符串方式

2024-01-08 291

本文分享自华为云社区《Golang生成随机字符串的八种方式与性能测试》，作者：张俭。

前言

这是**icza**在StackOverflow上的一篇高赞回答，质量很高，翻译一下，大家一起学习

问题是：go语言中，有没有什么最快最简单的方法，用来生成只包含英文字母的随机字符串

icza给出了8个方案，最简单的方法并不是最快的方法，它们各有优劣，末尾附上性能测试结果：

1. Runes

比较简单的答案，声明一个rune数组，通过随机数选取rune字符，拼接成结果

package approach1

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func randStr(n int) string {
	b := make([]rune, n)
	for i := range b {
		b[i] = letters[rand.Intn(len(letters))]
	}
	return string(b)
}

func TestApproach1(t *testing.T) {
	rand.Seed(time.Now().UnixNano())
	fmt.Println(randStr(10))
}

func BenchmarkApproach1(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

2. Bytes

如果随机挑选的字符只包含英文字母，我们可以直接使用bytes，因为在UTF-8编码模式下，英文字符和Bytes是一对一的（Go正是使用UTF-8模式编码）

所以可以把

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

用这个替代

var letters = []byte("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

或者更好

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

现在我们有很大的进展了，我们把它变为了一个常数，在go里面，只有string常数，可并没有slice常数。额外的收获，表达式len(letters)也变为了一个常数（如果s为常数，那么len(s)也将是常数)

我们没有付出什么代码，现在letters可以通过下标访问其中的bytes了，这正是我们需要的。

package approach2

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randStr(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letters[rand.Intn(len(letters))]
	}
	return string(b)
}

func TestApproach2(t *testing.T) {
	rand.Seed(time.Now().UnixNano())

	fmt.Println(randStr(10))
}

func BenchmarkApproach2(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

3. Remainder 余数

上面的解决方法通过rand.Intn()来获得一个随机字母，这个方法底层调用了Rand.Intn()，然后调用了Rand.Int31n()

相比于生成63个随机bits的函数rand.Int63()来说，Rand.Int31n()很慢。

我们可以简单地调用rand.Int63()然后除以len(letterBytes)，使用它的余数来生成字母

package approach3

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

func randStr(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letters[rand.Int63() % int64(len(letters))]
	}
	return string(b)
}

func TestApproach3(t *testing.T) {
	rand.Seed(time.Now().UnixNano())

	fmt.Println(randStr(10))
}

func BenchmarkApproach3(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

这个算法能正常工作并且非常快，不过它牺牲了部分精确性，字母出现的概率并不是精确一样的（假设rand.Int63()生成63比特的数字是等概率的）。由于字母总共才52个，远小于 1<<63 - 1，因此失真非常小，因此实际上这完全没问题。

解释: 假设你想要0~5的随机数，如果使用3位的bit，3位的bit等概率出现0~7，所以出现0和1的概率是出现2、3、4概率的两倍。使用5位的 bit，0和1出现的概率是6/32，2、3、4出现的概率是5/32。现在接近了一些了，是吧？不断地增加比特位，这个差距就会变得越小，当你有63位地时候，这差别已经可忽略不计。

4. Masking 掩码

在上一个方案的基础上，我们通过仅使用随机数的最低n位保持均匀分布，n表示所有字符的数量。比如我们有52个字母，我们需要6位（52 = 110100b）。所以我们仅仅使用了rand.Int63()的最后6位。并且，为了保持所有字符的均匀分布，我们决定只接受在0..len(letterBytes)-1的数字即0~51。（译者注：这里已经没有第三个方案的不准确问题了）

最低几位大于等于len(letterBytes)的概率一般小于0.5（平均值为0.25），这意味着出现这种情况，只要重试就好。重试n次之后，我们仍然需要丢弃这个数字的概率远小于0.5的n次方（这是上界了，实际会低于这个值）。以本文的52个字母为例，最低6位需要丢弃的概率只有(64-52)/64=0.19。这意味着，重复10次，仍然没有数字的概率是1*10^-8。

package approach4

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

const (
	// 6 bits to represent a letters index
	letterIdBits = 6
	// All 1-bits as many as letterIdBits
	letterIdMask = 1 <<letterIdBits - 1
)

func randStr(n int) string {
	b := make([]byte, n)
	for i := range b {
		if idx := int(rand.Int63() & letterIdMask); idx < len(letters) {
			b[i] = letters[idx]
			i++
		}
	}
	return string(b)
}

func TestApproach4(t *testing.T) {
	rand.Seed(time.Now().UnixNano())

	fmt.Println(randStr(10))
}

func BenchmarkApproach4(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

5. Masking Improved

第4节的方案只使用了rand.Int63()方法返回的64个随机字节的后6位。这实在是太浪费了，因为rand.Int63()是我们算法中最耗时的部分了。

如果我们有52个字母，6位就能生成一个随机字符串。所以63个随机字节，可以利用63/6=10次。

译者注：使用了缓存，缓存了rand.Int63()方法返回的内容，使用10次，不过已经并不是协程安全的了。

package approach5

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

const (
	// 6 bits to represent a letter index
	letterIdBits = 6
	// All 1-bits as many as letterIdBits
	letterIdMask = 1<<letterIdBits - 1
	letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
	b := make([]byte, n)
	// A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
	for i, cache, remain := n-1, rand.Int63(), letterIdMax; i >= 0; {
		if remain == 0 {
			cache, remain = rand.Int63(), letterIdMax
		}
		if idx := int(cache & letterIdMask); idx < len(letters) {
			b[i] = letters[idx]
			i--
		}
		cache >>= letterIdBits
		remain--
	}
	return string(b)
}

func TestApproach5(t *testing.T) {
	rand.Seed(time.Now().UnixNano())

	fmt.Println(randStr(10))
}

func BenchmarkApproach5(b *testing.B) {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

6. Source

第5个方案非常好，能改进的点并不多。我们可以但不值得搞得很复杂。

让我们来找可以改进的点：随机数的生成源

crypto/rand的包提供了Read(b []byte)的函数，可以通过这个函数获得需要的随机比特数，只需要一次调用。不过并不能提升性能，因为crypto/rand实现了一个密码学上的安全伪随机数，所以速度比较慢。

所以让我们坚持使用math/rand包，rand.Rand使用rand.Source作为随机位的来源，rand.Source是一个声明了Int63() int64的接口：正是我们在最新解决方案中需要和使用的唯一方法。

所以我们不是真的需要rand.Rand，rand.Source包对于我们来说已经足够了

package approach6

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
	// 6 bits to represent a letter index
	letterIdBits = 6
	// All 1-bits as many as letterIdBits
	letterIdMask = 1<<letterIdBits - 1
	letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
	b := make([]byte, n)
	// A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
	for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdMax
		}
		if idx := int(cache & letterIdMask); idx < len(letters) {
			b[i] = letters[idx]
			i--
		}
		cache >>= letterIdBits
		remain--
	}
	return string(b)
}

func TestApproach6(t *testing.T) {
	fmt.Println(randStr(10))
}

func BenchmarkApproach6(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

注意到这里我们没有使用种子初始化rand了，取而代之的是初始化了rand.Source

还有一件需要注意的事，math/rand的文档指出

默认的Source是协程安全的

所以默认的Source比通过rand.NewSource()创建出来的Source要慢。不用处理协程并发场景，当然慢啦。

7. 使用 strings.Builder

之前的解决方案都返回了通过slice构造的字符串。最后的一次转换进行了一次拷贝，因为字符串是不可变的，如果转换的时候不进行拷贝，就无法保证转换完成之后，byte slice再被修改后，字符串仍能保持不变。

Go1.10引入了strings.Builder，这是一个新的类型，和bytes.Buffer类似，用来构造字符串。底层使用[]byte来构造内容，正是我们现在在做的，最后可以通过Builder.String()方法来获得最终的字符串值。但它很酷的地方在于，它无需执行刚才谈到的复制即可完成此操作。它敢这么做是因为它底层构造的[]byte从未暴露出来，所以仍然可以保证没有人可以无意地、恶意地来修改已经生成的不可变字符串。

所以我们的下一个想法不是在slice中构建随机字符串，而是使用 strings.Builder，结束building后，我们就可以获取并返回结果，而无需复制。这可能在速度方面有所帮助，并且在内存使用和分配方面肯定会有所帮助（译者注：等会在benchmark中会清晰地看到）。

package approach7

import (
	"fmt"
	"math/rand"
	"strings"
	"testing"
	"time"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
	// 6 bits to represent a letter index
	letterIdBits = 6
	// All 1-bits as many as letterIdBits
	letterIdMask = 1<<letterIdBits - 1
	letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
	sb := strings.Builder{}
	sb.Grow(n)
	// A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
	for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdMax
		}
		if idx := int(cache & letterIdMask); idx < len(letters) {
			sb.WriteByte(letters[idx])
			i--
		}
		cache >>= letterIdBits
		remain--
	}
	return sb.String()
}

func TestApproach7(t *testing.T) {
	fmt.Println(randStr(10))
}

func BenchmarkApproach7(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

在构造出builder之后，我们立刻调用了Builder.Grow()方法，使得它分配一个足够大的底层slice,避免在后续操作中再进行分配

8. “Mimicing” strings.Builder with package unsafe

模仿string.Builder使用unsafe包

string.Builder跟我们第六节地解法一样，都是用[]byte来构建字符串。切换到strings.Builder可能有一些太重了，我们使用strings.Builder只是想避免拷贝slice。

string.Builder使用unsafe包来避免最终的拷贝

// String returns the accumulated string.
func (b *Builder) String() string {
    return *(*string)(unsafe.Pointer(&b.buf))
}

我们也可以自己完成这个流程。所以思路是我们通过unsafe包来返回一个字符串，来避免拷贝

package approach8

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
	"unsafe"
)

const letters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"

var src = rand.NewSource(time.Now().UnixNano())

const (
	// 6 bits to represent a letter index
	letterIdBits = 6
	// All 1-bits as many as letterIdBits
	letterIdMask = 1<<letterIdBits - 1
	letterIdMax  = 63 / letterIdBits
)

func randStr(n int) string {
	b := make([]byte, n)
	// A rand.Int63() generates 63 random bits, enough for letterIdMax letters!
	for i, cache, remain := n-1, src.Int63(), letterIdMax; i >= 0; {
		if remain == 0 {
			cache, remain = src.Int63(), letterIdMax
		}
		if idx := int(cache & letterIdMask); idx < len(letters) {
			b[i] = letters[idx]
			i--
		}
		cache >>= letterIdBits
		remain--
	}
	return *(*string)(unsafe.Pointer(&b))
}

func TestApproach8(t *testing.T) {
	fmt.Println(randStr(10))
}

func BenchmarkApproach8(b *testing.B) {
	for i := 0; i < b.N; i++ {
		_ = randStr(10)
	}
}

Benchmark

go test ./... -bench=. -benchmem

原作者测试的数据

(译者注：第三列代表操作一次需要多少纳秒)

BenchmarkRunes-4                     2000000    723 ns/op   96 B/op   2 allocs/op
BenchmarkBytes-4                     3000000    550 ns/op   32 B/op   2 allocs/op
BenchmarkBytesRmndr-4                3000000    438 ns/op   32 B/op   2 allocs/op
BenchmarkBytesMask-4                 3000000    534 ns/op   32 B/op   2 allocs/op
BenchmarkBytesMaskImpr-4            10000000    176 ns/op   32 B/op   2 allocs/op
BenchmarkBytesMaskImprSrc-4         10000000    139 ns/op   32 B/op   2 allocs/op
BenchmarkBytesMaskImprSrcSB-4       10000000    134 ns/op   16 B/op   1 allocs/op
BenchmarkBytesMaskImprSrcUnsafe-4   10000000    115 ns/op   16 B/op   1 allocs/op

译者测试的数据

BenchmarkApproach1-12            3849038               299.5 ns/op            64 B/op          2 allocs/op
BenchmarkApproach2-12            5545350               216.4 ns/op            32 B/op          2 allocs/op
BenchmarkApproach3-12            7003654               169.7 ns/op            32 B/op          2 allocs/op
BenchmarkApproach4-12            7164259               168.7 ns/op            32 B/op          2 allocs/op
BenchmarkApproach5-12           13205474                89.06 ns/op           32 B/op          2 allocs/op
BenchmarkApproach6-12           13665636                84.41 ns/op           32 B/op          2 allocs/op
BenchmarkApproach7-12           17213431                70.37 ns/op           16 B/op          1 allocs/op
BenchmarkApproach8-12           19756956                61.41 ns/op           16 B/op          1 allocs/op

现在跑出来的数据，相原作者时候，已经有了一些变化，不过并不妨碍我们看出来各个方法的趋势：

仅仅只是把rune切换到byte，就获得了性能的大幅度提升(大于百分之20)
使用rand.Int63()代替rand.Intn()也获得大幅度提升(大于百分之20)
使用Masking并没有提升性能，相反在原作者哪里，反而性能下降了
不过使用了一次rand.Int63()返回的全部字符后，性能提升了3倍
使用rand.Source替代rand.Rand，性能提升了21%
使用strings.Builder，我们在速度上提升了3.5%，并且把原本2次的内存分配，降低到了一次！
使用unsafe包来代替strings.Builder，性能提升了14%

将第八个方案和第一个方案比较，第八个方案比第一个方案快6.3倍，仅仅使用六分之一的内存，分配次数也只有原来的一半。

点击关注，第一时间了解华为云新鲜技术~

微信关注我们

原文链接：https://my.oschina.net/u/4526289/blog/10676267

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

DDD落地实践-架构师眼中的餐厅

本文以餐厅场景为叙事主线，以领域驱动为核心思想，结合架构设计与功能设计方法论。是从领域分析到落地的全过程案例，内容偏重于落地，因此不乏一些探讨，欢迎指正。文章较长、全程干货、耐心读完、必有收获。本文不针对餐厅的实现细节，重在探讨设计思想和方法。 1、领域设计让我们抛开技术人员的本能技术视角、站在纯业务视角来分析领域问题。领域设计的核心是分而治之，目的是实现业务领域的自治性。就像你平时不会将枕头和被子放在厨房或卫生间一样，你的床上不会放着大米白面，否则你想睡觉是一件很复杂的事情，软件系统也是如此，这就是我们要解决的问题。 1.1 宏观流程假如我要设计一个餐厅，由于分而治之的需要，我会首先从宏观流程去分析，可以帮我们迅速找到重要的区域。因此会得到几个明确的行为区域，我将餐厅划分为“菜品域”，“订单域”，“厨房域”，“用餐域”，这是业务级别的领域划分，后续应该针对每个区域单独分析。产出物是：宏观流程和参与角色 1.2 统一语言语言贯穿于整个开发过程，从需求分析到设计、从设计到编码，因此好的语言非常重要，好的语言体现了清晰的业务概念。在这个阶段，我们需要通过梳理，找...

2024-01-03

289

一、前言 GaussDB是一个高度可靠、可扩展、高性能的数据库管理系统，用于支持企业级应用、数据仓库、数据科学和实时分析等场景。它提供了丰富的功能和工具，以帮助开发和管理员有效地管理数据。在GaussDB中，触发器是一种重要的数据库对象，用于在满足特定条件时自动触发预定义的操作。通过使用触发器，您可以实现数据的实时监控、验证、日志记录和其他自动化任务。本篇文章将介绍GaussDB数据库中触发器的基本概念、创建以及示例，并简要总结触发器的优缺点。二、触发器概念触发器是GaussDB数据库中的一种数据库对象，它是一种自动触发的SQL代码块，用于在满足特定条件时执行预定义的操作。触发器可以用于监控数据库中的数据变化、实施业务规则、日志记录等。与存储过程不同，触发器是自动触发的，无需显式调用。三、GaussDB数据库中的触发器创建一个触发器。触发器将与指定的表或视图关联，并在特定条件下执行指定的函数。 1、语法格式 CREATE [ CONSTRAINT ] TRIGGER trigger_name { BEFORE | AFTER | INSTEAD OF } { event [...

2024-01-08

318

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。