Merge 29823983793857eb344503f4b3beacddbf9632bf into 1534abdb050acaa5aa6ef27f94e91bca97e6faa3

feat(util/gpage): marked deprecated (#4230 )
feat(net/ghttp): enhance GetHeader method to support default values (#4210 )
2025-04-04 10:32:46 +08:00 · 2025-04-02 23:53:06 +08:00 · 2025-04-02 19:56:28 +08:00 · 2025-03-25 20:42:30 +08:00 · 2025-03-17 15:52:26 +08:00 · 2025-03-17 14:50:07 +08:00
68 changed files with 773 additions and 402 deletions
--- a/.github/workflows/issue-check-inactive.yml
+++ b/.github/workflows/issue-check-inactive.yml
@ -23,6 +23,6 @@ jobs:
        with:
          actions: 'check-inactive'
          inactive-label: 'inactive'
-          inactive-day: 7
+          inactive-day: 30
          issue-state: open
          exclude-labels: 'bug,planned,$exclude-empty'
--- a/.gitignore
+++ b/.gitignore
@ -23,3 +23,4 @@ go.work.sum
 node_modules
 .docusaurus
 output
+.example/
--- a/README.MD
+++ b/README.MD
@ -36,7 +36,7 @@ A powerful framework for faster, easier, and more efficient project development.
 💖 [Thanks to all the contributors who made GoFrame possible](https://github.com/gogf/gf/graphs/contributors) 💖

 <a href="https://github.com/gogf/gf/graphs/contributors">
-<img src="https://goframe.org/img/contributors.svg?version=v2.9.0-beta" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.9.0" alt="goframe contributors"/>
 </a>

 # License
--- a/cmd/gf/go.mod
+++ b/cmd/gf/go.mod
@ -3,13 +3,13 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.22

 require (
-	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.0-beta
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.0-beta
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.0-beta
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.0-beta
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.0-beta
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.0-beta
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.0
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.0
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.0
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.0
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.0
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.0
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
 	github.com/olekukonko/tablewriter v0.0.5
 	github.com/schollz/progressbar/v3 v3.15.0
--- a/cmd/gf/internal/cmd/testdata/build/varmap/go.mod
+++ b/cmd/gf/internal/cmd/testdata/build/varmap/go.mod
@ -1,12 +1,12 @@
 module github.com/gogf/gf/cmd/gf/cmd/gf/testdata/vardump/v2

-go 1.18
+go 1.22

 require github.com/gogf/gf/v2 v2.8.2

 require (
-	go.opentelemetry.io/otel v1.24.0 // indirect
-	go.opentelemetry.io/otel/trace v1.24.0 // indirect
+	go.opentelemetry.io/otel v1.32.0 // indirect
+	go.opentelemetry.io/otel/trace v1.32.0 // indirect
 )

 replace github.com/gogf/gf/v2 => ../../../../../../../
--- a/cmd/gf/internal/cmd/testdata/build/varmap/go.sum
+++ b/cmd/gf/internal/cmd/testdata/build/varmap/go.sum
@ -19,10 +19,12 @@ github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
 go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
 go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg=
 go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
 go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
 go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
 go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8=
 golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
 golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
 golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
--- a/cmd/gf/internal/service/install.go
+++ b/cmd/gf/internal/service/install.go
@ -162,8 +162,14 @@ func (s serviceInstall) getGoPathBin() string {
 func (s serviceInstall) getAvailablePaths() []serviceInstallAvailablePath {
 	var (
 		folderPaths    []serviceInstallAvailablePath
-		binaryFileName = "gf" + gfile.Ext(gfile.SelfPath())
+		binaryFileName = "gf"
 	)
+
+	// Windows binary file name suffix.
+	if runtime.GOOS == "windows" {
+		binaryFileName += ".exe"
+	}
+
 	// $GOPATH/bin
 	if goPathBin := s.getGoPathBin(); goPathBin != "" {
 		folderPaths = s.checkAndAppendToAvailablePath(
--- a/contrib/config/apollo/go.mod
+++ b/contrib/config/apollo/go.mod
@ -4,7 +4,7 @@ go 1.22

 require (
 	github.com/apolloconfig/agollo/v4 v4.3.1
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 )

 require (
--- a/contrib/config/consul/go.mod
+++ b/contrib/config/consul/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/consul/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/hashicorp/consul/api v1.24.0
 	github.com/hashicorp/go-cleanhttp v0.5.2
 )
--- a/contrib/config/kubecm/go.mod
+++ b/contrib/config/kubecm/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/kubecm/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	k8s.io/api v0.27.4
 	k8s.io/apimachinery v0.27.4
 	k8s.io/client-go v0.27.4
--- a/contrib/config/nacos/go.mod
+++ b/contrib/config/nacos/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/nacos/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/nacos-group/nacos-sdk-go/v2 v2.2.5
 )

--- a/contrib/config/polaris/go.mod
+++ b/contrib/config/polaris/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/config/polaris/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/polarismesh/polaris-go v1.5.8
 )

--- a/contrib/drivers/clickhouse/go.mod
+++ b/contrib/drivers/clickhouse/go.mod
@ -4,7 +4,7 @@ go 1.22

 require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.0.15
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/google/uuid v1.6.0
 	github.com/shopspring/decimal v1.3.1
 )
--- a/contrib/drivers/dm/go.mod
+++ b/contrib/drivers/dm/go.mod
@ -6,7 +6,7 @@ replace github.com/gogf/gf/v2 => ../../../

 require (
 	gitee.com/chunanyong/dm v1.8.12
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 )

 require (
--- a/contrib/drivers/mssql/go.mod
+++ b/contrib/drivers/mssql/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/mssql/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/microsoft/go-mssqldb v1.7.1
 )

--- a/contrib/drivers/mysql/go.mod
+++ b/contrib/drivers/mysql/go.mod
@ -4,7 +4,7 @@ go 1.22

 require (
 	github.com/go-sql-driver/mysql v1.7.1
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 )

 require (
--- a/contrib/drivers/mysql/mysql_z_unit_transaction_test.go
+++ b/contrib/drivers/mysql/mysql_z_unit_transaction_test.go
@ -1286,8 +1286,7 @@ func Test_Transaction_Propagation(t *testing.T) {
 				Propagation: gdb.PropagationNotSupported,
 			}, func(ctx context.Context, tx2 gdb.TX) error {
 				// Should execute without transaction
-				t.Assert(tx2, nil)
-				_, err := db.Insert(ctx, table, g.Map{
+				_, err = db.Insert(ctx, table, g.Map{
 					"id":       9,
 					"passport": "non_tx_record",
 				})
@ -1346,8 +1345,6 @@ func Test_Transaction_Propagation(t *testing.T) {
 		err := db.TransactionWithOptions(ctx, gdb.TxOptions{
 			Propagation: gdb.PropagationNever,
 		}, func(ctx context.Context, tx gdb.TX) error {
-			// Should execute without transaction
-			t.Assert(tx, nil)
 			_, err := db.Insert(ctx, table, g.Map{
 				"id":       11,
 				"passport": "never",
@ -1369,6 +1366,51 @@ func Test_Transaction_Propagation(t *testing.T) {
 	})
 }

+func Test_Transaction_Propagation_PropagationSupports(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		table := createTable()
+		defer dropTable(table)
+
+		// scenario1: when in a transaction, use PropagationSupports to execute a transaction
+		err := db.Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+			// insert in outer tx.
+			_, err := tx.Insert(table, g.Map{
+				"id": 1,
+			})
+			if err != nil {
+				return err
+			}
+			err = tx.TransactionWithOptions(ctx, gdb.TxOptions{
+				Propagation: gdb.PropagationSupports,
+			}, func(ctx context.Context, tx2 gdb.TX) error {
+				_, err = tx2.Insert(table, g.Map{
+					"id": 2,
+				})
+				return gerror.New("error")
+			})
+			return err
+		})
+		t.AssertNE(err, nil)
+
+		// scenario2: when not in a transaction, do not use transaction but direct db link.
+		err = db.TransactionWithOptions(ctx, gdb.TxOptions{
+			Propagation: gdb.PropagationSupports,
+		}, func(ctx context.Context, tx gdb.TX) error {
+			_, err = tx.Insert(table, g.Map{
+				"id": 3,
+			})
+			return err
+		})
+		t.AssertNil(err)
+
+		// 查询结果
+		result, err := db.Model(table).OrderAsc("id").All()
+		t.AssertNil(err)
+		t.Assert(len(result), 1)
+		t.Assert(result[0]["id"], 3)
+	})
+}
+
 func Test_Transaction_Propagation_Complex(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		table1 := createTable()
@ -1389,7 +1431,7 @@ func Test_Transaction_Propagation_Complex(t *testing.T) {
 			err = tx1.TransactionWithOptions(ctx, gdb.TxOptions{
 				Propagation: gdb.PropagationNested,
 			}, func(ctx context.Context, tx2 gdb.TX) error {
-				_, err := tx2.Insert(table1, g.Map{
+				_, err = tx2.Insert(table1, g.Map{
 					"id":       2,
 					"passport": "nested1",
 				})
@ -1427,10 +1469,7 @@ func Test_Transaction_Propagation_Complex(t *testing.T) {
 			err = tx1.TransactionWithOptions(ctx, gdb.TxOptions{
 				Propagation: gdb.PropagationNotSupported,
 			}, func(ctx context.Context, tx2 gdb.TX) error {
-				// Should execute without transaction
-				t.Assert(tx2, nil)
-
-				_, err := db.Insert(ctx, table2, g.Map{
+				_, err = db.Insert(ctx, table2, g.Map{
 					"id":       5,
 					"passport": "not_supported",
 				})
@ -1489,9 +1528,6 @@ func Test_Transaction_Propagation_Complex(t *testing.T) {
 			err = tx1.TransactionWithOptions(ctx, gdb.TxOptions{
 				Propagation: gdb.PropagationNotSupported,
 			}, func(ctx context.Context, tx2 gdb.TX) error {
-				// Should execute without transaction
-				t.Assert(tx2, nil)
-
 				// Start a new independent transaction
 				return db.Transaction(ctx, func(ctx context.Context, tx3 gdb.TX) error {
 					_, err := tx3.Insert(table, g.Map{
--- a/contrib/drivers/oracle/go.mod
+++ b/contrib/drivers/oracle/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/oracle/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/sijms/go-ora/v2 v2.7.10
 )

--- a/contrib/drivers/pgsql/go.mod
+++ b/contrib/drivers/pgsql/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/pgsql/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/lib/pq v1.10.9
 )

--- a/contrib/drivers/sqlite/go.mod
+++ b/contrib/drivers/sqlite/go.mod
@ -4,7 +4,7 @@ go 1.22

 require (
 	github.com/glebarez/go-sqlite v1.21.2
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 )

 require (
--- a/contrib/drivers/sqlitecgo/go.mod
+++ b/contrib/drivers/sqlitecgo/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/drivers/sqlitecgo/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/mattn/go-sqlite3 v1.14.17
 )

--- a/contrib/metric/otelmetric/go.mod
+++ b/contrib/metric/otelmetric/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/metric/otelmetric/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/prometheus/client_golang v1.19.1
 	go.opentelemetry.io/contrib/instrumentation/runtime v0.49.0
 	go.opentelemetry.io/otel v1.32.0
--- a/contrib/nosql/redis/go.mod
+++ b/contrib/nosql/redis/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/nosql/redis/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/redis/go-redis/v9 v9.7.0
 	go.opentelemetry.io/otel v1.32.0
 	go.opentelemetry.io/otel/trace v1.32.0
--- a/contrib/registry/consul/go.mod
+++ b/contrib/registry/consul/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/consul/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/hashicorp/consul/api v1.26.1
 )

--- a/contrib/registry/etcd/go.mod
+++ b/contrib/registry/etcd/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/etcd/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	go.etcd.io/etcd/client/v3 v3.5.17
 	google.golang.org/grpc v1.59.0
 )
--- a/contrib/registry/file/go.mod
+++ b/contrib/registry/file/go.mod
@ -2,7 +2,7 @@ module github.com/gogf/gf/contrib/registry/file/v2

 go 1.22

-require github.com/gogf/gf/v2 v2.9.0-beta
+require github.com/gogf/gf/v2 v2.9.0

 require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
--- a/contrib/registry/nacos/go.mod
+++ b/contrib/registry/nacos/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/nacos/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/nacos-group/nacos-sdk-go/v2 v2.2.7
 )

--- a/contrib/registry/polaris/go.mod
+++ b/contrib/registry/polaris/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/registry/polaris/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	github.com/polarismesh/polaris-go v1.5.8
 )

--- a/contrib/registry/zookeeper/go.mod
+++ b/contrib/registry/zookeeper/go.mod
@ -4,7 +4,7 @@ go 1.22

 require (
 	github.com/go-zookeeper/zk v1.0.3
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	golang.org/x/sync v0.10.0
 )

--- a/contrib/rpc/grpcx/go.mod
+++ b/contrib/rpc/grpcx/go.mod
@ -3,8 +3,8 @@ module github.com/gogf/gf/contrib/rpc/grpcx/v2
 go 1.22

 require (
-	github.com/gogf/gf/contrib/registry/file/v2 v2.9.0-beta
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/contrib/registry/file/v2 v2.9.0
+	github.com/gogf/gf/v2 v2.9.0
 	go.opentelemetry.io/otel v1.32.0
 	go.opentelemetry.io/otel/trace v1.32.0
 	google.golang.org/grpc v1.64.1
--- a/contrib/sdk/httpclient/go.mod
+++ b/contrib/sdk/httpclient/go.mod
@ -2,7 +2,7 @@ module github.com/gogf/gf/contrib/sdk/httpclient/v2

 go 1.22

-require github.com/gogf/gf/v2 v2.9.0-beta
+require github.com/gogf/gf/v2 v2.9.0

 require (
 	github.com/BurntSushi/toml v1.4.0 // indirect
--- a/contrib/trace/otlpgrpc/go.mod
+++ b/contrib/trace/otlpgrpc/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/trace/otlpgrpc/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	go.opentelemetry.io/otel v1.32.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.24.0
--- a/contrib/trace/otlphttp/go.mod
+++ b/contrib/trace/otlphttp/go.mod
@ -3,7 +3,7 @@ module github.com/gogf/gf/contrib/trace/otlphttp/v2
 go 1.22

 require (
-	github.com/gogf/gf/v2 v2.9.0-beta
+	github.com/gogf/gf/v2 v2.9.0
 	go.opentelemetry.io/otel v1.32.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.24.0
 	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.24.0
--- a/database/gdb/gdb_core_transaction.go
+++ b/database/gdb/gdb_core_transaction.go
@ -19,9 +19,15 @@ import (
 type Propagation string

 const (
+	// PropagationNested starts a nested transaction if already in a transaction,
+	// or behaves like PropagationRequired if not in a transaction.
+	//
+	// It is the default behavior.
+	PropagationNested Propagation = "NESTED"
+
 	// PropagationRequired starts a new transaction if not in a transaction,
 	// or uses the existing transaction if already in a transaction.
-	PropagationRequired Propagation = "" // REQUIRED
+	PropagationRequired Propagation = "REQUIRED"

 	// PropagationSupports executes within the existing transaction if present,
 	// otherwise executes without transaction.
@ -30,10 +36,6 @@ const (
 	// PropagationRequiresNew starts a new transaction, and suspends the current transaction if one exists.
 	PropagationRequiresNew Propagation = "REQUIRES_NEW"

-	// PropagationNested starts a nested transaction if already in a transaction,
-	// or behaves like PropagationRequired if not in a transaction.
-	PropagationNested Propagation = "NESTED"
-
 	// PropagationNotSupported executes non-transactional, suspends any existing transaction.
 	PropagationNotSupported Propagation = "NOT_SUPPORTED"

@ -66,7 +68,8 @@ var transactionIdGenerator = gtype.NewUint64()
 // DefaultTxOptions returns the default transaction options.
 func DefaultTxOptions() TxOptions {
 	return TxOptions{
-		Propagation: PropagationRequired,
+		// Note the default propagation type is PropagationNested not PropagationRequired.
+		Propagation: PropagationNested,
 	}
 }

@ -138,11 +141,14 @@ func (c *Core) TransactionWithOptions(
 	switch opts.Propagation {
 	case PropagationRequired:
 		if currentTx != nil {
-			return currentTx.Transaction(ctx, f)
+			return f(ctx, currentTx)
 		}
 		return c.createNewTransaction(ctx, opts, f)

 	case PropagationSupports:
+		if currentTx == nil {
+			currentTx = c.newEmptyTX()
+		}
 		return f(ctx, currentTx)

 	case PropagationMandatory:
@ -160,7 +166,7 @@ func (c *Core) TransactionWithOptions(

 	case PropagationNotSupported:
 		ctx = WithoutTX(ctx, group)
-		return f(ctx, nil)
+		return f(ctx, c.newEmptyTX())

 	case PropagationNever:
 		if currentTx != nil {
@ -169,22 +175,12 @@ func (c *Core) TransactionWithOptions(
 				"transaction propagation NEVER cannot run within an existing transaction",
 			)
 		}
-		return f(ctx, nil)
+		ctx = WithoutTX(ctx, group)
+		return f(ctx, c.newEmptyTX())

 	case PropagationNested:
 		if currentTx != nil {
-			// Create savepoint for nested transaction
-			if err = currentTx.Begin(); err != nil {
-				return err
-			}
-			defer func() {
-				if err != nil {
-					if rbErr := currentTx.Rollback(); rbErr != nil {
-						err = gerror.Wrap(err, rbErr.Error())
-					}
-				}
-			}()
-			return f(ctx, currentTx)
+			return currentTx.Transaction(ctx, f)
 		}
 		return c.createNewTransaction(ctx, opts, f)

@ -280,6 +276,10 @@ func TXFromCtx(ctx context.Context, group string) TX {
 		if tx.IsClosed() {
 			return nil
 		}
+		// no underlying sql tx.
+		if tx.GetSqlTX() == nil {
+			return nil
+		}
 		tx = tx.Ctx(ctx)
 		return tx
 	}
--- a/database/gdb/gdb_core_txcore.go
+++ b/database/gdb/gdb_core_txcore.go
@ -46,6 +46,12 @@ type TXCore struct {
 	cancelFunc context.CancelFunc
 }

+func (c *Core) newEmptyTX() TX {
+	return &TXCore{
+		db: c.db,
+	}
+}
+
 // transactionKeyForNestedPoint forms and returns the transaction key at current save point.
 func (tx *TXCore) transactionKeyForNestedPoint() string {
 	return tx.db.GetCore().QuoteWord(
@ -427,5 +433,5 @@ func (tx *TXCore) IsOnMaster() bool {

 // IsTransaction implements interface function Link.IsTransaction.
 func (tx *TXCore) IsTransaction() bool {
-	return true
+	return tx != nil
 }
--- a/database/gdb/gdb_core_underlying.go
+++ b/database/gdb/gdb_core_underlying.go
@ -103,7 +103,7 @@ func (c *Core) DoExec(ctx context.Context, link Link, sql string, args ...interf
 			return nil, err
 		}
 	} else if !link.IsTransaction() {
-		// If current link is not transaction link, it checks and retrieves transaction from context.
+		// If current link is not transaction link, it tries retrieving transaction object from context.
 		if tx := TXFromCtx(ctx, c.db.GetGroup()); tx != nil {
 			link = &txLink{tx.GetSqlTX()}
 		}
--- a/database/gdb/gdb_model_utility.go
+++ b/database/gdb/gdb_model_utility.go
@ -247,7 +247,9 @@ func (m *Model) doMappingAndFilterForInsertOrUpdateDataMap(data Map, allowOmitEm
 // The parameter `master` specifies whether using the master node if master-slave configured.
 func (m *Model) getLink(master bool) Link {
 	if m.tx != nil {
-		return &txLink{m.tx.GetSqlTX()}
+		if sqlTx := m.tx.GetSqlTX(); sqlTx != nil {
+			return &txLink{sqlTx}
+		}
 	}
 	linkType := m.linkType
 	if linkType == 0 {
--- a/database/gdb/gdb_type_result.go
+++ b/database/gdb/gdb_type_result.go
@ -201,11 +201,14 @@ func (r Result) Structs(pointer interface{}) (err error) {
 		return nil
 	}
 	var (
-		sliceOption = gconv.SliceOption{ContinueOnError: true}
-		mapOption   = gconv.StructOption{
+		sliceOption  = gconv.SliceOption{ContinueOnError: true}
+		structOption = gconv.StructOption{
 			PriorityTag:     OrmTagForStruct,
 			ContinueOnError: true,
 		}
 	)
-	return converter.Structs(r, pointer, sliceOption, mapOption)
+	return converter.Structs(r, pointer, gconv.StructsOption{
+		SliceOption:  sliceOption,
+		StructOption: structOption,
+	})
 }
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit bf0ab5ac16fbf654fc424baf45e96e541a037cb3
+Subproject commit f15e0c1978935dbe44ae6a7b8fe91de53abf1beb
--- a/net/ghttp/ghttp.go
+++ b/net/ghttp/ghttp.go
@ -64,11 +64,11 @@ type (
 		Handler          *HandlerItem // The handler.
 		Server           string       // Server name.
 		Address          string       // Listening address.
-		Domain           string       // Bound domain.
+		Domain           string       // Bound domain, eg: example.com
 		Type             HandlerType  // Route handler type.
 		Middleware       string       // Bound middleware.
-		Method           string       // Handler method name.
-		Route            string       // Route URI.
+		Method           string       // Handler method name, eg: get, post.
+		Route            string       // Route URI, eg: /api/v1/user/{id}.
 		Priority         int          // Just for reference.
 		IsServiceHandler bool         // Is a service handler.
 	}
--- a/net/ghttp/ghttp_request.go
+++ b/net/ghttp/ghttp_request.go
@ -151,8 +151,13 @@ func (r *Request) IsExited() bool {
 }

 // GetHeader retrieves and returns the header value with given `key`.
-func (r *Request) GetHeader(key string) string {
-	return r.Header.Get(key)
+// It returns the optional `def` parameter if the header does not exist.
+func (r *Request) GetHeader(key string, def ...string) string {
+	value := r.Header.Get(key)
+	if value == "" && len(def) > 0 {
+		value = def[0]
+	}
+	return value
 }

 // GetHost returns current request host name, which might be a domain or an IP without port.
--- a/net/ghttp/ghttp_request_param_handler.go
+++ b/net/ghttp/ghttp_request_param_handler.go
@ -6,8 +6,6 @@

 package ghttp

-import "github.com/gogf/gf/v2/util/gmeta"
-
 // GetHandlerResponse retrieves and returns the handler response object and its error.
 func (r *Request) GetHandlerResponse() interface{} {
 	return r.handlerResponse
@ -17,25 +15,3 @@ func (r *Request) GetHandlerResponse() interface{} {
 func (r *Request) GetServeHandler() *HandlerItemParsed {
 	return r.serveHandler
 }
-
-// GetMetaTag retrieves and returns the metadata value associated with the given key from the request struct.
-// The meta value is from struct tags from g.Meta/gmeta.Meta type.
-// For example:
-//
-//	type GetMetaTagReq struct {
-//	    g.Meta `path:"/test" method:"post" summary:"meta_tag" tags:"meta"`
-//	    // ...
-//	}
-//
-// r.GetServeHandler().GetMetaTag("summary") // returns "meta_tag"
-// r.GetServeHandler().GetMetaTag("method")  // returns "post"
-func (h *HandlerItemParsed) GetMetaTag(key string) string {
-	if h == nil || h.Handler == nil {
-		return ""
-	}
-	metaValue := gmeta.Get(h.Handler.Info.Type.In(1), key)
-	if metaValue != nil {
-		return metaValue.String()
-	}
-	return ""
-}
--- a/net/ghttp/ghttp_request_param_page.go
+++ b/net/ghttp/ghttp_request_param_page.go
@ -17,10 +17,12 @@ import (
 // GetPage creates and returns the pagination object for given `totalSize` and `pageSize`.
 // NOTE THAT the page parameter name from clients is constantly defined as gpage.DefaultPageName
 // for simplification and convenience.
+//
+// Deprecated: wrap this pagination html content in business layer.
 func (r *Request) GetPage(totalSize, pageSize int) *gpage.Page {
 	// It must have Router object attribute.
 	if r.Router == nil {
-		panic("Router object not found")
+		panic("router object not found")
 	}
 	var (
 		url            = *r.URL
--- a/net/ghttp/ghttp_server_router_serve.go
+++ b/net/ghttp/ghttp_server_router_serve.go
@ -18,6 +18,7 @@ import (
 	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/util/gmeta"
 )

 // handlerCacheItem is an item just for internal router searching cache.
@ -252,34 +253,34 @@ func (s *Server) searchHandlers(method, path, domain string) (parsedItems []*Han
 }

 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (item HandlerItem) MarshalJSON() ([]byte, error) {
-	switch item.Type {
+func (h *HandlerItem) MarshalJSON() ([]byte, error) {
+	switch h.Type {
 	case HandlerTypeHook:
 		return json.Marshal(
 			fmt.Sprintf(
 				`%s %s:%s (%s)`,
-				item.Router.Uri,
-				item.Router.Domain,
-				item.Router.Method,
-				item.HookName,
+				h.Router.Uri,
+				h.Router.Domain,
+				h.Router.Method,
+				h.HookName,
 			),
 		)
 	case HandlerTypeMiddleware:
 		return json.Marshal(
 			fmt.Sprintf(
 				`%s %s:%s (MIDDLEWARE)`,
-				item.Router.Uri,
-				item.Router.Domain,
-				item.Router.Method,
+				h.Router.Uri,
+				h.Router.Domain,
+				h.Router.Method,
 			),
 		)
 	default:
 		return json.Marshal(
 			fmt.Sprintf(
 				`%s %s:%s`,
-				item.Router.Uri,
-				item.Router.Domain,
-				item.Router.Method,
+				h.Router.Uri,
+				h.Router.Domain,
+				h.Router.Method,
 			),
 		)
 	}
@ -289,3 +290,34 @@ func (item HandlerItem) MarshalJSON() ([]byte, error) {
 func (h *HandlerItemParsed) MarshalJSON() ([]byte, error) {
 	return json.Marshal(h.Handler)
 }
+
+// GetMetaTag retrieves and returns the metadata value associated with the given key from the request struct.
+// The meta value is from struct tags from g.Meta/gmeta.Meta type.
+func (h *HandlerItem) GetMetaTag(key string) string {
+	if h == nil {
+		return ""
+	}
+	metaValue := gmeta.Get(h.Info.Type.In(1), key)
+	if metaValue != nil {
+		return metaValue.String()
+	}
+	return ""
+}
+
+// GetMetaTag retrieves and returns the metadata value associated with the given key from the request struct.
+// The meta value is from struct tags from g.Meta/gmeta.Meta type.
+// For example:
+//
+//	type GetMetaTagReq struct {
+//	    g.Meta `path:"/test" method:"post" summary:"meta_tag" tags:"meta"`
+//	    // ...
+//	}
+//
+// r.GetServeHandler().GetMetaTag("summary") // returns "meta_tag"
+// r.GetServeHandler().GetMetaTag("method")  // returns "post"
+func (h *HandlerItemParsed) GetMetaTag(key string) string {
+	if h == nil || h.Handler == nil {
+		return ""
+	}
+	return h.Handler.GetMetaTag(key)
+}
--- a/net/ghttp/ghttp_z_unit_feature_request_param_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_request_param_test.go
@ -1,3 +1,9 @@
+// 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 ghttp_test

 import (
--- a/net/ghttp/ghttp_z_unit_feature_request_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_request_test.go
@ -363,7 +363,11 @@ func Test_Params_Basic(t *testing.T) {
 func Test_Params_Header(t *testing.T) {
 	s := g.Server(guid.S())
 	s.BindHandler("/header", func(r *ghttp.Request) {
-		r.Response.Write(r.GetHeader("test"))
+		r.Response.Write(map[string]interface{}{
+			"without-def":   r.GetHeader("no-header"),
+			"with-def":      r.GetHeader("no-header", "my-default"),
+			"x-custom-with": r.GetHeader("x-custom", "my-default"),
+		})
 	})
 	s.SetDumpRouterMap(false)
 	s.Start()
@ -374,8 +378,14 @@ func Test_Params_Header(t *testing.T) {
 		prefix := fmt.Sprintf("http://127.0.0.1:%d", s.GetListenedPort())
 		client := g.Client()
 		client.SetPrefix(prefix)
+		client.SetHeader("x-custom", "custom-value")

-		t.Assert(client.Header(g.MapStrStr{"test": "123456"}).GetContent(ctx, "/header"), "123456")
+		resp := client.GetContent(ctx, "/header")
+		t.Assert(gjson.New(resp).Map(), g.Map{
+			"without-def":   "",
+			"with-def":      "my-default",
+			"x-custom-with": "custom-value",
+		})
 	})
 }

--- a/net/ghttp/ghttp_z_unit_feature_router_standard_test.go
+++ b/net/ghttp/ghttp_z_unit_feature_router_standard_test.go
@ -21,7 +21,7 @@ import (
 	"github.com/gogf/gf/v2/util/guid"
 )

-func Test_Router_Handler_Strict_WithObject(t *testing.T) {
+func Test_Router_Handler_Standard_WithObject(t *testing.T) {
 	type TestReq struct {
 		Age  int
 		Name string
@ -137,7 +137,7 @@ func (ControllerForHandlerWithObjectAndMeta2) Test4(ctx context.Context, req *Te
 	}, nil
 }

-func Test_Router_Handler_Strict_WithObjectAndMeta(t *testing.T) {
+func Test_Router_Handler_Standard_WithObjectAndMeta(t *testing.T) {
 	s := g.Server(guid.S())
 	s.Use(ghttp.MiddlewareHandlerResponse)
 	s.Group("/", func(group *ghttp.RouterGroup) {
@ -159,7 +159,7 @@ func Test_Router_Handler_Strict_WithObjectAndMeta(t *testing.T) {
 	})
 }

-func Test_Router_Handler_Strict_Group_Bind(t *testing.T) {
+func Test_Router_Handler_Standard_Group_Bind(t *testing.T) {
 	s := g.Server(guid.S())
 	s.Use(ghttp.MiddlewareHandlerResponse)
 	s.Group("/api/v1", func(group *ghttp.RouterGroup) {
@ -300,7 +300,7 @@ func Test_Custom_Slice_Type_Attribute(t *testing.T) {
 	})
 }

-func Test_Router_Handler_Strict_WithGeneric(t *testing.T) {
+func Test_Router_Handler_Standard_WithGeneric(t *testing.T) {
 	type TestReq struct {
 		Age int
 	}
@ -397,7 +397,7 @@ func (c *ParameterCaseSensitiveController) Path(
 	return &ParameterCaseSensitiveControllerPathRes{Path: req.Path}, nil
 }

-func Test_Router_Handler_Strict_ParameterCaseSensitive(t *testing.T) {
+func Test_Router_Handler_Standard_ParameterCaseSensitive(t *testing.T) {
 	s := g.Server(guid.S())
 	s.Use(ghttp.MiddlewareHandlerResponse)
 	s.Group("/", func(group *ghttp.RouterGroup) {
@ -534,3 +534,40 @@ func Test_NullString_Issue3465(t *testing.T) {

 	})
 }
+
+type testHandlerItemGetMetaTagReq struct {
+	g.Meta `path:"/test" method:"get" sm:"hello" tags:"示例"`
+}
+type testHandlerItemGetMetaTagRes struct{}
+
+type testHandlerItemGetMetaTag struct {
+}
+
+func (t *testHandlerItemGetMetaTag) Test(ctx context.Context, req *testHandlerItemGetMetaTagReq) (res *testHandlerItemGetMetaTagRes, err error) {
+	return nil, nil
+}
+
+func TestHandlerItem_GetMetaTag(t *testing.T) {
+	s := g.Server(guid.S())
+	s.Use(ghttp.MiddlewareHandlerResponse)
+	s.Group("/", func(group *ghttp.RouterGroup) {
+		group.Bind(new(testHandlerItemGetMetaTag))
+	})
+	s.SetDumpRouterMap(false)
+	s.Start()
+	defer s.Shutdown()
+
+	time.Sleep(100 * time.Millisecond)
+	gtest.C(t, func(t *gtest.T) {
+		routes := s.GetRoutes()
+		for _, route := range routes {
+			if !route.IsServiceHandler {
+				continue
+			}
+			t.Assert(route.Handler.GetMetaTag("path"), "/test")
+			t.Assert(route.Handler.GetMetaTag("method"), "get")
+			t.Assert(route.Handler.GetMetaTag("sm"), "hello")
+			t.Assert(route.Handler.GetMetaTag("tags"), "示例")
+		}
+	})
+}
--- a/util/gconv/gconv.go
+++ b/util/gconv/gconv.go
@ -35,7 +35,7 @@ type Converter interface {

 // ConverterForBasic is the basic converting interface.
 type ConverterForBasic interface {
-	Scan(srcValue, dstPointer any, option ScanOption) (err error)
+	Scan(srcValue, dstPointer any, option ...ScanOption) (err error)
 	String(any any) (string, error)
 	Bool(any any) (bool, error)
 	Rune(any any) (rune, error)
@ -74,37 +74,37 @@ type ConverterForFloat interface {

 // 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)
+	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)
+	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, option ...SliceMapOption) ([]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)
+	Struct(params, pointer any, option ...StructOption) (err error)
+	Structs(params, pointer any, option ...StructsOption) (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)
+	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.
@ -123,12 +123,18 @@ type (
 	// SliceOption is the option for Slice type converting.
 	SliceOption = converter.SliceOption

+	// SliceMapOption is the option for SliceMap function.
+	SliceMapOption = converter.SliceMapOption
+
 	// ScanOption is the option for the Scan function.
 	ScanOption = converter.ScanOption

 	// StructOption is the option for Struct converting.
 	StructOption = converter.StructOption

+	// StructsOption is the option for Structs function.
+	StructsOption = converter.StructsOption
+
 	// ConvertOption is the option for converting.
 	ConvertOption = converter.ConvertOption
 )
@ -142,11 +148,6 @@ var (
 	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()
@ -162,3 +163,8 @@ func RegisterConverter(fn any) (err error) {
 func RegisterTypeConverterFunc(fn any) (err error) {
 	return defaultConverter.RegisterTypeConverterFunc(fn)
 }
+
+// RegisterAnyConverterFunc registers custom type converting function for specified type.
+func RegisterAnyConverterFunc(f AnyConvertFunc, types ...reflect.Type) {
+	defaultConverter.RegisterAnyConverterFunc(f, types...)
+}
--- a/util/gconv/gconv_maps.go
+++ b/util/gconv/gconv_maps.go
@ -6,7 +6,10 @@

 package gconv

-import "github.com/gogf/gf/v2/internal/json"
+import (
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv/internal/converter"
+)

 // SliceMap is alias of Maps.
 func SliceMap(any any, option ...MapOption) []map[string]any {
@ -28,9 +31,12 @@ func Maps(value any, option ...MapOption) []map[string]any {
 	if len(option) > 0 {
 		mapOption = option[0]
 	}
-	result, _ := defaultConverter.SliceMap(value, SliceOption{
-		ContinueOnError: true,
-	}, mapOption)
+	result, _ := defaultConverter.SliceMap(value, SliceMapOption{
+		MapOption: mapOption,
+		SliceOption: converter.SliceOption{
+			ContinueOnError: true,
+		},
+	})
 	return result
 }

--- a/util/gconv/gconv_structs.go
+++ b/util/gconv/gconv_structs.go
@ -6,6 +6,8 @@

 package gconv

+import "github.com/gogf/gf/v2/util/gconv/internal/converter"
+
 // Structs converts any slice to given struct slice.
 // Also see Scan, Struct.
 func Structs(params any, pointer any, paramKeyToAttrMap ...map[string]string) (err error) {
@ -21,10 +23,13 @@ func SliceStruct(params any, pointer any, mapping ...map[string]string) (err err
 // 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 any, pointer any, priorityTag string) (err error) {
-	return defaultConverter.Structs(params, pointer, SliceOption{
-		ContinueOnError: true,
-	}, StructOption{
-		PriorityTag:     priorityTag,
-		ContinueOnError: true,
+	return defaultConverter.Structs(params, pointer, StructsOption{
+		SliceOption: converter.SliceOption{
+			ContinueOnError: true,
+		},
+		StructOption: converter.StructOption{
+			PriorityTag:     priorityTag,
+			ContinueOnError: true,
+		},
 	})
 }
--- a/util/gconv/gconv_z_unit_converter_test.go
+++ b/util/gconv/gconv_z_unit_converter_test.go
@ -171,3 +171,72 @@ func TestNewConverter(t *testing.T) {
 		})
 	})
 }
+
+type UserInput struct {
+	Name     string
+	Age      int
+	IsActive bool
+}
+
+type UserModel struct {
+	ID       int
+	FullName string
+	Age      int
+	Status   int
+}
+
+func userInput2Model(in any, out reflect.Value) error {
+	if out.Type() == reflect.TypeOf(&UserModel{}) {
+		if input, ok := in.(UserInput); ok {
+			model := UserModel{
+				ID:       1,
+				FullName: input.Name,
+				Age:      input.Age,
+				Status:   0,
+			}
+			if input.IsActive {
+				model.Status = 1
+			}
+			out.Elem().Set(reflect.ValueOf(model))
+			return nil
+		}
+		return fmt.Errorf("unsupported type %T to UserModel", in)
+	}
+	return fmt.Errorf("unsupported type %s", out.Type())
+}
+
+func TestConverter_RegisterAnyConverterFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		converter := gconv.NewConverter()
+		converter.RegisterAnyConverterFunc(userInput2Model, reflect.TypeOf(UserModel{}))
+		var (
+			model UserModel
+			input = UserInput{Name: "sam", Age: 30, IsActive: true}
+		)
+		err := converter.Scan(input, &model)
+		t.AssertNil(err)
+		t.Assert(model, UserModel{
+			ID:       1,
+			FullName: "sam",
+			Age:      30,
+			Status:   1,
+		})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		converter := gconv.NewConverter()
+		converter.RegisterAnyConverterFunc(userInput2Model, reflect.TypeOf(&UserModel{}))
+		var (
+			model UserModel
+			input = UserInput{Name: "sam", Age: 30, IsActive: true}
+		)
+		err := converter.Scan(input, &model)
+		t.AssertNil(err)
+		t.Assert(model, UserModel{
+			ID:       1,
+			FullName: "sam",
+			Age:      30,
+			Status:   1,
+		})
+	})
+}
--- a/util/gconv/gconv_z_unit_map_test.go
+++ b/util/gconv/gconv_z_unit_map_test.go
@ -345,7 +345,7 @@ func TestMapToMapExtra(t *testing.T) {
 			expect = make(map[string]interface{})
 		)
 		err = gconv.MapToMap(value, &expect)
-		t.Assert(err, nil)
+		t.AssertNil(err)
 		t.Assert(value["k1"], expect["k1"])
 	})

--- a/util/gconv/internal/converter/converter_convert.go
+++ b/util/gconv/internal/converter/converter_convert.go
@ -23,20 +23,27 @@ type ConvertOption struct {
 	StructOption StructOption
 }

+func (c *Converter) getConvertOption(option ...ConvertOption) ConvertOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return ConvertOption{}
+}
+
 // 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) {
+func (c *Converter) ConvertWithTypeName(fromValue any, toTypeName string, option ...ConvertOption) (any, error) {
 	return c.doConvert(
 		doConvertInput{
 			FromValue:  fromValue,
 			ToTypeName: toTypeName,
 			ReferValue: nil,
 		},
-		option,
+		c.getConvertOption(option...),
 	)
 }

 // ConvertWithRefer converts the variable `fromValue` to the type referred by value `referValue`.
-func (c *Converter) ConvertWithRefer(fromValue, referValue any, option ConvertOption) (any, error) {
+func (c *Converter) ConvertWithRefer(fromValue, referValue any, option ...ConvertOption) (any, error) {
 	var referValueRf reflect.Value
 	if v, ok := referValue.(reflect.Value); ok {
 		referValueRf = v
@ -49,7 +56,7 @@ func (c *Converter) ConvertWithRefer(fromValue, referValue any, option ConvertOp
 			ToTypeName: referValueRf.Type().String(),
 			ReferValue: referValue,
 		},
-		option,
+		c.getConvertOption(option...),
 	)
 }

@ -354,7 +361,10 @@ func (c *Converter) doConvert(in doConvertInput, option ConvertOption) (converte
 		return c.Map(in.FromValue, option.MapOption)

 	case "[]map[string]interface {}":
-		return c.SliceMap(in.FromValue, option.SliceOption, option.MapOption)
+		return c.SliceMap(in.FromValue, SliceMapOption{
+			SliceOption: option.SliceOption,
+			MapOption:   option.MapOption,
+		})

 	case "RawMessage", "json.RawMessage":
 		// issue 3449
@ -463,7 +473,53 @@ func (c *Converter) doConvertWithReflectValueSet(reflectValue reflect.Value, in
 	return err
 }

-func (c *Converter) getRegisteredConverterFuncAndSrcType(
+// callCustomConverter call the custom converter. It will try some possible type.
+func (c *Converter) callCustomConverter(srcReflectValue, dstReflectValue reflect.Value) (converted bool, err error) {
+	// search type converter function.
+	registeredConverterFunc, srcType, ok := c.getRegisteredTypeConverterFuncAndSrcType(srcReflectValue, dstReflectValue)
+	if ok {
+		return c.doCallCustomTypeConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
+	}
+
+	// search any converter function.
+	anyConverterFunc := c.getRegisteredAnyConverterFunc(dstReflectValue)
+	if anyConverterFunc == nil {
+		return false, nil
+	}
+	err = anyConverterFunc(srcReflectValue.Interface(), dstReflectValue)
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}
+
+func (c *Converter) callCustomConverterWithRefer(
+	srcReflectValue, referReflectValue reflect.Value,
+) (dstReflectValue reflect.Value, converted bool, err error) {
+	// search type converter function.
+	registeredConverterFunc, srcType, ok := c.getRegisteredTypeConverterFuncAndSrcType(
+		srcReflectValue, referReflectValue,
+	)
+	if ok {
+		dstReflectValue = reflect.New(referReflectValue.Type()).Elem()
+		converted, err = c.doCallCustomTypeConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
+		return
+	}
+
+	// search any converter function.
+	anyConverterFunc := c.getRegisteredAnyConverterFunc(referReflectValue)
+	if anyConverterFunc == nil {
+		return reflect.Value{}, false, nil
+	}
+	dstReflectValue = reflect.New(referReflectValue.Type()).Elem()
+	err = anyConverterFunc(srcReflectValue.Interface(), dstReflectValue)
+	if err != nil {
+		return reflect.Value{}, false, err
+	}
+	return dstReflectValue, true, nil
+}
+
+func (c *Converter) getRegisteredTypeConverterFuncAndSrcType(
 	srcReflectValue, dstReflectValueForRefer reflect.Value,
 ) (f converterFunc, srcType reflect.Type, ok bool) {
 	if len(c.typeConverterFuncMap) == 0 {
@ -499,28 +555,28 @@ func (c *Converter) getRegisteredConverterFuncAndSrcType(
 	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
+func (c *Converter) getRegisteredAnyConverterFunc(dstReflectValueForRefer reflect.Value) (f AnyConvertFunc) {
+	if c.internalConverter.IsAnyConvertFuncEmpty() {
+		return nil
 	}
-	dstReflectValue = reflect.New(referReflectValue.Type()).Elem()
-	converted, err = c.doCallCustomConverter(srcReflectValue, dstReflectValue, registeredConverterFunc, srcType)
-	return
+	if !dstReflectValueForRefer.IsValid() {
+		return nil
+	}
+	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)
+	}
+	return c.internalConverter.GetAnyConvertFuncByType(dstType)
 }

-// 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(
+func (c *Converter) doCallCustomTypeConverter(
 	srcReflectValue reflect.Value,
 	dstReflectValue reflect.Value,
 	registeredConverterFunc converterFunc,
--- a/util/gconv/internal/converter/converter_map.go
+++ b/util/gconv/internal/converter/converter_map.go
@ -35,34 +35,42 @@ type MapOption struct {
 	ContinueOnError bool
 }

+func (c *Converter) getMapOption(option ...MapOption) MapOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return MapOption{}
+}
+
 // 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)
+func (c *Converter) Map(value any, option ...MapOption) (map[string]any, error) {
+	return c.doMapConvert(value, RecursiveTypeAuto, false, c.getMapOption(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) {
+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 {
+	m, err := c.Map(value, option...)
+	if err != nil {
 		return nil, err
 	}
 	if len(m) > 0 {
 		var (
-			s    string
-			vMap = make(map[string]string, len(m))
+			s         string
+			vMap      = make(map[string]string, len(m))
+			mapOption = c.getMapOption(option...)
 		)
 		for k, v := range m {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !mapOption.ContinueOnError {
 				return nil, err
 			}
 			vMap[k] = s
--- a/util/gconv/internal/converter/converter_maptomap.go
+++ b/util/gconv/internal/converter/converter_maptomap.go
@ -24,7 +24,7 @@ import (
 // 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,
+	params, pointer any, mapping map[string]string, option ...MapOption,
 ) (err error) {
 	var (
 		paramsRv   reflect.Value
@ -41,11 +41,11 @@ func (c *Converter) MapToMap(
 		paramsKind = paramsRv.Kind()
 	}
 	if paramsKind != reflect.Map {
-		m, err := c.Map(params, option)
+		m, err := c.Map(params, option...)
 		if err != nil {
 			return err
 		}
-		return c.MapToMap(m, pointer, mapping, option)
+		return c.MapToMap(m, pointer, mapping, option...)
 	}
 	// Empty params map, no need continue.
 	if paramsRv.Len() == 0 {
@ -85,10 +85,11 @@ func (c *Converter) MapToMap(
 		pointerValueType = pointerRv.Type().Elem()
 		pointerValueKind = pointerValueType.Kind()
 		dataMap          = reflect.MakeMapWithSize(pointerRv.Type(), len(paramsKeys))
+		mapOption        = c.getMapOption(option...)
 		convertOption    = ConvertOption{
-			StructOption: StructOption{ContinueOnError: option.ContinueOnError},
-			SliceOption:  SliceOption{ContinueOnError: option.ContinueOnError},
-			MapOption:    option,
+			StructOption: StructOption{ContinueOnError: mapOption.ContinueOnError},
+			SliceOption:  SliceOption{ContinueOnError: mapOption.ContinueOnError},
+			MapOption:    mapOption,
 		}
 	)
 	// Retrieve the true element type of target map.
@ -102,7 +103,7 @@ func (c *Converter) MapToMap(
 			structOption := StructOption{
 				ParamKeyToAttrMap: mapping,
 				PriorityTag:       "",
-				ContinueOnError:   option.ContinueOnError,
+				ContinueOnError:   mapOption.ContinueOnError,
 			}
 			if err = c.Struct(paramsRv.MapIndex(key).Interface(), mapValue, structOption); err != nil {
 				return err
--- a/util/gconv/internal/converter/converter_maptomaps.go
+++ b/util/gconv/internal/converter/converter_maptomaps.go
@ -22,7 +22,7 @@ import (
 // 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,
+	params any, pointer any, paramKeyToAttrMap map[string]string, option ...MapOption,
 ) (err error) {
 	// Params and its element type check.
 	var (
@ -105,13 +105,13 @@ func (c *Converter) MapToMaps(
 		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 {
+			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 {
+			if err = c.MapToMap(paramsRv.Index(i).Interface(), item, paramKeyToAttrMap, option...); err != nil {
 				return err
 			}
 			pointerSlice.Index(i).Set(item.Elem())
--- a/util/gconv/internal/converter/converter_scan.go
+++ b/util/gconv/internal/converter/converter_scan.go
@ -25,8 +25,15 @@ type ScanOption struct {
 	ContinueOnError bool
 }

+func (c *Converter) getScanOption(option ...ScanOption) ScanOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return ScanOption{}
+}
+
 // Scan automatically checks the type of `pointer` and converts `params` to `pointer`.
-func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err error) {
+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
@ -90,12 +97,12 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e
 			// 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 {
+			if err = c.Scan(srcValueReflectValue, nextLevelPtr, option...); err == nil {
 				dstPointerReflectValueElem.Set(nextLevelPtr)
 			}
 			return
 		}
-		return c.Scan(srcValueReflectValue, dstPointerReflectValueElem, option)
+		return c.Scan(srcValueReflectValue, dstPointerReflectValueElem, option...)
 	}

 	// Check if srcValue and dstPointer are the same type, in which case direct assignment can be performed
@ -103,11 +110,12 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e
 		return nil
 	}

+	scanOption := c.getScanOption(option...)
 	// 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 {
+		if err != nil && !scanOption.ContinueOnError {
 			return err
 		}
 		dstPointerReflectValueElem.SetInt(v)
@ -115,7 +123,7 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e

 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
 		v, err := c.Uint64(srcValue)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !scanOption.ContinueOnError {
 			return err
 		}
 		dstPointerReflectValueElem.SetUint(v)
@ -123,7 +131,7 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e

 	case reflect.Float32, reflect.Float64:
 		v, err := c.Float64(srcValue)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !scanOption.ContinueOnError {
 			return err
 		}
 		dstPointerReflectValueElem.SetFloat(v)
@ -131,7 +139,7 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e

 	case reflect.String:
 		v, err := c.String(srcValue)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !scanOption.ContinueOnError {
 			return err
 		}
 		dstPointerReflectValueElem.SetString(v)
@ -139,7 +147,7 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e

 	case reflect.Bool:
 		v, err := c.Bool(srcValue)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !scanOption.ContinueOnError {
 			return err
 		}
 		dstPointerReflectValueElem.SetBool(v)
@ -158,7 +166,7 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e
 		}
 		// Special handling for struct or map slice elements
 		if dstElemKind == reflect.Struct || dstElemKind == reflect.Map {
-			return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+			return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, scanOption)
 		}
 		// Handle basic type slice conversions
 		var srcValueReflectValueKind = srcValueReflectValue.Kind()
@ -172,48 +180,48 @@ func (c *Converter) Scan(srcValue any, dstPointer any, option ScanOption) (err e
 				switch dstElemType.Kind() {
 				case reflect.String:
 					v, err := c.String(srcElem)
-					if err != nil && !option.ContinueOnError {
+					if err != nil && !scanOption.ContinueOnError {
 						return err
 					}
 					newSlice.Index(i).SetString(v)
 				case reflect.Int:
 					v, err := c.Int64(srcElem)
-					if err != nil && !option.ContinueOnError {
+					if err != nil && !scanOption.ContinueOnError {
 						return err
 					}
 					newSlice.Index(i).SetInt(v)
 				case reflect.Int64:
 					v, err := c.Int64(srcElem)
-					if err != nil && !option.ContinueOnError {
+					if err != nil && !scanOption.ContinueOnError {
 						return err
 					}
 					newSlice.Index(i).SetInt(v)
 				case reflect.Float64:
 					v, err := c.Float64(srcElem)
-					if err != nil && !option.ContinueOnError {
+					if err != nil && !scanOption.ContinueOnError {
 						return err
 					}
 					newSlice.Index(i).SetFloat(v)
 				case reflect.Bool:
 					v, err := c.Bool(srcElem)
-					if err != nil && !option.ContinueOnError {
+					if err != nil && !scanOption.ContinueOnError {
 						return err
 					}
 					newSlice.Index(i).SetBool(v)
 				default:
 					return c.Scan(
-						srcElem, newSlice.Index(i).Addr().Interface(), option,
+						srcElem, newSlice.Index(i).Addr().Interface(), option...,
 					)
 				}
 			}
 			dstPointerReflectValueElem.Set(newSlice)
 			return nil
 		}
-		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, scanOption)

 	default:
 		// Handle complex types (structs, maps, etc.)
-		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, option)
+		return c.doScanForComplicatedTypes(srcValue, dstPointer, dstPointerReflectType, scanOption)
 	}
 }

@ -282,7 +290,10 @@ func (c *Converter) doScanForComplicatedTypes(
 				ContinueOnError:   option.ContinueOnError,
 			}
 		)
-		return c.Structs(srcValue, dstPointer, sliceOption, mapOption)
+		return c.Structs(srcValue, dstPointer, StructsOption{
+			SliceOption:  sliceOption,
+			StructOption: mapOption,
+		})

 	default:
 		structOption := StructOption{
--- a/util/gconv/internal/converter/converter_slice_any.go
+++ b/util/gconv/internal/converter/converter_slice_any.go
@ -22,8 +22,15 @@ type SliceOption struct {
 	ContinueOnError bool
 }

+func (c *Converter) getSliceOption(option ...SliceOption) SliceOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return SliceOption{}
+}
+
 // SliceAny converts `any` to []any.
-func (c *Converter) SliceAny(any interface{}, option SliceOption) ([]any, error) {
+func (c *Converter) SliceAny(any interface{}, _ ...SliceOption) ([]any, error) {
 	if empty.IsNil(any) {
 		return nil, nil
 	}
--- a/util/gconv/internal/converter/converter_slice_float.go
+++ b/util/gconv/internal/converter/converter_slice_float.go
@ -17,21 +17,22 @@ import (
 )

 // SliceFloat32 converts `any` to []float32.
-func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32, error) {
+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
+		err         error
+		f           float32
+		array       []float32 = nil
+		sliceOption           = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -40,7 +41,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -49,7 +50,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -58,7 +59,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -67,7 +68,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -76,7 +77,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -85,7 +86,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -99,7 +100,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -116,7 +117,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		}
 		if utils.IsNumeric(value) {
 			f, err = c.Float32(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []float32{f}, err
@ -125,7 +126,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -134,7 +135,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -143,7 +144,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -152,7 +153,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -163,7 +164,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -172,7 +173,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		array = make([]float32, len(value))
 		for k, v := range value {
 			f, err = c.Float32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -182,10 +183,10 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		return array, err
 	}
 	if v, ok := any.(localinterface.IFloats); ok {
-		return c.SliceFloat32(v.Floats(), option)
+		return c.SliceFloat32(v.Floats(), option...)
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceFloat32(v.Interfaces(), option)
+		return c.SliceFloat32(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -197,7 +198,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 		)
 		for i := 0; i < length; i++ {
 			f, err = c.Float32(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = f
@ -209,7 +210,7 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 			return []float32{}, err
 		}
 		f, err = c.Float32(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []float32{f}, err
@ -217,21 +218,22 @@ func (c *Converter) SliceFloat32(any interface{}, option SliceOption) ([]float32
 }

 // SliceFloat64 converts `any` to []float64.
-func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64, error) {
+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
+		err         error
+		f           float64
+		array       []float64 = nil
+		sliceOption           = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -240,7 +242,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -249,7 +251,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -258,7 +260,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -267,7 +269,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -276,7 +278,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -285,7 +287,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -299,7 +301,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -316,7 +318,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		}
 		if utils.IsNumeric(value) {
 			f, err = c.Float64(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []float64{f}, err
@ -325,7 +327,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -334,7 +336,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -343,7 +345,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -352,7 +354,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -361,7 +363,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -372,7 +374,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		array = make([]float64, len(value))
 		for k, v := range value {
 			f, err = c.Float64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = f
@ -385,7 +387,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		return v.Floats(), err
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceFloat64(v.Interfaces(), option)
+		return c.SliceFloat64(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -397,7 +399,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 		)
 		for i := 0; i < length; i++ {
 			f, err = c.Float64(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = f
@ -409,7 +411,7 @@ func (c *Converter) SliceFloat64(any interface{}, option SliceOption) ([]float64
 			return []float64{}, err
 		}
 		f, err = c.Float64(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []float64{f}, err
--- a/util/gconv/internal/converter/converter_slice_int.go
+++ b/util/gconv/internal/converter/converter_slice_int.go
@ -17,21 +17,22 @@ import (
 )

 // SliceInt converts `any` to []int.
-func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
+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
+		err         error
+		ii          int
+		array       []int = nil
+		sliceOption       = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -85,7 +86,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		}
 		if utils.IsNumeric(value) {
 			ii, err = c.Int(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []int{ii}, err
@ -118,7 +119,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		array = make([]int, len(value))
 		for k, v := range value {
 			ii, err = c.Int(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -127,7 +128,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		array = make([]int, len(value))
 		for k, v := range value {
 			ii, err = c.Int(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -136,7 +137,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		array = make([]int, len(value))
 		for k, v := range value {
 			ii, err = c.Int(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -145,7 +146,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		array = make([]int, len(value))
 		for k, v := range value {
 			ii, err = c.Int(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -158,7 +159,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		return v.Ints(), err
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceInt(v.Interfaces(), option)
+		return c.SliceInt(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -170,7 +171,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 		)
 		for i := 0; i < length; i++ {
 			ii, err = c.Int(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ii
@ -182,7 +183,7 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 			return []int{}, err
 		}
 		ii, err = c.Int(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []int{ii}, err
@ -190,21 +191,22 @@ func (c *Converter) SliceInt(any any, option SliceOption) ([]int, error) {
 }

 // SliceInt32 converts `any` to []int32.
-func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
+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
+		err         error
+		ii          int32
+		array       []int32 = nil
+		sliceOption         = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -258,7 +260,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		}
 		if utils.IsNumeric(value) {
 			ii, err = c.Int32(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []int32{ii}, err
@ -291,7 +293,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		array = make([]int32, len(value))
 		for k, v := range value {
 			ii, err = c.Int32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -300,7 +302,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		array = make([]int32, len(value))
 		for k, v := range value {
 			ii, err = c.Int32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -309,7 +311,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		array = make([]int32, len(value))
 		for k, v := range value {
 			ii, err = c.Int32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -318,7 +320,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		array = make([]int32, len(value))
 		for k, v := range value {
 			ii, err = c.Int32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -328,10 +330,10 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		return array, err
 	}
 	if v, ok := any.(localinterface.IInts); ok {
-		return c.SliceInt32(v.Ints(), option)
+		return c.SliceInt32(v.Ints(), option...)
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceInt32(v.Interfaces(), option)
+		return c.SliceInt32(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -343,7 +345,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 		)
 		for i := 0; i < length; i++ {
 			ii, err = c.Int32(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ii
@ -355,7 +357,7 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 			return []int32{}, err
 		}
 		ii, err = c.Int32(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []int32{ii}, err
@ -363,21 +365,22 @@ func (c *Converter) SliceInt32(any any, option SliceOption) ([]int32, error) {
 }

 // SliceInt64 converts `any` to []int64.
-func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
+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
+		err         error
+		ii          int64
+		array       []int64 = nil
+		sliceOption         = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -431,7 +434,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		}
 		if utils.IsNumeric(value) {
 			ii, err = c.Int64(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []int64{ii}, err
@ -464,7 +467,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		array = make([]int64, len(value))
 		for k, v := range value {
 			ii, err = c.Int64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -473,7 +476,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		array = make([]int64, len(value))
 		for k, v := range value {
 			ii, err = c.Int64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -482,7 +485,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		array = make([]int64, len(value))
 		for k, v := range value {
 			ii, err = c.Int64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -491,7 +494,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		array = make([]int64, len(value))
 		for k, v := range value {
 			ii, err = c.Int64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ii
@ -501,10 +504,10 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		return array, err
 	}
 	if v, ok := any.(localinterface.IInts); ok {
-		return c.SliceInt64(v.Ints(), option)
+		return c.SliceInt64(v.Ints(), option...)
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceInt64(v.Interfaces(), option)
+		return c.SliceInt64(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -516,7 +519,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 		)
 		for i := 0; i < length; i++ {
 			ii, err = c.Int64(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ii
@ -528,7 +531,7 @@ func (c *Converter) SliceInt64(any any, option SliceOption) ([]int64, error) {
 			return []int64{}, err
 		}
 		ii, err = c.Int64(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []int64{ii}, err
--- a/util/gconv/internal/converter/converter_slice_map.go
+++ b/util/gconv/internal/converter/converter_slice_map.go
@ -8,9 +8,22 @@ package converter

 import "github.com/gogf/gf/v2/internal/json"

+// SliceMapOption is the option for SliceMap function.
+type SliceMapOption struct {
+	SliceOption SliceOption
+	MapOption   MapOption
+}
+
+func (c *Converter) getSliceMapOption(option ...SliceMapOption) SliceMapOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return SliceMapOption{}
+}
+
 // 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) {
+func (c *Converter) SliceMap(value any, option ...SliceMapOption) ([]map[string]any, error) {
 	if value == nil {
 		return nil, nil
 	}
@ -39,7 +52,8 @@ func (c *Converter) SliceMap(value any, sliceOption SliceOption, mapOption MapOp
 		return r, nil

 	default:
-		array, err := c.SliceAny(value, sliceOption)
+		sliceMapOption := c.getSliceMapOption(option...)
+		array, err := c.SliceAny(value, sliceMapOption.SliceOption)
 		if err != nil {
 			return nil, err
 		}
@ -48,8 +62,8 @@ func (c *Converter) SliceMap(value any, sliceOption SliceOption, mapOption MapOp
 		}
 		list := make([]map[string]any, len(array))
 		for k, v := range array {
-			m, err := c.Map(v, mapOption)
-			if err != nil && !sliceOption.ContinueOnError {
+			m, err := c.Map(v, sliceMapOption.MapOption)
+			if err != nil && !sliceMapOption.SliceOption.ContinueOnError {
 				return nil, err
 			}
 			list[k] = m
--- a/util/gconv/internal/converter/converter_slice_str.go
+++ b/util/gconv/internal/converter/converter_slice_str.go
@ -16,21 +16,22 @@ import (
 )

 // SliceStr converts `any` to []string.
-func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, error) {
+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
+		err         error
+		s           string
+		array       []string = nil
+		sliceOption          = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -39,7 +40,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -48,7 +49,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -57,7 +58,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -66,7 +67,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -75,7 +76,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -89,7 +90,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -110,7 +111,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -119,7 +120,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -128,7 +129,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -137,7 +138,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -146,7 +147,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -155,7 +156,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -164,7 +165,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -175,7 +176,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		array = make([]string, len(value))
 		for k, v := range value {
 			s, err = c.String(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = s
@ -188,7 +189,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		return v.Strings(), err
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceStr(v.Interfaces(), option)
+		return c.SliceStr(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -200,7 +201,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 		)
 		for i := 0; i < length; i++ {
 			s, err = c.String(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = s
@ -212,7 +213,7 @@ func (c *Converter) SliceStr(any interface{}, option SliceOption) ([]string, err
 			return []string{}, err
 		}
 		s, err = c.String(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []string{s}, err
--- a/util/gconv/internal/converter/converter_slice_uint.go
+++ b/util/gconv/internal/converter/converter_slice_uint.go
@ -17,21 +17,22 @@ import (
 )

 // SliceUint converts `any` to []uint.
-func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, error) {
+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
+		err         error
+		ui          uint
+		array       []uint = nil
+		sliceOption        = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -80,7 +81,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		}
 		if utils.IsNumeric(value) {
 			ui, err = c.Uint(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []uint{ui}, err
@ -113,7 +114,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		array = make([]uint, len(value))
 		for k, v := range value {
 			ui, err = c.Uint(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -122,7 +123,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		array = make([]uint, len(value))
 		for k, v := range value {
 			ui, err = c.Uint(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -131,7 +132,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		array = make([]uint, len(value))
 		for k, v := range value {
 			ui, err = c.Uint(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -140,7 +141,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		array = make([]uint, len(value))
 		for k, v := range value {
 			ui, err = c.Uint(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -156,7 +157,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		return v.Uints(), err
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceUint(v.Interfaces(), option)
+		return c.SliceUint(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -168,7 +169,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 		)
 		for i := 0; i < length; i++ {
 			ui, err = c.Uint(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ui
@ -180,7 +181,7 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 			return []uint{}, err
 		}
 		ui, err = c.Uint(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []uint{ui}, err
@ -188,21 +189,22 @@ func (c *Converter) SliceUint(any interface{}, option SliceOption) ([]uint, erro
 }

 // SliceUint32 converts `any` to []uint32.
-func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32, error) {
+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
+		err         error
+		ui          uint32
+		array       []uint32 = nil
+		sliceOption          = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -254,7 +256,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		}
 		if utils.IsNumeric(value) {
 			ui, err = c.Uint32(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []uint32{ui}, err
@ -284,7 +286,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		array = make([]uint32, len(value))
 		for k, v := range value {
 			ui, err = c.Uint32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -293,7 +295,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		array = make([]uint32, len(value))
 		for k, v := range value {
 			ui, err = c.Uint32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -302,7 +304,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		array = make([]uint32, len(value))
 		for k, v := range value {
 			ui, err = c.Uint32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -311,7 +313,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		array = make([]uint32, len(value))
 		for k, v := range value {
 			ui, err = c.Uint32(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -323,10 +325,10 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,

 	// Default handler.
 	if v, ok := any.(localinterface.IUints); ok {
-		return c.SliceUint32(v.Uints(), option)
+		return c.SliceUint32(v.Uints(), option...)
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceUint32(v.Interfaces(), option)
+		return c.SliceUint32(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -338,7 +340,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 		)
 		for i := 0; i < length; i++ {
 			ui, err = c.Uint32(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ui
@ -350,7 +352,7 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 			return []uint32{}, err
 		}
 		ui, err = c.Uint32(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []uint32{ui}, err
@ -358,21 +360,22 @@ func (c *Converter) SliceUint32(any interface{}, option SliceOption) ([]uint32,
 }

 // SliceUint64 converts `any` to []uint64.
-func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64, error) {
+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
+		err         error
+		ui          uint64
+		array       []uint64 = nil
+		sliceOption          = c.getSliceOption(option...)
 	)
 	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 {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -424,7 +427,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		}
 		if utils.IsNumeric(value) {
 			ui, err = c.Uint64(value)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			return []uint64{ui}, err
@ -454,7 +457,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		array = make([]uint64, len(value))
 		for k, v := range value {
 			ui, err = c.Uint64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -463,7 +466,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		array = make([]uint64, len(value))
 		for k, v := range value {
 			ui, err = c.Uint64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -472,7 +475,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		array = make([]uint64, len(value))
 		for k, v := range value {
 			ui, err = c.Uint64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -481,7 +484,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		array = make([]uint64, len(value))
 		for k, v := range value {
 			ui, err = c.Uint64(v)
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			array[k] = ui
@ -492,10 +495,10 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 	}
 	// Default handler.
 	if v, ok := any.(localinterface.IUints); ok {
-		return c.SliceUint64(v.Uints(), option)
+		return c.SliceUint64(v.Uints(), option...)
 	}
 	if v, ok := any.(localinterface.IInterfaces); ok {
-		return c.SliceUint64(v.Interfaces(), option)
+		return c.SliceUint64(v.Interfaces(), option...)
 	}
 	// Not a common type, it then uses reflection for conversion.
 	originValueAndKind := reflection.OriginValueAndKind(any)
@ -507,7 +510,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 		)
 		for i := 0; i < length; i++ {
 			ui, err = c.Uint64(originValueAndKind.OriginValue.Index(i).Interface())
-			if err != nil && !option.ContinueOnError {
+			if err != nil && !sliceOption.ContinueOnError {
 				return nil, err
 			}
 			slice[i] = ui
@ -519,7 +522,7 @@ func (c *Converter) SliceUint64(any interface{}, option SliceOption) ([]uint64,
 			return []uint64{}, err
 		}
 		ui, err = c.Uint64(any)
-		if err != nil && !option.ContinueOnError {
+		if err != nil && !sliceOption.ContinueOnError {
 			return nil, err
 		}
 		return []uint64{ui}, err
--- a/util/gconv/internal/converter/converter_struct.go
+++ b/util/gconv/internal/converter/converter_struct.go
@ -32,8 +32,15 @@ type StructOption struct {
 	ContinueOnError bool
 }

+func (c *Converter) getStructOption(option ...StructOption) StructOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return StructOption{}
+}
+
 // Struct is the core internal converting function for any data to struct.
-func (c *Converter) Struct(params, pointer any, option StructOption) (err error) {
+func (c *Converter) Struct(params, pointer any, option ...StructOption) (err error) {
 	if params == nil {
 		// If `params` is nil, no conversion.
 		return nil
@ -63,6 +70,7 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 	}()

 	var (
+		structOption            = c.getStructOption(option...)
 		paramsReflectValue      reflect.Value
 		paramsInterface         any // DO NOT use `params` directly as it might be type `reflect.Value`
 		pointerReflectValue     reflect.Value
@ -105,9 +113,13 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 	}

 	// custom convert.
-	if ok, err = c.callCustomConverter(paramsReflectValue, pointerReflectValue); ok {
+	ok, err = c.callCustomConverter(paramsReflectValue, pointerReflectValue)
+	if err != nil && !structOption.ContinueOnError {
 		return err
 	}
+	if ok {
+		return nil
+	}

 	// Normal unmarshalling interfaces checks.
 	if ok, err = bindVarToReflectValueWithInterfaceCheck(pointerReflectValue, paramsInterface); ok {
@ -142,7 +154,7 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 		// 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,
+			ContinueOnError: structOption.ContinueOnError,
 		})
 		if err != nil {
 			return err
@ -161,7 +173,7 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 	}
 	// Get struct info from cache or parse struct and cache the struct info.
 	cachedStructInfo := c.internalConverter.GetCachedStructInfo(
-		pointerElemReflectValue.Type(), option.PriorityTag,
+		pointerElemReflectValue.Type(), structOption.PriorityTag,
 	)
 	// Nothing to be converted.
 	if cachedStructInfo == nil {
@ -182,7 +194,7 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)

 	// 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 {
+	for paramKey, fieldName := range structOption.ParamKeyToAttrMap {
 		paramsValue, ok = paramsMap[paramKey]
 		if !ok {
 			continue
@ -194,13 +206,13 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 				cachedFieldInfo,
 				fieldValue,
 				paramsValue,
-				option,
+				structOption,
 			); err != nil {
 				return err
 			}
 			if len(cachedFieldInfo.OtherSameNameField) > 0 {
 				if err = c.setOtherSameNameField(
-					cachedFieldInfo, paramsValue, pointerReflectValue, option,
+					cachedFieldInfo, paramsValue, pointerReflectValue, structOption,
 				); err != nil {
 					return err
 				}
@ -215,7 +227,7 @@ func (c *Converter) Struct(params, pointer any, option StructOption) (err error)
 	return c.bindStructWithLoopFieldInfos(
 		paramsMap, pointerElemReflectValue,
 		usedParamsKeyOrTagNameMap, cachedStructInfo,
-		option,
+		structOption,
 	)
 }

--- a/util/gconv/internal/converter/converter_structs.go
+++ b/util/gconv/internal/converter/converter_structs.go
@ -13,6 +13,19 @@ import (
 	"github.com/gogf/gf/v2/errors/gerror"
 )

+// StructsOption is the option for Structs function.
+type StructsOption struct {
+	SliceOption  SliceOption
+	StructOption StructOption
+}
+
+func (c *Converter) getStructsOption(option ...StructsOption) StructsOption {
+	if len(option) > 0 {
+		return option[0]
+	}
+	return StructsOption{}
+}
+
 // Structs converts any slice to given struct slice.
 //
 // It automatically checks and converts json string to []map if `params` is string/[]byte.
@ -20,9 +33,7 @@ import (
 // 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) {
+func (c *Converter) Structs(params any, pointer any, option ...StructsOption) (err error) {
 	defer func() {
 		// Catch the panic, especially the reflection operation panics.
 		if exception := recover(); exception != nil {
@ -47,9 +58,10 @@ func (c *Converter) Structs(
 	}
 	// Converting `params` to map slice.
 	var (
-		paramsList []any
-		paramsRv   = reflect.ValueOf(params)
-		paramsKind = paramsRv.Kind()
+		paramsList    []any
+		paramsRv      = reflect.ValueOf(params)
+		paramsKind    = paramsRv.Kind()
+		structsOption = c.getStructsOption(option...)
 	)
 	for paramsKind == reflect.Ptr {
 		paramsRv = paramsRv.Elem()
@ -62,8 +74,11 @@ func (c *Converter) Structs(
 			paramsList[i] = paramsRv.Index(i).Interface()
 		}
 	default:
-		paramsMaps, err := c.SliceMap(params, sliceOption, MapOption{
-			ContinueOnError: structOption.ContinueOnError,
+		paramsMaps, err := c.SliceMap(params, SliceMapOption{
+			SliceOption: structsOption.SliceOption,
+			MapOption: MapOption{
+				ContinueOnError: structsOption.StructOption.ContinueOnError,
+			},
 		})
 		if err != nil {
 			return err
@ -95,7 +110,7 @@ func (c *Converter) Structs(
 			if !tempReflectValue.IsValid() {
 				tempReflectValue = reflect.New(itemType.Elem()).Elem()
 			}
-			if err = c.Struct(paramsList[i], tempReflectValue, structOption); err != nil {
+			if err = c.Struct(paramsList[i], tempReflectValue, structsOption.StructOption); err != nil {
 				return err
 			}
 			reflectElemArray.Index(i).Set(tempReflectValue.Addr())
@ -109,7 +124,7 @@ func (c *Converter) Structs(
 			} else {
 				tempReflectValue = reflect.New(itemType).Elem()
 			}
-			if err = c.Struct(paramsList[i], tempReflectValue, structOption); err != nil {
+			if err = c.Struct(paramsList[i], tempReflectValue, structsOption.StructOption); err != nil {
 				return err
 			}
 			reflectElemArray.Index(i).Set(tempReflectValue)
--- a/util/gconv/internal/structcache/structcache.go
+++ b/util/gconv/internal/structcache/structcache.go
@ -8,9 +8,12 @@
 package structcache

 import (
+	"context"
 	"reflect"
+	"runtime"
 	"sync"

+	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/util/gconv/internal/localinterface"
 )

@ -36,6 +39,7 @@ type Converter struct {
 }

 // AnyConvertFunc is the function type for converting any to specified type.
+// Note that the parameter `to` is usually a pointer type.
 type AnyConvertFunc func(from any, to reflect.Value) error

 // NewConverter creates and returns a new Converter object.
@ -56,21 +60,39 @@ func (cf *Converter) MarkTypeConvertFunc(fieldType reflect.Type) {
 }

 // RegisterAnyConvertFunc registers custom type converting function for specified type.
-func (cf *Converter) RegisterAnyConvertFunc(t reflect.Type, convertFunc AnyConvertFunc) {
-	if t == nil || convertFunc == nil {
+func (cf *Converter) RegisterAnyConvertFunc(dstType reflect.Type, convertFunc AnyConvertFunc) {
+	if dstType == nil || convertFunc == nil {
 		return
 	}
-	for t.Kind() == reflect.Ptr {
-		t = t.Elem()
+	for dstType.Kind() == reflect.Ptr {
+		dstType = dstType.Elem()
 	}
-	if t.Kind() == reflect.Interface {
+	if dstType.Kind() == reflect.Interface {
 		cf.interfaceToTypeConvertMap = append(cf.interfaceToTypeConvertMap, interfaceTypeConverter{
-			interfaceType: t,
+			interfaceType: dstType,
 			convertFunc:   convertFunc,
 		})
 		return
 	}
-	cf.anyToTypeConvertMap[t] = convertFunc
+	cf.anyToTypeConvertMap[dstType] = convertFunc
+	intlog.Printf(
+		context.Background(),
+		`RegisterAnyConvertFunc: %s -> %s`,
+		dstType.String(), runtime.FuncForPC(reflect.ValueOf(convertFunc).Pointer()).Name(),
+	)
+}
+
+// GetAnyConvertFuncByType retrieves and returns the converting function for specified type.
+func (cf *Converter) GetAnyConvertFuncByType(dstType reflect.Type) AnyConvertFunc {
+	if dstType.Kind() == reflect.Ptr {
+		dstType = dstType.Elem()
+	}
+	return cf.anyToTypeConvertMap[dstType]
+}
+
+// IsAnyConvertFuncEmpty checks whether there's any converting function registered.
+func (cf *Converter) IsAnyConvertFuncEmpty() bool {
+	return len(cf.anyToTypeConvertMap) == 0
 }

 func (cf *Converter) checkTypeImplInterface(t reflect.Type) AnyConvertFunc {
--- a/util/gpage/gpage.go
+++ b/util/gpage/gpage.go
@ -5,6 +5,8 @@
 // You can obtain one at https://github.com/gogf/gf.

 // Package gpage provides useful paging functionality for web pages.
+//
+// Deprecated: wrap this pagination html content in business layer.
 package gpage

 import (
@ -18,6 +20,8 @@ import (

 // Page is the pagination implementer.
 // All the attributes are public, you can change them when necessary.
+//
+// Deprecated: wrap this pagination html content in business layer.
 type Page struct {
 	TotalSize      int    // Total size.
 	TotalPage      int    // Total page, which is automatically calculated.
@ -48,6 +52,8 @@ const (
 // /user/list/{.page}, /user/list/{.page}.html, /user/list?page={.page}&type=1, etc.
 // The build-in variable in `urlTemplate` "{.page}" specifies the page number, which will be replaced by certain
 // page number when producing.
+//
+// Deprecated: wrap this pagination html content in business layer.
 func New(totalSize, pageSize, currentPage int, urlTemplate string) *Page {
 	p := &Page{
 		LinkStyle:    "GPageLink",
--- a/version.go
+++ b/version.go
@ -2,5 +2,5 @@ package gf

 const (
 	// VERSION is the current GoFrame version.
-	VERSION = "v2.9.0-beta"
+	VERSION = "v2.9.0"
 )
Author	SHA1	Message	Date
John Guo	a822489ee4	Merge 29823983793857eb344503f4b3beacddbf9632bf into 1534abdb050acaa5aa6ef27f94e91bca97e6faa3	2025-04-02 23:53:06 +08:00
John Guo	1534abdb05	feat(util/gpage): marked deprecated (#4230 )	2025-04-02 19:56:28 +08:00
hailaz	fee38b4531	feat(net/ghttp): enhance GetHeader method to support default values (#4210 )	2025-03-25 20:42:30 +08:00
John Guo	69e3362d0d	feat: new version v2.9.0 (#4204 )	2025-03-17 15:52:26 +08:00
John Guo	9a61a6970f	fix(database/gdb): fix transaction propagation feature (#4199 )	2025-03-17 14:50:07 +08:00
hailaz	abf77fac50	fix(cmd/gf): invalid binary suffix after installing binary using custom renamed file name that has suffix with `.` character (#4207 )	2025-03-17 13:48:54 +08:00
John Guo	07696fc779	feat(net/ghttp): add `GetMetaTag` function to retrieve metadata value for `HandlerItem` (#4206 )	2025-03-17 09:21:00 +08:00
John Guo	bc1e1019c5	refract(util/gconv): change `Converter` interface definition for more convenient usage (#4202 )	2025-03-14 18:23:07 +08:00