rand随机包

目录

• rand随机
  • 从切片中随机取值
  • 订单编号
  • 雪花算法
  • 抽奖
  • 随机n位字符串
  • 从切片中随机获取n位不同的值

rand随机

# 时间戳为种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for i:=0;i<10;i++{
		fmt.Println(r.Intn(100))
	}


rand.NewSource(种子)  设置种子
rand.Intn(100) 返回一个随机的整数
rand.Float64() 返回一个64位浮点数
rand.Perm(len(slice)) 生成一个指定长度的随机排列整数切片

//step1: 设置种子数
rand.Seed(time.Now().UnixNano())
//step2：获取随机数
num4 := rand.Intn(10) // 0-9随机数
fmt.Println(num4)


r := rand.New(rand.NewSource(time.Now().UnixNano()))
res := r.Intn(right-left+1)+left  # left到right

从切片中随机取值

# 定义随机种子
r := rand.New(rand.NewSource(time.Now().UnixNano()))

lis := make([]int,0)  //定义切片
// 给切片造假数据
for i:=0;i<100;i++ {
  lis = append(lis, i)
}
fmt.Println(lis)

for i:=0;i<10;i++ {
  a := len(lis) //获取切片长度
  b := r.Intn(a) //随机获取一个长度以内的整数
  fmt.Println(lis[b])  //取值
}

订单编号

// 生产n位数字，主用作验证码
func RandomInt(length int) (str string) {
	// length 长度
	var arr []byte = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	size := len(arr)
	for i := 0; i < length; i++ {
		str += string(arr[r.Intn(size)])
	}
	return
}

// 订单编号
func Start(userId int, num str) string {
  // num 以什么结尾
	now := time.Now()
	uidStr := fmt.Sprintf("%04d", userId)
	return now.Format("0601021504") + uidStr + qutil.RandomInt(3) + string(orderChannel)
}

雪花算法

地址：github.com/bwmarrin/snowflake

调用一次GenID()产生一个有序且唯一的id.

如果多台机器，可以把GenID()方法做成一个服务，调用即可
注意：可以用69年，每毫秒可以产生40多万个不重复的id

package main

import (
	"fmt"
	"time"

	"github.com/bwmarrin/snowflake"
)

var node *snowflake.Node

func Init(startTime string, machineId int64) (err error) {
	var st time.Time
	st, err = time.Parse("2006-01-02", startTime)
	if err != nil {
		return
	}
	snowflake.Epoch = st.UnixNano() / 1000000
	node, err = snowflake.NewNode(machineId)
	return
}

func GenID() (id int64, err error) {
	if err := Init("2021-01-13", 1); err != nil {
		fmt.Printf("init failed,err:%V\n", err)
		return 0, err
	}
	id = node.Generate().Int64()
	return id, nil
}

func main() {
	id, err := GenID()
	fmt.Println(id)
	fmt.Println(err)
}

抽奖

func main() {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	rands := []int{10, 20, 30, 40}
	rNum := r.Intn(100) + 1
	fmt.Println(rNum)
	num := 0
	for _, v := range rands {
		num += v
		if rNum < num {
			//中奖
			fmt.Println(v)
			return
		}
	}
}

随机n位字符串

func randNum(lenth int) string {
	now := time.Now()
	rand.Seed(now.UnixMicro())
	letterRunes := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
	b := make([]rune, lenth)
	for i := range b {
		b[i] = letterRunes[rand.Intn(len(letterRunes))]
	}
	randomString := string(b)
	return string(b)
}

从切片中随机获取n位不同的值

func RandSliceNum(slice []int, num int) ([]int, error) {
	if num > len(slice) {
		return nil, fmt.Errorf("num is bigger than slice")
	}

	li := []int{}
	// 设置随机种子
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	perm := r.Perm(len(slice))
	for i := 0; i < num; i++ {
		li = append(li, slice[perm[i]])
	}
	return li, nil
}