refactor(util/gconv): add Converter feature for more flexable and extensible type converting (#4107)

.github/PULL_REQUEST_TEMPLATE.MD

@@ -1,16 +1,16 @@
 **Please ensure you adhere to every item in this list.**
 + The PR title is formatted as follows: `<type>[optional scope]: <description>` For example, `fix(os/gtime): fix time zone issue`
   + `<type>` is mandatory and can be one of `fix`, `feat`, `build`, `ci`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`
-    + fix: Used when a bug has been fixed.
-    + feat: Used when a new feature has been added.
-    + build: Used for modifications to the project build system, such as changes to dependencies, external interfaces, or upgrading Node version.
-    + ci: Used for modifications to continuous integration processes, such as changes to Travis, Jenkins workflow configurations.
-    + docs: Used for modifications to documentation, such as changes to README files, API documentation, etc.
-    + style: Used for changes to code style, such as adjustments to indentation, spaces, blank lines, etc.
-    + refactor: Used for code refactoring, such as changes to code structure, variable names, function names, without altering functionality.
-    + perf: Used for performance optimization, such as improving code performance, reducing memory usage, etc.
-    + test: Used for modifications to test cases, such as adding, deleting, or modifying test cases for code.
-    + chore: Used for modifications to non-business-related code, such as changes to build processes or tool configurations.
+    + `fix`: Used when a bug has been fixed.
+    + `feat`: Used when a new feature has been added.
+    + `build`: Used for modifications to the project build system, such as changes to dependencies, external interfaces, or upgrading Node version.
+    + `ci`: Used for modifications to continuous integration processes, such as changes to Travis, Jenkins workflow configurations.
+    + `docs`: Used for modifications to documentation, such as changes to README files, API documentation, etc.
+    + `style`: Used for changes to code style, such as adjustments to indentation, spaces, blank lines, etc.
+    + `refactor`: Used for code refactoring, such as changes to code structure, variable names, function names, without altering functionality.
+    + `perf`: Used for performance optimization, such as improving code performance, reducing memory usage, etc.
+    + `test`: Used for modifications to test cases, such as adding, deleting, or modifying test cases for code.
+    + `chore`: Used for modifications to non-business-related code, such as changes to build processes or tool configurations.
   + After `<type>`, specify the affected package name or scope in parentheses, for example, `(os/gtime)`.
   + The part after the colon uses the verb tense + phrase that completes the blank in
   + Lowercase verb after the colon

Makefile

@@ -34,8 +34,8 @@ version:
 subup:
 	@set -e; \
 	echo "Updating submodules..."; \
-	cd examples && git pull origin main; \
-	cd ..;
+	git submodule init;\
+	git submodule update;
 
 # update and commit submodules
 .PHONY: subsync

cmd/gf/internal/cmd/gendao/gendao.go

@@ -36,7 +36,7 @@ type (
 		Link               string   `name:"link"                short:"l"  brief:"{CGenDaoBriefLink}"`
 		Tables             string   `name:"tables"              short:"t"  brief:"{CGenDaoBriefTables}"`
 		TablesEx           string   `name:"tablesEx"            short:"x"  brief:"{CGenDaoBriefTablesEx}"`
-		ShardingPattern    []string `name:"ShardingPattern"     short:"sp" brief:"{CGenDaoBriefShardingPattern}"`
+		ShardingPattern    []string `name:"shardingPattern"     short:"sp" brief:"{CGenDaoBriefShardingPattern}"`
 		Group              string   `name:"group"               short:"g"  brief:"{CGenDaoBriefGroup}" d:"default"`
 		Prefix             string   `name:"prefix"              short:"f"  brief:"{CGenDaoBriefPrefix}"`
 		RemovePrefix       string   `name:"removePrefix"        short:"r"  brief:"{CGenDaoBriefRemovePrefix}"`

container/gvar/gvar.go

@@ -8,14 +8,8 @@
 package gvar
 
 import (
-	"time"
-
 	"github.com/gogf/gf/v2/container/gtype"
-	"github.com/gogf/gf/v2/internal/deepcopy"
 	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/os/gtime"
-	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/gutil"
 )
 
 // Var is an universal variable type implementer.
@@ -39,144 +33,8 @@ func New(value interface{}, safe ...bool) *Var {
 	}
 }
 
-// Copy does a deep copy of current Var and returns a pointer to this Var.
-func (v *Var) Copy() *Var {
-	return New(gutil.Copy(v.Val()), v.safe)
-}
-
-// Clone does a shallow copy of current Var and returns a pointer to this Var.
-func (v *Var) Clone() *Var {
-	return New(v.Val(), v.safe)
-}
-
-// Set sets `value` to `v`, and returns the old value.
-func (v *Var) Set(value interface{}) (old interface{}) {
-	if v.safe {
-		if t, ok := v.value.(*gtype.Interface); ok {
-			old = t.Set(value)
-			return
-		}
-	}
-	old = v.value
-	v.value = value
-	return
-}
-
-// Val returns the current value of `v`.
-func (v *Var) Val() interface{} {
-	if v == nil {
-		return nil
-	}
-	if v.safe {
-		if t, ok := v.value.(*gtype.Interface); ok {
-			return t.Val()
-		}
-	}
-	return v.value
-}
-
-// Interface is alias of Val.
-func (v *Var) Interface() interface{} {
-	return v.Val()
-}
-
-// Bytes converts and returns `v` as []byte.
-func (v *Var) Bytes() []byte {
-	return gconv.Bytes(v.Val())
-}
-
-// String converts and returns `v` as string.
-func (v *Var) String() string {
-	return gconv.String(v.Val())
-}
-
-// Bool converts and returns `v` as bool.
-func (v *Var) Bool() bool {
-	return gconv.Bool(v.Val())
-}
-
-// Int converts and returns `v` as int.
-func (v *Var) Int() int {
-	return gconv.Int(v.Val())
-}
-
-// Int8 converts and returns `v` as int8.
-func (v *Var) Int8() int8 {
-	return gconv.Int8(v.Val())
-}
-
-// Int16 converts and returns `v` as int16.
-func (v *Var) Int16() int16 {
-	return gconv.Int16(v.Val())
-}
-
-// Int32 converts and returns `v` as int32.
-func (v *Var) Int32() int32 {
-	return gconv.Int32(v.Val())
-}
-
-// Int64 converts and returns `v` as int64.
-func (v *Var) Int64() int64 {
-	return gconv.Int64(v.Val())
-}
-
-// Uint converts and returns `v` as uint.
-func (v *Var) Uint() uint {
-	return gconv.Uint(v.Val())
-}
-
-// Uint8 converts and returns `v` as uint8.
-func (v *Var) Uint8() uint8 {
-	return gconv.Uint8(v.Val())
-}
-
-// Uint16 converts and returns `v` as uint16.
-func (v *Var) Uint16() uint16 {
-	return gconv.Uint16(v.Val())
-}
-
-// Uint32 converts and returns `v` as uint32.
-func (v *Var) Uint32() uint32 {
-	return gconv.Uint32(v.Val())
-}
-
-// Uint64 converts and returns `v` as uint64.
-func (v *Var) Uint64() uint64 {
-	return gconv.Uint64(v.Val())
-}
-
-// Float32 converts and returns `v` as float32.
-func (v *Var) Float32() float32 {
-	return gconv.Float32(v.Val())
-}
-
-// Float64 converts and returns `v` as float64.
-func (v *Var) Float64() float64 {
-	return gconv.Float64(v.Val())
-}
-
-// Time converts and returns `v` as time.Time.
-// The parameter `format` specifies the format of the time string using gtime,
-// eg: Y-m-d H:i:s.
-func (v *Var) Time(format ...string) time.Time {
-	return gconv.Time(v.Val(), format...)
-}
-
-// Duration converts and returns `v` as time.Duration.
-// If value of `v` is string, then it uses time.ParseDuration for conversion.
-func (v *Var) Duration() time.Duration {
-	return gconv.Duration(v.Val())
-}
-
-// GTime converts and returns `v` as *gtime.Time.
-// The parameter `format` specifies the format of the time string using gtime,
-// eg: Y-m-d H:i:s.
-func (v *Var) GTime(format ...string) *gtime.Time {
-	return gconv.GTime(v.Val(), format...)
-}
-
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (v Var) MarshalJSON() ([]byte, error) {
+func (v *Var) MarshalJSON() ([]byte, error) {
 	return json.Marshal(v.Val())
 }
 
@@ -195,11 +53,3 @@ func (v *Var) UnmarshalValue(value interface{}) error {
 	v.Set(value)
 	return nil
 }
-
-// DeepCopy implements interface for deep copy of current type.
-func (v *Var) DeepCopy() interface{} {
-	if v == nil {
-		return nil
-	}
-	return New(deepcopy.Copy(v.Val()), v.safe)
-}

container/gvar/gvar_basic.go

@@ -0,0 +1,105 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gvar
+
+import (
+	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// Val returns the current value of `v`.
+func (v *Var) Val() any {
+	if v == nil {
+		return nil
+	}
+	if v.safe {
+		if t, ok := v.value.(*gtype.Interface); ok {
+			return t.Val()
+		}
+	}
+	return v.value
+}
+
+// Interface is alias of Val.
+func (v *Var) Interface() any {
+	return v.Val()
+}
+
+// Bytes converts and returns `v` as []byte.
+func (v *Var) Bytes() []byte {
+	return gconv.Bytes(v.Val())
+}
+
+// String converts and returns `v` as string.
+func (v *Var) String() string {
+	return gconv.String(v.Val())
+}
+
+// Bool converts and returns `v` as bool.
+func (v *Var) Bool() bool {
+	return gconv.Bool(v.Val())
+}
+
+// Int converts and returns `v` as int.
+func (v *Var) Int() int {
+	return gconv.Int(v.Val())
+}
+
+// Int8 converts and returns `v` as int8.
+func (v *Var) Int8() int8 {
+	return gconv.Int8(v.Val())
+}
+
+// Int16 converts and returns `v` as int16.
+func (v *Var) Int16() int16 {
+	return gconv.Int16(v.Val())
+}
+
+// Int32 converts and returns `v` as int32.
+func (v *Var) Int32() int32 {
+	return gconv.Int32(v.Val())
+}
+
+// Int64 converts and returns `v` as int64.
+func (v *Var) Int64() int64 {
+	return gconv.Int64(v.Val())
+}
+
+// Uint converts and returns `v` as uint.
+func (v *Var) Uint() uint {
+	return gconv.Uint(v.Val())
+}
+
+// Uint8 converts and returns `v` as uint8.
+func (v *Var) Uint8() uint8 {
+	return gconv.Uint8(v.Val())
+}
+
+// Uint16 converts and returns `v` as uint16.
+func (v *Var) Uint16() uint16 {
+	return gconv.Uint16(v.Val())
+}
+
+// Uint32 converts and returns `v` as uint32.
+func (v *Var) Uint32() uint32 {
+	return gconv.Uint32(v.Val())
+}
+
+// Uint64 converts and returns `v` as uint64.
+func (v *Var) Uint64() uint64 {
+	return gconv.Uint64(v.Val())
+}
+
+// Float32 converts and returns `v` as float32.
+func (v *Var) Float32() float32 {
+	return gconv.Float32(v.Val())
+}
+
+// Float64 converts and returns `v` as float64.
+func (v *Var) Float64() float64 {
+	return gconv.Float64(v.Val())
+}

container/gvar/gvar_copy.go

@@ -0,0 +1,30 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gvar
+
+import (
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+// Copy does a deep copy of current Var and returns a pointer to this Var.
+func (v *Var) Copy() *Var {
+	return New(gutil.Copy(v.Val()), v.safe)
+}
+
+// Clone does a shallow copy of current Var and returns a pointer to this Var.
+func (v *Var) Clone() *Var {
+	return New(v.Val(), v.safe)
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (v *Var) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
+	return New(deepcopy.Copy(v.Val()), v.safe)
+}

container/gvar/gvar_scan.go

@@ -10,8 +10,7 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
-// Scan automatically checks the type of `pointer` and converts `params` to `pointer`. It supports `pointer`
-// with type of `*map/*[]map/*[]*map/*struct/**struct/*[]struct/*[]*struct` for converting.
+// Scan automatically checks the type of `pointer` and converts value of Var to `pointer`.
 //
 // See gconv.Scan.
 func (v *Var) Scan(pointer interface{}, mapping ...map[string]string) error {

container/gvar/gvar_set.go

@@ -0,0 +1,24 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gvar
+
+import (
+	"github.com/gogf/gf/v2/container/gtype"
+)
+
+// Set sets `value` to `v`, and returns the old value.
+func (v *Var) Set(value interface{}) (old interface{}) {
+	if v.safe {
+		if t, ok := v.value.(*gtype.Interface); ok {
+			old = t.Set(value)
+			return
+		}
+	}
+	old = v.value
+	v.value = value
+	return
+}

container/gvar/gvar_time.go

@@ -0,0 +1,34 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gvar
+
+import (
+	"time"
+
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// Time converts and returns `v` as time.Time.
+// The parameter `format` specifies the format of the time string using gtime,
+// eg: Y-m-d H:i:s.
+func (v *Var) Time(format ...string) time.Time {
+	return gconv.Time(v.Val(), format...)
+}
+
+// Duration converts and returns `v` as time.Duration.
+// If value of `v` is string, then it uses time.ParseDuration for conversion.
+func (v *Var) Duration() time.Duration {
+	return gconv.Duration(v.Val())
+}
+
+// GTime converts and returns `v` as *gtime.Time.
+// The parameter `format` specifies the format of the time string using gtime,
+// eg: Y-m-d H:i:s.
+func (v *Var) GTime(format ...string) *gtime.Time {
+	return gconv.GTime(v.Val(), format...)
+}

contrib/drivers/mysql/mysql_z_unit_feature_model_struct_test.go

@@ -17,7 +17,6 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
@@ -481,117 +480,3 @@ func Test_Scan_AutoFilteringByStructAttributes(t *testing.T) {
 		t.Assert(users[0].Id, 1)
 	})
 }
-
-func Test_Scan_JsonAttributes(t *testing.T) {
-	type GiftImage struct {
-		Uid    string `json:"uid"`
-		Url    string `json:"url"`
-		Status string `json:"status"`
-		Name   string `json:"name"`
-	}
-
-	type GiftComment struct {
-		Name     string `json:"name"`
-		Field    string `json:"field"`
-		Required bool   `json:"required"`
-	}
-
-	type Prop struct {
-		Name   string   `json:"name"`
-		Values []string `json:"values"`
-	}
-
-	type Sku struct {
-		GiftId      int64  `json:"gift_id"`
-		Name        string `json:"name"`
-		ScorePrice  int    `json:"score_price"`
-		MarketPrice int    `json:"market_price"`
-		CostPrice   int    `json:"cost_price"`
-		Stock       int    `json:"stock"`
-	}
-
-	type Covers struct {
-		List []GiftImage `json:"list"`
-	}
-
-	type GiftEntity struct {
-		Id                   int64         `json:"id"`
-		StoreId              int64         `json:"store_id"`
-		GiftType             int           `json:"gift_type"`
-		GiftName             string        `json:"gift_name"`
-		Description          string        `json:"description"`
-		Covers               Covers        `json:"covers"`
-		Cover                string        `json:"cover"`
-		GiftCategoryId       []int64       `json:"gift_category_id"`
-		HasProps             bool          `json:"has_props"`
-		OutSn                string        `json:"out_sn"`
-		IsLimitSell          bool          `json:"is_limit_sell"`
-		LimitSellType        int           `json:"limit_sell_type"`
-		LimitSellCycle       string        `json:"limit_sell_cycle"`
-		LimitSellCycleCount  int           `json:"limit_sell_cycle_count"`
-		LimitSellCustom      bool          `json:"limit_sell_custom"`   // 只允许特定会员兑换
-		LimitCustomerTags    []int64       `json:"limit_customer_tags"` // 允许兑换的成员
-		ScorePrice           int           `json:"score_price"`
-		MarketPrice          float64       `json:"market_price"`
-		CostPrice            int           `json:"cost_price"`
-		Stock                int           `json:"stock"`
-		Props                []Prop        `json:"props"`
-		Skus                 []Sku         `json:"skus"`
-		ExpressType          []string      `json:"express_type"`
-		Comments             []GiftComment `json:"comments"`
-		Content              string        `json:"content"`
-		AtLeastRechargeCount int           `json:"at_least_recharge_count"`
-		Status               int           `json:"status"`
-	}
-
-	type User struct {
-		Id       int
-		Passport string
-	}
-
-	table := "jfy_gift"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue1380.sql`), ";")
-	for _, v := range array {
-		if _, err := db.Exec(ctx, v); err != nil {
-			gtest.Error(err)
-		}
-	}
-	defer dropTable(table)
-
-	gtest.C(t, func(t *gtest.T) {
-		var (
-			entity = new(GiftEntity)
-			err    = db.Model(table).Where("id", 17).Scan(entity)
-		)
-		t.AssertNil(err)
-		t.Assert(len(entity.Skus), 2)
-
-		t.Assert(entity.Skus[0].Name, "red")
-		t.Assert(entity.Skus[0].Stock, 10)
-		t.Assert(entity.Skus[0].GiftId, 1)
-		t.Assert(entity.Skus[0].CostPrice, 80)
-		t.Assert(entity.Skus[0].ScorePrice, 188)
-		t.Assert(entity.Skus[0].MarketPrice, 388)
-
-		t.Assert(entity.Skus[1].Name, "blue")
-		t.Assert(entity.Skus[1].Stock, 100)
-		t.Assert(entity.Skus[1].GiftId, 2)
-		t.Assert(entity.Skus[1].CostPrice, 81)
-		t.Assert(entity.Skus[1].ScorePrice, 200)
-		t.Assert(entity.Skus[1].MarketPrice, 288)
-
-		t.Assert(entity.Id, 17)
-		t.Assert(entity.StoreId, 100004)
-		t.Assert(entity.GiftType, 1)
-		t.Assert(entity.GiftName, "GIFT")
-		t.Assert(entity.Description, "支持个性定制的父亲节老师长辈的专属礼物")
-		t.Assert(len(entity.Covers.List), 3)
-		t.Assert(entity.OutSn, "259402")
-		t.Assert(entity.LimitCustomerTags, "[]")
-		t.Assert(entity.ScorePrice, 10)
-		t.Assert(len(entity.Props), 1)
-		t.Assert(len(entity.Comments), 2)
-		t.Assert(entity.Status, 99)
-		t.Assert(entity.Content, `<p>礼品详情</p>`)
-	})
-}

contrib/drivers/mysql/mysql_z_unit_issue_test.go

@@ -8,6 +8,7 @@ package mysql_test
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"sync"
 	"testing"
@@ -24,6 +25,121 @@ import (
 	"github.com/gogf/gf/v2/util/guid"
 )
 
+// https://github.com/gogf/gf/issues/1380
+func Test_Issue1380(t *testing.T) {
+	type GiftImage struct {
+		Uid    string `json:"uid"`
+		Url    string `json:"url"`
+		Status string `json:"status"`
+		Name   string `json:"name"`
+	}
+
+	type GiftComment struct {
+		Name     string `json:"name"`
+		Field    string `json:"field"`
+		Required bool   `json:"required"`
+	}
+
+	type Prop struct {
+		Name   string   `json:"name"`
+		Values []string `json:"values"`
+	}
+
+	type Sku struct {
+		GiftId      int64  `json:"gift_id"`
+		Name        string `json:"name"`
+		ScorePrice  int    `json:"score_price"`
+		MarketPrice int    `json:"market_price"`
+		CostPrice   int    `json:"cost_price"`
+		Stock       int    `json:"stock"`
+	}
+
+	type Covers struct {
+		List []GiftImage `json:"list"`
+	}
+
+	type GiftEntity struct {
+		Id                   int64         `json:"id"`
+		StoreId              int64         `json:"store_id"`
+		GiftType             int           `json:"gift_type"`
+		GiftName             string        `json:"gift_name"`
+		Description          string        `json:"description"`
+		Covers               Covers        `json:"covers"`
+		Cover                string        `json:"cover"`
+		GiftCategoryId       []int64       `json:"gift_category_id"`
+		HasProps             bool          `json:"has_props"`
+		OutSn                string        `json:"out_sn"`
+		IsLimitSell          bool          `json:"is_limit_sell"`
+		LimitSellType        int           `json:"limit_sell_type"`
+		LimitSellCycle       string        `json:"limit_sell_cycle"`
+		LimitSellCycleCount  int           `json:"limit_sell_cycle_count"`
+		LimitSellCustom      bool          `json:"limit_sell_custom"`   // 只允许特定会员兑换
+		LimitCustomerTags    []int64       `json:"limit_customer_tags"` // 允许兑换的成员
+		ScorePrice           int           `json:"score_price"`
+		MarketPrice          float64       `json:"market_price"`
+		CostPrice            int           `json:"cost_price"`
+		Stock                int           `json:"stock"`
+		Props                []Prop        `json:"props"`
+		Skus                 []Sku         `json:"skus"`
+		ExpressType          []string      `json:"express_type"`
+		Comments             []GiftComment `json:"comments"`
+		Content              string        `json:"content"`
+		AtLeastRechargeCount int           `json:"at_least_recharge_count"`
+		Status               int           `json:"status"`
+	}
+
+	type User struct {
+		Id       int
+		Passport string
+	}
+
+	table := "jfy_gift"
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `1380.sql`), ";")
+	for _, v := range array {
+		if _, err := db.Exec(ctx, v); err != nil {
+			gtest.Error(err)
+		}
+	}
+	defer dropTable(table)
+
+	gtest.C(t, func(t *gtest.T) {
+		var (
+			entity = new(GiftEntity)
+			err    = db.Model(table).Where("id", 17).Scan(entity)
+		)
+		t.AssertNil(err)
+		t.Assert(len(entity.Skus), 2)
+
+		t.Assert(entity.Skus[0].Name, "red")
+		t.Assert(entity.Skus[0].Stock, 10)
+		t.Assert(entity.Skus[0].GiftId, 1)
+		t.Assert(entity.Skus[0].CostPrice, 80)
+		t.Assert(entity.Skus[0].ScorePrice, 188)
+		t.Assert(entity.Skus[0].MarketPrice, 388)
+
+		t.Assert(entity.Skus[1].Name, "blue")
+		t.Assert(entity.Skus[1].Stock, 100)
+		t.Assert(entity.Skus[1].GiftId, 2)
+		t.Assert(entity.Skus[1].CostPrice, 81)
+		t.Assert(entity.Skus[1].ScorePrice, 200)
+		t.Assert(entity.Skus[1].MarketPrice, 288)
+
+		t.Assert(entity.Id, 17)
+		t.Assert(entity.StoreId, 100004)
+		t.Assert(entity.GiftType, 1)
+		t.Assert(entity.GiftName, "GIFT")
+		t.Assert(entity.Description, "支持个性定制的父亲节老师长辈的专属礼物")
+		t.Assert(len(entity.Covers.List), 3)
+		t.Assert(entity.OutSn, "259402")
+		t.Assert(entity.LimitCustomerTags, "[]")
+		t.Assert(entity.ScorePrice, 10)
+		t.Assert(len(entity.Props), 1)
+		t.Assert(len(entity.Comments), 2)
+		t.Assert(entity.Status, 99)
+		t.Assert(entity.Content, `<p>礼品详情</p>`)
+	})
+}
+
 // https://github.com/gogf/gf/issues/1934
 func Test_Issue1934(t *testing.T) {
 	table := createInitTable()
@@ -170,7 +286,7 @@ func Test_Issue1401(t *testing.T) {
 		table1 = "parcels"
 		table2 = "parcel_items"
 	)
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue1401.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `1401.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -212,7 +328,7 @@ func Test_Issue1412(t *testing.T) {
 		table1 = "parcels"
 		table2 = "items"
 	)
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue1412.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `1412.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -474,7 +590,7 @@ func Test_Issue2012(t *testing.T) {
 // https://github.com/gogf/gf/issues/2105
 func Test_Issue2105(t *testing.T) {
 	table := "issue2105"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue2105.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `2105.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -772,7 +888,7 @@ func Test_Issue2561(t *testing.T) {
 // https://github.com/gogf/gf/issues/2439
 func Test_Issue2439(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := gstr.SplitAndTrim(gtest.DataContent(`issue2439.sql`), ";")
+		array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `2439.sql`), ";")
 		for _, v := range array {
 			if _, err := db.Exec(ctx, v); err != nil {
 				gtest.Error(err)
@@ -868,7 +984,7 @@ func Test_Issue2907(t *testing.T) {
 // https://github.com/gogf/gf/issues/3086
 func Test_Issue3086(t *testing.T) {
 	table := "issue3086_user"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue3086.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `3086.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -1013,7 +1129,7 @@ func Test_Issue3204(t *testing.T) {
 // https://github.com/gogf/gf/issues/3218
 func Test_Issue3218(t *testing.T) {
 	table := "issue3218_sys_config"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue3218.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `3218.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -1136,7 +1252,7 @@ func Test_Issue2552_ClearTableFields(t *testing.T) {
 // https://github.com/gogf/gf/issues/2643
 func Test_Issue2643(t *testing.T) {
 	table := "issue2643"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue2643.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `2643.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -1221,7 +1337,7 @@ func Test_Issue3649(t *testing.T) {
 // https://github.com/gogf/gf/issues/3754
 func Test_Issue3754(t *testing.T) {
 	table := "issue3754"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue3754.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `3754.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -1283,7 +1399,7 @@ func Test_Issue3754(t *testing.T) {
 // https://github.com/gogf/gf/issues/3626
 func Test_Issue3626(t *testing.T) {
 	table := "issue3626"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue3626.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `3626.sql`), ";")
 	defer dropTable(table)
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
@@ -1413,7 +1529,7 @@ func Test_Issue3968(t *testing.T) {
 // https://github.com/gogf/gf/issues/3915
 func Test_Issue3915(t *testing.T) {
 	table := "issue3915"
-	array := gstr.SplitAndTrim(gtest.DataContent(`issue3915.sql`), ";")
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `3915.sql`), ";")
 	for _, v := range array {
 		if _, err := db.Exec(ctx, v); err != nil {
 			gtest.Error(err)
@@ -1500,7 +1616,7 @@ func Test_Issue2119(t *testing.T) {
 		defer dropTable(tables[0])
 		defer dropTable(tables[1])
 		_ = tables
-		array := gstr.SplitAndTrim(gtest.DataContent(`issue2119.sql`), ";")
+		array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `2119.sql`), ";")
 		for _, v := range array {
 			_, err := db.Exec(ctx, v)
 			t.AssertNil(err)
@@ -1561,7 +1677,7 @@ func Test_Issue2119(t *testing.T) {
 func Test_Issue4034(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		table := "issue4034"
-		array := gstr.SplitAndTrim(gtest.DataContent(`issue4034.sql`), ";")
+		array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `4034.sql`), ";")
 		for _, v := range array {
 			_, err := db.Exec(ctx, v)
 			t.AssertNil(err)
@@ -1590,3 +1706,162 @@ func issue4034SaveAppDevice(ctx context.Context, table string, tx gdb.TX) error
 	}).Save()
 	return err
 }
+
+// https://github.com/gogf/gf/issues/4086
+func Test_Issue4086(t *testing.T) {
+	table := "issue4086"
+	defer dropTable(table)
+	array := gstr.SplitAndTrim(gtest.DataContent(`issues`, `4086.sql`), ";")
+	for _, v := range array {
+		_, err := db.Exec(ctx, v)
+		gtest.AssertNil(err)
+	}
+
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64   `json:"proxyId" orm:"proxy_id"`
+			RecommendIds []int64 `json:"recommendIds" orm:"recommend_ids"`
+			Photos       []int64 `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: []int64{584, 585},
+				Photos:       nil,
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: []int64{},
+				Photos:       nil,
+			},
+		})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64     `json:"proxyId" orm:"proxy_id"`
+			RecommendIds []int64   `json:"recommendIds" orm:"recommend_ids"`
+			Photos       []float32 `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: []int64{584, 585},
+				Photos:       nil,
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: []int64{},
+				Photos:       nil,
+			},
+		})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64    `json:"proxyId" orm:"proxy_id"`
+			RecommendIds []int64  `json:"recommendIds" orm:"recommend_ids"`
+			Photos       []string `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: []int64{584, 585},
+				Photos:       nil,
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: []int64{},
+				Photos:       nil,
+			},
+		})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64   `json:"proxyId" orm:"proxy_id"`
+			RecommendIds []int64 `json:"recommendIds" orm:"recommend_ids"`
+			Photos       []any   `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: []int64{584, 585},
+				Photos:       nil,
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: []int64{},
+				Photos:       nil,
+			},
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64   `json:"proxyId" orm:"proxy_id"`
+			RecommendIds []int64 `json:"recommendIds" orm:"recommend_ids"`
+			Photos       string  `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: []int64{584, 585},
+				Photos:       "null",
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: []int64{},
+				Photos:       "",
+			},
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		type ProxyParam struct {
+			ProxyId      int64           `json:"proxyId" orm:"proxy_id"`
+			RecommendIds string          `json:"recommendIds" orm:"recommend_ids"`
+			Photos       json.RawMessage `json:"photos" orm:"photos"`
+		}
+
+		var proxyParamList []*ProxyParam
+		err := db.Model(table).Ctx(ctx).Scan(&proxyParamList)
+		t.AssertNil(err)
+		t.Assert(len(proxyParamList), 2)
+		t.Assert(proxyParamList, []*ProxyParam{
+			{
+				ProxyId:      1,
+				RecommendIds: "[584, 585]",
+				Photos:       json.RawMessage("null"),
+			},
+			{
+				ProxyId:      2,
+				RecommendIds: "[]",
+				Photos:       json.RawMessage("null"),
+			},
+		})
+	})
+}

contrib/drivers/mysql/mysql_z_unit_model_test.go

@@ -682,6 +682,7 @@ func Test_Model_Array(t *testing.T) {
 		t.Assert(all.Array("id"), g.Slice{1, 2, 3})
 		t.Assert(all.Array("nickname"), g.Slice{"name_1", "name_2", "name_3"})
 	})
+
 	gtest.C(t, func(t *gtest.T) {
 		array, err := db.Model(table).Fields("nickname").Where("id", g.Slice{1, 2, 3}).Array()
 		t.AssertNil(err)
@@ -757,6 +758,7 @@ func Test_Model_Value_WithCache(t *testing.T) {
 		t.AssertNil(err)
 		t.Assert(value.Int(), 0)
 	})
+
 	gtest.C(t, func(t *gtest.T) {
 		result, err := db.Model(table).Data(g.MapStrAny{
 			"id":       1,
@@ -1437,6 +1439,7 @@ func Test_Model_Option_Map(t *testing.T) {
 		t.AssertNE(one["nickname"].String(), "1")
 		t.Assert(one["passport"].String(), "1")
 	})
+
 	gtest.C(t, func(t *gtest.T) {
 		table := createTable()
 		defer dropTable(table)

contrib/drivers/mysql/testdata/issues/4086.sql

@@ -0,0 +1,10 @@
+DROP TABLE IF EXISTS `issue4086`;
+CREATE TABLE `issue4086` (
+    `proxy_id` bigint NOT NULL,
+    `recommend_ids` json DEFAULT NULL,
+    `photos` json DEFAULT NULL,
+    PRIMARY KEY (`proxy_id`)
+) ENGINE=InnoDB;
+
+INSERT INTO `issue4086` (`proxy_id`, `recommend_ids`, `photos`) VALUES (1, '[584, 585]', 'null');
+INSERT INTO `issue4086` (`proxy_id`, `recommend_ids`, `photos`) VALUES (2, '[]', NULL);

contrib/drivers/pgsql/pgsql_convert.go

@@ -124,7 +124,7 @@ func (d *Driver) ConvertValueForLocal(ctx context.Context, fieldType string, fie
 
 	// String slice.
 	case "_varchar", "_text":
-		var result pq.StringArray
+		var result = make(pq.StringArray, 0)
 		if err := result.Scan(fieldValue); err != nil {
 			return nil, err
 		}

database/gdb/gdb.go

@@ -516,8 +516,9 @@ type Core struct {
 	links         *gmap.Map       // links caches all created links by node.
 	logger        glog.ILogger    // Logger for logging functionality.
 	config        *ConfigNode     // Current config node.
+	localTypeMap  *gmap.StrAnyMap // Local type map for database field type conversion.
 	dynamicConfig dynamicConfig   // Dynamic configurations, which can be changed in runtime.
-	innerMemCache *gcache.Cache
+	innerMemCache *gcache.Cache   // Internal memory cache for storing temporary data.
 }
 
 type dynamicConfig struct {
@@ -768,6 +769,8 @@ const (
 	SqlTypeStmtQueryRowContext SqlType = "DB.Statement.QueryRowContext"
 )
 
+// LocalType is a type that defines the local storage type of a field value.
+// It is used to specify how the field value should be processed locally.
 type LocalType string
 
 const (
@@ -925,6 +928,7 @@ func newDBByConfigNode(node *ConfigNode, group string) (db DB, err error) {
 		links:         gmap.New(true),
 		logger:        glog.New(),
 		config:        node,
+		localTypeMap:  gmap.NewStrAnyMap(true),
 		innerMemCache: gcache.New(),
 		dynamicConfig: dynamicConfig{
 			MaxIdleConnCount: node.MaxIdleConnCount,

database/gdb/gdb_converter.go

@@ -0,0 +1,82 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gdb
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// iVal is used for type assert api for Val().
+type iVal interface {
+	Val() any
+}
+
+var (
+	// converter is the internal type converter for gdb.
+	converter = gconv.NewConverter()
+)
+
+func init() {
+	converter.RegisterAnyConverterFunc(
+		sliceTypeConverterFunc,
+		reflect.TypeOf([]string{}),
+		reflect.TypeOf([]float32{}),
+		reflect.TypeOf([]float64{}),
+		reflect.TypeOf([]int{}),
+		reflect.TypeOf([]int32{}),
+		reflect.TypeOf([]int64{}),
+		reflect.TypeOf([]uint{}),
+		reflect.TypeOf([]uint32{}),
+		reflect.TypeOf([]uint64{}),
+	)
+}
+
+// GetConverter returns the internal type converter for gdb.
+func GetConverter() gconv.Converter {
+	return converter
+}
+
+func sliceTypeConverterFunc(from any, to reflect.Value) (err error) {
+	v, ok := from.(iVal)
+	if !ok {
+		return nil
+	}
+	fromVal := v.Val()
+	switch x := fromVal.(type) {
+	case []byte:
+		dst := to.Addr().Interface()
+		err = json.Unmarshal(x, dst)
+	case string:
+		dst := to.Addr().Interface()
+		err = json.Unmarshal([]byte(x), dst)
+	default:
+		fromType := reflect.TypeOf(fromVal)
+		switch fromType.Kind() {
+		case reflect.Slice:
+			convertOption := gconv.ConvertOption{
+				SliceOption:  gconv.SliceOption{ContinueOnError: true},
+				MapOption:    gconv.MapOption{ContinueOnError: true},
+				StructOption: gconv.StructOption{ContinueOnError: true},
+			}
+			dv, err := converter.ConvertWithTypeName(fromVal, to.Type().String(), convertOption)
+			if err != nil {
+				return err
+			}
+			to.Set(reflect.ValueOf(dv))
+		default:
+			err = gerror.Newf(
+				`unsupported type converting from type "%T" to type "%T"`,
+				fromVal, to,
+			)
+		}
+	}
+	return err
+}

database/gdb/gdb_core.go

@@ -223,6 +223,8 @@ func (c *Core) GetScan(ctx context.Context, pointer interface{}, sql string, arg
 
 	case reflect.Struct:
 		return c.db.GetCore().doGetStruct(ctx, pointer, sql, args...)
+
+	default:
 	}
 	return gerror.NewCodef(
 		gcode.CodeInvalidParameter,
@@ -735,6 +737,7 @@ func (c *Core) HasTable(name string) (bool, error) {
 	return false, nil
 }
 
+// GetInnerMemCache retrieves and returns the inner memory cache object.
 func (c *Core) GetInnerMemCache() *gcache.Cache {
 	return c.innerMemCache
 }

database/gdb/gdb_core_structure.go

@@ -223,7 +223,9 @@ Default:
 }
 
 // CheckLocalTypeForField checks and returns corresponding type for given db type.
-func (c *Core) CheckLocalTypeForField(ctx context.Context, fieldType string, fieldValue interface{}) (LocalType, error) {
+// The `fieldType` is retrieved from ColumnTypes of db driver, example:
+// UNSIGNED INT
+func (c *Core) CheckLocalTypeForField(ctx context.Context, fieldType string, _ interface{}) (LocalType, error) {
 	var (
 		typeName    string
 		typePattern string
@@ -233,7 +235,12 @@ func (c *Core) CheckLocalTypeForField(ctx context.Context, fieldType string, fie
 		typeName = gstr.Trim(match[1])
 		typePattern = gstr.Trim(match[2])
 	} else {
-		typeName = gstr.Split(fieldType, " ")[0]
+		var array = gstr.SplitAndTrim(fieldType, " ")
+		if len(array) > 1 && gstr.Equal(array[0], "unsigned") {
+			typeName = array[1]
+		} else if len(array) > 0 {
+			typeName = array[0]
+		}
 	}
 
 	typeName = strings.ToLower(typeName)
@@ -291,11 +298,6 @@ func (c *Core) CheckLocalTypeForField(ctx context.Context, fieldType string, fie
 		if typePattern == "1" {
 			return LocalTypeBool, nil
 		}
-		s := gconv.String(fieldValue)
-		// mssql is true|false string.
-		if strings.EqualFold(s, "true") || strings.EqualFold(s, "false") {
-			return LocalTypeBool, nil
-		}
 		if gstr.ContainsI(fieldType, "unsigned") {
 			return LocalTypeUint64Bytes, nil
 		}

database/gdb/gdb_core_underlying.go

@@ -478,8 +478,11 @@ func (c *Core) RowsToResult(ctx context.Context, rows *sql.Rows) (Result, error)
 				// which will cause struct converting issue.
 				record[columnTypes[i].Name()] = nil
 			} else {
-				var convertedValue interface{}
-				if convertedValue, err = c.columnValueToLocalValue(ctx, value, columnTypes[i]); err != nil {
+				var (
+					convertedValue interface{}
+					columnType     = columnTypes[i]
+				)
+				if convertedValue, err = c.columnValueToLocalValue(ctx, value, columnType); err != nil {
 					return nil, err
 				}
 				record[columnTypes[i].Name()] = gvar.New(convertedValue)
@@ -498,7 +501,9 @@ func (c *Core) OrderRandomFunction() string {
 	return "RAND()"
 }
 
-func (c *Core) columnValueToLocalValue(ctx context.Context, value interface{}, columnType *sql.ColumnType) (interface{}, error) {
+func (c *Core) columnValueToLocalValue(
+	ctx context.Context, value interface{}, columnType *sql.ColumnType,
+) (interface{}, error) {
 	var scanType = columnType.ScanType()
 	if scanType != nil {
 		// Common basic builtin types.

database/gdb/gdb_type_record.go

@@ -53,7 +53,10 @@ func (r Record) Struct(pointer interface{}) error {
 		}
 		return nil
 	}
-	return gconv.StructTag(r, pointer, OrmTagForStruct)
+	return converter.Struct(r, pointer, gconv.StructOption{
+		PriorityTag:     OrmTagForStruct,
+		ContinueOnError: true,
+	})
 }
 
 // IsEmpty checks and returns whether `r` is empty.

database/gdb/gdb_type_result.go

@@ -200,5 +200,12 @@ func (r Result) Structs(pointer interface{}) (err error) {
 		}
 		return nil
 	}
-	return gconv.StructsTag(r, pointer, OrmTagForStruct)
+	var (
+		sliceOption = gconv.SliceOption{ContinueOnError: true}
+		mapOption   = gconv.StructOption{
+			PriorityTag:     OrmTagForStruct,
+			ContinueOnError: true,
+		}
+	)
+	return converter.Structs(r, pointer, sliceOption, mapOption)
 }

database/gdb/gdb_z_mysql_internal_test.go

@@ -14,6 +14,15 @@ import (
 	"github.com/gogf/gf/v2/text/gregex"
 )
 
+func Test_GetConverter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		c := GetConverter()
+		s, err := c.String(1)
+		t.AssertNil(err)
+		t.AssertEQ(s, "1")
+	})
+}
+
 func Test_HookSelect_Regex(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (

examples

@@ -1 +1 @@
-Subproject commit 2544fee34dd10e6914687f7335bd9e772215ce07
+Subproject commit c454db2549ac7ecce844b687c1e610461818830d

net/ghttp/ghttp_z_unit_feature_config_test.go

@@ -30,15 +30,15 @@ func Test_ConfigFromMap(t *testing.T) {
 			"readTimeout":     "60s",
 			"indexFiles":      g.Slice{"index.php", "main.php"},
 			"errorLogEnabled": true,
-			"cookieMaxAge":    "1y",
+			"cookieMaxAge":    "1d",
 			"cookieSameSite":  "lax",
 			"cookieSecure":    true,
 			"cookieHttpOnly":  true,
 		}
 		config, err := ghttp.ConfigFromMap(m)
 		t.AssertNil(err)
-		d1, _ := time.ParseDuration(gconv.String(m["readTimeout"]))
-		d2, _ := time.ParseDuration(gconv.String(m["cookieMaxAge"]))
+		d1, _ := gtime.ParseDuration(gconv.String(m["readTimeout"]))
+		d2, _ := gtime.ParseDuration(gconv.String(m["cookieMaxAge"]))
 		t.Assert(config.Address, m["address"])
 		t.Assert(config.ReadTimeout, d1)
 		t.Assert(config.CookieMaxAge, d2)

net/ghttp/ghttp_z_unit_feature_router_strict_test.go

@@ -505,7 +505,6 @@ func (t *testNullStringIssue3465) Test(ctx context.Context, req *testNullStringI
 
 // https://github.com/gogf/gf/issues/3465
 func Test_NullString_Issue3465(t *testing.T) {
-
 	s := g.Server(guid.S())
 	s.Use(ghttp.MiddlewareHandlerResponse)
 	s.Group("/", func(group *ghttp.RouterGroup) {

util/gconv/gconv.go

@@ -10,36 +10,155 @@
 package gconv
 
 import (
+	"reflect"
+	"time"
+
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv/internal/converter"
 	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
 	"github.com/gogf/gf/v2/util/gconv/internal/structcache"
 )
 
-var (
-	// Empty strings.
-	emptyStringMap = map[string]struct{}{
-		"":      {},
-		"0":     {},
-		"no":    {},
-		"off":   {},
-		"false": {},
-	}
+// Converter is the manager for type converting.
+type Converter interface {
+	ConverterForConvert
+	ConverterForRegister
+	ConverterForInt
+	ConverterForUint
+	ConverterForTime
+	ConverterForFloat
+	ConverterForMap
+	ConverterForSlice
+	ConverterForStruct
+	ConverterForBasic
+}
+
+// ConverterForBasic is the basic converting interface.
+type ConverterForBasic interface {
+	Scan(srcValue, dstPointer any, option ScanOption) (err error)
+	String(any any) (string, error)
+	Bool(any any) (bool, error)
+	Rune(any any) (rune, error)
+}
+
+// ConverterForTime is the converting interface for time.
+type ConverterForTime interface {
+	Time(v any, format ...string) (time.Time, error)
+	Duration(v any) (time.Duration, error)
+	GTime(v any, format ...string) (*gtime.Time, error)
+}
+
+// ConverterForInt is the converting interface for integer.
+type ConverterForInt interface {
+	Int(v any) (int, error)
+	Int8(v any) (int8, error)
+	Int16(v any) (int16, error)
+	Int32(v any) (int32, error)
+	Int64(v any) (int64, error)
+}
+
+// ConverterForUint is the converting interface for unsigned integer.
+type ConverterForUint interface {
+	Uint(v any) (uint, error)
+	Uint8(v any) (uint8, error)
+	Uint16(v any) (uint16, error)
+	Uint32(v any) (uint32, error)
+	Uint64(v any) (uint64, error)
+}
+
+// ConverterForFloat is the converting interface for float.
+type ConverterForFloat interface {
+	Float32(v any) (float32, error)
+	Float64(v any) (float64, error)
+}
+
+// ConverterForMap is the converting interface for map.
+type ConverterForMap interface {
+	Map(v any, option MapOption) (map[string]any, error)
+	MapStrStr(v any, option MapOption) (map[string]string, error)
+}
+
+// ConverterForSlice is the converting interface for slice.
+type ConverterForSlice interface {
+	Bytes(v any) ([]byte, error)
+	Runes(v any) ([]rune, error)
+	SliceAny(v any, option SliceOption) ([]any, error)
+	SliceFloat32(v any, option SliceOption) ([]float32, error)
+	SliceFloat64(v any, option SliceOption) ([]float64, error)
+	SliceInt(v any, option SliceOption) ([]int, error)
+	SliceInt32(v any, option SliceOption) ([]int32, error)
+	SliceInt64(v any, option SliceOption) ([]int64, error)
+	SliceUint(v any, option SliceOption) ([]uint, error)
+	SliceUint32(v any, option SliceOption) ([]uint32, error)
+	SliceUint64(v any, option SliceOption) ([]uint64, error)
+	SliceStr(v any, option SliceOption) ([]string, error)
+	SliceMap(v any, sliceOption SliceOption, mapOption MapOption) ([]map[string]any, error)
+}
+
+// ConverterForStruct is the converting interface for struct.
+type ConverterForStruct interface {
+	Struct(params, pointer any, option StructOption) (err error)
+	Structs(params, pointer any, sliceOption SliceOption, structOption StructOption) (err error)
+}
+
+// ConverterForConvert is the converting interface for custom converting.
+type ConverterForConvert interface {
+	ConvertWithRefer(fromValue, referValue any, option ConvertOption) (any, error)
+	ConvertWithTypeName(fromValue any, toTypeName string, option ConvertOption) (any, error)
+}
+
+// ConverterForRegister is the converting interface for custom converter registration.
+type ConverterForRegister interface {
+	RegisterTypeConverterFunc(f any) error
+	RegisterAnyConverterFunc(f AnyConvertFunc, types ...reflect.Type)
+}
+
+type (
+	// AnyConvertFunc is the function type for converting any to specified type.
+	AnyConvertFunc = structcache.AnyConvertFunc
+
+	// MapOption specifies the option for map converting.
+	MapOption = converter.MapOption
+
+	// SliceOption is the option for Slice type converting.
+	SliceOption = converter.SliceOption
+
+	// ScanOption is the option for the Scan function.
+	ScanOption = converter.ScanOption
+
+	// StructOption is the option for Struct converting.
+	StructOption = converter.StructOption
+
+	// ConvertOption is the option for converting.
+	ConvertOption = converter.ConvertOption
 )
 
 // IUnmarshalValue is the interface for custom defined types customizing value assignment.
 // Note that only pointer can implement interface IUnmarshalValue.
 type IUnmarshalValue = localinterface.IUnmarshalValue
 
-func init() {
-	// register common converters for internal usage.
-	structcache.RegisterCommonConverter(structcache.CommonConverter{
-		Int64:   Int64,
-		Uint64:  Uint64,
-		String:  String,
-		Float32: Float32,
-		Float64: Float64,
-		Time:    Time,
-		GTime:   GTime,
-		Bytes:   Bytes,
-		Bool:    Bool,
-	})
+var (
+	// defaultConverter is the default management object converting.
+	defaultConverter = converter.NewConverter()
+)
+
+// RegisterAnyConverterFunc registers custom type converting function for specified type.
+func RegisterAnyConverterFunc(f AnyConvertFunc, types ...reflect.Type) {
+	defaultConverter.RegisterAnyConverterFunc(f, types...)
+}
+
+// NewConverter creates and returns management object for type converting.
+func NewConverter() Converter {
+	return converter.NewConverter()
+}
+
+// RegisterConverter registers custom converter.
+// Deprecated: use RegisterTypeConverterFunc instead for clear
+func RegisterConverter(fn any) (err error) {
+	return RegisterTypeConverterFunc(fn)
+}
+
+// RegisterTypeConverterFunc registers custom converter.
+func RegisterTypeConverterFunc(fn any) (err error) {
+	return defaultConverter.RegisterTypeConverterFunc(fn)
 }

util/gconv/gconv_basic.go

@@ -6,331 +6,40 @@
 
 package gconv
 
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/gogf/gf/v2/encoding/gbinary"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/os/gtime"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // Byte converts `any` to byte.
 func Byte(any any) byte {
-	v, _ := doByte(any)
+	v, _ := defaultConverter.Uint8(any)
 	return v
 }
 
-func doByte(any any) (byte, error) {
-	if v, ok := any.(byte); ok {
-		return v, nil
-	}
-	return doUint8(any)
-}
-
 // Bytes converts `any` to []byte.
 func Bytes(any any) []byte {
-	v, _ := doBytes(any)
+	v, _ := defaultConverter.Bytes(any)
 	return v
 }
 
-func doBytes(any any) ([]byte, error) {
-	if any == nil {
-		return nil, nil
-	}
-	switch value := any.(type) {
-	case string:
-		return []byte(value), nil
-
-	case []byte:
-		return value, nil
-
-	default:
-		if f, ok := value.(localinterface.IBytes); ok {
-			return f.Bytes(), nil
-		}
-		originValueAndKind := reflection.OriginValueAndKind(any)
-		switch originValueAndKind.OriginKind {
-		case reflect.Map:
-			bytes, err := json.Marshal(any)
-			if err != nil {
-				return nil, err
-			}
-			return bytes, nil
-
-		case reflect.Array, reflect.Slice:
-			var (
-				ok    = true
-				bytes = make([]byte, originValueAndKind.OriginValue.Len())
-			)
-			for i := range bytes {
-				int32Value, err := doInt32(originValueAndKind.OriginValue.Index(i).Interface())
-				if err != nil {
-					return nil, err
-				}
-				if int32Value < 0 || int32Value > math.MaxUint8 {
-					ok = false
-					break
-				}
-				bytes[i] = byte(int32Value)
-			}
-			if ok {
-				return bytes, nil
-			}
-		default:
-		}
-		return gbinary.Encode(any), nil
-	}
-}
-
 // Rune converts `any` to rune.
 func Rune(any any) rune {
-	v, _ := doRune(any)
+	v, _ := defaultConverter.Rune(any)
 	return v
 }
 
-func doRune(any any) (rune, error) {
-	if v, ok := any.(rune); ok {
-		return v, nil
-	}
-	v, err := doInt32(any)
-	if err != nil {
-		return 0, err
-	}
-	return v, nil
-}
-
 // Runes converts `any` to []rune.
 func Runes(any any) []rune {
-	v, _ := doRunes(any)
+	v, _ := defaultConverter.Runes(any)
 	return v
 }
 
-func doRunes(any any) ([]rune, error) {
-	if v, ok := any.([]rune); ok {
-		return v, nil
-	}
-	s, err := doString(any)
-	if err != nil {
-		return nil, err
-	}
-	return []rune(s), nil
-}
-
 // String converts `any` to string.
 // It's most commonly used converting function.
 func String(any any) string {
-	v, _ := doString(any)
+	v, _ := defaultConverter.String(any)
 	return v
 }
 
-func doString(any any) (string, error) {
-	if any == nil {
-		return "", nil
-	}
-	switch value := any.(type) {
-	case int:
-		return strconv.Itoa(value), nil
-	case int8:
-		return strconv.Itoa(int(value)), nil
-	case int16:
-		return strconv.Itoa(int(value)), nil
-	case int32:
-		return strconv.Itoa(int(value)), nil
-	case int64:
-		return strconv.FormatInt(value, 10), nil
-	case uint:
-		return strconv.FormatUint(uint64(value), 10), nil
-	case uint8:
-		return strconv.FormatUint(uint64(value), 10), nil
-	case uint16:
-		return strconv.FormatUint(uint64(value), 10), nil
-	case uint32:
-		return strconv.FormatUint(uint64(value), 10), nil
-	case uint64:
-		return strconv.FormatUint(value, 10), nil
-	case float32:
-		return strconv.FormatFloat(float64(value), 'f', -1, 32), nil
-	case float64:
-		return strconv.FormatFloat(value, 'f', -1, 64), nil
-	case bool:
-		return strconv.FormatBool(value), nil
-	case string:
-		return value, nil
-	case []byte:
-		return string(value), nil
-	case complex64, complex128:
-		return fmt.Sprintf("%v", value), nil
-	case time.Time:
-		if value.IsZero() {
-			return "", nil
-		}
-		return value.String(), nil
-	case *time.Time:
-		if value == nil {
-			return "", nil
-		}
-		return value.String(), nil
-	case gtime.Time:
-		if value.IsZero() {
-			return "", nil
-		}
-		return value.String(), nil
-	case *gtime.Time:
-		if value == nil {
-			return "", nil
-		}
-		return value.String(), nil
-	default:
-		if f, ok := value.(localinterface.IString); ok {
-			// If the variable implements the String() interface,
-			// then use that interface to perform the conversion
-			return f.String(), nil
-		}
-		if f, ok := value.(localinterface.IError); ok {
-			// If the variable implements the Error() interface,
-			// then use that interface to perform the conversion
-			return f.Error(), nil
-		}
-		// Reflect checks.
-		var (
-			rv   = reflect.ValueOf(value)
-			kind = rv.Kind()
-		)
-		switch kind {
-		case
-			reflect.Chan,
-			reflect.Map,
-			reflect.Slice,
-			reflect.Func,
-			reflect.Interface,
-			reflect.UnsafePointer:
-			if rv.IsNil() {
-				return "", nil
-			}
-		case reflect.String:
-			return rv.String(), nil
-		case reflect.Ptr:
-			if rv.IsNil() {
-				return "", nil
-			}
-			return doString(rv.Elem().Interface())
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return strconv.FormatInt(rv.Int(), 10), nil
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return strconv.FormatUint(rv.Uint(), 10), nil
-		case reflect.Uintptr:
-			return strconv.FormatUint(rv.Uint(), 10), nil
-		case reflect.Float32, reflect.Float64:
-			return strconv.FormatFloat(rv.Float(), 'f', -1, 64), nil
-		case reflect.Bool:
-			return strconv.FormatBool(rv.Bool()), nil
-		default:
-		}
-		// Finally, we use json.Marshal to convert.
-		jsonContent, err := json.Marshal(value)
-		if err != nil {
-			return fmt.Sprint(value), gerror.WrapCodef(
-				gcode.CodeInvalidParameter, err, "error marshaling value to JSON for: %v", value,
-			)
-		}
-		return string(jsonContent), nil
-	}
-}
-
 // Bool converts `any` to bool.
 // It returns false if `any` is: false, "", 0, "false", "off", "no", empty slice/map.
 func Bool(any any) bool {
-	v, _ := doBool(any)
+	v, _ := defaultConverter.Bool(any)
 	return v
 }
-
-func doBool(any any) (bool, error) {
-	if any == nil {
-		return false, nil
-	}
-	switch value := any.(type) {
-	case bool:
-		return value, nil
-	case []byte:
-		if _, ok := emptyStringMap[strings.ToLower(string(value))]; ok {
-			return false, nil
-		}
-		return true, nil
-	case string:
-		if _, ok := emptyStringMap[strings.ToLower(value)]; ok {
-			return false, nil
-		}
-		return true, nil
-	default:
-		if f, ok := value.(localinterface.IBool); ok {
-			return f.Bool(), nil
-		}
-		rv := reflect.ValueOf(any)
-		switch rv.Kind() {
-		case reflect.Ptr:
-			if rv.IsNil() {
-				return false, nil
-			}
-			if rv.Type().Elem().Kind() == reflect.Bool {
-				return rv.Elem().Bool(), nil
-			}
-			return doBool(rv.Elem().Interface())
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return rv.Int() != 0, nil
-		case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return rv.Uint() != 0, nil
-		case reflect.Float32, reflect.Float64:
-			return rv.Float() != 0, nil
-		case reflect.Bool:
-			return rv.Bool(), nil
-		// TODO：(Map，Array，Slice，Struct) It might panic here for these types.
-		case reflect.Map, reflect.Array:
-			fallthrough
-		case reflect.Slice:
-			return rv.Len() != 0, nil
-		case reflect.Struct:
-			return true, nil
-		default:
-			s, err := doString(any)
-			if err != nil {
-				return false, err
-			}
-			if _, ok := emptyStringMap[strings.ToLower(s)]; ok {
-				return false, nil
-			}
-			return true, nil
-		}
-	}
-}
-
-// checkJsonAndUnmarshalUseNumber checks if given `any` is JSON formatted string value and does converting using `json.UnmarshalUseNumber`.
-func checkJsonAndUnmarshalUseNumber(any any, target any) bool {
-	switch r := any.(type) {
-	case []byte:
-		if json.Valid(r) {
-			if err := json.UnmarshalUseNumber(r, &target); err != nil {
-				return false
-			}
-			return true
-		}
-
-	case string:
-		anyAsBytes := []byte(r)
-		if json.Valid(anyAsBytes) {
-			if err := json.UnmarshalUseNumber(anyAsBytes, &target); err != nil {
-				return false
-			}
-			return true
-		}
-	}
-	return false
-}

util/gconv/gconv_convert.go

@@ -6,353 +6,30 @@
 
 package gconv
 
-import (
-	"context"
-	"reflect"
-	"time"
-
-	"github.com/gogf/gf/v2/internal/intlog"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/os/gtime"
-)
-
 // Convert converts the variable `fromValue` to the type `toTypeName`, the type `toTypeName` is specified by string.
 //
 // The optional parameter `extraParams` is used for additional necessary parameter for this conversion.
 // It supports common basic types conversion as its conversion based on type name string.
-func Convert(fromValue interface{}, toTypeName string, extraParams ...interface{}) interface{} {
-	return doConvert(doConvertInput{
-		FromValue:  fromValue,
-		ToTypeName: toTypeName,
-		ReferValue: nil,
-		Extra:      extraParams,
+func Convert(fromValue any, toTypeName string, extraParams ...any) any {
+	result, _ := defaultConverter.ConvertWithTypeName(fromValue, toTypeName, ConvertOption{
+		ExtraParams:  extraParams,
+		SliceOption:  SliceOption{ContinueOnError: true},
+		MapOption:    MapOption{ContinueOnError: true},
+		StructOption: StructOption{ContinueOnError: true},
 	})
+	return result
 }
 
 // ConvertWithRefer converts the variable `fromValue` to the type referred by value `referValue`.
 //
 // The optional parameter `extraParams` is used for additional necessary parameter for this conversion.
 // It supports common basic types conversion as its conversion based on type name string.
-func ConvertWithRefer(fromValue interface{}, referValue interface{}, extraParams ...interface{}) interface{} {
-	var referValueRf reflect.Value
-	if v, ok := referValue.(reflect.Value); ok {
-		referValueRf = v
-	} else {
-		referValueRf = reflect.ValueOf(referValue)
-	}
-	return doConvert(doConvertInput{
-		FromValue:  fromValue,
-		ToTypeName: referValueRf.Type().String(),
-		ReferValue: referValue,
-		Extra:      extraParams,
+func ConvertWithRefer(fromValue any, referValue any, extraParams ...any) any {
+	result, _ := defaultConverter.ConvertWithRefer(fromValue, referValue, ConvertOption{
+		ExtraParams:  extraParams,
+		SliceOption:  SliceOption{ContinueOnError: true},
+		MapOption:    MapOption{ContinueOnError: true},
+		StructOption: StructOption{ContinueOnError: true},
 	})
-}
-
-type doConvertInput struct {
-	FromValue  interface{}   // Value that is converted from.
-	ToTypeName string        // Target value type name in string.
-	ReferValue interface{}   // Referred value, a value in type `ToTypeName`. Note that its type might be reflect.Value.
-	Extra      []interface{} // Extra values for implementing the converting.
-	// Marks that the value is already converted and set to `ReferValue`. Caller can ignore the returned result.
-	// It is an attribute for internal usage purpose.
-	alreadySetToReferValue bool
-}
-
-// doConvert does commonly use types converting.
-func doConvert(in doConvertInput) (convertedValue interface{}) {
-	switch in.ToTypeName {
-	case "int":
-		return Int(in.FromValue)
-	case "*int":
-		if _, ok := in.FromValue.(*int); ok {
-			return in.FromValue
-		}
-		v := Int(in.FromValue)
-		return &v
-
-	case "int8":
-		return Int8(in.FromValue)
-	case "*int8":
-		if _, ok := in.FromValue.(*int8); ok {
-			return in.FromValue
-		}
-		v := Int8(in.FromValue)
-		return &v
-
-	case "int16":
-		return Int16(in.FromValue)
-	case "*int16":
-		if _, ok := in.FromValue.(*int16); ok {
-			return in.FromValue
-		}
-		v := Int16(in.FromValue)
-		return &v
-
-	case "int32":
-		return Int32(in.FromValue)
-	case "*int32":
-		if _, ok := in.FromValue.(*int32); ok {
-			return in.FromValue
-		}
-		v := Int32(in.FromValue)
-		return &v
-
-	case "int64":
-		return Int64(in.FromValue)
-	case "*int64":
-		if _, ok := in.FromValue.(*int64); ok {
-			return in.FromValue
-		}
-		v := Int64(in.FromValue)
-		return &v
-
-	case "uint":
-		return Uint(in.FromValue)
-	case "*uint":
-		if _, ok := in.FromValue.(*uint); ok {
-			return in.FromValue
-		}
-		v := Uint(in.FromValue)
-		return &v
-
-	case "uint8":
-		return Uint8(in.FromValue)
-	case "*uint8":
-		if _, ok := in.FromValue.(*uint8); ok {
-			return in.FromValue
-		}
-		v := Uint8(in.FromValue)
-		return &v
-
-	case "uint16":
-		return Uint16(in.FromValue)
-	case "*uint16":
-		if _, ok := in.FromValue.(*uint16); ok {
-			return in.FromValue
-		}
-		v := Uint16(in.FromValue)
-		return &v
-
-	case "uint32":
-		return Uint32(in.FromValue)
-	case "*uint32":
-		if _, ok := in.FromValue.(*uint32); ok {
-			return in.FromValue
-		}
-		v := Uint32(in.FromValue)
-		return &v
-
-	case "uint64":
-		return Uint64(in.FromValue)
-	case "*uint64":
-		if _, ok := in.FromValue.(*uint64); ok {
-			return in.FromValue
-		}
-		v := Uint64(in.FromValue)
-		return &v
-
-	case "float32":
-		return Float32(in.FromValue)
-	case "*float32":
-		if _, ok := in.FromValue.(*float32); ok {
-			return in.FromValue
-		}
-		v := Float32(in.FromValue)
-		return &v
-
-	case "float64":
-		return Float64(in.FromValue)
-	case "*float64":
-		if _, ok := in.FromValue.(*float64); ok {
-			return in.FromValue
-		}
-		v := Float64(in.FromValue)
-		return &v
-
-	case "bool":
-		return Bool(in.FromValue)
-	case "*bool":
-		if _, ok := in.FromValue.(*bool); ok {
-			return in.FromValue
-		}
-		v := Bool(in.FromValue)
-		return &v
-
-	case "string":
-		return String(in.FromValue)
-	case "*string":
-		if _, ok := in.FromValue.(*string); ok {
-			return in.FromValue
-		}
-		v := String(in.FromValue)
-		return &v
-
-	case "[]byte":
-		return Bytes(in.FromValue)
-	case "[]int":
-		return Ints(in.FromValue)
-	case "[]int32":
-		return Int32s(in.FromValue)
-	case "[]int64":
-		return Int64s(in.FromValue)
-	case "[]uint":
-		return Uints(in.FromValue)
-	case "[]uint8":
-		return Bytes(in.FromValue)
-	case "[]uint32":
-		return Uint32s(in.FromValue)
-	case "[]uint64":
-		return Uint64s(in.FromValue)
-	case "[]float32":
-		return Float32s(in.FromValue)
-	case "[]float64":
-		return Float64s(in.FromValue)
-	case "[]string":
-		return Strings(in.FromValue)
-
-	case "Time", "time.Time":
-		if len(in.Extra) > 0 {
-			return Time(in.FromValue, String(in.Extra[0]))
-		}
-		return Time(in.FromValue)
-	case "*time.Time":
-		var v time.Time
-		if len(in.Extra) > 0 {
-			v = Time(in.FromValue, String(in.Extra[0]))
-		} else {
-			if _, ok := in.FromValue.(*time.Time); ok {
-				return in.FromValue
-			}
-			v = Time(in.FromValue)
-		}
-		return &v
-
-	case "GTime", "gtime.Time":
-		if len(in.Extra) > 0 {
-			if v := GTime(in.FromValue, String(in.Extra[0])); v != nil {
-				return *v
-			} else {
-				return *gtime.New()
-			}
-		}
-		if v := GTime(in.FromValue); v != nil {
-			return *v
-		} else {
-			return *gtime.New()
-		}
-	case "*gtime.Time":
-		if len(in.Extra) > 0 {
-			if v := GTime(in.FromValue, String(in.Extra[0])); v != nil {
-				return v
-			} else {
-				return gtime.New()
-			}
-		}
-		if v := GTime(in.FromValue); v != nil {
-			return v
-		} else {
-			return gtime.New()
-		}
-
-	case "Duration", "time.Duration":
-		return Duration(in.FromValue)
-	case "*time.Duration":
-		if _, ok := in.FromValue.(*time.Duration); ok {
-			return in.FromValue
-		}
-		v := Duration(in.FromValue)
-		return &v
-
-	case "map[string]string":
-		return MapStrStr(in.FromValue)
-
-	case "map[string]interface {}":
-		return Map(in.FromValue)
-
-	case "[]map[string]interface {}":
-		return Maps(in.FromValue)
-
-	case "RawMessage", "json.RawMessage":
-		// issue 3449
-		bytes, err := json.Marshal(in.FromValue)
-		if err != nil {
-			intlog.Errorf(context.TODO(), `%+v`, err)
-		}
-		return bytes
-
-	default:
-		if in.ReferValue != nil {
-			var referReflectValue reflect.Value
-			if v, ok := in.ReferValue.(reflect.Value); ok {
-				referReflectValue = v
-			} else {
-				referReflectValue = reflect.ValueOf(in.ReferValue)
-			}
-			var fromReflectValue reflect.Value
-			if v, ok := in.FromValue.(reflect.Value); ok {
-				fromReflectValue = v
-			} else {
-				fromReflectValue = reflect.ValueOf(in.FromValue)
-			}
-
-			// custom converter.
-			if dstReflectValue, ok, _ := callCustomConverterWithRefer(fromReflectValue, referReflectValue); ok {
-				return dstReflectValue.Interface()
-			}
-
-			defer func() {
-				if recover() != nil {
-					in.alreadySetToReferValue = false
-					if err := bindVarToReflectValue(referReflectValue, in.FromValue, nil); err == nil {
-						in.alreadySetToReferValue = true
-						convertedValue = referReflectValue.Interface()
-					}
-				}
-			}()
-			switch referReflectValue.Kind() {
-			case reflect.Ptr:
-				// Type converting for custom type pointers.
-				// Eg:
-				// type PayMode int
-				// type Req struct{
-				//     Mode *PayMode
-				// }
-				//
-				// Struct(`{"Mode": 1000}`, &req)
-				originType := referReflectValue.Type().Elem()
-				switch originType.Kind() {
-				case reflect.Struct:
-					// Not support some kinds.
-				default:
-					in.ToTypeName = originType.Kind().String()
-					in.ReferValue = nil
-					refElementValue := reflect.ValueOf(doConvert(in))
-					originTypeValue := reflect.New(refElementValue.Type()).Elem()
-					originTypeValue.Set(refElementValue)
-					in.alreadySetToReferValue = true
-					return originTypeValue.Addr().Convert(referReflectValue.Type()).Interface()
-				}
-
-			case reflect.Map:
-				var targetValue = reflect.New(referReflectValue.Type()).Elem()
-				if err := doMapToMap(in.FromValue, targetValue); err == nil {
-					in.alreadySetToReferValue = true
-				}
-				return targetValue.Interface()
-			}
-			in.ToTypeName = referReflectValue.Kind().String()
-			in.ReferValue = nil
-			in.alreadySetToReferValue = true
-			convertedValue = reflect.ValueOf(doConvert(in)).Convert(referReflectValue.Type()).Interface()
-			return convertedValue
-		}
-		return in.FromValue
-	}
-}
-
-func doConvertWithReflectValueSet(reflectValue reflect.Value, in doConvertInput) {
-	convertedValue := doConvert(in)
-	if !in.alreadySetToReferValue {
-		reflectValue.Set(reflect.ValueOf(convertedValue))
-	}
+	return result
 }

util/gconv/gconv_converter.go

@@ -1,187 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package gconv
-
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/util/gconv/internal/structcache"
-)
-
-type (
-	converterInType  = reflect.Type
-	converterOutType = reflect.Type
-	converterFunc    = reflect.Value
-)
-
-// customConverters for internal converter storing.
-var customConverters = make(map[converterInType]map[converterOutType]converterFunc)
-
-// RegisterConverter to register custom converter.
-// It must be registered before you use this custom converting feature.
-// It is suggested to do it in boot procedure of the process.
-//
-// Note:
-//  1. The parameter `fn` must be defined as pattern `func(T1) (T2, error)`.
-//     It will convert type `T1` to type `T2`.
-//  2. The `T1` should not be type of pointer, but the `T2` should be type of pointer.
-func RegisterConverter(fn interface{}) (err error) {
-	var (
-		fnReflectType = reflect.TypeOf(fn)
-		errType       = reflect.TypeOf((*error)(nil)).Elem()
-	)
-	if fnReflectType.Kind() != reflect.Func ||
-		fnReflectType.NumIn() != 1 || fnReflectType.NumOut() != 2 ||
-		!fnReflectType.Out(1).Implements(errType) {
-		err = gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"parameter must be type of converter function and defined as pattern `func(T1) (T2, error)`, but defined as `%s`",
-			fnReflectType.String(),
-		)
-		return
-	}
-
-	// The Key and Value of the converter map should not be pointer.
-	var (
-		inType  = fnReflectType.In(0)
-		outType = fnReflectType.Out(0)
-	)
-	if inType.Kind() == reflect.Pointer {
-		err = gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"invalid converter function `%s`: invalid input parameter type `%s`, should not be type of pointer",
-			fnReflectType.String(), inType.String(),
-		)
-		return
-	}
-	if outType.Kind() != reflect.Pointer {
-		err = gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"invalid converter function `%s`: invalid output parameter type `%s` should be type of pointer",
-			fnReflectType.String(), outType.String(),
-		)
-		return
-	}
-
-	registeredOutTypeMap, ok := customConverters[inType]
-	if !ok {
-		registeredOutTypeMap = make(map[converterOutType]converterFunc)
-		customConverters[inType] = registeredOutTypeMap
-	}
-	if _, ok = registeredOutTypeMap[outType]; ok {
-		err = gerror.NewCodef(
-			gcode.CodeInvalidOperation,
-			"the converter parameter type `%s` to type `%s` has already been registered",
-			inType.String(), outType.String(),
-		)
-		return
-	}
-	registeredOutTypeMap[outType] = reflect.ValueOf(fn)
-	structcache.RegisterCustomConvertType(outType)
-	return
-}
-
-func getRegisteredConverterFuncAndSrcType(
-	srcReflectValue, dstReflectValueForRefer reflect.Value,
-) (f converterFunc, srcType reflect.Type, ok bool) {
-	if len(customConverters) == 0 {
-		return reflect.Value{}, nil, false
-	}
-	srcType = srcReflectValue.Type()
-	for srcType.Kind() == reflect.Pointer {
-		srcType = srcType.Elem()
-	}
-	var registeredOutTypeMap map[converterOutType]converterFunc
-	// firstly, it searches the map by input parameter type.
-	registeredOutTypeMap, ok = customConverters[srcType]
-	if !ok {
-		return reflect.Value{}, nil, false
-	}
-	var dstType = dstReflectValueForRefer.Type()
-	if dstType.Kind() == reflect.Pointer {
-		// Might be **struct, which is support as designed.
-		if dstType.Elem().Kind() == reflect.Pointer {
-			dstType = dstType.Elem()
-		}
-	} else if dstReflectValueForRefer.IsValid() && dstReflectValueForRefer.CanAddr() {
-		dstType = dstReflectValueForRefer.Addr().Type()
-	} else {
-		dstType = reflect.PointerTo(dstType)
-	}
-	// secondly, it searches the input parameter type map
-	// and finds the result converter function by the output parameter type.
-	f, ok = registeredOutTypeMap[dstType]
-	if !ok {
-		return reflect.Value{}, nil, false
-	}
-	return
-}
-
-func callCustomConverterWithRefer(
-	srcReflectValue, referReflectValue reflect.Value,
-) (dstReflectValue reflect.Value, converted bool, err error) {
-	registeredConverterFunc, srcType, ok := getRegisteredConverterFuncAndSrcType(srcReflectValue, referReflectValue)
-	if !ok {
-		return reflect.Value{}, false, nil
-	}
-	dstReflectValue = reflect.New(referReflectValue.Type()).Elem()
-	converted, err = doCallCustomConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
-	return
-}
-
-// callCustomConverter call the custom converter. It will try some possible type.
-func callCustomConverter(srcReflectValue, dstReflectValue reflect.Value) (converted bool, err error) {
-	registeredConverterFunc, srcType, ok := getRegisteredConverterFuncAndSrcType(srcReflectValue, dstReflectValue)
-	if !ok {
-		return false, nil
-	}
-	return doCallCustomConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
-}
-
-func doCallCustomConverter(
-	srcReflectValue reflect.Value,
-	dstReflectValue reflect.Value,
-	registeredConverterFunc converterFunc,
-	srcType reflect.Type,
-) (converted bool, err error) {
-	// Converter function calling.
-	for srcReflectValue.Type() != srcType {
-		srcReflectValue = srcReflectValue.Elem()
-	}
-	result := registeredConverterFunc.Call([]reflect.Value{srcReflectValue})
-	if !result[1].IsNil() {
-		return false, result[1].Interface().(error)
-	}
-	// The `result[0]` is a pointer.
-	if result[0].IsNil() {
-		return false, nil
-	}
-	var resultValue = result[0]
-	for {
-		if resultValue.Type() == dstReflectValue.Type() && dstReflectValue.CanSet() {
-			dstReflectValue.Set(resultValue)
-			converted = true
-		} else if dstReflectValue.Kind() == reflect.Pointer {
-			if resultValue.Type() == dstReflectValue.Elem().Type() && dstReflectValue.Elem().CanSet() {
-				dstReflectValue.Elem().Set(resultValue)
-				converted = true
-			}
-		}
-		if converted {
-			break
-		}
-		if resultValue.Kind() == reflect.Pointer {
-			resultValue = resultValue.Elem()
-		} else {
-			break
-		}
-	}
-
-	return converted, nil
-}

util/gconv/gconv_float.go

@@ -6,143 +6,14 @@
 
 package gconv
 
-import (
-	"reflect"
-	"strconv"
-
-	"github.com/gogf/gf/v2/encoding/gbinary"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // Float32 converts `any` to float32.
 func Float32(any any) float32 {
-	v, _ := doFloat32(any)
+	v, _ := defaultConverter.Float32(any)
 	return v
 }
 
-func doFloat32(any any) (float32, error) {
-	if any == nil {
-		return 0, nil
-	}
-	switch value := any.(type) {
-	case float32:
-		return value, nil
-	case float64:
-		return float32(value), nil
-	case []byte:
-		// TODO: It might panic here for these types.
-		return gbinary.DecodeToFloat32(value), nil
-	default:
-		rv := reflect.ValueOf(any)
-		switch rv.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return float32(rv.Int()), nil
-		case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return float32(rv.Uint()), nil
-		case reflect.Float32, reflect.Float64:
-			return float32(rv.Float()), nil
-		case reflect.Bool:
-			if rv.Bool() {
-				return 1, nil
-			}
-			return 0, nil
-		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 32)
-			if err != nil {
-				return 0, gerror.WrapCodef(
-					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
-				)
-			}
-			return float32(f), nil
-		case reflect.Ptr:
-			if rv.IsNil() {
-				return 0, nil
-			}
-			if f, ok := value.(localinterface.IFloat32); ok {
-				return f.Float32(), nil
-			}
-			return doFloat32(rv.Elem().Interface())
-		default:
-			if f, ok := value.(localinterface.IFloat32); ok {
-				return f.Float32(), nil
-			}
-			v, err := strconv.ParseFloat(String(any), 32)
-			if err != nil {
-				return 0, gerror.WrapCodef(
-					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
-				)
-			}
-			return float32(v), nil
-		}
-	}
-}
-
 // Float64 converts `any` to float64.
 func Float64(any any) float64 {
-	v, _ := doFloat64(any)
+	v, _ := defaultConverter.Float64(any)
 	return v
 }
-
-func doFloat64(any any) (float64, error) {
-	if any == nil {
-		return 0, nil
-	}
-	switch value := any.(type) {
-	case float32:
-		return float64(value), nil
-	case float64:
-		return value, nil
-	case []byte:
-		// TODO: It might panic here for these types.
-		return gbinary.DecodeToFloat64(value), nil
-	default:
-		rv := reflect.ValueOf(any)
-		switch rv.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			return float64(rv.Int()), nil
-		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-			return float64(rv.Uint()), nil
-		case reflect.Uintptr:
-			return float64(rv.Uint()), nil
-		case reflect.Float32, reflect.Float64:
-			// Please Note:
-			// When the type is float32 or a custom type defined based on float32,
-			// switching to float64 may result in a few extra decimal places.
-			return rv.Float(), nil
-		case reflect.Bool:
-			if rv.Bool() {
-				return 1, nil
-			}
-			return 0, nil
-		case reflect.String:
-			f, err := strconv.ParseFloat(rv.String(), 64)
-			if err != nil {
-				return 0, gerror.WrapCodef(
-					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
-				)
-			}
-			return f, nil
-		case reflect.Ptr:
-			if rv.IsNil() {
-				return 0, nil
-			}
-			if f, ok := value.(localinterface.IFloat64); ok {
-				return f.Float64(), nil
-			}
-			return doFloat64(rv.Elem().Interface())
-		default:
-			if f, ok := value.(localinterface.IFloat64); ok {
-				return f.Float64(), nil
-			}
-			v, err := strconv.ParseFloat(String(any), 64)
-			if err != nil {
-				return 0, gerror.WrapCodef(
-					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
-				)
-			}
-			return v, nil
-		}
-	}
-}

util/gconv/gconv_int.go

@@ -6,176 +6,32 @@
 
 package gconv
 
-import (
-	"math"
-	"reflect"
-	"strconv"
-
-	"github.com/gogf/gf/v2/encoding/gbinary"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // Int converts `any` to int.
 func Int(any any) int {
-	v, _ := doInt(any)
+	v, _ := defaultConverter.Int(any)
 	return v
 }
 
-func doInt(any any) (int, error) {
-	if v, ok := any.(int); ok {
-		return v, nil
-	}
-	v, err := doInt64(any)
-	if err != nil {
-		return 0, err
-	}
-	return int(v), nil
-}
-
 // Int8 converts `any` to int8.
 func Int8(any any) int8 {
-	v, _ := doInt8(any)
+	v, _ := defaultConverter.Int8(any)
 	return v
 }
 
-func doInt8(any any) (int8, error) {
-	if v, ok := any.(int8); ok {
-		return v, nil
-	}
-	v, err := doInt64(any)
-	if err != nil {
-		return 0, err
-	}
-	return int8(v), nil
-}
-
 // Int16 converts `any` to int16.
 func Int16(any any) int16 {
-	v, _ := doInt16(any)
+	v, _ := defaultConverter.Int16(any)
 	return v
 }
 
-func doInt16(any any) (int16, error) {
-	if v, ok := any.(int16); ok {
-		return v, nil
-	}
-	v, err := doInt64(any)
-	if err != nil {
-		return 0, err
-	}
-	return int16(v), nil
-}
-
 // Int32 converts `any` to int32.
 func Int32(any any) int32 {
-	v, _ := doInt32(any)
+	v, _ := defaultConverter.Int32(any)
 	return v
 }
 
-func doInt32(any any) (int32, error) {
-	if v, ok := any.(int32); ok {
-		return v, nil
-	}
-	v, err := doInt64(any)
-	if err != nil {
-		return 0, err
-	}
-	return int32(v), nil
-}
-
 // Int64 converts `any` to int64.
 func Int64(any any) int64 {
-	v, _ := doInt64(any)
+	v, _ := defaultConverter.Int64(any)
 	return v
 }
-
-func doInt64(any any) (int64, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(int64); ok {
-		return v, nil
-	}
-	rv := reflect.ValueOf(any)
-	switch rv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return rv.Int(), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return int64(rv.Uint()), nil
-	case reflect.Uintptr:
-		return int64(rv.Uint()), nil
-	case reflect.Float32, reflect.Float64:
-		return int64(rv.Float()), nil
-	case reflect.Bool:
-		if rv.Bool() {
-			return 1, nil
-		}
-		return 0, nil
-	case reflect.Ptr:
-		if rv.IsNil() {
-			return 0, nil
-		}
-		if f, ok := any.(localinterface.IInt64); ok {
-			return f.Int64(), nil
-		}
-		return doInt64(rv.Elem().Interface())
-	case reflect.Slice:
-		// TODO: It might panic here for these types.
-		if rv.Type().Elem().Kind() == reflect.Uint8 {
-			return gbinary.DecodeToInt64(rv.Bytes()), nil
-		}
-	case reflect.String:
-		var (
-			s       = rv.String()
-			isMinus = false
-		)
-		if len(s) > 0 {
-			if s[0] == '-' {
-				isMinus = true
-				s = s[1:]
-			} else if s[0] == '+' {
-				s = s[1:]
-			}
-		}
-		// Hexadecimal.
-		if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
-			if v, e := strconv.ParseInt(s[2:], 16, 64); e == nil {
-				if isMinus {
-					return -v, nil
-				}
-				return v, nil
-			}
-		}
-		// Decimal.
-		if v, e := strconv.ParseInt(s, 10, 64); e == nil {
-			if isMinus {
-				return -v, nil
-			}
-			return v, nil
-		}
-		// Float64.
-		valueInt64, err := doFloat64(s)
-		if err != nil {
-			return 0, err
-		}
-		if math.IsNaN(valueInt64) {
-			return 0, nil
-		} else {
-			if isMinus {
-				return -int64(valueInt64), nil
-			}
-			return int64(valueInt64), nil
-		}
-	default:
-		if f, ok := any.(localinterface.IInt64); ok {
-			return f.Int64(), nil
-		}
-	}
-	return 0, gerror.NewCodef(
-		gcode.CodeInvalidParameter,
-		`unsupport value type for converting to int64: %v`,
-		reflect.TypeOf(any),
-	)
-}

util/gconv/gconv_map.go

@@ -6,566 +6,42 @@
 
 package gconv
 
-import (
-	"reflect"
-	"strings"
-
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-	"github.com/gogf/gf/v2/util/gtag"
-)
-
-type recursiveType string
-
-const (
-	recursiveTypeAuto recursiveType = "auto"
-	recursiveTypeTrue recursiveType = "true"
-)
-
-// MapOption specifies the option for map converting.
-type MapOption struct {
-	// Deep marks doing Map function recursively, which means if the attribute of given converting value
-	// is also a struct/*struct, it automatically calls Map function on this attribute converting it to
-	// a map[string]interface{} type variable.
-	Deep bool
-
-	// OmitEmpty ignores the attributes that has json `omitempty` tag.
-	OmitEmpty bool
-
-	// Tags specifies the converted map key name by struct tag name.
-	Tags []string
-}
-
-// Map converts any variable `value` to map[string]interface{}. If the parameter `value` is not a
+// Map converts any variable `value` to map[string]any. If the parameter `value` is not a
 // map/struct/*struct type, then the conversion will fail and returns nil.
 //
 // If `value` is a struct/*struct object, the second parameter `priorityTagAndFieldName` specifies the most priority
 // priorityTagAndFieldName that will be detected, otherwise it detects the priorityTagAndFieldName in order of:
 // gconv, json, field name.
-func Map(value interface{}, option ...MapOption) map[string]interface{} {
-	return doMapConvert(value, recursiveTypeAuto, false, option...)
+func Map(value any, option ...MapOption) map[string]any {
+	result, _ := defaultConverter.Map(value, getUsedMapOption(option...))
+	return result
 }
 
 // MapDeep does Map function recursively, which means if the attribute of `value`
 // is also a struct/*struct, calls Map function on this attribute converting it to
-// a map[string]interface{} type variable.
+// a map[string]any type variable.
 // Deprecated: used Map instead.
-func MapDeep(value interface{}, tags ...string) map[string]interface{} {
-	return doMapConvert(value, recursiveTypeTrue, false, MapOption{
+func MapDeep(value any, tags ...string) map[string]any {
+	result, _ := defaultConverter.Map(value, MapOption{
 		Deep:            true,
+		OmitEmpty:       false,
 		Tags:            tags,
+		ContinueOnError: true,
 	})
-}
-
-// doMapConvert implements the map converting.
-// It automatically checks and converts json string to map if `value` is string/[]byte.
-//
-// TODO completely implement the recursive converting for all types, especially the map.
-func doMapConvert(value interface{}, recursive recursiveType, mustMapReturn bool, option ...MapOption) map[string]interface{} {
-	if value == nil {
-		return nil
-	}
-	// It redirects to its underlying value if it has implemented interface iVal.
-	if v, ok := value.(localinterface.IVal); ok {
-		value = v.Val()
-	}
-	var (
-		usedOption = getUsedMapOption(option...)
-		newTags    = gtag.StructTagPriority
-	)
-	if usedOption.Deep {
-		recursive = recursiveTypeTrue
-	}
-	switch len(usedOption.Tags) {
-	case 0:
-		// No need handling.
-	case 1:
-		newTags = append(strings.Split(usedOption.Tags[0], ","), gtag.StructTagPriority...)
-	default:
-		newTags = append(usedOption.Tags, gtag.StructTagPriority...)
-	}
-	// Assert the common combination of types, and finally it uses reflection.
-	dataMap := make(map[string]interface{})
-	switch r := value.(type) {
-	case string:
-		// If it is a JSON string, automatically unmarshal it!
-		if len(r) > 0 && r[0] == '{' && r[len(r)-1] == '}' {
-			if err := json.UnmarshalUseNumber([]byte(r), &dataMap); err != nil {
-				return nil
-			}
-		} else {
-			return nil
-		}
-	case []byte:
-		// If it is a JSON string, automatically unmarshal it!
-		if len(r) > 0 && r[0] == '{' && r[len(r)-1] == '}' {
-			if err := json.UnmarshalUseNumber(r, &dataMap); err != nil {
-				return nil
-			}
-		} else {
-			return nil
-		}
-	case map[interface{}]interface{}:
-		recursiveOption := usedOption
-		recursiveOption.Tags = newTags
-		for k, v := range r {
-			dataMap[String(k)] = doMapConvertForMapOrStructValue(
-				doMapConvertForMapOrStructValueInput{
-					IsRoot:          false,
-					Value:           v,
-					RecursiveType:   recursive,
-					RecursiveOption: recursive == recursiveTypeTrue,
-					Option:          recursiveOption,
-				},
-			)
-		}
-	case map[interface{}]string:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[interface{}]int:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[interface{}]uint:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[interface{}]float32:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[interface{}]float64:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[string]bool:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]int:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]uint:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]float32:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]float64:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]string:
-		for k, v := range r {
-			dataMap[k] = v
-		}
-	case map[string]interface{}:
-		if recursive == recursiveTypeTrue {
-			recursiveOption := usedOption
-			recursiveOption.Tags = newTags
-			// A copy of current map.
-			for k, v := range r {
-				dataMap[k] = doMapConvertForMapOrStructValue(
-					doMapConvertForMapOrStructValueInput{
-						IsRoot:          false,
-						Value:           v,
-						RecursiveType:   recursive,
-						RecursiveOption: recursive == recursiveTypeTrue,
-						Option:          recursiveOption,
-					},
-				)
-			}
-		} else {
-			// It returns the map directly without any changing.
-			return r
-		}
-	case map[int]interface{}:
-		recursiveOption := usedOption
-		recursiveOption.Tags = newTags
-		for k, v := range r {
-			dataMap[String(k)] = doMapConvertForMapOrStructValue(
-				doMapConvertForMapOrStructValueInput{
-					IsRoot:          false,
-					Value:           v,
-					RecursiveType:   recursive,
-					RecursiveOption: recursive == recursiveTypeTrue,
-					Option:          recursiveOption,
-				},
-			)
-		}
-	case map[int]string:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-	case map[uint]string:
-		for k, v := range r {
-			dataMap[String(k)] = v
-		}
-
-	default:
-		// Not a common type, it then uses reflection for conversion.
-		var reflectValue reflect.Value
-		if v, ok := value.(reflect.Value); ok {
-			reflectValue = v
-		} else {
-			reflectValue = reflect.ValueOf(value)
-		}
-		reflectKind := reflectValue.Kind()
-		// If it is a pointer, we should find its real data type.
-		for reflectKind == reflect.Ptr {
-			reflectValue = reflectValue.Elem()
-			reflectKind = reflectValue.Kind()
-		}
-		switch reflectKind {
-		// If `value` is type of array, it converts the value of even number index as its key and
-		// the value of odd number index as its corresponding value, for example:
-		// []string{"k1","v1","k2","v2"} => map[string]interface{}{"k1":"v1", "k2":"v2"}
-		// []string{"k1","v1","k2"}      => map[string]interface{}{"k1":"v1", "k2":nil}
-		case reflect.Slice, reflect.Array:
-			length := reflectValue.Len()
-			for i := 0; i < length; i += 2 {
-				if i+1 < length {
-					dataMap[String(reflectValue.Index(i).Interface())] = reflectValue.Index(i + 1).Interface()
-				} else {
-					dataMap[String(reflectValue.Index(i).Interface())] = nil
-				}
-			}
-		case reflect.Map, reflect.Struct, reflect.Interface:
-			recursiveOption := usedOption
-			recursiveOption.Tags = newTags
-			convertedValue := doMapConvertForMapOrStructValue(
-				doMapConvertForMapOrStructValueInput{
-					IsRoot:          true,
-					Value:           value,
-					RecursiveType:   recursive,
-					RecursiveOption: recursive == recursiveTypeTrue,
-					Option:          recursiveOption,
-					MustMapReturn:   mustMapReturn,
-				},
-			)
-			if m, ok := convertedValue.(map[string]interface{}); ok {
-				return m
-			}
-			return nil
-		default:
-			return nil
-		}
-	}
-	return dataMap
-}
-
-func getUsedMapOption(option ...MapOption) MapOption {
-	var usedOption MapOption
-	if len(option) > 0 {
-		usedOption = option[0]
-	}
-	return usedOption
-}
-
-type doMapConvertForMapOrStructValueInput struct {
-	IsRoot          bool          // It returns directly if it is not root and with no recursive converting.
-	Value           interface{}   // Current operation value.
-	RecursiveType   recursiveType // The type from top function entry.
-	RecursiveOption bool          // Whether convert recursively for `current` operation.
-	Option          MapOption     // Map converting option.
-	MustMapReturn   bool          // Must return map instead of Value when empty.
-}
-
-func doMapConvertForMapOrStructValue(in doMapConvertForMapOrStructValueInput) interface{} {
-	if !in.IsRoot && !in.RecursiveOption {
-		return in.Value
-	}
-
-	var reflectValue reflect.Value
-	if v, ok := in.Value.(reflect.Value); ok {
-		reflectValue = v
-		in.Value = v.Interface()
-	} else {
-		reflectValue = reflect.ValueOf(in.Value)
-	}
-	reflectKind := reflectValue.Kind()
-	// If it is a pointer, we should find its real data type.
-	for reflectKind == reflect.Ptr {
-		reflectValue = reflectValue.Elem()
-		reflectKind = reflectValue.Kind()
-	}
-	switch reflectKind {
-	case reflect.Map:
-		var (
-			mapIter = reflectValue.MapRange()
-			dataMap = make(map[string]interface{})
-		)
-		for mapIter.Next() {
-			var (
-				mapKeyValue = mapIter.Value()
-				mapValue    interface{}
-			)
-			switch {
-			case mapKeyValue.IsZero():
-				if utils.CanCallIsNil(mapKeyValue) && mapKeyValue.IsNil() {
-					// quick check for nil value.
-					mapValue = nil
-				} else {
-					// in case of:
-					// exception recovered: reflect: call of reflect.Value.Interface on zero Value
-					mapValue = reflect.New(mapKeyValue.Type()).Elem().Interface()
-				}
-			default:
-				mapValue = mapKeyValue.Interface()
-			}
-			dataMap[String(mapIter.Key().Interface())] = doMapConvertForMapOrStructValue(
-				doMapConvertForMapOrStructValueInput{
-					IsRoot:          false,
-					Value:           mapValue,
-					RecursiveType:   in.RecursiveType,
-					RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-					Option:          in.Option,
-				},
-			)
-		}
-		return dataMap
-
-	case reflect.Struct:
-		var dataMap = make(map[string]interface{})
-		// Map converting interface check.
-		if v, ok := in.Value.(localinterface.IMapStrAny); ok {
-			// Value copy, in case of concurrent safety.
-			for mapK, mapV := range v.MapStrAny() {
-				if in.RecursiveOption {
-					dataMap[mapK] = doMapConvertForMapOrStructValue(
-						doMapConvertForMapOrStructValueInput{
-							IsRoot:          false,
-							Value:           mapV,
-							RecursiveType:   in.RecursiveType,
-							RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-							Option:          in.Option,
-						},
-					)
-				} else {
-					dataMap[mapK] = mapV
-				}
-			}
-			if len(dataMap) > 0 {
-				return dataMap
-			}
-		}
-		// Using reflect for converting.
-		var (
-			rtField     reflect.StructField
-			rvField     reflect.Value
-			reflectType = reflectValue.Type() // attribute value type.
-			mapKey      = ""                  // mapKey may be the tag name or the struct attribute name.
-		)
-		for i := 0; i < reflectValue.NumField(); i++ {
-			rtField = reflectType.Field(i)
-			rvField = reflectValue.Field(i)
-			// Only convert the public attributes.
-			fieldName := rtField.Name
-			if !utils.IsLetterUpper(fieldName[0]) {
-				continue
-			}
-			mapKey = ""
-			fieldTag := rtField.Tag
-			for _, tag := range in.Option.Tags {
-				if mapKey = fieldTag.Get(tag); mapKey != "" {
-					break
-				}
-			}
-			if mapKey == "" {
-				mapKey = fieldName
-			} else {
-				// Support json tag feature: -, omitempty
-				mapKey = strings.TrimSpace(mapKey)
-				if mapKey == "-" {
-					continue
-				}
-				array := strings.Split(mapKey, ",")
-				if len(array) > 1 {
-					switch strings.TrimSpace(array[1]) {
-					case "omitempty":
-						if in.Option.OmitEmpty && empty.IsEmpty(rvField.Interface()) {
-							continue
-						} else {
-							mapKey = strings.TrimSpace(array[0])
-						}
-					default:
-						mapKey = strings.TrimSpace(array[0])
-					}
-				}
-				if mapKey == "" {
-					mapKey = fieldName
-				}
-			}
-			if in.RecursiveOption || rtField.Anonymous {
-				// Do map converting recursively.
-				var (
-					rvAttrField = rvField
-					rvAttrKind  = rvField.Kind()
-				)
-				if rvAttrKind == reflect.Ptr {
-					rvAttrField = rvField.Elem()
-					rvAttrKind = rvAttrField.Kind()
-				}
-				switch rvAttrKind {
-				case reflect.Struct:
-					// Embedded struct and has no fields, just ignores it.
-					// Eg: gmeta.Meta
-					if rvAttrField.Type().NumField() == 0 {
-						continue
-					}
-					var (
-						hasNoTag = mapKey == fieldName
-						// DO NOT use rvAttrField.Interface() here,
-						// as it might be changed from pointer to struct.
-						rvInterface = rvField.Interface()
-					)
-					switch {
-					case hasNoTag && rtField.Anonymous:
-						// It means this attribute field has no tag.
-						// Overwrite the attribute with sub-struct attribute fields.
-						anonymousValue := doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
-							IsRoot:          false,
-							Value:           rvInterface,
-							RecursiveType:   in.RecursiveType,
-							RecursiveOption: true,
-							Option:          in.Option,
-						})
-						if m, ok := anonymousValue.(map[string]interface{}); ok {
-							for k, v := range m {
-								dataMap[k] = v
-							}
-						} else {
-							dataMap[mapKey] = rvInterface
-						}
-
-					// It means this attribute field has desired tag.
-					case !hasNoTag && rtField.Anonymous:
-						dataMap[mapKey] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
-							IsRoot:          false,
-							Value:           rvInterface,
-							RecursiveType:   in.RecursiveType,
-							RecursiveOption: true,
-							Option:          in.Option,
-						})
-
-					default:
-						dataMap[mapKey] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
-							IsRoot:          false,
-							Value:           rvInterface,
-							RecursiveType:   in.RecursiveType,
-							RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-							Option:          in.Option,
-						})
-					}
-
-				// The struct attribute is type of slice.
-				case reflect.Array, reflect.Slice:
-					length := rvAttrField.Len()
-					if length == 0 {
-						dataMap[mapKey] = rvAttrField.Interface()
-						break
-					}
-					array := make([]interface{}, length)
-					for arrayIndex := 0; arrayIndex < length; arrayIndex++ {
-						array[arrayIndex] = doMapConvertForMapOrStructValue(
-							doMapConvertForMapOrStructValueInput{
-								IsRoot:          false,
-								Value:           rvAttrField.Index(arrayIndex).Interface(),
-								RecursiveType:   in.RecursiveType,
-								RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-								Option:          in.Option,
-							},
-						)
-					}
-					dataMap[mapKey] = array
-				case reflect.Map:
-					var (
-						mapIter   = rvAttrField.MapRange()
-						nestedMap = make(map[string]interface{})
-					)
-					for mapIter.Next() {
-						nestedMap[String(mapIter.Key().Interface())] = doMapConvertForMapOrStructValue(
-							doMapConvertForMapOrStructValueInput{
-								IsRoot:          false,
-								Value:           mapIter.Value().Interface(),
-								RecursiveType:   in.RecursiveType,
-								RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-								Option:          in.Option,
-							},
-						)
-					}
-					dataMap[mapKey] = nestedMap
-				default:
-					if rvField.IsValid() {
-						dataMap[mapKey] = reflectValue.Field(i).Interface()
-					} else {
-						dataMap[mapKey] = nil
-					}
-				}
-			} else {
-				// No recursive map value converting
-				if rvField.IsValid() {
-					dataMap[mapKey] = reflectValue.Field(i).Interface()
-				} else {
-					dataMap[mapKey] = nil
-				}
-			}
-		}
-		if !in.MustMapReturn && len(dataMap) == 0 {
-			return in.Value
-		}
-		return dataMap
-
-	// The given value is type of slice.
-	case reflect.Array, reflect.Slice:
-		length := reflectValue.Len()
-		if length == 0 {
-			break
-		}
-		array := make([]interface{}, reflectValue.Len())
-		for i := 0; i < length; i++ {
-			array[i] = doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
-				IsRoot:          false,
-				Value:           reflectValue.Index(i).Interface(),
-				RecursiveType:   in.RecursiveType,
-				RecursiveOption: in.RecursiveType == recursiveTypeTrue,
-				Option:          in.Option,
-			})
-		}
-		return array
-
-	default:
-	}
-	return in.Value
+	return result
 }
 
 // MapStrStr converts `value` to map[string]string.
 // Note that there might be data copy for this map type converting.
-func MapStrStr(value interface{}, option ...MapOption) map[string]string {
-	if r, ok := value.(map[string]string); ok {
-		return r
-	}
-	m := Map(value, option...)
-	if len(m) > 0 {
-		vMap := make(map[string]string, len(m))
-		for k, v := range m {
-			vMap[k] = String(v)
-		}
-		return vMap
-	}
-	return nil
+func MapStrStr(value any, option ...MapOption) map[string]string {
+	result, _ := defaultConverter.MapStrStr(value, getUsedMapOption(option...))
+	return result
 }
 
 // MapStrStrDeep converts `value` to map[string]string recursively.
 // Note that there might be data copy for this map type converting.
 // Deprecated: used MapStrStr instead.
-func MapStrStrDeep(value interface{}, tags ...string) map[string]string {
+func MapStrStrDeep(value any, tags ...string) map[string]string {
 	if r, ok := value.(map[string]string); ok {
 		return r
 	}
@@ -579,3 +55,13 @@ func MapStrStrDeep(value interface{}, tags ...string) map[string]string {
 	}
 	return nil
 }
+
+func getUsedMapOption(option ...MapOption) MapOption {
+	var usedOption = MapOption{
+		ContinueOnError: true,
+	}
+	if len(option) > 0 {
+		usedOption = option[0]
+	}
+	return usedOption
+}

util/gconv/gconv_maps.go

@@ -9,72 +9,42 @@ package gconv
 import "github.com/gogf/gf/v2/internal/json"
 
 // SliceMap is alias of Maps.
-func SliceMap(any interface{}, option ...MapOption) []map[string]interface{} {
+func SliceMap(any any, option ...MapOption) []map[string]any {
 	return Maps(any, option...)
 }
 
 // SliceMapDeep is alias of MapsDeep.
 // Deprecated: used SliceMap instead.
-func SliceMapDeep(any interface{}) []map[string]interface{} {
+func SliceMapDeep(any any) []map[string]any {
 	return MapsDeep(any)
 }
 
-// Maps converts `value` to []map[string]interface{}.
+// Maps converts `value` to []map[string]any.
 // Note that it automatically checks and converts json string to []map if `value` is string/[]byte.
-func Maps(value interface{}, option ...MapOption) []map[string]interface{} {
-	if value == nil {
-		return nil
+func Maps(value any, option ...MapOption) []map[string]any {
+	mapOption := MapOption{
+		ContinueOnError: true,
 	}
-	switch r := value.(type) {
-	case string:
-		list := make([]map[string]interface{}, 0)
-		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
-			if err := json.UnmarshalUseNumber([]byte(r), &list); err != nil {
-				return nil
-			}
-			return list
-		} else {
-			return nil
-		}
-
-	case []byte:
-		list := make([]map[string]interface{}, 0)
-		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
-			if err := json.UnmarshalUseNumber(r, &list); err != nil {
-				return nil
-			}
-			return list
-		} else {
-			return nil
-		}
-
-	case []map[string]interface{}:
-		return r
-
-	default:
-		array := Interfaces(value)
-		if len(array) == 0 {
-			return nil
-		}
-		list := make([]map[string]interface{}, len(array))
-		for k, v := range array {
-			list[k] = Map(v, option...)
-		}
-		return list
+	if len(option) > 0 {
+		mapOption = option[0]
 	}
+	result, _ := defaultConverter.SliceMap(value, SliceOption{
+		ContinueOnError: true,
+	}, mapOption)
+	return result
 }
 
-// MapsDeep converts `value` to []map[string]interface{} recursively.
+// MapsDeep converts `value` to []map[string]any recursively.
 //
 // TODO completely implement the recursive converting for all types.
 // Deprecated: used Maps instead.
-func MapsDeep(value interface{}, tags ...string) []map[string]interface{} {
+func MapsDeep(value any, tags ...string) []map[string]any {
 	if value == nil {
 		return nil
 	}
 	switch r := value.(type) {
 	case string:
-		list := make([]map[string]interface{}, 0)
+		list := make([]map[string]any, 0)
 		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
 			if err := json.UnmarshalUseNumber([]byte(r), &list); err != nil {
 				return nil
@@ -85,7 +55,7 @@ func MapsDeep(value interface{}, tags ...string) []map[string]interface{} {
 		}
 
 	case []byte:
-		list := make([]map[string]interface{}, 0)
+		list := make([]map[string]any, 0)
 		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
 			if err := json.UnmarshalUseNumber(r, &list); err != nil {
 				return nil
@@ -95,8 +65,8 @@ func MapsDeep(value interface{}, tags ...string) []map[string]interface{} {
 			return nil
 		}
 
-	case []map[string]interface{}:
-		list := make([]map[string]interface{}, len(r))
+	case []map[string]any:
+		list := make([]map[string]any, len(r))
 		for k, v := range r {
 			list[k] = MapDeep(v, tags...)
 		}
@@ -107,7 +77,7 @@ func MapsDeep(value interface{}, tags ...string) []map[string]interface{} {
 		if len(array) == 0 {
 			return nil
 		}
-		list := make([]map[string]interface{}, len(array))
+		list := make([]map[string]any, len(array))
 		for k, v := range array {
 			list[k] = MapDeep(v, tags...)
 		}

util/gconv/gconv_maptomap.go

@@ -6,126 +6,9 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-)
-
 // MapToMap converts any map type variable `params` to another map type variable `pointer`
 // using reflect.
 // See doMapToMap.
-func MapToMap(params interface{}, pointer interface{}, mapping ...map[string]string) error {
+func MapToMap(params any, pointer any, mapping ...map[string]string) error {
 	return Scan(params, pointer, mapping...)
 }
-
-// doMapToMap converts any map type variable `params` to another map type variable `pointer`.
-//
-// The parameter `params` can be any type of map, like:
-// map[string]string, map[string]struct, map[string]*struct, reflect.Value, etc.
-//
-// The parameter `pointer` should be type of *map, like:
-// map[int]string, map[string]struct, map[string]*struct, reflect.Value, etc.
-//
-// The optional parameter `mapping` is used for struct attribute to map key mapping, which makes
-// sense only if the items of original map `params` is type struct.
-func doMapToMap(params interface{}, pointer interface{}, mapping ...map[string]string) (err error) {
-	var (
-		paramsRv                  reflect.Value
-		paramsKind                reflect.Kind
-		keyToAttributeNameMapping map[string]string
-	)
-	if len(mapping) > 0 {
-		keyToAttributeNameMapping = mapping[0]
-	}
-	if v, ok := params.(reflect.Value); ok {
-		paramsRv = v
-	} else {
-		paramsRv = reflect.ValueOf(params)
-	}
-	paramsKind = paramsRv.Kind()
-	if paramsKind == reflect.Ptr {
-		paramsRv = paramsRv.Elem()
-		paramsKind = paramsRv.Kind()
-	}
-	if paramsKind != reflect.Map {
-		return doMapToMap(Map(params), pointer, mapping...)
-	}
-	// Empty params map, no need continue.
-	if paramsRv.Len() == 0 {
-		return nil
-	}
-	var pointerRv reflect.Value
-	if v, ok := pointer.(reflect.Value); ok {
-		pointerRv = v
-	} else {
-		pointerRv = reflect.ValueOf(pointer)
-	}
-	pointerKind := pointerRv.Kind()
-	for pointerKind == reflect.Ptr {
-		pointerRv = pointerRv.Elem()
-		pointerKind = pointerRv.Kind()
-	}
-	if pointerKind != reflect.Map {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			`destination pointer should be type of *map, but got: %s`,
-			pointerKind,
-		)
-	}
-	defer func() {
-		// Catch the panic, especially the reflection operation panics.
-		if exception := recover(); exception != nil {
-			if v, ok := exception.(error); ok && gerror.HasStack(v) {
-				err = v
-			} else {
-				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
-			}
-		}
-	}()
-	var (
-		paramsKeys       = paramsRv.MapKeys()
-		pointerKeyType   = pointerRv.Type().Key()
-		pointerValueType = pointerRv.Type().Elem()
-		pointerValueKind = pointerValueType.Kind()
-		dataMap          = reflect.MakeMapWithSize(pointerRv.Type(), len(paramsKeys))
-	)
-	// Retrieve the true element type of target map.
-	if pointerValueKind == reflect.Ptr {
-		pointerValueKind = pointerValueType.Elem().Kind()
-	}
-	for _, key := range paramsKeys {
-		mapValue := reflect.New(pointerValueType).Elem()
-		switch pointerValueKind {
-		case reflect.Map, reflect.Struct:
-			if err = doStruct(
-				paramsRv.MapIndex(key).Interface(), mapValue, keyToAttributeNameMapping, "",
-			); err != nil {
-				return err
-			}
-		default:
-			mapValue.Set(
-				reflect.ValueOf(
-					doConvert(doConvertInput{
-						FromValue:  paramsRv.MapIndex(key).Interface(),
-						ToTypeName: pointerValueType.String(),
-						ReferValue: mapValue,
-						Extra:      nil,
-					}),
-				),
-			)
-		}
-		var mapKey = reflect.ValueOf(
-			doConvert(doConvertInput{
-				FromValue:  key.Interface(),
-				ToTypeName: pointerKeyType.Name(),
-				ReferValue: reflect.New(pointerKeyType).Elem().Interface(),
-				Extra:      nil,
-			}),
-		)
-		dataMap.SetMapIndex(mapKey, mapValue)
-	}
-	pointerRv.Set(dataMap)
-	return nil
-}

util/gconv/gconv_maptomaps.go

@@ -6,121 +6,8 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-)
-
 // MapToMaps converts any slice type variable `params` to another map slice type variable `pointer`.
 // See doMapToMaps.
-func MapToMaps(params interface{}, pointer interface{}, mapping ...map[string]string) error {
+func MapToMaps(params any, pointer any, mapping ...map[string]string) error {
 	return Scan(params, pointer, mapping...)
 }
-
-// doMapToMaps converts any map type variable `params` to another map slice variable `pointer`.
-//
-// The parameter `params` can be type of []map, []*map, []struct, []*struct.
-//
-// The parameter `pointer` should be type of []map, []*map.
-//
-// The optional parameter `mapping` is used for struct attribute to map key mapping, which makes
-// sense only if the item of `params` is type struct.
-func doMapToMaps(params interface{}, pointer interface{}, paramKeyToAttrMap ...map[string]string) (err error) {
-	// Params and its element type check.
-	var (
-		paramsRv   reflect.Value
-		paramsKind reflect.Kind
-	)
-	if v, ok := params.(reflect.Value); ok {
-		paramsRv = v
-	} else {
-		paramsRv = reflect.ValueOf(params)
-	}
-	paramsKind = paramsRv.Kind()
-	if paramsKind == reflect.Ptr {
-		paramsRv = paramsRv.Elem()
-		paramsKind = paramsRv.Kind()
-	}
-	if paramsKind != reflect.Array && paramsKind != reflect.Slice {
-		return gerror.NewCode(
-			gcode.CodeInvalidParameter,
-			"params should be type of slice, example: []map/[]*map/[]struct/[]*struct",
-		)
-	}
-	var (
-		paramsElem     = paramsRv.Type().Elem()
-		paramsElemKind = paramsElem.Kind()
-	)
-	if paramsElemKind == reflect.Ptr {
-		paramsElem = paramsElem.Elem()
-		paramsElemKind = paramsElem.Kind()
-	}
-	if paramsElemKind != reflect.Map &&
-		paramsElemKind != reflect.Struct &&
-		paramsElemKind != reflect.Interface {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"params element should be type of map/*map/struct/*struct, but got: %s",
-			paramsElemKind,
-		)
-	}
-	// Empty slice, no need continue.
-	if paramsRv.Len() == 0 {
-		return nil
-	}
-	// Pointer and its element type check.
-	var (
-		pointerRv   = reflect.ValueOf(pointer)
-		pointerKind = pointerRv.Kind()
-	)
-	for pointerKind == reflect.Ptr {
-		pointerRv = pointerRv.Elem()
-		pointerKind = pointerRv.Kind()
-	}
-	if pointerKind != reflect.Array && pointerKind != reflect.Slice {
-		return gerror.NewCode(gcode.CodeInvalidParameter, "pointer should be type of *[]map/*[]*map")
-	}
-	var (
-		pointerElemType = pointerRv.Type().Elem()
-		pointerElemKind = pointerElemType.Kind()
-	)
-	if pointerElemKind == reflect.Ptr {
-		pointerElemKind = pointerElemType.Elem().Kind()
-	}
-	if pointerElemKind != reflect.Map {
-		return gerror.NewCode(gcode.CodeInvalidParameter, "pointer element should be type of map/*map")
-	}
-	defer func() {
-		// Catch the panic, especially the reflection operation panics.
-		if exception := recover(); exception != nil {
-			if v, ok := exception.(error); ok && gerror.HasStack(v) {
-				err = v
-			} else {
-				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
-			}
-		}
-	}()
-	var (
-		pointerSlice = reflect.MakeSlice(pointerRv.Type(), paramsRv.Len(), paramsRv.Len())
-	)
-	for i := 0; i < paramsRv.Len(); i++ {
-		var item reflect.Value
-		if pointerElemType.Kind() == reflect.Ptr {
-			item = reflect.New(pointerElemType.Elem())
-			if err = MapToMap(paramsRv.Index(i).Interface(), item, paramKeyToAttrMap...); err != nil {
-				return err
-			}
-			pointerSlice.Index(i).Set(item)
-		} else {
-			item = reflect.New(pointerElemType)
-			if err = MapToMap(paramsRv.Index(i).Interface(), item, paramKeyToAttrMap...); err != nil {
-				return err
-			}
-			pointerSlice.Index(i).Set(item.Elem())
-		}
-	}
-	pointerRv.Set(pointerSlice)
-	return
-}

util/gconv/gconv_scan.go

@@ -6,15 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // Scan automatically checks the type of `pointer` and converts `params` to `pointer`.
 // It supports various types of parameter conversions, including:
 // 1. Basic types (int, string, float, etc.)
@@ -26,321 +17,11 @@ import (
 // The `paramKeyToAttrMap` parameter is used for mapping between attribute names and parameter keys.
 // TODO: change `paramKeyToAttrMap` to `ScanOption` to be more scalable; add `DeepCopy` option for `ScanOption`.
 func Scan(srcValue any, dstPointer any, paramKeyToAttrMap ...map[string]string) (err error) {
-	// Check if srcValue is nil, in which case no conversion is needed
-	if srcValue == nil {
-		return nil
+	option := ScanOption{
+		ContinueOnError: true,
 	}
-	// Check if dstPointer is nil, which is an invalid parameter
-	if dstPointer == nil {
-		return gerror.NewCode(
-			gcode.CodeInvalidParameter,
-			`destination pointer should not be nil`,
-		)
-	}
-
-	// Get the reflection type and value of dstPointer
-	var (
-		dstPointerReflectType  reflect.Type
-		dstPointerReflectValue reflect.Value
-	)
-	if v, ok := dstPointer.(reflect.Value); ok {
-		dstPointerReflectValue = v
-		dstPointerReflectType = v.Type()
-	} else {
-		dstPointerReflectValue = reflect.ValueOf(dstPointer)
-		// Do not use dstPointerReflectValue.Type() as dstPointerReflectValue might be zero
-		dstPointerReflectType = reflect.TypeOf(dstPointer)
-	}
-
-	// Validate the kind of dstPointer
-	var dstPointerReflectKind = dstPointerReflectType.Kind()
-	if dstPointerReflectKind != reflect.Ptr {
-		// If dstPointer is not a pointer, try to get its address
-		if dstPointerReflectValue.CanAddr() {
-			dstPointerReflectValue = dstPointerReflectValue.Addr()
-			dstPointerReflectType = dstPointerReflectValue.Type()
-			dstPointerReflectKind = dstPointerReflectType.Kind()
-		} else {
-			// If dstPointer is not a pointer and cannot be addressed, return an error
-			return gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				`destination pointer should be type of pointer, but got type: %v`,
-				dstPointerReflectType,
-			)
-		}
-	}
-
-	// Get the reflection value of srcValue
-	var srcValueReflectValue reflect.Value
-	if v, ok := srcValue.(reflect.Value); ok {
-		srcValueReflectValue = v
-	} else {
-		srcValueReflectValue = reflect.ValueOf(srcValue)
-	}
-
-	// Get the element type and kind of dstPointer
-	var (
-		dstPointerReflectValueElem     = dstPointerReflectValue.Elem()
-		dstPointerReflectValueElemKind = dstPointerReflectValueElem.Kind()
-	)
-	// Handle multiple level pointers
-	if dstPointerReflectValueElemKind == reflect.Ptr {
-		if dstPointerReflectValueElem.IsNil() {
-			// Create a new value for the pointer dereference
-			nextLevelPtr := reflect.New(dstPointerReflectValueElem.Type().Elem())
-			// Recursively scan into the dereferenced pointer
-			if err = Scan(srcValueReflectValue, nextLevelPtr, paramKeyToAttrMap...); err == nil {
-				dstPointerReflectValueElem.Set(nextLevelPtr)
-			}
-			return
-		}
-		return Scan(srcValueReflectValue, dstPointerReflectValueElem, paramKeyToAttrMap...)
-	}
-
-	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed
-	if ok := doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem); ok {
-		return nil
-	}
-
-	// Handle different destination types
-	switch dstPointerReflectValueElemKind {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		// Convert to int type
-		dstPointerReflectValueElem.SetInt(Int64(srcValue))
-		return nil
-
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		// Convert to uint type
-		dstPointerReflectValueElem.SetUint(Uint64(srcValue))
-		return nil
-
-	case reflect.Float32, reflect.Float64:
-		// Convert to float type
-		dstPointerReflectValueElem.SetFloat(Float64(srcValue))
-		return nil
-
-	case reflect.String:
-		// Convert to string type
-		dstPointerReflectValueElem.SetString(String(srcValue))
-		return nil
-
-	case reflect.Bool:
-		// Convert to bool type
-		dstPointerReflectValueElem.SetBool(Bool(srcValue))
-		return nil
-
-	case reflect.Slice:
-		// Handle slice type conversion
-		var (
-			dstElemType = dstPointerReflectValueElem.Type().Elem()
-			dstElemKind = dstElemType.Kind()
-		)
-		// The slice element might be a pointer type
-		if dstElemKind == reflect.Ptr {
-			dstElemType = dstElemType.Elem()
-			dstElemKind = dstElemType.Kind()
-		}
-		// Special handling for struct or map slice elements
-		if dstElemKind == reflect.Struct || dstElemKind == reflect.Map {
-			return doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, paramKeyToAttrMap...)
-		}
-		// Handle basic type slice conversions
-		var srcValueReflectValueKind = srcValueReflectValue.Kind()
-		if srcValueReflectValueKind == reflect.Slice || srcValueReflectValueKind == reflect.Array {
-			var (
-				srcLen   = srcValueReflectValue.Len()
-				newSlice = reflect.MakeSlice(dstPointerReflectValueElem.Type(), srcLen, srcLen)
-			)
-			for i := 0; i < srcLen; i++ {
-				srcElem := srcValueReflectValue.Index(i).Interface()
-				switch dstElemType.Kind() {
-				case reflect.String:
-					newSlice.Index(i).SetString(String(srcElem))
-				case reflect.Int:
-					newSlice.Index(i).SetInt(Int64(srcElem))
-				case reflect.Int64:
-					newSlice.Index(i).SetInt(Int64(srcElem))
-				case reflect.Float64:
-					newSlice.Index(i).SetFloat(Float64(srcElem))
-				case reflect.Bool:
-					newSlice.Index(i).SetBool(Bool(srcElem))
-				default:
-					return Scan(
-						srcElem, newSlice.Index(i).Addr().Interface(), paramKeyToAttrMap...,
-					)
-				}
-			}
-			dstPointerReflectValueElem.Set(newSlice)
-			return nil
-		}
-		return doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, paramKeyToAttrMap...)
-
-	default:
-		// Handle complex types (structs, maps, etc.)
-		return doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, paramKeyToAttrMap...)
-	}
-}
-
-// doScanForComplicatedTypes handles the scanning of complex data types.
-// It supports converting between maps, structs, and slices of these types.
-// The function first attempts JSON conversion, then falls back to specific type handling.
-//
-// It supports `pointer` in type of `*map/*[]map/*[]*map/*struct/**struct/*[]struct/*[]*struct` for converting.
-//
-// Parameters:
-// - srcValue: The source value to convert from
-// - dstPointer: The destination pointer to convert to
-// - dstPointerReflectType: The reflection type of the destination pointer
-// - paramKeyToAttrMap: Optional mapping between parameter keys and struct attribute names
-func doScanForComplicatedTypes(
-	srcValue, dstPointer any,
-	dstPointerReflectType reflect.Type,
-	paramKeyToAttrMap ...map[string]string,
-) error {
-	// Try JSON conversion first
-	ok, err := doConvertWithJsonCheck(srcValue, dstPointer)
-	if err != nil {
-		return err
-	}
-	if ok {
-		return nil
-	}
-
-	// Handle specific type conversions
-	var (
-		dstPointerReflectTypeElem     = dstPointerReflectType.Elem()
-		dstPointerReflectTypeElemKind = dstPointerReflectTypeElem.Kind()
-		keyToAttributeNameMapping     map[string]string
-	)
 	if len(paramKeyToAttrMap) > 0 {
-		keyToAttributeNameMapping = paramKeyToAttrMap[0]
-	}
-
-	// Handle different destination types
-	switch dstPointerReflectTypeElemKind {
-	case reflect.Map:
-		// Convert map to map
-		return doMapToMap(srcValue, dstPointer, paramKeyToAttrMap...)
-
-	case reflect.Array, reflect.Slice:
-		var (
-			sliceElem     = dstPointerReflectTypeElem.Elem()
-			sliceElemKind = sliceElem.Kind()
-		)
-		// Handle pointer elements
-		for sliceElemKind == reflect.Ptr {
-			sliceElem = sliceElem.Elem()
-			sliceElemKind = sliceElem.Kind()
-		}
-		if sliceElemKind == reflect.Map {
-			// Convert to slice of maps
-			return doMapToMaps(srcValue, dstPointer, paramKeyToAttrMap...)
-		}
-		// Convert to slice of structs
-		return doStructs(srcValue, dstPointer, keyToAttributeNameMapping, "")
-
-	default:
-		// Convert to single struct
-		return doStruct(srcValue, dstPointer, keyToAttributeNameMapping, "")
+		option.ParamKeyToAttrMap = paramKeyToAttrMap[0]
 	}
-}
-
-// doConvertWithTypeCheck supports `pointer` in type of `*map/*[]map/*[]*map/*struct/**struct/*[]struct/*[]*struct`
-// for converting.
-func doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem reflect.Value) (ok bool) {
-	if !dstPointerReflectValueElem.IsValid() || !srcValueReflectValue.IsValid() {
-		return false
-	}
-	switch {
-	// Examples:
-	// UploadFile       => UploadFile
-	// []UploadFile     => []UploadFile
-	// *UploadFile      => *UploadFile
-	// *[]UploadFile    => *[]UploadFile
-	// map[int][int]    => map[int][int]
-	// []map[int][int]  => []map[int][int]
-	// *[]map[int][int] => *[]map[int][int]
-	case dstPointerReflectValueElem.Type() == srcValueReflectValue.Type():
-		dstPointerReflectValueElem.Set(srcValueReflectValue)
-		return true
-
-	// Examples:
-	// UploadFile      => *UploadFile
-	// []UploadFile    => *[]UploadFile
-	// map[int][int]   => *map[int][int]
-	// []map[int][int] => *[]map[int][int]
-	case dstPointerReflectValueElem.Kind() == reflect.Ptr &&
-		dstPointerReflectValueElem.Elem().IsValid() &&
-		dstPointerReflectValueElem.Elem().Type() == srcValueReflectValue.Type():
-		dstPointerReflectValueElem.Elem().Set(srcValueReflectValue)
-		return true
-
-	// Examples:
-	// *UploadFile      => UploadFile
-	// *[]UploadFile    => []UploadFile
-	// *map[int][int]   => map[int][int]
-	// *[]map[int][int] => []map[int][int]
-	case srcValueReflectValue.Kind() == reflect.Ptr &&
-		srcValueReflectValue.Elem().IsValid() &&
-		dstPointerReflectValueElem.Type() == srcValueReflectValue.Elem().Type():
-		dstPointerReflectValueElem.Set(srcValueReflectValue.Elem())
-		return true
-
-	default:
-		return false
-	}
-}
-
-// doConvertWithJsonCheck attempts to convert the source value to the destination
-// using JSON marshaling and unmarshaling. This is particularly useful for complex
-// types that can be represented as JSON.
-//
-// Parameters:
-// - srcValue: The source value to convert from
-// - dstPointer: The destination pointer to convert to
-//
-// Returns:
-// - bool: true if JSON conversion was successful
-// - error: any error that occurred during conversion
-func doConvertWithJsonCheck(srcValue any, dstPointer any) (ok bool, err error) {
-	switch valueResult := srcValue.(type) {
-	case []byte:
-		if json.Valid(valueResult) {
-			if dstPointerReflectType, ok := dstPointer.(reflect.Value); ok {
-				if dstPointerReflectType.Kind() == reflect.Ptr {
-					if dstPointerReflectType.IsNil() {
-						return false, nil
-					}
-					return true, json.UnmarshalUseNumber(valueResult, dstPointerReflectType.Interface())
-				} else if dstPointerReflectType.CanAddr() {
-					return true, json.UnmarshalUseNumber(valueResult, dstPointerReflectType.Addr().Interface())
-				}
-			} else {
-				return true, json.UnmarshalUseNumber(valueResult, dstPointer)
-			}
-		}
-
-	case string:
-		if valueBytes := []byte(valueResult); json.Valid(valueBytes) {
-			if dstPointerReflectType, ok := dstPointer.(reflect.Value); ok {
-				if dstPointerReflectType.Kind() == reflect.Ptr {
-					if dstPointerReflectType.IsNil() {
-						return false, nil
-					}
-					return true, json.UnmarshalUseNumber(valueBytes, dstPointerReflectType.Interface())
-				} else if dstPointerReflectType.CanAddr() {
-					return true, json.UnmarshalUseNumber(valueBytes, dstPointerReflectType.Addr().Interface())
-				}
-			} else {
-				return true, json.UnmarshalUseNumber(valueBytes, dstPointer)
-			}
-		}
-
-	default:
-		// The `params` might be struct that implements interface function Interface, eg: gvar.Var.
-		if v, ok := srcValue.(localinterface.IInterface); ok {
-			return doConvertWithJsonCheck(v.Interface(), dstPointer)
-		}
-	}
-	return false, nil
+	return defaultConverter.Scan(srcValue, dstPointer, option)
 }

util/gconv/gconv_scan_list.go

@@ -93,7 +93,9 @@ import (
 // given `relation` parameter.
 //
 // See the example or unit testing cases for clear understanding for this function.
-func ScanList(structSlice interface{}, structSlicePointer interface{}, bindToAttrName string, relationAttrNameAndFields ...string) (err error) {
+func ScanList(
+	structSlice any, structSlicePointer any, bindToAttrName string, relationAttrNameAndFields ...string,
+) (err error) {
 	var (
 		relationAttrName string
 		relationFields   string
@@ -111,7 +113,7 @@ func ScanList(structSlice interface{}, structSlicePointer interface{}, bindToAtt
 // doScanList converts `structSlice` to struct slice which contains other complex struct attributes recursively.
 // Note that the parameter `structSlicePointer` should be type of *[]struct/*[]*struct.
 func doScanList(
-	structSlice interface{}, structSlicePointer interface{}, bindToAttrName, relationAttrName, relationFields string,
+	structSlice any, structSlicePointer any, bindToAttrName, relationAttrName, relationFields string,
 ) (err error) {
 	var (
 		maps    = Maps(structSlice)
@@ -169,7 +171,7 @@ func doScanList(
 
 	// Relation variables.
 	var (
-		relationDataMap         map[string]interface{}
+		relationDataMap         map[string]any
 		relationFromFieldName   string // Eg: relationKV: id:uid  -> id
 		relationBindToFieldName string // Eg: relationKV: id:uid  -> uid
 	)
@@ -315,7 +317,7 @@ func doScanList(
 				relationFromAttrField = relationFromAttrValue.FieldByName(relationBindToFieldName)
 				if relationFromAttrField.IsValid() {
 					// results := make(Result, 0)
-					results := make([]interface{}, 0)
+					results := make([]any, 0)
 					for _, v := range SliceAny(relationDataMap[String(relationFromAttrField.Interface())]) {
 						item := v
 						results = append(results, item)

util/gconv/gconv_slice_any.go

@@ -6,14 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // SliceAny is alias of Interfaces.
 func SliceAny(any interface{}) []interface{} {
 	return Interfaces(any)
@@ -21,111 +13,8 @@ func SliceAny(any interface{}) []interface{} {
 
 // Interfaces converts `any` to []interface{}.
 func Interfaces(any interface{}) []interface{} {
-	if any == nil {
-		return nil
-	}
-	var array []interface{}
-	switch value := any.(type) {
-	case []interface{}:
-		array = value
-	case []string:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []int:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []int8:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []int16:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []int32:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []int64:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []uint:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]interface{}, len(value))
-			for k, v := range value {
-				array[k] = v
-			}
-		}
-	case []uint16:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []uint32:
-		for _, v := range value {
-			array = append(array, v)
-		}
-	case []uint64:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []bool:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []float32:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	case []float64:
-		array = make([]interface{}, len(value))
-		for k, v := range value {
-			array[k] = v
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return v.Interfaces()
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]interface{}, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = originValueAndKind.OriginValue.Index(i).Interface()
-		}
-		return slice
-
-	default:
-		return []interface{}{any}
-	}
+	result, _ := defaultConverter.SliceAny(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }

util/gconv/gconv_slice_float.go

@@ -6,14 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // SliceFloat is alias of Floats.
 func SliceFloat(any interface{}) []float64 {
 	return Floats(any)
@@ -36,248 +28,16 @@ func Floats(any interface{}) []float64 {
 
 // Float32s converts `any` to []float32.
 func Float32s(any interface{}) []float32 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []float32 = nil
-	)
-	switch value := any.(type) {
-	case string:
-		if value == "" {
-			return []float32{}
-		}
-		return []float32{Float32(value)}
-	case []string:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []int:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []int8:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []int16:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []int32:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []int64:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []uint:
-		for _, v := range value {
-			array = append(array, Float32(v))
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]float32, len(value))
-			for k, v := range value {
-				array[k] = Float32(v)
-			}
-		}
-	case []uint16:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []uint32:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []uint64:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []bool:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []float32:
-		array = value
-	case []float64:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	case []interface{}:
-		array = make([]float32, len(value))
-		for k, v := range value {
-			array[k] = Float32(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IFloats); ok {
-		return Float32s(v.Floats())
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Float32s(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]float32, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Float32(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []float32{}
-		}
-		return []float32{Float32(any)}
-	}
+	result, _ := defaultConverter.SliceFloat32(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }
 
 // Float64s converts `any` to []float64.
 func Float64s(any interface{}) []float64 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []float64 = nil
-	)
-	switch value := any.(type) {
-	case string:
-		if value == "" {
-			return []float64{}
-		}
-		return []float64{Float64(value)}
-	case []string:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []int:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []int8:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []int16:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []int32:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []int64:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []uint:
-		for _, v := range value {
-			array = append(array, Float64(v))
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]float64, len(value))
-			for k, v := range value {
-				array[k] = Float64(v)
-			}
-		}
-	case []uint16:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []uint32:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []uint64:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []bool:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []float32:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	case []float64:
-		array = value
-	case []interface{}:
-		array = make([]float64, len(value))
-		for k, v := range value {
-			array[k] = Float64(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IFloats); ok {
-		return v.Floats()
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Floats(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]float64, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Float64(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []float64{}
-		}
-		return []float64{Float64(any)}
-	}
+	result, _ := defaultConverter.SliceFloat64(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }

util/gconv/gconv_slice_int.go

@@ -6,412 +6,41 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // SliceInt is alias of Ints.
-func SliceInt(any interface{}) []int {
+func SliceInt(any any) []int {
 	return Ints(any)
 }
 
 // SliceInt32 is alias of Int32s.
-func SliceInt32(any interface{}) []int32 {
+func SliceInt32(any any) []int32 {
 	return Int32s(any)
 }
 
 // SliceInt64 is alias of Int64s.
-func SliceInt64(any interface{}) []int64 {
+func SliceInt64(any any) []int64 {
 	return Int64s(any)
 }
 
 // Ints converts `any` to []int.
-func Ints(any interface{}) []int {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []int = nil
-	)
-	switch value := any.(type) {
-	case []string:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = Int(v)
-		}
-	case []int:
-		array = value
-	case []int8:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []int16:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []int32:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []int64:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []uint:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]int, len(value))
-			for k, v := range value {
-				array[k] = int(v)
-			}
-		}
-	case []uint16:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []uint32:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []uint64:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = int(v)
-		}
-	case []bool:
-		array = make([]int, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = Int(v)
-		}
-	case []float64:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = Int(v)
-		}
-	case []interface{}:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = Int(v)
-		}
-	case [][]byte:
-		array = make([]int, len(value))
-		for k, v := range value {
-			array[k] = Int(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IInts); ok {
-		return v.Ints()
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Ints(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]int, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Int(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []int{}
-		}
-		return []int{Int(any)}
-	}
+func Ints(any any) []int {
+	result, _ := defaultConverter.SliceInt(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }
 
 // Int32s converts `any` to []int32.
-func Int32s(any interface{}) []int32 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []int32 = nil
-	)
-	switch value := any.(type) {
-	case []string:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = Int32(v)
-		}
-	case []int:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []int8:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []int16:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []int32:
-		array = value
-	case []int64:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []uint:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]int32, len(value))
-			for k, v := range value {
-				array[k] = int32(v)
-			}
-		}
-	case []uint16:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []uint32:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []uint64:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = int32(v)
-		}
-	case []bool:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = Int32(v)
-		}
-	case []float64:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = Int32(v)
-		}
-	case []interface{}:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = Int32(v)
-		}
-	case [][]byte:
-		array = make([]int32, len(value))
-		for k, v := range value {
-			array[k] = Int32(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IInts); ok {
-		return Int32s(v.Ints())
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Int32s(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]int32, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Int32(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []int32{}
-		}
-		return []int32{Int32(any)}
-	}
+func Int32s(any any) []int32 {
+	result, _ := defaultConverter.SliceInt32(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }
 
 // Int64s converts `any` to []int64.
-func Int64s(any interface{}) []int64 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []int64 = nil
-	)
-	switch value := any.(type) {
-	case []string:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = Int64(v)
-		}
-	case []int:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []int8:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []int16:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []int32:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []int64:
-		array = value
-	case []uint:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]int64, len(value))
-			for k, v := range value {
-				array[k] = int64(v)
-			}
-		}
-	case []uint16:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []uint32:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []uint64:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = int64(v)
-		}
-	case []bool:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = Int64(v)
-		}
-	case []float64:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = Int64(v)
-		}
-	case []interface{}:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = Int64(v)
-		}
-	case [][]byte:
-		array = make([]int64, len(value))
-		for k, v := range value {
-			array[k] = Int64(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IInts); ok {
-		return Int64s(v.Ints())
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Int64s(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]int64, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Int64(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []int64{}
-		}
-		return []int64{Int64(any)}
-	}
+func Int64s(any any) []int64 {
+	result, _ := defaultConverter.SliceInt64(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }

util/gconv/gconv_slice_str.go

@@ -6,14 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // SliceStr is alias of Strings.
 func SliceStr(any interface{}) []string {
 	return Strings(any)
@@ -21,140 +13,8 @@ func SliceStr(any interface{}) []string {
 
 // Strings converts `any` to []string.
 func Strings(any interface{}) []string {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []string = nil
-	)
-	switch value := any.(type) {
-	case []int:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []int8:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []int16:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []int32:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []int64:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []uint:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		}
-		if array == nil {
-			array = make([]string, len(value))
-			for k, v := range value {
-				array[k] = String(v)
-			}
-			return array
-		}
-	case string:
-		byteValue := []byte(value)
-		if json.Valid(byteValue) {
-			_ = json.UnmarshalUseNumber(byteValue, &array)
-		}
-		if array == nil {
-			if value == "" {
-				return []string{}
-			}
-			// Prevent strings from being null
-			// See Issue 3465 for details
-			return []string{value}
-		}
-	case []uint16:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []uint32:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []uint64:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []bool:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []float32:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []float64:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []interface{}:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	case []string:
-		array = value
-	case [][]byte:
-		array = make([]string, len(value))
-		for k, v := range value {
-			array[k] = String(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	if v, ok := any.(localinterface.IStrings); ok {
-		return v.Strings()
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Strings(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]string, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = String(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []string{}
-		}
-		return []string{String(any)}
-	}
+	result, _ := defaultConverter.SliceStr(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }

util/gconv/gconv_slice_uint.go

@@ -6,16 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-	"strings"
-
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/reflection"
-	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // SliceUint is alias of Uints.
 func SliceUint(any interface{}) []uint {
 	return Uints(any)
@@ -33,405 +23,24 @@ func SliceUint64(any interface{}) []uint64 {
 
 // Uints converts `any` to []uint.
 func Uints(any interface{}) []uint {
-	if any == nil {
-		return nil
-	}
-
-	var (
-		array []uint = nil
-	)
-	switch value := any.(type) {
-	case string:
-		value = strings.TrimSpace(value)
-		if value == "" {
-			return []uint{}
-		}
-		if utils.IsNumeric(value) {
-			return []uint{Uint(value)}
-		}
-
-	case []string:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = Uint(v)
-		}
-	case []int8:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []int16:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []int32:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []int64:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []uint:
-		array = value
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]uint, len(value))
-			for k, v := range value {
-				array[k] = uint(v)
-			}
-		}
-	case []uint16:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []uint32:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []uint64:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = uint(v)
-		}
-	case []bool:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = Uint(v)
-		}
-	case []float64:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = Uint(v)
-		}
-	case []interface{}:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = Uint(v)
-		}
-	case [][]byte:
-		array = make([]uint, len(value))
-		for k, v := range value {
-			array[k] = Uint(v)
-		}
-	}
-
-	if array != nil {
-		return array
-	}
-
-	// Default handler.
-	if v, ok := any.(localinterface.IUints); ok {
-		return v.Uints()
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Uints(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]uint, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Uint(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []uint{}
-		}
-		return []uint{Uint(any)}
-	}
+	result, _ := defaultConverter.SliceUint(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }
 
 // Uint32s converts `any` to []uint32.
 func Uint32s(any interface{}) []uint32 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []uint32 = nil
-	)
-	switch value := any.(type) {
-	case string:
-		value = strings.TrimSpace(value)
-		if value == "" {
-			return []uint32{}
-		}
-		if utils.IsNumeric(value) {
-			return []uint32{Uint32(value)}
-		}
-	case []string:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = Uint32(v)
-		}
-	case []int8:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []int16:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []int32:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []int64:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []uint:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]uint32, len(value))
-			for k, v := range value {
-				array[k] = uint32(v)
-			}
-		}
-	case []uint16:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []uint32:
-		array = value
-	case []uint64:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = uint32(v)
-		}
-	case []bool:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = Uint32(v)
-		}
-	case []float64:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = Uint32(v)
-		}
-	case []interface{}:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = Uint32(v)
-		}
-	case [][]byte:
-		array = make([]uint32, len(value))
-		for k, v := range value {
-			array[k] = Uint32(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-
-	// Default handler.
-	if v, ok := any.(localinterface.IUints); ok {
-		return Uint32s(v.Uints())
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Uint32s(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]uint32, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Uint32(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []uint32{}
-		}
-		return []uint32{Uint32(any)}
-	}
+	result, _ := defaultConverter.SliceUint32(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }
 
 // Uint64s converts `any` to []uint64.
 func Uint64s(any interface{}) []uint64 {
-	if any == nil {
-		return nil
-	}
-	var (
-		array []uint64 = nil
-	)
-	switch value := any.(type) {
-	case string:
-		value = strings.TrimSpace(value)
-		if value == "" {
-			return []uint64{}
-		}
-		if utils.IsNumeric(value) {
-			return []uint64{Uint64(value)}
-		}
-
-	case []string:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = Uint64(v)
-		}
-	case []int8:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []int16:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []int32:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []int64:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []uint:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []uint8:
-		if json.Valid(value) {
-			_ = json.UnmarshalUseNumber(value, &array)
-		} else {
-			array = make([]uint64, len(value))
-			for k, v := range value {
-				array[k] = uint64(v)
-			}
-		}
-	case []uint16:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []uint32:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = uint64(v)
-		}
-	case []uint64:
-		array = value
-	case []bool:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			if v {
-				array[k] = 1
-			} else {
-				array[k] = 0
-			}
-		}
-	case []float32:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = Uint64(v)
-		}
-	case []float64:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = Uint64(v)
-		}
-	case []interface{}:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = Uint64(v)
-		}
-	case [][]byte:
-		array = make([]uint64, len(value))
-		for k, v := range value {
-			array[k] = Uint64(v)
-		}
-	}
-	if array != nil {
-		return array
-	}
-	// Default handler.
-	if v, ok := any.(localinterface.IUints); ok {
-		return Uint64s(v.Uints())
-	}
-	if v, ok := any.(localinterface.IInterfaces); ok {
-		return Uint64s(v.Interfaces())
-	}
-	// JSON format string value converting.
-	if checkJsonAndUnmarshalUseNumber(any, &array) {
-		return array
-	}
-	// Not a common type, it then uses reflection for conversion.
-	originValueAndKind := reflection.OriginValueAndKind(any)
-	switch originValueAndKind.OriginKind {
-	case reflect.Slice, reflect.Array:
-		var (
-			length = originValueAndKind.OriginValue.Len()
-			slice  = make([]uint64, length)
-		)
-		for i := 0; i < length; i++ {
-			slice[i] = Uint64(originValueAndKind.OriginValue.Index(i).Interface())
-		}
-		return slice
-
-	default:
-		if originValueAndKind.OriginValue.IsZero() {
-			return []uint64{}
-		}
-		return []uint64{Uint64(any)}
-	}
+	result, _ := defaultConverter.SliceUint64(any, SliceOption{
+		ContinueOnError: true,
+	})
+	return result
 }

util/gconv/gconv_struct.go

@@ -6,19 +6,6 @@
 
 package gconv
 
-import (
-	"reflect"
-	"strings"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-	"github.com/gogf/gf/v2/util/gconv/internal/structcache"
-)
-
 // Struct maps the params key-value pairs to the corresponding struct object's attributes.
 // The third parameter `mapping` is unnecessary, indicating the mapping rules between the
 // custom key name and the attribute name(case-sensitive).
@@ -32,609 +19,17 @@ import (
 //     It will automatically convert the first letter of the key to uppercase
 //     in mapping procedure to do the matching.
 //     It ignores the map key, if it does not match.
-func Struct(params interface{}, pointer interface{}, paramKeyToAttrMap ...map[string]string) (err error) {
+func Struct(params any, pointer any, paramKeyToAttrMap ...map[string]string) (err error) {
 	return Scan(params, pointer, paramKeyToAttrMap...)
 }
 
 // StructTag acts as Struct but also with support for priority tag feature, which retrieves the
 // specified priorityTagAndFieldName for `params` key-value items to struct attribute names mapping.
 // The parameter `priorityTag` supports multiple priorityTagAndFieldName that can be joined with char ','.
-func StructTag(params interface{}, pointer interface{}, priorityTag string) (err error) {
-	return doStruct(params, pointer, nil, priorityTag)
-}
-
-// doStruct is the core internal converting function for any data to struct.
-func doStruct(
-	params interface{}, pointer interface{}, paramKeyToAttrMap map[string]string, priorityTag string,
-) (err error) {
-	if params == nil {
-		// If `params` is nil, no conversion.
-		return nil
-	}
-	if pointer == nil {
-		return gerror.NewCode(gcode.CodeInvalidParameter, "object pointer cannot be nil")
-	}
-
-	// JSON content converting.
-	ok, err := doConvertWithJsonCheck(params, pointer)
-	if err != nil {
-		return err
-	}
-	if ok {
-		return nil
-	}
-
-	defer func() {
-		// Catch the panic, especially the reflection operation panics.
-		if exception := recover(); exception != nil {
-			if v, ok := exception.(error); ok && gerror.HasStack(v) {
-				err = v
-			} else {
-				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
-			}
-		}
-	}()
-
-	var (
-		paramsReflectValue      reflect.Value
-		paramsInterface         interface{} // DO NOT use `params` directly as it might be type `reflect.Value`
-		pointerReflectValue     reflect.Value
-		pointerReflectKind      reflect.Kind
-		pointerElemReflectValue reflect.Value // The reflection value to struct element.
-	)
-	if v, ok := params.(reflect.Value); ok {
-		paramsReflectValue = v
-	} else {
-		paramsReflectValue = reflect.ValueOf(params)
-	}
-	paramsInterface = paramsReflectValue.Interface()
-	if v, ok := pointer.(reflect.Value); ok {
-		pointerReflectValue = v
-		pointerElemReflectValue = v
-	} else {
-		pointerReflectValue = reflect.ValueOf(pointer)
-		pointerReflectKind = pointerReflectValue.Kind()
-		if pointerReflectKind != reflect.Ptr {
-			return gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				"destination pointer should be type of '*struct', but got '%v'",
-				pointerReflectKind,
-			)
-		}
-		// Using IsNil on reflect.Ptr variable is OK.
-		if !pointerReflectValue.IsValid() || pointerReflectValue.IsNil() {
-			return gerror.NewCode(
-				gcode.CodeInvalidParameter,
-				"destination pointer cannot be nil",
-			)
-		}
-		pointerElemReflectValue = pointerReflectValue.Elem()
-	}
-
-	// If `params` and `pointer` are the same type, the do directly assignment.
-	// For performance enhancement purpose.
-	if ok = doConvertWithTypeCheck(paramsReflectValue, pointerElemReflectValue); ok {
-		return nil
-	}
-
-	// custom convert.
-	if ok, err = callCustomConverter(paramsReflectValue, pointerReflectValue); ok {
-		return err
-	}
-
-	// Normal unmarshalling interfaces checks.
-	if ok, err = bindVarToReflectValueWithInterfaceCheck(pointerReflectValue, paramsInterface); ok {
-		return err
-	}
-
-	// It automatically creates struct object if necessary.
-	// For example, if `pointer` is **User, then `elem` is *User, which is a pointer to User.
-	if pointerElemReflectValue.Kind() == reflect.Ptr {
-		if !pointerElemReflectValue.IsValid() || pointerElemReflectValue.IsNil() {
-			e := reflect.New(pointerElemReflectValue.Type().Elem())
-			pointerElemReflectValue.Set(e)
-			defer func() {
-				if err != nil {
-					// If it is converted failed, it reset the `pointer` to nil.
-					pointerReflectValue.Elem().Set(reflect.Zero(pointerReflectValue.Type().Elem()))
-				}
-			}()
-		}
-		// if v, ok := pointerElemReflectValue.Interface().(localinterface.IUnmarshalValue); ok {
-		//	return v.UnmarshalValue(params)
-		// }
-		// Note that it's `pointerElemReflectValue` here not `pointerReflectValue`.
-		if ok, err = bindVarToReflectValueWithInterfaceCheck(pointerElemReflectValue, paramsInterface); ok {
-			return err
-		}
-		// Retrieve its element, may be struct at last.
-		pointerElemReflectValue = pointerElemReflectValue.Elem()
-	}
-	paramsMap, ok := paramsInterface.(map[string]interface{})
-	if !ok {
-		// paramsMap is the map[string]interface{} type variable for params.
-		// DO NOT use MapDeep here.
-		paramsMap = doMapConvert(paramsInterface, recursiveTypeAuto, true)
-		if paramsMap == nil {
-			return gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				`convert params from "%#v" to "map[string]interface{}" failed`,
-				params,
-			)
-		}
-	}
-	// Nothing to be done as the parameters are empty.
-	if len(paramsMap) == 0 {
-		return nil
-	}
-	// Get struct info from cache or parse struct and cache the struct info.
-	cachedStructInfo := structcache.GetCachedStructInfo(
-		pointerElemReflectValue.Type(), priorityTag,
-	)
-	// Nothing to be converted.
-	if cachedStructInfo == nil {
-		return nil
-	}
-	// For the structure types of 0 tagOrFiledNameToFieldInfoMap,
-	// they also need to be cached to prevent invalid logic
-	if cachedStructInfo.HasNoFields() {
-		return nil
-	}
-	var (
-		// Indicates that those values have been used and cannot be reused.
-		usedParamsKeyOrTagNameMap = structcache.GetUsedParamsKeyOrTagNameMapFromPool()
-		cachedFieldInfo           *structcache.CachedFieldInfo
-		paramsValue               interface{}
-	)
-	defer structcache.PutUsedParamsKeyOrTagNameMapToPool(usedParamsKeyOrTagNameMap)
-
-	// Firstly, search according to custom mapping rules.
-	// If a possible direct assignment is found, reduce the number of subsequent map searches.
-	for paramKey, fieldName := range paramKeyToAttrMap {
-		paramsValue, ok = paramsMap[paramKey]
-		if !ok {
-			continue
-		}
-		cachedFieldInfo = cachedStructInfo.GetFieldInfo(fieldName)
-		if cachedFieldInfo != nil {
-			fieldValue := cachedFieldInfo.GetFieldReflectValueFrom(pointerElemReflectValue)
-			if err = bindVarToStructField(
-				fieldValue,
-				paramsValue,
-				cachedFieldInfo,
-				paramKeyToAttrMap,
-			); err != nil {
-				return err
-			}
-			if len(cachedFieldInfo.OtherSameNameField) > 0 {
-				if err = setOtherSameNameField(
-					cachedFieldInfo, paramsValue, pointerReflectValue, paramKeyToAttrMap,
-				); err != nil {
-					return err
-				}
-			}
-			usedParamsKeyOrTagNameMap[paramKey] = struct{}{}
-		}
-	}
-	// Already done converting for given `paramsMap`.
-	if len(usedParamsKeyOrTagNameMap) == len(paramsMap) {
-		return nil
-	}
-	return bindStructWithLoopFieldInfos(
-		paramsMap, pointerElemReflectValue, paramKeyToAttrMap, usedParamsKeyOrTagNameMap, cachedStructInfo,
-	)
-}
-
-func setOtherSameNameField(
-	cachedFieldInfo *structcache.CachedFieldInfo,
-	srcValue any,
-	structValue reflect.Value,
-	paramKeyToAttrMap map[string]string,
-) (err error) {
-	// loop the same field name of all sub attributes.
-	for _, otherFieldInfo := range cachedFieldInfo.OtherSameNameField {
-		fieldValue := cachedFieldInfo.GetOtherFieldReflectValueFrom(structValue, otherFieldInfo.FieldIndexes)
-		if err = bindVarToStructField(fieldValue, srcValue, otherFieldInfo, paramKeyToAttrMap); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func bindStructWithLoopFieldInfos(
-	paramsMap map[string]any,
-	structValue reflect.Value,
-	paramKeyToAttrMap map[string]string,
-	usedParamsKeyOrTagNameMap map[string]struct{},
-	cachedStructInfo *structcache.CachedStructInfo,
-) (err error) {
-	var (
-		cachedFieldInfo *structcache.CachedFieldInfo
-		fuzzLastKey     string
-		fieldValue      reflect.Value
-		paramKey        string
-		paramValue      any
-		matched         bool
-		ok              bool
-	)
-	for _, cachedFieldInfo = range cachedStructInfo.FieldConvertInfos {
-		for _, fieldTag := range cachedFieldInfo.PriorityTagAndFieldName {
-			if paramValue, ok = paramsMap[fieldTag]; !ok {
-				continue
-			}
-			fieldValue = cachedFieldInfo.GetFieldReflectValueFrom(structValue)
-			if err = bindVarToStructField(
-				fieldValue, paramValue, cachedFieldInfo, paramKeyToAttrMap,
-			); err != nil {
-				return err
-			}
-			// handle same field name in nested struct.
-			if len(cachedFieldInfo.OtherSameNameField) > 0 {
-				if err = setOtherSameNameField(
-					cachedFieldInfo, paramValue, structValue, paramKeyToAttrMap,
-				); err != nil {
-					return err
-				}
-			}
-			usedParamsKeyOrTagNameMap[fieldTag] = struct{}{}
-			matched = true
-			break
-		}
-		if matched {
-			matched = false
-			continue
-		}
-
-		fuzzLastKey = cachedFieldInfo.LastFuzzyKey.Load().(string)
-		if paramValue, ok = paramsMap[fuzzLastKey]; !ok {
-			paramKey, paramValue = fuzzyMatchingFieldName(
-				cachedFieldInfo.RemoveSymbolsFieldName, paramsMap, usedParamsKeyOrTagNameMap,
-			)
-			ok = paramKey != ""
-			cachedFieldInfo.LastFuzzyKey.Store(paramKey)
-		}
-		if ok {
-			fieldValue = cachedFieldInfo.GetFieldReflectValueFrom(structValue)
-			if paramValue != nil {
-				if err = bindVarToStructField(
-					fieldValue, paramValue, cachedFieldInfo, paramKeyToAttrMap,
-				); err != nil {
-					return err
-				}
-				// handle same field name in nested struct.
-				if len(cachedFieldInfo.OtherSameNameField) > 0 {
-					if err = setOtherSameNameField(
-						cachedFieldInfo, paramValue, structValue, paramKeyToAttrMap,
-					); err != nil {
-						return err
-					}
-				}
-			}
-			usedParamsKeyOrTagNameMap[paramKey] = struct{}{}
-		}
-	}
-	return nil
-}
-
-// fuzzy matching rule:
-// to match field name and param key in case-insensitive and without symbols.
-func fuzzyMatchingFieldName(
-	fieldName string,
-	paramsMap map[string]any,
-	usedParamsKeyMap map[string]struct{},
-) (string, any) {
-	for paramKey, paramValue := range paramsMap {
-		if _, ok := usedParamsKeyMap[paramKey]; ok {
-			continue
-		}
-		removeParamKeyUnderline := utils.RemoveSymbols(paramKey)
-		if strings.EqualFold(fieldName, removeParamKeyUnderline) {
-			return paramKey, paramValue
-		}
-	}
-	return "", nil
-}
-
-// bindVarToStructField sets value to struct object attribute by name.
-func bindVarToStructField(
-	fieldValue reflect.Value,
-	srcValue interface{},
-	cachedFieldInfo *structcache.CachedFieldInfo,
-	paramKeyToAttrMap map[string]string,
-) (err error) {
-	if !fieldValue.IsValid() {
-		return nil
-	}
-	// CanSet checks whether attribute is public accessible.
-	if !fieldValue.CanSet() {
-		return nil
-	}
-	defer func() {
-		if exception := recover(); exception != nil {
-			if err = bindVarToReflectValue(fieldValue, srcValue, paramKeyToAttrMap); err != nil {
-				err = gerror.Wrapf(err, `error binding srcValue to attribute "%s"`, cachedFieldInfo.FieldName())
-			}
-		}
-	}()
-	// Directly converting.
-	if empty.IsNil(srcValue) {
-		fieldValue.Set(reflect.Zero(fieldValue.Type()))
-		return nil
-	}
-	// Try to call custom converter.
-	// Issue: https://github.com/gogf/gf/issues/3099
-	var (
-		customConverterInput reflect.Value
-		ok                   bool
-	)
-	if cachedFieldInfo.HasCustomConvert {
-		if customConverterInput, ok = srcValue.(reflect.Value); !ok {
-			customConverterInput = reflect.ValueOf(srcValue)
-		}
-		if ok, err = callCustomConverter(customConverterInput, fieldValue); ok || err != nil {
-			return
-		}
-	}
-	if cachedFieldInfo.IsCommonInterface {
-		if ok, err = bindVarToReflectValueWithInterfaceCheck(fieldValue, srcValue); ok || err != nil {
-			return
-		}
-	}
-	// Common types use fast assignment logic
-	if cachedFieldInfo.ConvertFunc != nil {
-		cachedFieldInfo.ConvertFunc(srcValue, fieldValue)
-		return nil
-	}
-	doConvertWithReflectValueSet(fieldValue, doConvertInput{
-		FromValue:  srcValue,
-		ToTypeName: cachedFieldInfo.StructField.Type.String(),
-		ReferValue: fieldValue,
-	})
-	return nil
-}
-
-// bindVarToReflectValueWithInterfaceCheck does bind using common interfaces checks.
-func bindVarToReflectValueWithInterfaceCheck(reflectValue reflect.Value, value interface{}) (bool, error) {
-	var pointer interface{}
-	if reflectValue.Kind() != reflect.Ptr && reflectValue.CanAddr() {
-		reflectValueAddr := reflectValue.Addr()
-		if reflectValueAddr.IsNil() || !reflectValueAddr.IsValid() {
-			return false, nil
-		}
-		// Not a pointer, but can token address, that makes it can be unmarshalled.
-		pointer = reflectValue.Addr().Interface()
-	} else {
-		if reflectValue.IsNil() || !reflectValue.IsValid() {
-			return false, nil
-		}
-		pointer = reflectValue.Interface()
-	}
-	// UnmarshalValue.
-	if v, ok := pointer.(localinterface.IUnmarshalValue); ok {
-		return ok, v.UnmarshalValue(value)
-	}
-	// UnmarshalText.
-	if v, ok := pointer.(localinterface.IUnmarshalText); ok {
-		var valueBytes []byte
-		if b, ok := value.([]byte); ok {
-			valueBytes = b
-		} else if s, ok := value.(string); ok {
-			valueBytes = []byte(s)
-		} else if f, ok := value.(localinterface.IString); ok {
-			valueBytes = []byte(f.String())
-		}
-		if len(valueBytes) > 0 {
-			return ok, v.UnmarshalText(valueBytes)
-		}
-	}
-	// UnmarshalJSON.
-	if v, ok := pointer.(localinterface.IUnmarshalJSON); ok {
-		var valueBytes []byte
-		if b, ok := value.([]byte); ok {
-			valueBytes = b
-		} else if s, ok := value.(string); ok {
-			valueBytes = []byte(s)
-		} else if f, ok := value.(localinterface.IString); ok {
-			valueBytes = []byte(f.String())
-		}
-
-		if len(valueBytes) > 0 {
-			// If it is not a valid JSON string, it then adds char `"` on its both sides to make it is.
-			if !json.Valid(valueBytes) {
-				newValueBytes := make([]byte, len(valueBytes)+2)
-				newValueBytes[0] = '"'
-				newValueBytes[len(newValueBytes)-1] = '"'
-				copy(newValueBytes[1:], valueBytes)
-				valueBytes = newValueBytes
-			}
-			return ok, v.UnmarshalJSON(valueBytes)
-		}
-	}
-	if v, ok := pointer.(localinterface.ISet); ok {
-		v.Set(value)
-		return ok, nil
-	}
-	return false, nil
-}
-
-// bindVarToReflectValue sets `value` to reflect value object `structFieldValue`.
-func bindVarToReflectValue(
-	structFieldValue reflect.Value, value interface{}, paramKeyToAttrMap map[string]string,
-) (err error) {
-	// JSON content converting.
-	ok, err := doConvertWithJsonCheck(value, structFieldValue)
-	if err != nil {
-		return err
-	}
-	if ok {
-		return nil
-	}
-
-	kind := structFieldValue.Kind()
-	// Converting using `Set` interface implements, for some types.
-	switch kind {
-	case reflect.Slice, reflect.Array, reflect.Ptr, reflect.Interface:
-		if !structFieldValue.IsNil() {
-			if v, ok := structFieldValue.Interface().(localinterface.ISet); ok {
-				v.Set(value)
-				return nil
-			}
-		}
-	}
-
-	// Converting using reflection by kind.
-	switch kind {
-	case reflect.Map:
-		return doMapToMap(value, structFieldValue, paramKeyToAttrMap)
-
-	case reflect.Struct:
-		// Recursively converting for struct attribute.
-		if err = doStruct(value, structFieldValue, nil, ""); err != nil {
-			// Note there's reflect conversion mechanism here.
-			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
-		}
-
-	// Note that the slice element might be type of struct,
-	// so it uses Struct function doing the converting internally.
-	case reflect.Slice, reflect.Array:
-		var (
-			reflectArray reflect.Value
-			reflectValue = reflect.ValueOf(value)
-		)
-		if reflectValue.Kind() == reflect.Slice || reflectValue.Kind() == reflect.Array {
-			reflectArray = reflect.MakeSlice(structFieldValue.Type(), reflectValue.Len(), reflectValue.Len())
-			if reflectValue.Len() > 0 {
-				var (
-					elemType     = reflectArray.Index(0).Type()
-					elemTypeName string
-					converted    bool
-				)
-				for i := 0; i < reflectValue.Len(); i++ {
-					converted = false
-					elemTypeName = elemType.Name()
-					if elemTypeName == "" {
-						elemTypeName = elemType.String()
-					}
-					var elem reflect.Value
-					if elemType.Kind() == reflect.Ptr {
-						elem = reflect.New(elemType.Elem()).Elem()
-					} else {
-						elem = reflect.New(elemType).Elem()
-					}
-					if elem.Kind() == reflect.Struct {
-						if err = doStruct(reflectValue.Index(i).Interface(), elem, nil, ""); err == nil {
-							converted = true
-						}
-					}
-					if !converted {
-						doConvertWithReflectValueSet(elem, doConvertInput{
-							FromValue:  reflectValue.Index(i).Interface(),
-							ToTypeName: elemTypeName,
-							ReferValue: elem,
-						})
-					}
-					if elemType.Kind() == reflect.Ptr {
-						// Before it sets the `elem` to array, do pointer converting if necessary.
-						elem = elem.Addr()
-					}
-					reflectArray.Index(i).Set(elem)
-				}
-			}
-		} else {
-			var (
-				elem         reflect.Value
-				elemType     = structFieldValue.Type().Elem()
-				elemTypeName = elemType.Name()
-				converted    bool
-			)
-			switch reflectValue.Kind() {
-			case reflect.String:
-				// Value is empty string.
-				if reflectValue.IsZero() {
-					var elemKind = elemType.Kind()
-					// Try to find the original type kind of the slice element.
-					if elemKind == reflect.Ptr {
-						elemKind = elemType.Elem().Kind()
-					}
-					switch elemKind {
-					case reflect.String:
-						// Empty string cannot be assigned to string slice.
-						return nil
-					}
-				}
-			}
-			if elemTypeName == "" {
-				elemTypeName = elemType.String()
-			}
-			if elemType.Kind() == reflect.Ptr {
-				elem = reflect.New(elemType.Elem()).Elem()
-			} else {
-				elem = reflect.New(elemType).Elem()
-			}
-			if elem.Kind() == reflect.Struct {
-				if err = doStruct(value, elem, nil, ""); err == nil {
-					converted = true
-				}
-			}
-			if !converted {
-				doConvertWithReflectValueSet(elem, doConvertInput{
-					FromValue:  value,
-					ToTypeName: elemTypeName,
-					ReferValue: elem,
-				})
-			}
-			if elemType.Kind() == reflect.Ptr {
-				// Before it sets the `elem` to array, do pointer converting if necessary.
-				elem = elem.Addr()
-			}
-			reflectArray = reflect.MakeSlice(structFieldValue.Type(), 1, 1)
-			reflectArray.Index(0).Set(elem)
-		}
-		structFieldValue.Set(reflectArray)
-
-	case reflect.Ptr:
-		if structFieldValue.IsNil() || structFieldValue.IsZero() {
-			// Nil or empty pointer, it creates a new one.
-			item := reflect.New(structFieldValue.Type().Elem())
-			if ok, err = bindVarToReflectValueWithInterfaceCheck(item, value); ok {
-				structFieldValue.Set(item)
-				return err
-			}
-			elem := item.Elem()
-			if err = bindVarToReflectValue(elem, value, paramKeyToAttrMap); err == nil {
-				structFieldValue.Set(elem.Addr())
-			}
-		} else {
-			// Not empty pointer, it assigns values to it.
-			return bindVarToReflectValue(structFieldValue.Elem(), value, paramKeyToAttrMap)
-		}
-
-	// It mainly and specially handles the interface of nil value.
-	case reflect.Interface:
-		if value == nil {
-			// Specially.
-			structFieldValue.Set(reflect.ValueOf((*interface{})(nil)))
-		} else {
-			// Note there's reflect conversion mechanism here.
-			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
-		}
-
-	default:
-		defer func() {
-			if exception := recover(); exception != nil {
-				err = gerror.NewCodef(
-					gcode.CodeInternalPanic,
-					`cannot convert value "%+v" to type "%s":%+v`,
-					value,
-					structFieldValue.Type().String(),
-					exception,
-				)
-			}
-		}()
-		// It here uses reflect converting `value` to type of the attribute and assigns
-		// the result value to the attribute. It might fail and panic if the usual Go
-		// conversion rules do not allow conversion.
-		structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
-	}
-	return nil
+func StructTag(params any, pointer any, priorityTag string) (err error) {
+	option := StructOption{
+		PriorityTag:     priorityTag,
+		ContinueOnError: true,
+	}
+	return defaultConverter.Struct(params, pointer, option)
 }

util/gconv/gconv_structs.go

@@ -6,128 +6,25 @@
 
 package gconv
 
-import (
-	"reflect"
-
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-)
-
 // Structs converts any slice to given struct slice.
 // Also see Scan, Struct.
-func Structs(params interface{}, pointer interface{}, paramKeyToAttrMap ...map[string]string) (err error) {
+func Structs(params any, pointer any, paramKeyToAttrMap ...map[string]string) (err error) {
 	return Scan(params, pointer, paramKeyToAttrMap...)
 }
 
 // SliceStruct is alias of Structs.
-func SliceStruct(params interface{}, pointer interface{}, mapping ...map[string]string) (err error) {
+func SliceStruct(params any, pointer any, mapping ...map[string]string) (err error) {
 	return Structs(params, pointer, mapping...)
 }
 
 // StructsTag acts as Structs but also with support for priority tag feature, which retrieves the
 // specified priorityTagAndFieldName for `params` key-value items to struct attribute names mapping.
 // The parameter `priorityTag` supports multiple priorityTagAndFieldName that can be joined with char ','.
-func StructsTag(params interface{}, pointer interface{}, priorityTag string) (err error) {
-	return doStructs(params, pointer, nil, priorityTag)
-}
-
-// doStructs converts any slice to given struct slice.
-//
-// It automatically checks and converts json string to []map if `params` is string/[]byte.
-//
-// The parameter `pointer` should be type of pointer to slice of struct.
-// Note that if `pointer` is a pointer to another pointer of type of slice of struct,
-// it will create the struct/pointer internally.
-func doStructs(
-	params interface{}, pointer interface{}, paramKeyToAttrMap map[string]string, priorityTag string,
-) (err error) {
-	defer func() {
-		// Catch the panic, especially the reflection operation panics.
-		if exception := recover(); exception != nil {
-			if v, ok := exception.(error); ok && gerror.HasStack(v) {
-				err = v
-			} else {
-				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
-			}
-		}
-	}()
-
-	// Pointer type check.
-	pointerRv, ok := pointer.(reflect.Value)
-	if !ok {
-		pointerRv = reflect.ValueOf(pointer)
-		if kind := pointerRv.Kind(); kind != reflect.Ptr {
-			return gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				"pointer should be type of pointer, but got: %v", kind,
-			)
-		}
-	}
-	// Converting `params` to map slice.
-	var (
-		paramsList []interface{}
-		paramsRv   = reflect.ValueOf(params)
-		paramsKind = paramsRv.Kind()
-	)
-	for paramsKind == reflect.Ptr {
-		paramsRv = paramsRv.Elem()
-		paramsKind = paramsRv.Kind()
-	}
-	switch paramsKind {
-	case reflect.Slice, reflect.Array:
-		paramsList = make([]interface{}, paramsRv.Len())
-		for i := 0; i < paramsRv.Len(); i++ {
-			paramsList[i] = paramsRv.Index(i).Interface()
-		}
-	default:
-		var paramsMaps = Maps(params)
-		paramsList = make([]interface{}, len(paramsMaps))
-		for i := 0; i < len(paramsMaps); i++ {
-			paramsList[i] = paramsMaps[i]
-		}
-	}
-	// If `params` is an empty slice, no conversion.
-	if len(paramsList) == 0 {
-		return nil
-	}
-	var (
-		reflectElemArray = reflect.MakeSlice(pointerRv.Type().Elem(), len(paramsList), len(paramsList))
-		itemType         = reflectElemArray.Index(0).Type()
-		itemTypeKind     = itemType.Kind()
-		pointerRvElem    = pointerRv.Elem()
-		pointerRvLength  = pointerRvElem.Len()
-	)
-	if itemTypeKind == reflect.Ptr {
-		// Pointer element.
-		for i := 0; i < len(paramsList); i++ {
-			var tempReflectValue reflect.Value
-			if i < pointerRvLength {
-				// Might be nil.
-				tempReflectValue = pointerRvElem.Index(i).Elem()
-			}
-			if !tempReflectValue.IsValid() {
-				tempReflectValue = reflect.New(itemType.Elem()).Elem()
-			}
-			if err = doStruct(paramsList[i], tempReflectValue, paramKeyToAttrMap, priorityTag); err != nil {
-				return err
-			}
-			reflectElemArray.Index(i).Set(tempReflectValue.Addr())
-		}
-	} else {
-		// Struct element.
-		for i := 0; i < len(paramsList); i++ {
-			var tempReflectValue reflect.Value
-			if i < pointerRvLength {
-				tempReflectValue = pointerRvElem.Index(i)
-			} else {
-				tempReflectValue = reflect.New(itemType).Elem()
-			}
-			if err = doStruct(paramsList[i], tempReflectValue, paramKeyToAttrMap, priorityTag); err != nil {
-				return err
-			}
-			reflectElemArray.Index(i).Set(tempReflectValue)
-		}
-	}
-	pointerRv.Elem().Set(reflectElemArray)
-	return nil
+func StructsTag(params any, pointer any, priorityTag string) (err error) {
+	return defaultConverter.Structs(params, pointer, SliceOption{
+		ContinueOnError: true,
+	}, StructOption{
+		PriorityTag:     priorityTag,
+		ContinueOnError: true,
+	})
 }

util/gconv/gconv_time.go

@@ -9,39 +9,21 @@ package gconv
 import (
 	"time"
 
-	"github.com/gogf/gf/v2/internal/utils"
 	"github.com/gogf/gf/v2/os/gtime"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
 )
 
 // Time converts `any` to time.Time.
-func Time(any interface{}, format ...string) time.Time {
-	// It's already this type.
-	if len(format) == 0 {
-		if v, ok := any.(time.Time); ok {
-			return v
-		}
-	}
-	if t := GTime(any, format...); t != nil {
-		return t.Time
-	}
-	return time.Time{}
+func Time(any any, format ...string) time.Time {
+	t, _ := defaultConverter.Time(any, format...)
+	return t
 }
 
 // Duration converts `any` to time.Duration.
 // If `any` is string, then it uses time.ParseDuration to convert it.
 // If `any` is numeric, then it converts `any` as nanoseconds.
-func Duration(any interface{}) time.Duration {
-	// It's already this type.
-	if v, ok := any.(time.Duration); ok {
-		return v
-	}
-	s := String(any)
-	if !utils.IsNumeric(s) {
-		d, _ := gtime.ParseDuration(s)
+func Duration(any any) time.Duration {
+	d, _ := defaultConverter.Duration(any)
 	return d
-	}
-	return time.Duration(Int64(any))
 }
 
 // GTime converts `any` to *gtime.Time.
@@ -49,43 +31,7 @@ func Duration(any interface{}) time.Duration {
 // It returns the converted value that matched the first format of the formats slice.
 // If no `format` given, it converts `any` using gtime.NewFromTimeStamp if `any` is numeric,
 // or using gtime.StrToTime if `any` is string.
-func GTime(any interface{}, format ...string) *gtime.Time {
-	if any == nil {
-		return nil
-	}
-	if v, ok := any.(localinterface.IGTime); ok {
-		return v.GTime(format...)
-	}
-	// It's already this type.
-	if len(format) == 0 {
-		if v, ok := any.(*gtime.Time); ok {
-			return v
-		}
-		if t, ok := any.(time.Time); ok {
-			return gtime.New(t)
-		}
-		if t, ok := any.(*time.Time); ok {
-			return gtime.New(t)
-		}
-	}
-	s := String(any)
-	if len(s) == 0 {
-		return gtime.New()
-	}
-	// Priority conversion using given format.
-	if len(format) > 0 {
-		for _, item := range format {
-			t, err := gtime.StrToTimeFormat(s, item)
-			if t != nil && err == nil {
+func GTime(any any, format ...string) *gtime.Time {
+	t, _ := defaultConverter.GTime(any, format...)
 	return t
-			}
-		}
-		return nil
-	}
-	if utils.IsNumeric(s) {
-		return gtime.NewFromTimeStamp(Int64(s))
-	} else {
-		t, _ := gtime.StrToTime(s)
-		return t
-	}
 }

util/gconv/gconv_uint.go

@@ -6,180 +6,32 @@
 
 package gconv
 
-import (
-	"math"
-	"reflect"
-	"strconv"
-
-	"github.com/gogf/gf/v2/encoding/gbinary"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
-)
-
 // Uint converts `any` to uint.
 func Uint(any any) uint {
-	v, _ := doUint(any)
+	v, _ := defaultConverter.Uint(any)
 	return v
 }
 
-func doUint(any any) (uint, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(uint); ok {
-		return v, nil
-	}
-	v, err := doUint64(any)
-	return uint(v), err
-}
-
 // Uint8 converts `any` to uint8.
 func Uint8(any any) uint8 {
-	v, _ := doUint8(any)
+	v, _ := defaultConverter.Uint8(any)
 	return v
 }
 
-func doUint8(any any) (uint8, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(uint8); ok {
-		return v, nil
-	}
-	v, err := doUint64(any)
-	return uint8(v), err
-}
-
 // Uint16 converts `any` to uint16.
 func Uint16(any any) uint16 {
-	v, _ := doUint16(any)
+	v, _ := defaultConverter.Uint16(any)
 	return v
 }
 
-func doUint16(any any) (uint16, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(uint16); ok {
-		return v, nil
-	}
-	v, err := doUint64(any)
-	return uint16(v), err
-}
-
 // Uint32 converts `any` to uint32.
 func Uint32(any any) uint32 {
-	v, _ := doUint32(any)
+	v, _ := defaultConverter.Uint32(any)
 	return v
 }
 
-func doUint32(any any) (uint32, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(uint32); ok {
-		return v, nil
-	}
-	v, err := doUint64(any)
-	return uint32(v), err
-}
-
 // Uint64 converts `any` to uint64.
 func Uint64(any any) uint64 {
-	v, _ := doUint64(any)
+	v, _ := defaultConverter.Uint64(any)
 	return v
 }
-
-func doUint64(any any) (uint64, error) {
-	if any == nil {
-		return 0, nil
-	}
-	if v, ok := any.(uint64); ok {
-		return v, nil
-	}
-	rv := reflect.ValueOf(any)
-	switch rv.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		val := rv.Int()
-		if val < 0 {
-			return uint64(val), gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				`cannot convert negative value "%d" to uint64`,
-				val,
-			)
-		}
-		return uint64(val), nil
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return rv.Uint(), nil
-	case reflect.Uintptr:
-		return rv.Uint(), nil
-	case reflect.Float32, reflect.Float64:
-		val := rv.Float()
-		if val < 0 {
-			return uint64(val), gerror.NewCodef(
-				gcode.CodeInvalidParameter,
-				`cannot convert negative value "%f" to uint64`,
-				val,
-			)
-		}
-		return uint64(val), nil
-	case reflect.Bool:
-		if rv.Bool() {
-			return 1, nil
-		}
-		return 0, nil
-	case reflect.Ptr:
-		if rv.IsNil() {
-			return 0, nil
-		}
-		if f, ok := any.(localinterface.IUint64); ok {
-			return f.Uint64(), nil
-		}
-		return doUint64(rv.Elem().Interface())
-	case reflect.Slice:
-		if rv.Type().Elem().Kind() == reflect.Uint8 {
-			return gbinary.DecodeToUint64(rv.Bytes()), nil
-		}
-		return 0, gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			`unsupport slice type "%s" for converting to uint64`,
-			rv.Type().String(),
-		)
-	case reflect.String:
-		var s = rv.String()
-		// Hexadecimal
-		if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
-			v, err := strconv.ParseUint(s[2:], 16, 64)
-			if err == nil {
-				return v, nil
-			}
-			return 0, gerror.WrapCodef(
-				gcode.CodeInvalidParameter,
-				err,
-				`cannot convert hexadecimal string "%s" to uint64`,
-				s,
-			)
-		}
-		// Decimal
-		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
-			return v, nil
-		}
-		// Float64
-		if v, err := doFloat64(any); err == nil {
-			if math.IsNaN(v) {
-				return 0, nil
-			}
-			return uint64(v), nil
-		}
-	default:
-		if f, ok := any.(localinterface.IUint64); ok {
-			return f.Uint64(), nil
-		}
-	}
-	return 0, gerror.NewCodef(
-		gcode.CodeInvalidParameter,
-		`unsupport value type "%s" for converting to uint64`,
-		reflect.TypeOf(any).String(),
-	)
-}

util/gconv/gconv_z_bench_struct_test.go

@@ -92,7 +92,7 @@ func Benchmark_Struct_Basic(b *testing.B) {
 
 func Benchmark_doStruct_Fields8_Basic_MapToStruct(b *testing.B) {
 	for i := 0; i < b.N; i++ {
-		doStruct(structMapFields8, structPointer8, map[string]string{}, "")
+		defaultConverter.Struct(structMapFields8, structPointer8, StructOption{})
 	}
 }
 

util/gconv/gconv_z_unit_converter_test.go

@@ -7,6 +7,9 @@
 package gconv_test
 
 import (
+	"database/sql"
+	"fmt"
+	"reflect"
 	"testing"
 
 	"github.com/gogf/gf/v2/test/gtest"
@@ -84,3 +87,87 @@ func TestConvertWithRefer(t *testing.T) {
 		t.AssertNE(gconv.ConvertWithRefer("1.01", false), false)
 	})
 }
+
+func testAnyToMyInt(from any, to reflect.Value) error {
+	switch x := from.(type) {
+	case int:
+		to.SetInt(123456)
+	default:
+		return fmt.Errorf("unsupported type %T(%v)", x, x)
+	}
+	return nil
+}
+
+func testAnyToSqlNullType(_ any, to reflect.Value) error {
+	if to.Kind() != reflect.Ptr {
+		to = to.Addr()
+	}
+	return to.Interface().(sql.Scanner).Scan(123456)
+}
+
+func TestNewConverter(t *testing.T) {
+	type Dst[T any] struct {
+		A T
+	}
+	gtest.C(t, func(t *gtest.T) {
+		conv := gconv.NewConverter()
+		conv.RegisterAnyConverterFunc(testAnyToMyInt, reflect.TypeOf((*myInt)(nil)))
+		var dst Dst[myInt]
+		err := conv.Struct(map[string]any{
+			"a": 1200,
+		}, &dst, gconv.StructOption{})
+		t.AssertNil(err)
+		t.Assert(dst, Dst[myInt]{
+			A: 123456,
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		conv := gconv.NewConverter()
+		conv.RegisterAnyConverterFunc(testAnyToMyInt, reflect.TypeOf((myInt)(0)))
+		var dst Dst[*myInt]
+		err := conv.Struct(map[string]any{
+			"a": 1200,
+		}, &dst, gconv.StructOption{})
+		t.AssertNil(err)
+		t.Assert(*dst.A, 123456)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		conv := gconv.NewConverter()
+		conv.RegisterAnyConverterFunc(testAnyToSqlNullType, reflect.TypeOf((*sql.Scanner)(nil)))
+		type sqlNullDst struct {
+			A sql.Null[int]
+			B sql.Null[float32]
+			C sql.NullInt64
+			D sql.NullString
+
+			E *sql.Null[int]
+			F *sql.Null[float32]
+			G *sql.NullInt64
+			H *sql.NullString
+		}
+		var dst sqlNullDst
+		err := conv.Struct(map[string]any{
+			"a": 12,
+			"b": 34,
+			"c": 56,
+			"d": "sqlNullString",
+			"e": 12,
+			"f": 34,
+			"g": 56,
+			"h": "sqlNullString",
+		}, &dst, gconv.StructOption{})
+		t.AssertNil(err)
+		t.Assert(dst, sqlNullDst{
+			A: sql.Null[int]{V: 123456, Valid: true},
+			B: sql.Null[float32]{V: 123456, Valid: true},
+			C: sql.NullInt64{Int64: 123456, Valid: true},
+			D: sql.NullString{String: "123456", Valid: true},
+
+			E: &sql.Null[int]{V: 123456, Valid: true},
+			F: &sql.Null[float32]{V: 123456, Valid: true},
+			G: &sql.NullInt64{Int64: 123456, Valid: true},
+			H: &sql.NullString{String: "123456", Valid: true},
+		})
+	})
+}

util/gconv/internal/converter/converter.go

@@ -0,0 +1,180 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// Package converter provides converting utilities for any types of variables.
+package converter
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv/internal/structcache"
+)
+
+// AnyConvertFunc is the type for any type converting function.
+type AnyConvertFunc = structcache.AnyConvertFunc
+
+// RecursiveType is the type for converting recursively.
+type RecursiveType string
+
+const (
+	RecursiveTypeAuto RecursiveType = "auto"
+	RecursiveTypeTrue RecursiveType = "true"
+)
+
+type (
+	converterInType  = reflect.Type
+	converterOutType = reflect.Type
+	converterFunc    = reflect.Value
+)
+
+// Converter implements the interface Converter.
+type Converter struct {
+	internalConverter    *structcache.Converter
+	typeConverterFuncMap map[converterInType]map[converterOutType]converterFunc
+}
+
+var (
+	// Empty strings.
+	emptyStringMap = map[string]struct{}{
+		"":      {},
+		"0":     {},
+		"no":    {},
+		"off":   {},
+		"false": {},
+	}
+)
+
+// NewConverter creates and returns management object for type converting.
+func NewConverter() *Converter {
+	cf := &Converter{
+		internalConverter:    structcache.NewConverter(),
+		typeConverterFuncMap: make(map[converterInType]map[converterOutType]converterFunc),
+	}
+	cf.registerBuiltInAnyConvertFunc()
+	return cf
+}
+
+// RegisterTypeConverterFunc registers custom converter.
+// It must be registered before you use this custom converting feature.
+// It is suggested to do it in boot procedure of the process.
+//
+// Note:
+//  1. The parameter `fn` must be defined as pattern `func(T1) (T2, error)`.
+//     It will convert type `T1` to type `T2`.
+//  2. The `T1` should not be type of pointer, but the `T2` should be type of pointer.
+func (c *Converter) RegisterTypeConverterFunc(f any) (err error) {
+	var (
+		fReflectType = reflect.TypeOf(f)
+		errType      = reflect.TypeOf((*error)(nil)).Elem()
+	)
+	if fReflectType.Kind() != reflect.Func ||
+		fReflectType.NumIn() != 1 || fReflectType.NumOut() != 2 ||
+		!fReflectType.Out(1).Implements(errType) {
+		err = gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"parameter must be type of converter function and defined as pattern `func(T1) (T2, error)`, "+
+				"but defined as `%s`",
+			fReflectType.String(),
+		)
+		return
+	}
+
+	// The Key and Value of the converter map should not be pointer.
+	var (
+		inType  = fReflectType.In(0)
+		outType = fReflectType.Out(0)
+	)
+	if inType.Kind() == reflect.Pointer {
+		err = gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"invalid converter function `%s`: invalid input parameter type `%s`, should not be type of pointer",
+			fReflectType.String(), inType.String(),
+		)
+		return
+	}
+	if outType.Kind() != reflect.Pointer {
+		err = gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"invalid converter function `%s`: invalid output parameter type `%s` should be type of pointer",
+			fReflectType.String(), outType.String(),
+		)
+		return
+	}
+
+	registeredOutTypeMap, ok := c.typeConverterFuncMap[inType]
+	if !ok {
+		registeredOutTypeMap = make(map[converterOutType]converterFunc)
+		c.typeConverterFuncMap[inType] = registeredOutTypeMap
+	}
+	if _, ok = registeredOutTypeMap[outType]; ok {
+		err = gerror.NewCodef(
+			gcode.CodeInvalidOperation,
+			"the converter parameter type `%s` to type `%s` has already been registered",
+			inType.String(), outType.String(),
+		)
+		return
+	}
+	registeredOutTypeMap[outType] = reflect.ValueOf(f)
+	c.internalConverter.MarkTypeConvertFunc(outType)
+	return
+}
+
+// RegisterAnyConverterFunc registers custom type converting function for specified types.
+func (c *Converter) RegisterAnyConverterFunc(convertFunc AnyConvertFunc, types ...reflect.Type) {
+	for _, t := range types {
+		c.internalConverter.RegisterAnyConvertFunc(t, convertFunc)
+	}
+}
+
+func (c *Converter) registerBuiltInAnyConvertFunc() {
+	var (
+		intType     = reflect.TypeOf(0)
+		int8Type    = reflect.TypeOf(int8(0))
+		int16Type   = reflect.TypeOf(int16(0))
+		int32Type   = reflect.TypeOf(int32(0))
+		int64Type   = reflect.TypeOf(int64(0))
+		uintType    = reflect.TypeOf(uint(0))
+		uint8Type   = reflect.TypeOf(uint8(0))
+		uint16Type  = reflect.TypeOf(uint16(0))
+		uint32Type  = reflect.TypeOf(uint32(0))
+		uint64Type  = reflect.TypeOf(uint64(0))
+		float32Type = reflect.TypeOf(float32(0))
+		float64Type = reflect.TypeOf(float64(0))
+		stringType  = reflect.TypeOf("")
+		bytesType   = reflect.TypeOf([]byte{})
+		boolType    = reflect.TypeOf(false)
+		timeType    = reflect.TypeOf((*time.Time)(nil)).Elem()
+		gtimeType   = reflect.TypeOf((*gtime.Time)(nil)).Elem()
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForInt64, intType, int8Type, int16Type, int32Type, int64Type,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForUint64, uintType, uint8Type, uint16Type, uint32Type, uint64Type,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForString, stringType,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForFloat64, float32Type, float64Type,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForBool, boolType,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForBytes, bytesType,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForTime, timeType,
+	)
+	c.RegisterAnyConverterFunc(
+		c.builtInAnyConvertFuncForGTime, gtimeType,
+	)
+}

util/gconv/internal/converter/converter_bool.go

@@ -0,0 +1,75 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Bool converts `any` to bool.
+func (c *Converter) Bool(any any) (bool, error) {
+	if empty.IsNil(any) {
+		return false, nil
+	}
+	switch value := any.(type) {
+	case bool:
+		return value, nil
+	case []byte:
+		if _, ok := emptyStringMap[strings.ToLower(string(value))]; ok {
+			return false, nil
+		}
+		return true, nil
+	case string:
+		if _, ok := emptyStringMap[strings.ToLower(value)]; ok {
+			return false, nil
+		}
+		return true, nil
+	default:
+		if f, ok := value.(localinterface.IBool); ok {
+			return f.Bool(), nil
+		}
+		rv := reflect.ValueOf(any)
+		switch rv.Kind() {
+		case reflect.Ptr:
+			if rv.IsNil() {
+				return false, nil
+			}
+			if rv.Type().Elem().Kind() == reflect.Bool {
+				return rv.Elem().Bool(), nil
+			}
+			return c.Bool(rv.Elem().Interface())
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return rv.Int() != 0, nil
+		case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			return rv.Uint() != 0, nil
+		case reflect.Float32, reflect.Float64:
+			return rv.Float() != 0, nil
+		case reflect.Bool:
+			return rv.Bool(), nil
+		// TODO：(Map，Array，Slice，Struct) It might panic here for these types.
+		case reflect.Map, reflect.Array:
+			fallthrough
+		case reflect.Slice:
+			return rv.Len() != 0, nil
+		case reflect.Struct:
+			return true, nil
+		default:
+			s, err := c.String(any)
+			if err != nil {
+				return false, err
+			}
+			if _, ok := emptyStringMap[strings.ToLower(s)]; ok {
+				return false, nil
+			}
+			return true, nil
+		}
+	}
+}

util/gconv/internal/converter/converter_builtin.go

@@ -0,0 +1,89 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+func (c *Converter) builtInAnyConvertFuncForInt64(from any, to reflect.Value) error {
+	v, err := c.Int64(from)
+	if err != nil {
+		return err
+	}
+	to.SetInt(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForUint64(from any, to reflect.Value) error {
+	v, err := c.Uint64(from)
+	if err != nil {
+		return err
+	}
+	to.SetUint(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForString(from any, to reflect.Value) error {
+	v, err := c.String(from)
+	if err != nil {
+		return err
+	}
+	to.SetString(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForFloat64(from any, to reflect.Value) error {
+	v, err := c.Float64(from)
+	if err != nil {
+		return err
+	}
+	to.SetFloat(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForBool(from any, to reflect.Value) error {
+	v, err := c.Bool(from)
+	if err != nil {
+		return err
+	}
+	to.SetBool(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForBytes(from any, to reflect.Value) error {
+	v, err := c.Bytes(from)
+	if err != nil {
+		return err
+	}
+	to.SetBytes(v)
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForTime(from any, to reflect.Value) error {
+	t, err := c.Time(from)
+	if err != nil {
+		return err
+	}
+	*to.Addr().Interface().(*time.Time) = t
+	return nil
+}
+
+func (c *Converter) builtInAnyConvertFuncForGTime(from any, to reflect.Value) error {
+	v, err := c.GTime(from)
+	if err != nil {
+		return err
+	}
+	if v == nil {
+		v = gtime.New()
+	}
+	*to.Addr().Interface().(*gtime.Time) = *v
+	return nil
+}

util/gconv/internal/converter/converter_bytes.go

@@ -0,0 +1,68 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"math"
+	"reflect"
+
+	"github.com/gogf/gf/v2/encoding/gbinary"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Bytes converts `any` to []byte.
+func (c *Converter) Bytes(any any) ([]byte, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	switch value := any.(type) {
+	case string:
+		return []byte(value), nil
+
+	case []byte:
+		return value, nil
+
+	default:
+		if f, ok := value.(localinterface.IBytes); ok {
+			return f.Bytes(), nil
+		}
+		originValueAndKind := reflection.OriginValueAndKind(any)
+		switch originValueAndKind.OriginKind {
+		case reflect.Map:
+			bytes, err := json.Marshal(any)
+			if err != nil {
+				return nil, err
+			}
+			return bytes, nil
+
+		case reflect.Array, reflect.Slice:
+			var (
+				ok    = true
+				bytes = make([]byte, originValueAndKind.OriginValue.Len())
+			)
+			for i := range bytes {
+				int32Value, err := c.Int32(originValueAndKind.OriginValue.Index(i).Interface())
+				if err != nil {
+					return nil, err
+				}
+				if int32Value < 0 || int32Value > math.MaxUint8 {
+					ok = false
+					break
+				}
+				bytes[i] = byte(int32Value)
+			}
+			if ok {
+				return bytes, nil
+			}
+		default:
+		}
+		return gbinary.Encode(any), nil
+	}
+}

util/gconv/internal/converter/converter_convert.go

@@ -0,0 +1,563 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"time"
+
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// ConvertOption is the option for converting.
+type ConvertOption struct {
+	// ExtraParams are extra values for implementing the converting.
+	ExtraParams  []any
+	SliceOption  SliceOption
+	MapOption    MapOption
+	StructOption StructOption
+}
+
+// ConvertWithTypeName converts the variable `fromValue` to the type `toTypeName`, the type `toTypeName` is specified by string.
+func (c *Converter) ConvertWithTypeName(fromValue any, toTypeName string, option ConvertOption) (any, error) {
+	return c.doConvert(
+		doConvertInput{
+			FromValue:  fromValue,
+			ToTypeName: toTypeName,
+			ReferValue: nil,
+		},
+		option,
+	)
+}
+
+// ConvertWithRefer converts the variable `fromValue` to the type referred by value `referValue`.
+func (c *Converter) ConvertWithRefer(fromValue, referValue any, option ConvertOption) (any, error) {
+	var referValueRf reflect.Value
+	if v, ok := referValue.(reflect.Value); ok {
+		referValueRf = v
+	} else {
+		referValueRf = reflect.ValueOf(referValue)
+	}
+	return c.doConvert(
+		doConvertInput{
+			FromValue:  fromValue,
+			ToTypeName: referValueRf.Type().String(),
+			ReferValue: referValue,
+		},
+		option,
+	)
+}
+
+type doConvertInput struct {
+	FromValue  any    // Value that is converted from.
+	ToTypeName string // Target value type name in string.
+	ReferValue any    // Referred value, a value in type `ToTypeName`. Note that its type might be reflect.Value.
+
+	// Marks that the value is already converted and set to `ReferValue`. Caller can ignore the returned result.
+	// It is an attribute for internal usage purpose.
+	alreadySetToReferValue bool
+}
+
+// doConvert does commonly use types converting.
+func (c *Converter) doConvert(in doConvertInput, option ConvertOption) (convertedValue any, err error) {
+	switch in.ToTypeName {
+	case "int":
+		return c.Int(in.FromValue)
+	case "*int":
+		if _, ok := in.FromValue.(*int); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Int(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "int8":
+		return c.Int8(in.FromValue)
+	case "*int8":
+		if _, ok := in.FromValue.(*int8); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Int8(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "int16":
+		return c.Int16(in.FromValue)
+	case "*int16":
+		if _, ok := in.FromValue.(*int16); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Int16(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "int32":
+		return c.Int32(in.FromValue)
+	case "*int32":
+		if _, ok := in.FromValue.(*int32); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Int32(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "int64":
+		return c.Int64(in.FromValue)
+	case "*int64":
+		if _, ok := in.FromValue.(*int64); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Int64(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "uint":
+		return c.Uint(in.FromValue)
+	case "*uint":
+		if _, ok := in.FromValue.(*uint); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Uint(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "uint8":
+		return c.Uint8(in.FromValue)
+	case "*uint8":
+		if _, ok := in.FromValue.(*uint8); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Uint8(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "uint16":
+		return c.Uint16(in.FromValue)
+	case "*uint16":
+		if _, ok := in.FromValue.(*uint16); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Uint16(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "uint32":
+		return c.Uint32(in.FromValue)
+	case "*uint32":
+		if _, ok := in.FromValue.(*uint32); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Uint32(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "uint64":
+		return c.Uint64(in.FromValue)
+	case "*uint64":
+		if _, ok := in.FromValue.(*uint64); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Uint64(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "float32":
+		return c.Float32(in.FromValue)
+	case "*float32":
+		if _, ok := in.FromValue.(*float32); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Float32(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "float64":
+		return c.Float64(in.FromValue)
+	case "*float64":
+		if _, ok := in.FromValue.(*float64); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Float64(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "bool":
+		return c.Bool(in.FromValue)
+	case "*bool":
+		if _, ok := in.FromValue.(*bool); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Bool(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "string":
+		return c.String(in.FromValue)
+	case "*string":
+		if _, ok := in.FromValue.(*string); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.String(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "[]byte":
+		return c.Bytes(in.FromValue)
+	case "[]int":
+		return c.SliceInt(in.FromValue, option.SliceOption)
+	case "[]int32":
+		return c.SliceInt32(in.FromValue, option.SliceOption)
+	case "[]int64":
+		return c.SliceInt64(in.FromValue, option.SliceOption)
+	case "[]uint":
+		return c.SliceUint(in.FromValue, option.SliceOption)
+	case "[]uint8":
+		return c.Bytes(in.FromValue)
+	case "[]uint32":
+		return c.SliceUint32(in.FromValue, option.SliceOption)
+	case "[]uint64":
+		return c.SliceUint64(in.FromValue, option.SliceOption)
+	case "[]float32":
+		return c.SliceFloat32(in.FromValue, option.SliceOption)
+	case "[]float64":
+		return c.SliceFloat64(in.FromValue, option.SliceOption)
+	case "[]string":
+		return c.SliceStr(in.FromValue, option.SliceOption)
+
+	case "Time", "time.Time":
+		if len(option.ExtraParams) > 0 {
+			s, err := c.String(option.ExtraParams[0])
+			if err != nil {
+				return nil, err
+			}
+			return c.Time(in.FromValue, s)
+		}
+		return c.Time(in.FromValue)
+	case "*time.Time":
+		var v time.Time
+		if len(option.ExtraParams) > 0 {
+			s, err := c.String(option.ExtraParams[0])
+			if err != nil {
+				return time.Time{}, err
+			}
+			v, err = c.Time(in.FromValue, s)
+			if err != nil {
+				return time.Time{}, err
+			}
+		} else {
+			if _, ok := in.FromValue.(*time.Time); ok {
+				return in.FromValue, nil
+			}
+			v, err = c.Time(in.FromValue)
+			if err != nil {
+				return time.Time{}, err
+			}
+		}
+		return &v, nil
+
+	case "GTime", "gtime.Time":
+		if len(option.ExtraParams) > 0 {
+			s, err := c.String(option.ExtraParams[0])
+			if err != nil {
+				return *gtime.New(), err
+			}
+			v, err := c.GTime(in.FromValue, s)
+			if err != nil {
+				return *gtime.New(), err
+			}
+			if v != nil {
+				return *v, nil
+			}
+			return *gtime.New(), nil
+		}
+		v, err := c.GTime(in.FromValue)
+		if err != nil {
+			return *gtime.New(), err
+		}
+		if v != nil {
+			return *v, nil
+		}
+		return *gtime.New(), nil
+	case "*gtime.Time":
+		if len(option.ExtraParams) > 0 {
+			s, err := c.String(option.ExtraParams[0])
+			if err != nil {
+				return gtime.New(), err
+			}
+			v, err := c.GTime(in.FromValue, s)
+			if err != nil {
+				return gtime.New(), err
+			}
+			if v != nil {
+				return v, nil
+			}
+			return gtime.New(), nil
+		}
+		v, err := c.GTime(in.FromValue)
+		if err != nil {
+			return gtime.New(), err
+		}
+		if v != nil {
+			return v, nil
+		}
+		return gtime.New(), nil
+
+	case "Duration", "time.Duration":
+		return c.Duration(in.FromValue)
+	case "*time.Duration":
+		if _, ok := in.FromValue.(*time.Duration); ok {
+			return in.FromValue, nil
+		}
+		v, err := c.Duration(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return &v, nil
+
+	case "map[string]string":
+		return c.MapStrStr(in.FromValue, option.MapOption)
+
+	case "map[string]interface {}":
+		return c.Map(in.FromValue, option.MapOption)
+
+	case "[]map[string]interface {}":
+		return c.SliceMap(in.FromValue, option.SliceOption, option.MapOption)
+
+	case "RawMessage", "json.RawMessage":
+		// issue 3449
+		bytes, err := json.Marshal(in.FromValue)
+		if err != nil {
+			return nil, err
+		}
+		return bytes, nil
+
+	default:
+		return c.doConvertForDefault(in, option)
+	}
+}
+
+func (c *Converter) doConvertForDefault(in doConvertInput, option ConvertOption) (convertedValue any, err error) {
+	if in.ReferValue != nil {
+		var referReflectValue reflect.Value
+		if v, ok := in.ReferValue.(reflect.Value); ok {
+			referReflectValue = v
+		} else {
+			referReflectValue = reflect.ValueOf(in.ReferValue)
+		}
+		var fromReflectValue reflect.Value
+		if v, ok := in.FromValue.(reflect.Value); ok {
+			fromReflectValue = v
+		} else {
+			fromReflectValue = reflect.ValueOf(in.FromValue)
+		}
+
+		// custom converter.
+		dstReflectValue, ok, err := c.callCustomConverterWithRefer(fromReflectValue, referReflectValue)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			return dstReflectValue.Interface(), nil
+		}
+
+		defer func() {
+			if recover() != nil {
+				in.alreadySetToReferValue = false
+				if err = c.bindVarToReflectValue(referReflectValue, in.FromValue, option.StructOption); err == nil {
+					in.alreadySetToReferValue = true
+					convertedValue = referReflectValue.Interface()
+				}
+			}
+		}()
+		switch referReflectValue.Kind() {
+		case reflect.Ptr:
+			// Type converting for custom type pointers.
+			// Eg:
+			// type PayMode int
+			// type Req struct{
+			//     Mode *PayMode
+			// }
+			//
+			// Struct(`{"Mode": 1000}`, &req)
+			originType := referReflectValue.Type().Elem()
+			switch originType.Kind() {
+			case reflect.Struct:
+				// Not support some kinds.
+			default:
+				in.ToTypeName = originType.Kind().String()
+				in.ReferValue = nil
+				result, err := c.doConvert(in, option)
+				if err != nil {
+					return nil, err
+				}
+				refElementValue := reflect.ValueOf(result)
+				originTypeValue := reflect.New(refElementValue.Type()).Elem()
+				originTypeValue.Set(refElementValue)
+				in.alreadySetToReferValue = true
+				return originTypeValue.Addr().Convert(referReflectValue.Type()).Interface(), nil
+			}
+
+		case reflect.Map:
+			var targetValue = reflect.New(referReflectValue.Type()).Elem()
+			if err = c.MapToMap(in.FromValue, targetValue, nil, option.MapOption); err == nil {
+				in.alreadySetToReferValue = true
+			}
+			return targetValue.Interface(), nil
+
+		default:
+		}
+		in.ToTypeName = referReflectValue.Kind().String()
+		in.ReferValue = nil
+		in.alreadySetToReferValue = true
+		result, err := c.doConvert(in, option)
+		if err != nil {
+			return nil, err
+		}
+		convertedValue = reflect.ValueOf(result).Convert(referReflectValue.Type()).Interface()
+		return convertedValue, nil
+	}
+	return in.FromValue, nil
+}
+
+func (c *Converter) doConvertWithReflectValueSet(reflectValue reflect.Value, in doConvertInput, option ConvertOption) error {
+	convertedValue, err := c.doConvert(in, option)
+	if err != nil {
+		return err
+	}
+	if !in.alreadySetToReferValue {
+		reflectValue.Set(reflect.ValueOf(convertedValue))
+	}
+	return err
+}
+
+func (c *Converter) getRegisteredConverterFuncAndSrcType(
+	srcReflectValue, dstReflectValueForRefer reflect.Value,
+) (f converterFunc, srcType reflect.Type, ok bool) {
+	if len(c.typeConverterFuncMap) == 0 {
+		return reflect.Value{}, nil, false
+	}
+	srcType = srcReflectValue.Type()
+	for srcType.Kind() == reflect.Pointer {
+		srcType = srcType.Elem()
+	}
+	var registeredOutTypeMap map[converterOutType]converterFunc
+	// firstly, it searches the map by input parameter type.
+	registeredOutTypeMap, ok = c.typeConverterFuncMap[srcType]
+	if !ok {
+		return reflect.Value{}, nil, false
+	}
+	var dstType = dstReflectValueForRefer.Type()
+	if dstType.Kind() == reflect.Pointer {
+		// Might be **struct, which is support as designed.
+		if dstType.Elem().Kind() == reflect.Pointer {
+			dstType = dstType.Elem()
+		}
+	} else if dstReflectValueForRefer.IsValid() && dstReflectValueForRefer.CanAddr() {
+		dstType = dstReflectValueForRefer.Addr().Type()
+	} else {
+		dstType = reflect.PointerTo(dstType)
+	}
+	// secondly, it searches the input parameter type map
+	// and finds the result converter function by the output parameter type.
+	f, ok = registeredOutTypeMap[dstType]
+	if !ok {
+		return reflect.Value{}, nil, false
+	}
+	return
+}
+
+func (c *Converter) callCustomConverterWithRefer(
+	srcReflectValue, referReflectValue reflect.Value,
+) (dstReflectValue reflect.Value, converted bool, err error) {
+	registeredConverterFunc, srcType, ok := c.getRegisteredConverterFuncAndSrcType(srcReflectValue, referReflectValue)
+	if !ok {
+		return reflect.Value{}, false, nil
+	}
+	dstReflectValue = reflect.New(referReflectValue.Type()).Elem()
+	converted, err = c.doCallCustomConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
+	return
+}
+
+// callCustomConverter call the custom converter. It will try some possible type.
+func (c *Converter) callCustomConverter(srcReflectValue, dstReflectValue reflect.Value) (converted bool, err error) {
+	registeredConverterFunc, srcType, ok := c.getRegisteredConverterFuncAndSrcType(srcReflectValue, dstReflectValue)
+	if !ok {
+		return false, nil
+	}
+	return c.doCallCustomConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
+}
+
+func (c *Converter) doCallCustomConverter(
+	srcReflectValue reflect.Value,
+	dstReflectValue reflect.Value,
+	registeredConverterFunc converterFunc,
+	srcType reflect.Type,
+) (converted bool, err error) {
+	// Converter function calling.
+	for srcReflectValue.Type() != srcType {
+		srcReflectValue = srcReflectValue.Elem()
+	}
+	result := registeredConverterFunc.Call([]reflect.Value{srcReflectValue})
+	if !result[1].IsNil() {
+		return false, result[1].Interface().(error)
+	}
+	// The `result[0]` is a pointer.
+	if result[0].IsNil() {
+		return false, nil
+	}
+	var resultValue = result[0]
+	for {
+		if resultValue.Type() == dstReflectValue.Type() && dstReflectValue.CanSet() {
+			dstReflectValue.Set(resultValue)
+			converted = true
+		} else if dstReflectValue.Kind() == reflect.Pointer {
+			if resultValue.Type() == dstReflectValue.Elem().Type() && dstReflectValue.Elem().CanSet() {
+				dstReflectValue.Elem().Set(resultValue)
+				converted = true
+			}
+		}
+		if converted {
+			break
+		}
+		if resultValue.Kind() == reflect.Pointer {
+			resultValue = resultValue.Elem()
+		} else {
+			break
+		}
+	}
+
+	return converted, nil
+}

util/gconv/internal/converter/converter_float.go

@@ -0,0 +1,147 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"strconv"
+
+	"github.com/gogf/gf/v2/encoding/gbinary"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Float32 converts `any` to float32.
+func (c *Converter) Float32(any any) (float32, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	switch value := any.(type) {
+	case float32:
+		return value, nil
+	case float64:
+		return float32(value), nil
+	case []byte:
+		// TODO: It might panic here for these types.
+		return gbinary.DecodeToFloat32(value), nil
+	default:
+		rv := reflect.ValueOf(any)
+		switch rv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return float32(rv.Int()), nil
+		case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			return float32(rv.Uint()), nil
+		case reflect.Float32, reflect.Float64:
+			return float32(rv.Float()), nil
+		case reflect.Bool:
+			if rv.Bool() {
+				return 1, nil
+			}
+			return 0, nil
+		case reflect.String:
+			f, err := strconv.ParseFloat(rv.String(), 32)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
+				)
+			}
+			return float32(f), nil
+		case reflect.Ptr:
+			if rv.IsNil() {
+				return 0, nil
+			}
+			if f, ok := value.(localinterface.IFloat32); ok {
+				return f.Float32(), nil
+			}
+			return c.Float32(rv.Elem().Interface())
+		default:
+			if f, ok := value.(localinterface.IFloat32); ok {
+				return f.Float32(), nil
+			}
+			s, err := c.String(any)
+			if err != nil {
+				return 0, err
+			}
+			v, err := strconv.ParseFloat(s, 32)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float32 failed for: %v", any,
+				)
+			}
+			return float32(v), nil
+		}
+	}
+}
+
+// Float64 converts `any` to float64.
+func (c *Converter) Float64(any any) (float64, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	switch value := any.(type) {
+	case float32:
+		return float64(value), nil
+	case float64:
+		return value, nil
+	case []byte:
+		// TODO: It might panic here for these types.
+		return gbinary.DecodeToFloat64(value), nil
+	default:
+		rv := reflect.ValueOf(any)
+		switch rv.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return float64(rv.Int()), nil
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			return float64(rv.Uint()), nil
+		case reflect.Uintptr:
+			return float64(rv.Uint()), nil
+		case reflect.Float32, reflect.Float64:
+			// Please Note:
+			// When the type is float32 or a custom type defined based on float32,
+			// switching to float64 may result in a few extra decimal places.
+			return rv.Float(), nil
+		case reflect.Bool:
+			if rv.Bool() {
+				return 1, nil
+			}
+			return 0, nil
+		case reflect.String:
+			f, err := strconv.ParseFloat(rv.String(), 64)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
+				)
+			}
+			return f, nil
+		case reflect.Ptr:
+			if rv.IsNil() {
+				return 0, nil
+			}
+			if f, ok := value.(localinterface.IFloat64); ok {
+				return f.Float64(), nil
+			}
+			return c.Float64(rv.Elem().Interface())
+		default:
+			if f, ok := value.(localinterface.IFloat64); ok {
+				return f.Float64(), nil
+			}
+			s, err := c.String(any)
+			if err != nil {
+				return 0, err
+			}
+			v, err := strconv.ParseFloat(s, 64)
+			if err != nil {
+				return 0, gerror.WrapCodef(
+					gcode.CodeInvalidParameter, err, "converting string to float64 failed for: %v", any,
+				)
+			}
+			return v, nil
+		}
+	}
+}

util/gconv/internal/converter/converter_int.go

@@ -0,0 +1,157 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+
+	"github.com/gogf/gf/v2/encoding/gbinary"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Int converts `any` to int.
+func (c *Converter) Int(any any) (int, error) {
+	if v, ok := any.(int); ok {
+		return v, nil
+	}
+	v, err := c.Int64(any)
+	if err != nil {
+		return 0, err
+	}
+	return int(v), nil
+}
+
+// Int8 converts `any` to int8.
+func (c *Converter) Int8(any any) (int8, error) {
+	if v, ok := any.(int8); ok {
+		return v, nil
+	}
+	v, err := c.Int64(any)
+	if err != nil {
+		return 0, err
+	}
+	return int8(v), nil
+}
+
+// Int16 converts `any` to int16.
+func (c *Converter) Int16(any any) (int16, error) {
+	if v, ok := any.(int16); ok {
+		return v, nil
+	}
+	v, err := c.Int64(any)
+	if err != nil {
+		return 0, err
+	}
+	return int16(v), nil
+}
+
+// Int32 converts `any` to int32.
+func (c *Converter) Int32(any any) (int32, error) {
+	if v, ok := any.(int32); ok {
+		return v, nil
+	}
+	v, err := c.Int64(any)
+	if err != nil {
+		return 0, err
+	}
+	return int32(v), nil
+}
+
+// Int64 converts `any` to int64.
+func (c *Converter) Int64(any any) (int64, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(int64); ok {
+		return v, nil
+	}
+	rv := reflect.ValueOf(any)
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return rv.Int(), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return int64(rv.Uint()), nil
+	case reflect.Uintptr:
+		return int64(rv.Uint()), nil
+	case reflect.Float32, reflect.Float64:
+		return int64(rv.Float()), nil
+	case reflect.Bool:
+		if rv.Bool() {
+			return 1, nil
+		}
+		return 0, nil
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return 0, nil
+		}
+		if f, ok := any.(localinterface.IInt64); ok {
+			return f.Int64(), nil
+		}
+		return c.Int64(rv.Elem().Interface())
+	case reflect.Slice:
+		// TODO: It might panic here for these types.
+		if rv.Type().Elem().Kind() == reflect.Uint8 {
+			return gbinary.DecodeToInt64(rv.Bytes()), nil
+		}
+	case reflect.String:
+		var (
+			s       = rv.String()
+			isMinus = false
+		)
+		if len(s) > 0 {
+			if s[0] == '-' {
+				isMinus = true
+				s = s[1:]
+			} else if s[0] == '+' {
+				s = s[1:]
+			}
+		}
+		// Hexadecimal.
+		if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
+			if v, e := strconv.ParseInt(s[2:], 16, 64); e == nil {
+				if isMinus {
+					return -v, nil
+				}
+				return v, nil
+			}
+		}
+		// Decimal.
+		if v, e := strconv.ParseInt(s, 10, 64); e == nil {
+			if isMinus {
+				return -v, nil
+			}
+			return v, nil
+		}
+		// Float64.
+		valueInt64, err := c.Float64(s)
+		if err != nil {
+			return 0, err
+		}
+		if math.IsNaN(valueInt64) {
+			return 0, nil
+		} else {
+			if isMinus {
+				return -int64(valueInt64), nil
+			}
+			return int64(valueInt64), nil
+		}
+	default:
+		if f, ok := any.(localinterface.IInt64); ok {
+			return f.Int64(), nil
+		}
+	}
+	return 0, gerror.NewCodef(
+		gcode.CodeInvalidParameter,
+		`unsupport value type for converting to int64: %v`,
+		reflect.TypeOf(any),
+	)
+}

util/gconv/internal/converter/converter_map.go

@@ -0,0 +1,646 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+	"github.com/gogf/gf/v2/util/gtag"
+)
+
+// MapOption specifies the option for map converting.
+type MapOption struct {
+	// Deep marks doing Map function recursively, which means if the attribute of given converting value
+	// is also a struct/*struct, it automatically calls Map function on this attribute converting it to
+	// a map[string]any type variable.
+	Deep bool
+
+	// OmitEmpty ignores the attributes that has json `omitempty` tag.
+	OmitEmpty bool
+
+	// Tags specifies the converted map key name by struct tag name.
+	Tags []string
+
+	// ContinueOnError specifies whether to continue converting the next element
+	// if one element converting fails.
+	ContinueOnError bool
+}
+
+// Map converts any variable `value` to map[string]any. If the parameter `value` is not a
+// map/struct/*struct type, then the conversion will fail and returns nil.
+//
+// If `value` is a struct/*struct object, the second parameter `priorityTagAndFieldName` specifies the most priority
+// priorityTagAndFieldName that will be detected, otherwise it detects the priorityTagAndFieldName in order of:
+// gconv, json, field name.
+func (c *Converter) Map(value any, option MapOption) (map[string]any, error) {
+	return c.doMapConvert(value, RecursiveTypeAuto, false, option)
+}
+
+// MapStrStr converts `value` to map[string]string.
+// Note that there might be data copy for this map type converting.
+func (c *Converter) MapStrStr(value any, option MapOption) (map[string]string, error) {
+	if r, ok := value.(map[string]string); ok {
+		return r, nil
+	}
+	m, err := c.Map(value, option)
+	if err != nil && !option.ContinueOnError {
+		return nil, err
+	}
+	if len(m) > 0 {
+		var (
+			s    string
+			vMap = make(map[string]string, len(m))
+		)
+		for k, v := range m {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			vMap[k] = s
+		}
+		return vMap, nil
+	}
+	return nil, nil
+}
+
+// MapConvert implements the map converting.
+// It automatically checks and converts json string to map if `value` is string/[]byte.
+//
+// TODO completely implement the recursive converting for all types, especially the map.
+func (c *Converter) doMapConvert(
+	value any, recursive RecursiveType, mustMapReturn bool, option MapOption,
+) (map[string]any, error) {
+	if value == nil {
+		return nil, nil
+	}
+	// It redirects to its underlying value if it has implemented interface iVal.
+	if v, ok := value.(localinterface.IVal); ok {
+		value = v.Val()
+	}
+	var (
+		err     error
+		newTags = gtag.StructTagPriority
+	)
+	if option.Deep {
+		recursive = RecursiveTypeTrue
+	}
+	switch len(option.Tags) {
+	case 0:
+		// No need handling.
+	case 1:
+		newTags = append(strings.Split(option.Tags[0], ","), gtag.StructTagPriority...)
+	default:
+		newTags = append(option.Tags, gtag.StructTagPriority...)
+	}
+	// Assert the common combination of types, and finally it uses reflection.
+	dataMap := make(map[string]interface{})
+	switch r := value.(type) {
+	case string:
+		// If it is a JSON string, automatically unmarshal it!
+		if len(r) > 0 && r[0] == '{' && r[len(r)-1] == '}' {
+			if err = json.UnmarshalUseNumber([]byte(r), &dataMap); err != nil {
+				return nil, err
+			}
+		} else {
+			return nil, nil
+		}
+	case []byte:
+		// If it is a JSON string, automatically unmarshal it!
+		if len(r) > 0 && r[0] == '{' && r[len(r)-1] == '}' {
+			if err = json.UnmarshalUseNumber(r, &dataMap); err != nil {
+				return nil, err
+			}
+		} else {
+			return nil, nil
+		}
+	case map[interface{}]interface{}:
+		recursiveOption := option
+		recursiveOption.Tags = newTags
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s], err = c.doMapConvertForMapOrStructValue(
+				doMapConvertForMapOrStructValueInput{
+					IsRoot:          false,
+					Value:           v,
+					RecursiveType:   recursive,
+					RecursiveOption: recursive == RecursiveTypeTrue,
+					Option:          recursiveOption,
+				},
+			)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+		}
+	case map[interface{}]string:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[interface{}]int:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[interface{}]uint:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[interface{}]float32:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[interface{}]float64:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[string]bool:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]int:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]uint:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]float32:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]float64:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]string:
+		for k, v := range r {
+			dataMap[k] = v
+		}
+	case map[string]interface{}:
+		if recursive == RecursiveTypeTrue {
+			recursiveOption := option
+			recursiveOption.Tags = newTags
+			// A copy of current map.
+			for k, v := range r {
+				dataMap[k], err = c.doMapConvertForMapOrStructValue(
+					doMapConvertForMapOrStructValueInput{
+						IsRoot:          false,
+						Value:           v,
+						RecursiveType:   recursive,
+						RecursiveOption: recursive == RecursiveTypeTrue,
+						Option:          recursiveOption,
+					},
+				)
+				if err != nil && !option.ContinueOnError {
+					return nil, err
+				}
+			}
+		} else {
+			// It returns the map directly without any changing.
+			return r, nil
+		}
+	case map[int]interface{}:
+		recursiveOption := option
+		recursiveOption.Tags = newTags
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s], err = c.doMapConvertForMapOrStructValue(
+				doMapConvertForMapOrStructValueInput{
+					IsRoot:          false,
+					Value:           v,
+					RecursiveType:   recursive,
+					RecursiveOption: recursive == RecursiveTypeTrue,
+					Option:          recursiveOption,
+				},
+			)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+		}
+	case map[int]string:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+	case map[uint]string:
+		for k, v := range r {
+			s, err := c.String(k)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s] = v
+		}
+
+	default:
+		// Not a common type, it then uses reflection for conversion.
+		var reflectValue reflect.Value
+		if v, ok := value.(reflect.Value); ok {
+			reflectValue = v
+		} else {
+			reflectValue = reflect.ValueOf(value)
+		}
+		reflectKind := reflectValue.Kind()
+		// If it is a pointer, we should find its real data type.
+		for reflectKind == reflect.Ptr {
+			reflectValue = reflectValue.Elem()
+			reflectKind = reflectValue.Kind()
+		}
+		switch reflectKind {
+		// If `value` is type of array, it converts the value of even number index as its key and
+		// the value of odd number index as its corresponding value, for example:
+		// []string{"k1","v1","k2","v2"} => map[string]interface{}{"k1":"v1", "k2":"v2"}
+		// []string{"k1","v1","k2"}      => map[string]interface{}{"k1":"v1", "k2":nil}
+		case reflect.Slice, reflect.Array:
+			length := reflectValue.Len()
+			for i := 0; i < length; i += 2 {
+				s, err := c.String(reflectValue.Index(i).Interface())
+				if err != nil && !option.ContinueOnError {
+					return nil, err
+				}
+				if i+1 < length {
+					dataMap[s] = reflectValue.Index(i + 1).Interface()
+				} else {
+					dataMap[s] = nil
+				}
+			}
+		case reflect.Map, reflect.Struct, reflect.Interface:
+			recursiveOption := option
+			recursiveOption.Tags = newTags
+			convertedValue, err := c.doMapConvertForMapOrStructValue(
+				doMapConvertForMapOrStructValueInput{
+					IsRoot:          true,
+					Value:           value,
+					RecursiveType:   recursive,
+					RecursiveOption: recursive == RecursiveTypeTrue,
+					Option:          recursiveOption,
+					MustMapReturn:   mustMapReturn,
+				},
+			)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			if m, ok := convertedValue.(map[string]interface{}); ok {
+				return m, nil
+			}
+			return nil, nil
+		default:
+			return nil, nil
+		}
+	}
+	return dataMap, nil
+}
+
+type doMapConvertForMapOrStructValueInput struct {
+	IsRoot          bool          // It returns directly if it is not root and with no recursive converting.
+	Value           interface{}   // Current operation value.
+	RecursiveType   RecursiveType // The type from top function entry.
+	RecursiveOption bool          // Whether convert recursively for `current` operation.
+	Option          MapOption     // Map converting option.
+	MustMapReturn   bool          // Must return map instead of Value when empty.
+}
+
+func (c *Converter) doMapConvertForMapOrStructValue(in doMapConvertForMapOrStructValueInput) (any, error) {
+	if !in.IsRoot && !in.RecursiveOption {
+		return in.Value, nil
+	}
+
+	var (
+		err          error
+		reflectValue reflect.Value
+	)
+	if v, ok := in.Value.(reflect.Value); ok {
+		reflectValue = v
+		in.Value = v.Interface()
+	} else {
+		reflectValue = reflect.ValueOf(in.Value)
+	}
+	reflectKind := reflectValue.Kind()
+	// If it is a pointer, we should find its real data type.
+	for reflectKind == reflect.Ptr {
+		reflectValue = reflectValue.Elem()
+		reflectKind = reflectValue.Kind()
+	}
+	switch reflectKind {
+	case reflect.Map:
+		var (
+			mapIter = reflectValue.MapRange()
+			dataMap = make(map[string]interface{})
+		)
+		for mapIter.Next() {
+			var (
+				mapKeyValue = mapIter.Value()
+				mapValue    interface{}
+			)
+			switch {
+			case mapKeyValue.IsZero():
+				if utils.CanCallIsNil(mapKeyValue) && mapKeyValue.IsNil() {
+					// quick check for nil value.
+					mapValue = nil
+				} else {
+					// in case of:
+					// exception recovered: reflect: call of reflect.Value.Interface on zero Value
+					mapValue = reflect.New(mapKeyValue.Type()).Elem().Interface()
+				}
+			default:
+				mapValue = mapKeyValue.Interface()
+			}
+			s, err := c.String(mapIter.Key().Interface())
+			if err != nil && !in.Option.ContinueOnError {
+				return nil, err
+			}
+			dataMap[s], err = c.doMapConvertForMapOrStructValue(
+				doMapConvertForMapOrStructValueInput{
+					IsRoot:          false,
+					Value:           mapValue,
+					RecursiveType:   in.RecursiveType,
+					RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+					Option:          in.Option,
+				},
+			)
+			if err != nil && !in.Option.ContinueOnError {
+				return nil, err
+			}
+		}
+		return dataMap, nil
+
+	case reflect.Struct:
+		var dataMap = make(map[string]interface{})
+		// Map converting interface check.
+		if v, ok := in.Value.(localinterface.IMapStrAny); ok {
+			// Value copy, in case of concurrent safety.
+			for mapK, mapV := range v.MapStrAny() {
+				if in.RecursiveOption {
+					dataMap[mapK], err = c.doMapConvertForMapOrStructValue(
+						doMapConvertForMapOrStructValueInput{
+							IsRoot:          false,
+							Value:           mapV,
+							RecursiveType:   in.RecursiveType,
+							RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+							Option:          in.Option,
+						},
+					)
+					if err != nil && !in.Option.ContinueOnError {
+						return nil, err
+					}
+				} else {
+					dataMap[mapK] = mapV
+				}
+			}
+			if len(dataMap) > 0 {
+				return dataMap, nil
+			}
+		}
+		// Using reflect for converting.
+		var (
+			rtField     reflect.StructField
+			rvField     reflect.Value
+			reflectType = reflectValue.Type() // attribute value type.
+			mapKey      = ""                  // mapKey may be the tag name or the struct attribute name.
+		)
+		for i := 0; i < reflectValue.NumField(); i++ {
+			rtField = reflectType.Field(i)
+			rvField = reflectValue.Field(i)
+			// Only convert the public attributes.
+			fieldName := rtField.Name
+			if !utils.IsLetterUpper(fieldName[0]) {
+				continue
+			}
+			mapKey = ""
+			fieldTag := rtField.Tag
+			for _, tag := range in.Option.Tags {
+				if mapKey = fieldTag.Get(tag); mapKey != "" {
+					break
+				}
+			}
+			if mapKey == "" {
+				mapKey = fieldName
+			} else {
+				// Support json tag feature: -, omitempty
+				mapKey = strings.TrimSpace(mapKey)
+				if mapKey == "-" {
+					continue
+				}
+				array := strings.Split(mapKey, ",")
+				if len(array) > 1 {
+					switch strings.TrimSpace(array[1]) {
+					case "omitempty":
+						if in.Option.OmitEmpty && empty.IsEmpty(rvField.Interface()) {
+							continue
+						} else {
+							mapKey = strings.TrimSpace(array[0])
+						}
+					default:
+						mapKey = strings.TrimSpace(array[0])
+					}
+				}
+				if mapKey == "" {
+					mapKey = fieldName
+				}
+			}
+			if in.RecursiveOption || rtField.Anonymous {
+				// Do map converting recursively.
+				var (
+					rvAttrField = rvField
+					rvAttrKind  = rvField.Kind()
+				)
+				if rvAttrKind == reflect.Ptr {
+					rvAttrField = rvField.Elem()
+					rvAttrKind = rvAttrField.Kind()
+				}
+				switch rvAttrKind {
+				case reflect.Struct:
+					// Embedded struct and has no fields, just ignores it.
+					// Eg: gmeta.Meta
+					if rvAttrField.Type().NumField() == 0 {
+						continue
+					}
+					var (
+						hasNoTag = mapKey == fieldName
+						// DO NOT use rvAttrField.Interface() here,
+						// as it might be changed from pointer to struct.
+						rvInterface = rvField.Interface()
+					)
+					switch {
+					case hasNoTag && rtField.Anonymous:
+						// It means this attribute field has no tag.
+						// Overwrite the attribute with sub-struct attribute fields.
+						anonymousValue, err := c.doMapConvertForMapOrStructValue(
+							doMapConvertForMapOrStructValueInput{
+								IsRoot:          false,
+								Value:           rvInterface,
+								RecursiveType:   in.RecursiveType,
+								RecursiveOption: true,
+								Option:          in.Option,
+							},
+						)
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+						if m, ok := anonymousValue.(map[string]interface{}); ok {
+							for k, v := range m {
+								dataMap[k] = v
+							}
+						} else {
+							dataMap[mapKey] = rvInterface
+						}
+
+					// It means this attribute field has desired tag.
+					case !hasNoTag && rtField.Anonymous:
+						dataMap[mapKey], err = c.doMapConvertForMapOrStructValue(
+							doMapConvertForMapOrStructValueInput{
+								IsRoot:          false,
+								Value:           rvInterface,
+								RecursiveType:   in.RecursiveType,
+								RecursiveOption: true,
+								Option:          in.Option,
+							},
+						)
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+
+					default:
+						dataMap[mapKey], err = c.doMapConvertForMapOrStructValue(
+							doMapConvertForMapOrStructValueInput{
+								IsRoot:          false,
+								Value:           rvInterface,
+								RecursiveType:   in.RecursiveType,
+								RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+								Option:          in.Option,
+							},
+						)
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+					}
+
+				// The struct attribute is type of slice.
+				case reflect.Array, reflect.Slice:
+					length := rvAttrField.Len()
+					if length == 0 {
+						dataMap[mapKey] = rvAttrField.Interface()
+						break
+					}
+					array := make([]interface{}, length)
+					for arrayIndex := 0; arrayIndex < length; arrayIndex++ {
+						array[arrayIndex], err = c.doMapConvertForMapOrStructValue(
+							doMapConvertForMapOrStructValueInput{
+								IsRoot:          false,
+								Value:           rvAttrField.Index(arrayIndex).Interface(),
+								RecursiveType:   in.RecursiveType,
+								RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+								Option:          in.Option,
+							},
+						)
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+					}
+					dataMap[mapKey] = array
+				case reflect.Map:
+					var (
+						mapIter   = rvAttrField.MapRange()
+						nestedMap = make(map[string]interface{})
+					)
+					for mapIter.Next() {
+						s, err := c.String(mapIter.Key().Interface())
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+						nestedMap[s], err = c.doMapConvertForMapOrStructValue(
+							doMapConvertForMapOrStructValueInput{
+								IsRoot:          false,
+								Value:           mapIter.Value().Interface(),
+								RecursiveType:   in.RecursiveType,
+								RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+								Option:          in.Option,
+							},
+						)
+						if err != nil && !in.Option.ContinueOnError {
+							return nil, err
+						}
+					}
+					dataMap[mapKey] = nestedMap
+				default:
+					if rvField.IsValid() {
+						dataMap[mapKey] = reflectValue.Field(i).Interface()
+					} else {
+						dataMap[mapKey] = nil
+					}
+				}
+			} else {
+				// No recursive map value converting
+				if rvField.IsValid() {
+					dataMap[mapKey] = reflectValue.Field(i).Interface()
+				} else {
+					dataMap[mapKey] = nil
+				}
+			}
+		}
+		if !in.MustMapReturn && len(dataMap) == 0 {
+			return in.Value, nil
+		}
+		return dataMap, nil
+
+	// The given value is type of slice.
+	case reflect.Array, reflect.Slice:
+		length := reflectValue.Len()
+		if length == 0 {
+			break
+		}
+		array := make([]interface{}, reflectValue.Len())
+		for i := 0; i < length; i++ {
+			array[i], err = c.doMapConvertForMapOrStructValue(doMapConvertForMapOrStructValueInput{
+				IsRoot:          false,
+				Value:           reflectValue.Index(i).Interface(),
+				RecursiveType:   in.RecursiveType,
+				RecursiveOption: in.RecursiveType == RecursiveTypeTrue,
+				Option:          in.Option,
+			})
+			if err != nil && !in.Option.ContinueOnError {
+				return nil, err
+			}
+		}
+		return array, nil
+
+	default:
+	}
+	return in.Value, nil
+}

util/gconv/internal/converter/converter_maptomap.go

@@ -0,0 +1,140 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+// MapToMap converts any map type variable `params` to another map type variable `pointer`.
+//
+// The parameter `params` can be any type of map, like:
+// map[string]string, map[string]struct, map[string]*struct, reflect.Value, etc.
+//
+// The parameter `pointer` should be type of *map, like:
+// map[int]string, map[string]struct, map[string]*struct, reflect.Value, etc.
+//
+// The optional parameter `mapping` is used for struct attribute to map key mapping, which makes
+// sense only if the items of original map `params` is type struct.
+func (c *Converter) MapToMap(
+	params, pointer any, mapping map[string]string, option MapOption,
+) (err error) {
+	var (
+		paramsRv   reflect.Value
+		paramsKind reflect.Kind
+	)
+	if v, ok := params.(reflect.Value); ok {
+		paramsRv = v
+	} else {
+		paramsRv = reflect.ValueOf(params)
+	}
+	paramsKind = paramsRv.Kind()
+	if paramsKind == reflect.Ptr {
+		paramsRv = paramsRv.Elem()
+		paramsKind = paramsRv.Kind()
+	}
+	if paramsKind != reflect.Map {
+		m, err := c.Map(params, option)
+		if err != nil {
+			return err
+		}
+		return c.MapToMap(m, pointer, mapping, option)
+	}
+	// Empty params map, no need continue.
+	if paramsRv.Len() == 0 {
+		return nil
+	}
+	var pointerRv reflect.Value
+	if v, ok := pointer.(reflect.Value); ok {
+		pointerRv = v
+	} else {
+		pointerRv = reflect.ValueOf(pointer)
+	}
+	pointerKind := pointerRv.Kind()
+	for pointerKind == reflect.Ptr {
+		pointerRv = pointerRv.Elem()
+		pointerKind = pointerRv.Kind()
+	}
+	if pointerKind != reflect.Map {
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			`destination pointer should be type of *map, but got: %s`,
+			pointerKind,
+		)
+	}
+	defer func() {
+		// Catch the panic, especially the reflection operation panics.
+		if exception := recover(); exception != nil {
+			if v, ok := exception.(error); ok && gerror.HasStack(v) {
+				err = v
+			} else {
+				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
+			}
+		}
+	}()
+	var (
+		paramsKeys       = paramsRv.MapKeys()
+		pointerKeyType   = pointerRv.Type().Key()
+		pointerValueType = pointerRv.Type().Elem()
+		pointerValueKind = pointerValueType.Kind()
+		dataMap          = reflect.MakeMapWithSize(pointerRv.Type(), len(paramsKeys))
+		convertOption    = ConvertOption{
+			StructOption: StructOption{ContinueOnError: option.ContinueOnError},
+			SliceOption:  SliceOption{ContinueOnError: option.ContinueOnError},
+			MapOption:    option,
+		}
+	)
+	// Retrieve the true element type of target map.
+	if pointerValueKind == reflect.Ptr {
+		pointerValueKind = pointerValueType.Elem().Kind()
+	}
+	for _, key := range paramsKeys {
+		mapValue := reflect.New(pointerValueType).Elem()
+		switch pointerValueKind {
+		case reflect.Map, reflect.Struct:
+			structOption := StructOption{
+				ParamKeyToAttrMap: mapping,
+				PriorityTag:       "",
+				ContinueOnError:   option.ContinueOnError,
+			}
+			if err = c.Struct(paramsRv.MapIndex(key).Interface(), mapValue, structOption); err != nil {
+				return err
+			}
+		default:
+			convertResult, err := c.doConvert(
+				doConvertInput{
+					FromValue:  paramsRv.MapIndex(key).Interface(),
+					ToTypeName: pointerValueType.String(),
+					ReferValue: mapValue,
+				},
+				convertOption,
+			)
+			if err != nil {
+				return err
+			}
+			mapValue.Set(reflect.ValueOf(convertResult))
+		}
+		convertResult, err := c.doConvert(
+			doConvertInput{
+				FromValue:  key.Interface(),
+				ToTypeName: pointerKeyType.Name(),
+				ReferValue: reflect.New(pointerKeyType).Elem().Interface(),
+			},
+			convertOption,
+		)
+		if err != nil {
+			return err
+		}
+		var mapKey = reflect.ValueOf(convertResult)
+		dataMap.SetMapIndex(mapKey, mapValue)
+	}
+	pointerRv.Set(dataMap)
+	return nil
+}

util/gconv/internal/converter/converter_maptomaps.go

@@ -0,0 +1,122 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+// MapToMaps converts any map type variable `params` to another map slice variable `pointer`.
+//
+// The parameter `params` can be type of []map, []*map, []struct, []*struct.
+//
+// The parameter `pointer` should be type of []map, []*map.
+//
+// The optional parameter `mapping` is used for struct attribute to map key mapping, which makes
+// sense only if the item of `params` is type struct.
+func (c *Converter) MapToMaps(
+	params any, pointer any, paramKeyToAttrMap map[string]string, option MapOption,
+) (err error) {
+	// Params and its element type check.
+	var (
+		paramsRv   reflect.Value
+		paramsKind reflect.Kind
+	)
+	if v, ok := params.(reflect.Value); ok {
+		paramsRv = v
+	} else {
+		paramsRv = reflect.ValueOf(params)
+	}
+	paramsKind = paramsRv.Kind()
+	if paramsKind == reflect.Ptr {
+		paramsRv = paramsRv.Elem()
+		paramsKind = paramsRv.Kind()
+	}
+	if paramsKind != reflect.Array && paramsKind != reflect.Slice {
+		return gerror.NewCode(
+			gcode.CodeInvalidParameter,
+			"params should be type of slice, example: []map/[]*map/[]struct/[]*struct",
+		)
+	}
+	var (
+		paramsElem     = paramsRv.Type().Elem()
+		paramsElemKind = paramsElem.Kind()
+	)
+	if paramsElemKind == reflect.Ptr {
+		paramsElem = paramsElem.Elem()
+		paramsElemKind = paramsElem.Kind()
+	}
+	if paramsElemKind != reflect.Map &&
+		paramsElemKind != reflect.Struct &&
+		paramsElemKind != reflect.Interface {
+		return gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			"params element should be type of map/*map/struct/*struct, but got: %s",
+			paramsElemKind,
+		)
+	}
+	// Empty slice, no need continue.
+	if paramsRv.Len() == 0 {
+		return nil
+	}
+	// Pointer and its element type check.
+	var (
+		pointerRv   = reflect.ValueOf(pointer)
+		pointerKind = pointerRv.Kind()
+	)
+	for pointerKind == reflect.Ptr {
+		pointerRv = pointerRv.Elem()
+		pointerKind = pointerRv.Kind()
+	}
+	if pointerKind != reflect.Array && pointerKind != reflect.Slice {
+		return gerror.NewCode(gcode.CodeInvalidParameter, "pointer should be type of *[]map/*[]*map")
+	}
+	var (
+		pointerElemType = pointerRv.Type().Elem()
+		pointerElemKind = pointerElemType.Kind()
+	)
+	if pointerElemKind == reflect.Ptr {
+		pointerElemKind = pointerElemType.Elem().Kind()
+	}
+	if pointerElemKind != reflect.Map {
+		return gerror.NewCode(gcode.CodeInvalidParameter, "pointer element should be type of map/*map")
+	}
+	defer func() {
+		// Catch the panic, especially the reflection operation panics.
+		if exception := recover(); exception != nil {
+			if v, ok := exception.(error); ok && gerror.HasStack(v) {
+				err = v
+			} else {
+				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
+			}
+		}
+	}()
+	var (
+		pointerSlice = reflect.MakeSlice(pointerRv.Type(), paramsRv.Len(), paramsRv.Len())
+	)
+	for i := 0; i < paramsRv.Len(); i++ {
+		var item reflect.Value
+		if pointerElemType.Kind() == reflect.Ptr {
+			item = reflect.New(pointerElemType.Elem())
+			if err = c.MapToMap(paramsRv.Index(i).Interface(), item, paramKeyToAttrMap, option); err != nil {
+				return err
+			}
+			pointerSlice.Index(i).Set(item)
+		} else {
+			item = reflect.New(pointerElemType)
+			if err = c.MapToMap(paramsRv.Index(i).Interface(), item, paramKeyToAttrMap, option); err != nil {
+				return err
+			}
+			pointerSlice.Index(i).Set(item.Elem())
+		}
+	}
+	pointerRv.Set(pointerSlice)
+	return
+}

util/gconv/internal/converter/converter_rune.go

@@ -0,0 +1,31 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+// Rune converts `any` to rune.
+func (c *Converter) Rune(any any) (rune, error) {
+	if v, ok := any.(rune); ok {
+		return v, nil
+	}
+	v, err := c.Int32(any)
+	if err != nil {
+		return 0, err
+	}
+	return v, nil
+}
+
+// Runes converts `any` to []rune.
+func (c *Converter) Runes(any any) ([]rune, error) {
+	if v, ok := any.([]rune); ok {
+		return v, nil
+	}
+	s, err := c.String(any)
+	if err != nil {
+		return nil, err
+	}
+	return []rune(s), nil
+}

util/gconv/internal/converter/converter_scan.go

@@ -0,0 +1,395 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// ScanOption is the option for the Scan function.
+type ScanOption struct {
+	// ParamKeyToAttrMap specifies the mapping between parameter keys and struct attribute names.
+	ParamKeyToAttrMap map[string]string
+
+	// ContinueOnError specifies whether to continue converting the next element
+	// if one element converting fails.
+	ContinueOnError bool
+}
+
+// Scan automatically checks the type of `pointer` and converts `params` to `pointer`.
+func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err error) {
+	// Check if srcValue is nil, in which case no conversion is needed
+	if srcValue == nil {
+		return nil
+	}
+	// Check if dstPointer is nil, which is an invalid parameter
+	if dstPointer == nil {
+		return gerror.NewCode(
+			gcode.CodeInvalidParameter,
+			`destination pointer should not be nil`,
+		)
+	}
+
+	// Get the reflection type and value of dstPointer
+	var (
+		dstPointerReflectType  reflect.Type
+		dstPointerReflectValue reflect.Value
+	)
+	if v, ok := dstPointer.(reflect.Value); ok {
+		dstPointerReflectValue = v
+		dstPointerReflectType = v.Type()
+	} else {
+		dstPointerReflectValue = reflect.ValueOf(dstPointer)
+		// Do not use dstPointerReflectValue.Type() as dstPointerReflectValue might be zero
+		dstPointerReflectType = reflect.TypeOf(dstPointer)
+	}
+
+	// Validate the kind of dstPointer
+	var dstPointerReflectKind = dstPointerReflectType.Kind()
+	if dstPointerReflectKind != reflect.Ptr {
+		// If dstPointer is not a pointer, try to get its address
+		if dstPointerReflectValue.CanAddr() {
+			dstPointerReflectValue = dstPointerReflectValue.Addr()
+			dstPointerReflectType = dstPointerReflectValue.Type()
+			dstPointerReflectKind = dstPointerReflectType.Kind()
+		} else {
+			// If dstPointer is not a pointer and cannot be addressed, return an error
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				`destination pointer should be type of pointer, but got type: %v`,
+				dstPointerReflectType,
+			)
+		}
+	}
+
+	// Get the reflection value of srcValue
+	var srcValueReflectValue reflect.Value
+	if v, ok := srcValue.(reflect.Value); ok {
+		srcValueReflectValue = v
+	} else {
+		srcValueReflectValue = reflect.ValueOf(srcValue)
+	}
+
+	// Get the element type and kind of dstPointer
+	var (
+		dstPointerReflectValueElem     = dstPointerReflectValue.Elem()
+		dstPointerReflectValueElemKind = dstPointerReflectValueElem.Kind()
+	)
+	// Handle multiple level pointers
+	if dstPointerReflectValueElemKind == reflect.Ptr {
+		if dstPointerReflectValueElem.IsNil() {
+			// Create a new value for the pointer dereference
+			nextLevelPtr := reflect.New(dstPointerReflectValueElem.Type().Elem())
+			// Recursively scan into the dereferenced pointer
+			if err = c.Scan(srcValueReflectValue, nextLevelPtr, option); err == nil {
+				dstPointerReflectValueElem.Set(nextLevelPtr)
+			}
+			return
+		}
+		return c.Scan(srcValueReflectValue, dstPointerReflectValueElem, option)
+	}
+
+	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed
+	if ok := c.doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem); ok {
+		return nil
+	}
+
+	// Handle different destination types
+	switch dstPointerReflectValueElemKind {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		v, err := c.Int64(srcValue)
+		if err != nil && !option.ContinueOnError {
+			return err
+		}
+		dstPointerReflectValueElem.SetInt(v)
+		return nil
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		v, err := c.Uint64(srcValue)
+		if err != nil && !option.ContinueOnError {
+			return err
+		}
+		dstPointerReflectValueElem.SetUint(v)
+		return nil
+
+	case reflect.Float32, reflect.Float64:
+		v, err := c.Float64(srcValue)
+		if err != nil && !option.ContinueOnError {
+			return err
+		}
+		dstPointerReflectValueElem.SetFloat(v)
+		return nil
+
+	case reflect.String:
+		v, err := c.String(srcValue)
+		if err != nil && !option.ContinueOnError {
+			return err
+		}
+		dstPointerReflectValueElem.SetString(v)
+		return nil
+
+	case reflect.Bool:
+		v, err := c.Bool(srcValue)
+		if err != nil && !option.ContinueOnError {
+			return err
+		}
+		dstPointerReflectValueElem.SetBool(v)
+		return nil
+
+	case reflect.Slice:
+		// Handle slice type conversion
+		var (
+			dstElemType = dstPointerReflectValueElem.Type().Elem()
+			dstElemKind = dstElemType.Kind()
+		)
+		// The slice element might be a pointer type
+		if dstElemKind == reflect.Ptr {
+			dstElemType = dstElemType.Elem()
+			dstElemKind = dstElemType.Kind()
+		}
+		// Special handling for struct or map slice elements
+		if dstElemKind == reflect.Struct || dstElemKind == reflect.Map {
+			return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+		}
+		// Handle basic type slice conversions
+		var srcValueReflectValueKind = srcValueReflectValue.Kind()
+		if srcValueReflectValueKind == reflect.Slice || srcValueReflectValueKind == reflect.Array {
+			var (
+				srcLen   = srcValueReflectValue.Len()
+				newSlice = reflect.MakeSlice(dstPointerReflectValueElem.Type(), srcLen, srcLen)
+			)
+			for i := 0; i < srcLen; i++ {
+				srcElem := srcValueReflectValue.Index(i).Interface()
+				switch dstElemType.Kind() {
+				case reflect.String:
+					v, err := c.String(srcElem)
+					if err != nil && !option.ContinueOnError {
+						return err
+					}
+					newSlice.Index(i).SetString(v)
+				case reflect.Int:
+					v, err := c.Int64(srcElem)
+					if err != nil && !option.ContinueOnError {
+						return err
+					}
+					newSlice.Index(i).SetInt(v)
+				case reflect.Int64:
+					v, err := c.Int64(srcElem)
+					if err != nil && !option.ContinueOnError {
+						return err
+					}
+					newSlice.Index(i).SetInt(v)
+				case reflect.Float64:
+					v, err := c.Float64(srcElem)
+					if err != nil && !option.ContinueOnError {
+						return err
+					}
+					newSlice.Index(i).SetFloat(v)
+				case reflect.Bool:
+					v, err := c.Bool(srcElem)
+					if err != nil && !option.ContinueOnError {
+						return err
+					}
+					newSlice.Index(i).SetBool(v)
+				default:
+					return c.Scan(
+						srcElem, newSlice.Index(i).Addr().Interface(), option,
+					)
+				}
+			}
+			dstPointerReflectValueElem.Set(newSlice)
+			return nil
+		}
+		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+
+	default:
+		// Handle complex types (structs, maps, etc.)
+		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+	}
+}
+
+// doScanForComplicatedTypes handles the scanning of complex data types.
+// It supports converting between maps, structs, and slices of these types.
+// The function first attempts JSON conversion, then falls back to specific type handling.
+//
+// It supports `pointer` in type of `*map/*[]map/*[]*map/*struct/**struct/*[]struct/*[]*struct` for converting.
+//
+// Parameters:
+// - srcValue: The source value to convert from
+// - dstPointer: The destination pointer to convert to
+// - dstPointerReflectType: The reflection type of the destination pointer
+// - paramKeyToAttrMap: Optional mapping between parameter keys and struct attribute names
+func (c *Converter) doScanForComplicatedTypes(
+	srcValue, dstPointer any,
+	dstPointerReflectType reflect.Type,
+	option ScanOption,
+) error {
+	// Try JSON conversion first
+	ok, err := c.doConvertWithJsonCheck(srcValue, dstPointer)
+	if err != nil {
+		return err
+	}
+	if ok {
+		return nil
+	}
+
+	// Handle specific type conversions
+	var (
+		dstPointerReflectTypeElem     = dstPointerReflectType.Elem()
+		dstPointerReflectTypeElemKind = dstPointerReflectTypeElem.Kind()
+		keyToAttributeNameMapping     = option.ParamKeyToAttrMap
+	)
+	// Handle different destination types
+	switch dstPointerReflectTypeElemKind {
+	case reflect.Map:
+		// Convert map to map
+		return c.MapToMap(srcValue, dstPointer, keyToAttributeNameMapping, MapOption{
+			ContinueOnError: option.ContinueOnError,
+		})
+
+	case reflect.Array, reflect.Slice:
+		var (
+			sliceElem     = dstPointerReflectTypeElem.Elem()
+			sliceElemKind = sliceElem.Kind()
+		)
+		// Handle pointer elements
+		for sliceElemKind == reflect.Ptr {
+			sliceElem = sliceElem.Elem()
+			sliceElemKind = sliceElem.Kind()
+		}
+		if sliceElemKind == reflect.Map {
+			// Convert to slice of maps
+			return c.MapToMaps(srcValue, dstPointer, keyToAttributeNameMapping, MapOption{
+				ContinueOnError: option.ContinueOnError,
+			})
+		}
+		// Convert to slice of structs
+		var (
+			sliceOption = SliceOption{
+				ContinueOnError: option.ContinueOnError,
+			}
+			mapOption = StructOption{
+				ParamKeyToAttrMap: keyToAttributeNameMapping,
+				ContinueOnError:   option.ContinueOnError,
+			}
+		)
+		return c.Structs(srcValue, dstPointer, sliceOption, mapOption)
+
+	default:
+		structOption := StructOption{
+			ParamKeyToAttrMap: keyToAttributeNameMapping,
+			PriorityTag:       "",
+			ContinueOnError:   option.ContinueOnError,
+		}
+		return c.Struct(srcValue, dstPointer, structOption)
+	}
+}
+
+// doConvertWithTypeCheck supports `pointer` in type of `*map/*[]map/*[]*map/*struct/**struct/*[]struct/*[]*struct`
+// for converting.
+func (c *Converter) doConvertWithTypeCheck(srcValueReflectValue, dstPointerReflectValueElem reflect.Value) (ok bool) {
+	if !dstPointerReflectValueElem.IsValid() || !srcValueReflectValue.IsValid() {
+		return false
+	}
+	switch {
+	// Examples:
+	// UploadFile       => UploadFile
+	// []UploadFile     => []UploadFile
+	// *UploadFile      => *UploadFile
+	// *[]UploadFile    => *[]UploadFile
+	// map[int][int]    => map[int][int]
+	// []map[int][int]  => []map[int][int]
+	// *[]map[int][int] => *[]map[int][int]
+	case dstPointerReflectValueElem.Type() == srcValueReflectValue.Type():
+		dstPointerReflectValueElem.Set(srcValueReflectValue)
+		return true
+
+	// Examples:
+	// UploadFile      => *UploadFile
+	// []UploadFile    => *[]UploadFile
+	// map[int][int]   => *map[int][int]
+	// []map[int][int] => *[]map[int][int]
+	case dstPointerReflectValueElem.Kind() == reflect.Ptr &&
+		dstPointerReflectValueElem.Elem().IsValid() &&
+		dstPointerReflectValueElem.Elem().Type() == srcValueReflectValue.Type():
+		dstPointerReflectValueElem.Elem().Set(srcValueReflectValue)
+		return true
+
+	// Examples:
+	// *UploadFile      => UploadFile
+	// *[]UploadFile    => []UploadFile
+	// *map[int][int]   => map[int][int]
+	// *[]map[int][int] => []map[int][int]
+	case srcValueReflectValue.Kind() == reflect.Ptr &&
+		srcValueReflectValue.Elem().IsValid() &&
+		dstPointerReflectValueElem.Type() == srcValueReflectValue.Elem().Type():
+		dstPointerReflectValueElem.Set(srcValueReflectValue.Elem())
+		return true
+
+	default:
+		return false
+	}
+}
+
+// doConvertWithJsonCheck attempts to convert the source value to the destination
+// using JSON marshaling and unmarshaling. This is particularly useful for complex
+// types that can be represented as JSON.
+//
+// Parameters:
+// - srcValue: The source value to convert from
+// - dstPointer: The destination pointer to convert to
+//
+// Returns:
+// - bool: true if JSON conversion was successful
+// - error: any error that occurred during conversion
+func (c *Converter) doConvertWithJsonCheck(srcValue any, dstPointer any) (ok bool, err error) {
+	switch valueResult := srcValue.(type) {
+	case []byte:
+		if json.Valid(valueResult) {
+			if dstPointerReflectType, ok := dstPointer.(reflect.Value); ok {
+				if dstPointerReflectType.Kind() == reflect.Ptr {
+					if dstPointerReflectType.IsNil() {
+						return false, nil
+					}
+					return true, json.UnmarshalUseNumber(valueResult, dstPointerReflectType.Interface())
+				} else if dstPointerReflectType.CanAddr() {
+					return true, json.UnmarshalUseNumber(valueResult, dstPointerReflectType.Addr().Interface())
+				}
+			} else {
+				return true, json.UnmarshalUseNumber(valueResult, dstPointer)
+			}
+		}
+
+	case string:
+		if valueBytes := []byte(valueResult); json.Valid(valueBytes) {
+			if dstPointerReflectType, ok := dstPointer.(reflect.Value); ok {
+				if dstPointerReflectType.Kind() == reflect.Ptr {
+					if dstPointerReflectType.IsNil() {
+						return false, nil
+					}
+					return true, json.UnmarshalUseNumber(valueBytes, dstPointerReflectType.Interface())
+				} else if dstPointerReflectType.CanAddr() {
+					return true, json.UnmarshalUseNumber(valueBytes, dstPointerReflectType.Addr().Interface())
+				}
+			} else {
+				return true, json.UnmarshalUseNumber(valueBytes, dstPointer)
+			}
+		}
+
+	default:
+		// The `params` might be struct that implements interface function Interface, eg: gvar.Var.
+		if v, ok := srcValue.(localinterface.IInterface); ok {
+			return c.doConvertWithJsonCheck(v.Interface(), dstPointer)
+		}
+	}
+	return false, nil
+}

util/gconv/internal/converter/converter_slice_any.go

@@ -0,0 +1,143 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceOption is the option for Slice type converting.
+type SliceOption struct {
+	// ContinueOnError specifies whether to continue converting the next element
+	// if one element converting fails.
+	ContinueOnError bool
+}
+
+// SliceAny converts `any` to []any.
+func (c *Converter) SliceAny(any interface{}, option SliceOption) ([]any, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		array []interface{}
+	)
+	switch value := any.(type) {
+	case []interface{}:
+		array = value
+	case []string:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []int:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []int8:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []int16:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []int32:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []int64:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []uint:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+
+	case []uint16:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []uint32:
+		for _, v := range value {
+			array = append(array, v)
+		}
+	case []uint64:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []bool:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []float32:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	case []float64:
+		array = make([]interface{}, len(value))
+		for k, v := range value {
+			array[k] = v
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return v.Interfaces(), err
+	}
+
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]interface{}, length)
+		)
+		for i := 0; i < length; i++ {
+			slice[i] = originValueAndKind.OriginValue.Index(i).Interface()
+		}
+		return slice, err
+
+	default:
+		return []interface{}{any}, err
+	}
+}

util/gconv/internal/converter/converter_slice_float.go

@@ -0,0 +1,417 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceFloat32 converts `any` to []float32.
+func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		f     float32
+		array []float32 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int8:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int16:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int32:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int64:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []float32{}, err
+		}
+		if utils.IsNumeric(value) {
+			f, err = c.Float32(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []float32{f}, err
+		}
+	case []uint16:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint32:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint64:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []bool:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []float32:
+		array = value
+	case []float64:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []interface{}:
+		array = make([]float32, len(value))
+		for k, v := range value {
+			f, err = c.Float32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IFloats); ok {
+		return c.SliceFloat32(v.Floats(), option)
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceFloat32(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]float32, length)
+		)
+		for i := 0; i < length; i++ {
+			f, err = c.Float32(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = f
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []float32{}, err
+		}
+		f, err = c.Float32(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []float32{f}, err
+	}
+}
+
+// SliceFloat64 converts `any` to []float64.
+func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		f     float64
+		array []float64 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int8:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int16:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int32:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []int64:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []float64{}, err
+		}
+		if utils.IsNumeric(value) {
+			f, err = c.Float64(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []float64{f}, err
+		}
+	case []uint16:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint32:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []uint64:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []bool:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []float32:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	case []float64:
+		array = value
+	case []interface{}:
+		array = make([]float64, len(value))
+		for k, v := range value {
+			f, err = c.Float64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = f
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IFloats); ok {
+		return v.Floats(), err
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceFloat64(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]float64, length)
+		)
+		for i := 0; i < length; i++ {
+			f, err = c.Float64(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = f
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []float64{}, err
+		}
+		f, err = c.Float64(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []float64{f}, err
+	}
+}

util/gconv/internal/converter/converter_slice_int.go

@@ -0,0 +1,536 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceInt converts `any` to []int.
+func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ii    int
+		array []int = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]int, len(value))
+		for k, v := range value {
+			ii, err = c.Int(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []int:
+		array = value
+	case []int8:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []int16:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []int32:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []int64:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []uint:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []int{}, err
+		}
+		if utils.IsNumeric(value) {
+			ii, err = c.Int(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []int{ii}, err
+		}
+	case []uint16:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []uint32:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []uint64:
+		array = make([]int, len(value))
+		for k, v := range value {
+			array[k] = int(v)
+		}
+	case []bool:
+		array = make([]int, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]int, len(value))
+		for k, v := range value {
+			ii, err = c.Int(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []float64:
+		array = make([]int, len(value))
+		for k, v := range value {
+			ii, err = c.Int(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []interface{}:
+		array = make([]int, len(value))
+		for k, v := range value {
+			ii, err = c.Int(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case [][]byte:
+		array = make([]int, len(value))
+		for k, v := range value {
+			ii, err = c.Int(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IInts); ok {
+		return v.Ints(), err
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceInt(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]int, length)
+		)
+		for i := 0; i < length; i++ {
+			ii, err = c.Int(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ii
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []int{}, err
+		}
+		ii, err = c.Int(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []int{ii}, err
+	}
+}
+
+// SliceInt32 converts `any` to []int32.
+func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ii    int32
+		array []int32 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			ii, err = c.Int32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []int:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []int8:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []int16:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []int32:
+		array = value
+	case []int64:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []uint:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []int32{}, err
+		}
+		if utils.IsNumeric(value) {
+			ii, err = c.Int32(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []int32{ii}, err
+		}
+	case []uint16:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []uint32:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []uint64:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			array[k] = int32(v)
+		}
+	case []bool:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			ii, err = c.Int32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []float64:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			ii, err = c.Int32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []interface{}:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			ii, err = c.Int32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case [][]byte:
+		array = make([]int32, len(value))
+		for k, v := range value {
+			ii, err = c.Int32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IInts); ok {
+		return c.SliceInt32(v.Ints(), option)
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceInt32(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]int32, length)
+		)
+		for i := 0; i < length; i++ {
+			ii, err = c.Int32(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ii
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []int32{}, err
+		}
+		ii, err = c.Int32(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []int32{ii}, err
+	}
+}
+
+// SliceInt64 converts `any` to []int64.
+func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ii    int64
+		array []int64 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			ii, err = c.Int64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []int:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []int8:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []int16:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []int32:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []int64:
+		array = value
+	case []uint:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []int64{}, err
+		}
+		if utils.IsNumeric(value) {
+			ii, err = c.Int64(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []int64{ii}, err
+		}
+	case []uint16:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []uint32:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []uint64:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			array[k] = int64(v)
+		}
+	case []bool:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			ii, err = c.Int64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []float64:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			ii, err = c.Int64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case []interface{}:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			ii, err = c.Int64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	case [][]byte:
+		array = make([]int64, len(value))
+		for k, v := range value {
+			ii, err = c.Int64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ii
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IInts); ok {
+		return c.SliceInt64(v.Ints(), option)
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceInt64(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]int64, length)
+		)
+		for i := 0; i < length; i++ {
+			ii, err = c.Int64(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ii
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []int64{}, err
+		}
+		ii, err = c.Int64(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []int64{ii}, err
+	}
+}

util/gconv/internal/converter/converter_slice_map.go

@@ -0,0 +1,59 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import "github.com/gogf/gf/v2/internal/json"
+
+// SliceMap converts `value` to []map[string]any.
+// Note that it automatically checks and converts json string to []map if `value` is string/[]byte.
+func (c *Converter) SliceMap(value any, sliceOption SliceOption, mapOption MapOption) ([]map[string]any, error) {
+	if value == nil {
+		return nil, nil
+	}
+	switch r := value.(type) {
+	case string:
+		list := make([]map[string]any, 0)
+		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
+			if err := json.UnmarshalUseNumber([]byte(r), &list); err != nil {
+				return nil, err
+			}
+			return list, nil
+		}
+		return nil, nil
+
+	case []byte:
+		list := make([]map[string]any, 0)
+		if len(r) > 0 && r[0] == '[' && r[len(r)-1] == ']' {
+			if err := json.UnmarshalUseNumber(r, &list); err != nil {
+				return nil, err
+			}
+			return list, nil
+		}
+		return nil, nil
+
+	case []map[string]any:
+		return r, nil
+
+	default:
+		array, err := c.SliceAny(value, sliceOption)
+		if err != nil {
+			return nil, err
+		}
+		if len(array) == 0 {
+			return nil, nil
+		}
+		list := make([]map[string]any, len(array))
+		for k, v := range array {
+			m, err := c.Map(v, mapOption)
+			if err != nil && !sliceOption.ContinueOnError {
+				return nil, err
+			}
+			list[k] = m
+		}
+		return list, nil
+	}
+}

util/gconv/internal/converter/converter_slice_str.go

@@ -0,0 +1,220 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceStr converts `any` to []string.
+func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		s     string
+		array []string = nil
+	)
+	switch value := any.(type) {
+	case []int:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []int8:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []int16:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []int32:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []int64:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []uint:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+		return array, err
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []string{}, err
+		}
+		return []string{value}, err
+	case []uint16:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []uint32:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []uint64:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []bool:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []float32:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []float64:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []interface{}:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	case []string:
+		array = value
+	case [][]byte:
+		array = make([]string, len(value))
+		for k, v := range value {
+			s, err = c.String(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = s
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	if v, ok := any.(localinterface.IStrings); ok {
+		return v.Strings(), err
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceStr(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]string, length)
+		)
+		for i := 0; i < length; i++ {
+			s, err = c.String(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = s
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []string{}, err
+		}
+		s, err = c.String(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []string{s}, err
+	}
+}

util/gconv/internal/converter/converter_slice_uint.go

@@ -0,0 +1,527 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/reflection"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// SliceUint converts `any` to []uint.
+func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ui    uint
+		array []uint = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			ui, err = c.Uint(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []int8:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []int16:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []int32:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []int64:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []uint:
+		array = value
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []uint{}, err
+		}
+		if utils.IsNumeric(value) {
+			ui, err = c.Uint(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []uint{ui}, err
+		}
+	case []uint16:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []uint32:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []uint64:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			array[k] = uint(v)
+		}
+	case []bool:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			ui, err = c.Uint(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []float64:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			ui, err = c.Uint(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []interface{}:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			ui, err = c.Uint(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case [][]byte:
+		array = make([]uint, len(value))
+		for k, v := range value {
+			ui, err = c.Uint(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	}
+
+	if array != nil {
+		return array, err
+	}
+
+	// Default handler.
+	if v, ok := any.(localinterface.IUints); ok {
+		return v.Uints(), err
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceUint(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]uint, length)
+		)
+		for i := 0; i < length; i++ {
+			ui, err = c.Uint(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ui
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []uint{}, err
+		}
+		ui, err = c.Uint(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []uint{ui}, err
+	}
+}
+
+// SliceUint32 converts `any` to []uint32.
+func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ui    uint32
+		array []uint32 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			ui, err = c.Uint32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []int8:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []int16:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []int32:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []int64:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []uint:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []uint32{}, err
+		}
+		if utils.IsNumeric(value) {
+			ui, err = c.Uint32(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []uint32{ui}, err
+		}
+	case []uint16:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []uint32:
+		array = value
+	case []uint64:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			array[k] = uint32(v)
+		}
+	case []bool:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			ui, err = c.Uint32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []float64:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			ui, err = c.Uint32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []interface{}:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			ui, err = c.Uint32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case [][]byte:
+		array = make([]uint32, len(value))
+		for k, v := range value {
+			ui, err = c.Uint32(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+
+	// Default handler.
+	if v, ok := any.(localinterface.IUints); ok {
+		return c.SliceUint32(v.Uints(), option)
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceUint32(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]uint32, length)
+		)
+		for i := 0; i < length; i++ {
+			ui, err = c.Uint32(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ui
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []uint32{}, err
+		}
+		ui, err = c.Uint32(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []uint32{ui}, err
+	}
+}
+
+// SliceUint64 converts `any` to []uint64.
+func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	var (
+		err   error
+		ui    uint64
+		array []uint64 = nil
+	)
+	switch value := any.(type) {
+	case []string:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			ui, err = c.Uint64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []int8:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []int16:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []int32:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []int64:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []uint:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []uint8:
+		if json.Valid(value) {
+			if err = json.UnmarshalUseNumber(value, &array); array != nil {
+				return array, err
+			}
+		}
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case string:
+		byteValue := []byte(value)
+		if json.Valid(byteValue) {
+			if err = json.UnmarshalUseNumber(byteValue, &array); array != nil {
+				return array, err
+			}
+		}
+		if value == "" {
+			return []uint64{}, err
+		}
+		if utils.IsNumeric(value) {
+			ui, err = c.Uint64(value)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			return []uint64{ui}, err
+		}
+	case []uint16:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []uint32:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			array[k] = uint64(v)
+		}
+	case []uint64:
+		array = value
+	case []bool:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			if v {
+				array[k] = 1
+			} else {
+				array[k] = 0
+			}
+		}
+	case []float32:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			ui, err = c.Uint64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []float64:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			ui, err = c.Uint64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case []interface{}:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			ui, err = c.Uint64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	case [][]byte:
+		array = make([]uint64, len(value))
+		for k, v := range value {
+			ui, err = c.Uint64(v)
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			array[k] = ui
+		}
+	}
+	if array != nil {
+		return array, err
+	}
+	// Default handler.
+	if v, ok := any.(localinterface.IUints); ok {
+		return c.SliceUint64(v.Uints(), option)
+	}
+	if v, ok := any.(localinterface.IInterfaces); ok {
+		return c.SliceUint64(v.Interfaces(), option)
+	}
+	// Not a common type, it then uses reflection for conversion.
+	originValueAndKind := reflection.OriginValueAndKind(any)
+	switch originValueAndKind.OriginKind {
+	case reflect.Slice, reflect.Array:
+		var (
+			length = originValueAndKind.OriginValue.Len()
+			slice  = make([]uint64, length)
+		)
+		for i := 0; i < length; i++ {
+			ui, err = c.Uint64(originValueAndKind.OriginValue.Index(i).Interface())
+			if err != nil && !option.ContinueOnError {
+				return nil, err
+			}
+			slice[i] = ui
+		}
+		return slice, err
+
+	default:
+		if originValueAndKind.OriginValue.IsZero() {
+			return []uint64{}, err
+		}
+		ui, err = c.Uint64(any)
+		if err != nil && !option.ContinueOnError {
+			return nil, err
+		}
+		return []uint64{ui}, err
+	}
+}

util/gconv/internal/converter/converter_string.go

@@ -0,0 +1,135 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"fmt"
+	"reflect"
+	"strconv"
+	"time"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+func (c *Converter) String(any any) (string, error) {
+	if empty.IsNil(any) {
+		return "", nil
+	}
+	switch value := any.(type) {
+	case int:
+		return strconv.Itoa(value), nil
+	case int8:
+		return strconv.Itoa(int(value)), nil
+	case int16:
+		return strconv.Itoa(int(value)), nil
+	case int32:
+		return strconv.Itoa(int(value)), nil
+	case int64:
+		return strconv.FormatInt(value, 10), nil
+	case uint:
+		return strconv.FormatUint(uint64(value), 10), nil
+	case uint8:
+		return strconv.FormatUint(uint64(value), 10), nil
+	case uint16:
+		return strconv.FormatUint(uint64(value), 10), nil
+	case uint32:
+		return strconv.FormatUint(uint64(value), 10), nil
+	case uint64:
+		return strconv.FormatUint(value, 10), nil
+	case float32:
+		return strconv.FormatFloat(float64(value), 'f', -1, 32), nil
+	case float64:
+		return strconv.FormatFloat(value, 'f', -1, 64), nil
+	case bool:
+		return strconv.FormatBool(value), nil
+	case string:
+		return value, nil
+	case []byte:
+		return string(value), nil
+	case complex64, complex128:
+		return fmt.Sprintf("%v", value), nil
+	case time.Time:
+		if value.IsZero() {
+			return "", nil
+		}
+		return value.String(), nil
+	case *time.Time:
+		if value == nil {
+			return "", nil
+		}
+		return value.String(), nil
+	case gtime.Time:
+		if value.IsZero() {
+			return "", nil
+		}
+		return value.String(), nil
+	case *gtime.Time:
+		if value == nil {
+			return "", nil
+		}
+		return value.String(), nil
+	default:
+		if f, ok := value.(localinterface.IString); ok {
+			// If the variable implements the String() interface,
+			// then use that interface to perform the conversion
+			return f.String(), nil
+		}
+		if f, ok := value.(localinterface.IError); ok {
+			// If the variable implements the Error() interface,
+			// then use that interface to perform the conversion
+			return f.Error(), nil
+		}
+		// Reflect checks.
+		var (
+			rv   = reflect.ValueOf(value)
+			kind = rv.Kind()
+		)
+		switch kind {
+		case
+			reflect.Chan,
+			reflect.Map,
+			reflect.Slice,
+			reflect.Func,
+			reflect.Interface,
+			reflect.UnsafePointer:
+			if rv.IsNil() {
+				return "", nil
+			}
+		case reflect.String:
+			return rv.String(), nil
+		case reflect.Ptr:
+			if rv.IsNil() {
+				return "", nil
+			}
+			return c.String(rv.Elem().Interface())
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+			return strconv.FormatInt(rv.Int(), 10), nil
+		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+			return strconv.FormatUint(rv.Uint(), 10), nil
+		case reflect.Uintptr:
+			return strconv.FormatUint(rv.Uint(), 10), nil
+		case reflect.Float32, reflect.Float64:
+			return strconv.FormatFloat(rv.Float(), 'f', -1, 64), nil
+		case reflect.Bool:
+			return strconv.FormatBool(rv.Bool()), nil
+		default:
+		}
+		// Finally, we use json.Marshal to convert.
+		jsonContent, err := json.Marshal(value)
+		if err != nil {
+			return fmt.Sprint(value), gerror.WrapCodef(
+				gcode.CodeInvalidParameter, err, "error marshaling value to JSON for: %v", value,
+			)
+		}
+		return string(jsonContent), nil
+	}
+}

util/gconv/internal/converter/converter_struct.go

@@ -0,0 +1,662 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+	"strings"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+	"github.com/gogf/gf/v2/util/gconv/internal/structcache"
+)
+
+// StructOption is the option for Struct converting.
+type StructOption struct {
+	// ParamKeyToAttrMap is the map for custom parameter key to attribute name mapping.
+	ParamKeyToAttrMap map[string]string
+
+	// PriorityTag is the priority tag for struct converting.
+	PriorityTag string
+
+	// ContinueOnError specifies whether to continue converting the next element
+	// if one element converting fails.
+	ContinueOnError bool
+}
+
+// Struct is the core internal converting function for any data to struct.
+func (c *Converter) Struct(params, pointer any, option StructOption) (err error) {
+	if params == nil {
+		// If `params` is nil, no conversion.
+		return nil
+	}
+	if pointer == nil {
+		return gerror.NewCode(gcode.CodeInvalidParameter, "object pointer cannot be nil")
+	}
+
+	// JSON content converting.
+	ok, err := c.doConvertWithJsonCheck(params, pointer)
+	if err != nil {
+		return err
+	}
+	if ok {
+		return nil
+	}
+
+	defer func() {
+		// Catch the panic, especially the reflection operation panics.
+		if exception := recover(); exception != nil {
+			if v, ok := exception.(error); ok && gerror.HasStack(v) {
+				err = v
+			} else {
+				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
+			}
+		}
+	}()
+
+	var (
+		paramsReflectValue      reflect.Value
+		paramsInterface         any // DO NOT use `params` directly as it might be type `reflect.Value`
+		pointerReflectValue     reflect.Value
+		pointerReflectKind      reflect.Kind
+		pointerElemReflectValue reflect.Value // The reflection value to struct element.
+	)
+	if v, ok := params.(reflect.Value); ok {
+		paramsReflectValue = v
+	} else {
+		paramsReflectValue = reflect.ValueOf(params)
+	}
+	paramsInterface = paramsReflectValue.Interface()
+	if v, ok := pointer.(reflect.Value); ok {
+		pointerReflectValue = v
+		pointerElemReflectValue = v
+	} else {
+		pointerReflectValue = reflect.ValueOf(pointer)
+		pointerReflectKind = pointerReflectValue.Kind()
+		if pointerReflectKind != reflect.Ptr {
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				"destination pointer should be type of '*struct', but got '%v'",
+				pointerReflectKind,
+			)
+		}
+		// Using IsNil on reflect.Ptr variable is OK.
+		if !pointerReflectValue.IsValid() || pointerReflectValue.IsNil() {
+			return gerror.NewCode(
+				gcode.CodeInvalidParameter,
+				"destination pointer cannot be nil",
+			)
+		}
+		pointerElemReflectValue = pointerReflectValue.Elem()
+	}
+
+	// If `params` and `pointer` are the same type, the do directly assignment.
+	// For performance enhancement purpose.
+	if ok = c.doConvertWithTypeCheck(paramsReflectValue, pointerElemReflectValue); ok {
+		return nil
+	}
+
+	// custom convert.
+	if ok, err = c.callCustomConverter(paramsReflectValue, pointerReflectValue); ok {
+		return err
+	}
+
+	// Normal unmarshalling interfaces checks.
+	if ok, err = bindVarToReflectValueWithInterfaceCheck(pointerReflectValue, paramsInterface); ok {
+		return err
+	}
+
+	// It automatically creates struct object if necessary.
+	// For example, if `pointer` is **User, then `elem` is *User, which is a pointer to User.
+	if pointerElemReflectValue.Kind() == reflect.Ptr {
+		if !pointerElemReflectValue.IsValid() || pointerElemReflectValue.IsNil() {
+			e := reflect.New(pointerElemReflectValue.Type().Elem())
+			pointerElemReflectValue.Set(e)
+			defer func() {
+				if err != nil {
+					// If it is converted failed, it reset the `pointer` to nil.
+					pointerReflectValue.Elem().Set(reflect.Zero(pointerReflectValue.Type().Elem()))
+				}
+			}()
+		}
+		// if v, ok := pointerElemReflectValue.Interface().(localinterface.IUnmarshalValue); ok {
+		//	return v.UnmarshalValue(params)
+		// }
+		// Note that it's `pointerElemReflectValue` here not `pointerReflectValue`.
+		if ok, err = bindVarToReflectValueWithInterfaceCheck(pointerElemReflectValue, paramsInterface); ok {
+			return err
+		}
+		// Retrieve its element, may be struct at last.
+		pointerElemReflectValue = pointerElemReflectValue.Elem()
+	}
+	paramsMap, ok := paramsInterface.(map[string]any)
+	if !ok {
+		// paramsMap is the map[string]any type variable for params.
+		// DO NOT use MapDeep here.
+		paramsMap, err = c.doMapConvert(paramsInterface, RecursiveTypeAuto, true, MapOption{
+			ContinueOnError: option.ContinueOnError,
+		})
+		if err != nil {
+			return err
+		}
+		if paramsMap == nil {
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				`convert params from "%#v" to "map[string]any" failed`,
+				params,
+			)
+		}
+	}
+	// Nothing to be done as the parameters are empty.
+	if len(paramsMap) == 0 {
+		return nil
+	}
+	// Get struct info from cache or parse struct and cache the struct info.
+	cachedStructInfo := c.internalConverter.GetCachedStructInfo(
+		pointerElemReflectValue.Type(), option.PriorityTag,
+	)
+	// Nothing to be converted.
+	if cachedStructInfo == nil {
+		return nil
+	}
+	// For the structure types of 0 tagOrFiledNameToFieldInfoMap,
+	// they also need to be cached to prevent invalid logic
+	if cachedStructInfo.HasNoFields() {
+		return nil
+	}
+	var (
+		// Indicates that those values have been used and cannot be reused.
+		usedParamsKeyOrTagNameMap = structcache.GetUsedParamsKeyOrTagNameMapFromPool()
+		cachedFieldInfo           *structcache.CachedFieldInfo
+		paramsValue               any
+	)
+	defer structcache.PutUsedParamsKeyOrTagNameMapToPool(usedParamsKeyOrTagNameMap)
+
+	// Firstly, search according to custom mapping rules.
+	// If a possible direct assignment is found, reduce the number of subsequent map searches.
+	for paramKey, fieldName := range option.ParamKeyToAttrMap {
+		paramsValue, ok = paramsMap[paramKey]
+		if !ok {
+			continue
+		}
+		cachedFieldInfo = cachedStructInfo.GetFieldInfo(fieldName)
+		if cachedFieldInfo != nil {
+			fieldValue := cachedFieldInfo.GetFieldReflectValueFrom(pointerElemReflectValue)
+			if err = c.bindVarToStructField(
+				cachedFieldInfo,
+				fieldValue,
+				paramsValue,
+				option,
+			); err != nil {
+				return err
+			}
+			if len(cachedFieldInfo.OtherSameNameField) > 0 {
+				if err = c.setOtherSameNameField(
+					cachedFieldInfo, paramsValue, pointerReflectValue, option,
+				); err != nil {
+					return err
+				}
+			}
+			usedParamsKeyOrTagNameMap[paramKey] = struct{}{}
+		}
+	}
+	// Already done converting for given `paramsMap`.
+	if len(usedParamsKeyOrTagNameMap) == len(paramsMap) {
+		return nil
+	}
+	return c.bindStructWithLoopFieldInfos(
+		paramsMap, pointerElemReflectValue,
+		usedParamsKeyOrTagNameMap, cachedStructInfo,
+		option,
+	)
+}
+
+func (c *Converter) setOtherSameNameField(
+	cachedFieldInfo *structcache.CachedFieldInfo,
+	srcValue any,
+	structValue reflect.Value,
+	option StructOption,
+) (err error) {
+	// loop the same field name of all sub attributes.
+	for _, otherFieldInfo := range cachedFieldInfo.OtherSameNameField {
+		fieldValue := cachedFieldInfo.GetOtherFieldReflectValueFrom(structValue, otherFieldInfo.FieldIndexes)
+		if err = c.bindVarToStructField(otherFieldInfo, fieldValue, srcValue, option); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *Converter) bindStructWithLoopFieldInfos(
+	paramsMap map[string]any,
+	structValue reflect.Value,
+	usedParamsKeyOrTagNameMap map[string]struct{},
+	cachedStructInfo *structcache.CachedStructInfo,
+	option StructOption,
+) (err error) {
+	var (
+		cachedFieldInfo *structcache.CachedFieldInfo
+		fuzzLastKey     string
+		fieldValue      reflect.Value
+		paramKey        string
+		paramValue      any
+		matched         bool
+		ok              bool
+	)
+	for _, cachedFieldInfo = range cachedStructInfo.GetFieldConvertInfos() {
+		for _, fieldTag := range cachedFieldInfo.PriorityTagAndFieldName {
+			if paramValue, ok = paramsMap[fieldTag]; !ok {
+				continue
+			}
+			fieldValue = cachedFieldInfo.GetFieldReflectValueFrom(structValue)
+			if err = c.bindVarToStructField(
+				cachedFieldInfo, fieldValue, paramValue, option,
+			); err != nil && !option.ContinueOnError {
+				return err
+			}
+			// handle same field name in nested struct.
+			if len(cachedFieldInfo.OtherSameNameField) > 0 {
+				if err = c.setOtherSameNameField(
+					cachedFieldInfo, paramValue, structValue, option,
+				); err != nil && !option.ContinueOnError {
+					return err
+				}
+			}
+			usedParamsKeyOrTagNameMap[fieldTag] = struct{}{}
+			matched = true
+			break
+		}
+		if matched {
+			matched = false
+			continue
+		}
+
+		fuzzLastKey = cachedFieldInfo.LastFuzzyKey.Load().(string)
+		if paramValue, ok = paramsMap[fuzzLastKey]; !ok {
+			paramKey, paramValue = fuzzyMatchingFieldName(
+				cachedFieldInfo.RemoveSymbolsFieldName, paramsMap, usedParamsKeyOrTagNameMap,
+			)
+			ok = paramKey != ""
+			cachedFieldInfo.LastFuzzyKey.Store(paramKey)
+		}
+		if ok {
+			fieldValue = cachedFieldInfo.GetFieldReflectValueFrom(structValue)
+			if paramValue != nil {
+				if err = c.bindVarToStructField(
+					cachedFieldInfo, fieldValue, paramValue, option,
+				); err != nil && !option.ContinueOnError {
+					return err
+				}
+				// handle same field name in nested struct.
+				if len(cachedFieldInfo.OtherSameNameField) > 0 {
+					if err = c.setOtherSameNameField(
+						cachedFieldInfo, paramValue, structValue, option,
+					); err != nil && !option.ContinueOnError {
+						return err
+					}
+				}
+			}
+			usedParamsKeyOrTagNameMap[paramKey] = struct{}{}
+		}
+	}
+	return nil
+}
+
+// fuzzy matching rule:
+// to match field name and param key in case-insensitive and without symbols.
+func fuzzyMatchingFieldName(
+	fieldName string,
+	paramsMap map[string]any,
+	usedParamsKeyMap map[string]struct{},
+) (string, any) {
+	for paramKey, paramValue := range paramsMap {
+		if _, ok := usedParamsKeyMap[paramKey]; ok {
+			continue
+		}
+		removeParamKeyUnderline := utils.RemoveSymbols(paramKey)
+		if strings.EqualFold(fieldName, removeParamKeyUnderline) {
+			return paramKey, paramValue
+		}
+	}
+	return "", nil
+}
+
+// bindVarToStructField sets value to struct object attribute by name.
+// each value to attribute converting comes into in this function.
+func (c *Converter) bindVarToStructField(
+	cachedFieldInfo *structcache.CachedFieldInfo,
+	fieldValue reflect.Value,
+	srcValue any,
+	option StructOption,
+) (err error) {
+	if !fieldValue.IsValid() {
+		return nil
+	}
+	// CanSet checks whether attribute is public accessible.
+	if !fieldValue.CanSet() {
+		return nil
+	}
+	defer func() {
+		if exception := recover(); exception != nil {
+			if err = c.bindVarToReflectValue(fieldValue, srcValue, option); err != nil {
+				err = gerror.Wrapf(err, `error binding srcValue to attribute "%s"`, cachedFieldInfo.FieldName())
+			}
+		}
+	}()
+	// Directly converting.
+	if empty.IsNil(srcValue) {
+		fieldValue.Set(reflect.Zero(fieldValue.Type()))
+		return nil
+	}
+	// Try to call custom converter.
+	// Issue: https://github.com/gogf/gf/issues/3099
+	var (
+		customConverterInput reflect.Value
+		ok                   bool
+	)
+	if cachedFieldInfo.HasCustomConvert {
+		if customConverterInput, ok = srcValue.(reflect.Value); !ok {
+			customConverterInput = reflect.ValueOf(srcValue)
+		}
+		if ok, err = c.callCustomConverter(customConverterInput, fieldValue); ok || err != nil {
+			return
+		}
+	}
+	if cachedFieldInfo.IsCommonInterface {
+		if ok, err = bindVarToReflectValueWithInterfaceCheck(fieldValue, srcValue); ok || err != nil {
+			return
+		}
+	}
+	// Common types use fast assignment logic
+	if cachedFieldInfo.ConvertFunc != nil {
+		return cachedFieldInfo.ConvertFunc(srcValue, fieldValue)
+	}
+	convertOption := ConvertOption{
+		StructOption: option,
+		SliceOption:  SliceOption{ContinueOnError: option.ContinueOnError},
+		MapOption:    MapOption{ContinueOnError: option.ContinueOnError},
+	}
+	err = c.doConvertWithReflectValueSet(
+		fieldValue, doConvertInput{
+			FromValue:  srcValue,
+			ToTypeName: cachedFieldInfo.StructField.Type.String(),
+			ReferValue: fieldValue,
+		},
+		convertOption,
+	)
+	return err
+}
+
+// bindVarToReflectValueWithInterfaceCheck does bind using common interfaces checks.
+func bindVarToReflectValueWithInterfaceCheck(reflectValue reflect.Value, value any) (bool, error) {
+	var pointer any
+	if reflectValue.Kind() != reflect.Ptr && reflectValue.CanAddr() {
+		reflectValueAddr := reflectValue.Addr()
+		if reflectValueAddr.IsNil() || !reflectValueAddr.IsValid() {
+			return false, nil
+		}
+		// Not a pointer, but can token address, that makes it can be unmarshalled.
+		pointer = reflectValue.Addr().Interface()
+	} else {
+		if reflectValue.IsNil() || !reflectValue.IsValid() {
+			return false, nil
+		}
+		pointer = reflectValue.Interface()
+	}
+	// UnmarshalValue.
+	if v, ok := pointer.(localinterface.IUnmarshalValue); ok {
+		return ok, v.UnmarshalValue(value)
+	}
+	// UnmarshalText.
+	if v, ok := pointer.(localinterface.IUnmarshalText); ok {
+		var valueBytes []byte
+		if b, ok := value.([]byte); ok {
+			valueBytes = b
+		} else if s, ok := value.(string); ok {
+			valueBytes = []byte(s)
+		} else if f, ok := value.(localinterface.IString); ok {
+			valueBytes = []byte(f.String())
+		}
+		if len(valueBytes) > 0 {
+			return ok, v.UnmarshalText(valueBytes)
+		}
+	}
+	// UnmarshalJSON.
+	if v, ok := pointer.(localinterface.IUnmarshalJSON); ok {
+		var valueBytes []byte
+		if b, ok := value.([]byte); ok {
+			valueBytes = b
+		} else if s, ok := value.(string); ok {
+			valueBytes = []byte(s)
+		} else if f, ok := value.(localinterface.IString); ok {
+			valueBytes = []byte(f.String())
+		}
+
+		if len(valueBytes) > 0 {
+			// If it is not a valid JSON string, it then adds char `"` on its both sides to make it is.
+			if !json.Valid(valueBytes) {
+				newValueBytes := make([]byte, len(valueBytes)+2)
+				newValueBytes[0] = '"'
+				newValueBytes[len(newValueBytes)-1] = '"'
+				copy(newValueBytes[1:], valueBytes)
+				valueBytes = newValueBytes
+			}
+			return ok, v.UnmarshalJSON(valueBytes)
+		}
+	}
+	if v, ok := pointer.(localinterface.ISet); ok {
+		v.Set(value)
+		return ok, nil
+	}
+	return false, nil
+}
+
+// bindVarToReflectValue sets `value` to reflect value object `structFieldValue`.
+func (c *Converter) bindVarToReflectValue(structFieldValue reflect.Value, value any, option StructOption) (err error) {
+	// JSON content converting.
+	ok, err := c.doConvertWithJsonCheck(value, structFieldValue)
+	if err != nil {
+		return err
+	}
+	if ok {
+		return nil
+	}
+
+	kind := structFieldValue.Kind()
+	// Converting using `Set` interface implements, for some types.
+	switch kind {
+	case reflect.Slice, reflect.Array, reflect.Ptr, reflect.Interface:
+		if !structFieldValue.IsNil() {
+			if v, ok := structFieldValue.Interface().(localinterface.ISet); ok {
+				v.Set(value)
+				return nil
+			}
+		}
+	default:
+	}
+
+	// Converting using reflection by kind.
+	switch kind {
+	case reflect.Map:
+		return c.MapToMap(value, structFieldValue, option.ParamKeyToAttrMap, MapOption{
+			ContinueOnError: option.ContinueOnError,
+		})
+
+	case reflect.Struct:
+		// Recursively converting for struct attribute.
+		if err = c.Struct(value, structFieldValue, option); err != nil {
+			// Note there's reflect conversion mechanism here.
+			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
+		}
+
+	// Note that the slice element might be type of struct,
+	// so it uses Struct function doing the converting internally.
+	case reflect.Slice, reflect.Array:
+		var (
+			reflectArray  reflect.Value
+			reflectValue  = reflect.ValueOf(value)
+			convertOption = ConvertOption{
+				StructOption: option,
+				SliceOption:  SliceOption{ContinueOnError: option.ContinueOnError},
+				MapOption:    MapOption{ContinueOnError: option.ContinueOnError},
+			}
+		)
+		if reflectValue.Kind() == reflect.Slice || reflectValue.Kind() == reflect.Array {
+			reflectArray = reflect.MakeSlice(structFieldValue.Type(), reflectValue.Len(), reflectValue.Len())
+			if reflectValue.Len() > 0 {
+				var (
+					elemType     = reflectArray.Index(0).Type()
+					elemTypeName string
+					converted    bool
+				)
+				for i := 0; i < reflectValue.Len(); i++ {
+					converted = false
+					elemTypeName = elemType.Name()
+					if elemTypeName == "" {
+						elemTypeName = elemType.String()
+					}
+					var elem reflect.Value
+					if elemType.Kind() == reflect.Ptr {
+						elem = reflect.New(elemType.Elem()).Elem()
+					} else {
+						elem = reflect.New(elemType).Elem()
+					}
+					if elem.Kind() == reflect.Struct {
+						if err = c.Struct(reflectValue.Index(i).Interface(), elem, option); err == nil {
+							converted = true
+						}
+					}
+					if !converted {
+						err = c.doConvertWithReflectValueSet(
+							elem, doConvertInput{
+								FromValue:  reflectValue.Index(i).Interface(),
+								ToTypeName: elemTypeName,
+								ReferValue: elem,
+							},
+							convertOption,
+						)
+						if err != nil {
+							return err
+						}
+					}
+					if elemType.Kind() == reflect.Ptr {
+						// Before it sets the `elem` to array, do pointer converting if necessary.
+						elem = elem.Addr()
+					}
+					reflectArray.Index(i).Set(elem)
+				}
+			}
+		} else {
+			var (
+				elem         reflect.Value
+				elemType     = structFieldValue.Type().Elem()
+				elemTypeName = elemType.Name()
+				converted    bool
+			)
+			switch reflectValue.Kind() {
+			case reflect.String:
+				// Value is empty string.
+				if reflectValue.IsZero() {
+					var elemKind = elemType.Kind()
+					// Try to find the original type kind of the slice element.
+					if elemKind == reflect.Ptr {
+						elemKind = elemType.Elem().Kind()
+					}
+					switch elemKind {
+					case reflect.String:
+						// Empty string cannot be assigned to string slice.
+						return nil
+					default:
+					}
+				}
+			default:
+			}
+			if elemTypeName == "" {
+				elemTypeName = elemType.String()
+			}
+			if elemType.Kind() == reflect.Ptr {
+				elem = reflect.New(elemType.Elem()).Elem()
+			} else {
+				elem = reflect.New(elemType).Elem()
+			}
+			if elem.Kind() == reflect.Struct {
+				if err = c.Struct(value, elem, option); err == nil {
+					converted = true
+				}
+			}
+			if !converted {
+				err = c.doConvertWithReflectValueSet(
+					elem, doConvertInput{
+						FromValue:  value,
+						ToTypeName: elemTypeName,
+						ReferValue: elem,
+					},
+					convertOption,
+				)
+				if err != nil {
+					return err
+				}
+			}
+			if elemType.Kind() == reflect.Ptr {
+				// Before it sets the `elem` to array, do pointer converting if necessary.
+				elem = elem.Addr()
+			}
+			reflectArray = reflect.MakeSlice(structFieldValue.Type(), 1, 1)
+			reflectArray.Index(0).Set(elem)
+		}
+		structFieldValue.Set(reflectArray)
+
+	case reflect.Ptr:
+		if structFieldValue.IsNil() || structFieldValue.IsZero() {
+			// Nil or empty pointer, it creates a new one.
+			item := reflect.New(structFieldValue.Type().Elem())
+			if ok, err = bindVarToReflectValueWithInterfaceCheck(item, value); ok {
+				structFieldValue.Set(item)
+				return err
+			}
+			elem := item.Elem()
+			if err = c.bindVarToReflectValue(elem, value, option); err == nil {
+				structFieldValue.Set(elem.Addr())
+			}
+		} else {
+			// Not empty pointer, it assigns values to it.
+			return c.bindVarToReflectValue(structFieldValue.Elem(), value, option)
+		}
+
+	// It mainly and specially handles the interface of nil value.
+	case reflect.Interface:
+		if value == nil {
+			// Specially.
+			structFieldValue.Set(reflect.ValueOf((*any)(nil)))
+		} else {
+			// Note there's reflect conversion mechanism here.
+			structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
+		}
+
+	default:
+		defer func() {
+			if exception := recover(); exception != nil {
+				err = gerror.NewCodef(
+					gcode.CodeInternalPanic,
+					`cannot convert value "%+v" to type "%s":%+v`,
+					value,
+					structFieldValue.Type().String(),
+					exception,
+				)
+			}
+		}()
+		// It here uses reflect converting `value` to type of the attribute and assigns
+		// the result value to the attribute. It might fail and panic if the usual Go
+		// conversion rules do not allow conversion.
+		structFieldValue.Set(reflect.ValueOf(value).Convert(structFieldValue.Type()))
+	}
+	return nil
+}

util/gconv/internal/converter/converter_structs.go

@@ -0,0 +1,120 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"reflect"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+)
+
+// Structs converts any slice to given struct slice.
+//
+// It automatically checks and converts json string to []map if `params` is string/[]byte.
+//
+// The parameter `pointer` should be type of pointer to slice of struct.
+// Note that if `pointer` is a pointer to another pointer of type of slice of struct,
+// it will create the struct/pointer internally.
+func (c *Converter) Structs(
+	params any, pointer any, sliceOption SliceOption, structOption StructOption,
+) (err error) {
+	defer func() {
+		// Catch the panic, especially the reflection operation panics.
+		if exception := recover(); exception != nil {
+			if v, ok := exception.(error); ok && gerror.HasStack(v) {
+				err = v
+			} else {
+				err = gerror.NewCodeSkipf(gcode.CodeInternalPanic, 1, "%+v", exception)
+			}
+		}
+	}()
+
+	// Pointer type check.
+	pointerRv, ok := pointer.(reflect.Value)
+	if !ok {
+		pointerRv = reflect.ValueOf(pointer)
+		if kind := pointerRv.Kind(); kind != reflect.Ptr {
+			return gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				"pointer should be type of pointer, but got: %v", kind,
+			)
+		}
+	}
+	// Converting `params` to map slice.
+	var (
+		paramsList []any
+		paramsRv   = reflect.ValueOf(params)
+		paramsKind = paramsRv.Kind()
+	)
+	for paramsKind == reflect.Ptr {
+		paramsRv = paramsRv.Elem()
+		paramsKind = paramsRv.Kind()
+	}
+	switch paramsKind {
+	case reflect.Slice, reflect.Array:
+		paramsList = make([]any, paramsRv.Len())
+		for i := 0; i < paramsRv.Len(); i++ {
+			paramsList[i] = paramsRv.Index(i).Interface()
+		}
+	default:
+		paramsMaps, err := c.SliceMap(params, sliceOption, MapOption{
+			ContinueOnError: structOption.ContinueOnError,
+		})
+		if err != nil {
+			return err
+		}
+		paramsList = make([]any, len(paramsMaps))
+		for i := 0; i < len(paramsMaps); i++ {
+			paramsList[i] = paramsMaps[i]
+		}
+	}
+	// If `params` is an empty slice, no conversion.
+	if len(paramsList) == 0 {
+		return nil
+	}
+	var (
+		reflectElemArray = reflect.MakeSlice(pointerRv.Type().Elem(), len(paramsList), len(paramsList))
+		itemType         = reflectElemArray.Index(0).Type()
+		itemTypeKind     = itemType.Kind()
+		pointerRvElem    = pointerRv.Elem()
+		pointerRvLength  = pointerRvElem.Len()
+	)
+	if itemTypeKind == reflect.Ptr {
+		// Pointer element.
+		for i := 0; i < len(paramsList); i++ {
+			var tempReflectValue reflect.Value
+			if i < pointerRvLength {
+				// Might be nil.
+				tempReflectValue = pointerRvElem.Index(i).Elem()
+			}
+			if !tempReflectValue.IsValid() {
+				tempReflectValue = reflect.New(itemType.Elem()).Elem()
+			}
+			if err = c.Struct(paramsList[i], tempReflectValue, structOption); err != nil {
+				return err
+			}
+			reflectElemArray.Index(i).Set(tempReflectValue.Addr())
+		}
+	} else {
+		// Struct element.
+		for i := 0; i < len(paramsList); i++ {
+			var tempReflectValue reflect.Value
+			if i < pointerRvLength {
+				tempReflectValue = pointerRvElem.Index(i)
+			} else {
+				tempReflectValue = reflect.New(itemType).Elem()
+			}
+			if err = c.Struct(paramsList[i], tempReflectValue, structOption); err != nil {
+				return err
+			}
+			reflectElemArray.Index(i).Set(tempReflectValue)
+		}
+	}
+	pointerRv.Elem().Set(reflectElemArray)
+	return nil
+}

util/gconv/internal/converter/converter_time.go

@@ -0,0 +1,111 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"time"
+
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/utils"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Time converts `any` to time.Time.
+func (c *Converter) Time(any interface{}, format ...string) (time.Time, error) {
+	// It's already this type.
+	if len(format) == 0 {
+		if v, ok := any.(time.Time); ok {
+			return v, nil
+		}
+	}
+	t, err := c.GTime(any, format...)
+	if err != nil {
+		return time.Time{}, err
+	}
+	if t != nil {
+		return t.Time, nil
+	}
+	return time.Time{}, nil
+}
+
+// Duration converts `any` to time.Duration.
+// If `any` is string, then it uses time.ParseDuration to convert it.
+// If `any` is numeric, then it converts `any` as nanoseconds.
+func (c *Converter) Duration(any interface{}) (time.Duration, error) {
+	// It's already this type.
+	if v, ok := any.(time.Duration); ok {
+		return v, nil
+	}
+	s, err := c.String(any)
+	if err != nil {
+		return 0, err
+	}
+	if !utils.IsNumeric(s) {
+		return gtime.ParseDuration(s)
+	}
+	i, err := c.Int64(any)
+	if err != nil {
+		return 0, err
+	}
+	return time.Duration(i), nil
+}
+
+// GTime converts `any` to *gtime.Time.
+// The parameter `format` can be used to specify the format of `any`.
+// It returns the converted value that matched the first format of the formats slice.
+// If no `format` given, it converts `any` using gtime.NewFromTimeStamp if `any` is numeric,
+// or using gtime.StrToTime if `any` is string.
+func (c *Converter) GTime(any interface{}, format ...string) (*gtime.Time, error) {
+	if empty.IsNil(any) {
+		return nil, nil
+	}
+	if v, ok := any.(localinterface.IGTime); ok {
+		return v.GTime(format...), nil
+	}
+	// It's already this type.
+	if len(format) == 0 {
+		if v, ok := any.(*gtime.Time); ok {
+			return v, nil
+		}
+		if t, ok := any.(time.Time); ok {
+			return gtime.New(t), nil
+		}
+		if t, ok := any.(*time.Time); ok {
+			return gtime.New(t), nil
+		}
+	}
+	s, err := c.String(any)
+	if err != nil {
+		return nil, err
+	}
+	if len(s) == 0 {
+		return gtime.New(), nil
+	}
+	// Priority conversion using given format.
+	if len(format) > 0 {
+		for _, item := range format {
+			t, err := gtime.StrToTimeFormat(s, item)
+			if err != nil {
+				return nil, err
+			}
+			if t != nil {
+				return t, nil
+			}
+		}
+		return nil, nil
+	}
+	if utils.IsNumeric(s) {
+		i, err := c.Int64(s)
+		if err != nil {
+			return nil, err
+		}
+		return gtime.NewFromTimeStamp(i), nil
+	} else {
+		return gtime.StrToTime(s)
+	}
+}

util/gconv/internal/converter/converter_uint.go

@@ -0,0 +1,161 @@
+// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package converter
+
+import (
+	"math"
+	"reflect"
+	"strconv"
+
+	"github.com/gogf/gf/v2/encoding/gbinary"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
+)
+
+// Uint converts `any` to uint.
+func (c *Converter) Uint(any any) (uint, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(uint); ok {
+		return v, nil
+	}
+	v, err := c.Uint64(any)
+	return uint(v), err
+}
+
+// Uint8 converts `any` to uint8.
+func (c *Converter) Uint8(any any) (uint8, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(uint8); ok {
+		return v, nil
+	}
+	v, err := c.Uint64(any)
+	return uint8(v), err
+}
+
+// Uint16 converts `any` to uint16.
+func (c *Converter) Uint16(any any) (uint16, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(uint16); ok {
+		return v, nil
+	}
+	v, err := c.Uint64(any)
+	return uint16(v), err
+}
+
+// Uint32 converts `any` to uint32.
+func (c *Converter) Uint32(any any) (uint32, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(uint32); ok {
+		return v, nil
+	}
+	v, err := c.Uint64(any)
+	return uint32(v), err
+}
+
+// Uint64 converts `any` to uint64.
+func (c *Converter) Uint64(any any) (uint64, error) {
+	if empty.IsNil(any) {
+		return 0, nil
+	}
+	if v, ok := any.(uint64); ok {
+		return v, nil
+	}
+	rv := reflect.ValueOf(any)
+	switch rv.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		val := rv.Int()
+		if val < 0 {
+			return uint64(val), gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				`cannot convert negative value "%d" to uint64`,
+				val,
+			)
+		}
+		return uint64(val), nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return rv.Uint(), nil
+	case reflect.Uintptr:
+		return rv.Uint(), nil
+	case reflect.Float32, reflect.Float64:
+		val := rv.Float()
+		if val < 0 {
+			return uint64(val), gerror.NewCodef(
+				gcode.CodeInvalidParameter,
+				`cannot convert negative value "%f" to uint64`,
+				val,
+			)
+		}
+		return uint64(val), nil
+	case reflect.Bool:
+		if rv.Bool() {
+			return 1, nil
+		}
+		return 0, nil
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return 0, nil
+		}
+		if f, ok := any.(localinterface.IUint64); ok {
+			return f.Uint64(), nil
+		}
+		return c.Uint64(rv.Elem().Interface())
+	case reflect.Slice:
+		if rv.Type().Elem().Kind() == reflect.Uint8 {
+			return gbinary.DecodeToUint64(rv.Bytes()), nil
+		}
+		return 0, gerror.NewCodef(
+			gcode.CodeInvalidParameter,
+			`unsupport slice type "%s" for converting to uint64`,
+			rv.Type().String(),
+		)
+	case reflect.String:
+		var s = rv.String()
+		// Hexadecimal
+		if len(s) > 2 && s[0] == '0' && (s[1] == 'x' || s[1] == 'X') {
+			v, err := strconv.ParseUint(s[2:], 16, 64)
+			if err == nil {
+				return v, nil
+			}
+			return 0, gerror.WrapCodef(
+				gcode.CodeInvalidParameter,
+				err,
+				`cannot convert hexadecimal string "%s" to uint64`,
+				s,
+			)
+		}
+		// Decimal
+		if v, err := strconv.ParseUint(s, 10, 64); err == nil {
+			return v, nil
+		}
+		// Float64
+		if v, err := c.Float64(any); err == nil {
+			if math.IsNaN(v) {
+				return 0, nil
+			}
+			return uint64(v), nil
+		}
+	default:
+		if f, ok := any.(localinterface.IUint64); ok {
+			return f.Uint64(), nil
+		}
+	}
+	return 0, gerror.NewCodef(
+		gcode.CodeInvalidParameter,
+		`unsupport value type "%s" for converting to uint64`,
+		reflect.TypeOf(any).String(),
+	)
+}

util/gconv/internal/localinterface/localinterface.go

@@ -9,9 +9,9 @@ package localinterface
 
 import "github.com/gogf/gf/v2/os/gtime"
 
-// IVal is used for type assert api for String().
+// IVal is used for type assert api for Val().
 type IVal interface {
-	Val() interface{}
+	Val() any
 }
 
 // IString is used for type assert api for String().
@@ -56,12 +56,12 @@ type IBytes interface {
 
 // IInterface is used for type assert api for Interface().
 type IInterface interface {
-	Interface() interface{}
+	Interface() any
 }
 
 // IInterfaces is used for type assert api for Interfaces().
 type IInterfaces interface {
-	Interfaces() []interface{}
+	Interfaces() []any
 }
 
 // IFloats is used for type assert api for Floats().
@@ -86,7 +86,7 @@ type IUints interface {
 
 // IMapStrAny is the interface support for converting struct parameter to map.
 type IMapStrAny interface {
-	MapStrAny() map[string]interface{}
+	MapStrAny() map[string]any
 }
 
 // IUnmarshalText is the interface for custom defined types customizing value assignment.
@@ -104,12 +104,12 @@ type IUnmarshalJSON interface {
 // IUnmarshalValue is the interface for custom defined types customizing value assignment.
 // Note that only pointer can implement interface IUnmarshalValue.
 type IUnmarshalValue interface {
-	UnmarshalValue(interface{}) error
+	UnmarshalValue(any) error
 }
 
 // ISet is the interface for custom value assignment.
 type ISet interface {
-	Set(value interface{}) (old interface{})
+	Set(value any) (old any)
 }
 
 // IGTime is the interface for gtime.Time converting.

util/gconv/internal/structcache/structcache.go

@@ -9,24 +9,80 @@ package structcache
 
 import (
 	"reflect"
+	"sync"
 
 	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
 )
 
-var (
-	// customConvertTypeMap is used to store whether field types are registered to custom conversions
-	// For example:
-	// func (src *TypeA) (dst *TypeB,err error)
-	// This map will store `TypeB` for quick judgment during assignment.
-	customConvertTypeMap = map[reflect.Type]struct{}{}
-)
+type interfaceTypeConverter struct {
+	interfaceType reflect.Type
+	convertFunc   AnyConvertFunc
+}
 
-// RegisterCustomConvertType registers custom
-func RegisterCustomConvertType(fieldType reflect.Type) {
+// Converter is the configuration for type converting.
+type Converter struct {
+	// map[reflect.Type]*CachedStructInfo
+	cachedStructsInfoMap sync.Map
+
+	// anyToTypeConvertMap for custom type converting from any to its reflect.Value.
+	anyToTypeConvertMap map[reflect.Type]AnyConvertFunc
+
+	// interfaceToTypeConvertMap used for converting any interface type
+	// the reason why map is not used here, is because interface types cannot be instantiated
+	interfaceToTypeConvertMap []interfaceTypeConverter
+
+	// typeConverterFuncMarkMap is used to store whether field types are registered to custom conversions
+	typeConverterFuncMarkMap map[reflect.Type]struct{}
+}
+
+// AnyConvertFunc is the function type for converting any to specified type.
+type AnyConvertFunc func(from any, to reflect.Value) error
+
+// NewConverter creates and returns a new Converter object.
+func NewConverter() *Converter {
+	return &Converter{
+		cachedStructsInfoMap:     sync.Map{},
+		typeConverterFuncMarkMap: make(map[reflect.Type]struct{}),
+		anyToTypeConvertMap:      make(map[reflect.Type]AnyConvertFunc),
+	}
+}
+
+// MarkTypeConvertFunc marks converting function registered for custom type.
+func (cf *Converter) MarkTypeConvertFunc(fieldType reflect.Type) {
 	if fieldType.Kind() == reflect.Ptr {
 		fieldType = fieldType.Elem()
 	}
-	customConvertTypeMap[fieldType] = struct{}{}
+	cf.typeConverterFuncMarkMap[fieldType] = struct{}{}
+}
+
+// RegisterAnyConvertFunc registers custom type converting function for specified type.
+func (cf *Converter) RegisterAnyConvertFunc(t reflect.Type, convertFunc AnyConvertFunc) {
+	if t == nil || convertFunc == nil {
+		return
+	}
+	for t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+	if t.Kind() == reflect.Interface {
+		cf.interfaceToTypeConvertMap = append(cf.interfaceToTypeConvertMap, interfaceTypeConverter{
+			interfaceType: t,
+			convertFunc:   convertFunc,
+		})
+		return
+	}
+	cf.anyToTypeConvertMap[t] = convertFunc
+}
+
+func (cf *Converter) checkTypeImplInterface(t reflect.Type) AnyConvertFunc {
+	if t.Kind() != reflect.Ptr {
+		t = reflect.PointerTo(t)
+	}
+	for _, inter := range cf.interfaceToTypeConvertMap {
+		if t.Implements(inter.interfaceType) {
+			return inter.convertFunc
+		}
+	}
+	return nil
 }
 
 var (

util/gconv/internal/structcache/structcache_cached.go

@@ -8,48 +8,19 @@ package structcache
 
 import (
 	"reflect"
-	"sync"
-	"time"
 
 	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/util/gtag"
 )
 
-// CommonConverter holds some converting functions of common types for internal usage.
-type CommonConverter struct {
-	Int64   func(any interface{}) int64
-	Uint64  func(any interface{}) uint64
-	String  func(any interface{}) string
-	Float32 func(any interface{}) float32
-	Float64 func(any interface{}) float64
-	Time    func(any interface{}, format ...string) time.Time
-	GTime   func(any interface{}, format ...string) *gtime.Time
-	Bytes   func(any interface{}) []byte
-	Bool    func(any interface{}) bool
-}
-
-var (
-	// map[reflect.Type]*CachedStructInfo
-	cachedStructsInfoMap = sync.Map{}
-
-	// localCommonConverter holds some converting functions of common types for internal usage.
-	localCommonConverter CommonConverter
-)
-
-// RegisterCommonConverter registers the CommonConverter for local usage.
-func RegisterCommonConverter(commonConverter CommonConverter) {
-	localCommonConverter = commonConverter
-}
-
 // GetCachedStructInfo retrieves or parses and returns a cached info for certain struct type.
 // The given `structType` should be type of struct.
-func GetCachedStructInfo(structType reflect.Type, priorityTag string) *CachedStructInfo {
+func (cf *Converter) GetCachedStructInfo(structType reflect.Type, priorityTag string) *CachedStructInfo {
 	if structType.Kind() != reflect.Struct {
 		return nil
 	}
 	// check if it has been cached.
-	cachedStructInfo, ok := getCachedConvertStructInfo(structType)
+	cachedStructInfo, ok := cf.getCachedConvertStructInfo(structType)
 	if ok {
 		// directly returns the cached struct info if already exists.
 		return cachedStructInfo
@@ -58,9 +29,7 @@ func GetCachedStructInfo(structType reflect.Type, priorityTag string) *CachedStr
 	// else create one.
 
 	// it parses and generates a cache info for given struct type.
-	cachedStructInfo = &CachedStructInfo{
-		tagOrFiledNameToFieldInfoMap: make(map[string]*CachedFieldInfo),
-	}
+	cachedStructInfo = NewCachedStructInfo(cf)
 	var (
 		priorityTagArray []string
 		parentIndex      = make([]int, 0)
@@ -70,19 +39,19 @@ func GetCachedStructInfo(structType reflect.Type, priorityTag string) *CachedStr
 	} else {
 		priorityTagArray = gtag.StructTagPriority
 	}
-	parseStructToCachedStructInfo(structType, parentIndex, cachedStructInfo, priorityTagArray)
-	storeCachedStructInfo(structType, cachedStructInfo)
+	cf.parseStructToCachedStructInfo(structType, parentIndex, cachedStructInfo, priorityTagArray)
+	cf.storeCachedStructInfo(structType, cachedStructInfo)
 	return cachedStructInfo
 }
 
-func storeCachedStructInfo(structType reflect.Type, cachedStructInfo *CachedStructInfo) {
+func (cf *Converter) storeCachedStructInfo(structType reflect.Type, cachedStructInfo *CachedStructInfo) {
 	// Temporarily enabled as an experimental feature
-	cachedStructsInfoMap.Store(structType, cachedStructInfo)
+	cf.cachedStructsInfoMap.Store(structType, cachedStructInfo)
 }
 
-func getCachedConvertStructInfo(structType reflect.Type) (*CachedStructInfo, bool) {
+func (cf *Converter) getCachedConvertStructInfo(structType reflect.Type) (*CachedStructInfo, bool) {
 	// Temporarily enabled as an experimental feature
-	v, ok := cachedStructsInfoMap.Load(structType)
+	v, ok := cf.cachedStructsInfoMap.Load(structType)
 	if ok {
 		return v.(*CachedStructInfo), ok
 	}
@@ -91,7 +60,7 @@ func getCachedConvertStructInfo(structType reflect.Type) (*CachedStructInfo, boo
 
 // parseStructToCachedStructInfo parses given struct reflection type and stores its fields info into given CachedStructInfo.
 // It stores nothing into CachedStructInfo if given struct reflection type has no fields.
-func parseStructToCachedStructInfo(
+func (cf *Converter) parseStructToCachedStructInfo(
 	structType reflect.Type,
 	fieldIndexes []int,
 	cachedStructInfo *CachedStructInfo,
@@ -136,7 +105,7 @@ func parseStructToCachedStructInfo(
 				// Do not add anonymous structures without tags
 				cachedStructInfo.AddField(structField, append(copyFieldIndexes, i), priorityTagArray)
 			}
-			parseStructToCachedStructInfo(fieldType, append(copyFieldIndexes, i), cachedStructInfo, priorityTagArray)
+			cf.parseStructToCachedStructInfo(fieldType, append(copyFieldIndexes, i), cachedStructInfo, priorityTagArray)
 			continue
 		}
 		// Do not directly use append(fieldIndexes, i)

util/gconv/internal/structcache/structcache_cached_field_info.go

@@ -51,6 +51,8 @@ type CachedFieldInfoBase struct {
 	IsCommonInterface bool
 
 	// HasCustomConvert marks there custom converting function for this field type.
+	// A custom converting function is a function that user defined for converting specified type
+	// to another type.
 	HasCustomConvert bool
 
 	// StructField is the type info of this field.
@@ -74,7 +76,7 @@ type CachedFieldInfoBase struct {
 	OtherSameNameField []*CachedFieldInfo
 
 	// ConvertFunc is the converting function for this field.
-	ConvertFunc func(from any, to reflect.Value)
+	ConvertFunc AnyConvertFunc
 
 	// The last fuzzy matching key for this field.
 	// The fuzzy matching occurs only if there are no direct tag and field name matching in the params map.

util/gconv/internal/structcache/structcache_cached_struct_info.go

@@ -9,14 +9,17 @@ package structcache
 import (
 	"reflect"
 	"strings"
-	"time"
 
 	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/os/gtime"
 )
 
 // CachedStructInfo holds the cached info for certain struct.
 type CachedStructInfo struct {
+	// All sub attributes field info slice.
+	fieldConvertInfos []*CachedFieldInfo
+
+	converter *Converter
+
 	// This map field is mainly used in the bindStructWithLoopParamsMap method
 	// key = field's name
 	// Will save all field names and PriorityTagAndFieldName
@@ -25,9 +28,19 @@ type CachedStructInfo struct {
 	//
 	// It will be stored twice, which keys are `name` and `field`.
 	tagOrFiledNameToFieldInfoMap map[string]*CachedFieldInfo
+}
 
-	// All sub attributes field info slice.
-	FieldConvertInfos []*CachedFieldInfo
+// NewCachedStructInfo creates and returns a new CachedStructInfo object.
+func NewCachedStructInfo(converter *Converter) *CachedStructInfo {
+	return &CachedStructInfo{
+		tagOrFiledNameToFieldInfoMap: make(map[string]*CachedFieldInfo),
+		fieldConvertInfos:            make([]*CachedFieldInfo, 0),
+		converter:                    converter,
+	}
+}
+
+func (csi *CachedStructInfo) GetFieldConvertInfos() []*CachedFieldInfo {
+	return csi.fieldConvertInfos
 }
 
 func (csi *CachedStructInfo) HasNoFields() bool {
@@ -46,7 +59,7 @@ func (csi *CachedStructInfo) AddField(field reflect.StructField, fieldIndexes []
 			field, fieldIndexes, priorityTags, cachedFieldInfo, tagOrFieldName,
 		)
 		if newFieldInfo.IsField {
-			csi.FieldConvertInfos = append(csi.FieldConvertInfos, newFieldInfo)
+			csi.fieldConvertInfos = append(csi.fieldConvertInfos, newFieldInfo)
 		}
 		// if the field info by `tagOrFieldName` already cached,
 		// it so adds this new field info to other same name field.
@@ -82,7 +95,9 @@ func (csi *CachedStructInfo) makeOrCopyCachedInfo(
 
 // copyCachedInfoWithFieldIndexes copies and returns a new CachedFieldInfo based on given CachedFieldInfo, but different
 // FieldIndexes. Mainly used for copying fields with the same name and type.
-func (csi *CachedStructInfo) copyCachedInfoWithFieldIndexes(cfi *CachedFieldInfo, fieldIndexes []int) *CachedFieldInfo {
+func (csi *CachedStructInfo) copyCachedInfoWithFieldIndexes(
+	cfi *CachedFieldInfo, fieldIndexes []int,
+) *CachedFieldInfo {
 	base := CachedFieldInfoBase{}
 	base = *cfi.CachedFieldInfoBase
 	base.FieldIndexes = fieldIndexes
@@ -98,7 +113,7 @@ func (csi *CachedStructInfo) makeCachedFieldInfo(
 		IsCommonInterface:       checkTypeIsCommonInterface(field),
 		StructField:             field,
 		FieldIndexes:            fieldIndexes,
-		ConvertFunc:             csi.genFieldConvertFunc(field.Type.String()),
+		ConvertFunc:             csi.genFieldConvertFunc(field.Type),
 		HasCustomConvert:        csi.checkTypeHasCustomConvert(field.Type),
 		PriorityTagAndFieldName: csi.genPriorityTagAndFieldName(field, priorityTags),
 		RemoveSymbolsFieldName:  utils.RemoveSymbols(field.Name),
@@ -109,57 +124,26 @@ func (csi *CachedStructInfo) makeCachedFieldInfo(
 	}
 }
 
-func (csi *CachedStructInfo) genFieldConvertFunc(fieldType string) (convertFunc func(from any, to reflect.Value)) {
-	if fieldType[0] == '*' {
-		convertFunc = csi.genFieldConvertFunc(fieldType[1:])
+func (csi *CachedStructInfo) genFieldConvertFunc(fieldType reflect.Type) (convertFunc AnyConvertFunc) {
+	ptr := 0
+	for fieldType.Kind() == reflect.Ptr {
+		fieldType = fieldType.Elem()
+		ptr++
+	}
+	convertFunc = csi.converter.anyToTypeConvertMap[fieldType]
+	if convertFunc == nil {
+		// If the registered custom implementation cannot be found,
+		// try to check if there is an implementation interface
+		convertFunc = csi.converter.checkTypeImplInterface(fieldType)
+	}
+	// if the registered type is not found and
+	// the corresponding interface is not implemented, return directly
 	if convertFunc == nil {
 		return nil
 	}
-		return csi.genPtrConvertFunc(convertFunc)
-	}
-	switch fieldType {
-	case "int", "int8", "int16", "int32", "int64":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetInt(localCommonConverter.Int64(from))
-		}
-	case "uint", "uint8", "uint16", "uint32", "uint64":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetUint(localCommonConverter.Uint64(from))
-		}
-	case "string":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetString(localCommonConverter.String(from))
-		}
-	case "float32":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetFloat(float64(localCommonConverter.Float32(from)))
-		}
-	case "float64":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetFloat(localCommonConverter.Float64(from))
-		}
-	case "Time", "time.Time":
-		convertFunc = func(from any, to reflect.Value) {
-			*to.Addr().Interface().(*time.Time) = localCommonConverter.Time(from)
-		}
-	case "GTime", "gtime.Time":
-		convertFunc = func(from any, to reflect.Value) {
-			v := localCommonConverter.GTime(from)
-			if v == nil {
-				v = gtime.New()
-			}
-			*to.Addr().Interface().(*gtime.Time) = *v
-		}
-	case "bool":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetBool(localCommonConverter.Bool(from))
-		}
-	case "[]byte":
-		convertFunc = func(from any, to reflect.Value) {
-			to.SetBytes(localCommonConverter.Bytes(from))
-		}
-	default:
-		return nil
+	for i := 0; i < ptr; i++ {
+		// If it is a pointer type, it needs to be packaged
+		convertFunc = genPtrConvertFunc(convertFunc)
 	}
 	return convertFunc
 }
@@ -188,21 +172,19 @@ func (csi *CachedStructInfo) genPriorityTagAndFieldName(
 	return
 }
 
+func genPtrConvertFunc(convertFunc AnyConvertFunc) AnyConvertFunc {
+	return func(from any, to reflect.Value) error {
+		if to.IsNil() {
+			to.Set(reflect.New(to.Type().Elem()))
+		}
+		return convertFunc(from, to.Elem())
+	}
+}
+
 func (csi *CachedStructInfo) checkTypeHasCustomConvert(fieldType reflect.Type) bool {
 	if fieldType.Kind() == reflect.Ptr {
 		fieldType = fieldType.Elem()
 	}
-	_, ok := customConvertTypeMap[fieldType]
+	_, ok := csi.converter.typeConverterFuncMarkMap[fieldType]
 	return ok
 }
-
-func (csi *CachedStructInfo) genPtrConvertFunc(
-	convertFunc func(from any, to reflect.Value),
-) func(from any, to reflect.Value) {
-	return func(from any, to reflect.Value) {
-		if to.IsNil() {
-			to.Set(reflect.New(to.Type().Elem()))
-		}
-		convertFunc(from, to.Elem())
-	}
-}