# go-fun **Repository Path**: jishulangcom/go-fun ## Basic Information - **Project Name**: go-fun - **Description**: golang常用方法（字符串、数组、文件操作、算法、加密等） - **Primary Language**: Go - **License**: Apache-2.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 1 - **Created**: 2023-12-30 - **Last Updated**: 2025-09-12 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README #### algorithm ```go 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 ```go 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 ```go 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 ```go 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 ```go 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 ```go 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 ```go 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 ```go 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 ```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 ```go 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 ```go 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 ```go 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 ```go ``` #### rsa ```go 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 ```go 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 ```go 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("815437877@qq.com") 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 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 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 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 } // @title: string转*big.Float func TestStrToBigFloat(t *testing.T) { i, err := fun.StrToBigFloat("123456.789") fmt.Println(i, err) // 123456 } // @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 ```go 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 ```go 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 ```go 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) } ```