fun

algorithm

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 二分查找法
func TestBinarySearch(t *testing.T) {
	// 已排序的整数数组
	nums := []int{1, 3, 5, 6, 8, 9, 11, 15, 18, 20}

	// 要查找的值
	val := 11

	// 调用二分查找函数
	index := fun.BinarySearch(nums, val)

	// 输出结果
	if index != -1 {
		fmt.Printf("找到了值 %d 在索引 %d 的位置。\n", val, index)
	} else {
		fmt.Println("没有找到指定的值。")
	}
}

// @title: 斐波拉契数列-递归方法
func TestFibonacciRecursion(t *testing.T) {
	// 计算斐波那契数列的第10项
	n := 10
	fibNumber := fun.FibonacciRecursion(n)
	fmt.Printf("斐波那契数列的第%d项是：%d\n", n, fibNumber)

	// 输出前10项斐波那契数列
	fmt.Println("前10项斐波那契数列:")
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", fun.FibonacciRecursion(i))
	}
	fmt.Println()
}

// @title: 斐波拉契数列-迭代法
func TestFibonacciFind(t *testing.T) {
	// 计算斐波那契数列的第10项
	n := 10
	fibNumber := fun.FibonacciFind(n)
	fmt.Printf("斐波那契数列的第%d项是：%d\n", n, fibNumber)

	// 输出前10项斐波那契数列
	fmt.Println("前10项斐波那契数列:")
	for i := 0; i < 10; i++ {
		fmt.Printf("%d ", fun.FibonacciFind(i))
	}
	fmt.Println()
}

// @title: 雪花算法
func TestSnowflake(t *testing.T) {
	worker, _ := fun.Snowflake(10)
	id := worker.GetId()
	fmt.Println(id)
}

// @title: 快速排序
func TestQuickSort(t *testing.T) {
	nums := []int{10, 5, 2, 3, 7, 6, 8, 1, 9, 4}
	fun.QuickSort(nums, 0, len(nums)-1)
	fmt.Println(nums)
}

// @title: 冒泡排序
func TestBubbleSort(t *testing.T) {
	nums := []int{10, 5, 2, 3, 7, 6, 8, 1, 9, 4}
	fun.BubbleSort(nums)
	fmt.Println(nums)
}

// @title: 洗牌算法
func TestShuffle(t *testing.T) {
	nums := []int{10, 5, 2, 3, 7, 6, 8, 1, 9, 4}
	fun.Shuffle(nums)
	fmt.Println(nums)
}

bool

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 变量是否布尔类型
func TestIsBool(t *testing.T) {
	v := true
	//v := "技术狼"
	is := fun.IsBool(v)
	fmt.Println(is) // true
}

byte

package test

import (
	"bytes"
	"encoding/binary"
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: []byte转float32
func TestBytesToFloat32(t *testing.T) {
	f := float32(3.14)   // 直接定义一个 float32 值
	var buf bytes.Buffer // 使用 bytes.Buffer 来创建一个可写入的字节缓冲区

	// 将 float32 写入缓冲区
	err := binary.Write(&buf, binary.LittleEndian, f)
	if err != nil {
		fmt.Println("Error writing to buffer:", err)
		return
	}
	byteData := buf.Bytes() // 现在 buf.Bytes() 包含了 float32 的字节表示

	//
	data := fun.BytesToFloat32(byteData)
	fmt.Println(data)
}

// @title: []byte转float64
func TestBytesToFloat64(t *testing.T) {
	f := float64(3.14)   // 直接定义一个 float32 值
	var buf bytes.Buffer // 使用 bytes.Buffer 来创建一个可写入的字节缓冲区

	// 将 float64 写入缓冲区
	err := binary.Write(&buf, binary.LittleEndian, f)
	if err != nil {
		fmt.Println("Error writing to buffer:", err)
		return
	}
	byteData := buf.Bytes() // 现在 buf.Bytes() 包含了 float32 的字节表示

	//
	data := fun.BytesToFloat64(byteData)
	fmt.Println(data)
}

// @title: 将字节切片转换为字符串
func TestUnsafeBytesToString(t *testing.T) {
	byteSlice := []byte("技术狼(jishulang.com)")
	resultString := fun.UnsafeBytesToString(byteSlice)
	fmt.Println(resultString) // 输出: 技术狼(jishulang.com)
}

// @title: []byte转io.Reader
func TestBytesToIoReader(t *testing.T) {
	data := []byte("技术狼(jishulang.com)")

	// 使用 BytesToIoReader 函数将字节切片转换为 io.Reader
	reader := fun.BytesToIoReader(data)

	// 从 reader 中读取数据
	buf := make([]byte, len(data))
	_, err := reader.Read(buf)
	if err != nil {
		panic(err)
	}

	// 打印读取到的数据
	fmt.Println(string(buf))
}

// @title: base32加密
func TestBase32Encode(t *testing.T) {
	// 定义一个字节切片
	originalBytes := []byte("技术狼(jishulang.com)")

	// 使用 Base32Encode 函数编码字节切片
	encodedString := fun.Base32Encode(originalBytes)

	// 打印编码后的 base32 字符串
	fmt.Println("Encoded String:", encodedString)
}

// @title: base32解密
func TestBase32Decode(t *testing.T) {
	originalBytes := []byte("技术狼(jishulang.com)")
	encodedString := fun.Base32Encode(originalBytes)

	//
	decodeString, err := fun.Base32Decode(encodedString)
	fmt.Println(string(decodeString), err)
}

crypto

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: Md5加密
func TestMd5(t *testing.T) {
	is := fun.Md5("技术狼")
	fmt.Println(is)
}

// @title: sha1加密
func TestSha1(t *testing.T) {
	is := fun.Sha1("技术狼")
	fmt.Println(is)
}

// @title: Sha256加密
func TestSha256(t *testing.T) {
	is := fun.Sha256("技术狼")
	fmt.Println(is)
}

// @title: Sha512加密
func TestSha512(t *testing.T) {
	is := fun.Sha512("技术狼")
	fmt.Println(is)
}

// @title: CBC(密码分组链接模式)
func TestCBC(t *testing.T) {
	// 这里使用一个固定的key和IV只是为了演示，实际应用中应该使用更安全的方式生成它们
	key := []byte("xxxxxxxxxxxxxxxx") // 必须是16, 24, 或32字节长
	//iv := key[:aes.BlockSize]                     // 使用key的一部分作为IV，但实际中应随机生成

	plaintext := []byte("技术狼")

	// 加密数据
	encrypted, err := fun.AesEncryptCBC(plaintext, key)
	fmt.Println("Encrypted:", encrypted, err)

	// 解密数据
	decrypted, err := fun.AesDecryptCBC(encrypted, key)
	fmt.Println("Decrypted:", string(decrypted), err)
}

// @title: CFB(密码反馈模式)
func TestCFB(t *testing.T) {
	// 这里使用一个固定的key和IV只是为了演示，实际应用中应该使用更安全的方式生成它们
	key := []byte("xxxxxxxxxxxxxxxx") // 必须是16, 24, 或32字节长
	//iv := key[:aes.BlockSize]                     // 使用key的一部分作为IV，但实际中应随机生成

	plaintext := []byte("技术狼")

	// 加密数据
	encrypted, err := fun.AesEncryptCFB(plaintext, key)
	fmt.Println("Encrypted:", encrypted, err)

	// 解密数据
	decrypted, err := fun.AesDecryptCFB(encrypted, key)
	fmt.Println("Decrypted:", string(decrypted), err)
}

// @title: ECB(电码本模式)
func TestECB(t *testing.T) {
	// 这里使用一个固定的key和IV只是为了演示，实际应用中应该使用更安全的方式生成它们
	key := []byte("xxxxxxxxxxxxxxxx") // 必须是16, 24, 或32字节长
	//iv := key[:aes.BlockSize]                     // 使用key的一部分作为IV，但实际中应随机生成

	plaintext := []byte("技术狼")

	// 加密数据
	encrypted, err := fun.AesEncryptECB(plaintext, key)
	fmt.Println("Encrypted:", encrypted, err)

	// 解密数据
	decrypted, err := fun.AesDecryptECB(encrypted, key)
	fmt.Println("Decrypted:", string(decrypted), err)
}

dir

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 目录是否存在
func TestDirIsExist(t *testing.T) {
	is, err := fun.DirIsExist("../test")
	fmt.Println(is, err)
}

// @title: 创建目录
func TestDirCreate(t *testing.T) {
	err := fun.DirCreate("../test2", 0777)
	fmt.Println(err)
}

// @title: 目录复制
func TestDirCopy(t *testing.T) {
	err := fun.DirCopy("../test", "../test2")
	fmt.Println(err)
}

// @title: 目录路径以斜杠结尾
func TestDirEndsWithSlash(t *testing.T) {
	err := fun.DirEndsWithSlash("E:\\jishulangcom\\go-fun")
	fmt.Println(err)
}

// @title: 获取某目录指定后缀的所有文件
func TestDirFilesBySuffix(t *testing.T) {
	arr, err := fun.DirFilesBySuffix("./", ".go")
	fmt.Println(arr, err)
}

// @title: 列出指定目录的所有文件及目录
func TestListDirFiles(t *testing.T) {
	arr, err := fun.ListDirFiles("./")
	fmt.Println(arr, err)
}

json

package test

import (
	"fmt"
	"gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: json转map
func TestJsonToMap(t *testing.T) {
	jsonStr := `{"name":"技术狼", "site":"jishulang.com"}`
	jsonBytes := []byte(jsonStr)
	resultMap, err := fun.JsonToMap(jsonBytes)
	fmt.Println(resultMap, err)
}

// @title: map转json
func TestMapToJson(t *testing.T) {
	jsonStr := `{"name":"技术狼", "site":"jishulang.com"}`
	jsonBytes := []byte(jsonStr)
	resultMap, _ := fun.JsonToMap(jsonBytes)

	str := fun.MapToJson(resultMap)
	fmt.Println(str)
}

file

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 文件是否存在
func TestFileIsExist(t *testing.T) {
	is, err := fun.FileIsExist("./file_test.go")
	fmt.Println(is, err)
}

// @title: 文件复制
func TestFileCopy(t *testing.T) {
	err := fun.FileCopy("./file_test.go", "./file_test2.go")
	fmt.Println(err)
}

// @title: 获取文件内容
func TestFileGetContents(t *testing.T) {
	b, err := fun.FileGetContents("./file_test.go")
	fmt.Println(string(b), err)
}

// @title: 文件写入内容
func TestFilePutContents(t *testing.T) {
	err := fun.FilePutContents("./file_test.txt", "技术狼")
	fmt.Println(err)
}

// @title: 文件隐藏(windows)
func TestFileHide(t *testing.T) {
	is, err := fun.FileHide("./file_test.txt")
	fmt.Println(is, err)
}

float

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 变量是否浮点类型
func TestIsFloat(t *testing.T) {
	is := fun.IsFloat(3.14)
	fmt.Println(is)
}

// @title: float64转string
func TestFloat64ToStr(t *testing.T) {
	is := fun.Float64ToStr(3.14)
	fmt.Println(is)
}

// @title: float64小数位数
func TestFloat64Decimal(t *testing.T) {
	is := fun.Float64Decimal(3.14)
	fmt.Println(is)
}

// @title: float32转byte
func TestFloat32ToByte(t *testing.T) {
	is := fun.Float32ToByte(3.14)
	fmt.Println(is)
}

// @title: float64转byte
func TestFloat64ToByte(t *testing.T) {
	is := fun.Float64ToByte(3.14)
	fmt.Println(is)
}

// @title: float64转int64
func TestFloat64ToInt64(t *testing.T) {
	data := fun.Float64ToInt64(3.14)
	fmt.Println(data)

	data2 := fun.Float64ToInt64(3.54)
	fmt.Println(data2)
}

// @title: float64转int
func TestFloat64ToInt(t *testing.T) {
	data := fun.Float64ToInt(3.14)
	fmt.Println(data)

	data2 := fun.Float64ToInt(3.54)
	fmt.Println(data2)
}

// @title: float32转int64
func TestFloat32ToInt64(t *testing.T) {
	data := fun.Float32ToInt64(3.14)
	fmt.Println(data)

	data2 := fun.Float32ToInt64(3.54)
	fmt.Println(data2)
}

// @title: float32转int
func TestFloat32ToInt(t *testing.T) {
	data := fun.Float32ToInt(3.14)
	fmt.Println(data)

	data2 := fun.Float32ToInt(3.54)
	fmt.Println(data2)
}

go

package test

import (
	fun "gitee.com/jishulangcom/go-fun"
	"log"
	"testing"
)

type JslStruct struct{}

func (y JslStruct) Fun1(i int, str string) (int, string) {
	return i, str
}

// 魔法函数
func TestCallFun(t *testing.T) {
	// 调用某结构体的方法
	data := JslStruct{}
	i, str := data.Fun1(10, "test")
	log.Println(i, str)

	// 使用魔法函数调用某结构体的方法
	res2 := fun.CallFun(JslStruct{}, "Fun1", 20, "test2")
	log.Println(res2[0], res2[1])
}

int

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: int转字符
func TestIntToStr(t *testing.T) {
	is := fun.IntToStr(100)
	fmt.Println(is)
}

// @title: int64转string
func TestInt64ToStr(t *testing.T) {
	is := fun.Int64ToStr(100)
	fmt.Println(is)
}

// @title: int64转int
func TestInt64ToInt(t *testing.T) {
	is := fun.Int64ToInt(100)
	fmt.Println(is)
}

// @title: int转int64
func TestIntToInt64(t *testing.T) {
	is := fun.IntToInt64(100)
	fmt.Println(is)
}

// @title: int转float64
func TestIntToFloat64(t *testing.T) {
	is := fun.IntToFloat64(100)
	fmt.Println(is)
}

// @title: 判断Int是否是奇数
func TestIntIsOdd(t *testing.T) {
	is := fun.IntIsOdd(101)
	fmt.Println(is)
}

// @title: 判断Int是否是偶数
func TestIntIsEven(t *testing.T) {
	is := fun.IntIsEven(100)
	fmt.Println(is)
}

// @title: 判断Int64是否是奇数
func TestInt64IsOdd(t *testing.T) {
	is := fun.Int64IsOdd(101)
	fmt.Println(is)
}

// @title: 判断Int64是否是偶数
func TestInt64IsEven(t *testing.T) {
	is := fun.Int64IsEven(100)
	fmt.Println(is)
}

// @title: 是否是int相关类型
func TestIsInt(t *testing.T) {
	is := fun.IsInt(100)
	fmt.Println(is)
}

// @title: 是否是int类型
func TestIsNumeric(t *testing.T) {
	is := fun.IsNumeric(100)
	fmt.Println(is)
}

interface

package test

import (
	"encoding/json"
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: Interface转换string
func TestInterfaceToStr(t *testing.T) {
	var val string
	var err error

	fmt.Println("======nil=======")
	val, err = fun.InterfaceToStr(nil)
	fmt.Println(val, err)

	fmt.Println("======浮点=======")
	val, err = fun.InterfaceToStr(1.111111)
	fmt.Println(val, err)
	val, err = fun.InterfaceToStr("1.111111")
	fmt.Println(val, err)

	fmt.Println("======浮点（科学计数）=======")
	val, err = fun.InterfaceToStr(1.111111e+06)
	fmt.Println(val, err)
	val, err = fun.InterfaceToStr("1.1111111111111112e+02")
	fmt.Println(val, err)
	val, err = fun.InterfaceToStr("11111111111111111111111111111111.2e+02")
	fmt.Println(val, err)

	fmt.Println("======布尔=======")
	val, err = fun.InterfaceToStr(true)
	fmt.Println(val, err)

	fmt.Println("======字符串=======")
	val, err = fun.InterfaceToStr("技术狼")
	fmt.Println(val, err)

	fmt.Println("======指针=======")
	var i int64 = 100
	val, err = fun.InterfaceToStr(&i)
	fmt.Println(val, err)

	fmt.Println("======json.Number=======")
	val, err = fun.InterfaceToStr(json.Number("200"))
	fmt.Println(val, err)

	fmt.Println("======[]byte=======")
	val, err = fun.InterfaceToStr([]byte("jishulang.com"))
	fmt.Println(val, err)

}

// @title: Interface转float64
func TestInterfaceToFloat64(t *testing.T) {
	var val float64
	var err error

	fmt.Println("======nil=======")
	val, err = fun.InterfaceToFloat64(nil)
	fmt.Println(val, err)

	fmt.Println("======浮点=======")
	val, err = fun.InterfaceToFloat64(1.111111)
	fmt.Println(val, err)
	val, err = fun.InterfaceToFloat64("1.111111")
	fmt.Println(val, err)

	fmt.Println("======浮点（科学计数）=======")
	val, err = fun.InterfaceToFloat64(1.111111e+06)
	fmt.Println(val, err)
	val, err = fun.InterfaceToFloat64("1.111111e+06")
	fmt.Println(val, err)

	fmt.Println("======布尔=======")
	val, err = fun.InterfaceToFloat64(true)
	fmt.Println(val, err)

	fmt.Println("======字符串=======")
	val, err = fun.InterfaceToFloat64("技术狼")
	fmt.Println(val, err)

	fmt.Println("======指针=======")
	var i int64 = 100
	val, err = fun.InterfaceToFloat64(&i)
	fmt.Println(val, err)

	fmt.Println("======json.Number=======")
	val, err = fun.InterfaceToFloat64(json.Number("200.1"))
	fmt.Println(val, err)

	fmt.Println("======[]byte=======")
	val, err = fun.InterfaceToFloat64([]byte("300.1"))
	fmt.Println(val, err)
}

// @title: Interface转int64
func TestInterfaceToInt64(t *testing.T) {
	var val int64
	var err error

	fmt.Println("======nil=======")
	val, err = fun.InterfaceToInt64(nil)
	fmt.Println(val, err)

	fmt.Println("======浮点=======")
	val, err = fun.InterfaceToInt64(1.111111)
	fmt.Println(val, err)
	val, err = fun.InterfaceToInt64("1.111111")
	fmt.Println(val, err)

	fmt.Println("======浮点（科学计数）=======")
	val, err = fun.InterfaceToInt64(1.111111e+06)
	fmt.Println(val, err)
	val, err = fun.InterfaceToInt64("1.111111e+06")
	fmt.Println(val, err)

	fmt.Println("======布尔=======")
	val, err = fun.InterfaceToInt64(true)
	fmt.Println(val, err)

	fmt.Println("======字符串=======")
	val, err = fun.InterfaceToInt64("技术狼")
	fmt.Println(val, err)

	fmt.Println("======指针=======")
	var i int64 = 100
	val, err = fun.InterfaceToInt64(&i)
	fmt.Println(val, err)

	fmt.Println("======json.Number=======")
	val, err = fun.InterfaceToInt64(json.Number("200"))
	fmt.Println(val, err)

	fmt.Println("======[]byte=======")
	val, err = fun.InterfaceToInt64([]byte("300"))
	fmt.Println(val, err)
}

// @title: Interface是否是结构体
func TestInterfaceIsStruct(t *testing.T) {
	var is bool

	type User struct {
		Name string `json:"name"`
	}
	is = fun.InterfaceIsStruct(User{})
	fmt.Println(is)
}

// @title: Interface是否是指针
func TestIInterfaceIsPtr(t *testing.T) {
	var is bool

	var str string
	is = fun.InterfaceIsPtr(&str)
	fmt.Println(is)
}

io

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"os"
	"testing"
)

// @title: io.Reader转[]byte
func TestIoReaderToBytes(t *testing.T) {
	// Open a file
	file, err := os.Open("io_test.go")
	if err != nil {
		panic(err)
	}
	defer file.Close()

	// Read the file content into a byte slice
	content := fun.IoReaderToBytes(file)

	// Print the content
	fmt.Println("File Content:")
	fmt.Println(string(content))
}

json

rsa

package test

import (
	"encoding/json"
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// Transaction Submit KEY(自家站点)
var transactionSubmitPrivateKey = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALu4z/1kcTys46RTSBgS1Ie+f+AJZXPHpFObXw/UsdCFxHng26ilRvTAGwptb14RunxinOPB1ALhwAPGBZBi/EQB9azhxsdNQquWqfgCNgMd87wLA+YFRwid/EQitJJJgpc3K8PhRh/stHQfxFnALPTarh0aeE4HL0gtP1WG92c3AgMBAAECgYEAnBFcqlhVZJKAd9/dclZFZ83TVpm5RPbYAcKM2AaHBswPuxxcwusWAOmuEY9GJbkrh7ocoaZF81doYjrB6XbCLwE5ZO5wC/awuzlChIUEYbuKHYaHklOIRXZdVB5F1VWNuigm9+Bp1Z1tgMPJ3XuPh8vcLsBjYzoW/n52KZjWX/ECQQD2vi8IJvOoq3VTMguBsX1C/WuIP7i6jS8p794SyYj7OlZ5lCDj38/YxSGbTL/1sOQ2hTPqfPjnOWbkIRfA/8srAkEAwsPElz/V3dVYQJDm4B4aOTbA5RJWHcSyvCzme3J50V+f1n+NYT5A7vsfuwD/EtOg4JUAK2oKEJYJx4qDIJAeJQJBAJsDjp6rggakeVgkJ7B6Jnzwox79EXw5+Lh7FuRsst9KnktRcXxX/sdryZo8lJixYh6SfrRBgUoa+PY3iCnbSfMCQQCY9oXcwB7olZk1RFh/JkU0MCN5BVirEoPJtH3j8DlqTe7L2OuhtvHqf0IhbZvnHlyYZY13i1WSRzQxCkEH/wgdAkB8T84E5yKQ4n0PoigggVrCv3SekwZMOxtka5/KfH9ioJOq7XQZN5nZHxX5xIFmngiowOiAIJ/Hpnv72/Oi3Ns+"
var transactionSubmitPublicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7uM/9ZHE8rOOkU0gYEtSHvn/gCWVzx6RTm18P1LHQhcR54NuopUb0wBsKbW9eEbp8YpzjwdQC4cADxgWQYvxEAfWs4cbHTUKrlqn4AjYDHfO8CwPmBUcInfxEIrSSSYKXNyvD4UYf7LR0H8RZwCz02q4dGnhOBy9ILT9VhvdnNwIDAQAB"

// Transaction Notification KEY(pay平台)
var transactionNotificationPrivateKey = "MIICeAIBADANBgkqhkiG9w0BAQEFAASCAmIwggJeAgEAAoGBALu4z/1kcTys46RTSBgS1Ie+f+AJZXPHpFObXw/UsdCFxHng26ilRvTAGwptb14RunxinOPB1ALhwAPGBZBi/EQB9azhxsdNQquWqfgCNgMd87wLA+YFRwid/EQitJJJgpc3K8PhRh/stHQfxFnALPTarh0aeE4HL0gtP1WG92c3AgMBAAECgYEAnBFcqlhVZJKAd9/dclZFZ83TVpm5RPbYAcKM2AaHBswPuxxcwusWAOmuEY9GJbkrh7ocoaZF81doYjrB6XbCLwE5ZO5wC/awuzlChIUEYbuKHYaHklOIRXZdVB5F1VWNuigm9+Bp1Z1tgMPJ3XuPh8vcLsBjYzoW/n52KZjWX/ECQQD2vi8IJvOoq3VTMguBsX1C/WuIP7i6jS8p794SyYj7OlZ5lCDj38/YxSGbTL/1sOQ2hTPqfPjnOWbkIRfA/8srAkEAwsPElz/V3dVYQJDm4B4aOTbA5RJWHcSyvCzme3J50V+f1n+NYT5A7vsfuwD/EtOg4JUAK2oKEJYJx4qDIJAeJQJBAJsDjp6rggakeVgkJ7B6Jnzwox79EXw5+Lh7FuRsst9KnktRcXxX/sdryZo8lJixYh6SfrRBgUoa+PY3iCnbSfMCQQCY9oXcwB7olZk1RFh/JkU0MCN5BVirEoPJtH3j8DlqTe7L2OuhtvHqf0IhbZvnHlyYZY13i1WSRzQxCkEH/wgdAkB8T84E5yKQ4n0PoigggVrCv3SekwZMOxtka5/KfH9ioJOq7XQZN5nZHxX5xIFmngiowOiAIJ/Hpnv72/Oi3Ns+"
var transactionNotificationPublicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC7uM/9ZHE8rOOkU0gYEtSHvn/gCWVzx6RTm18P1LHQhcR54NuopUb0wBsKbW9eEbp8YpzjwdQC4cADxgWQYvxEAfWs4cbHTUKrlqn4AjYDHfO8CwPmBUcInfxEIrSSSYKXNyvD4UYf7LR0H8RZwCz02q4dGnhOBy9ILT9VhvdnNwIDAQAB"

type transactionSubmitDto struct {
	Currency string `json:"currency"`
	Amount   string `json:"amount"`
	Sign     string `json:"sign"`
}

type transactionNotificationDto struct {
	Id     int64  `json:"id"`
	Amount string `json:"amount"`
	Sign   string `json:"sign"`
}

// @title: Rsa Sha1 签名验证
func TestRsaSha1(t *testing.T) {
	//Rsa Sha1 签名(模拟取得Notification数据)
	originalData, _ := rsaSha1Sign(transactionNotificationPrivateKey)
	originalDataByte, _ := json.Marshal(originalData)
	fmt.Println("originalData json：", string(originalDataByte))

	//Rsa Sha1 签名验证
	rsaData := transactionNotificationDto{}
	json.Unmarshal(originalDataByte, &rsaData)
	delete(originalData, "sign")
	signatureStr := fun.SortingSplicing(originalData)
	ok, err := fun.RsaSha1Verify(signatureStr, rsaData.Sign, transactionNotificationPublicKey)
	if err != nil {
		fmt.Println("RsaSha1Verify err：", err)
		return
	}
	fmt.Println(ok)
}

func rsaSha1Sign(privateKey string) (map[string]interface{}, error) {
	data := make(map[string]interface{})
	data["amount"] = "100"

	origData := fun.SortingSplicing(data)
	signStr, err := fun.RsaSha1Sign(origData, privateKey)
	if err != nil {
		return nil, err
	}
	data["sign"] = string(signStr)

	return data, err
}

slice

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 是否是切片
func TestIsSlice(t *testing.T) {
	arr := []int{1, 2, 3, 4}
	v := fun.IsSlice(arr)
	fmt.Println(v)
}

// @title: 是否是数组
func TestIsArray(t *testing.T) {
	arr := []int{1, 2, 3, 4}
	v := fun.IsArray(arr)
	fmt.Println(v)

	arr2 := [...]int{1, 2, 3, 4}
	v2 := fun.IsArray(arr2)
	fmt.Println(v2)

	arr3 := [4]int{1, 2, 3, 4}
	v3 := fun.IsArray(arr3)
	fmt.Println(v3)
}

// @title: 是否是切片
func TestImplode(t *testing.T) {
	arr := []int{1, 2, 3, 4}
	v := fun.Implode(",", arr)
	fmt.Println(v)
}

string

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 生成N个随机字符
func TestRandString(t *testing.T) {
	str := fun.RandString(10)
	fmt.Println(str) // lIETOH7p1x
}

// @title: 是否手机号
func TestIsMobile(t *testing.T) {
	var is bool

	// 移动
	arr1 := []int{134, 135, 136, 137, 138, 139, 147, 150, 151, 152, 157, 158, 159, 182, 187, 188, 198, 178}

	// 联通
	arr2 := []int{130, 131, 132, 145, 155, 156, 166, 171, 175, 176, 185, 186}

	// 电信
	arr3 := []int{133, 149, 153, 173, 177, 180, 181, 189, 191, 199}

	// 合并
	arr := append(arr1, arr2...)
	arr = append(arr, arr3...)

	for _, m := range arr {
		mobile := fmt.Sprintf("%d00000000", m)
		is = fun.IsMobile(mobile)
		fmt.Println(mobile, is)
	}
}

// @title: 手机号*号处理
func TestMobileStar(t *testing.T) {
	mobile := fun.MobileStar("13600000001")
	fmt.Println(mobile) // 136****01
}

// @title: 是否邮箱
func TestIsEmail(t *testing.T) {
	email := fun.IsEmail("[email protected]")
	fmt.Println(email) // true
}

// @title: string转int
func TestStrToInt(t *testing.T) {
	var i int
	var err error

	i, err = fun.StrToInt("123456")
	fmt.Println(i, err) // 123456 <nil>

	i, err = fun.StrToInt("1.23456")
	fmt.Println(i, err) // 0 strconv.Atoi: parsing "1.23456": invalid syntax
}

// @title: string转int64
func TestStrToInt64(t *testing.T) {
	var i int64
	var err error

	i, err = fun.StrToInt64("123456")
	fmt.Println(i, err) // 123456 <nil>

	i, err = fun.StrToInt64("1.23456")
	fmt.Println(i, err) // 0 strconv.Atoi: parsing "1.23456": invalid syntax
}

// @title: string转uint64
func TestStrToUint64(t *testing.T) {
	var i uint64
	var err error

	i, err = fun.StrToUint64("123456")
	fmt.Println(i, err) // 123456 <nil>

	i, err = fun.StrToUint64("1.23456")
	fmt.Println(i, err) // 0 strconv.Atoi: parsing "1.23456": invalid syntax
}

// @title: string转Float64
func TestStrToFloat64(t *testing.T) {
	i, err := fun.StrToFloat64("123456.789")
	fmt.Println(i, err) // 123456 <nil>
}

// @title: string转*big.Float
func TestStrToBigFloat(t *testing.T) {
	i, err := fun.StrToBigFloat("123456.789")
	fmt.Println(i, err) // 123456 <nil>
}

// @title: string转*big.Int
func TestStrToBigInt(t *testing.T) {
	bigInt, ok := fun.StrToBigInt("0.123", 3)
	fmt.Println(bigInt.String(), ok) // 123 true
}

// @title: 某字符串是否存在数组中
func TestStrIsInArr(t *testing.T) {
	arr := []string{"技术狼(jishulang.com)", "jishulang.com"}
	is := fun.StrIsInArr("技术狼(jishulang.com)", arr)
	fmt.Println(is)
}

// @title: string是否是浮点
func TestStrIsFloat(t *testing.T) {
	is := fun.StrIsFloat("0.123")
	fmt.Println(is)
}

// @title: string是否是浮点
func TestIsInString(t *testing.T) {
	is := fun.IsInString("技术狼", "技术狼(jishulang.com)")
	fmt.Println(is)
}

// @title: 是否是字符类型
func TestIsString(t *testing.T) {
	is := fun.IsString("技术狼")
	fmt.Println(is)
}

// @title: 字符串打散为数组
func TestExplode(t *testing.T) {
	m := fun.Explode(",", "jishulang.com,jishulang.net,jishulang.cn")
	fmt.Println(m)
}

// @title: 获取字符串中字符的数量
func TestMbStrLen(t *testing.T) {
	var l int
	l = fun.MbStrLen("技术狼(jishulang.com)")
	fmt.Println(l)

	// 获取字节数(一个中文字符在UTF-8中通常占用3个字节)
	l = len("技术狼(jishulang.com)")
	fmt.Println(l)
}

// @title: 字符串首字母转成小写
func TestLcfirst(t *testing.T) {
	l := fun.Lcfirst("JISHULANG.COM")
	fmt.Println(l)
}

// @title: 字符串首字母转成小写
func TestUcfirst(t *testing.T) {
	l := fun.Ucfirst("jishulang.com")
	fmt.Println(l)
}

// @title: 字符串全转大写
func TestStrToUpper(t *testing.T) {
	l := fun.StrToUpper("jishulang.COM")
	fmt.Println(l)
}

// @title: 字符串全转小写
func TestStrToLower(t *testing.T) {
	l := fun.StrToLower("jishulang.COM")
	fmt.Println(l)
}

// @title: 字符串全转小写
func TestUcword(t *testing.T) {
	l := fun.Ucword("jishulang.com jishulang.cn jishulang.net")
	fmt.Println(l)
}

// @title: 移除字符串两侧的字符
func TestTrim(t *testing.T) {
	l := fun.Trim("====技术狼==jishulang.com==", "=")
	fmt.Println(l)
}

// @title: 去除全部空格
func TestTrimAll(t *testing.T) {
	l := fun.TrimAll("  技术狼 jishulang.com   ")
	fmt.Println(l)
}

// @title: 移除字符串左侧的字符
func TestLtrim(t *testing.T) {
	str := fun.Ltrim("技术狼jishulang.com, 技术狼jishulang.cn", "技术狼")
	fmt.Println(str)
}

// @title: 移除字符串右侧的字符
func TestRtrim(t *testing.T) {
	var str string
	str = fun.Rtrim("技术狼jishulang.com, 技术狼jishulang", "jishulang")
	fmt.Println(str) // 技术狼jishulang.com, 技术狼

	str = fun.Rtrim("技术狼jishulang.com, 技术狼jishulang.com", "jishulang")
	fmt.Println(str) // 技术狼jishulang.com, 技术狼jishulang.com

	str = fun.Rtrim("技术狼jishulang.com, 技术狼jishulang.jjj", "jishulang")
	fmt.Println(str) // 技术狼jishulang.com, 技术狼jishulang.

	str = fun.Rtrim("技术狼jishulang.com, 技术狼jishulang.oooo", "jishulang")
	fmt.Println(str) // 技术狼jishulang.com, 技术狼jishulang.oooo
}

// @title: 移除字符串左侧的字符
func TestOrd(t *testing.T) {
	str := fun.Ord("jishulang.com")
	fmt.Println(str)
}

// @title: 传ASCII值返回字符
func TestChr(t *testing.T) {
	str := fun.Chr(106)
	fmt.Println(str)
}

// @title: 传ASCII值返回字符
func TestStrRepeat(t *testing.T) {
	str := fun.StrRepeat("技术狼", 3)
	fmt.Println(str)
}

// @title: 字符替换
func TestStrReplace(t *testing.T) {
	str := fun.StrReplace("技术狼jishulang.com", "jishulang.com", "jishulang.cn")
	fmt.Println(str)
}

// @title: 是否是科学计数
func TestIsScientificNotation(t *testing.T) {
	str := fun.IsScientificNotation("4.843671275939215e+21")
	fmt.Println(str)
}

// @title: 科学计数转换为字符串数字
func TestScientificNotationToStrings(t *testing.T) {
	str := "4.843000e+2"
	decimalStr, _ := fun.ScientificNotationToStrings(str, 5)
	decimalStr = fun.RemoveAllZerosFromLastDecimal(decimalStr) // 移除无效的0
	fmt.Println(decimalStr)
}

// @title: 获取小数点后的位数
func TestCountDecimalPlaces(t *testing.T) {
	//str := "4.843000e+2"
	str := "4.843000"
	//str := "技术狼.com"
	//str := "100"
	i := fun.CountDecimalPlaces(str)
	fmt.Println(i)
}

// @title: 保留n位小数
func TestRetainDecimalPlaces(t *testing.T) {
	str := "4.843000"
	amount, err := fun.RetainDecimalPlaces(str, 2)
	fmt.Println(amount, err)
}

// @title: 金额精度
func TestAmountDecimal(t *testing.T) {
	//str := "1.3345345354e+3" // 科学计数
	//str := "1334.5345354354788" // 小数位截取
	str := "1334.5300000000" // 去除无效的0
	decimalStr := fun.AmountDecimal(str, 5)
	fmt.Println(decimalStr)
}

// @title: 移出小数点后无效的数
func TestRemoveAllZerosFromLastDecimal(t *testing.T) {
	str := "4.843000"
	amount := fun.RemoveAllZerosFromLastDecimal(str)
	fmt.Println(amount)
}

struct

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 结构体转换为数组
func TestStructToArr(t *testing.T) {
	type User struct {
		Name string `json:"name" yaml:"name" xml:"name"`
		Sex  int    `json:"sex"`
	}
	str := fun.StructToArr(User{})
	fmt.Println(str)
}

time

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
	"time"
)

// @title: Rfc3339格式时间转为正常时间
func TestRfc3339ToDatetime(t *testing.T) {
	val := "2018-01-14T21:45:54+08:00"
	str := fun.Rfc3339ToDatetime(val)
	fmt.Println(str)
}

// @title: 标准时间转为时间戳
func TestDatetimeToTimestamp(t *testing.T) {
	val := "2018-01-14 21:45:54"
	str := fun.DatetimeToTimestamp(val)
	fmt.Println(str)
}

// @title: 标准时间转化为时间戳
func TestTimestampToDatetime(t *testing.T) {
	str := fun.TimestampToDatetime(1515937554)
	fmt.Println(str)
}

// @title: 获取当前标准时间
func TestCurrentDateTime(t *testing.T) {
	str := fun.CurrentDateTime()
	fmt.Println(str)
}

// @title: 获取当前时间戳（秒）
func TestTimeStampSecond(t *testing.T) {
	data := fun.TimeStampSecond()
	fmt.Println(data)
}

// @title: 获取当前时间戳（毫秒）
func TestMillisecond(t *testing.T) {
	data := fun.Millisecond()
	fmt.Println(data)
}

// @title: 一个字符串时间与当前时间的时间差
func TestDateTimeStrAadNowSub(t *testing.T) {
	data, err := fun.DateTimeStrAadNowSub("2022-05-22 23:59:59")
	fmt.Println(data, err)
}

// @title: 时间戳转数字格式日期字符
func TestTimestampToDate(t *testing.T) {
	str := fun.TimestampToDate(time.Now().Unix(), time.UTC)
	fmt.Println(str) // 2023-04-04
}

// @title: 时间戳转数字格式日期字符
func TestTimestampToDateNumber(t *testing.T) {
	str := fun.TimestampToDateNumber(time.Now().Unix(), fun.LocAsiaShanghai())
	fmt.Println(str) // 20230404
}

// @title: 时间戳转数字格式日期字符
func TestLocAsiaShanghai(t *testing.T) {
	data := fun.LocAsiaShanghai()
	fmt.Println(data)
}

// @title: 时间戳转数字格式日期字符
func TestLocUTC(t *testing.T) {
	data := fun.LocUTC()
	fmt.Println(data)
}

// @title: 时间戳转数字格式日期字符
func TestLocAmericaLosAngeles(t *testing.T) {
	data := fun.LocAmericaLosAngeles()
	fmt.Println(data)
}

// @title: 获取某个时间起，N天内的连续的数字格式日期
func TestGetSometimeApartNDaysTimes(t *testing.T) {
	list := fun.GetSometimeApartNDaysTimes(time.Now().UTC(), +1, 7, true)
	fmt.Println(list)
}

// @title: 获取某个时间起，N天内的连续的时间（指定日期格式）
func TestGetSometimeApartNDaysTimesFormat(t *testing.T) {
	list := fun.GetSometimeApartNDaysTimesFormat(time.Now().UTC(), +1, 7, true, "2006-01-02")
	fmt.Println(list)
}

// @title: 获取某个时间起，第N天内的时间（指定日期格式）
func TestGetSometimeApartNDaysTimeFormat(t *testing.T) {
	date := fun.GetSometimeApartNDaysTimeFormat(time.Now().UTC(), +1, "2006-01-02")
	fmt.Println(date) // 明天日期
}

web

package test

import (
	"fmt"
	fun "gitee.com/jishulangcom/go-fun"
	"testing"
)

// @title: 获取URL主域名
func TestUrlDomain(t *testing.T) {
	str := fun.UrlDomain("https://www.jishulang.com/index.html?source=gofun")
	fmt.Println(str)
}

// @title: 获取服务器端IP
func TestServeIp(t *testing.T) {
	str := fun.ServeIp()
	fmt.Println(str)
}