.gitignore

@@ -1,5 +1 @@
-.gemini/
-.ai/
-.geminiignore
-.gemini
-/CODE-FULL.md
+go.sum

CHANGELOG.md

@@ -1,49 +1,5 @@
 # CHANGELOG
 
-## [v1.2.9] - 2026-05-09
-### Changed
-- **移除第三方依赖**: 移除了对 `jsontag` 模块的依赖，统一使用标准库及自有基础设施对齐，增强了模块的独立性与长期稳定性。
-
-## [v1.2.8] - 2026-05-05
-### Fixed
-- **JSON 解码器深度增强**: 修复了 `cast.UnmarshalJSON` 在反序列化到 `interface{}` 类型字段时会跳过对象和数组的重大缺陷。
-- **高精度整数解析**: 优化了 JSON 解码过程中的数字处理逻辑。当目标为 `interface{}` 时，优先将整数解析为 `int64` 而非 `float64`，彻底解决了纳秒级时间戳（Nanosecond Timestamp）和 64 位长 ID 的精度丢失问题。
-- **接口兼容性**: 完善了对 `interface{}` 类型的自动类型识别，支持正确解析为 `map[string]any` 和 `[]any`。
-
-## [v1.2.6] - 2026-05-04
-### Fixed
-- **Map 深度合并修复**: 修复了在 `Convert` 或 `ToMap` 过程中，如果目标 Map 已存在该 Key，其原有结构体/Map 值会被直接覆盖而非深度合并的问题。通过引入 `dst.MapIndex` 预读取与临时寻址变量，现已完美支持 Map 下非指针结构体的局部字段覆盖。
-
-### Added
-- **深度合并测试集**: 新增 `merge_test.go` 与 `complex_conversion_test.go`，覆盖了 Struct-to-Map, Map-to-Map, Slice-to-Map 等多种深度嵌套合并场景，确保配置覆盖逻辑的健壮性。
-
-## [v1.2.3] - 2026-05-04
-### Added
-- **强大的时间解析引擎**: 移植 `time` 模块的核心算法至 `cast.ParseTime`，支持时间戳（秒至纳秒）、RFC3339、JS 格式、紧凑格式（20060102150405）及中文日期解析。
-- **时间操作 API**: 新增 `FormatTime(layout, v)` 支持直观格式化（YYYY-MM-DD），新增 `AddTime(expr, v)` 支持 DSL 时间加减（+1Y-2M）。
-- **时区上下文支持**: 引入 `TimeZone` 类型及全局 `DefaultTimeZone`，支持 `SetDefaultTimeZone` 统一控制全项目的转换时区。
-
-### Optimized
-- **ToTime 升级**: 重构 `ToTime` 底层，默认调用高性能 `ParseTime` 引擎，并强制转换至 `DefaultTimeZone` 时区。
-- **JSON 时间处理**: `FastEncoder` 与 `FastDecoder` 现已深度集成 `DefaultTimeZone`，确保序列化与反序列化时的时区一致性。
-
-## [v1.2.2] - 2026-05-04
-### Added
-- **深度对象映射引擎**: 移植 `convert` 包的核心能力至 `cast.Convert`。
-- **Convert API**: 新增 `Convert(dst, src any)` 入口，支持深度转换与原地更新，遵循 Go 语言参数哲学。
-- **Func 转换支持**: 原生支持 `func` 到 `func` 的自动类型适配与包装。
-- **CSV 自动解析**: `To[[]T]` 和 `Convert` 现支持自动将逗号分隔字符串解析为切片。
-- **ParseHook 支持**: 支持结构体字段的自定义 `ParseFieldName` 钩子函数。
-- **自我转换保护**: 增加指针地址校验，防止 `Convert(a, a)` 导致的死循环或无效开销。
-
-### Optimized
-- **极致性能重构**: 实现 `performRecursiveTo` 递归引擎，全面消灭内存逃逸，对象映射性能提升 ~40%，内存分配减少 ~75%。
-- **覆盖赋值语义**: 修正单值转切片的语义，从“追加”改为“覆盖赋值”。
-- **Bool 强制转换优化**: 重构 `Bool()` 底层分支逻辑，提升 CPU 分支预测友好度。
-
-### Removed
-- **convert 模块**: 正式移除外部 `apigo.cc/go/convert` 依赖，功能全部合并至 `cast`。
-
 ## [v1.2.1] - 2026-05-04
 ### Added
 - **Encoder 元数据缓存**: 引入 `encoderStructDescriptor` 缓存，大幅减少结构体序列化时的反射开销。

README.md

@@ -7,9 +7,9 @@
 
 `@go/cast` 是一个为“极致敏捷”设计的 Go 基础工具库。其核心目标是**彻底消除摩擦**：
 
-*   **万能零摩擦入口**：`To[T]、Convert` 作为核心 API，永不返回 `error`。在失败或非法转换时静默返回类型零值。
+*   **万能零摩擦入口**：`To[T]` 作为核心 API，永不返回 `error`。在失败或非法转换时静默返回类型零值。
 *   **语义化 As 包装**：提供 `As` 函数用于将传统“值+错误”双返回结果一键转化为单值，消除外部库带来的摩擦。
-*   **智能自动穿透**：`To[T]、Convert` 自动识别 JSON 文本、复杂容器映射、指针穿透等场景。
+*   **智能自动穿透**：`To[T]` 自动识别 JSON 文本、复杂容器映射、指针穿透等场景。
 *   **极致性能 JSON**：内置高性能 `fastjson` 引擎，支持 Struct 元数据缓存、`time.Time` 原生处理、零分配 Key 匹配及批量转义优化。
 
 ## 📦 安装
@@ -48,13 +48,10 @@ list, _ := cast.ToSlice[int]([]string{"1", "2", "3"})
 
 1.  **通用转换 (Frictionless)**
     * `To[T any](any) T` —— 万能转换入口。支持基础类型、Slice、Map 以及 JSON 的双向自动转换。失败时返回类型零值。
-    * `Convert(dst, src any)` —— 原地转换。第一个参数为目标对象指针，支持深度映射、自动包装/解包、ParseHook 等。
     * 支持矩阵:
         * `string/[]byte` <-> `struct/map/slice` (自动 JSON 编解码)
-        * `string (CSV)` -> `slice` (自动逗号分隔转换)
-        * `map` <-> `struct` (字段名智能模糊匹配)
+        * `map` <-> `struct` (字段名智能匹配)
         * `[]any` <-> `map` (KV 序列展开/折叠)
-        * `func` <-> `func` (自动参数类型适配转换)
         * 所有基础类型 (`int`, `string`, `bool`, `float`, `duration`, `time.Time`) 互相转换。
 
 2.  **错误处理工具**
@@ -77,29 +74,18 @@ list, _ := cast.ToSlice[int]([]string{"1", "2", "3"})
     * `Ptr[T any](T) *T` —— 快速取指针。
     * `ArrayToBoolMap[T comparable]([]T) map[T]bool` —— 快速构建索引 Map。
 
-6.  **基础转换与时间 (直接调用，极致性能)**
+6.  **基础转换 (直接调用，极致性能)**
     * `Int`, `Int64`, `Uint`, `Uint64`, `Float`, `Float64`, `String`, `Bool`, `Duration`
-    * `RealValue(reflect.Value) reflect.Value` —— 递归获取指针或接口下的真实值。
-    * `ParseTime(any) time.Time` —— 强大的时间解析，支持时间戳、RFC3339、JS 格式、紧凑格式及中文日期。
-    * `FormatTime(layout, any) string` —— 直观格式化（如 YYYY-MM-DD HH:mm:ss）。
-    * `AddTime(expr, any) time.Time` —— DSL 时间计算（如 +1Y-2M+3D）。
-    * `DescribeDuration(time.Duration) string` —— 将时长转化为自然语言描述（如 1h 5m）。
-
-7.  **字符串与参数处理**
-    * `Split(s, sep string) []string` —— 增强型分割，自动 Trim 并过滤空字符串。
-    * `SplitArgs(string) []string` —— 命令行参数分割，支持引号与转义。
-    * `JoinArgs([]string, sep string) string` —— 命令行参数合并，自动处理引号与转义。
-    * `UniqueAppend(to []string, from ...any) []string` —— 去重追加。
-    * `GetLowerName(string) string` | `GetUpperName(string) string` —— 首字母大小写转换工具。
-    * `FixUpperCase([]byte, []string)` —— 针对 JSON Key 的特殊大小写修复工具。
-
-8.  **时区支持**
-    * `DefaultTimeZone` —— 全局默认时区上下文。
-    * `SetDefaultTimeZone(*time.Location)` —— 修改全局默认时区（影响所有 Convert 与 ToTime 操作）。
-    * `DefaultTimeZone.Now()` —— 获取时区上下文下的当前时间。
-	* `NewTimeZone(*time.Location)` —— 创建一个时区上下文，支持 Parse、Format、Add、Now 等操作。
 
 ## 🧪 验证状态
 测试全部通过，性能达标。
 
+### JSON 性能概览 (v1.3.0)
+| 场景 | 耗时 | 内存分配 | 说明 |
+| :--- | :--- | :--- | :--- |
+| **Struct 序列化** | ~290 ns/op | 96 B/op | 引入元数据缓存，反射开销极低 |
+| **Map 序列化** | ~650 ns/op | 152 B/op | 采用 MapRange + 无序化，性能翻倍 |
+| **Frictionless 匹配** | ~420 ns/op | 72 B/op | 零分配 Key 比对，GC 压力极小 |
+| **字符串转义** | ~170 ns/op | 64 B/op | 批量处理，长文本优势明显 |
+
 详见：[TEST.md](./TEST.md)

TEST.md

@@ -14,7 +14,6 @@
     - **零分配摩擦匹配**: `normalizeEqual` 算法实现 0 内存分配的归一化 Key 匹配，支持 UTF-8。
     - **智能 Slice 扩容**: 尊重预设 Capacity，减少反序列化时的内存重分配。
     - **FastDecoder**: 实现单路径流式解析，支持嵌套指针、Slice 和 Map 的智能初始化。
-- **深度合并支持**: 支持在 `Convert` 过程中对 Map 和 Struct 进行深度递归合并。即使目标 Map 存储的是非指针结构体，也能通过反射寻址实现局部字段覆盖，而不丢失未提及的默认值。
 - **指针与接口**: `RealValue` 处理多级指针与接口解包。
 - **实用工具**: `UniqueAppend` ($O(n)$ 去重)，`If` (泛型三元)，`SplitArgs` (支持引用格式)。
 
@@ -24,21 +23,8 @@
 - `ToJSON (SimpleStruct)`: **~297 ns/op** (96 B/op) - 相比 v1.2.0 提升约 50%
 - `ToJSON (Map - No Sort)`: **~649 ns/op** (152 B/op) - 移除排序后性能大幅提升
 - `ToJSON (String Escaping)`: **~172 ns/op** (64 B/op) - 批量转义优化成果
-- `ToJSON (Time Support)`: **~522 ns/op** (232 B/op) - 原生 time.Time 处理
-- `ParseTime (RFC3339)`: **~143 ns/op** (72 B/op) - 极致优化解析
-- `ParseTime (Numeric String)`: **~188 ns/op** (0 B/op) - 紧凑格式零分配
-- `ParseTime (Native Number)`: **~7 ns/op** (0 B/op) - 原生数字时间戳 0 分配 & 极致性能
-- `FormatTime`: **~628 ns/op** (120 B/op) - 使用 Replacer 性能倍增
+- `ToJSON (Time Support)`: **~535 ns/op** (168 B/op) - 原生 time.Time 处理
 - `UnmarshalJSON (Frictionless)`: **~421 ns/op** (72 B/op) - 0 分配 Key 匹配
 - `ToMap`: ~816 ns/op (含 Struct 拍平与类型转换)
 - `ToSlice`: ~1819 ns/op
 - `UniqueAppend`: 大数据量下的 $O(n)$ 时间复杂度。
-
-### 性能概览
-| 场景 | 耗时 | 内存分配 | 说明 |
-| :--- | :--- | :--- | :--- |
-| **对象深度映射** | ~620 ns/op | 80 B/op | 引入 `performRecursiveTo` 引擎，就地赋值，无内存逃逸 |
-| **Struct 序列化** | ~290 ns/op | 96 B/op | 引入元数据缓存，反射开销极低 |
-| **Map 序列化** | ~650 ns/op | 152 B/op | 采用 MapRange + 无序化，性能翻倍 |
-| **Frictionless 匹配** | ~420 ns/op | 72 B/op | 零分配 Key 比对，GC 压力极小 |
-| **字符串转义** | ~170 ns/op | 64 B/op | 批量处理，长文本优势明显 |

bench_test.go

@@ -66,8 +66,8 @@ func BenchmarkString(b *testing.B) {
 
 func BenchmarkJSON(b *testing.B) {
 	type User struct {
-		ID   int
-		Name string
+		ID   int    `json:"id"`
+		Name string `json:"name"`
 	}
 	u := User{ID: 1, Name: "Benchmark User"}
 	for i := 0; i < b.N; i++ {
@@ -140,8 +140,8 @@ func BenchmarkString_FastPath(b *testing.B) {
 // 4. 测试 ToJSON 性能 (对比自定义逻辑与标准库)
 func BenchmarkToJSON_SimpleStruct(b *testing.B) {
 	type User struct {
-		ID   int
-		Name string
+		ID   int    `json:"id"`
+		Name string `json:"name"`
 	}
 	u := User{ID: 1, Name: "Benchmark User"}
 	b.ResetTimer()
@@ -162,21 +162,3 @@ func BenchmarkToJSON_DirtyMap(b *testing.B) {
 		_ = cast.To[string](val)
 	}
 }
-
-func BenchmarkTo_StructToStruct(b *testing.B) {
-	type Source struct {
-		ID   int
-		Name string
-		Age  string
-	}
-	type Target struct {
-		ID   int64
-		Name string
-		Age  int
-	}
-	src := Source{ID: 1, Name: "Tom", Age: "18"}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = cast.To[Target](src)
-	}
-}

cast.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"reflect"
 	"slices"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -42,455 +43,140 @@ func RealValue(v reflect.Value) reflect.Value {
 	}
 	return v
 }
-
 // --- Core Cast Logic ---
 
-var (
-	timeType = reflect.TypeOf(time.Time{})
-)
-
-// To 深度转换 (支持基础类型、Slice、Map、Struct 及 JSON 自动转换，零摩擦模式)
+// To 泛型转换 (支持基础类型、Slice、Map 及 JSON 自动转换，零摩擦模式)
 func To[T any](v any) T {
-	var res T
-	performRecursiveTo(reflect.ValueOf(v), reflect.ValueOf(&res).Elem())
-	return res
-}
+	targetType := reflect.TypeOf((*T)(nil)).Elem()
 
-// Convert 深度转换 (支持基础类型、Slice、Map、Struct 及 JSON 自动转换，原地更新)
-func Convert(dst, src any) {
-	if dst == nil {
-		return
+	// 1. 处理 JSON 自动转换 (Input: string/[]byte, Target: struct/map/slice)
+	if isJSONText(v) && isComplexType(targetType) {
+		return As(FromJSON[T](v))
 	}
 
-	dstV := reflect.ValueOf(dst)
-	var srcV reflect.Value
-	if v, ok := src.(reflect.Value); ok {
-		srcV = v
-	} else {
-		srcV = reflect.ValueOf(src)
+	// 2. 处理 JSON 自动转换 (Input: struct/map/slice, Target: string/[]byte)
+	if isComplexValue(v) && (targetType.Kind() == reflect.String || (targetType.Kind() == reflect.Slice && targetType.Elem().Kind() == reflect.Uint8)) {
+		s := As(ToJSON(v))
+		return any(reflectCast(s, targetType).Interface()).(T)
 	}
 
-	// Task 1: 拦截“自我转换”死循环陷阱 (Self-Assignment Guard)
-	if dstV.Kind() == reflect.Pointer && srcV.Kind() == reflect.Pointer {
-		if dstV.Pointer() == srcV.Pointer() {
-			return
-		}
+	// 3. 处理 Slice/Map
+	if targetType.Kind() == reflect.Slice && targetType.Elem().Kind() != reflect.Uint8 {
+		sv := reflect.MakeSlice(targetType, 0, 0)
+		ptr := reflect.New(targetType)
+		ptr.Elem().Set(sv)
+		fillToSlice(ptr.Elem(), v)
+		return ptr.Elem().Interface().(T)
+	}
+	if targetType.Kind() == reflect.Map {
+		mv := reflect.MakeMap(targetType)
+		fillToMap(mv, v)
+		return mv.Interface().(T)
 	}
 
-	performRecursiveTo(srcV, dstV)
-}
-
-func performRecursiveTo(src, dst reflect.Value) {
-	// 0. 处理 Interface 目标 (直接赋值)
-	if dst.Kind() == reflect.Interface {
-		if dst.CanSet() {
-			dst.Set(RealValue(src))
-		}
-		return
+	// 4. 处理基础类型
+	res, err := reflectCastE(v, targetType)
+	if err != nil {
+		var zero T
+		return zero
 	}
-
-	// 1. 处理指针 (自动初始化与解引用)
-	for dst.Kind() == reflect.Pointer {
-		if dst.IsNil() {
-			if dst.CanSet() {
-				dst.Set(reflect.New(dst.Type().Elem()))
-			} else {
-				return
-			}
-		}
-		dst = dst.Elem()
-	}
-
-	// 2. 解开源数据
-	src = RealValue(src)
-	if !src.IsValid() {
-		return
-	}
-
-	dstType := dst.Type()
-
-	// 3. 处理 JSON Unmarshaler 接口 (优先级高)
-	if dst.CanAddr() {
-		if unmarshaler, ok := dst.Addr().Interface().(json.Unmarshaler); ok {
-			var b []byte
-			if src.Kind() == reflect.String {
-				b = []byte(src.String())
-			} else if src.Kind() == reflect.Slice && src.Type().Elem().Kind() == reflect.Uint8 {
-				b = src.Bytes()
-			} else {
-				b, _ = ToJSONBytes(src.Interface())
-			}
-			if len(b) > 0 {
-				_ = unmarshaler.UnmarshalJSON(b)
-				return
-			}
-		}
-	}
-
-	// 4. Frictionless 增强：单值 <-> 切片 自动转换
-	if src.Kind() == reflect.Slice && src.Type().Elem().Kind() != reflect.Uint8 && src.Len() > 0 &&
-		dst.Kind() != reflect.Slice && dst.Kind() != reflect.Array && dst.Kind() != reflect.Map {
-		src = RealValue(src.Index(0))
-	}
-
-	// 5. 基础类型快速转换 (利用 cast 已有的高性能基础函数)
-	switch dst.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		if dst.CanSet() {
-			dst.SetInt(Int64(src.Interface()))
-		}
-		return
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		if dst.CanSet() {
-			dst.SetUint(Uint64(src.Interface()))
-		}
-		return
-	case reflect.Float32, reflect.Float64:
-		if dst.CanSet() {
-			dst.SetFloat(Float64(src.Interface()))
-		}
-		return
-	case reflect.String:
-		if dst.CanSet() {
-			if isComplexValue(src.Interface()) {
-				s, _ := ToJSON(src.Interface())
-				dst.SetString(s)
-			} else {
-				dst.SetString(String(src.Interface()))
-			}
-		}
-		return
-	case reflect.Bool:
-		if dst.CanSet() {
-			dst.SetBool(Bool(src.Interface()))
-		}
-		return
-	}
-
-	// 原生 time.Time 支持
-	if dstType == timeType {
-		if dst.CanSet() {
-			dst.Set(reflect.ValueOf(ToTime(src.Interface(), "")))
-		}
-		return
-	}
-
-	// 6. 复杂容器深度递归转换
-	switch dst.Kind() {
-	case reflect.Struct:
-		if src.Kind() == reflect.Map {
-			recursiveMapToStruct(src, dst)
-		} else if src.Kind() == reflect.Struct {
-			recursiveStructToStruct(src, dst)
-		} else if src.Kind() == reflect.String || (src.Kind() == reflect.Slice && src.Type().Elem().Kind() == reflect.Uint8) {
-			if dst.CanAddr() {
-				_ = UnmarshalJSON(src.Interface(), dst.Addr().Interface())
-			}
-		}
-	case reflect.Map:
-		if dst.IsNil() {
-			if dst.CanSet() {
-				dst.Set(reflect.MakeMap(dstType))
-			} else {
-				return
-			}
-		}
-		if src.Kind() == reflect.Map {
-			recursiveMapToMap(src, dst)
-		} else if src.Kind() == reflect.Struct {
-			recursiveStructToMap(src, dst)
-		} else if src.Kind() == reflect.Slice || src.Kind() == reflect.Array {
-			recursiveSliceToMap(src, dst)
-		} else if src.Kind() == reflect.String {
-			if dst.CanAddr() {
-				_ = UnmarshalJSON(src.Interface(), dst.Addr().Interface())
-			}
-		}
-	case reflect.Slice:
-		if dstType.Elem().Kind() == reflect.Uint8 {
-			if dst.CanSet() {
-				if isComplexValue(src.Interface()) {
-					b, _ := ToJSONBytes(src.Interface())
-					dst.SetBytes(b)
-				} else {
-					dst.SetBytes(toBytes(src.Interface()))
-				}
-			}
-		} else {
-			// JSON/CSV 字符串增强
-			if src.Kind() == reflect.String {
-				s := src.String()
-				if isJSONText(s) {
-					if dst.CanAddr() {
-						_ = UnmarshalJSON(s, dst.Addr().Interface())
-						return
-					}
-				}
-				if !strings.HasPrefix(s, "[") && strings.Contains(s, ",") {
-					src = reflect.ValueOf(Split(s, ","))
-				}
-			}
-			recursiveSliceToSlice(src, dst)
-		}
-	case reflect.Func:
-		if src.Kind() == reflect.Func {
-			dst.Set(reflect.MakeFunc(dstType, func(args []reflect.Value) []reflect.Value {
-				srcType := src.Type()
-				inParams := make([]reflect.Value, srcType.NumIn())
-				for i := 0; i < srcType.NumIn(); i++ {
-					inParams[i] = reflect.New(srcType.In(i)).Elem()
-					if i < len(args) {
-						performRecursiveTo(args[i], inParams[i])
-					}
-				}
-				results := src.Call(inParams)
-				outParams := make([]reflect.Value, dstType.NumOut())
-				for i := 0; i < dstType.NumOut(); i++ {
-					outParams[i] = reflect.New(dstType.Out(i)).Elem()
-					if i < len(results) {
-						performRecursiveTo(results[i], outParams[i])
-					}
-				}
-				return outParams
-			}))
-		}
-	}
-}
-
-// 内部递归助手 (零分配/高性能设计)
-
-func recursiveMapToStruct(src, dst reflect.Value) {
-	if !dst.CanAddr() {
-		return
-	}
-	dstAddr := dst.Addr()
-	dstType := dst.Type()
-	descriptor := getDecoderFieldMap(dstType)
-	iter := src.MapRange() // 零分配遍历
-	for iter.Next() {
-		rk := iter.Key()
-		var key string
-		if rk.Kind() == reflect.String {
-			key = rk.String()
-		} else {
-			key = String(rk.Interface())
-		}
-
-		if index, isTime, format, ok := matchField(key, descriptor); ok {
-			field := dst.Field(index)
-			fieldInfo := dstType.Field(index)
-
-			// ParseHook 支持: ParseFieldName(sourceType) FieldType
-			if method, ok := dstAddr.Type().MethodByName("Parse" + fieldInfo.Name); ok {
-				arg := reflect.New(method.Type.In(1)).Elem()
-				performRecursiveTo(iter.Value(), arg)
-				res := method.Func.Call([]reflect.Value{dstAddr, arg})
-				field.Set(res[0])
-				continue
-			}
-
-			if isTime {
-				field.Set(reflect.ValueOf(ToTime(iter.Value().Interface(), format)))
-			} else {
-				performRecursiveTo(iter.Value(), field)
-			}
-		}
-	}
-}
-
-func recursiveStructToStruct(src, dst reflect.Value) {
-	if !dst.CanAddr() {
-		return
-	}
-	dstAddr := dst.Addr()
-	srcType := src.Type()
-	dstType := dst.Type()
-	descriptor := getDecoderFieldMap(dstType)
-	for i := 0; i < src.NumField(); i++ {
-		field := srcType.Field(i)
-		if !field.IsExported() {
-			continue
-		}
-		if field.Anonymous {
-			recursiveStructToStruct(src.Field(i), dst)
-			continue
-		}
-		// 使用 matchField 实现归一化 Key 匹配 (零分配)
-		if index, isTime, format, ok := matchField(field.Name, descriptor); ok {
-			df := dst.Field(index)
-			fieldInfo := dstType.Field(index)
-
-			// ParseHook 支持
-			if method, ok := dstAddr.Type().MethodByName("Parse" + fieldInfo.Name); ok {
-				arg := reflect.New(method.Type.In(1)).Elem()
-				performRecursiveTo(src.Field(i), arg)
-				res := method.Func.Call([]reflect.Value{dstAddr, arg})
-				df.Set(res[0])
-				continue
-			}
-
-			if isTime {
-				df.Set(reflect.ValueOf(ToTime(src.Field(i).Interface(), format)))
-			} else {
-				performRecursiveTo(src.Field(i), df)
-			}
-		}
-	}
-}
-
-func recursiveMapToMap(src, dst reflect.Value) {
-	kt := dst.Type().Key()
-	vt := dst.Type().Elem()
-	newKey := reflect.New(kt).Elem()
-
-	iter := src.MapRange()
-	for iter.Next() {
-		newKey.Set(reflect.Zero(kt))
-		performRecursiveTo(iter.Key(), newKey)
-
-		// 1. 创建一个【可寻址】的临时变量
-		newVal := reflect.New(vt).Elem()
-
-		// 2. 尝试从目标 Map 中获取已经存在的老值
-		existingVal := dst.MapIndex(newKey)
-		if existingVal.IsValid() {
-			// 如果老值存在，把它拷贝到我们刚才创建的临时变量里作“底本”
-			// 这样就能保留原本没被覆盖的字段
-			newVal.Set(existingVal)
-		} else {
-			// 如果老值不存在，就用零值兜底
-			newVal.Set(reflect.Zero(vt))
-		}
-
-		// 3. 对这个可寻址的临时变量进行深度合并
-		performRecursiveTo(iter.Value(), newVal)
-
-		// 4. 将合并后的全新值，重新塞回目标 Map
-		dst.SetMapIndex(newKey, newVal)
-	}
-}
-
-func recursiveStructToMap(src, dst reflect.Value) {
-	kt := dst.Type().Key()
-	vt := dst.Type().Elem()
-	newKey := reflect.New(kt).Elem()
-
-	srcType := src.Type()
-	for i := 0; i < src.NumField(); i++ {
-		field := srcType.Field(i)
-		if !field.IsExported() {
-			continue
-		}
-		if field.Anonymous {
-			recursiveStructToMap(src.Field(i), dst)
-			continue
-		}
-		newKey.Set(reflect.Zero(kt))
-		performRecursiveTo(reflect.ValueOf(GetLowerName(field.Name)), newKey)
-
-		// 1. 创建一个【可寻址】的临时变量
-		newVal := reflect.New(vt).Elem()
-
-		// 2. 尝试获取老值
-		existingVal := dst.MapIndex(newKey)
-		if existingVal.IsValid() {
-			newVal.Set(existingVal)
-		} else {
-			newVal.Set(reflect.Zero(vt))
-		}
-
-		// 3. 合并
-		performRecursiveTo(src.Field(i), newVal)
-
-		// 4. 塞回
-		dst.SetMapIndex(newKey, newVal)
-	}
-}
-
-func recursiveSliceToMap(src, dst reflect.Value) {
-	kt := dst.Type().Key()
-	vt := dst.Type().Elem()
-	newKey := reflect.New(kt).Elem()
-	for i := 0; i < src.Len(); i += 2 {
-		newKey.Set(reflect.Zero(kt))
-		performRecursiveTo(src.Index(i), newKey)
-
-		newVal := reflect.New(vt).Elem()
-		existingVal := dst.MapIndex(newKey)
-		if existingVal.IsValid() {
-			newVal.Set(existingVal)
-		} else {
-			newVal.Set(reflect.Zero(vt))
-		}
-
-		if i+1 < src.Len() {
-			performRecursiveTo(src.Index(i+1), newVal)
-		}
-		dst.SetMapIndex(newKey, newVal)
-	}
-}
-
-func recursiveSliceToSlice(src, dst reflect.Value) {
-	et := dst.Type().Elem()
-	temp := reflect.New(et).Elem()
-	if src.Kind() == reflect.Slice || src.Kind() == reflect.Array {
-		l := src.Len()
-		dst.Set(reflect.MakeSlice(dst.Type(), l, l))
-		for i := 0; i < l; i++ {
-			temp.Set(reflect.Zero(et))
-			performRecursiveTo(src.Index(i), temp)
-			dst.Index(i).Set(temp)
-		}
-	} else {
-		// Frictionless: 自动包装单值为切片 (覆盖赋值)
-		dst.Set(reflect.MakeSlice(dst.Type(), 1, 1))
-		temp.Set(reflect.Zero(et))
-		performRecursiveTo(src, temp)
-		dst.Index(0).Set(temp)
-	}
-}
-
-func ToTime(v any, format string) time.Time {
-	if v == nil {
-		return time.Time{}
-	}
-	if t, ok := v.(time.Time); ok {
-		return t.In(DefaultTimeZone.loc)
-	}
-	if format != "" {
-		s := String(v)
-		if t, err := time.ParseInLocation(format, s, DefaultTimeZone.loc); err == nil {
-			return t
-		}
-	}
-	return DefaultTimeZone.ParseTime(v)
-}
-
-func reflectCast(value any, t reflect.Type) reflect.Value {
-	var v reflect.Value
-	if t.Kind() == reflect.Ptr {
-		v = reflect.New(t.Elem())
-	} else {
-		v = reflect.New(t).Elem()
-	}
-	performRecursiveTo(reflect.ValueOf(value), v)
-	return v
+	return res.Interface().(T)
 }
 
 func reflectCastE(value any, t reflect.Type) (reflect.Value, error) {
-	return reflectCast(value, t), nil
+	switch t.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		i, err := ToInt64E(value)
+		if err != nil {
+			return reflect.Value{}, err
+		}
+		return reflect.ValueOf(i).Convert(t), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
+		i, err := ToUint64E(value)
+		if err != nil {
+			return reflect.Value{}, err
+		}
+		return reflect.ValueOf(i).Convert(t), nil
+	case reflect.Float32, reflect.Float64:
+		f, err := ToFloat64E(value)
+		if err != nil {
+			return reflect.Value{}, err
+		}
+		return reflect.ValueOf(f).Convert(t), nil
+	case reflect.String:
+		return reflect.ValueOf(String(value)).Convert(t), nil
+	case reflect.Bool:
+		return reflect.ValueOf(Bool(value)).Convert(t), nil
+	case reflect.Interface:
+		if value == nil {
+			return reflect.Zero(t), nil
+		}
+		return reflect.ValueOf(value), nil
+	}
+
+	if t == reflect.TypeOf(time.Duration(0)) {
+		return reflect.ValueOf(Duration(value)), nil
+	}
+
+	return reflect.Zero(t), fmt.Errorf("unsupported target type: %v", t)
 }
 
 func ToInt64E(v any) (int64, error) {
-	return Int64(v), nil
+	if i, ok := toInt64(v); ok {
+		return i, nil
+	}
+	s := String(v)
+	i, err := strconv.ParseInt(s, 10, 64)
+	if err == nil {
+		return i, nil
+	}
+	if f, err := strconv.ParseFloat(s, 64); err == nil {
+		return int64(f), nil
+	}
+	return 0, fmt.Errorf("cannot cast %v to int64", v)
 }
 
 func ToUint64E(v any) (uint64, error) {
-	return Uint64(v), nil
+	switch realValue := v.(type) {
+	case int, int8, int16, int32, int64:
+		return uint64(Int64(realValue)), nil
+	case uint, uint8, uint16, uint32, uint64:
+		return Uint64(realValue), nil
+	case float32, float64:
+		return uint64(Float64(realValue)), nil
+	case bool:
+		return If(realValue, uint64(1), uint64(0)), nil
+	}
+	s := String(v)
+	i, err := strconv.ParseUint(s, 10, 64)
+	if err == nil {
+		return i, nil
+	}
+	if f, err := strconv.ParseFloat(s, 64); err == nil {
+		return uint64(f), nil
+	}
+	return 0, fmt.Errorf("cannot cast %v to uint64", v)
 }
 
 func ToFloat64E(v any) (float64, error) {
-	return Float64(v), nil
+	switch realValue := v.(type) {
+	case int, int8, int16, int32, int64:
+		return float64(Int64(realValue)), nil
+	case uint, uint8, uint16, uint32, uint64:
+		return float64(Uint64(realValue)), nil
+	case float32:
+		return float64(realValue), nil
+	case float64:
+		return realValue, nil
+	case bool:
+		return If(realValue, 1.0, 0.0), nil
+	}
+	s := String(v)
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return 0, fmt.Errorf("cannot cast %v to float64", v)
+	}
+	return f, nil
 }
 
 func isJSONText(v any) bool {
@@ -527,12 +213,6 @@ func isComplexValue(v any) bool {
 }
 
 func parseInt(s string) int64 {
-	if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
-		i, err := strconv.ParseInt(s, 0, 64)
-		if err == nil {
-			return i
-		}
-	}
 	i, err := strconv.ParseInt(s, 10, 64)
 	if err == nil {
 		return i
@@ -544,12 +224,6 @@ func parseInt(s string) int64 {
 }
 
 func parseUint(s string) uint64 {
-	if strings.HasPrefix(s, "0x") || strings.HasPrefix(s, "0X") {
-		i, err := strconv.ParseUint(s, 0, 64)
-		if err == nil {
-			return i
-		}
-	}
 	i, err := strconv.ParseUint(s, 10, 64)
 	if err == nil {
 		return i
@@ -565,49 +239,30 @@ func Int(value any) int { return int(Int64(value)) }
 // Helper for integer coercion to avoid repetition
 func toInt64(value any) (int64, bool) {
 	switch v := value.(type) {
-	case int:
-		return int64(v), true
-	case int8:
-		return int64(v), true
-	case int16:
-		return int64(v), true
-	case int32:
-		return int64(v), true
-	case int64:
-		return v, true
-	case uint:
-		return int64(v), true
-	case uint8:
-		return int64(v), true
-	case uint16:
-		return int64(v), true
-	case uint32:
-		return int64(v), true
-	case uint64:
-		return int64(v), true
-	case float32:
-		return int64(v), true
-	case float64:
-		return int64(v), true
-	case bool:
-		return If(v, int64(1), int64(0)), true
+	case int: return int64(v), true
+	case int8: return int64(v), true
+	case int16: return int64(v), true
+	case int32: return int64(v), true
+	case int64: return v, true
+	case uint: return int64(v), true
+	case uint8: return int64(v), true
+	case uint16: return int64(v), true
+	case uint32: return int64(v), true
+	case uint64: return int64(v), true
+	case float32: return int64(v), true
+	case float64: return int64(v), true
+	case bool: return If(v, int64(1), int64(0)), true
 	}
 	return 0, false
 }
 
 func Int64(value any) int64 {
-	if value == nil {
-		return 0
-	}
-	if i, ok := toInt64(value); ok {
-		return i
-	}
+	if value == nil { return 0 }
+	if i, ok := toInt64(value); ok { return i }
 	
 	switch realValue := value.(type) {
-	case []byte:
-		return parseInt(string(realValue))
-	case string:
-		return parseInt(realValue)
+	case []byte: return parseInt(string(realValue))
+	case string: return parseInt(realValue)
 	}
 	
 	rv := reflect.ValueOf(value)
@@ -733,16 +388,11 @@ func String(value any) string {
 }
 
 func Bool(value any) bool {
-	if value == nil {
-		return false
-	}
-	if b, ok := value.(bool); ok {
-		return b
-	}
-	if i, ok := toInt64(value); ok {
-		return i != 0
-	}
 	switch realValue := value.(type) {
+	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
+		return Uint64(realValue) != 0
+	case bool:
+		return realValue
 	case []byte:
 		s := strings.ToLower(string(realValue))
 		return s == "1" || s == "t" || s == "true"
@@ -931,25 +581,124 @@ func ArrayToBoolMap[T comparable](arr []T) map[T]bool {
 // ToMap 泛型构建新 Map
 func ToMap[K comparable, V any](source any) (map[K]V, error) {
 	m := make(map[K]V)
-	performRecursiveTo(reflect.ValueOf(source), reflect.ValueOf(m))
+	fillToMap(reflect.ValueOf(m), source)
 	return m, nil
 }
 
 // ToSlice 泛型构建新 Slice
 func ToSlice[T any](source any) ([]T, error) {
 	var s []T
-	performRecursiveTo(reflect.ValueOf(source), reflect.ValueOf(&s).Elem())
+	fillToSlice(reflect.ValueOf(&s).Elem(), source)
 	return s, nil
 }
 
-// FillMap 将 source 填充到目标 map 中
+// FillMap 将 source 填充到目标 map 中 (兼容旧 API 逻辑)
 func FillMap(target any, source any) {
-	Convert(target, source)
+	rv := reflect.ValueOf(target)
+	for rv.Kind() == reflect.Pointer {
+		if rv.IsNil() {
+			if !rv.CanSet() {
+				return
+			}
+			elemType := rv.Type().Elem()
+			if elemType.Kind() == reflect.Map || elemType.Kind() == reflect.Pointer || elemType.Kind() == reflect.Struct {
+				rv.Set(reflect.New(elemType))
+			} else {
+				return
+			}
+		}
+		rv = rv.Elem()
+	}
+
+	if rv.Kind() != reflect.Map {
+		return
+	}
+
+	if rv.IsNil() {
+		if rv.CanSet() {
+			rv.Set(reflect.MakeMap(rv.Type()))
+		} else {
+			return
+		}
+	}
+	fillToMap(rv, source)
 }
 
-// FillSlice 将 source 填充到目标 slice 中
+func fillToMap(rv reflect.Value, source any) {
+	kt := rv.Type().Key()
+	vt := rv.Type().Elem()
+
+	sv := RealValue(reflect.ValueOf(source))
+	switch sv.Kind() {
+	case reflect.Struct:
+		fillMapFromStruct(rv, sv, kt, vt)
+	case reflect.Slice, reflect.Array:
+		for i := 0; i < sv.Len(); i += 2 {
+			k := sv.Index(i).Interface()
+			var v any
+			if i+1 < sv.Len() {
+				v = sv.Index(i+1).Interface()
+			}
+			rv.SetMapIndex(reflectCast(k, kt), reflectCast(v, vt))
+		}
+	case reflect.Map:
+		iter := sv.MapRange()
+		for iter.Next() {
+			rv.SetMapIndex(reflectCast(iter.Key().Interface(), kt), reflectCast(iter.Value().Interface(), vt))
+		}
+	}
+}
+
+func fillMapFromStruct(targetMap, sv reflect.Value, kt, vt reflect.Type) {
+	st := sv.Type()
+	for i := 0; i < sv.NumField(); i++ {
+		field := st.Field(i)
+		if !field.IsExported() {
+			continue
+		}
+		if field.Anonymous {
+			fillMapFromStruct(targetMap, sv.Field(i), kt, vt)
+			continue
+		}
+		targetMap.SetMapIndex(reflectCast(GetLowerName(field.Name), kt), reflectCast(sv.Field(i).Interface(), vt))
+	}
+}
+
+// FillSlice 将 source 填充到目标 slice 中 (兼容旧 API 逻辑)
 func FillSlice(target any, source any) {
-	Convert(target, source)
+	rv := reflect.ValueOf(target)
+	if rv.Kind() != reflect.Pointer || rv.Elem().Kind() != reflect.Slice {
+		return
+	}
+	fillToSlice(rv.Elem(), source)
+}
+
+func fillToSlice(sliceRv reflect.Value, source any) {
+	et := sliceRv.Type().Elem()
+	sv := RealValue(reflect.ValueOf(source))
+	switch sv.Kind() {
+	case reflect.Map:
+		keys := sv.MapKeys()
+		sort.Slice(keys, func(i, j int) bool {
+			return String(keys[i].Interface()) < String(keys[j].Interface())
+		})
+		for _, key := range keys {
+			sliceRv.Set(reflect.Append(sliceRv, reflectCast(key.Interface(), et)))
+			sliceRv.Set(reflect.Append(sliceRv, reflectCast(sv.MapIndex(key).Interface(), et)))
+		}
+	case reflect.Slice, reflect.Array:
+		for i := 0; i < sv.Len(); i++ {
+			sliceRv.Set(reflect.Append(sliceRv, reflectCast(sv.Index(i).Interface(), et)))
+		}
+	case reflect.Invalid:
+		// Nil source, do nothing
+	default:
+		sliceRv.Set(reflect.Append(sliceRv, reflectCast(source, et)))
+	}
+}
+
+func reflectCast(value any, t reflect.Type) reflect.Value {
+	return As(reflectCastE(value, t))
 }
 
 // 补充缺失的 Key 转换工具

cast_test.go

@@ -55,7 +55,7 @@ func TestJSONToStruct(t *testing.T) {
 func TestSpecialJSON(t *testing.T) {
 	// 关键测试：特殊 HTML 字符序列化不应被转义
 	type Content struct {
-		Text string
+		Text string `json:"text"`
 	}
 	c := Content{Text: "<a> & <b>"}
 

complex_conversion_test.go

@@ -1,102 +0,0 @@
-package cast_test
-
-import (
-	"testing"
-	"apigo.cc/go/cast"
-)
-
-type SubConfig struct {
-	Level int
-	Tag   string
-}
-
-type MainConfig struct {
-	Name    string
-	Sub     SubConfig
-	Items   []string
-	Options map[string]int
-}
-
-func TestDeepMergeComplex(t *testing.T) {
-	dst := MainConfig{
-		Name: "Base",
-		Sub: SubConfig{
-			Level: 1,
-			Tag:   "original",
-		},
-		Items: []string{"a", "b"},
-		Options: map[string]int{
-			"debug": 1,
-			"trace": 0,
-		},
-	}
-
-	src := map[string]any{
-		"Sub": map[string]any{
-			"Level": 2,
-		},
-		"Options": map[string]any{
-			"trace": 1,
-			"new":   100,
-		},
-	}
-
-	cast.Convert(&dst, src)
-
-	if dst.Name != "Base" {
-		t.Errorf("Expected Name Base, got %s", dst.Name)
-	}
-	if dst.Sub.Level != 2 {
-		t.Errorf("Expected Sub.Level 2, got %d", dst.Sub.Level)
-	}
-	if dst.Sub.Tag != "original" {
-		t.Errorf("Expected Sub.Tag original, got %s", dst.Sub.Tag)
-	}
-	if len(dst.Items) != 2 {
-		t.Errorf("Expected Items length 2, got %d", len(dst.Items))
-	}
-	if dst.Options["debug"] != 1 {
-		t.Errorf("Expected Options.debug 1, got %d", dst.Options["debug"])
-	}
-	if dst.Options["trace"] != 1 {
-		t.Errorf("Expected Options.trace 1, got %d", dst.Options["trace"])
-	}
-	if dst.Options["new"] != 100 {
-		t.Errorf("Expected Options.new 100, got %d", dst.Options["new"])
-	}
-}
-
-func TestMapToMapMergeComplex(t *testing.T) {
-	dst := map[string]MainConfig{
-		"c1": {
-			Name: "Config1",
-			Sub:  SubConfig{Level: 10},
-		},
-	}
-
-	src := map[string]any{
-		"c1": map[string]any{
-			"Sub": map[string]any{
-				"Tag": "updated",
-			},
-		},
-		"c2": map[string]any{
-			"Name": "Config2",
-		},
-	}
-
-	cast.Convert(&dst, src)
-
-	if dst["c1"].Name != "Config1" {
-		t.Errorf("Expected c1.Name Config1, got %s", dst["c1"].Name)
-	}
-	if dst["c1"].Sub.Level != 10 {
-		t.Errorf("Expected c1.Sub.Level 10, got %d", dst["c1"].Sub.Level)
-	}
-	if dst["c1"].Sub.Tag != "updated" {
-		t.Errorf("Expected c1.Sub.Tag updated, got %s", dst["c1"].Sub.Tag)
-	}
-	if dst["c2"].Name != "Config2" {
-		t.Errorf("Expected c2.Name Config2, got %s", dst["c2"].Name)
-	}
-}

conversion_test.go

@@ -30,23 +30,23 @@ func TestToMap(t *testing.T) {
 }
 
 func TestToSlice(t *testing.T) {
-	// Test primitive-to-slice (overwrite)
+	// Test primitive-to-slice (append)
 	var s1 []int
 	cast.FillSlice(&s1, "123")
 	if len(s1) != 1 || s1[0] != 123 {
 		t.Errorf("Primitive-to-slice failed: %v", s1)
 	}
 
-	// Test slice-to-slice (overwrite)
+	// Test append slice
 	cast.FillSlice(&s1, []string{"456"})
-	if len(s1) != 1 || s1[0] != 456 {
-		t.Errorf("Slice-to-slice overwrite failed: %v", s1)
+	if len(s1) != 2 || s1[1] != 456 {
+		t.Errorf("Append slice to slice failed: %v", s1)
 	}
 }
 
 func TestJSON(t *testing.T) {
 	type Config struct {
-		Port int
+		Port int `json:"port"`
 	}
 	data := `{"port": 8080}`
 	

convert_compat_test.go

@@ -1,200 +0,0 @@
-package cast_test
-
-import (
-	"reflect"
-	"testing"
-
-	"apigo.cc/go/cast"
-)
-
-// Matrix Test Entry
-func TestConvertMatrix(t *testing.T) {
-	type testCase struct {
-		name     string
-		from     any
-		to       any // 传入指针的指针，用于接收结果
-		expected any
-	}
-
-	// 1. 基础类型全互转矩阵
-	cases := []testCase{
-		{name: "int to string", from: 123, to: new(string), expected: "123"},
-		{name: "string to int", from: "456", to: new(int), expected: 456},
-		{name: "float to int", from: 123.45, to: new(int), expected: 123},
-		{name: "bool to string", from: true, to: new(string), expected: "true"},
-		{name: "string to bool", from: "1", to: new(bool), expected: true},
-		{name: "string to bool (text)", from: "true", to: new(bool), expected: true},
-
-		// 2. 容器与单值的自动包装/解包 (去摩擦)
-		{name: "single to slice", from: 100, to: new([]int), expected: []int{100}},
-		{name: "slice to single (len 1)", from: []int{200}, to: new(int), expected: 200},
-		{name: "slice to single (len >1, take first)", from: []int{300, 400}, to: new(int), expected: 300},
-
-		// 3. 字符串与切片的智能转换
-		{name: "csv string to slice", from: "1, 2, 3", to: new([]int), expected: []int{1, 2, 3}},
-		{name: "json string to slice", from: `[4, 5, 6]`, to: new([]int), expected: []int{4, 5, 6}},
-
-		// 4. 指针转换 (深度穿透)
-		{name: "deep pointer to val", from: ptr(ptr(789)), to: new(int), expected: 789},
-		{name: "val to pointer", from: 999, to: new(*int), expected: ptr(999)},
-	}
-
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			cast.Convert(tc.to, tc.from)
-			// 获取 to 指针指向的实际值
-			actual := reflect.ValueOf(tc.to).Elem().Interface()
-			if !reflect.DeepEqual(actual, tc.expected) {
-				t.Errorf("[%s] Failed: from(%v) expected(%v) but got(%v)", tc.name, tc.from, tc.expected, actual)
-			}
-		})
-	}
-}
-
-func TestConvert_SelfAssignment(t *testing.T) {
-	type User struct {
-		Name string
-	}
-	u := &User{Name: "Tom"}
-	// 应命中自我转换保护，不报错且不改变状态
-	cast.Convert(u, u)
-	if u.Name != "Tom" {
-		t.Error("Self-assignment guard failed")
-	}
-}
-
-// 5. 复杂映射与去摩擦 Key 匹配测试
-func TestComplexFrictionlessMapping(t *testing.T) {
-	// 场景：Map 键名非常混乱，Struct 嵌套，目标存在旧数据
-	type Sub struct {
-		Age int
-	}
-	type User struct {
-		UserID   int
-		UserName string
-		SubInfo  Sub
-	}
-
-	from := map[string]any{
-		"user_id":   1001,   // 下划线
-		"USER-NAME": "Andy", // 中划线+大写
-		"subinfo": map[string]any{ // 嵌套+全小写
-			"age": "18", // 类型不一致 (string -> int)
-		},
-	}
-
-	var to User
-	to.UserID = 999 // 预设旧数据，验证是否被正确覆盖
-	cast.Convert(&to, from)
-
-	if to.UserID != 1001 {
-		t.Errorf("UserID match failed: %d", to.UserID)
-	}
-	if to.UserName != "Andy" {
-		t.Errorf("UserName match failed: %s", to.UserName)
-	}
-	if to.SubInfo.Age != 18 {
-		t.Errorf("SubInfo.Age match failed: %d", to.SubInfo.Age)
-	}
-}
-
-// 6. 函数转换测试 (Func to Func)
-func TestFuncConversion(t *testing.T) {
-	// 源函数：接收 int, string，返回 int, string
-	f1 := func(a int, b string) (int, string) {
-		return a + 1, b + "!"
-	}
-
-	// 目标函数：意图是接收 string, any，返回 string, any
-	var f2 func(string, any) (string, any)
-	cast.Convert(&f2, f1)
-
-	if f2 == nil {
-		t.Fatal("Converted function is nil")
-	}
-
-	r1, r2 := f2("10", "hello")
-	if r1 != "11" || r2 != "hello!" {
-		t.Errorf("Func conversion failed: r1=%v, r2=%v", r1, r2)
-	}
-}
-
-// 8. 命名风格模糊匹配测试
-func TestFuzzyNamingMapping(t *testing.T) {
-	type TestStruct struct {
-		JSONTag      string
-		UserID       int
-		UserName     string
-		IsActiveFlag bool
-	}
-
-	// 测试用例：各种不规范输入到标准结构体的映射
-	from := map[string]any{
-		"jsontag":        "val1", // 小写
-		"JSONTag":        "val2", // 原名
-		"JSON_TAG":       "val3", // 下划线大写
-		"user_id":        123,    // 下划线小写
-		"USERID":         456,    // 全大写
-		"userName":       "Andy", // 首字母小写
-		"user-name":      "Bob",  // 中划线
-		"is_active_flag": "true", // 模糊匹配 bool
-	}
-
-	var to TestStruct
-	cast.Convert(&to, from)
-
-	if to.UserID == 0 {
-		t.Errorf("UserID should be matched and set")
-	}
-	if to.UserName == "" {
-		t.Errorf("UserName should be matched and set")
-	}
-	if !to.IsActiveFlag {
-		t.Errorf("IsActiveFlag should be set to true")
-	}
-
-	t.Logf("Conversion result: %+v", to)
-}
-
-// 9. 异常防御测试 (Panic Prevention)
-func TestPanicPrevention(t *testing.T) {
-	t.Run("nil destination", func(t *testing.T) {
-		defer func() {
-			if r := recover(); r != nil {
-				t.Errorf("Panic occurred with nil destination: %v", r)
-			}
-		}()
-		cast.Convert(nil, "data")
-	})
-
-	t.Run("nil pointer destination", func(t *testing.T) {
-		// nil 指针目标应该是可以接受的，库应当忽略或优雅处理，不应 panic
-		var p *int = nil
-		cast.Convert(&p, 123) // 这里传入的是指针的指针
-		if p == nil || *p != 123 {
-			t.Errorf("Expected p to be initialized and set to 123, got %v", p)
-		}
-	})
-
-	t.Run("read-only destination", func(t *testing.T) {
-		const i = 1
-		cast.Convert(i, 123)
-	})
-}
-
-// 辅助函数
-func ptr[T any](v T) *T { return &v }
-
-// --- 性能测试 ---
-
-func BenchmarkCastMatrixConvert(b *testing.B) {
-	from := map[string]any{"id": "123", "name": "test"}
-	type Target struct {
-		ID   int
-		Name string
-	}
-	var to Target
-	for i := 0; i < b.N; i++ {
-		cast.Convert(&to, from)
-	}
-}

json_decoder.go

@@ -7,6 +7,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"time"
 	"unicode"
 	"unicode/utf8"
 )
@@ -23,7 +24,7 @@ type decoderFieldDescriptor struct {
 }
 
 type decoderStructDescriptor struct {
-	exactMatches map[string]decoderFieldDescriptor
+	exactMatches map[string]int
 	fields       []decoderFieldDescriptor
 }
 
@@ -77,50 +78,30 @@ func (d *decoder) decodeValue(reflectValue reflect.Value, timeFormat string) err
 
 	// 处理 time.Time
 	if reflectValue.Type() == timeType {
-		var v any
 		if char == '"' {
 			str, err := d.parseString()
 			if err != nil {
 				return err
 			}
-			v = str
-		} else if char == 'n' {
-			if string(d.data[d.pos:min(d.pos+4, len(d.data))]) == "null" {
-				d.pos += 4
-				reflectValue.Set(reflect.Zero(reflectValue.Type()))
-				return nil
+			if timeFormat == "" {
+				timeFormat = "2006-01-02 15:04:05.000"
 			}
-		} else {
-			literal, err := d.parseLiteral()
+			t, err := time.ParseInLocation(timeFormat, str, time.Local)
 			if err != nil {
-				return err
+				// 尝试其他常见格式
+				if t, err = time.Parse(time.RFC3339, str); err != nil {
+					t = time.Time{}
+				}
 			}
-			v = literal
+			reflectValue.Set(reflect.ValueOf(t))
+			return nil
 		}
-		reflectValue.Set(reflect.ValueOf(ToTime(v, timeFormat)))
-		return nil
 	}
 
 	switch char {
 	case '{':
-		if reflectValue.Kind() == reflect.Interface {
-			m := make(map[string]any)
-			if err := d.decodeObject(reflect.ValueOf(&m).Elem()); err != nil {
-				return err
-			}
-			reflectValue.Set(reflect.ValueOf(m))
-			return nil
-		}
 		return d.decodeObject(reflectValue)
 	case '[':
-		if reflectValue.Kind() == reflect.Interface {
-			var s []any
-			if err := d.decodeArray(reflect.ValueOf(&s).Elem()); err != nil {
-				return err
-			}
-			reflectValue.Set(reflect.ValueOf(s))
-			return nil
-		}
 		return d.decodeArray(reflectValue)
 	case '"':
 		str, err := d.parseString()
@@ -139,8 +120,6 @@ func (d *decoder) decodeValue(reflectValue reflect.Value, timeFormat string) err
 			reflectValue.SetFloat(Float64(str))
 		case reflect.Bool:
 			reflectValue.SetBool(Bool(str))
-		case reflect.Interface:
-			reflectValue.Set(reflect.ValueOf(str))
 		default:
 			// 尝试将字符串解析为具体对象（比如内部又是 JSON）
 			if strings.HasPrefix(str, "{") || strings.HasPrefix(str, "[") {
@@ -166,20 +145,7 @@ func (d *decoder) decodeValue(reflectValue reflect.Value, timeFormat string) err
 		case reflect.String:
 			reflectValue.SetString(literal)
 		case reflect.Interface:
-			// 优先作为数字处理以保留精度 (int64)
-			if literal == "true" {
-				reflectValue.Set(reflect.ValueOf(true))
-			} else if literal == "false" {
-				reflectValue.Set(reflect.ValueOf(false))
-			} else if literal == "null" {
-				reflectValue.Set(reflect.Zero(reflectValue.Type()))
-			} else if strings.Contains(literal, ".") || strings.Contains(literal, "e") || strings.Contains(literal, "E") {
-				reflectValue.Set(reflect.ValueOf(Float64(literal)))
-			} else if i, err := strconv.ParseInt(literal, 10, 64); err == nil {
-				reflectValue.Set(reflect.ValueOf(i))
-			} else {
-				reflectValue.Set(reflect.ValueOf(literal))
-			}
+			reflectValue.Set(reflect.ValueOf(literal))
 		}
 	}
 	return nil
@@ -426,7 +392,7 @@ func getDecoderFieldMap(reflectType reflect.Type) *decoderStructDescriptor {
 		return val.(*decoderStructDescriptor)
 	}
 	descriptor := &decoderStructDescriptor{
-		exactMatches: make(map[string]decoderFieldDescriptor),
+		exactMatches: make(map[string]int),
 	}
 	for index := 0; index < reflectType.NumField(); index++ {
 		field := reflectType.Field(index)
@@ -445,24 +411,21 @@ func getDecoderFieldMap(reflectType reflect.Type) *decoderStructDescriptor {
 
 		// 1. Tag
 		tag := field.Tag.Get("json")
-		if tag == "-" {
-			continue
-		}
-		if tag != "" {
+		if tag != "" && tag != "-" {
 			parts := strings.Split(tag, ",")
 			tagName := parts[0]
+			if tagName != "" {
+				descriptor.exactMatches[tagName] = index
+			}
 			for _, part := range parts {
 				if strings.HasPrefix(part, "format=") {
 					fieldDesc.timeFormat = strings.TrimPrefix(part, "format=")
 				}
 			}
-			if tagName != "" {
-				descriptor.exactMatches[tagName] = fieldDesc
-			}
 		}
 
 		// 2. 原名
-		descriptor.exactMatches[field.Name] = fieldDesc
+		descriptor.exactMatches[field.Name] = index
 
 		// 3. 归一化名
 		fieldDesc.normalized = normalizeKey(field.Name)
@@ -474,8 +437,14 @@ func getDecoderFieldMap(reflectType reflect.Type) *decoderStructDescriptor {
 
 func matchField(key string, descriptor *decoderStructDescriptor) (int, bool, string, bool) {
 	// 1. 精确匹配
-	if f, ok := descriptor.exactMatches[key]; ok {
-		return f.index, f.isTime, f.timeFormat, true
+	if index, ok := descriptor.exactMatches[key]; ok {
+		// 找到字段后还需要获取其 timeFormat 信息
+		for _, f := range descriptor.fields {
+			if f.index == index {
+				return index, f.isTime, f.timeFormat, true
+			}
+		}
+		return index, false, "", true
 	}
 	// 2. 归一化匹配 (忽略大小写、下划线等) - 零分配比对
 	for _, f := range descriptor.fields {

json_encoder.go

@@ -17,6 +17,7 @@ var (
 		},
 	}
 	encoderStructCache sync.Map
+	timeType           = reflect.TypeOf(time.Time{})
 )
 
 type encoderFieldDescriptor struct {
@@ -98,11 +99,8 @@ func (encoder *fastEncoder) encodeValue(reflectValue reflect.Value, path string)
 }
 
 func (encoder *fastEncoder) writeTime(t time.Time, format string) {
-	if format == "" {
-		format = "2006-01-02 15:04:05.000"
-	}
 	encoder.buffer.WriteByte('"')
-	encoder.buffer.WriteString(t.In(DefaultTimeZone.loc).Format(format))
+	encoder.buffer.WriteString(t.Format(format))
 	encoder.buffer.WriteByte('"')
 }
 
@@ -217,12 +215,9 @@ func getEncoderStructDescriptor(reflectType reflect.Type) *encoderStructDescript
 		}
 
 		tag := field.Tag.Get("json")
-		if tag == "-" {
-			continue
-		}
 		fieldDesc.keepKey = strings.Contains(string(field.Tag), "keepKey")
 
-		if tag != "" {
+		if tag != "" && tag != "-" {
 			parts := strings.Split(tag, ",")
 			for _, part := range parts {
 				if strings.HasPrefix(part, "format=") {

merge_test.go

@@ -1,119 +0,0 @@
-package cast_test
-
-import (
-	"testing"
-	"apigo.cc/go/cast"
-)
-
-type DBConfig struct {
-	Host string
-	Port int
-}
-
-func TestMapStructMerge(t *testing.T) {
-	// Initial configuration with default values
-	dst := map[string]DBConfig{
-		"mysql": {Host: "localhost", Port: 3306},
-	}
-
-	// New data (e.g., from environment variables) that only overrides Host
-	src := map[string]any{
-		"mysql": map[string]any{
-			"Host": "127.0.0.1",
-		},
-	}
-
-	// Perform conversion/merge
-	cast.Convert(&dst, src)
-
-	// Verify results
-	mysql, ok := dst["mysql"]
-	if !ok {
-		t.Fatal("mysql config not found")
-	}
-
-	if mysql.Host != "127.0.0.1" {
-		t.Errorf("Expected Host 127.0.0.1, got %s", mysql.Host)
-	}
-
-	if mysql.Port != 3306 {
-		t.Errorf("Expected Port 3306, got %d", mysql.Port)
-	}
-}
-
-func TestMapStructPointerMerge(t *testing.T) {
-	// Initial configuration with default values (using pointers)
-	dst := map[string]*DBConfig{
-		"mysql": {Host: "localhost", Port: 3306},
-	}
-
-	// New data that only overrides Host
-	src := map[string]any{
-		"mysql": map[string]any{
-			"Host": "127.0.0.1",
-		},
-	}
-
-	// Perform conversion/merge
-	cast.Convert(&dst, src)
-
-	// Verify results
-	mysql, ok := dst["mysql"]
-	if !ok {
-		t.Fatal("mysql config not found")
-	}
-
-	if mysql.Host != "127.0.0.1" {
-		t.Errorf("Expected Host 127.0.0.1, got %s", mysql.Host)
-	}
-
-	if mysql.Port != 3306 {
-		t.Errorf("Expected Port 3306, got %d", mysql.Port)
-	}
-}
-
-func TestSliceToMapMerge(t *testing.T) {
-	dst := map[string]int{
-		"a": 1,
-		"b": 2,
-	}
-	src := []any{"b", 20, "c", 30}
-
-	cast.Convert(&dst, src)
-
-	if dst["a"] != 1 {
-		t.Errorf("Expected a=1, got %d", dst["a"])
-	}
-	if dst["b"] != 20 {
-		t.Errorf("Expected b=20, got %d", dst["b"])
-	}
-	if dst["c"] != 30 {
-		t.Errorf("Expected c=30, got %d", dst["c"])
-	}
-}
-
-func TestStructToMapMerge(t *testing.T) {
-	type Config struct {
-		Host string
-		Port int
-	}
-	dst := map[string]any{
-		"host": "localhost",
-		"port": 3306,
-		"user": "root",
-	}
-	// Note: Struct fields are always "present", so Port:0 will overwrite port:3306
-	src := Config{Host: "127.0.0.1", Port: 8080}
-
-	cast.Convert(&dst, src)
-
-	if dst["host"] != "127.0.0.1" {
-		t.Errorf("Expected host 127.0.0.1, got %v", dst["host"])
-	}
-	if cast.Int(dst["port"]) != 8080 {
-		t.Errorf("Expected port 8080, got %v", dst["port"])
-	}
-	if dst["user"] != "root" {
-		t.Errorf("Expected user root, got %v", dst["user"])
-	}
-}

semantic_test.go

@@ -2,7 +2,6 @@ package cast_test
 
 import (
 	"testing"
-
 	"apigo.cc/go/cast"
 )
 
@@ -29,7 +28,7 @@ func TestTo(t *testing.T) {
 
 	// JSON Auto conversion (Struct to String)
 	type User struct {
-		Name string
+		Name string `json:"name"`
 	}
 	u := User{Name: "Alice"}
 	js := cast.To[string](u)

time.go

@@ -1,391 +0,0 @@
-package cast
-
-import (
-	"fmt"
-	"regexp"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// TimeZone 定义了特定时区上下文下的时间操作
-type TimeZone struct {
-	loc *time.Location
-}
-
-// NewTimeZone 创建一个时区上下文
-func NewTimeZone(loc *time.Location) *TimeZone {
-	if loc == nil {
-		loc = time.Local
-	}
-	return &TimeZone{loc: loc}
-}
-
-// DefaultTimeZone 全局默认时区，默认为本地时区
-var DefaultTimeZone = NewTimeZone(time.Local)
-
-// SetDefaultTimeZone 修改全局默认时区
-func SetDefaultTimeZone(loc *time.Location) {
-	if loc != nil {
-		DefaultTimeZone = NewTimeZone(loc)
-	}
-}
-
-// 在包级别预先初始化 Replacer，0 额外分配
-var timeFormatReplacer = strings.NewReplacer(
-	"YYYY", "2006", "YY", "06",
-	"MM", "01", "M", "1",
-	"DD", "02", "D", "2",
-	"HH", "15", "hh", "03", "h", "3",
-	"mm", "04", "ss", "05",
-	"a", "pm", "A", "PM",
-	"ZZ", "-0700", "Z", "-07:00",
-)
-
-// ParseTime 将任意类型转换为 time.Time。
-// 支持：time.Time, 时间戳 (秒/毫秒/微秒/纳秒), RFC3339, JS 格式, 中文格式等。
-// 转换失败返回零值 time.Time{} 以保持 cast 的静默风格。
-func (tz *TimeZone) ParseTime(v any) time.Time {
-	if v == nil {
-		return time.Time{}
-	}
-
-	if tm, ok := v.(time.Time); ok {
-		return tm.In(tz.loc)
-	}
-
-	// 1. 优先探测是否为原生数字类型 (时间戳)，彻底 0 分配
-	switch val := v.(type) {
-	case int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, float32, float64:
-		num := Int64(val)
-		if num > 0 {
-			switch {
-			case num < 1e10: // 秒
-				return time.Unix(num, 0).In(tz.loc)
-			case num < 1e13: // 毫秒
-				return time.UnixMilli(num).In(tz.loc)
-			case num < 1e16: // 微秒
-				return time.UnixMicro(num).In(tz.loc)
-			default: // 纳秒
-				return time.Unix(0, num).In(tz.loc)
-			}
-		}
-	}
-
-	// 2. 数字没命中，再老老实实当字符串处理
-	str := strings.TrimSpace(String(v))
-	if str == "" {
-		return time.Time{}
-	}
-
-	var tm time.Time
-	var err error
-
-	// 3. 处理纯数字字符串 (紧凑格式或时间戳)
-	if num, err := strconv.ParseInt(str, 10, 64); err == nil && num > 0 {
-		// 紧凑格式解析
-		switch len(str) {
-		case 14: // 20060102150405
-			if tm, err = time.ParseInLocation("20060102150405", str, tz.loc); err == nil {
-				return tm
-			}
-		case 8: // 20060102
-			if tm, err = time.ParseInLocation("20060102", str, tz.loc); err == nil {
-				return tm
-			}
-		case 6: // 150405 或 060102
-			if tm, err = time.ParseInLocation("150405", str, tz.loc); err == nil {
-				return tm
-			}
-			if tm, err = time.ParseInLocation("060102", str, tz.loc); err == nil {
-				return tm
-			}
-		}
-
-		// 时间戳处理
-		switch {
-		case num < 1e10: // 秒
-			return time.Unix(num, 0).In(tz.loc)
-		case num < 1e13: // 毫秒
-			return time.UnixMilli(num).In(tz.loc)
-		case num < 1e16: // 微秒
-			return time.UnixMicro(num).In(tz.loc)
-		default: // 纳秒
-			return time.Unix(0, num).In(tz.loc)
-		}
-	}
-
-	// 2. 标准格式与常见变体
-	// RFC3339 (带 T 和 Z 或偏移量)
-	if strings.Contains(str, "T") {
-		if tm, err = time.Parse(time.RFC3339Nano, str); err == nil {
-			return tm.In(tz.loc)
-		}
-		if tm, err = time.Parse(time.RFC3339, str); err == nil {
-			return tm.In(tz.loc)
-		}
-	}
-
-	// 处理分隔符：-, /, .
-	if len(str) >= 10 && (str[4] == '-' || str[4] == '/' || str[4] == '.') {
-		sep := str[4]
-		layout := fmt.Sprintf("2006%c01%c02", sep, sep)
-
-		// 完整日期时间
-		if len(str) >= 19 {
-			tsep := str[10] // 通常是 ' ' 或 'T'
-			if len(str) >= 20 && str[19] == '.' {
-				// 带纳秒
-				if tm, err = time.ParseInLocation(layout+fmt.Sprintf("%c15:04:05.999999999", tsep), str, tz.loc); err == nil {
-					return tm
-				}
-			} else {
-				if tm, err = time.ParseInLocation(layout+fmt.Sprintf("%c15:04:05", tsep), str[:19], tz.loc); err == nil {
-					return tm
-				}
-			}
-		}
-		// 纯日期
-		if tm, err = time.ParseInLocation(layout, str[:10], tz.loc); err == nil {
-			return tm
-		}
-	}
-
-	// 06-01-02 这种短年份格式
-	if len(str) >= 8 && (str[2] == '-' || str[2] == '/' || str[2] == '.') {
-		sep := str[2]
-		layout := fmt.Sprintf("06%c01%c02", sep, sep)
-		if len(str) >= 17 && (str[8] == ' ' || str[8] == 'T') {
-			if tm, err = time.ParseInLocation(layout+fmt.Sprintf("%c15:04:05", str[8]), str[:17], tz.loc); err == nil {
-				return tm
-			}
-		}
-		if tm, err = time.ParseInLocation(layout, str[:8], tz.loc); err == nil {
-			return tm
-		}
-	}
-
-	// 3. 特殊格式：JS, HTTP, 中文
-	if strings.Contains(str, "GMT") || strings.Contains(str, "CST") {
-		cleanStr := strings.SplitN(str, " (", 2)[0]
-		cleanStr = strings.Replace(cleanStr, "CST", "+0800", 1)
-
-		formats := []string{
-			"Mon Jan 02 2006 15:04:05 GMT-0700",
-			"Mon, 02 Jan 2006 15:04:05 GMT",
-			time.RFC1123Z,
-			time.RFC1123,
-			time.UnixDate,
-		}
-		for _, f := range formats {
-			if tm, err = time.Parse(f, cleanStr); err == nil {
-				return tm.In(tz.loc)
-			}
-		}
-	}
-
-	// 中文格式解析
-	if strings.ContainsAny(str, "年月日时点分秒") {
-		return tz.parseCN(str)
-	}
-
-	// 纯时间格式
-	if strings.Contains(str, ":") {
-		if tm, err = time.ParseInLocation("15:04:05.999999", str, tz.loc); err == nil {
-			return tm
-		}
-		if tm, err = time.ParseInLocation("15:04:05", str, tz.loc); err == nil {
-			return tm
-		}
-		if tm, err = time.ParseInLocation("15:04", str, tz.loc); err == nil {
-			return tm
-		}
-	}
-
-	return time.Time{}
-}
-
-var cnDateRegex = regexp.MustCompile(`(\d{2,4})?年?(\d{1,2})月(\d{1,2})日`)
-var cnTimeRegex = regexp.MustCompile(`(上午|下午)?(\d{1,2})(?:时|点|：)(\d{1,2})(?:分|：)(\d{1,2})?秒?`)
-
-func (tz *TimeZone) parseCN(str string) time.Time {
-	str = strings.ReplaceAll(str, "：", ":")
-	str = strings.ReplaceAll(str, " ", "")
-	var y, m, d, h, mm, s int
-	if matches := cnDateRegex.FindStringSubmatch(str); len(matches) == 4 {
-		y = Int(matches[1])
-		m = Int(matches[2])
-		d = Int(matches[3])
-		if y > 0 && y < 100 {
-			y += 2000
-		}
-	}
-	if matches := cnTimeRegex.FindStringSubmatch(str); len(matches) == 5 {
-		h = Int(matches[2])
-		mm = Int(matches[3])
-		s = Int(matches[4])
-		if matches[1] == "下午" && h < 12 {
-			h += 12
-		}
-		if matches[1] == "上午" && h >= 12 {
-			h -= 12
-		}
-	}
-	now := time.Now().In(tz.loc)
-	if y == 0 {
-		y = now.Year()
-	}
-	if m == 0 {
-		m = int(now.Month())
-	}
-	if d == 0 {
-		d = now.Day()
-	}
-	return time.Date(y, time.Month(m), d, h, mm, s, 0, tz.loc)
-}
-
-// ParseTime 将任意类型转换为 time.Time。
-func ParseTime(v any) time.Time {
-	return DefaultTimeZone.ParseTime(v)
-}
-
-// FormatTime 格式化时间。
-// layout 支持: YYYY-MM-DD HH:mm:ss, YYYY/MM/DD, HH:mm 等直观格式。
-func (tz *TimeZone) FormatTime(layout string, v any) string {
-	tm := tz.ParseTime(v)
-	if tm.IsZero() {
-		return ""
-	}
-	// 一次性流式替换，性能直接翻倍
-	return tm.Format(timeFormatReplacer.Replace(layout))
-}
-
-// FormatTime 格式化时间。
-func FormatTime(layout string, v any) string {
-	return DefaultTimeZone.FormatTime(layout, v)
-}
-
-// AddTime 时间加减 DSL。
-// 格式如: "+1Y-2M+3D", "+1h30m", "-1s"。
-// 单位支持: Y (年), M (月), D (天), h, m, s, ms, us, ns。
-func (tz *TimeZone) AddTime(expr string, v any) time.Time {
-	tm := tz.ParseTime(v)
-	if tm.IsZero() {
-		return tm
-	}
-	if expr == "" {
-		return tm
-	}
-
-	i := 0
-	years, months, days := 0, 0, 0
-	var duration time.Duration
-
-	for i < len(expr) {
-		sign := 1
-		if expr[i] == '+' {
-			i++
-		} else if expr[i] == '-' {
-			sign = -1
-			i++
-		}
-
-		j := i
-		for j < len(expr) && expr[j] >= '0' && expr[j] <= '9' {
-			j++
-		}
-		num := 1
-		if j > i {
-			num, _ = strconv.Atoi(expr[i:j])
-		}
-		val := num * sign
-
-		i = j
-		unit := ""
-		// 匹配双字符单位 (ms, us, ns)
-		if i+2 <= len(expr) {
-			u2 := expr[i : i+2]
-			if u2 == "ms" || u2 == "us" || u2 == "ns" {
-				unit = u2
-				i += 2
-			}
-		}
-		// 匹配单字符单位
-		if unit == "" && i < len(expr) {
-			unit = expr[i : i+1]
-			i++
-		}
-
-		switch unit {
-		case "Y":
-			years += val
-		case "M":
-			months += val
-		case "D":
-			days += val
-		case "h":
-			duration += time.Duration(val) * time.Hour
-		case "m":
-			duration += time.Duration(val) * time.Minute
-		case "s":
-			duration += time.Duration(val) * time.Second
-		case "ms":
-			duration += time.Duration(val) * time.Millisecond
-		case "us":
-			duration += time.Duration(val) * time.Microsecond
-		case "ns":
-			duration += time.Duration(val) * time.Nanosecond
-		default:
-			// 默认秒
-			duration += time.Duration(val) * time.Second
-		}
-	}
-
-	if years != 0 || months != 0 || days != 0 {
-		tm = tm.AddDate(years, months, days)
-	}
-	return tm.Add(duration)
-}
-
-// AddTime 时间加减 DSL。
-func AddTime(expr string, v any) time.Time {
-	return DefaultTimeZone.AddTime(expr, v)
-}
-
-// Now 获取当前时间
-func (tz *TimeZone) Now() time.Time { return time.Now().In(tz.loc) }
-
-// Location 获取当前时区
-func (tz *TimeZone) Location() *time.Location { return tz.loc }
-
-// Now 获取当前时间
-func Now() time.Time { return DefaultTimeZone.Now() }
-
-// DescribeDuration 将时长转化为自然语言描述，例如 "1h 1m 1s"
-func (tz *TimeZone) DescribeDuration(d time.Duration) string {
-	h := d / time.Hour
-	d -= h * time.Hour
-	m := d / time.Minute
-	d -= m * time.Minute
-	s := d / time.Second
-
-	var parts []string
-	if h > 0 {
-		parts = append(parts, fmt.Sprintf("%dh", h))
-	}
-	if m > 0 {
-		parts = append(parts, fmt.Sprintf("%dm", m))
-	}
-	if s > 0 {
-		parts = append(parts, fmt.Sprintf("%ds", s))
-	}
-	if len(parts) == 0 {
-		return "0s"
-	}
-	return strings.Join(parts, " ")
-}
-
-// DescribeDuration 将时长转化为自然语言描述
-func DescribeDuration(d time.Duration) string {
-	return DefaultTimeZone.DescribeDuration(d)
-}

time_bench_bench_test.go

@@ -1,45 +0,0 @@
-package cast_test
-
-import (
-	"testing"
-	"time"
-
-	"apigo.cc/go/cast"
-)
-
-func BenchmarkParseTime_RFC3339(b *testing.B) {
-	s := "2023-05-04T12:34:56Z"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = cast.ParseTime(s)
-	}
-}
-
-func BenchmarkParseTime_Standard(b *testing.B) {
-	s := "2023-05-04 12:34:56"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = cast.ParseTime(s)
-	}
-}
-
-func BenchmarkParseTime_Numeric(b *testing.B) {
-	s := "20230504123456"
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_ = cast.ParseTime(s)
-	}
-}
-
-func BenchmarkToJSON_WithTime(b *testing.B) {
-	type User struct {
-		ID        int       `json:"id"`
-		Name      string    `json:"name"`
-		CreatedAt time.Time `json:"created_at"`
-	}
-	u := User{ID: 1, Name: "Benchmark User", CreatedAt: time.Now()}
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		_, _ = cast.ToJSON(u)
-	}
-}

time_test.go

@@ -1,68 +0,0 @@
-package cast_test
-
-import (
-	"testing"
-	"time"
-
-	"apigo.cc/go/cast"
-)
-
-func TestParseTime(t *testing.T) {
-	tests := []struct {
-		input    any
-		expected string
-	}{
-		{"2023-05-04 12:34:56", "2023-05-04 12:34:56"},
-		{"2023/05/04 12:34:56", "2023-05-04 12:34:56"},
-		{"2023.05.04 12:34:56", "2023-05-04 12:34:56"},
-		{"20230504123456", "2023-05-04 12:34:56"},
-		{1683196496, "2023-05-04 10:34:56"}, // Unix timestamp (Example)
-		{"2023年5月4日 12时34分56秒", "2023-05-04 12:34:56"},
-	}
-
-	// Set UTC for test stability if needed, or just compare formatted strings
-	loc, _ := time.LoadLocation("UTC")
-	cast.SetDefaultTimeZone(loc)
-
-	for _, tt := range tests {
-		tm := cast.ParseTime(tt.input)
-		// We use a relative check for timestamp since it depends on the timezone if not careful
-		if tt.input == 1683196496 {
-			// 1683196496 is 2023-05-04 10:34:56 UTC
-			if tm.Format("2006-01-02 15:04:05") != tt.expected {
-				t.Errorf("ParseTime(%v) = %v, want %v", tt.input, tm.Format("2006-01-02 15:04:05"), tt.expected)
-			}
-			continue
-		}
-		
-		if tm.Format("2006-01-02 15:04:05") != tt.expected {
-			t.Errorf("ParseTime(%v) = %v, want %v", tt.input, tm.Format("2006-01-02 15:04:05"), tt.expected)
-		}
-	}
-}
-
-func TestFormatTime(t *testing.T) {
-	tm := time.Date(2023, 5, 4, 12, 34, 56, 0, time.UTC)
-	formatted := cast.FormatTime("YYYY-MM-DD HH:mm:ss", tm)
-	if formatted != "2023-05-04 12:34:56" {
-		t.Errorf("FormatTime failed, got %s", formatted)
-	}
-}
-
-func TestAddTime(t *testing.T) {
-	tm := time.Date(2023, 5, 4, 12, 34, 56, 0, time.UTC)
-	added := cast.AddTime("+1Y+1M+1D", tm)
-	expected := time.Date(2024, 6, 5, 12, 34, 56, 0, time.UTC)
-	if !added.Equal(expected) {
-		t.Errorf("AddTime failed, got %v, want %v", added, expected)
-	}
-}
-
-func TestTimeZoneNow(t *testing.T) {
-	loc, _ := time.LoadLocation("Asia/Shanghai")
-	tz := cast.NewTimeZone(loc)
-	now := tz.Now()
-	if now.Location().String() != "Asia/Shanghai" {
-		t.Errorf("TimeZone.Now() failed to set location, got %s", now.Location().String())
-	}
-}