489 lines
12 KiB
Go
489 lines
12 KiB
Go
package baseutils
|
||
|
||
import (
|
||
"bytes"
|
||
"encoding/binary"
|
||
"fmt"
|
||
"github.com/gogf/guuid"
|
||
"image/png"
|
||
"math/rand"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
"unsafe"
|
||
|
||
"github.com/boombuler/barcode"
|
||
"github.com/boombuler/barcode/qr"
|
||
)
|
||
|
||
func init() {
|
||
rand.Seed(time.Now().UnixNano())
|
||
}
|
||
|
||
// 转换16进制
|
||
var numberHexSmall = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}
|
||
var numberHexBig = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}
|
||
var stringBytes = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F',
|
||
'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
|
||
'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
|
||
'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '-', '+'}
|
||
var bcd2Bytes = []byte{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?'}
|
||
|
||
// RandomUUID 随机生成UUID
|
||
func RandomUUID() string {
|
||
/*retAdSource := string("")
|
||
retAdSource = retAdSource + RandomBigHexString(8) + "-"
|
||
retAdSource = retAdSource + RandomBigHexString(4) + "-"
|
||
retAdSource = retAdSource + RandomBigHexString(4) + "-"
|
||
retAdSource = retAdSource + RandomBigHexString(4) + "-"
|
||
retAdSource = retAdSource + RandomBigHexString(12)*/
|
||
|
||
return guuid.New().String()
|
||
}
|
||
|
||
// RandomBSSID 随机生成RandomBSSID
|
||
func RandomBSSID() string {
|
||
retAdSource := string("")
|
||
retAdSource = retAdSource + RandomSmallHexString(2) + "-"
|
||
retAdSource = retAdSource + RandomSmallHexString(2) + "-"
|
||
retAdSource = retAdSource + RandomSmallHexString(2) + "-"
|
||
retAdSource = retAdSource + RandomSmallHexString(2) + "-"
|
||
retAdSource = retAdSource + RandomSmallHexString(2) + "-"
|
||
retAdSource = retAdSource + RandomSmallHexString(2)
|
||
|
||
return retAdSource
|
||
}
|
||
|
||
func BuildRandomMac() string {
|
||
// 00:00:00:00:00:00
|
||
macs := make([]string, 6)
|
||
for i := range macs {
|
||
macs[i] = fmt.Sprintf("%02X", rand.Intn(0xff))
|
||
}
|
||
|
||
return strings.Join(macs, ":")
|
||
}
|
||
|
||
// RandomBytes RandomBytes
|
||
func RandomBytes(length uint32) []byte {
|
||
retBytes := make([]byte, length)
|
||
tmpRand := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
var i uint32
|
||
for i = 0; i < length; i++ {
|
||
retBytes[i] = byte(tmpRand.Intn(256))
|
||
}
|
||
|
||
return retBytes
|
||
}
|
||
|
||
// RandomBigHexString RandomBigHexString
|
||
func RandomBigHexString(length uint32) string {
|
||
retBytes := make([]byte, length)
|
||
tmpRand := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
var i uint32
|
||
for i = 0; i < length; i++ {
|
||
tmpIndex := tmpRand.Intn(16)
|
||
retBytes[i] = numberHexBig[tmpIndex]
|
||
}
|
||
|
||
return string(retBytes)
|
||
}
|
||
|
||
// RandomSmallHexString RandomSmallHexString
|
||
func RandomSmallHexString(length uint32) string {
|
||
retBytes := make([]byte, length)
|
||
tmpRand := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
var i uint32
|
||
for i = 0; i < length; i++ {
|
||
tmpIndex := tmpRand.Intn(16)
|
||
retBytes[i] = numberHexSmall[tmpIndex]
|
||
}
|
||
|
||
return string(retBytes)
|
||
}
|
||
|
||
// RandomStringByLength 随机固定长度的字符串
|
||
func RandomStringByLength(length uint32) []byte {
|
||
retBytes := make([]byte, length)
|
||
tmpRand := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
tmpSize := len(stringBytes)
|
||
var index = uint32(0)
|
||
for index = 0; index < length; index++ {
|
||
tmpIndex := tmpRand.Intn(tmpSize)
|
||
retBytes[index] = stringBytes[tmpIndex]
|
||
}
|
||
|
||
return retBytes
|
||
}
|
||
|
||
// RandomString 随机长度的字符串
|
||
func RandomString(smallLength uint32, bigLength uint32) []byte {
|
||
if smallLength >= bigLength || smallLength <= 0 {
|
||
return []byte{}
|
||
}
|
||
|
||
tmpRand := rand.New(rand.NewSource(time.Now().UnixNano()))
|
||
tmpSize := bigLength - smallLength
|
||
tmpLength := uint32(tmpRand.Intn(int(tmpSize))) + smallLength
|
||
|
||
return RandomStringByLength(tmpLength)
|
||
}
|
||
|
||
// BytesToInt32 bytes 转 uint32
|
||
func BytesToInt32(bytesData []byte) uint32 {
|
||
length := len(bytesData)
|
||
if length < 4 {
|
||
tmpBytes := make([]byte, 4-length)
|
||
tmpBytes = append(tmpBytes, bytesData[0:]...)
|
||
return binary.BigEndian.Uint32(tmpBytes)
|
||
}
|
||
return binary.BigEndian.Uint32(bytesData)
|
||
}
|
||
|
||
// BytesToInt32SmallEndian 小端整形
|
||
func BytesToInt32SmallEndian(bytesData []byte) uint32 {
|
||
return binary.LittleEndian.Uint32(bytesData)
|
||
}
|
||
|
||
// Int32ToBytes uint32 转 bytes
|
||
func Int32ToBytes(int32Value uint32) []byte {
|
||
var buf = make([]byte, 4)
|
||
binary.BigEndian.PutUint32(buf, int32Value)
|
||
return buf
|
||
}
|
||
|
||
// UInt64ToBytes uint64 转 bytes
|
||
func UInt64ToBytes(int64Value uint64) []byte {
|
||
var buf = make([]byte, 8)
|
||
binary.BigEndian.PutUint64(buf, int64Value)
|
||
return buf
|
||
}
|
||
|
||
// BigEndianInt32ToLittleEndianInt32 大端整形 转成小端整形
|
||
func BigEndianInt32ToLittleEndianInt32(intValue uint32) uint32 {
|
||
tmpBytes := Int32ToBytes(intValue)
|
||
return binary.LittleEndian.Uint32(tmpBytes)
|
||
}
|
||
|
||
// Int32ToBytesLittleEndian uint32 转 bytes
|
||
func Int32ToBytesLittleEndian(int32Value uint32) []byte {
|
||
var buf = make([]byte, 4)
|
||
binary.LittleEndian.PutUint32(buf, int32Value)
|
||
return buf
|
||
}
|
||
|
||
// Int16ToBytesLittleEndian uint16 转 bytes
|
||
func Int16ToBytesLittleEndian(int16Value uint16) []byte {
|
||
var buf = make([]byte, 2)
|
||
binary.LittleEndian.PutUint16(buf, int16Value)
|
||
return buf
|
||
}
|
||
|
||
// Int16ToBytesBigEndian uint16 转 bytes
|
||
func Int16ToBytesBigEndian(int16Value uint16) []byte {
|
||
var buf = make([]byte, 2)
|
||
binary.BigEndian.PutUint16(buf, int16Value)
|
||
return buf
|
||
}
|
||
|
||
// BytesToUint16BigEndian bytes 转 uint16 BigEndian
|
||
func BytesToUint16BigEndian(bytesData []byte) uint16 {
|
||
return binary.BigEndian.Uint16(bytesData)
|
||
}
|
||
|
||
// BytesToUint16LittleEndian bytes 转 uint16 LittleEndian
|
||
func BytesToUint16LittleEndian(bytesData []byte) uint16 {
|
||
return binary.LittleEndian.Uint16(bytesData)
|
||
}
|
||
|
||
// Int2Byte int 转成 字节数组
|
||
func Int2Byte(data int) (ret []byte) {
|
||
var len = unsafe.Sizeof(data)
|
||
ret = make([]byte, len)
|
||
var tmp = 0xff
|
||
var index = uint(0)
|
||
for index = 0; index < uint(len); index++ {
|
||
ret[index] = byte((tmp << (index * 8) & data) >> (index * 8))
|
||
}
|
||
return ret
|
||
}
|
||
|
||
// DecodeVByte32 获取变长整形值 和 所占用的字节数
|
||
// data ： 变长整数的字节数组
|
||
// current : 数组的起始坐标, 从这个坐标开启解析变长整数
|
||
// return 解密后的整形、占用的字节数
|
||
func DecodeVByte32(data []byte, current uint32) (uint32, uint32) {
|
||
var index = uint32(0)
|
||
for data[current+index] >= 0x80 {
|
||
index++
|
||
}
|
||
|
||
var retLen = uint32(index + 1)
|
||
var value = uint32(0)
|
||
for index != 0 {
|
||
value <<= 7
|
||
value |= (uint32)(data[current+index] & 0x7f)
|
||
index--
|
||
}
|
||
|
||
value <<= 7
|
||
value |= (uint32)(data[current] & 0x7f)
|
||
return value, retLen
|
||
}
|
||
|
||
// EncodeVByte32 uint32 转成 变长整形字节数组
|
||
func EncodeVByte32(num uint32) []byte {
|
||
retBytes := make([]byte, 0)
|
||
tmpValue := num
|
||
for tmpValue >= 0x80 {
|
||
var tmpByte = byte(0)
|
||
tmpByte = byte(tmpValue%0x80 + 0x80)
|
||
tmpValue = tmpValue / 0x80
|
||
retBytes = append(retBytes, tmpByte)
|
||
}
|
||
|
||
var tmpByte = byte(tmpValue)
|
||
retBytes = append(retBytes, tmpByte)
|
||
|
||
return retBytes
|
||
}
|
||
|
||
// UInt32To16Bytes 整形转换成16进制字节数组
|
||
func UInt32To16Bytes(intValue uint32) []byte {
|
||
retBytes := make([]byte, 0)
|
||
|
||
tmpValue := intValue
|
||
for tmpValue > 0 {
|
||
modValue := tmpValue % 16
|
||
retBytes = append(retBytes, numberHexSmall[modValue])
|
||
tmpValue = tmpValue / 16
|
||
}
|
||
|
||
retBytes = reverse(retBytes)
|
||
return retBytes
|
||
}
|
||
|
||
// 反转字节数组
|
||
func reverse(data []byte) []byte {
|
||
retBytes := make([]byte, 0)
|
||
dataLen := len(data)
|
||
for dataLen > 0 {
|
||
retBytes = append(retBytes, data[dataLen-1])
|
||
dataLen = dataLen - 1
|
||
}
|
||
|
||
return retBytes
|
||
}
|
||
|
||
// HashCode 计算字符串hashcode
|
||
func HashCode(str string) uint32 {
|
||
tmpBytes := []byte(str)
|
||
tmpLen := len(tmpBytes)
|
||
|
||
var retHashCode = uint32(0)
|
||
for index := 0; index < tmpLen; index++ {
|
||
var tmpValue = uint32(tmpBytes[index])
|
||
retHashCode = 31*retHashCode + tmpValue
|
||
}
|
||
|
||
return retHashCode
|
||
}
|
||
|
||
// StringCut 截取字符串
|
||
// srcStr 待截取的字符串
|
||
// index 截取的开始索引
|
||
// length 截取的长度
|
||
func StringCut(srcStr string, index uint32, length uint32) string {
|
||
srcBytes := []byte(srcStr)
|
||
tmpBytes := make([]byte, 0)
|
||
tmpBytes = append(tmpBytes, srcBytes[index:index+length]...)
|
||
|
||
retString := string(tmpBytes)
|
||
return retString
|
||
}
|
||
|
||
// HexStringToBytes 16进制字符串 转bytes
|
||
func HexStringToBytes(hexString string) []byte {
|
||
retBytes := make([]byte, 0)
|
||
count := len(hexString)
|
||
for index := 0; index < count; index += 2 {
|
||
tmpStr := StringCut(hexString, uint32(index), 2)
|
||
value64, _ := strconv.ParseInt(tmpStr, 16, 16)
|
||
retBytes = append(retBytes, byte(value64))
|
||
}
|
||
|
||
return retBytes
|
||
}
|
||
|
||
// BytesToHexString 字节数组转16进制String
|
||
func BytesToHexString(data []byte, isBig bool) string {
|
||
changeBytes := numberHexSmall
|
||
if isBig {
|
||
changeBytes = numberHexBig
|
||
}
|
||
length := len(data)
|
||
retBytes := make([]byte, length*2)
|
||
for index := 0; index < length; index++ {
|
||
tmpByte := data[index]
|
||
highIndex := ((tmpByte & 0xf0) >> 4)
|
||
lowIndex := tmpByte & 0x0f
|
||
retBytes[index*2] = changeBytes[highIndex]
|
||
retBytes[index*2+1] = changeBytes[lowIndex]
|
||
}
|
||
|
||
return string(retBytes)
|
||
}
|
||
|
||
// EscapeURL 对Url特殊字符转译
|
||
func EscapeURL(srcURL string) string {
|
||
size := len(srcURL)
|
||
retURL := []byte{}
|
||
for index := 0; index < size; index++ {
|
||
// 转译：%
|
||
if srcURL[index] == '%' {
|
||
retURL = append(retURL, []byte("%25")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：&
|
||
if srcURL[index] == '&' {
|
||
retURL = append(retURL, []byte("%26")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：+
|
||
if srcURL[index] == '+' {
|
||
retURL = append(retURL, []byte("%2B")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：/
|
||
if srcURL[index] == '/' {
|
||
retURL = append(retURL, []byte("%2F")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：
|
||
if srcURL[index] == ':' {
|
||
retURL = append(retURL, []byte("%3A")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：=
|
||
if srcURL[index] == '=' {
|
||
retURL = append(retURL, []byte("%3D")[0:]...)
|
||
continue
|
||
}
|
||
// 转译：?
|
||
if srcURL[index] == '?' {
|
||
retURL = append(retURL, []byte("%3F")[0:]...)
|
||
continue
|
||
}
|
||
retURL = append(retURL, srcURL[index])
|
||
}
|
||
|
||
return string(retURL)
|
||
}
|
||
|
||
// HongBaoStringToBytes HongBaoStringToBytes
|
||
func HongBaoStringToBytes(content string) string {
|
||
retBytes := []byte{}
|
||
tmpBytes := []byte(content)
|
||
count := len(tmpBytes)
|
||
for index := 0; index < count; index++ {
|
||
byteValue := tmpBytes[index]
|
||
if byteValue&0x80 != 0 {
|
||
high4Value := byteValue >> 4
|
||
low4Value := byteValue & 0xF
|
||
retBytes = append(retBytes, '%')
|
||
retBytes = append(retBytes, numberHexBig[high4Value])
|
||
retBytes = append(retBytes, numberHexBig[low4Value])
|
||
} else {
|
||
retBytes = append(retBytes, byteValue)
|
||
}
|
||
}
|
||
|
||
return string(retBytes)
|
||
}
|
||
|
||
// GetNumberString 获取前面的数字字符串
|
||
func GetNumberString(srcStr string) string {
|
||
retBytes := make([]byte, 0)
|
||
count := len(srcStr)
|
||
for index := 0; index < count; index++ {
|
||
if srcStr[index] >= '0' && srcStr[index] <= '9' {
|
||
retBytes = append(retBytes, srcStr[index])
|
||
} else {
|
||
break
|
||
}
|
||
}
|
||
return string(retBytes)
|
||
}
|
||
|
||
// BCD2ToASCII BCD2ToASCII
|
||
func BCD2ToASCII(ascString string) []byte {
|
||
retBytes := []byte{}
|
||
size := len(ascString)
|
||
if size%2 == 1 {
|
||
size = size + 1
|
||
ascString = "0" + ascString
|
||
}
|
||
tmpAscData := []byte(ascString)
|
||
for index := 0; index < size; index += 2 {
|
||
tmpByte := byte(0)
|
||
for index2 := byte(0); index2 < byte(16); index2++ {
|
||
if tmpAscData[index] == numberHexBig[index2] {
|
||
tmpByte = tmpByte + index2<<4
|
||
}
|
||
// 判断
|
||
if tmpAscData[index+1] == numberHexBig[index2] {
|
||
tmpByte = tmpByte + index2
|
||
}
|
||
}
|
||
retBytes = append(retBytes, tmpByte)
|
||
}
|
||
return retBytes
|
||
}
|
||
|
||
// ASCIIToBCD2 ASCIIToBCD2
|
||
func ASCIIToBCD2(ascData []byte, bFlag bool) []byte {
|
||
retBytes := []byte{}
|
||
exchangeBytes := bcd2Bytes
|
||
if bFlag {
|
||
exchangeBytes = numberHexBig
|
||
}
|
||
|
||
size := len(ascData)
|
||
for index := 0; index < size; index++ {
|
||
high4 := ascData[index] >> 4
|
||
low4 := ascData[index] & 0xF
|
||
retBytes = append(retBytes, exchangeBytes[high4])
|
||
retBytes = append(retBytes, exchangeBytes[low4])
|
||
}
|
||
return retBytes
|
||
}
|
||
|
||
// ParseInt 去掉除数字外的其他字符
|
||
func ParseInt(srcData string) uint32 {
|
||
retBytes := make([]byte, 0)
|
||
tmpLen := len(srcData)
|
||
for index := 0; index < tmpLen; index++ {
|
||
if srcData[index] >= '0' && srcData[index] <= '9' {
|
||
retBytes = append(retBytes, srcData[index])
|
||
}
|
||
}
|
||
|
||
retValue, err := strconv.Atoi(string(retBytes))
|
||
if err != nil {
|
||
return 0
|
||
}
|
||
return uint32(retValue)
|
||
}
|
||
|
||
// CreateQRCode 生成二维码
|
||
func CreateQRCode(data string) ([]byte, error) {
|
||
qrCode, _ := qr.Encode(data, qr.M, qr.Auto)
|
||
qrCode, _ = barcode.Scale(qrCode, 256, 256)
|
||
buffer := new(bytes.Buffer)
|
||
err := png.Encode(buffer, qrCode)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return buffer.Bytes(), nil
|
||
}
|