rand.go

package com

import (
	cryptoRand "crypto/rand"
	"math"
	"math/rand"
	"time"
)

// RandomSpec0 Creates a random string based on a variety of options, using
// supplied source of randomness.
//
// If start and end are both 0, start and end are set
// to ' ' and 'z', the ASCII printable
// characters, will be used, unless letters and numbers are both
// false, in which case, start and end are set to 0 and math.MaxInt32.
//
// If set is not nil, characters between start and end are chosen.
//
// This method accepts a user-supplied rand.Rand
// instance to use as a source of randomness. By seeding a single
// rand.Rand instance with a fixed seed and using it for each call,
// the same random sequence of strings can be generated repeatedly
// and predictably.
func randomSpec0(count uint, start, end int, letters, numbers bool,
	chars []rune) string {
	if count == 0 {
		return ""
	}
	if start == 0 && end == 0 {
		end = 'z' + 1
		start = ' '
		if !letters && !numbers {
			start = 0
			end = math.MaxInt32
		}
	}
	buffer := make([]rune, count)
	gap := end - start
	for count != 0 {
		count--
		var ch rune
		if len(chars) == 0 {
			ch = rune(rand.Intn(gap) + start)
		} else {
			ch = chars[rand.Intn(gap)+start]
		}
		if letters && ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) ||
			numbers && (ch >= '0' && ch <= '9') ||
			(!letters && !numbers) {
			if ch >= rune(56320) && ch <= rune(57343) {
				if count == 0 {
					count++
				} else {
					buffer[count] = ch
					count--
					buffer[count] = rune(55296 + rand.Intn(128))
				}
			} else if ch >= rune(55296) && ch <= rune(56191) {
				if count == 0 {
					count++
				} else {
					// high surrogate, insert low surrogate before putting it in
					buffer[count] = rune(56320 + rand.Intn(128))
					count--
					buffer[count] = ch
				}
			} else if ch >= rune(56192) && ch <= rune(56319) {
				// private high surrogate, no effing clue, so skip it
				count++
			} else {
				buffer[count] = ch
			}
		} else {
			count++
		}
	}
	return string(buffer)
}

// RandomSpec1 Creates a random string whose length is the number of characters specified.
//
// Characters will be chosen from the set of alpha-numeric
// characters as indicated by the arguments.
//
// Param count - the length of random string to create
// Param start - the position in set of chars to start at
// Param end   - the position in set of chars to end before
// Param letters - if true, generated string will include
//
//	alphabetic characters
//
// Param numbers - if true, generated string will include
//
//	numeric characters
func randomSpec1(count uint, start, end int, letters, numbers bool) string {
	return randomSpec0(count, start, end, letters, numbers, nil)
}

// RandomAlphaOrNumeric Creates a random string whose length is the number of characters specified.
//
// Characters will be chosen from the set of alpha-numeric
// characters as indicated by the arguments.
//
// Param count - the length of random string to create
// Param letters - if true, generated string will include
//
//	alphabetic characters
//
// Param numbers - if true, generated string will include
//
//	numeric characters
func randomAlphaOrNumeric(count uint, letters, numbers bool) string {
	return randomSpec1(count, 0, 0, letters, numbers)
}

func RandomString(count uint) string {
	return randomSpec1(count, 0, 255, false, false)
}

func RandomStringSpec0(count uint, set []rune) string {
	return randomSpec0(count, 0, len(set)-1, false, false, set)
}

func RandomStringSpec1(count uint, set string) string {
	return RandomStringSpec0(count, []rune(set))
}

// RandomASCII Creates a random string whose length is the number of characters
// specified.
// Characters will be chosen from the set of characters whose
// ASCII value is between 32 and 126 (inclusive).
func RandomASCII(count uint) string {
	return randomSpec1(count, 32, 127, false, false)
}

// RandomAlphabetic Creates a random string whose length is the number of characters specified.
// Characters will be chosen from the set of alphabetic characters.
func RandomAlphabetic(count uint) string {
	return randomAlphaOrNumeric(count, true, false)
}

// RandomAlphanumeric Creates a random string whose length is the number of characters specified.
// Characters will be chosen from the set of alpha-numeric characters.
func RandomAlphanumeric(count uint) string {
	return randomAlphaOrNumeric(count, true, true)
}

// RandomNumeric Creates a random string whose length is the number of characters specified.
// Characters will be chosen from the set of numeric characters.
func RandomNumeric(count uint) string {
	return randomAlphaOrNumeric(count, false, true)
}

// RandStr .
func RandStr(count int) (r string) {
	//count := 64
	b := make([]byte, count)
	_, err := cryptoRand.Read(b)
	if err != nil {
		r = RandomString(uint(count))
	} else {
		r = string(b)
	}
	return
}

// RandInt Get in the range [0, max], a random integer type int
func RandInt(max int) int {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Intn(max)
}

// RandFloat32 获取范围为[0.0, 1.0]，类型为float32的随机小数
func RandFloat32() float32 {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Float32()
}

// RandFloat64 获取范围为[0.0, 1.0]，类型为float64的随机小数
func RandFloat64() float64 {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Float64()
}

// RandPerm 获取范围为[0,max]，数量为max，类型为int的随机整数slice
func RandPerm(max int) []int {
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Perm(max)
}

// RandRangeInt64 生成区间随机数
// @param int64 min 最小值
// @param int64 max 最大值
// @return int64 生成的随机数
func RandRangeInt64(min, max int64) int64 {
	if min >= max || min == 0 || max == 0 {
		return max
	}
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Int63n(max-min) + min
}

// RandRangeInt 生成区间随机数
// @param int min 最小值
// @param int max 最大值
// @return int 生成的随机数
func RandRangeInt(min, max int) int {
	if min >= max || min == 0 || max == 0 {
		return max
	}
	r := rand.New(rand.NewSource(time.Now().UnixNano()))
	return r.Intn(max-min) + min
}