# ixUtils

**Repository Path**: ixgo/utils

## Basic Information

- **Project Name**: ixUtils
- **Description**: golang常用函数库
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-09-19
- **Last Updated**: 2025-10-13

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# ixUtils - Go 语言工具包

[![Go Version](https://img.shields.io/badge/Go-%3E%3D%201.18-blue.svg)](https://golang.org/)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)

ixUtils 是一个功能丰富的 Go 语言工具包，提供了日常开发中常用的工具函数，涵盖ID生成、网络工具、数学计算、字符串处理、数组操作、结构体操作、加密解密、HTTP 请求、并发控制、文件操作、时间处理等20多个功能模块。

## ✨ 特性

- 🚀 **高性能**: 优化的算法实现，注重性能
- 🔧 **易用性**: 简洁的 API 设计，开箱即用
- 🛡️ **类型安全**: 使用 Go 泛型，提供类型安全的操作
- 📦 **模块化**: 按功能分类，便于按需使用
- 🧪 **测试完备**: 完整的单元测试覆盖
- 📚 **文档详细**: 详细的使用说明和示例
- 🌐 **分布式友好**: 支持雪花ID、链路追踪等分布式场景
- 📊 **业务导向**: 提供订单ID、API密钥等业务专用功能

## 📁 功能模块

### 🆔 ID生成工具 (id.go)

强大的ID生成工具，支持UUID、雪花ID、短ID等多种ID生成方式，满足分布式系统和各种业务场景的需求。

#### 主要函数

**UUID生成**
- `GenerateUUID() string` - 生成标准UUID (RFC 4122 Version 4)
- `GenerateUUIDv4() string` - 生成UUID Version 4 (随机)
- `GenerateUUIDv1() string` - 生成UUID Version 1 (基于时间和MAC地址)
- `GenerateSimpleUUID() string` - 生成简单UUID (无连字符)
- `GenerateShortUUID() string` - 生成短UUID (22字符)

**雪花ID (Snowflake)**
- `GenerateSnowflakeID() int64` - 生成雪花ID (使用全局生成器)
- `NewSnowflakeGenerator(workerID, datacenterID int64) (*SnowflakeGenerator, error)` - 创建自定义雪花ID生成器
- `ParseSnowflakeID(id int64) map[string]int64` - 解析雪花ID

**短ID生成**
- `GenerateShortID() string` - 生成短ID (8字符)
- `GenerateShortIDWithLength(length int) string` - 生成指定长度的短ID
- `GenerateNanoID(size int) string` - 生成NanoID风格的ID

**ObjectID (MongoDB风格)**
- `GenerateObjectID() string` - 生成ObjectID (MongoDB风格)
- `ParseObjectID(objectID string) (map[string]interface{}, error)` - 解析ObjectID

**业务专用ID**
- `GenerateOrderID() string` - 生成订单ID (时间戳+随机数)
- `GenerateTraceID() string` - 生成链路追踪ID
- `GenerateSpanID() string` - 生成Span ID
- `GenerateRequestID() string` - 生成请求ID
- `GenerateSessionID() string` - 生成会话ID
- `GenerateAPIKey() string` - 生成API密钥
- `GenerateSecretKey() string` - 生成密钥

**验证函数**
- `ValidateUUID(uuid string) bool` - 验证UUID格式
- `ValidateObjectID(objectID string) bool` - 验证ObjectID格式

#### 使用示例

```go
import "gitee.com/ixgo/ixutils"

// UUID生成
uuid := ixUtils.GenerateUUID()
fmt.Println("UUID:", uuid) // UUID: 550e8400-e29b-41d4-a716-446655440000

// 雪花ID生成
snowflakeID := ixUtils.GenerateSnowflakeID()
fmt.Println("雪花ID:", snowflakeID) // 雪花ID: 1234567890123456789

// 解析雪花ID
parsed := ixUtils.ParseSnowflakeID(snowflakeID)
fmt.Printf("解析结果: %+v\n", parsed)

// 业务ID生成
orderID := ixUtils.GenerateOrderID()
apiKey := ixUtils.GenerateAPIKey()
fmt.Println("订单ID:", orderID) // 订单ID: 20230915143052123456
fmt.Println("API密钥:", apiKey) // API密钥: ak_1BvXerhVlMpXzRv4x2Nq8uY3Kw5Zr7tS
```
 

### 🌐 网络工具 (net.go)

全面的网络处理工具，包含IP处理、网络检测、域名解析等功能。

#### 主要函数

**IP处理**
- `GetLocalIP() string` - 获取本机内网IP地址
- `GetLocalIPs() []string` - 获取本机所有内网IP地址
- `GetPublicIP() string` - 获取公网IP地址
- `IsPrivateIP(ip string) bool` - 检查是否为私有IP地址
- `IsPublicIP(ip string) bool` - 检查是否为公网IP地址
- `IPToInt(ip string) uint32` - 将IP地址转换为32位无符号整数
- `IntToIP(ipInt uint32) string` - 将32位无符号整数转换为IP地址
- `IsValidIP(ip string) bool` - 检查IP地址格式是否有效
- `IsValidIPv4(ip string) bool` - 检查是否为有效的IPv4地址
- `IsValidIPv6(ip string) bool` - 检查是否为有效的IPv6地址

**网络检测**
- `Ping(host string) bool` - 检测主机是否可达
- `PingWithTimeout(host string, timeout time.Duration) bool` - 带超时的Ping检测
- `IsPortOpen(host string, port int) bool` - 检查指定主机的端口是否开放
- `IsPortOpenWithTimeout(host, port, timeout) bool` - 带超时的端口检测
- `ScanPorts(host string, startPort, endPort int) []int` - 扫描主机的端口范围
- `ScanPortsWithTimeout(host, startPort, endPort, timeout) []int` - 带超时的端口扫描

**域名解析**
- `GetDomainIP(domain string) []string` - 获取域名对应的IP地址列表
- `GetDomainIPWithTimeout(domain, timeout) []string` - 带超时的域名解析
- `GetDomainIPv4(domain string) []string` - 获取域名对应的IPv4地址列表
- `GetDomainIPv6(domain string) []string` - 获取域名对应的IPv6地址列表

**网络信息**
- `GetMACAddress() string` - 获取本机MAC地址
- `GetAllMACAddresses() map[string]string` - 获取所有网络接口的MAC地址
- `GetNetworkInterfaces() []NetworkInterface` - 获取网络接口信息

**网络工具**
- `IsValidPort(port int) bool` - 检查端口号是否有效
- `IsValidDomain(domain string) bool` - 检查域名格式是否有效
- `GetFreePort() (int, error)` - 获取一个可用的端口号
- `IsLocalhost(host string) bool` - 检查是否为本地地址
- `JoinHostPort(host string, port int) string` - 组合主机和端口
- `ParseHostPort(hostPort string) (host string, port int, err error)` - 解析主机和端口

**连接测试**
- `TestTCPConnection(host string, port int) ConnectionTest` - 测试TCP连接
- `TestUDPConnection(host string, port int) ConnectionTest` - 测试UDP连接
- `BatchTestConnections(hosts []string, ports []int) []ConnectionTest` - 批量测试连接

#### 使用示例

```go
// IP处理
localIP := ixUtils.GetLocalIP()
publicIP := ixUtils.GetPublicIP()
fmt.Printf("本机IP: %s, 公网IP: %s\n", localIP, publicIP)

// 网络检测
if ixUtils.Ping("www.baidu.com") {
    fmt.Println("网络连通")
}

if ixUtils.IsPortOpen("127.0.0.1", 3306) {
    fmt.Println("MySQL服务正在运行")
}

// 域名解析
ips := ixUtils.GetDomainIP("www.baidu.com")
fmt.Println("百度IP地址:", ips)

// 端口扫描
openPorts := ixUtils.ScanPorts("127.0.0.1", 20, 100)
fmt.Println("开放端口:", openPorts)
```

### 🔢 数学工具 (math.go)

全面的数学计算工具，支持基础数学运算、统计计算、数值处理等功能。

#### 主要函数

**基础数学运算**
- `MaxInt(a, b int) int` / `Max[T](a, b T) T` - 返回最大值
- `MinInt(a, b int) int` / `Min[T](a, b T) T` - 返回最小值
- `AbsInt(n int) int` / `Abs[T](n T) T` - 返回绝对值
- `Round(f float64, precision int) float64` - 四舍五入到指定精度
- `Ceil(f float64) int` - 向上取整
- `Floor(f float64) int` - 向下取整

**数值处理**
- `InRangeInt(value, min, max int) bool` / `InRange[T](value, min, max T) bool` - 检查是否在范围内
- `ClampInt(value, min, max int) int` / `Clamp[T](value, min, max T) T` - 限制在范围内
- `PercentageInt(part, total int) float64` / `Percentage[T](part, total T) float64` - 计算百分比
- `AverageInt(numbers []int) float64` / `Average[T](numbers []T) float64` - 计算平均值

**数组运算**
- `SumInt(numbers []int) int` / `Sum[T](numbers []T) T` - 求和
- `MaxSliceInt(numbers []int) int` / `MaxSlice[T](numbers []T) T` - 数组最大值
- `MinSliceInt(numbers []int) int` / `MinSlice[T](numbers []T) T` - 数组最小值

**高级数学**
- `PowerInt(base, exp int) int` - 整数幂运算
- `PowerFloat64(base, exp float64) float64` - 浮点数幂运算
- `Sqrt(f float64) float64` - 平方根
- `GCD(a, b int) int` - 最大公约数
- `LCM(a, b int) int` - 最小公倍数

**数值判断**
- `IsEven(n int) bool` - 检查是否为偶数
- `IsOdd(n int) bool` - 检查是否为奇数

#### 使用示例

```go
// 基础数学运算
fmt.Println("最大值:", ixUtils.Max(10, 20))           // 20
fmt.Println("绝对值:", ixUtils.Abs(-15))             // 15
fmt.Println("四舍五入:", ixUtils.Round(3.14159, 2))   // 3.14

// 数值处理
fmt.Println("在范围内:", ixUtils.InRange(15, 10, 20)) // true
fmt.Println("限制范围:", ixUtils.Clamp(25, 10, 20))   // 20
fmt.Println("百分比:", ixUtils.Percentage(25, 100))   // 25.0

// 数组运算
numbers := []int{10, 20, 30, 40, 50}
fmt.Println("平均值:", ixUtils.Average(numbers))      // 30.0
fmt.Println("总和:", ixUtils.Sum(numbers))           // 150
fmt.Println("最大值:", ixUtils.MaxSlice(numbers))     // 50
```

### 🔤 字符串工具 (string.go)

强大的字符串处理工具，包含字符串格式化、命名转换、验证等功能。

#### 主要函数

**字符串格式化**
- `PadLeft(str string, length int, pad string) string` - 左侧填充
- `PadRight(str string, length int, pad string) string` - 右侧填充
- `Truncate(str string, length int, suffix string) string` - 截断字符串
- `Capitalize(str string) string` - 首字母大写
- `LowerCase(str string) string` - 转小写
- `UpperCase(str string) string` - 转大写

**命名转换**
- `CamelCase(str string) string` - 转驼峰命名
- `PascalCase(str string) string` - 转帕斯卡命名
- `SnakeCase(str string) string` - 转蛇形命名
- `KebabCase(str string) string` - 转短横线命名
- `TitleCase(str string) string` - 转标题格式

**字符串操作**
- `Trim(str string) string` - 去除前后空格
- `TrimLeft(str, cutset string) string` - 去除左侧字符
- `TrimRight(str, cutset string) string` - 去除右侧字符
- `ReverseString(str string) string` - 反转字符串
- `Repeat(str string, count int) string` - 重复字符串

**字符串判断**
- `IsBlank(str string) bool` - 是否为空白字符串
- `IsNotEmpty(str string) bool` - 是否非空
- `IsNotBlank(str string) bool` - 是否非空白

**字符串验证**
- `IsEmail(str string) bool` - 验证邮箱格式
- `IsPhone(str string) bool` - 验证手机号
- `IsURL(str string) bool` - 验证URL格式
- `IsIP(str string) bool` - 验证IP地址
- `IsIPv4(str string) bool` - 验证IPv4地址
- `IsIPv6(str string) bool` - 验证IPv6地址
- `IsNumeric(str string) bool` - 验证是否为数字
- `IsInteger(str string) bool` - 验证是否为整数
- `IsFloat(str string) bool` - 验证是否为浮点数
- `IsAlpha(str string) bool` - 验证是否为字母
- `IsAlphaNumeric(str string) bool` - 验证是否为字母数字

#### 使用示例

```go
// 字符串格式化
fmt.Println("左填充:", ixUtils.PadLeft("123", 5, "0"))      // 00123
fmt.Println("截断:", ixUtils.Truncate("Hello World", 5, "...")) // Hello...
fmt.Println("首字母大写:", ixUtils.Capitalize("hello"))        // Hello

// 命名转换
fmt.Println("驼峰命名:", ixUtils.CamelCase("hello_world"))     // helloWorld
fmt.Println("蛇形命名:", ixUtils.SnakeCase("HelloWorld"))     // hello_world
fmt.Println("短横线:", ixUtils.KebabCase("HelloWorld"))       // hello-world

// 字符串验证
fmt.Println("邮箱验证:", ixUtils.IsEmail("test@example.com")) // true
fmt.Println("手机验证:", ixUtils.IsPhone("13800138000"))      // true
fmt.Println("数字验证:", ixUtils.IsNumeric("12345"))         // true
```

### 🔢 版本比较 (ver.go)

版本号比较工具，支持语义化版本号的大小比较。

#### 主要函数

- `CompareVersion(v1, v2 string) int` - 比较两个版本号大小

#### 使用示例

```go
// 版本号比较
result := ixUtils.CompareVersion("1.2.3", "1.2.4")
// result = -1 (1.2.3 < 1.2.4)

result = ixUtils.CompareVersion("2.0.0", "1.9.9")
// result = 1 (2.0.0 > 1.9.9)

result = ixUtils.CompareVersion("1.0.0", "1.0.0")
// result = 0 (1.0.0 = 1.0.0)

// 支持v前缀和预发布版本
result = ixUtils.CompareVersion("v1.2.3", "v1.2.4")    // -1
result = ixUtils.CompareVersion("1.2", "1.2.0")        // 0
```

### 📊 数组工具 (array.go)

强大的数组处理工具，使用Go泛型提供类型安全的数组操作。

#### 主要函数

**基础操作**
- `Contains[T comparable](arr []T, v T) bool` - 检查数组是否包含指定元素
- `IndexOf[T comparable](arr []T, v T) int` - 查找元素在数组中的索引
- `Remove[T comparable](arr []T, v T) []T` - 从数组中移除指定元素
- `Reverse[T any](arr []T) []T` - 反转数组

**数组处理**
- `Unique[T comparable](arr []T) []T` - 去除数组中的重复元素
- `Filter[T any](arr []T, f func(T) bool) []T` - 过滤数组元素
- `Map[T any, R any](arr []T, f func(T) R) []R` - 映射数组元素
- `Concat[T any](slices ...[]T) []T` - 连接多个数组

**条件判断**
- `Any[T any](arr []T, f func(T) bool) bool` - 检查是否有任何元素满足条件
- `All[T any](arr []T, f func(T) bool) bool` - 检查是否所有元素都满足条件

**集合操作**
- `Union[T comparable](a, b []T) []T` - 数组并集
- `Intersect[T comparable](a, b []T) []T` - 数组交集
- `Difference[T comparable](a, b []T) []T` - 数组差集

#### 使用示例

```go
// 基础操作
numbers := []int{1, 2, 3, 4, 5}
fmt.Println("包含3:", ixUtils.Contains(numbers, 3))        // true
fmt.Println("3的索引:", ixUtils.IndexOf(numbers, 3))       // 2
fmt.Println("移除3:", ixUtils.Remove(numbers, 3))         // [1, 2, 4, 5]

// 数组处理
duplicates := []int{1, 2, 2, 3, 3, 4}
fmt.Println("去重:", ixUtils.Unique(duplicates))          // [1, 2, 3, 4]

evens := ixUtils.Filter(numbers, func(n int) bool { return n%2 == 0 })
fmt.Println("偶数:", evens)                              // [2, 4]

doubled := ixUtils.Map(numbers, func(n int) int { return n * 2 })
fmt.Println("翻倍:", doubled)                            // [2, 4, 6, 8, 10]

// 集合操作
a := []int{1, 2, 3}
b := []int{3, 4, 5}
fmt.Println("并集:", ixUtils.Union(a, b))                // [1, 2, 3, 4, 5]
fmt.Println("交集:", ixUtils.Intersect(a, b))            // [3]
fmt.Println("差集:", ixUtils.Difference(a, b))           // [1, 2]
```

### 🏗️ 结构体工具 (struct.go)

全面的结构体操作工具，支持结构体与Map的相互转换、字段操作等。

#### 主要函数

**基础转换**
- `StructToMap(obj interface{}) (map[string]interface{}, error)` - 结构体转Map
- `MapToStruct(data map[string]interface{}, result interface{}) error` - Map转结构体
- `StructToMapWithTag(obj interface{}, tagName string) (map[string]interface{}, error)` - 使用指定tag转换
- `MapToStructWithTag(data map[string]interface{}, result interface{}, tagName string) error` - 使用指定tag转换

**字段操作**
- `GetStructFields(obj interface{}) []string` - 获取结构体字段名列表
- `GetStructTags(obj interface{}, tagName string) map[string]string` - 获取结构体标签
- `GetStructFieldValue(obj interface{}, fieldName string) (interface{}, error)` - 获取字段值
- `SetStructFieldValue(obj interface{}, fieldName string, value interface{}) error` - 设置字段值
- `HasStructField(obj interface{}, fieldName string) bool` - 检查是否有指定字段
- `GetStructFieldType(obj interface{}, fieldName string) (reflect.Type, error)` - 获取字段类型

**JSON转换**
- `StructToJson(obj interface{}) (string, error)` - 结构体转JSON
- `JsonToStruct(data string, result interface{}) error` - JSON转结构体

**结构体复制**
- `CopyStruct(src, dst interface{}) error` - 复制结构体

**强制转换版本 (Must系列)**
- `MustStructToMap(obj interface{}) map[string]interface{}` - 强制结构体转Map
- `MustMapToStruct(data map[string]interface{}, result interface{})` - 强制Map转结构体
- `MustGetStructFieldValue(obj interface{}, fieldName string) interface{}` - 强制获取字段值
- `MustSetStructFieldValue(obj interface{}, fieldName string, value interface{})` - 强制设置字段值
- `MustStructToJson(obj interface{}) string` - 强制结构体转JSON
- 等等...

#### 使用示例

```go
type User struct {
    Name  string `json:"name" db:"user_name"`
    Age   int    `json:"age" db:"user_age"`
    Email string `json:"email" db:"user_email"`
}

user := User{Name: "张三", Age: 25, Email: "zhangsan@example.com"}

// 结构体转Map
userMap, err := ixUtils.StructToMap(user)
fmt.Printf("用户Map: %+v\n", userMap)

// 使用指定tag转换
dbMap, err := ixUtils.StructToMapWithTag(user, "db")
fmt.Printf("数据库Map: %+v\n", dbMap)

// 获取字段信息
fields := ixUtils.GetStructFields(user)
fmt.Println("字段列表:", fields)

// 获取字段值
name, err := ixUtils.GetStructFieldValue(user, "Name")
fmt.Println("姓名:", name)

// 强制转换 (不返回错误)
userMap2 := ixUtils.MustStructToMap(user)
fmt.Printf("强制转换: %+v\n", userMap2)
```

### 📄 JSON工具 (json.go)

完整的JSON处理工具，支持编码、解码、文件操作、流处理等。

#### 主要函数

**基础JSON操作**
- `JsonEncode(v interface{}) (string, error)` - JSON编码
- `JsonEncodePretty(v interface{}) (string, error)` - 格式化JSON编码
- `JsonDecode(data string, v interface{}) error` - JSON解码
- `IsValidJson(str string) bool` - 验证JSON格式

**文件操作**
- `JsonEncodeFile(v interface{}, filename string) error` - 编码到文件
- `JsonDecodeFile(filename string, v interface{}) error` - 从文件解码

**流操作**
- `JsonEncodeStream(v interface{}, w io.Writer) error` - 流编码
- `JsonDecodeStream(r io.Reader, v interface{}) error` - 流解码

**JSON操作**
- `JsonGetField(data string, field string) (interface{}, error)` - 获取JSON字段
- `JsonSetField(data string, field string, value interface{}) (string, error)` - 设置JSON字段
- `JsonMerge(json1, json2 string) (string, error)` - 合并JSON

**强制转换版本 (Must系列)**
- `MustJsonEncode(v interface{}) string` - 强制JSON编码
- `MustJsonEncodePretty(v interface{}) string` - 强制格式化编码
- `MustJsonDecode(data string, v interface{})` - 强制JSON解码
- 等等...

#### 使用示例

```go
user := map[string]interface{}{
    "name": "张三",
    "age":  25,
    "email": "zhangsan@example.com",
}

// JSON编码
jsonStr, err := ixUtils.JsonEncode(user)
fmt.Println("JSON:", jsonStr)

// 格式化编码
prettyJson, err := ixUtils.JsonEncodePretty(user)
fmt.Println("格式化JSON:", prettyJson)

// JSON解码
var result map[string]interface{}
err = ixUtils.JsonDecode(jsonStr, &result)

// JSON验证
fmt.Println("有效JSON:", ixUtils.IsValidJson(jsonStr)) // true

// 强制编码 (不返回错误)
jsonStr2 := ixUtils.MustJsonEncode(user)
fmt.Println("强制编码:", jsonStr2)
```

### 🔄 类型转换 (convert.go)

强大的类型转换工具，支持字符串、数字、布尔值等类型之间的相互转换。

#### 主要函数

**字符串转换**
- `StringToInt(str string) (int, error)` - 字符串转整数
- `StringToInt64(str string) (int64, error)` - 字符串转64位整数
- `StringToFloat(str string) (float64, error)` - 字符串转浮点数
- `StringToBool(str string) (bool, error)` - 字符串转布尔值

**数字转换**
- `IntToString(num int) string` - 整数转字符串
- `Int64ToString(num int64) string` - 64位整数转字符串
- `FloatToString(num float64) string` - 浮点数转字符串
- `BoolToString(b bool) string` - 布尔值转字符串

**安全转换 (带默认值)**
- `StringToIntWithDefault(str string, defaultValue int) int` - 字符串转整数(带默认值)
- `StringToInt64WithDefault(str string, defaultValue int64) int64` - 字符串转64位整数(带默认值)
- `StringToFloatWithDefault(str string, defaultValue float64) float64` - 字符串转浮点数(带默认值)
- `StringToBoolWithDefault(str string, defaultValue bool) bool` - 字符串转布尔值(带默认值)

**接口转换**
- `InterfaceToString(v interface{}) string` - 接口转字符串
- `InterfaceToInt(v interface{}) (int, error)` - 接口转整数
- `InterfaceToFloat(v interface{}) (float64, error)` - 接口转浮点数
- `InterfaceToBool(v interface{}) (bool, error)` - 接口转布尔值

#### 使用示例

```go
// 字符串转换
num, err := ixUtils.StringToInt("123")
fmt.Println("字符串转整数:", num) // 123

// 安全转换 (带默认值)
num2 := ixUtils.StringToIntWithDefault("abc", 0)
fmt.Println("安全转换:", num2) // 0 (转换失败使用默认值)

// 数字转换
str := ixUtils.IntToString(456)
fmt.Println("整数转字符串:", str) // "456"

// 接口转换
var value interface{} = "789"
num3, err := ixUtils.InterfaceToInt(value)
fmt.Println("接口转整数:", num3) // 789
```

### 🔀 三元运算 (ternary.go)

提供三元运算符和空值合并等便捷函数。

#### 主要函数

- `Ternary[T any](cond bool, a, b T) T` - 三元运算符
- `Coalesce[T comparable](values ...T) T` - 返回第一个非零值
- `IfThenElse[T any](cond bool, ifFunc, elseFunc func() T) T` - 条件执行函数
- `Switch[T comparable, R any](value T, cases map[T]R, defaultValue R) R` - Switch语句

#### 使用示例

```go
// 三元运算符
result := ixUtils.Ternary(10 > 5, "大于", "小于等于")
fmt.Println(result) // "大于"

// 空值合并
str := ixUtils.Coalesce("", "默认值", "其他")
fmt.Println(str) // "默认值"

// 条件执行
result2 := ixUtils.IfThenElse(true, 
    func() string { return "执行if" },
    func() string { return "执行else" })
fmt.Println(result2) // "执行if"
```

### 🌐 HTTP工具 (http.go)

全面的HTTP请求工具，支持GET、POST、PUT、DELETE等各种HTTP方法，以及文件上传、Cookie管理等功能。

#### 主要函数

**基础HTTP请求**
- `HttpGet(url string, config ...*HttpConfig) (*HttpResponse, error)` - GET请求
- `HttpPost(url string, data interface{}, config ...*HttpConfig) (*HttpResponse, error)` - POST请求
- `HttpPut(url string, data interface{}, config ...*HttpConfig) (*HttpResponse, error)` - PUT请求
- `HttpDelete(url string, config ...*HttpConfig) (*HttpResponse, error)` - DELETE请求

**表单和文件上传**
- `HttpPostForm(url string, data map[string]string, config ...*HttpConfig) (*HttpResponse, error)` - 表单提交
- `HttpUploadFile(url, fieldName, filePath string, config ...*HttpConfig) (*HttpResponse, error)` - 文件上传
- `HttpUploadMultipleFiles(url string, files map[string]string, config ...*HttpConfig) (*HttpResponse, error)` - 多文件上传

**下载功能**
- `HttpDownloadFile(url, filePath string, config ...*HttpConfig) error` - 文件下载
- `HttpDownloadWithProgress(url, filePath string, progress func(downloaded, total int64), config ...*HttpConfig) error` - 带进度的下载

**客户端管理**
- `NewHttpClient(config *HttpConfig) *http.Client` - 创建HTTP客户端
- `SetDefaultHttpConfig(config *HttpConfig)` - 设置默认配置

#### 使用示例

```go
// 基础GET请求
resp, err := ixUtils.HttpGet("https://api.example.com/users")
if err == nil {
    fmt.Println("响应状态:", resp.StatusCode)
    fmt.Println("响应内容:", resp.Text)
}

// POST请求发送JSON
data := map[string]interface{}{
    "name": "张三",
    "age":  25,
}
resp, err = ixUtils.HttpPost("https://api.example.com/users", data)

// 自定义配置
config := &ixUtils.HttpConfig{
    Timeout: 30 * time.Second,
    Headers: map[string]string{
        "Authorization": "Bearer token123",
        "Content-Type":  "application/json",
    },
}
resp, err = ixUtils.HttpGet("https://api.example.com/protected", config)

// 文件上传
err = ixUtils.HttpUploadFile("https://api.example.com/upload", "file", "/path/to/file.jpg")

// 文件下载
err = ixUtils.HttpDownloadFile("https://example.com/file.zip", "/path/to/save/file.zip")
```

### 🔐 加密工具 (crypto.go)

全面的加密和编码工具，支持MD5、SHA系列、HMAC、Base64、Hex等多种加密和编码方式。

#### 主要函数

**MD5加密**
- `MD5(str string) string` - 计算字符串的MD5值
- `MD5File(filePath string) (string, error)` - 计算文件的MD5值

**SHA系列加密**
- `SHA1(str string) string` - 计算字符串的SHA1值
- `SHA256(str string) string` - 计算字符串的SHA256值
- `SHA512(str string) string` - 计算字符串的SHA512值
- `SHA1File(filePath string) (string, error)` - 计算文件的SHA1值
- `SHA256File(filePath string) (string, error)` - 计算文件的SHA256值
- `SHA512File(filePath string) (string, error)` - 计算文件的SHA512值

**HMAC加密**
- `HmacSHA1(str, key string) string` - HMAC-SHA1加密
- `HmacSHA256(str, key string) string` - HMAC-SHA256加密
- `HmacSHA512(str, key string) string` - HMAC-SHA512加密

**Base64编码**
- `Base64Encode(str string) string` - Base64编码
- `Base64Decode(str string) (string, error)` - Base64解码
- `Base64UrlEncode(str string) string` - Base64 URL安全编码
- `Base64UrlDecode(str string) (string, error)` - Base64 URL安全解码

**Hex编码**
- `HexEncode(str string) string` - Hex编码
- `HexDecode(str string) (string, error)` - Hex解码

#### 使用示例

```go
text := "Hello, World!"

// MD5加密
md5Hash := ixUtils.MD5(text)
fmt.Println("MD5:", md5Hash)

// SHA256加密
sha256Hash := ixUtils.SHA256(text)
fmt.Println("SHA256:", sha256Hash)

// HMAC-SHA256加密
key := "secret-key"
hmacHash := ixUtils.HmacSHA256(text, key)
fmt.Println("HMAC-SHA256:", hmacHash)

// Base64编码
encoded := ixUtils.Base64Encode(text)
fmt.Println("Base64编码:", encoded)

decoded, err := ixUtils.Base64Decode(encoded)
if err == nil {
    fmt.Println("Base64解码:", decoded)
}

// 文件MD5
fileMD5, err := ixUtils.MD5File("/path/to/file.txt")
if err == nil {
    fmt.Println("文件MD5:", fileMD5)
}
```

### 🎲 随机数工具 (random.go)

强大的随机数生成工具，支持随机整数、随机字符串、随机数组等功能。

#### 主要函数

**随机数生成**
- `RandomInt(min, max int) int` - 生成指定范围的随机整数
- `RandomInt64(min, max int64) int64` - 生成指定范围的随机64位整数
- `RandomFloat64(min, max float64) float64` - 生成指定范围的随机浮点数

**随机字符串**
- `RandomString(length int) string` - 生成指定长度的随机字符串
- `RandomStringWithCharset(length int, charset string) string` - 使用指定字符集生成随机字符串
- `RandomNumberString(length int) string` - 生成指定长度的随机数字字符串
- `RandomLetterString(length int) string` - 生成指定长度的随机字母字符串

**随机选择**
- `RandomChoice[T any](slice []T) T` - 从切片中随机选择一个元素
- `RandomChoices[T any](slice []T, count int) []T` - 从切片中随机选择多个元素
- `RandomSample[T any](slice []T, count int) []T` - 从切片中随机采样(不重复)

**随机布尔和概率**
- `RandomBool() bool` - 生成随机布尔值
- `RandomBoolWithProbability(probability float64) bool` - 按概率生成布尔值

**数组打乱**
- `Shuffle[T any](slice []T) []T` - 打乱数组顺序
- `ShuffleInPlace[T any](slice []T)` - 原地打乱数组

#### 使用示例

```go
// 随机数生成
randomNum := ixUtils.RandomInt(1, 100)
fmt.Println("随机数:", randomNum)

// 随机字符串
randomStr := ixUtils.RandomString(10)
fmt.Println("随机字符串:", randomStr)

// 自定义字符集
customStr := ixUtils.RandomStringWithCharset(8, "ABCDEF0123456789")
fmt.Println("自定义字符串:", customStr)

// 随机选择
fruits := []string{"苹果", "香蕉", "橙子", "葡萄"}
randomFruit := ixUtils.RandomChoice(fruits)
fmt.Println("随机水果:", randomFruit)

// 随机采样
samples := ixUtils.RandomSample(fruits, 2)
fmt.Println("随机采样:", samples)

// 数组打乱
numbers := []int{1, 2, 3, 4, 5}
shuffled := ixUtils.Shuffle(numbers)
fmt.Println("打乱后:", shuffled)
```

### ⚙️ 配置管理 (config.go)

强大的配置文件处理工具，支持JSON、YAML、ENV等多种格式的配置文件。

#### 主要函数

**配置加载**
- `LoadConfig(filePath string) (Config, error)` - 加载配置文件
- `LoadJsonConfig(filePath string) (Config, error)` - 加载JSON配置
- `LoadYamlConfig(filePath string) (Config, error)` - 加载YAML配置
- `LoadEnvConfig() Config` - 加载环境变量配置

**配置操作**
- `Get(key string) interface{}` - 获取配置值
- `GetString(key string) string` - 获取字符串配置
- `GetInt(key string) int` - 获取整数配置
- `GetBool(key string) bool` - 获取布尔配置
- `GetStringSlice(key string) []string` - 获取字符串数组配置

**配置保存**
- `SaveConfig(config Config, filePath string) error` - 保存配置到文件
- `SaveJsonConfig(config Config, filePath string) error` - 保存为JSON格式
- `SaveYamlConfig(config Config, filePath string) error` - 保存为YAML格式

#### 使用示例

```go
// 加载配置文件
config, err := ixUtils.LoadConfig("config.json")
if err != nil {
    log.Fatal(err)
}

// 获取配置值
dbHost := config.GetString("database.host")
dbPort := config.GetInt("database.port")
debug := config.GetBool("debug")

fmt.Printf("数据库: %s:%d, 调试模式: %v\n", dbHost, dbPort, debug)

// 环境变量配置
envConfig := ixUtils.LoadEnvConfig()
port := envConfig.GetString("PORT")
```

### 🔄 并发工具 (concurrent.go)

强大的并发控制工具，提供增强版的WaitGroup、工作池、并发限制等功能。

#### 主要函数

**增强WaitGroup**
- `NewWaitGroup(ctx context.Context, timeout time.Duration) *WaitGroup` - 创建支持超时和取消的WaitGroup
- `Add(delta int)` - 添加等待计数
- `Done()` - 完成一个任务
- `Wait() error` - 等待所有任务完成

**工作池**
- `NewWorkerPool(size int) *WorkerPool` - 创建工作池
- `Submit(task func())` - 提交任务
- `SubmitWithResult[T any](task func() T) <-chan T` - 提交有返回值的任务
- `Close()` - 关闭工作池

**并发限制**
- `NewSemaphore(capacity int) *Semaphore` - 创建信号量
- `Acquire() error` - 获取资源
- `Release()` - 释放资源
- `TryAcquire() bool` - 尝试获取资源

**并发安全计数器**
- `NewCounter() *Counter` - 创建计数器
- `Increment() int64` - 递增
- `Decrement() int64` - 递减
- `Get() int64` - 获取当前值

#### 使用示例

```go
// 使用增强WaitGroup
ctx := context.Background()
wg := ixUtils.NewWaitGroup(ctx, 30*time.Second)

for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        // 执行任务
        time.Sleep(time.Second)
        fmt.Printf("任务 %d 完成\n", id)
    }(i)
}

err := wg.Wait()
if err != nil {
    fmt.Println("等待超时或被取消")
}

// 使用工作池
pool := ixUtils.NewWorkerPool(3)
defer pool.Close()

for i := 0; i < 10; i++ {
    taskID := i
    pool.Submit(func() {
        fmt.Printf("执行任务 %d\n", taskID)
        time.Sleep(time.Second)
    })
}

// 使用信号量限制并发
sem := ixUtils.NewSemaphore(2) // 最多2个并发

for i := 0; i < 5; i++ {
    go func(id int) {
        sem.Acquire() // 获取资源
        defer sem.Release() // 释放资源
        
        fmt.Printf("任务 %d 开始执行\n", id)
        time.Sleep(2 * time.Second)
        fmt.Printf("任务 %d 执行完成\n", id)
    }(i)
}
```

### 📁 文件工具 (file.go)

全面的文件操作工具，支持文件读写、目录操作、文件信息获取等功能。

#### 主要函数

**文件检查**
- `FileExists(path string) bool` - 检查文件是否存在
- `IsDir(path string) bool` - 检查路径是否为目录
- `IsFile(path string) bool` - 检查路径是否为文件
- `GetFileSize(path string) (int64, error)` - 获取文件大小

**文件读写**
- `ReadFile(path string) (string, error)` - 读取文件内容
- `ReadFileBytes(path string) ([]byte, error)` - 读取文件字节
- `WriteFile(path, content string) error` - 写入文件内容
- `WriteFileBytes(path string, data []byte) error` - 写入文件字节
- `AppendFile(path, content string) error` - 追加文件内容

**文件操作**
- `CopyFile(src, dst string) error` - 复制文件
- `MoveFile(src, dst string) error` - 移动文件
- `DeleteFile(path string) error` - 删除文件
- `CreateDir(path string) error` - 创建目录
- `DeleteDir(path string) error` - 删除目录

**文件信息**
- `GetFileInfo(path string) (os.FileInfo, error)` - 获取文件信息
- `GetFileExt(path string) string` - 获取文件扩展名
- `GetFileName(path string) string` - 获取文件名
- `GetFileDir(path string) string` - 获取文件目录

**目录遍历**
- `ListFiles(dir string) ([]string, error)` - 列出目录中的文件
- `ListDirs(dir string) ([]string, error)` - 列出目录中的子目录
- `WalkDir(root string, walkFn filepath.WalkFunc) error` - 遍历目录

#### 使用示例

```go
// 文件检查
if ixUtils.FileExists("test.txt") {
    fmt.Println("文件存在")
}

if ixUtils.IsDir("/tmp") {
    fmt.Println("是目录")
}

// 文件读写
content, err := ixUtils.ReadFile("config.txt")
if err == nil {
    fmt.Println("文件内容:", content)
}

err = ixUtils.WriteFile("output.txt", "Hello, World!")
if err != nil {
    log.Fatal(err)
}

// 文件操作
err = ixUtils.CopyFile("source.txt", "backup.txt")
err = ixUtils.MoveFile("old.txt", "new.txt")

// 目录操作
err = ixUtils.CreateDir("new_directory")
files, err := ixUtils.ListFiles("./")
fmt.Println("当前目录文件:", files)
```

### ⏰ 时间工具 (time.go)

全面的时间处理工具，包含时间格式化、时间计算、时间比较、时区转换等功能。

#### 主要函数

**时间格式化**
- `FormatTime(t time.Time, format string) string` - 格式化时间
- `ParseTime(timeStr, format string) (time.Time, error)` - 解析时间字符串
- `TimeToString(t time.Time) string` - 时间转字符串
- `StringToTime(timeStr string) (time.Time, error)` - 字符串转时间

**时间计算**
- `AddDays(t time.Time, days int) time.Time` - 添加天数
- `AddHours(t time.Time, hours int) time.Time` - 添加小时
- `AddMinutes(t time.Time, minutes int) time.Time` - 添加分钟
- `DiffDays(t1, t2 time.Time) int` - 计算天数差
- `DiffHours(t1, t2 time.Time) int` - 计算小时差
- `DiffMinutes(t1, t2 time.Time) int` - 计算分钟差

**时间判断**
- `IsToday(t time.Time) bool` - 是否为今天
- `IsYesterday(t time.Time) bool` - 是否为昨天
- `IsTomorrow(t time.Time) bool` - 是否为明天
- `IsWeekend(t time.Time) bool` - 是否为周末
- `IsLeapYear(year int) bool` - 是否为闰年

**时间获取**
- `GetNow() time.Time` - 获取当前时间
- `GetToday() time.Time` - 获取今天开始时间
- `GetYesterday() time.Time` - 获取昨天开始时间
- `GetTomorrow() time.Time` - 获取明天开始时间
- `GetWeekStart(t time.Time) time.Time` - 获取周开始时间
- `GetMonthStart(t time.Time) time.Time` - 获取月开始时间

**时区转换**
- `ConvertTimeZone(t time.Time, fromZone, toZone string) (time.Time, error)` - 时区转换
- `ToUTC(t time.Time) time.Time` - 转换为UTC时间
- `ToLocal(t time.Time) time.Time` - 转换为本地时间

#### 使用示例

```go
now := time.Now()

// 时间格式化
formatted := ixUtils.FormatTime(now, ixUtils.TimeFormat)
fmt.Println("格式化时间:", formatted)

// 时间计算
tomorrow := ixUtils.AddDays(now, 1)
fmt.Println("明天:", ixUtils.TimeToString(tomorrow))

// 时间差计算
days := ixUtils.DiffDays(tomorrow, now)
fmt.Println("相差天数:", days)

// 时间判断
fmt.Println("是否今天:", ixUtils.IsToday(now))
fmt.Println("是否周末:", ixUtils.IsWeekend(now))
fmt.Println("是否闰年:", ixUtils.IsLeapYear(2024))

// 获取特定时间
today := ixUtils.GetToday()
weekStart := ixUtils.GetWeekStart(now)
monthStart := ixUtils.GetMonthStart(now)

fmt.Println("今天开始:", ixUtils.TimeToString(today))
fmt.Println("本周开始:", ixUtils.TimeToString(weekStart))
fmt.Println("本月开始:", ixUtils.TimeToString(monthStart))

// 时区转换
utcTime := ixUtils.ToUTC(now)
fmt.Println("UTC时间:", ixUtils.TimeToString(utcTime))
```

## 📦 安装

### Go Modules

```bash
go get gitee.com/ixgo/ixutils
```

### 导入使用

```go
import "gitee.com/ixgo/ixutils"

// 或者使用别名
import ixUtils "gitee.com/ixgo/ixutils"
```

## 🚀 快速开始

```go
package main

import (
    "fmt"
    "gitee.com/ixgo/ixutils"
)

func main() {
    // ID生成
    uuid := ixUtils.GenerateUUID()
    fmt.Println("UUID:", uuid)
    
    // 字符串处理
    camelCase := ixUtils.CamelCase("hello_world")
    fmt.Println("驼峰命名:", camelCase) // helloWorld
    
    // 数组操作
    numbers := []int{1, 2, 3, 4, 5}
    doubled := ixUtils.Map(numbers, func(n int) int { return n * 2 })
    fmt.Println("翻倍数组:", doubled) // [2, 4, 6, 8, 10]
    
    // 数学计算
    average := ixUtils.Average(numbers)
    fmt.Println("平均值:", average) // 3.0
    
    // 时间处理
    now := ixUtils.GetNow()
    tomorrow := ixUtils.AddDays(now, 1)
    fmt.Println("明天:", ixUtils.TimeToString(tomorrow))
    
    // HTTP请求
    resp, err := ixUtils.HttpGet("https://api.github.com")
    if err == nil {
        fmt.Println("GitHub API状态:", resp.StatusCode)
    }
    
    // 文件操作
    if ixUtils.FileExists("config.json") {
        content, _ := ixUtils.ReadFile("config.json")
        fmt.Println("配置内容:", content)
    }
}
```

## 📊 功能统计

| 模块 | 函数数量 | 主要功能 |
|------|----------|----------|
| 🆔 ID生成 | 22+ | UUID、雪花ID、ObjectID、业务ID |
| 🌐 网络工具 | 30+ | IP处理、网络检测、域名解析 |
| 🔢 数学工具 | 25+ | 基础数学、统计计算、数值处理 |
| 🔤 字符串工具 | 19+ | 格式化、验证、命名转换 |
| 📊 数组工具 | 13+ | 泛型数组操作、集合运算 |
| 🏗️ 结构体工具 | 20+ | 结构体转换、字段操作 |
| 📄 JSON工具 | 15+ | JSON编解码、文件操作 |
| 🔄 类型转换 | 20+ | 类型安全转换、默认值处理 |
| 🌐 HTTP工具 | 15+ | HTTP请求、文件上传下载 |
| 🔐 加密工具 | 15+ | MD5、SHA、HMAC、Base64 |
| 🎲 随机工具 | 15+ | 随机数、字符串、数组操作 |
| ⚙️ 配置管理 | 10+ | 多格式配置文件处理 |
| 🔄 并发工具 | 15+ | 并发控制、工作池、信号量 |
| 📁 文件工具 | 20+ | 文件操作、目录遍历 |
| ⏰ 时间工具 | 25+ | 时间处理、格式化、计算 |
| 🔢 版本比较 | 1+ | 语义化版本比较 |
| 🔀 三元运算 | 4+ | 条件运算、空值处理 |

**总计**: 300+ 个实用函数，涵盖18个功能模块

## 🎯 使用场景

### Web开发
- HTTP请求处理、JSON数据处理
- 用户输入验证、数据格式化
- 配置文件管理、日志处理

### 数据处理
- 数据类型转换、结构体操作
- 数学计算、统计分析

### 分布式系统
- 唯一ID生成（UUID、雪花ID）
- 网络检测、服务健康检查
- 并发控制、任务调度

### 文件管理
- 文件读写、目录操作
- 文件加密、完整性校验
- 批量文件处理

### 工具开发
- 命令行工具、脚本开发
- 自动化任务、数据迁移
- 系统监控、性能分析

## 🤝 贡献

欢迎提交 Issue 和 Pull Request 来帮助改进这个工具包！

## 📄 许可证

MIT License

## 🔗 相关链接

- [源码仓库](https://gitee.com/ixgo/go-helper)
- [API文档](https://pkg.go.dev/gitee.com/ixgo/ixutils)
- [更新日志](CHANGELOG.md)

---

**ixUtils** - 让Go开发更简单、更高效！ 🚀