Merge branch 'master' into copilot/fix-4382

Code example：
``` go
	var res *BasicInfo
	err := g.DB().Model("basic_info").
		FieldsPrefix("basic_info", basicInfoColumns).
		Where("id", 35813305356386305).Scan(&res)
	if err != nil {
		panic(err)
	}
	g.Dump(res)
```

SQL generated before modification ：
``` sql
SELECT basic_info.id,basic_info.full_name,basic_info.contact FROM `basic_info` WHERE (`id`=35813305356386305) AND `delete_time` IS NULL LIMIT 1
```

SQL generated after modification：
``` sql
SELECT `basic_info`.`id`,`basic_info`.`full_name`,`basic_info`.`contact` FROM `basic_info` WHERE (`id`=35813305356386305) AND `delete_time` IS NULL LIMIT 1
```

---------

Co-authored-by: hailaz <739476267@qq.com>

.github/workflows/ci-main.yml

@@ -20,6 +20,13 @@ on:
     - feature/**
     - enhance/**
     - fix/**
+  workflow_dispatch:
+    inputs:
+      debug:
+        type: boolean
+        description: 'Enable tmate Debug'
+        required: false
+        default: false
 
 # This allows a subsequently queued workflow run to interrupt previous runs
 concurrency:
@@ -207,6 +214,13 @@ jobs:
     - name: Checkout Repository
       uses: actions/checkout@v5
 
+    - name: Setup tmate Session
+      uses: mxschmitt/action-tmate@v3
+      if: ${{ github.event_name == 'workflow_dispatch' && inputs.debug }}
+      with:
+        detached: true
+        limit-access-to-actor: false
+
     - name: Start Apollo Containers
       run:  docker compose -f ".github/workflows/apollo/docker-compose.yml" up -d --build
       

.github/workflows/codeql.yml

@@ -0,0 +1,100 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL Advanced"
+
+on:
+  push:
+    branches: [ "master", "develop" ]
+  pull_request:
+    branches: [ "master", "develop" ]
+  schedule:
+    - cron: '0 21 * * *'
+
+jobs:
+  analyze:
+    name: Analyze (${{ matrix.language }})
+    # Runner size impacts CodeQL analysis time. To learn more, please see:
+    #   - https://gh.io/recommended-hardware-resources-for-running-codeql
+    #   - https://gh.io/supported-runners-and-hardware-resources
+    #   - https://gh.io/using-larger-runners (GitHub.com only)
+    # Consider using larger runners or machines with greater resources for possible analysis time improvements.
+    runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }}
+    permissions:
+      # required for all workflows
+      security-events: write
+
+      # required to fetch internal or private CodeQL packs
+      packages: read
+
+      # only required for workflows in private repositories
+      actions: read
+      contents: read
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+        - language: actions
+          build-mode: none
+        - language: go
+          build-mode: autobuild
+        # CodeQL supports the following values keywords for 'language': 'actions', 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'rust', 'swift'
+        # Use `c-cpp` to analyze code written in C, C++ or both
+        # Use 'java-kotlin' to analyze code written in Java, Kotlin or both
+        # Use 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both
+        # To learn more about changing the languages that are analyzed or customizing the build mode for your analysis,
+        # see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning.
+        # If you are analyzing a compiled language, you can modify the 'build-mode' for that language to customize how
+        # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+
+    # Add any setup steps before running the `github/codeql-action/init` action.
+    # This includes steps like installing compilers or runtimes (`actions/setup-node`
+    # or others). This is typically only required for manual builds.
+    # - name: Setup runtime (example)
+    #   uses: actions/setup-example@v1
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      with:
+        languages: ${{ matrix.language }}
+        build-mode: ${{ matrix.build-mode }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+    # If the analyze step fails for one of the languages you are analyzing with
+    # "We were unable to automatically build your code", modify the matrix above
+    # to set the build mode to "manual" for that language. Then modify this step
+    # to build your code.
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+    - if: matrix.build-mode == 'manual'
+      shell: bash
+      run: |
+        echo 'If you are using a "manual" build mode for one or more of the' \
+          'languages you are analyzing, replace this with the commands to build' \
+          'your code, for example:'
+        echo '  make bootstrap'
+        echo '  make release'
+        exit 1
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -34,7 +34,7 @@ jobs:
       - name: Build CLI Binary For All Platform
         run: |
           cd cmd/gf
-          gf build main.go -n gf -a all -s all -p temp
+          gf build main.go -n gf -a all -s linux,windows,darwin,freebsd,netbsd,openbsd -p temp
 
       - name: Move Files Before Release
         run: |

.github/workflows/scorecard.yml

@@ -0,0 +1,80 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: '0 21 * * *'
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.
+    if: github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request'
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      # Uncomment the permissions below if installing in a private repository.
+      # contents: read
+      # actions: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@v2.4.1
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecard on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+          # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore
+          # file_mode: git
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@v4.6.1
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # Upload the results to GitHub's code scanning dashboard (optional).
+      # Commenting out will disable upload of results to your repo's Code Scanning dashboard
+      - name: "Upload to code-scanning"
+        uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: results.sarif

.github/workflows/scripts/ci-main.sh

@@ -2,12 +2,6 @@
 
 coverage=$1
 
-# update code of submodules
-git clone https://github.com/gogf/examples
-
-# update go.mod in examples directory to replace github.com/gogf/gf packages with local directory
-bash .github/workflows/scripts/replace_examples_gomod.sh
-
 # find all path that contains go.mod.
 for file in `find . -name go.mod`; do
     dirpath=$(dirname $file)
@@ -24,22 +18,18 @@ for file in `find . -name go.mod`; do
         continue 1
     fi
 
-    # Check if it's a contrib directory or examples directory
-    if [[ $dirpath =~ "/contrib/" ]] || [[ $dirpath =~ "/examples/" ]]; then
+    # examples directory was moved to sub ci procedure.
+    if [[ $dirpath =~ "/examples/" ]]; then
+        continue 1
+    fi
+
+    # Check if it's a contrib directory
+    if [[ $dirpath =~ "/contrib/" ]]; then
         # Check if go version meets the requirement
         if ! go version | grep -qE "go${LATEST_GO_VERSION}"; then
             echo "ignore path $dirpath as go version is not ${LATEST_GO_VERSION}: $(go version)"
             continue 1
         fi
-        # If it's examples directory, only build without tests
-        if [[ $dirpath =~ "/examples/" ]]; then
-            echo "the examples directory only needs to be built, not unit tests and coverage tests."
-            cd $dirpath
-            go mod tidy
-            go build ./...
-            cd -
-            continue 1
-        fi
     fi
 
     if [[ $file =~ "/testdata/" ]]; then
@@ -47,6 +37,11 @@ for file in `find . -name go.mod`; do
         continue 1
     fi
 
+    if [[ $dirpath = "." ]]; then
+        # No space left on device error sometimes occurs in CI pipelines, so clean the cache before tests.
+        go clean -cache
+    fi
+
     cd $dirpath
     go mod tidy
     go build ./...

.github/workflows/scripts/ci-sub.sh

@@ -2,6 +2,12 @@
 
 coverage=$1
 
+# update code of submodules
+git clone https://github.com/gogf/examples
+
+# update go.mod in examples directory to replace github.com/gogf/gf packages with local directory
+bash .github/workflows/scripts/replace_examples_gomod.sh
+
 # Function to compare version numbers
 version_compare() {
     local ver1=$1
@@ -35,7 +41,19 @@ for file in `find . -name go.mod`; do
     dirpath=$(dirname $file)
     echo "Processing: $dirpath"
 
-    # Only process kubecm directory, skip others
+    # Only process examples and kubecm directories  
+
+    # Process examples directory (only build, no tests)
+    if [[ $dirpath =~ "/examples/" ]]; then
+        echo "  the examples directory only needs to be built, not unit tests."
+        cd $dirpath
+        go mod tidy
+        go build ./...
+        cd -
+        continue 1
+    fi
+    
+    # Process kubecm directory
     if [ "kubecm" != $(basename $dirpath) ]; then
         echo "  Skipping: not kubecm directory"
         continue

.github/workflows/sonarcloud.yaml

@@ -1,53 +0,0 @@
-name: Sonarcloud Scan
-
-on:
-  schedule:
-    # Weekly on Saturdays.
-    - cron: '30 1 * * 6'
-  push:
-    branches: [ master ]
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-
-# Declare default permissions as read only.
-permissions: read
-
-jobs:
-  analysis:
-    name: Scorecards analysis
-    runs-on: ubuntu-latest
-    permissions:
-      # Needed to upload the results to code-scanning dashboard.
-      security-events: write
-      # Used to receive a badge. (Upcoming feature)
-      id-token: write
-      # Needs for private repositories.
-      contents: read
-      actions: read
-
-    steps:
-      - name: "Checkout code"
-        uses: actions/checkout@v5
-        with:
-          persist-credentials: false
-
-      - name: "Run analysis"
-        uses: ossf/scorecard-action@v2.4.0 # v2.4.0
-        with:
-          results_file: results.sarif
-          results_format: sarif
-          publish_results: true
-
-      - name: "Upload artifact"
-        uses: actions/upload-artifact@v4
-        with:
-          name: SARIF file
-          path: results.sarif
-          retention-days: 5
-
-      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@3ebbd71c74ef574dbc558c82f70e52732c8b44fe # v2.2.1
-        with:
-          sarif_file: results.sarif

.make_tidy.sh

@@ -26,6 +26,8 @@ for file in `find ${workdir} -name go.mod`; do
     fi
 
     cd $goModPath
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     sed -i '' '/^toolchain/d' go.mod

.make_version.sh

@@ -80,6 +80,8 @@ for file in `find ${workdir} -name go.mod`; do
         go mod edit -replace github.com/gogf/gf/contrib/drivers/pgsql/v2=../../contrib/drivers/pgsql
         go mod edit -replace github.com/gogf/gf/contrib/drivers/sqlite/v2=../../contrib/drivers/sqlite
     fi
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     $SED_INPLACE '/^toolchain/d' go.mod
@@ -88,6 +90,8 @@ for file in `find ${workdir} -name go.mod`; do
     # it may not be possible to successfully upgrade. Please confirm before submitting the code
     go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf"
     go list -f "{{if and (not .Indirect) (not .Main)}}{{.Path}}@${newVersion}{{end}}" -m all | grep "^github.com/gogf/gf" | xargs -L1 go get -v 
+    # Remove indirect dependencies
+    sed -i '/\/\/ indirect/d' go.mod
     go mod tidy
     # Remove toolchain line if exists
     $SED_INPLACE '/^toolchain/d' go.mod

CONTRIBUTING.md

@@ -3,11 +3,13 @@
 Thanks for taking the time to join our community and start contributing!
 
 ## With issues
+
 - Use the search tool before opening a new issue.
 - Please provide source code and commit sha if you found a bug.
 - Review existing issues and provide feedback or react to them.
 
 ## With pull requests
+
 - Open your pull request against `master`
 - Your pull request should have no more than two commits, if not you should squash them.
 - It should pass all tests in the available continuous integrations systems such as GitHub CI.

Makefile

@@ -10,6 +10,24 @@ tidy:
 lint:
 	golangci-lint run -c .golangci.yml
 
+# make branch to=v2.4.0
+.PHONY: branch
+branch:
+	@set -e; \
+	newVersion=$(to); \
+	if [ -z "$$newVersion" ]; then \
+		echo "Error: 'to' variable is required. Usage: make branch to=vX.Y.Z"; \
+		exit 1; \
+	fi; \
+	branchName=fix/$$newVersion; \
+	echo "Switching to master branch..."; \
+	git checkout master; \
+	echo "Pulling latest changes from master..."; \
+	git pull origin master; \
+	echo "Creating and switching to branch $$branchName from master..."; \
+	git checkout -b $$branchName; \
+	echo "Branch $$branchName created successfully!"
+
 # make version to=v2.4.0
 .PHONY: version
 version:
@@ -18,6 +36,20 @@ version:
 	./.make_version.sh ./ $$newVersion; \
 	echo "make version to=$(to) done"
 
+# make tag to=v2.4.0
+.PHONY: tag
+tag:
+	@set -e; \
+	newVersion=$(to); \
+	echo "Switching to master branch..."; \
+	git checkout master; \
+	echo "Pulling latest changes from master..."; \
+	git pull origin master; \
+	echo "Creating annotated tag $$newVersion..."; \
+	git tag -a $$newVersion -m "Release $$newVersion"; \
+	echo "Pushing tag $$newVersion..."; \
+	git push origin $$newVersion; \
+	echo "Tag $$newVersion created and pushed successfully!"
 
 # update submodules
 .PHONY: subup

README.MD

@@ -23,24 +23,23 @@
 
 A powerful framework for faster, easier, and more efficient project development.
 
+## Documentation
 
-# Documentation
-
-- GoFrame Official Site: [https://goframe.org](https://goframe.org)
-- GoFrame Official Site(en): [https://goframe.org/en](https://goframe.org/en)
-- GoFrame Mirror Site(中文): [https://goframe.org.cn](https://goframe.org.cn)
-- GoFrame Mirror Site(github pages): [https://pages.goframe.org](https://pages.goframe.org)
+- Official Site: [https://goframe.org](https://goframe.org)
+- Official Site(en): [https://goframe.org/en](https://goframe.org/en)
+- 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
+- Mirror Site: [Github Pages](https://pages.goframe.org)
+- Mirror Site: [Offline Docs](https://github.com/gogf/goframe.org-pdf?tab=readme-ov-file#%E6%9C%80%E6%96%B0%E7%89%88%E6%9C%AC)
 - GoDoc API: [https://pkg.go.dev/github.com/gogf/gf/v2](https://pkg.go.dev/github.com/gogf/gf/v2)
 
-
-# Contributors
+## Contributors
 
 💖 [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.3" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.9.5" alt="goframe contributors"/>
 </a>
 
-# License
+## License
 
 `GoFrame` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.

cmd/gf/go.mod

@@ -3,18 +3,18 @@ module github.com/gogf/gf/cmd/gf/v2
 go 1.23.0
 
 require (
-	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.3
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.3
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.5
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.5
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.5
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.5
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.5
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.5
+	github.com/gogf/gf/v2 v2.9.5
 	github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
-	github.com/olekukonko/tablewriter v1.0.9
+	github.com/olekukonko/tablewriter v1.1.0
 	github.com/schollz/progressbar/v3 v3.15.0
-	golang.org/x/mod v0.26.0
-	golang.org/x/tools v0.35.0
+	golang.org/x/mod v0.25.0
+	golang.org/x/tools v0.26.0
 )
 
 require (
@@ -37,7 +37,7 @@ require (
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/lib/pq v1.10.9 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/microsoft/go-mssqldb v1.7.1 // indirect
@@ -51,16 +51,16 @@ require (
 	github.com/shopspring/decimal v1.3.1 // indirect
 	github.com/sijms/go-ora/v2 v2.7.10 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/crypto v0.41.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
-	golang.org/x/sync v0.16.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/crypto v0.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/term v0.34.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/term v0.32.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 	modernc.org/libc v1.22.5 // indirect
 	modernc.org/mathutil v1.5.0 // indirect

cmd/gf/go.sum

@@ -46,6 +46,20 @@ github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiU
 github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-sql-driver/mysql v1.7.1 h1:lUIinVbN1DY0xBg0eMOzmmtGoHwWBbvnWubQUrtU8EI=
 github.com/go-sql-driver/mysql v1.7.1/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.5 h1:WTbuQvbtOSddi2GtiobM/FCRUr5god7yzlEQP7WGOM8=
+github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.5/go.mod h1:/lnvHd9+8VmjDLdgIczzRTJA1tZYY5AA8bdcaexi/ao=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.5 h1:hgkgzbi6j8tDf+UpjG01fLqnAchD3913RZ37ruY9TqE=
+github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.5/go.mod h1:Sy0DQNJ/xEL4snJyWqcflmYGr2jE8Tn9mynxqbe2Dds=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.5 h1:0+ZBYhi4sqwxXwL+hIBpp06a7G4m5nmjskQ3NNb8qYc=
+github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.5/go.mod h1:vyB7J/uJcLCrHD5lfFBzxhEEMkePIRzfhd33EcsuLa0=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.5 h1:eCPD7oteF/gurCU5ZfAhFBU7E1vI85cnoHKRdckn9Vc=
+github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.5/go.mod h1:e5sxdxw3OrAFB+4VdYt3Wbm0G7LP5wofNRKj3JHIots=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.5 h1:FCgvTLBuhPX7HE6YyR/dbNASoiKv72jpVS5SqoYYJTw=
+github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.5/go.mod h1:/Lz1qzhYN3ogt5aMFoIfjp82SbeuzjpXCqQhFu4Z3MI=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.5 h1:MooWqn5qLMfB105PlBvd2Z7J3KdVBsjYxULtb42u308=
+github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.5/go.mod h1:pr68Q85xhRnJ5PhyGte/LiFJ/m+998RPjW+Jn+w+xYo=
+github.com/gogf/gf/v2 v2.9.5 h1:1scfOdHbMP854oQaiLejl+eL+c4xfuvtWmmZiDJxbKs=
+github.com/gogf/gf/v2 v2.9.5/go.mod h1:VUb5eyJKpvW77O/dXsbbLNO/Kjrg0UycIiq0lRiBjjo=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f h1:7xfXR/BhG3JDqO1s45n65Oyx9t4E/UqDOXep6jXdLCM=
 github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f/go.mod h1:HnYoio6S7VaFJdryKcD/r9HgX+4QzYfr00XiXUo/xz0=
 github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
@@ -86,8 +100,9 @@ github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -102,8 +117,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/paulmach/orb v0.7.1 h1:Zha++Z5OX/l168sqHK3k4z18LDvr+YAO/VjK0ReQ9rU=
 github.com/paulmach/orb v0.7.1/go.mod h1:FWRlTgl88VI1RBx/MkrwWDRhQ96ctqMCh8boXhmqB/A=
 github.com/paulmach/protoscan v0.2.1/go.mod h1:SpcSwydNLrxUGSDvXvO0P7g7AuhJ7lcKfDlhJCDw2gY=
@@ -120,8 +135,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/schollz/progressbar/v3 v3.15.0 h1:cNZmcNiVyea6oofBTg80ZhVXxf3wG/JoAhqCCwopkQo=
 github.com/schollz/progressbar/v3 v3.15.0/go.mod h1:ncBdc++eweU0dQoeZJ3loXoAc+bjaallHRIm8pVVeQM=
 github.com/shirou/gopsutil v2.19.11+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
@@ -136,8 +151,8 @@ github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UV
 github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
 github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.2/go.mod h1:R6va5+xMeoiuVRoj+gSkQ7d3FALtqAAGI1FQKckRals=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/tklauser/go-sysconf v0.3.10/go.mod h1:C8XykCvCb+Gn0oNCWPIlcb0RuglQTYaQ2hGm7jmxEFk=
 github.com/tklauser/numcpus v0.4.0/go.mod h1:1+UI3pD8NW14VMwdgJNJ1ESk2UnwhAnz5hMwiKKqXCQ=
 github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
@@ -146,38 +161,40 @@ github.com/yusufpapurcu/wmi v1.2.2/go.mod h1:SBZ9tNy3G9/m5Oi98Zks0QjeHVDvuK0qfxQ
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
 go.opentelemetry.io/otel v1.7.0/go.mod h1:5BdUoMIz5WEs0vt0CUEMtSSaTSHBBVwrhnz7+nrD5xk=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
 go.opentelemetry.io/otel/trace v1.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I=
-golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4=
-golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
 golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
 golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.26.0 h1:EGMPT//Ezu+ylkCijjPc+f4Aih7sZvaAr+O3EHBxvZg=
-golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ=
+golang.org/x/mod v0.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
+golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
-golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
@@ -187,24 +204,25 @@ golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210228012217-479acdf4ea46/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20220128215802-99c3d69c2c27/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220429233432-b5fbb4746d32/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.25.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw=
 golang.org/x/term v0.24.0/go.mod h1:lOBK/LVxemqiMij05LGJ0tzNr8xlmwBRJ81PX6wVLH8=
-golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4=
-golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw=
+golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
+golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
 golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/tools v0.35.0 h1:mBffYraMEf7aa0sB+NuKnuCy8qI/9Bughn8dC2Gu5r0=
-golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw=
+golang.org/x/tools v0.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=
+golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

cmd/gf/internal/cmd/cmd_build.go

@@ -30,12 +30,10 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
-var (
-	Build = cBuild{
-		nodeNameInConfigFile: "gfcli.build",
-		packedGoFileName:     "internal/packed/build_pack_data.go",
-	}
-)
+var Build = cBuild{
+	nodeNameInConfigFile: "gfcli.build",
+	packedGoFileName:     "internal/packed/build_pack_data.go",
+}
 
 type cBuild struct {
 	g.Meta               `name:"build" brief:"{cBuildBrief}" dc:"{cBuildDc}" eg:"{cBuildEg}" ad:"{cBuildAd}"`
@@ -65,45 +63,67 @@ It provides much more features for building binary:
 `
 	cBuildAd = `
 PLATFORMS
+    aix       ppc64
+    android   386,amd64,arm,arm64
     darwin    amd64,arm64
+    dragonfly amd64
     freebsd   386,amd64,arm
-    linux     386,amd64,arm,arm64,ppc64,ppc64le,mips,mipsle,mips64,mips64le
+    illumos   amd64
+    ios       arm64
+    js        wasm
+    linux     386,amd64,arm,arm64,loong64,mips,mipsle,mips64,mips64le,ppc64,ppc64le,riscv64,s390x
     netbsd    386,amd64,arm
-    openbsd   386,amd64,arm
-    windows   386,amd64
+    openbsd   386,amd64,arm,arm64
+    plan9     386,amd64,arm
+    solaris   amd64
+    wasip1    wasm
+    windows   386,amd64,arm,arm64
 `
 	// https://golang.google.cn/doc/install/source
 	cBuildPlatforms = `
+aix       ppc64
+android   386
+android   amd64
+android   arm
+android   arm64
 darwin    amd64
 darwin    arm64
-ios       amd64
-ios       arm64
+dragonfly amd64
 freebsd   386
 freebsd   amd64
 freebsd   arm
+illumos   amd64
+ios       arm64
+js        wasm
 linux     386
 linux     amd64
 linux     arm
 linux     arm64
-linux     ppc64
-linux     ppc64le
+linux     loong64
 linux     mips
 linux     mipsle
 linux     mips64
 linux     mips64le
+linux     ppc64
+linux     ppc64le
+linux     riscv64
+linux     s390x
 netbsd    386
 netbsd    amd64
 netbsd    arm
 openbsd   386
 openbsd   amd64
 openbsd   arm
-windows   386
-windows   amd64
-android   arm
-dragonfly amd64
+openbsd   arm64
 plan9     386
 plan9     amd64
+plan9     arm
 solaris   amd64
+wasip1    wasm
+windows   386
+windows   amd64
+windows   arm
+windows   arm64
 `
 )
 

cmd/gf/internal/cmd/cmd_run.go

@@ -13,6 +13,7 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
+	"time"
 
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/frame/g"
@@ -26,9 +27,7 @@ import (
 	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
-var (
-	Run = cRun{}
-)
+var Run = cRun{}
 
 type cRun struct {
 	g.Meta `name:"run" usage:"{cRunUsage}" brief:"{cRunBrief}" eg:"{cRunEg}" dc:"{cRunDc}"`
@@ -62,9 +61,7 @@ which compiles and runs the go codes asynchronously when codes change.
 	cRunWatchPathsBrief = `watch additional paths for live reload, separated by ",". i.e. "manifest/config/*.yaml"`
 )
 
-var (
-	process *gproc.Process
-)
+var process *gproc.Process
 
 func init() {
 	gtag.Sets(g.MapStrStr{
@@ -118,8 +115,12 @@ func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err err
 	}
 	dirty := gtype.NewBool()
 
-	var outputPath = app.genOutputPath()
+	outputPath := app.genOutputPath()
 	callbackFunc := func(event *gfsnotify.Event) {
+		if !event.IsWrite() && !event.IsCreate() && !event.IsRemove() && !event.IsRename() {
+			return
+		}
+
 		if gfile.ExtName(event.Path) != "go" {
 			return
 		}
@@ -207,8 +208,37 @@ func (app *cRunApp) End(ctx context.Context, sig os.Signal, outputPath string) {
 	// Delete the binary file.
 	// firstly, kill the process.
 	if process != nil {
-		if err := process.Kill(); err != nil {
-			mlog.Debugf("kill process error: %s", err.Error())
+		if sig != nil && runtime.GOOS != "windows" {
+			if err := process.Signal(sig); err != nil {
+				mlog.Debugf("send signal to process error: %s", err.Error())
+				if err := process.Kill(); err != nil {
+					mlog.Debugf("kill process error: %s", err.Error())
+				}
+			} else {
+				waitCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
+				defer cancel()
+				done := make(chan error, 1)
+				go func() {
+					select {
+					case <-waitCtx.Done():
+						done <- waitCtx.Err()
+					case done <- process.Wait():
+					}
+				}()
+				err := <-done
+				if err != nil {
+					mlog.Debugf("process wait error: %s", err.Error())
+					if err := process.Kill(); err != nil {
+						mlog.Debugf("kill process error: %s", err.Error())
+					}
+				} else {
+					mlog.Debug("process exited gracefully")
+				}
+			}
+		} else {
+			if err := process.Kill(); err != nil {
+				mlog.Debugf("kill process error: %s", err.Error())
+			}
 		}
 	}
 	if err := gfile.RemoveFile(outputPath); err != nil {

cmd/gf/internal/cmd/cmd_up.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/os/genv"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gproc"
 	"github.com/gogf/gf/v2/text/gstr"
@@ -39,7 +40,11 @@ gf up
 gf up -a
 gf up -c
 gf up -cf
+gf up -a -m=install
+gf up -a -m=install -p=github.com/gogf/gf/cmd/gf/v2@latest
 `
+	cliMethodHttpDownload = "http"
+	cliMethodGoInstall    = "install"
 )
 
 func init() {
@@ -49,10 +54,14 @@ func init() {
 }
 
 type cUpInput struct {
-	g.Meta `name:"up" config:"gfcli.up"`
-	All    bool `name:"all" short:"a" brief:"upgrade both version and cli, auto fix codes" orphan:"true"`
-	Cli    bool `name:"cli" short:"c" brief:"also upgrade CLI tool" orphan:"true"`
-	Fix    bool `name:"fix" short:"f" brief:"auto fix codes(it only make sense if cli is to be upgraded)" orphan:"true"`
+	g.Meta               `name:"up" config:"gfcli.up"`
+	All                  bool   `name:"all" short:"a" brief:"upgrade both version and cli, auto fix codes" orphan:"true"`
+	Cli                  bool   `name:"cli" short:"c" brief:"also upgrade CLI tool" orphan:"true"`
+	Fix                  bool   `name:"fix" short:"f" brief:"auto fix codes(it only make sense if cli is to be upgraded)" orphan:"true"`
+	CliDownloadingMethod string `name:"cli-download-method" short:"m" brief:"cli upgrade method: http=download binary via HTTP GET, install=upgrade via go install" d:"http"`
+	// CliModulePath specifies the module path for CLI installation via go install.
+	// This is used when CliDownloadingMethod is set to "install".
+	CliModulePath string `name:"cli-module-path" short:"p" brief:"custom cli module path for upgrade CLI tool with go install method" d:"github.com/gogf/gf/cmd/gf/v2@latest"`
 }
 
 type cUpOutput struct{}
@@ -76,7 +85,7 @@ func (c cUp) Index(ctx context.Context, in cUpInput) (out *cUpOutput, err error)
 	}
 
 	if in.Cli {
-		if err = c.doUpgradeCLI(ctx); err != nil {
+		if err = c.doUpgradeCLI(ctx, in); err != nil {
 			return nil, err
 		}
 	}
@@ -170,8 +179,22 @@ func (c cUp) doUpgradeVersion(ctx context.Context, in cUpInput) (out *doUpgradeV
 }
 
 // doUpgradeCLI downloads the new version binary with process.
-func (c cUp) doUpgradeCLI(ctx context.Context) (err error) {
+func (c cUp) doUpgradeCLI(ctx context.Context, in cUpInput) (err error) {
 	mlog.Print(`start upgrading cli...`)
+	fmt.Println(` cli upgrade method:`, in.CliDownloadingMethod)
+	switch in.CliDownloadingMethod {
+	case cliMethodHttpDownload:
+		return c.doUpgradeCLIWithHttpDownload(ctx)
+	case cliMethodGoInstall:
+		return c.doUpgradeCLIWithGoInstall(ctx, in)
+	default:
+		mlog.Fatalf(`invalid cli upgrade method: "%s", please use "http" or "install"`, in.CliDownloadingMethod)
+	}
+	return
+}
+
+func (c cUp) doUpgradeCLIWithHttpDownload(ctx context.Context) (err error) {
+	mlog.Print(`start upgrading cli with http get download...`)
 	var (
 		downloadUrl = fmt.Sprintf(
 			`https://github.com/gogf/gf/releases/latest/download/gf_%s_%s`,
@@ -213,6 +236,41 @@ func (c cUp) doUpgradeCLI(ctx context.Context) (err error) {
 	return
 }
 
+func (c cUp) doUpgradeCLIWithGoInstall(ctx context.Context, in cUpInput) (err error) {
+	mlog.Print(`upgrading cli with go install...`)
+	if !genv.Contains("GOPATH") {
+		mlog.Fatal(`"GOPATH" environment variable does not exist, please check your go installation`)
+	}
+
+	command := fmt.Sprintf(`go install %s`, in.CliModulePath)
+	mlog.Printf(`running command: %s`, command)
+	err = gproc.ShellRun(ctx, command)
+	if err != nil {
+		return err
+	}
+
+	cliFilePath := gfile.Join(genv.Get("GOPATH").String(), "bin/gf")
+	if runtime.GOOS == "windows" {
+		cliFilePath += ".exe"
+	}
+
+	// It fails if file not exist or its size is less than 1MB.
+	if !gfile.Exists(cliFilePath) || gfile.Size(cliFilePath) < 1024*1024 {
+		mlog.Fatalf(`go install %s failed, "%s" does not exist or its size is less than 1MB`, in.CliModulePath, cliFilePath)
+	}
+
+	newFile, err := gfile.Open(cliFilePath)
+	if err != nil {
+		return err
+	}
+	// selfupdate
+	err = selfupdate.Apply(newFile, selfupdate.Options{})
+	if err != nil {
+		return err
+	}
+	return
+}
+
 func (c cUp) doAutoFixing(ctx context.Context, dirPath string, version string) (err error) {
 	mlog.Printf(`auto fixing directory path "%s" from version "%s" ...`, dirPath, version)
 	command := fmt.Sprintf(`gf fix -p %s`, dirPath)

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go

@@ -66,6 +66,7 @@ func Test_Gen_Dao_Issue2572(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -155,6 +156,7 @@ func Test_Gen_Dao_Issue2616(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -266,6 +268,7 @@ func Test_Gen_Dao_Issue2746(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -338,6 +341,7 @@ func Test_Gen_Dao_Issue3459(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 			}
 		)

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go

@@ -69,6 +69,7 @@ func Test_Gen_Dao_Default(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -161,6 +162,7 @@ func Test_Gen_Dao_TypeMapping(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping: map[gendao.DBFieldTypeName]gendao.CustomAttributeType{
 					"int": {
 						Type:   "int64",
@@ -263,6 +265,7 @@ func Test_Gen_Dao_FieldMapping(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
+				GenTable:           false,
 				TypeMapping: map[gendao.DBFieldTypeName]gendao.CustomAttributeType{
 					"int": {
 						Type:   "int64",

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

@@ -47,8 +47,10 @@ type (
 		JsonCase           string   `name:"jsonCase"            short:"j"  brief:"{CGenDaoBriefJsonCase}" d:"CamelLower"`
 		ImportPrefix       string   `name:"importPrefix"        short:"i"  brief:"{CGenDaoBriefImportPrefix}"`
 		DaoPath            string   `name:"daoPath"             short:"d"  brief:"{CGenDaoBriefDaoPath}" d:"dao"`
+		TablePath          string   `name:"tablePath"           short:"tp" brief:"{CGenDaoBriefTablePath}" d:"table"`
 		DoPath             string   `name:"doPath"              short:"o"  brief:"{CGenDaoBriefDoPath}" d:"model/do"`
 		EntityPath         string   `name:"entityPath"          short:"e"  brief:"{CGenDaoBriefEntityPath}" d:"model/entity"`
+		TplDaoTablePath    string   `name:"tplDaoTablePath"     short:"t0" brief:"{CGenDaoBriefTplDaoTablePath}"`
 		TplDaoIndexPath    string   `name:"tplDaoIndexPath"     short:"t1" brief:"{CGenDaoBriefTplDaoIndexPath}"`
 		TplDaoInternalPath string   `name:"tplDaoInternalPath"  short:"t2" brief:"{CGenDaoBriefTplDaoInternalPath}"`
 		TplDaoDoPath       string   `name:"tplDaoDoPath"        short:"t3" brief:"{CGenDaoBriefTplDaoDoPathPath}"`
@@ -61,6 +63,7 @@ type (
 		NoJsonTag          bool     `name:"noJsonTag"           short:"k"  brief:"{CGenDaoBriefNoJsonTag}" orphan:"true"`
 		NoModelComment     bool     `name:"noModelComment"      short:"m"  brief:"{CGenDaoBriefNoModelComment}" orphan:"true"`
 		Clear              bool     `name:"clear"               short:"a"  brief:"{CGenDaoBriefClear}" orphan:"true"`
+		GenTable           bool     `name:"genTable"            short:"gt" brief:"{CGenDaoBriefGenTable}" orphan:"true"`
 
 		TypeMapping  map[DBFieldTypeName]CustomAttributeType  `name:"typeMapping"  short:"y"  brief:"{CGenDaoBriefTypeMapping}"  orphan:"true"`
 		FieldMapping map[DBTableFieldName]CustomAttributeType `name:"fieldMapping" short:"fm" brief:"{CGenDaoBriefFieldMapping}" orphan:"true"`
@@ -190,8 +193,29 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 	// Table excluding.
 	if in.TablesEx != "" {
 		array := garray.NewStrArrayFrom(tableNames)
-		for _, v := range gstr.SplitAndTrim(in.TablesEx, ",") {
-			array.RemoveValue(v)
+		for _, p := range gstr.SplitAndTrim(in.TablesEx, ",") {
+			if gstr.Contains(p, "*") || gstr.Contains(p, "?") {
+				p = gstr.ReplaceByMap(p, map[string]string{
+					"\r": "",
+					"\n": "",
+				})
+				p = gstr.ReplaceByMap(p, map[string]string{
+					"*": "\r",
+					"?": "\n",
+				})
+				p = gregex.Quote(p)
+				p = gstr.ReplaceByMap(p, map[string]string{
+					"\r": ".*",
+					"\n": ".",
+				})
+				for _, v := range array.Clone().Slice() {
+					if gregex.IsMatchString(p, v) {
+						array.RemoveValue(v)
+					}
+				}
+			} else {
+				array.RemoveValue(p)
+			}
 		}
 		tableNames = array.Slice()
 	}
@@ -258,6 +282,14 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 		NewTableNames:    newTableNames,
 		ShardingTableSet: shardingNewTableSet,
 	})
+	// Table: table fields.
+	generateTable(ctx, CGenDaoInternalInput{
+		CGenDaoInput:     in,
+		DB:               db,
+		TableNames:       tableNames,
+		NewTableNames:    newTableNames,
+		ShardingTableSet: shardingNewTableSet,
+	})
 	// Do.
 	generateDo(ctx, CGenDaoInternalInput{
 		CGenDaoInput:  in,

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

@@ -0,0 +1,147 @@
+// Copyright GoFrame gf 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 gendao
+
+import (
+	"bytes"
+	"context"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gfile"
+	"github.com/gogf/gf/v2/os/gview"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
+)
+
+// generateTable generates dao files for given tables.
+func generateTable(ctx context.Context, in CGenDaoInternalInput) {
+	dirPathTable := gfile.Join(in.Path, in.TablePath)
+	if !in.GenTable {
+		if gfile.Exists(dirPathTable) {
+			in.genItems.AppendDirPath(dirPathTable)
+		}
+		return
+	}
+	in.genItems.AppendDirPath(dirPathTable)
+	for i := 0; i < len(in.TableNames); i++ {
+		var (
+			realTableName = in.TableNames[i]
+			newTableName  = in.NewTableNames[i]
+		)
+		generateTableSingle(ctx, generateTableSingleInput{
+			CGenDaoInternalInput: in,
+			TableName:            realTableName,
+			NewTableName:         newTableName,
+			DirPathTable:         dirPathTable,
+		})
+	}
+}
+
+// generateTableSingleInput is the input parameter for generateTableSingle.
+type generateTableSingleInput struct {
+	CGenDaoInternalInput
+	// TableName specifies the table name of the table.
+	TableName string
+	// NewTableName specifies the prefix-stripped or custom edited name of the table.
+	NewTableName string
+	DirPathTable string
+}
+
+// generateTableSingle generates dao files for a single table.
+func generateTableSingle(ctx context.Context, in generateTableSingleInput) {
+	// Generating table data preparing.
+	fieldMap, err := in.DB.TableFields(ctx, in.TableName)
+	if err != nil {
+		mlog.Fatalf(`fetching tables fields failed for table "%s": %+v`, in.TableName, err)
+	}
+
+	tableNameSnakeCase := gstr.CaseSnake(in.NewTableName)
+	fileName := gstr.Trim(tableNameSnakeCase, "-_.")
+	if len(fileName) > 5 && fileName[len(fileName)-5:] == "_test" {
+		// Add suffix to avoid the table name which contains "_test",
+		// which would make the go file a testing file.
+		fileName += "_table"
+	}
+	path := filepath.FromSlash(gfile.Join(in.DirPathTable, fileName+".go"))
+	in.genItems.AppendGeneratedFilePath(path)
+	if in.OverwriteDao || !gfile.Exists(path) {
+		var (
+			ctx        = context.Background()
+			tplContent = getTemplateFromPathOrDefault(
+				in.TplDaoTablePath, consts.TemplateGenTableContent,
+			)
+		)
+		tplView.ClearAssigns()
+		tplView.Assigns(gview.Params{
+			tplVarGroupName:          in.Group,
+			tplVarTableName:          in.TableName,
+			tplVarTableNameCamelCase: formatFieldName(in.NewTableName, FieldNameCaseCamel),
+			tplVarPackageName:        filepath.Base(in.TablePath),
+			tplVarTableFields:        generateTableFields(fieldMap),
+		})
+		indexContent, err := tplView.ParseContent(ctx, tplContent)
+		if err != nil {
+			mlog.Fatalf("parsing template content failed: %v", err)
+		}
+		if err = gfile.PutContents(path, strings.TrimSpace(indexContent)); err != nil {
+			mlog.Fatalf("writing content to '%s' failed: %v", path, err)
+		} else {
+			utils.GoFmt(path)
+			mlog.Print("generated:", gfile.RealPath(path))
+		}
+	}
+}
+
+// generateTableFields generates and returns the field definition content for specified table.
+func generateTableFields(fields map[string]*gdb.TableField) string {
+	var buf bytes.Buffer
+	fieldNames := make([]string, 0, len(fields))
+	for fieldName := range fields {
+		fieldNames = append(fieldNames, fieldName)
+	}
+	sort.Slice(fieldNames, func(i, j int) bool {
+		return fields[fieldNames[i]].Index < fields[fieldNames[j]].Index // asc
+	})
+	for index, fieldName := range fieldNames {
+		field := fields[fieldName]
+		buf.WriteString("    " + strconv.Quote(field.Name) + ": {\n")
+		buf.WriteString("        Index:   " + gconv.String(field.Index) + ",\n")
+		buf.WriteString("        Name:    " + strconv.Quote(field.Name) + ",\n")
+		buf.WriteString("        Type:    " + strconv.Quote(field.Type) + ",\n")
+		buf.WriteString("        Null:    " + gconv.String(field.Null) + ",\n")
+		buf.WriteString("        Key:     " + strconv.Quote(field.Key) + ",\n")
+		buf.WriteString("        Default: " + generateDefaultValue(field.Default) + ",\n")
+		buf.WriteString("        Extra:   " + strconv.Quote(field.Extra) + ",\n")
+		buf.WriteString("        Comment: " + strconv.Quote(field.Comment) + ",\n")
+		buf.WriteString("    },")
+		if index != len(fieldNames)-1 {
+			buf.WriteString("\n")
+		}
+	}
+	return buf.String()
+}
+
+// generateDefaultValue generates and returns the default value definition for specified field.
+func generateDefaultValue(value interface{}) string {
+	if value == nil {
+		return "nil"
+	}
+	switch v := value.(type) {
+	case string:
+		return strconv.Quote(v)
+	default:
+		return gconv.String(v)
+	}
+}

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

@@ -60,6 +60,7 @@ CONFIGURATION SUPPORT
 	CGenDaoBriefGJsonSupport      = `use gJsonSupport to use *gjson.Json instead of string for generated json fields of tables`
 	CGenDaoBriefImportPrefix      = `custom import prefix for generated go files`
 	CGenDaoBriefDaoPath           = `directory path for storing generated dao files under path`
+	CGenDaoBriefTablePath         = `directory path for storing generated table files under path`
 	CGenDaoBriefDoPath            = `directory path for storing generated do files under path`
 	CGenDaoBriefEntityPath        = `directory path for storing generated entity files under path`
 	CGenDaoBriefOverwriteDao      = `overwrite all dao files both inside/outside internal folder`
@@ -69,6 +70,7 @@ CONFIGURATION SUPPORT
 	CGenDaoBriefNoJsonTag         = `no json tag will be added for each field`
 	CGenDaoBriefNoModelComment    = `no model comment will be added for each field`
 	CGenDaoBriefClear             = `delete all generated go files that do not exist in database`
+	CGenDaoBriefGenTable          = `generate table files`
 	CGenDaoBriefTypeMapping       = `custom local type mapping for generated struct attributes relevant to fields of table`
 	CGenDaoBriefFieldMapping      = `custom local type mapping for generated struct attributes relevant to specific fields of table`
 	CGenDaoBriefShardingPattern   = `sharding pattern for table name, e.g. "users_?" will be replace tables "users_001,users_002,..." to "users" dao`
@@ -98,6 +100,7 @@ generated json tag case for model struct, cases are as follows:
 	tplVarTableNameCamelLowerCase = `TplTableNameCamelLowerCase`
 	tplVarTableSharding           = `TplTableSharding`
 	tplVarTableShardingPrefix     = `TplTableShardingPrefix`
+	tplVarTableFields             = `TplTableFields`
 	tplVarPackageImports          = `TplPackageImports`
 	tplVarImportPrefix            = `TplImportPrefix`
 	tplVarStructDefine            = `TplStructDefine`
@@ -126,6 +129,7 @@ func init() {
 		`CGenDaoBriefStdTime`:            CGenDaoBriefStdTime,
 		`CGenDaoBriefWithTime`:           CGenDaoBriefWithTime,
 		`CGenDaoBriefDaoPath`:            CGenDaoBriefDaoPath,
+		`CGenDaoBriefTablePath`:          CGenDaoBriefTablePath,
 		`CGenDaoBriefDoPath`:             CGenDaoBriefDoPath,
 		`CGenDaoBriefEntityPath`:         CGenDaoBriefEntityPath,
 		`CGenDaoBriefGJsonSupport`:       CGenDaoBriefGJsonSupport,
@@ -137,6 +141,7 @@ func init() {
 		`CGenDaoBriefNoJsonTag`:          CGenDaoBriefNoJsonTag,
 		`CGenDaoBriefNoModelComment`:     CGenDaoBriefNoModelComment,
 		`CGenDaoBriefClear`:              CGenDaoBriefClear,
+		`CGenDaoBriefGenTable`:           CGenDaoBriefGenTable,
 		`CGenDaoBriefTypeMapping`:        CGenDaoBriefTypeMapping,
 		`CGenDaoBriefFieldMapping`:       CGenDaoBriefFieldMapping,
 		`CGenDaoBriefShardingPattern`:    CGenDaoBriefShardingPattern,

cmd/gf/internal/cmd/testdata/build/varmap/go.mod

@@ -4,11 +4,11 @@ go 1.23.0
 
 toolchain go1.24.6
 
-require github.com/gogf/gf/v2 v2.9.3-rc4
+require github.com/gogf/gf/v2 v2.9.5
 
 require (
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
 	golang.org/x/text v0.28.0 // indirect
 )
 

cmd/gf/internal/cmd/testdata/build/varmap/go.sum

@@ -24,8 +24,8 @@ github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtg
 github.com/grokify/html-strip-tags-go v0.1.0/go.mod h1:ZdzgfHEzAfz9X6Xe5eBLVblWIxXfYSQ40S/VKrAOGpc=
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -34,26 +34,26 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
 golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=

cmd/gf/internal/consts/consts_gen_dao_template_table.go

@@ -0,0 +1,35 @@
+// Copyright GoFrame gf 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 consts
+
+const TemplateGenTableContent = `
+// =================================================================================
+// This file is auto-generated by the GoFrame CLI tool. You may modify it as needed.
+// =================================================================================
+
+package {{.TplPackageName}}
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/database/gdb"
+)
+
+// {{.TplTableNameCamelCase}} defines the fields of table "{{.TplTableName}}" with their properties.
+// This map is used internally by GoFrame ORM to understand table structure.
+var {{.TplTableNameCamelCase}} = map[string]*gdb.TableField{
+{{.TplTableFields}}
+}
+
+// Set{{.TplTableNameCamelCase}}TableFields registers the table fields definition to the database instance.
+// db: database instance that implements gdb.DB interface.
+// schema: optional schema/namespace name, especially for databases that support schemas.
+func Set{{.TplTableNameCamelCase}}TableFields(ctx context.Context, db gdb.DB, schema ...string) error {
+	return db.GetCore().SetTableFields(ctx, "{{.TplTableName}}", {{.TplTableNameCamelCase}}, schema...)
+}
+
+`

container/garray/garray_func.go

@@ -6,7 +6,10 @@
 
 package garray
 
-import "strings"
+import (
+	"sort"
+	"strings"
+)
 
 // defaultComparatorInt for int comparison.
 func defaultComparatorInt(a, b int) int {
@@ -24,6 +27,14 @@ func defaultComparatorStr(a, b string) int {
 	return strings.Compare(a, b)
 }
 
+// defaultSorter is a generic sorting function that sorts a slice of comparable types
+// using the provided comparator function.
+func defaultSorter[T comparable](values []T, comparator func(a T, b T) int) {
+	sort.Slice(values, func(i, j int) bool {
+		return comparator(values[i], values[j]) < 0
+	})
+}
+
 // quickSortInt is the quick-sorting algorithm implements for int.
 func quickSortInt(values []int, comparator func(a, b int) int) {
 	if len(values) <= 1 {
@@ -67,3 +78,51 @@ func quickSortStr(values []string, comparator func(a, b string) int) {
 	quickSortStr(values[:head], comparator)
 	quickSortStr(values[head+1:], comparator)
 }
+
+// tToAnySlice converts []T to []any
+func tToAnySlice[T any](values []T) []any {
+	if values == nil {
+		return nil
+	}
+	anyValues := make([]any, len(values), cap(values))
+	for k, v := range values {
+		anyValues[k] = v
+	}
+	return anyValues
+}
+
+// anyToTSlice is convert []any to []T
+func anyToTSlice[T any](values []any) []T {
+	if values == nil {
+		return nil
+	}
+	tValues := make([]T, len(values), cap(values))
+	for k, v := range values {
+		tValues[k], _ = v.(T)
+	}
+	return tValues
+}
+
+// tToAnySlices converts [][]T to [][]any
+func tToAnySlices[T any](values [][]T) [][]any {
+	if values == nil {
+		return nil
+	}
+	anyValues := make([][]any, len(values), cap(values))
+	for k, v := range values {
+		anyValues[k] = tToAnySlice(v)
+	}
+	return anyValues
+}
+
+// anyToTSlices converts [][]any to [][]T
+func anyToTSlices[T any](values [][]any) [][]T {
+	if values == nil {
+		return nil
+	}
+	tValues := make([][]T, len(values), cap(values))
+	for k, v := range values {
+		tValues[k] = anyToTSlice[T](v)
+	}
+	return tValues
+}

container/garray/garray_normal_any.go

@@ -7,28 +7,18 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
-	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // Array is a golang array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type Array struct {
-	mu    rwmutex.RWMutex
-	array []any
+	*TArray[any]
+	once sync.Once
 }
 
 // New creates and returns an empty array.
@@ -48,8 +38,7 @@ func NewArray(safe ...bool) *Array {
 // which is false in default.
 func NewArraySize(size int, cap int, safe ...bool) *Array {
 	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: make([]any, size, cap),
+		TArray: NewTArraySize[any](size, cap, safe...),
 	}
 }
 
@@ -85,8 +74,7 @@ func NewFromCopy(array []any, safe ...bool) *Array {
 // which is false in default.
 func NewArrayFrom(array []any, safe ...bool) *Array {
 	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -96,265 +84,149 @@ func NewArrayFrom(array []any, safe ...bool) *Array {
 func NewArrayFromCopy(array []any, safe ...bool) *Array {
 	newArray := make([]any, len(array))
 	copy(newArray, array)
-	return &Array{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *Array) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[any](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `nil`.
 func (a *Array) At(index int) (value any) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *Array) Get(index int) (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *Array) Set(index int, value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *Array) SetArray(array []any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *Array) Replace(array []any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *Array) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // SortFunc sorts the array by custom function `less`.
 func (a *Array) SortFunc(less func(v1, v2 any) bool) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *Array) InsertBefore(index int, values ...any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]any{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `values` to the back of `index`.
 func (a *Array) InsertAfter(index int, values ...any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]any{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *Array) Remove(index int) (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *Array) doRemoveWithoutLock(index int) (value any, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *Array) RemoveValue(value any) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i := a.doSearchWithoutLock(value); i != -1 {
-		a.doRemoveWithoutLock(i)
-		return true
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // RemoveValues removes multiple items by `values`.
 func (a *Array) RemoveValues(values ...any) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i := a.doSearchWithoutLock(value); i != -1 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *Array) PushLeft(value ...any) *Array {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *Array) PushRight(value ...any) *Array {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopRand() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 func (a *Array) PopRands(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopLeft() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *Array) PopRight() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return nil, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 func (a *Array) PopLefts(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 func (a *Array) PopRights(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -365,26 +237,8 @@ func (a *Array) PopRights(size int) []any {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *Array) Range(start int, end ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]any)(nil)
-	if a.mu.IsSafe() {
-		array = make([]any, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -401,69 +255,29 @@ func (a *Array) Range(start int, end ...int) []any {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *Array) SubSlice(offset int, length ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]any, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight, please See PushRight.
 func (a *Array) Append(value ...any) *Array {
-	a.PushRight(value...)
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *Array) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *Array) Slice() []any {
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array := make([]any, len(a.array))
-		copy(array, a.array)
-		return array
-	} else {
-		return a.array
-	}
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
@@ -473,89 +287,49 @@ func (a *Array) Interfaces() []any {
 
 // Clone returns a new array, which is a copy of current array.
 func (a *Array) Clone() (newArray *Array) {
-	a.mu.RLock()
-	array := make([]any, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &Array{TArray: a.TArray.Clone()}
 }
 
 // Clear deletes all items of current array.
 func (a *Array) Clear() *Array {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]any, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *Array) Contains(value any) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *Array) Search(value any) int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return a.doSearchWithoutLock(value)
-}
-
-func (a *Array) doSearchWithoutLock(value any) int {
-	if len(a.array) == 0 {
-		return -1
-	}
-	result := -1
-	for index, v := range a.array {
-		if v == value {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *Array) Unique() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        any
-		uniqueSet   = make(map[any]struct{})
-		uniqueArray = make([]any, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *Array) LockFunc(f func(array []any)) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *Array) RLockFunc(f func(array []any)) *Array {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -564,48 +338,23 @@ func (a *Array) RLockFunc(f func(array []any)) *Array {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *Array) Merge(array any) *Array {
+	a.lazyInit()
 	return a.Append(gconv.Interfaces(array)...)
 }
 
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *Array) Fill(startIndex int, num int, value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *Array) Chunk(size int) [][]any {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]any
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -613,98 +362,47 @@ func (a *Array) Chunk(size int) [][]any {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *Array) Pad(size int, val any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]any, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = val
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, val)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *Array) Rand() (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *Array) Rands(size int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *Array) Shuffle() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *Array) Reverse() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *Array) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *Array) CountValues() map[any]int {
-	m := make(map[any]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -715,25 +413,15 @@ func (a *Array) Iterator(f func(k int, v any) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *Array) IteratorAsc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *Array) IteratorDesc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -741,118 +429,64 @@ func (a *Array) String() string {
 	if a == nil {
 		return ""
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	buffer := bytes.NewBuffer(nil)
-	buffer.WriteByte('[')
-	s := ""
-	for k, v := range a.array {
-		s = gconv.String(v)
-		if gstr.IsNumeric(s) {
-			buffer.WriteString(s)
-		} else {
-			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-		}
-		if k != len(a.array)-1 {
-			buffer.WriteByte(',')
-		}
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a Array) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *Array) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]any, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *Array) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceAny(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *Array) Filter(filter func(index int, value any) bool) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterNil removes all nil value of the array.
 func (a *Array) FilterNil() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterNil()
 	return a
 }
 
 // FilterEmpty removes all empty value of the array.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (a *Array) FilterEmpty() *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *Array) Walk(f func(value any) any) *Array {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *Array) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -860,11 +494,8 @@ func (a *Array) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]any, len(a.array))
-	for i, v := range a.array {
-		newSlice[i] = deepcopy.Copy(v)
+	a.lazyInit()
+	return &Array{
+		TArray: a.TArray.DeepCopy().(*TArray[any]),
 	}
-	return NewArrayFrom(newSlice, a.mu.IsSafe())
 }

container/garray/garray_normal_int.go

@@ -7,25 +7,19 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
 	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // IntArray is a golang int array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type IntArray struct {
-	mu    rwmutex.RWMutex
-	array []int
+	*TArray[int]
+	once sync.Once
 }
 
 // NewIntArray creates and returns an empty array.
@@ -40,8 +34,7 @@ func NewIntArray(safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArraySize(size int, cap int, safe ...bool) *IntArray {
 	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: make([]int, size, cap),
+		TArray: NewTArraySize[int](size, cap, safe...),
 	}
 }
 
@@ -65,8 +58,7 @@ func NewIntArrayRange(start, end, step int, safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -76,78 +68,66 @@ func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 func NewIntArrayFromCopy(array []int, safe ...bool) *IntArray {
 	newArray := make([]int, len(array))
 	copy(newArray, array)
-	return &IntArray{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewIntArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *IntArray) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[int](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `0`.
 func (a *IntArray) At(index int) (value int) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *IntArray) Get(index int) (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *IntArray) Set(index int, value int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *IntArray) SetArray(array []int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *IntArray) Replace(array []int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *IntArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += v
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort in increasing order(default) or decreasing order.
 func (a *IntArray) Sort(reverse ...bool) *IntArray {
+	a.lazyInit()
+
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
 	if len(reverse) > 0 && reverse[0] {
 		sort.Slice(a.array, func(i, j int) bool {
 			return a.array[i] >= a.array[j]
@@ -160,210 +140,101 @@ func (a *IntArray) Sort(reverse ...bool) *IntArray {
 
 // SortFunc sorts the array by custom function `less`.
 func (a *IntArray) SortFunc(less func(v1, v2 int) bool) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *IntArray) InsertBefore(index int, values ...int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			index, len(a.array),
-		)
-	}
-	rear := append([]int{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `value` to the back of `index`.
 func (a *IntArray) InsertAfter(index int, values ...int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			index, len(a.array),
-		)
-	}
-	rear := append([]int{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *IntArray) Remove(index int) (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *IntArray) doRemoveWithoutLock(index int) (value int, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *IntArray) RemoveValue(value int) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i := a.doSearchWithoutLock(value); i != -1 {
-		a.doRemoveWithoutLock(i)
-		return true
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // RemoveValues removes multiple items by `values`.
 func (a *IntArray) RemoveValues(values ...int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i := a.doSearchWithoutLock(value); i != -1 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *IntArray) PushLeft(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *IntArray) PushRight(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopLeft() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopRight() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return 0, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *IntArray) PopRand() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopRands(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopLefts(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *IntArray) PopRights(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -374,26 +245,8 @@ func (a *IntArray) PopRights(size int) []int {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *IntArray) Range(start int, end ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		array = make([]int, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -410,170 +263,84 @@ func (a *IntArray) Range(start int, end ...int) []int {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *IntArray) SubSlice(offset int, length ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]int, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *IntArray) Append(value ...int) *IntArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *IntArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *IntArray) Slice() []int {
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]int, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *IntArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Interfaces()
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *IntArray) Clone() (newArray *IntArray) {
-	a.mu.RLock()
-	array := make([]int, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewIntArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &IntArray{
+		TArray: a.TArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *IntArray) Clear() *IntArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]int, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *IntArray) Contains(value int) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *IntArray) Search(value int) int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return a.doSearchWithoutLock(value)
-}
-
-func (a *IntArray) doSearchWithoutLock(value int) int {
-	if len(a.array) == 0 {
-		return -1
-	}
-	result := -1
-	for index, v := range a.array {
-		if v == value {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        int
-		uniqueSet   = make(map[int]struct{})
-		uniqueArray = make([]int, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -588,46 +355,16 @@ func (a *IntArray) Merge(array any) *IntArray {
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *IntArray) Fill(startIndex int, num int, value int) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(
-			gcode.CodeInvalidParameter,
-			"index %d out of array range %d",
-			startIndex, len(a.array),
-		)
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *IntArray) Chunk(size int) [][]int {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]int
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -635,98 +372,47 @@ func (a *IntArray) Chunk(size int) [][]int {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *IntArray) Pad(size int, value int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]int, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = value
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, value)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *IntArray) Rand() (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *IntArray) Rands(size int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *IntArray) Shuffle() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *IntArray) Reverse() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *IntArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *IntArray) CountValues() map[int]int {
-	m := make(map[int]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -737,25 +423,15 @@ func (a *IntArray) Iterator(f func(k int, v int) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *IntArray) IteratorAsc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *IntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -769,80 +445,49 @@ func (a *IntArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a IntArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *IntArray) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]int, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *IntArray) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceInt(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *IntArray) Filter(filter func(index int, value int) bool) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all zero value of the array.
 func (a *IntArray) FilterEmpty() *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if a.array[i] == 0 {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *IntArray) Walk(f func(value int) int) *IntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *IntArray) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -850,9 +495,8 @@ func (a *IntArray) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]int, len(a.array))
-	copy(newSlice, a.array)
-	return NewIntArrayFrom(newSlice, a.mu.IsSafe())
+	a.lazyInit()
+	return &IntArray{
+		TArray: a.TArray.DeepCopy().(*TArray[int]),
+	}
 }

container/garray/garray_normal_str.go

@@ -8,25 +8,20 @@ package garray
 
 import (
 	"bytes"
-	"math"
 	"sort"
 	"strings"
+	"sync"
 
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // StrArray is a golang string array with rich features.
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type StrArray struct {
-	mu    rwmutex.RWMutex
-	array []string
+	*TArray[string]
+	once sync.Once
 }
 
 // NewStrArray creates and returns an empty array.
@@ -41,8 +36,7 @@ func NewStrArray(safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: make([]string, size, cap),
+		TArray: NewTArraySize[string](size, cap, safe...),
 	}
 }
 
@@ -51,8 +45,7 @@ func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: array,
+		TArray: NewTArrayFrom(array, safe...),
 	}
 }
 
@@ -62,77 +55,64 @@ func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 func NewStrArrayFromCopy(array []string, safe ...bool) *StrArray {
 	newArray := make([]string, len(array))
 	copy(newArray, array)
-	return &StrArray{
-		mu:    rwmutex.Create(safe...),
-		array: newArray,
-	}
+	return NewStrArrayFrom(newArray, safe...)
+}
+
+// lazyInit lazily initializes the array.
+func (a *StrArray) lazyInit() {
+	a.once.Do(func() {
+		if a.TArray == nil {
+			a.TArray = NewTArray[string](false)
+		}
+	})
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns an empty string.
 func (a *StrArray) At(index int) (value string) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.TArray.At(index)
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *StrArray) Get(index int) (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.TArray.Get(index)
 }
 
 // Set sets value to specified index.
 func (a *StrArray) Set(index int, value string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	a.array[index] = value
-	return nil
+	a.lazyInit()
+	return a.TArray.Set(index, value)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *StrArray) SetArray(array []string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
+	a.lazyInit()
+	a.TArray.SetArray(array)
 	return a
 }
 
 // Replace replaces the array items by given `array` from the beginning of array.
 func (a *StrArray) Replace(array []string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	max := len(array)
-	if max > len(a.array) {
-		max = len(a.array)
-	}
-	for i := 0; i < max; i++ {
-		a.array[i] = array[i]
-	}
+	a.lazyInit()
+	a.TArray.Replace(array)
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *StrArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.TArray.Sum()
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order
 func (a *StrArray) Sort(reverse ...bool) *StrArray {
+	a.lazyInit()
+
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	if len(reverse) > 0 && reverse[0] {
@@ -147,200 +127,101 @@ func (a *StrArray) Sort(reverse ...bool) *StrArray {
 
 // SortFunc sorts the array by custom function `less`.
 func (a *StrArray) SortFunc(less func(v1, v2 string) bool) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return less(a.array[i], a.array[j])
-	})
+	a.lazyInit()
+	a.TArray.SortFunc(less)
 	return a
 }
 
 // InsertBefore inserts the `values` to the front of `index`.
 func (a *StrArray) InsertBefore(index int, values ...string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]string{}, a.array[index:]...)
-	a.array = append(a.array[0:index], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertBefore(index, values...)
 }
 
 // InsertAfter inserts the `values` to the back of `index`.
 func (a *StrArray) InsertAfter(index int, values ...string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if index < 0 || index >= len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
-	}
-	rear := append([]string{}, a.array[index+1:]...)
-	a.array = append(a.array[0:index+1], values...)
-	a.array = append(a.array, rear...)
-	return nil
+	a.lazyInit()
+	return a.TArray.InsertAfter(index, values...)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *StrArray) Remove(index int) (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *StrArray) doRemoveWithoutLock(index int) (value string, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.TArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *StrArray) RemoveValue(value string) bool {
-	if i := a.Search(value); i != -1 {
-		_, found := a.Remove(i)
-		return found
-	}
-	return false
+	a.lazyInit()
+	return a.TArray.RemoveValue(value)
 }
 
 // RemoveValues removes multiple items by `values`.
 func (a *StrArray) RemoveValues(values ...string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i := a.doSearchWithoutLock(value); i != -1 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.TArray.RemoveValues(values...)
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *StrArray) PushLeft(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(value, a.array...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushLeft(value...)
 	return a
 }
 
 // PushRight pushes one or multiple items to the end of array.
 // It equals to Append.
 func (a *StrArray) PushRight(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.PushRight(value...)
 	return a
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopLeft() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopRight() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return "", false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.TArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *StrArray) PopRand() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.TArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopRands(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopLefts(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.TArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *StrArray) PopRights(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.TArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -351,26 +232,8 @@ func (a *StrArray) PopRights(size int) []string {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *StrArray) Range(start int, end ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		array = make([]string, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -387,111 +250,63 @@ func (a *StrArray) Range(start int, end ...int) []string {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *StrArray) SubSlice(offset int, length ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]string, size)
-		copy(s, a.array[offset:])
-		return s
-	}
-	return a.array[offset:end]
+	a.lazyInit()
+	return a.TArray.SubSlice(offset, length...)
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *StrArray) Append(value ...string) *StrArray {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Append(value...)
 	return a
 }
 
 // Len returns the length of array.
 func (a *StrArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.TArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *StrArray) Slice() []string {
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]string, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *StrArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Interfaces()
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *StrArray) Clone() (newArray *StrArray) {
-	a.mu.RLock()
-	array := make([]string, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewStrArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &StrArray{
+		TArray: a.TArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *StrArray) Clear() *StrArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]string, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.TArray.Clear()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *StrArray) Contains(value string) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.TArray.Contains(value)
 }
 
 // ContainsI checks whether a value exists in the array with case-insensitively.
 // Note that it internally iterates the whole array to do the comparison with case-insensitively.
 func (a *StrArray) ContainsI(value string) bool {
+	a.lazyInit()
+
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
@@ -508,64 +323,29 @@ func (a *StrArray) ContainsI(value string) bool {
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *StrArray) Search(value string) int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return a.doSearchWithoutLock(value)
-}
-
-func (a *StrArray) doSearchWithoutLock(value string) int {
-	if len(a.array) == 0 {
-		return -1
-	}
-	result := -1
-	for index, v := range a.array {
-		if strings.Compare(v, value) == 0 {
-			result = index
-			break
-		}
-	}
-	return result
+	a.lazyInit()
+	return a.TArray.Search(value)
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	var (
-		ok          bool
-		temp        string
-		uniqueSet   = make(map[string]struct{})
-		uniqueArray = make([]string, 0, len(a.array))
-	)
-	for i := 0; i < len(a.array); i++ {
-		temp = a.array[i]
-		if _, ok = uniqueSet[temp]; ok {
-			continue
-		}
-		uniqueSet[temp] = struct{}{}
-		uniqueArray = append(uniqueArray, temp)
-	}
-	a.array = uniqueArray
+	a.lazyInit()
+	a.TArray.Unique()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *StrArray) LockFunc(f func(array []string)) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *StrArray) RLockFunc(f func(array []string)) *StrArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.TArray.RLockFunc(f)
 	return a
 }
 
@@ -580,42 +360,16 @@ func (a *StrArray) Merge(array any) *StrArray {
 // Fill fills an array with num entries of the value `value`,
 // keys starting at the `startIndex` parameter.
 func (a *StrArray) Fill(startIndex int, num int, value string) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if startIndex < 0 || startIndex > len(a.array) {
-		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
-	}
-	for i := startIndex; i < startIndex+num; i++ {
-		if i > len(a.array)-1 {
-			a.array = append(a.array, value)
-		} else {
-			a.array[i] = value
-		}
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.Fill(startIndex, num, value)
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *StrArray) Chunk(size int) [][]string {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]string
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.TArray.Chunk(size)
 }
 
 // Pad pads array to the specified length with `value`.
@@ -623,98 +377,47 @@ func (a *StrArray) Chunk(size int) [][]string {
 // If the absolute value of `size` is less than or equal to the length of the array
 // then no padding takes place.
 func (a *StrArray) Pad(size int, value string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-		return a
-	}
-	n := size
-	if size < 0 {
-		n = -size
-	}
-	n -= len(a.array)
-	tmp := make([]string, n)
-	for i := 0; i < n; i++ {
-		tmp[i] = value
-	}
-	if size > 0 {
-		a.array = append(a.array, tmp...)
-	} else {
-		a.array = append(tmp, a.array...)
-	}
+	a.lazyInit()
+	a.TArray.Pad(size, value)
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *StrArray) Rand() (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.TArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *StrArray) Rands(size int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.TArray.Rands(size)
 }
 
 // Shuffle randomly shuffles the array.
 func (a *StrArray) Shuffle() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range grand.Perm(len(a.array)) {
-		a.array[i], a.array[v] = a.array[v], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Shuffle()
 	return a
 }
 
 // Reverse makes array with elements in reverse order.
 func (a *StrArray) Reverse() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
-		a.array[i], a.array[j] = a.array[j], a.array[i]
-	}
+	a.lazyInit()
+	a.TArray.Reverse()
 	return a
 }
 
 // Join joins array elements with a string `glue`.
 func (a *StrArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(v)
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.TArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *StrArray) CountValues() map[string]int {
-	m := make(map[string]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.TArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
@@ -725,25 +428,15 @@ func (a *StrArray) Iterator(f func(k int, v string) bool) {
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *StrArray) IteratorAsc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *StrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.TArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -751,6 +444,9 @@ func (a *StrArray) String() string {
 	if a == nil {
 		return ""
 	}
+
+	a.lazyInit()
+
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -768,80 +464,49 @@ func (a *StrArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a StrArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.TArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *StrArray) UnmarshalJSON(b []byte) error {
-	if a.array == nil {
-		a.array = make([]string, 0)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *StrArray) UnmarshalValue(value any) error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceStr(value)
-	}
-	return nil
+	a.lazyInit()
+	return a.TArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *StrArray) Filter(filter func(index int, value string) bool) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all empty string value of the array.
 func (a *StrArray) FilterEmpty() *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if a.array[i] == "" {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.TArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *StrArray) Walk(f func(value string) string) *StrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.TArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *StrArray) IsEmpty() bool {
-	return a.Len() == 0
+	a.lazyInit()
+	return a.TArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
@@ -849,9 +514,8 @@ func (a *StrArray) DeepCopy() any {
 	if a == nil {
 		return nil
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]string, len(a.array))
-	copy(newSlice, a.array)
-	return NewStrArrayFrom(newSlice, a.mu.IsSafe())
+	a.lazyInit()
+	return &StrArray{
+		TArray: a.TArray.DeepCopy().(*TArray[string]),
+	}
 }

container/garray/garray_normal_t.go

@@ -0,0 +1,859 @@
+// 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 garray
+
+import (
+	"bytes"
+	"math"
+	"sort"
+
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
+)
+
+// TArray is a golang array with rich features.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
+type TArray[T comparable] struct {
+	mu    rwmutex.RWMutex
+	array []T
+}
+
+// NewTArray creates and returns an empty array.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArray[T comparable](safe ...bool) *TArray[T] {
+	return NewTArraySize[T](0, 0, safe...)
+}
+
+// NewTArraySize create and returns an array with given size and cap.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArraySize[T comparable](size int, cap int, safe ...bool) *TArray[T] {
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: make([]T, size, cap),
+	}
+}
+
+// NewTArrayFrom creates and returns an array with given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArrayFrom[T comparable](array []T, safe ...bool) *TArray[T] {
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: array,
+	}
+}
+
+// NewTArrayFromCopy creates and returns an array from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewTArrayFromCopy[T comparable](array []T, safe ...bool) *TArray[T] {
+	newArray := make([]T, len(array))
+	copy(newArray, array)
+	return &TArray[T]{
+		mu:    rwmutex.Create(safe...),
+		array: newArray,
+	}
+}
+
+// At returns the value by the specified index.
+// If the given `index` is out of range of the array, it returns `nil`.
+func (a *TArray[T]) At(index int) (value T) {
+	value, _ = a.Get(index)
+	return
+}
+
+// Get returns the value by the specified index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *TArray[T]) Get(index int) (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	return a.array[index], true
+}
+
+// Set sets value to specified index.
+func (a *TArray[T]) Set(index int, value T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	a.array[index] = value
+	return nil
+}
+
+// SetArray sets the underlying slice array with the given `array`.
+func (a *TArray[T]) SetArray(array []T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	return a
+}
+
+// Replace replaces the array items by given `array` from the beginning of array.
+func (a *TArray[T]) Replace(array []T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	max := len(array)
+	if max > len(a.array) {
+		max = len(a.array)
+	}
+	for i := 0; i < max; i++ {
+		a.array[i] = array[i]
+	}
+	return a
+}
+
+// Sum returns the sum of values in an array.
+func (a *TArray[T]) Sum() (sum int) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += gconv.Int(v)
+	}
+	return
+}
+
+// SortFunc sorts the array by custom function `less`.
+func (a *TArray[T]) SortFunc(less func(v1, v2 T) bool) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	sort.Slice(a.array, func(i, j int) bool {
+		return less(a.array[i], a.array[j])
+	})
+	return a
+}
+
+// InsertBefore inserts the `values` to the front of `index`.
+func (a *TArray[T]) InsertBefore(index int, values ...T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	rear := append([]T{}, a.array[index:]...)
+	a.array = append(a.array[0:index], values...)
+	a.array = append(a.array, rear...)
+	return nil
+}
+
+// InsertAfter inserts the `values` to the back of `index`.
+func (a *TArray[T]) InsertAfter(index int, values ...T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", index, len(a.array))
+	}
+	rear := append([]T{}, a.array[index+1:]...)
+	a.array = append(a.array[0:index+1], values...)
+	a.array = append(a.array, rear...)
+	return nil
+}
+
+// Remove removes an item by index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *TArray[T]) Remove(index int) (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(index)
+}
+
+// doRemoveWithoutLock removes an item by index without lock.
+func (a *TArray[T]) doRemoveWithoutLock(index int) (value T, found bool) {
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	// Determine array boundaries when deleting to improve deletion efficiency.
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value, true
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value, true
+	}
+	// If it is a non-boundary delete,
+	// it will involve the creation of an array,
+	// then the deletion is less efficient.
+	value = a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value, true
+}
+
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *TArray[T]) RemoveValue(value T) bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if i := a.doSearchWithoutLock(value); i != -1 {
+		a.doRemoveWithoutLock(i)
+		return true
+	}
+	return false
+}
+
+// RemoveValues removes multiple items by `values`.
+func (a *TArray[T]) RemoveValues(values ...T) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i := a.doSearchWithoutLock(value); i != -1 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
+// PushLeft pushes one or multiple items to the beginning of array.
+func (a *TArray[T]) PushLeft(value ...T) *TArray[T] {
+	a.mu.Lock()
+	a.array = append(value, a.array...)
+	a.mu.Unlock()
+	return a
+}
+
+// PushRight pushes one or multiple items to the end of array.
+// It equals to Append.
+func (a *TArray[T]) PushRight(value ...T) *TArray[T] {
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
+	return a
+}
+
+// PopRand randomly pops and return an item out of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopRand() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+}
+
+// PopRands randomly pops and returns `size` items out of array.
+func (a *TArray[T]) PopRands(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	}
+	return array
+}
+
+// PopLeft pops and returns an item from the beginning of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopLeft() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	value = a.array[0]
+	a.array = a.array[1:]
+	return value, true
+}
+
+// PopRight pops and returns an item from the end of array.
+// Note that if the array is empty, the `found` is false.
+func (a *TArray[T]) PopRight() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	if index < 0 {
+		found = false
+		return
+	}
+	value = a.array[index]
+	a.array = a.array[:index]
+	return value, true
+}
+
+// PopLefts pops and returns `size` items from the beginning of array.
+func (a *TArray[T]) PopLefts(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[0:size]
+	a.array = a.array[size:]
+	return value
+}
+
+// PopRights pops and returns `size` items from the end of array.
+func (a *TArray[T]) PopRights(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	index := len(a.array) - size
+	if index <= 0 {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[index:]
+	a.array = a.array[:index]
+	return value
+}
+
+// Range picks and returns items by range, like array[start:end].
+// Notice, if in concurrent-safe usage, it returns a copy of slice;
+// else a pointer to the underlying data.
+//
+// If `end` is negative, then the offset will start from the end of array.
+// If `end` is omitted, then the sequence will have everything from start up
+// until the end of the array.
+func (a *TArray[T]) Range(start int, end ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]T)(nil)
+	if a.mu.IsSafe() {
+		array = make([]T, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// SubSlice returns a slice of elements from the array as specified
+// by the `offset` and `size` parameters.
+// If in concurrent safe usage, it returns a copy of the slice; else a pointer.
+//
+// If offset is non-negative, the sequence will start at that offset in the array.
+// If offset is negative, the sequence will start that far from the end of the array.
+//
+// If length is given and is positive, then the sequence will have up to that many elements in it.
+// If the array is shorter than the length, then only the available array elements will be present.
+// If length is given and is negative then the sequence will stop that many elements from the end of the array.
+// If it is omitted, then the sequence will have everything from offset up until the end of the array.
+//
+// Any possibility crossing the left border of array, it will fail.
+func (a *TArray[T]) SubSlice(offset int, length ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]T, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
+}
+
+// Append is alias of PushRight, please See PushRight.
+func (a *TArray[T]) Append(value ...T) *TArray[T] {
+	a.PushRight(value...)
+	return a
+}
+
+// Len returns the length of array.
+func (a *TArray[T]) Len() int {
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
+}
+
+// Slice returns the underlying data of array.
+// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
+// or else a pointer to the underlying data.
+func (a *TArray[T]) Slice() []T {
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array := make([]T, len(a.array))
+		copy(array, a.array)
+		return array
+	} else {
+		return a.array
+	}
+}
+
+// Interfaces returns current array as []any.
+func (a *TArray[T]) Interfaces() []any {
+	return tToAnySlice(a.Slice())
+}
+
+// Clone returns a new array, which is a copy of current array.
+func (a *TArray[T]) Clone() (newArray *TArray[T]) {
+	a.mu.RLock()
+	array := make([]T, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewTArrayFrom(array, a.mu.IsSafe())
+}
+
+// Clear deletes all items of current array.
+func (a *TArray[T]) Clear() *TArray[T] {
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]T, 0)
+	}
+	a.mu.Unlock()
+	return a
+}
+
+// Contains checks whether a value exists in the array.
+func (a *TArray[T]) Contains(value T) bool {
+	return a.Search(value) != -1
+}
+
+// Search searches array by `value`, returns the index of `value`,
+// or returns -1 if not exists.
+func (a *TArray[T]) Search(value T) int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.doSearchWithoutLock(value)
+}
+
+func (a *TArray[T]) doSearchWithoutLock(value T) int {
+	if len(a.array) == 0 {
+		return -1
+	}
+	result := -1
+	for index, v := range a.array {
+		if v == value {
+			result = index
+			break
+		}
+	}
+	return result
+}
+
+// Unique uniques the array, clear repeated items.
+// Example: [1,1,2,3,2] -> [1,2,3]
+func (a *TArray[T]) Unique() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	var (
+		ok          bool
+		temp        T
+		uniqueSet   = make(map[T]struct{})
+		uniqueArray = make([]T, 0, len(a.array))
+	)
+	for i := 0; i < len(a.array); i++ {
+		temp = a.array[i]
+		if _, ok = uniqueSet[temp]; ok {
+			continue
+		}
+		uniqueSet[temp] = struct{}{}
+		uniqueArray = append(uniqueArray, temp)
+	}
+	a.array = uniqueArray
+	return a
+}
+
+// LockFunc locks writing by callback function `f`.
+func (a *TArray[T]) LockFunc(f func(array []T)) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+	return a
+}
+
+// RLockFunc locks reading by callback function `f`.
+func (a *TArray[T]) RLockFunc(f func(array []T)) *TArray[T] {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
+}
+
+// Merge merges `array` into current array.
+// The parameter `array` can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *TArray[T]) Merge(array any) *TArray[T] {
+	var vals []T
+	switch v := array.(type) {
+	case *SortedTArray[T]:
+		vals = v.Slice()
+	case *TArray[T]:
+		vals = v.Slice()
+	case []T:
+		vals = v
+	default:
+		interfaces := gconv.Interfaces(v)
+		if err := gconv.Scan(interfaces, &vals); err != nil {
+			panic(err)
+		}
+	}
+
+	return a.Append(vals...)
+}
+
+// Fill fills an array with num entries of the value `value`,
+// keys starting at the `startIndex` parameter.
+func (a *TArray[T]) Fill(startIndex int, num int, value T) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if startIndex < 0 || startIndex > len(a.array) {
+		return gerror.NewCodef(gcode.CodeInvalidParameter, "index %d out of array range %d", startIndex, len(a.array))
+	}
+	for i := startIndex; i < startIndex+num; i++ {
+		if i > len(a.array)-1 {
+			a.array = append(a.array, value)
+		} else {
+			a.array[i] = value
+		}
+	}
+	return nil
+}
+
+// Chunk splits an array into multiple arrays,
+// the size of each array is determined by `size`.
+// The last chunk may contain less than size elements.
+func (a *TArray[T]) Chunk(size int) [][]T {
+	if size < 1 {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	length := len(a.array)
+	chunks := int(math.Ceil(float64(length) / float64(size)))
+	var n [][]T
+	for i, end := 0, 0; chunks > 0; chunks-- {
+		end = (i + 1) * size
+		if end > length {
+			end = length
+		}
+		n = append(n, a.array[i*size:end])
+		i++
+	}
+	return n
+}
+
+// Pad pads array to the specified length with `value`.
+// If size is positive then the array is padded on the right, or negative on the left.
+// If the absolute value of `size` is less than or equal to the length of the array
+// then no padding takes place.
+func (a *TArray[T]) Pad(size int, val T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
+		return a
+	}
+	n := size
+	if size < 0 {
+		n = -size
+	}
+	n -= len(a.array)
+	tmp := make([]T, n)
+	for i := 0; i < n; i++ {
+		tmp[i] = val
+	}
+	if size > 0 {
+		a.array = append(a.array, tmp...)
+	} else {
+		a.array = append(tmp, a.array...)
+	}
+	return a
+}
+
+// Rand randomly returns one item from array(no deleting).
+func (a *TArray[T]) Rand() (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	return a.array[grand.Intn(len(a.array))], true
+}
+
+// Rands randomly returns `size` items from array(no deleting).
+func (a *TArray[T]) Rands(size int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i] = a.array[grand.Intn(len(a.array))]
+	}
+	return array
+}
+
+// Shuffle randomly shuffles the array.
+func (a *TArray[T]) Shuffle() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, v := range grand.Perm(len(a.array)) {
+		a.array[i], a.array[v] = a.array[v], a.array[i]
+	}
+	return a
+}
+
+// Reverse makes array with elements in reverse order.
+func (a *TArray[T]) Reverse() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, j := 0, len(a.array)-1; i < j; i, j = i+1, j-1 {
+		a.array[i], a.array[j] = a.array[j], a.array[i]
+	}
+	return a
+}
+
+// Join joins array elements with a string `glue`.
+func (a *TArray[T]) Join(glue string) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return ""
+	}
+	buffer := bytes.NewBuffer(nil)
+	for k, v := range a.array {
+		buffer.WriteString(gconv.String(v))
+		if k != len(a.array)-1 {
+			buffer.WriteString(glue)
+		}
+	}
+	return buffer.String()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *TArray[T]) CountValues() map[T]int {
+	m := make(map[T]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+func (a *TArray[T]) Iterator(f func(k int, v T) bool) {
+	a.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *TArray[T]) IteratorAsc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for k, v := range a.array {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *TArray[T]) IteratorDesc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for i := len(a.array) - 1; i >= 0; i-- {
+		if !f(i, a.array[i]) {
+			break
+		}
+	}
+}
+
+// String returns current array as a string, which implements like json.Marshal does.
+func (a *TArray[T]) String() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('[')
+	s := ""
+	for k, v := range a.array {
+		s = gconv.String(v)
+		if gstr.IsNumeric(s) {
+			buffer.WriteString(s)
+		} else {
+			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
+		}
+		if k != len(a.array)-1 {
+			buffer.WriteByte(',')
+		}
+	}
+	buffer.WriteByte(']')
+	return buffer.String()
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// Note that do not use pointer as its receiver here.
+func (a TArray[T]) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (a *TArray[T]) UnmarshalJSON(b []byte) error {
+	if a.array == nil {
+		a.array = make([]T, 0)
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
+		return err
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *TArray[T]) UnmarshalValue(value any) error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
+	default:
+		if err := gconv.Scan(gconv.SliceAny(value), &a.array); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Filter iterates array and filters elements using custom callback function.
+// It removes the element from array if callback function `filter` returns true,
+// it or else does nothing and continues iterating.
+func (a *TArray[T]) Filter(filter func(index int, value T) bool) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// FilterNil removes all nil value of the array.
+func (a *TArray[T]) FilterNil() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// FilterEmpty removes all empty value of the array.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
+func (a *TArray[T]) FilterEmpty() *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Walk applies a user supplied function `f` to every item of array.
+func (a *TArray[T]) Walk(f func(value T) T) *TArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i, v := range a.array {
+		a.array[i] = f(v)
+	}
+	return a
+}
+
+// IsEmpty checks whether the array is empty.
+func (a *TArray[T]) IsEmpty() bool {
+	return a.Len() == 0
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *TArray[T]) DeepCopy() any {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]T, len(a.array))
+	for i, v := range a.array {
+		newSlice[i] = deepcopy.Copy(v).(T)
+	}
+	return NewTArrayFrom(newSlice, a.mu.IsSafe())
+}

container/garray/garray_sorted_any.go

@@ -7,19 +7,11 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
 	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/deepcopy"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
-	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
-	"github.com/gogf/gf/v2/util/gutil"
 )
 
 // SortedArray is a golang sorted array with rich features.
@@ -28,10 +20,17 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedArray struct {
-	mu         rwmutex.RWMutex
-	array      []any
-	unique     bool               // Whether enable unique feature(false)
-	comparator func(a, b any) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[any]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize[any](0, nil, false)
+		}
+	})
 }
 
 // NewSortedArray creates and returns an empty sorted array.
@@ -49,9 +48,7 @@ func NewSortedArray(comparator func(a, b any) int, safe ...bool) *SortedArray {
 // which is false in default.
 func NewSortedArraySize(cap int, comparator func(a, b any) int, safe ...bool) *SortedArray {
 	return &SortedArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]any, 0, cap),
-		comparator: comparator,
+		SortedTArray: NewSortedTArraySize(cap, comparator, safe...),
 	}
 }
 
@@ -94,224 +91,111 @@ func NewSortedArrayFromCopy(array []any, comparator func(a, b any) int, safe ...
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `nil`.
 func (a *SortedArray) At(index int) (value any) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedArray) SetArray(array []any) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
 // SetComparator sets/changes the comparator for sorting.
 // It resorts the array as the comparator is changed.
 func (a *SortedArray) SetComparator(comparator func(a, b any) int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.comparator = comparator
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.SetComparator(comparator)
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order
 func (a *SortedArray) Sort() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedArray) Add(values ...any) *SortedArray {
-	return a.Append(values...)
+	a.lazyInit()
+	a.SortedTArray.Add(values...)
+	return a
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedArray) Append(values ...any) *SortedArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		a.array = append(a.array[:index], append([]any{value}, a.array[index:]...)...)
-	}
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedArray) Get(index int) (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedArray) Remove(index int) (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedArray) doRemoveWithoutLock(index int) (value any, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return nil, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedArray) RemoveValue(value any) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // RemoveValues removes an item by `values`.
 func (a *SortedArray) RemoveValues(values ...any) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i, r := a.binSearch(value, false); r == 0 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopLeft() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopRight() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return nil, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedArray) PopRand() (value any, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 func (a *SortedArray) PopRands(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 func (a *SortedArray) PopLefts(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 func (a *SortedArray) PopRights(size int) []any {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -322,26 +206,7 @@ func (a *SortedArray) PopRights(size int) []any {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedArray) Range(start int, end ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]any)(nil)
-	if a.mu.IsSafe() {
-		array = make([]any, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -358,194 +223,91 @@ func (a *SortedArray) Range(start int, end ...int) []any {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedArray) SubSlice(offset int, length ...int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]any, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Len returns the length of array.
 func (a *SortedArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedArray) Slice() []any {
-	var array []any
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]any, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedArray) Interfaces() []any {
-	return a.Slice()
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedArray) Contains(value any) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedArray) Search(value any) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedArray) binSearch(value any, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + (max-min)/2
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // SetUnique sets unique mark to the array,
 // which means it does not contain any repeated items.
 // It also does unique check, remove all repeated items.
 func (a *SortedArray) SetUnique(unique bool) *SortedArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedArray) Unique() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedArray) Clone() (newArray *SortedArray) {
-	a.mu.RLock()
-	array := make([]any, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedArrayFrom(array, a.comparator, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedArray) Clear() *SortedArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]any, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedArray) LockFunc(f func(array []any)) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
-
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedArray) RLockFunc(f func(array []any)) *SortedArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -561,104 +323,52 @@ func (a *SortedArray) Merge(array any) *SortedArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedArray) Chunk(size int) [][]any {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]any
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedArray) Rand() (value any, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return nil, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedArray) Rands(size int) []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]any, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedArray) CountValues() map[any]int {
-	m := make(map[any]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedArray) Iterator(f func(k int, v any) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedArray) IteratorAsc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedArray) IteratorDesc(f func(k int, v any) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -666,94 +376,35 @@ func (a *SortedArray) String() string {
 	if a == nil {
 		return ""
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	buffer := bytes.NewBuffer(nil)
-	buffer.WriteByte('[')
-	s := ""
-	for k, v := range a.array {
-		s = gconv.String(v)
-		if gstr.IsNumeric(s) {
-			buffer.WriteString(s)
-		} else {
-			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-		}
-		if k != len(a.array)-1 {
-			buffer.WriteByte(',')
-		}
-	}
-	buffer.WriteByte(']')
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.String()
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 // Note that the comparator is set as string comparator in default.
 func (a *SortedArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]any, 0)
-		a.comparator = gutil.ComparatorString
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.comparator != nil && a.array != nil {
-		sort.Slice(a.array, func(i, j int) bool {
-			return a.comparator(a.array[i], a.array[j]) < 0
-		})
-	}
-	return nil
+	a.lazyInit()
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 // Note that the comparator is set as string comparator in default.
 func (a *SortedArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
-		a.comparator = gutil.ComparatorString
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceAny(value)
-	}
-	if a.comparator != nil && a.array != nil {
-		sort.Slice(a.array, func(i, j int) bool {
-			return a.comparator(a.array[i], a.array[j]) < 0
-		})
-	}
-	return err
+	a.lazyInit()
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // FilterNil removes all nil value of the array.
 func (a *SortedArray) FilterNil() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
-	for i := len(a.array) - 1; i >= 0; {
-		if empty.IsNil(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.FilterNil()
 	return a
 }
 
@@ -761,78 +412,36 @@ func (a *SortedArray) FilterNil() *SortedArray {
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *SortedArray) Filter(filter func(index int, value any) bool) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all empty value of the array.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (a *SortedArray) FilterEmpty() *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
-	for i := len(a.array) - 1; i >= 0; {
-		if empty.IsEmpty(a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.FilterEmpty()
 	return a
 }
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedArray) Walk(f func(value any) any) *SortedArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	// Keep the array always sorted.
-	defer sort.Slice(a.array, func(i, j int) bool {
-		return a.getComparator()(a.array[i], a.array[j]) < 0
-	})
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it panics.
-func (a *SortedArray) getComparator() func(a, b any) int {
-	if a.comparator == nil {
-		panic("comparator is missing for sorted array")
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[any]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]any, len(a.array))
-	for i, v := range a.array {
-		newSlice[i] = deepcopy.Copy(v)
-	}
-	return NewSortedArrayFrom(newSlice, a.comparator, a.mu.IsSafe())
 }

container/garray/garray_sorted_int.go

@@ -7,15 +7,10 @@
 package garray
 
 import (
-	"bytes"
 	"fmt"
-	"math"
-	"sort"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // SortedIntArray is a golang sorted int array with rich features.
@@ -24,10 +19,18 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedIntArray struct {
-	mu         rwmutex.RWMutex
-	array      []int
-	unique     bool               // Whether enable unique feature(false)
-	comparator func(a, b int) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[int]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedIntArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize(0, defaultComparatorInt, false)
+			a.SetSorter(quickSortInt)
+		}
+	})
 }
 
 // NewSortedIntArray creates and returns an empty sorted array.
@@ -49,10 +52,10 @@ func NewSortedIntArrayComparator(comparator func(a, b int) int, safe ...bool) *S
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedIntArraySize(cap int, safe ...bool) *SortedIntArray {
+	a := NewSortedTArraySize(cap, defaultComparatorInt, safe...)
+	a.SetSorter(quickSortInt)
 	return &SortedIntArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]int, 0, cap),
-		comparator: defaultComparatorInt,
+		SortedTArray: a,
 	}
 }
 
@@ -77,7 +80,7 @@ func NewSortedIntArrayRange(start, end, step int, safe ...bool) *SortedIntArray
 func NewSortedIntArrayFrom(array []int, safe ...bool) *SortedIntArray {
 	a := NewSortedIntArraySize(0, safe...)
 	a.array = array
-	sort.Ints(a.array)
+	a.sorter(a.array, defaultComparatorInt)
 	return a
 }
 
@@ -93,16 +96,14 @@ func NewSortedIntArrayFromCopy(array []int, safe ...bool) *SortedIntArray {
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns `0`.
 func (a *SortedIntArray) At(index int) (value int) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	quickSortInt(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
@@ -110,200 +111,95 @@ func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedIntArray) Sort() *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	quickSortInt(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedIntArray) Add(values ...int) *SortedIntArray {
+	a.lazyInit()
 	return a.Append(values...)
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedIntArray) Append(values ...int) *SortedIntArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		rear := append([]int{}, a.array[index:]...)
-		a.array = append(a.array[0:index], value)
-		a.array = append(a.array, rear...)
-	}
+	a.lazyInit()
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedIntArray) Get(index int) (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedIntArray) Remove(index int) (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedIntArray) doRemoveWithoutLock(index int) (value int, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return 0, false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedIntArray) RemoveValue(value int) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // RemoveValues removes an item by `values`.
 func (a *SortedIntArray) RemoveValues(values ...int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i, r := a.binSearch(value, false); r == 0 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopLeft() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopRight() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return 0, false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedIntArray) PopRand() (value int, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopRands(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopLefts(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedIntArray) PopRights(size int) []int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -314,26 +210,8 @@ func (a *SortedIntArray) PopRights(size int) []int {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedIntArray) Range(start int, end ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		array = make([]int, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -350,194 +228,91 @@ func (a *SortedIntArray) Range(start int, end ...int) []int {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedIntArray) SubSlice(offset int, length ...int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]int, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Len returns the length of array.
 func (a *SortedIntArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedIntArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += v
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedIntArray) Slice() []int {
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]int, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedIntArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedIntArray) Contains(value int) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedIntArray) Search(value int) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + int((max-min)/2)
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // SetUnique sets unique mark to the array,
 // which means it does not contain any repeated items.
 // It also do unique check, remove all repeated items.
 func (a *SortedIntArray) SetUnique(unique bool) *SortedIntArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedIntArray) Unique() *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
-	a.mu.RLock()
-	array := make([]int, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedIntArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedIntArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedIntArray) Clear() *SortedIntArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]int, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -546,6 +321,7 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedIntArray) Merge(array any) *SortedIntArray {
+	a.lazyInit()
 	return a.Add(gconv.Ints(array)...)
 }
 
@@ -553,104 +329,52 @@ func (a *SortedIntArray) Merge(array any) *SortedIntArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedIntArray) Chunk(size int) [][]int {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]int
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedIntArray) Rand() (value int, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return 0, false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedIntArray) Rands(size int) []int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]int, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedIntArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(gconv.String(v))
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedIntArray) CountValues() map[int]int {
-	m := make(map[int]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedIntArray) Iterator(f func(k int, v int) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedIntArray) IteratorAsc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedIntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -658,73 +382,64 @@ func (a *SortedIntArray) String() string {
 	if a == nil {
 		return ""
 	}
+	a.lazyInit()
 	return "[" + a.Join(",") + "]"
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedIntArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedIntArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]int, 0)
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorInt
+		a.sorter = quickSortInt
+		a.array = make([]int, 0)
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.array != nil {
-		sort.Ints(a.array)
-	}
-	return nil
+
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *SortedIntArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorInt
+		a.sorter = quickSortInt
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceInt(value)
-	}
-	if a.array != nil {
-		sort.Ints(a.array)
-	}
-	return err
+
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *SortedIntArray) Filter(filter func(index int, value int) bool) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all zero value of the array.
 func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
+	a.lazyInit()
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
+	if len(a.array) == 0 {
+		return a
+	}
+
+	if a.array[0] != 0 && a.array[len(a.array)-1] != 0 {
+		a.SortedTArray.FilterEmpty()
+		return a
+	}
+
 	for i := 0; i < len(a.array); {
 		if a.array[i] == 0 {
 			a.array = append(a.array[:i], a.array[i+1:]...)
@@ -735,6 +450,7 @@ func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
 	for i := len(a.array) - 1; i >= 0; {
 		if a.array[i] == 0 {
 			a.array = append(a.array[:i], a.array[i+1:]...)
+			i--
 		} else {
 			break
 		}
@@ -744,40 +460,21 @@ func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedIntArray) Walk(f func(value int) int) *SortedIntArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer quickSortInt(a.array, a.getComparator())
-
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedIntArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it returns a default comparator.
-func (a *SortedIntArray) getComparator() func(a, b int) int {
-	if a.comparator == nil {
-		return defaultComparatorInt
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedIntArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedIntArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[int]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]int, len(a.array))
-	copy(newSlice, a.array)
-	return NewSortedIntArrayFrom(newSlice, a.mu.IsSafe())
 }

container/garray/garray_sorted_str.go

@@ -8,15 +8,11 @@ package garray
 
 import (
 	"bytes"
-	"math"
-	"sort"
 	"strings"
+	"sync"
 
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/grand"
 )
 
 // SortedStrArray is a golang sorted string array with rich features.
@@ -25,10 +21,18 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedStrArray struct {
-	mu         rwmutex.RWMutex
-	array      []string
-	unique     bool                  // Whether enable unique feature(false)
-	comparator func(a, b string) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	*SortedTArray[string]
+	once sync.Once
+}
+
+// lazyInit lazily initializes the array.
+func (a *SortedStrArray) lazyInit() {
+	a.once.Do(func() {
+		if a.SortedTArray == nil {
+			a.SortedTArray = NewSortedTArraySize(0, defaultComparatorStr, false)
+			a.SetSorter(quickSortStr)
+		}
+	})
 }
 
 // NewSortedStrArray creates and returns an empty sorted array.
@@ -50,10 +54,10 @@ func NewSortedStrArrayComparator(comparator func(a, b string) int, safe ...bool)
 // The parameter `safe` is used to specify whether using array in concurrent-safety,
 // which is false in default.
 func NewSortedStrArraySize(cap int, safe ...bool) *SortedStrArray {
+	a := NewSortedTArraySize(cap, defaultComparatorStr, safe...)
+	a.SetSorter(quickSortStr)
 	return &SortedStrArray{
-		mu:         rwmutex.Create(safe...),
-		array:      make([]string, 0, cap),
-		comparator: defaultComparatorStr,
+		SortedTArray: a,
 	}
 }
 
@@ -78,218 +82,112 @@ func NewSortedStrArrayFromCopy(array []string, safe ...bool) *SortedStrArray {
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedStrArray) SetArray(array []string) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array = array
-	quickSortStr(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.SetArray(array)
 	return a
 }
 
 // At returns the value by the specified index.
 // If the given `index` is out of range of the array, it returns an empty string.
 func (a *SortedStrArray) At(index int) (value string) {
-	value, _ = a.Get(index)
-	return
+	a.lazyInit()
+	return a.SortedTArray.At(index)
 }
 
 // Sort sorts the array in increasing order.
 // The parameter `reverse` controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedStrArray) Sort() *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	quickSortStr(a.array, a.getComparator())
+	a.lazyInit()
+	a.SortedTArray.Sort()
 	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
 // It's alias of function Append, see Append.
 func (a *SortedStrArray) Add(values ...string) *SortedStrArray {
-	return a.Append(values...)
+	a.lazyInit()
+	a.SortedTArray.Add(values...)
+	return a
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedStrArray) Append(values ...string) *SortedStrArray {
-	if len(values) == 0 {
-		return a
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		index, cmp := a.binSearch(value, false)
-		if a.unique && cmp == 0 {
-			continue
-		}
-		if index < 0 {
-			a.array = append(a.array, value)
-			continue
-		}
-		if cmp > 0 {
-			index++
-		}
-		rear := append([]string{}, a.array[index:]...)
-		a.array = append(a.array[0:index], value)
-		a.array = append(a.array, rear...)
-	}
+	a.lazyInit()
+	a.SortedTArray.Append(values...)
 	return a
 }
 
 // Get returns the value by the specified index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedStrArray) Get(index int) (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	return a.array[index], true
+	a.lazyInit()
+	return a.SortedTArray.Get(index)
 }
 
 // Remove removes an item by index.
 // If the given `index` is out of range of the array, the `found` is false.
 func (a *SortedStrArray) Remove(index int) (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(index)
-}
-
-// doRemoveWithoutLock removes an item by index without lock.
-func (a *SortedStrArray) doRemoveWithoutLock(index int) (value string, found bool) {
-	if index < 0 || index >= len(a.array) {
-		return "", false
-	}
-	// Determine array boundaries when deleting to improve deletion efficiency.
-	if index == 0 {
-		value := a.array[0]
-		a.array = a.array[1:]
-		return value, true
-	} else if index == len(a.array)-1 {
-		value := a.array[index]
-		a.array = a.array[:index]
-		return value, true
-	}
-	// If it is a non-boundary delete,
-	// it will involve the creation of an array,
-	// then the deletion is less efficient.
-	value = a.array[index]
-	a.array = append(a.array[:index], a.array[index+1:]...)
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.Remove(index)
 }
 
 // RemoveValue removes an item by value.
 // It returns true if value is found in the array, or else false if not found.
 func (a *SortedStrArray) RemoveValue(value string) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if i, r := a.binSearch(value, false); r == 0 {
-		_, res := a.doRemoveWithoutLock(i)
-		return res
-	}
-	return false
+	a.lazyInit()
+	return a.SortedTArray.RemoveValue(value)
 }
 
 // RemoveValues removes an item by `values`.
 func (a *SortedStrArray) RemoveValues(values ...string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for _, value := range values {
-		if i, r := a.binSearch(value, false); r == 0 {
-			a.doRemoveWithoutLock(i)
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.RemoveValues(values...)
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopLeft() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	value = a.array[0]
-	a.array = a.array[1:]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopLeft()
 }
 
 // PopRight pops and returns an item from the end of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopRight() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	index := len(a.array) - 1
-	if index < 0 {
-		return "", false
-	}
-	value = a.array[index]
-	a.array = a.array[:index]
-	return value, true
+	a.lazyInit()
+	return a.SortedTArray.PopRight()
 }
 
 // PopRand randomly pops and return an item out of array.
 // Note that if the array is empty, the `found` is false.
 func (a *SortedStrArray) PopRand() (value string, found bool) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	a.lazyInit()
+	return a.SortedTArray.PopRand()
 }
 
 // PopRands randomly pops and returns `size` items out of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopRands(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		size = len(a.array)
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.PopRands(size)
 }
 
 // PopLefts pops and returns `size` items from the beginning of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopLefts(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	if size >= len(a.array) {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[0:size]
-	a.array = a.array[size:]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopLefts(size)
 }
 
 // PopRights pops and returns `size` items from the end of array.
 // If the given `size` is greater than size of the array, it returns all elements of the array.
 // Note that if given `size` <= 0 or the array is empty, it returns nil.
 func (a *SortedStrArray) PopRights(size int) []string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	index := len(a.array) - size
-	if index <= 0 {
-		array := a.array
-		a.array = a.array[:0]
-		return array
-	}
-	value := a.array[index:]
-	a.array = a.array[:index]
-	return value
+	a.lazyInit()
+	return a.SortedTArray.PopRights(size)
 }
 
 // Range picks and returns items by range, like array[start:end].
@@ -300,26 +198,8 @@ func (a *SortedStrArray) PopRights(size int) []string {
 // If `end` is omitted, then the sequence will have everything from start up
 // until the end of the array.
 func (a *SortedStrArray) Range(start int, end ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	offsetEnd := len(a.array)
-	if len(end) > 0 && end[0] < offsetEnd {
-		offsetEnd = end[0]
-	}
-	if start > offsetEnd {
-		return nil
-	}
-	if start < 0 {
-		start = 0
-	}
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		array = make([]string, offsetEnd-start)
-		copy(array, a.array[start:offsetEnd])
-	} else {
-		array = a.array[start:offsetEnd]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Range(start, end...)
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -336,95 +216,46 @@ func (a *SortedStrArray) Range(start int, end ...int) []string {
 //
 // Any possibility crossing the left border of array, it will fail.
 func (a *SortedStrArray) SubSlice(offset int, length ...int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	size := len(a.array)
-	if len(length) > 0 {
-		size = length[0]
-	}
-	if offset > len(a.array) {
-		return nil
-	}
-	if offset < 0 {
-		offset = len(a.array) + offset
-		if offset < 0 {
-			return nil
-		}
-	}
-	if size < 0 {
-		offset += size
-		size = -size
-		if offset < 0 {
-			return nil
-		}
-	}
-	end := offset + size
-	if end > len(a.array) {
-		end = len(a.array)
-		size = len(a.array) - offset
-	}
-	if a.mu.IsSafe() {
-		s := make([]string, size)
-		copy(s, a.array[offset:])
-		return s
-	} else {
-		return a.array[offset:end]
-	}
+	a.lazyInit()
+	return a.SortedTArray.SubSlice(offset, length...)
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedStrArray) Sum() (sum int) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		sum += gconv.Int(v)
-	}
-	return
+	a.lazyInit()
+	return a.SortedTArray.Sum()
 }
 
 // Len returns the length of array.
 func (a *SortedStrArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
+	a.lazyInit()
+	return a.SortedTArray.Len()
 }
 
 // Slice returns the underlying data of array.
 // Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
 // or else a pointer to the underlying data.
 func (a *SortedStrArray) Slice() []string {
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-		array = make([]string, len(a.array))
-		copy(array, a.array)
-	} else {
-		array = a.array
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Slice()
 }
 
 // Interfaces returns current array as []any.
 func (a *SortedStrArray) Interfaces() []any {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	array := make([]any, len(a.array))
-	for k, v := range a.array {
-		array[k] = v
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Interfaces()
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedStrArray) Contains(value string) bool {
-	return a.Search(value) != -1
+	a.lazyInit()
+	return a.SortedTArray.Contains(value)
 }
 
 // ContainsI checks whether a value exists in the array with case-insensitively.
 // Note that it internally iterates the whole array to do the comparison with case-insensitively.
 func (a *SortedStrArray) ContainsI(value string) bool {
+	a.lazyInit()
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
@@ -441,105 +272,52 @@ func (a *SortedStrArray) ContainsI(value string) bool {
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedStrArray) Search(value string) (index int) {
-	if i, r := a.binSearch(value, true); r == 0 {
-		return i
-	}
-	return -1
-}
-
-// Binary search.
-// It returns the last compared index and the result.
-// If `result` equals to 0, it means the value at `index` is equals to `value`.
-// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
-// If `result` greater than 0, it means the value at `index` is greater than `value`.
-func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result int) {
-	if lock {
-		a.mu.RLock()
-		defer a.mu.RUnlock()
-	}
-	if len(a.array) == 0 {
-		return -1, -2
-	}
-	min := 0
-	max := len(a.array) - 1
-	mid := 0
-	cmp := -2
-	for min <= max {
-		mid = min + int((max-min)/2)
-		cmp = a.getComparator()(value, a.array[mid])
-		switch {
-		case cmp < 0:
-			max = mid - 1
-		case cmp > 0:
-			min = mid + 1
-		default:
-			return mid, cmp
-		}
-	}
-	return mid, cmp
+	a.lazyInit()
+	return a.SortedTArray.Search(value)
 }
 
 // SetUnique sets unique mark to the array,
 // which means it does not contain any repeated items.
 // It also do unique check, remove all repeated items.
 func (a *SortedStrArray) SetUnique(unique bool) *SortedStrArray {
-	oldUnique := a.unique
-	a.unique = unique
-	if unique && oldUnique != unique {
-		a.Unique()
-	}
+	a.lazyInit()
+	a.SortedTArray.SetUnique(unique)
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedStrArray) Unique() *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if len(a.array) == 0 {
-		return a
-	}
-	for i := 0; i < len(a.array)-1; {
-		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
-			a.array = append(a.array[:i+1], a.array[i+2:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Unique()
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedStrArray) Clone() (newArray *SortedStrArray) {
-	a.mu.RLock()
-	array := make([]string, len(a.array))
-	copy(array, a.array)
-	a.mu.RUnlock()
-	return NewSortedStrArrayFrom(array, a.mu.IsSafe())
+	a.lazyInit()
+	return &SortedStrArray{
+		SortedTArray: a.SortedTArray.Clone(),
+	}
 }
 
 // Clear deletes all items of current array.
 func (a *SortedStrArray) Clear() *SortedStrArray {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		a.array = make([]string, 0)
-	}
-	a.mu.Unlock()
+	a.lazyInit()
+	a.SortedTArray.Clear()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedStrArray) LockFunc(f func(array []string)) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.LockFunc(f)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	f(a.array)
+	a.lazyInit()
+	a.SortedTArray.RLockFunc(f)
 	return a
 }
 
@@ -548,6 +326,7 @@ func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedStrArray) Merge(array any) *SortedStrArray {
+	a.lazyInit()
 	return a.Add(gconv.Strings(array)...)
 }
 
@@ -555,104 +334,52 @@ func (a *SortedStrArray) Merge(array any) *SortedStrArray {
 // the size of each array is determined by `size`.
 // The last chunk may contain less than size elements.
 func (a *SortedStrArray) Chunk(size int) [][]string {
-	if size < 1 {
-		return nil
-	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	length := len(a.array)
-	chunks := int(math.Ceil(float64(length) / float64(size)))
-	var n [][]string
-	for i, end := 0, 0; chunks > 0; chunks-- {
-		end = (i + 1) * size
-		if end > length {
-			end = length
-		}
-		n = append(n, a.array[i*size:end])
-		i++
-	}
-	return n
+	a.lazyInit()
+	return a.SortedTArray.Chunk(size)
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedStrArray) Rand() (value string, found bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return "", false
-	}
-	return a.array[grand.Intn(len(a.array))], true
+	a.lazyInit()
+	return a.SortedTArray.Rand()
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedStrArray) Rands(size int) []string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if size <= 0 || len(a.array) == 0 {
-		return nil
-	}
-	array := make([]string, size)
-	for i := 0; i < size; i++ {
-		array[i] = a.array[grand.Intn(len(a.array))]
-	}
-	return array
+	a.lazyInit()
+	return a.SortedTArray.Rands(size)
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedStrArray) Join(glue string) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	if len(a.array) == 0 {
-		return ""
-	}
-	buffer := bytes.NewBuffer(nil)
-	for k, v := range a.array {
-		buffer.WriteString(v)
-		if k != len(a.array)-1 {
-			buffer.WriteString(glue)
-		}
-	}
-	return buffer.String()
+	a.lazyInit()
+	return a.SortedTArray.Join(glue)
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedStrArray) CountValues() map[string]int {
-	m := make(map[string]int)
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for _, v := range a.array {
-		m[v]++
-	}
-	return m
+	a.lazyInit()
+	return a.SortedTArray.CountValues()
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedStrArray) Iterator(f func(k int, v string) bool) {
-	a.IteratorAsc(f)
+	a.lazyInit()
+	a.SortedTArray.Iterator(f)
 }
 
 // IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedStrArray) IteratorAsc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for k, v := range a.array {
-		if !f(k, v) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorAsc(f)
 }
 
 // IteratorDesc iterates the array readonly in descending order with given callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (a *SortedStrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	for i := len(a.array) - 1; i >= 0; i-- {
-		if !f(i, a.array[i]) {
-			break
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.IteratorDesc(f)
 }
 
 // String returns current array as a string, which implements like json.Marshal does.
@@ -660,6 +387,7 @@ func (a *SortedStrArray) String() string {
 	if a == nil {
 		return ""
 	}
+	a.lazyInit()
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -677,67 +405,56 @@ func (a *SortedStrArray) String() string {
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 // Note that do not use pointer as its receiver here.
 func (a SortedStrArray) MarshalJSON() ([]byte, error) {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	return json.Marshal(a.array)
+	a.lazyInit()
+	return a.SortedTArray.MarshalJSON()
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedStrArray) UnmarshalJSON(b []byte) error {
-	if a.comparator == nil {
-		a.array = make([]string, 0)
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorStr
+		a.sorter = quickSortStr
+		a.array = make([]string, 0)
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
-		return err
-	}
-	if a.array != nil {
-		sort.Strings(a.array)
-	}
-	return nil
+	return a.SortedTArray.UnmarshalJSON(b)
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
 func (a *SortedStrArray) UnmarshalValue(value any) (err error) {
-	if a.comparator == nil {
+	a.lazyInit()
+	if a.comparator == nil || a.sorter == nil {
 		a.comparator = defaultComparatorStr
+		a.sorter = quickSortStr
 	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	switch value.(type) {
-	case string, []byte:
-		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
-	default:
-		a.array = gconv.SliceStr(value)
-	}
-	if a.array != nil {
-		sort.Strings(a.array)
-	}
-	return err
+
+	return a.SortedTArray.UnmarshalValue(value)
 }
 
 // Filter iterates array and filters elements using custom callback function.
 // It removes the element from array if callback function `filter` returns true,
 // it or else does nothing and continues iterating.
 func (a *SortedStrArray) Filter(filter func(index int, value string) bool) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	for i := 0; i < len(a.array); {
-		if filter(i, a.array[i]) {
-			a.array = append(a.array[:i], a.array[i+1:]...)
-		} else {
-			i++
-		}
-	}
+	a.lazyInit()
+	a.SortedTArray.Filter(filter)
 	return a
 }
 
 // FilterEmpty removes all empty string value of the array.
 func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
+	a.lazyInit()
 	a.mu.Lock()
 	defer a.mu.Unlock()
+
+	if len(a.array) == 0 {
+		return a
+	}
+
+	if a.array[0] != "" && a.array[len(a.array)-1] != "" {
+		a.SortedTArray.FilterEmpty()
+		return a
+	}
+
 	for i := 0; i < len(a.array); {
 		if a.array[i] == "" {
 			a.array = append(a.array[:i], a.array[i+1:]...)
@@ -748,6 +465,7 @@ func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
 	for i := len(a.array) - 1; i >= 0; {
 		if a.array[i] == "" {
 			a.array = append(a.array[:i], a.array[i+1:]...)
+			i--
 		} else {
 			break
 		}
@@ -757,40 +475,21 @@ func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
 
 // Walk applies a user supplied function `f` to every item of array.
 func (a *SortedStrArray) Walk(f func(value string) string) *SortedStrArray {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-
-	// Keep the array always sorted.
-	defer quickSortStr(a.array, a.getComparator())
-
-	for i, v := range a.array {
-		a.array[i] = f(v)
-	}
+	a.lazyInit()
+	a.SortedTArray.Walk(f)
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedStrArray) IsEmpty() bool {
-	return a.Len() == 0
-}
-
-// getComparator returns the comparator if it's previously set,
-// or else it returns a default comparator.
-func (a *SortedStrArray) getComparator() func(a, b string) int {
-	if a.comparator == nil {
-		return defaultComparatorStr
-	}
-	return a.comparator
+	a.lazyInit()
+	return a.SortedTArray.IsEmpty()
 }
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedStrArray) DeepCopy() any {
-	if a == nil {
-		return nil
+	a.lazyInit()
+	return &SortedStrArray{
+		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[string]),
 	}
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	newSlice := make([]string, len(a.array))
-	copy(newSlice, a.array)
-	return NewSortedStrArrayFrom(newSlice, a.mu.IsSafe())
 }

container/garray/garray_sorted_t.go

@@ -0,0 +1,852 @@
+// 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 garray
+
+import (
+	"bytes"
+	"math"
+
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/grand"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+// SortedTArray is a golang sorted array with rich features.
+// It is using increasing order in default, which can be changed by
+// setting it a custom comparator.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
+type SortedTArray[T comparable] struct {
+	mu         rwmutex.RWMutex
+	array      []T
+	unique     bool             // Whether enable unique feature(false)
+	comparator func(a, b T) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
+	sorter     func(values []T, comparator func(a, b T) int)
+}
+
+// NewSortedTArray creates and returns an empty sorted array.
+// The parameter `safe` is used to specify whether using array in concurrent-safety, which is false in default.
+// The parameter `comparator` used to compare values to sort in array,
+// if it returns value < 0, means `a` < `b`; the `a` will be inserted before `b`;
+// if it returns value = 0, means `a` = `b`; the `a` will be replaced by     `b`;
+// if it returns value > 0, means `a` > `b`; the `a` will be inserted after  `b`;
+func NewSortedTArray[T comparable](comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	return NewSortedTArraySize(0, comparator, safe...)
+}
+
+// NewSortedTArraySize create and returns an sorted array with given size and cap.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArraySize[T comparable](cap int, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	return &SortedTArray[T]{
+		mu:         rwmutex.Create(safe...),
+		array:      make([]T, 0, cap),
+		comparator: comparator,
+		sorter:     nil,
+	}
+}
+
+// NewSortedTArrayFrom creates and returns an sorted array with given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArrayFrom[T comparable](array []T, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	a := NewSortedTArraySize(0, comparator, safe...)
+	a.array = array
+	a.getSorter()(a.array, a.getComparator())
+	return a
+}
+
+// NewSortedTArrayFromCopy creates and returns an sorted array from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using array in concurrent-safety,
+// which is false in default.
+func NewSortedTArrayFromCopy[T comparable](array []T, comparator func(a, b T) int, safe ...bool) *SortedTArray[T] {
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	newArray := make([]T, len(array))
+	copy(newArray, array)
+	return NewSortedTArrayFrom(newArray, comparator, safe...)
+}
+
+func (a *SortedTArray[T]) getSorter() func(values []T, comparator func(a, b T) int) {
+	if a.sorter == nil {
+		return defaultSorter
+	} else {
+		return a.sorter
+	}
+}
+
+// At returns the value by the specified index.
+// If the given `index` is out of range of the array, it returns the zero value of type `T`
+func (a *SortedTArray[T]) At(index int) (value T) {
+	value, _ = a.Get(index)
+	return
+}
+
+// SetArray sets the underlying slice array with the given `array`.
+func (a *SortedTArray[T]) SetArray(array []T) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	a.getSorter()(a.array, a.getComparator())
+
+	return a
+}
+
+// SetSorter sets/changes the sorter for sorting.
+func (a *SortedTArray[T]) SetSorter(sorter func(values []T, comparator func(a, b T) int)) {
+	if sorter == nil {
+		a.sorter = defaultSorter
+	} else {
+		a.sorter = sorter
+	}
+	a.sorter(a.array, a.getComparator())
+}
+
+// SetComparator sets/changes the comparator for sorting.
+// It resorts the array as the comparator is changed.
+func (a *SortedTArray[T]) SetComparator(comparator func(a, b T) int) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if comparator == nil {
+		comparator = gutil.ComparatorTStr
+	}
+	a.comparator = comparator
+	a.getSorter()(a.array, comparator)
+}
+
+// Sort sorts the array in increasing order.
+// The parameter `reverse` controls whether sort
+// in increasing order(default) or decreasing order
+func (a *SortedTArray[T]) Sort() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	a.getSorter()(a.array, a.getComparator())
+
+	return a
+}
+
+// Add adds one or multiple values to sorted array, the array always keeps sorted.
+// It's alias of function Append, see Append.
+func (a *SortedTArray[T]) Add(values ...T) *SortedTArray[T] {
+	return a.Append(values...)
+}
+
+// Append adds one or multiple values to sorted array, the array always keeps sorted.
+func (a *SortedTArray[T]) Append(values ...T) *SortedTArray[T] {
+	if len(values) == 0 {
+		return a
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		index, cmp := a.binSearch(value, false)
+		if a.unique && cmp == 0 {
+			continue
+		}
+		if index < 0 {
+			a.array = append(a.array, value)
+			continue
+		}
+		if cmp > 0 {
+			index++
+		}
+		a.array = append(a.array[:index], append([]T{value}, a.array[index:]...)...)
+	}
+	return a
+}
+
+// Get returns the value by the specified index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *SortedTArray[T]) Get(index int) (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	return a.array[index], true
+}
+
+// Remove removes an item by index.
+// If the given `index` is out of range of the array, the `found` is false.
+func (a *SortedTArray[T]) Remove(index int) (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(index)
+}
+
+// doRemoveWithoutLock removes an item by index without lock.
+func (a *SortedTArray[T]) doRemoveWithoutLock(index int) (value T, found bool) {
+	if index < 0 || index >= len(a.array) {
+		found = false
+		return
+	}
+	// Determine array boundaries when deleting to improve deletion efficiency.
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value, true
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value, true
+	}
+	// If it is a non-boundary delete,
+	// it will involve the creation of an array,
+	// then the deletion is less efficient.
+	value = a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value, true
+}
+
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *SortedTArray[T]) RemoveValue(value T) bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if i, r := a.binSearch(value, false); r == 0 {
+		_, res := a.doRemoveWithoutLock(i)
+		return res
+	}
+	return false
+}
+
+// RemoveValues removes an item by `values`.
+func (a *SortedTArray[T]) RemoveValues(values ...T) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		if i, r := a.binSearch(value, false); r == 0 {
+			a.doRemoveWithoutLock(i)
+		}
+	}
+}
+
+// PopLeft pops and returns an item from the beginning of array.
+// Note that if the array is empty, the `found` is false.
+func (a *SortedTArray[T]) PopLeft() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	value = a.array[0]
+	a.array = a.array[1:]
+	return value, true
+}
+
+// PopRight pops and returns an item from the end of array.
+// Note that if the array is empty, the `found` is false.
+func (a *SortedTArray[T]) PopRight() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	if index < 0 {
+		found = false
+		return
+	}
+	value = a.array[index]
+	a.array = a.array[:index]
+	return value, true
+}
+
+// PopRand randomly pops and return an item out of array.
+// Note that if the array is empty, the `found` is false.
+func (a *SortedTArray[T]) PopRand() (value T, found bool) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+}
+
+// PopRands randomly pops and returns `size` items out of array.
+func (a *SortedTArray[T]) PopRands(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i], _ = a.doRemoveWithoutLock(grand.Intn(len(a.array)))
+	}
+	return array
+}
+
+// PopLefts pops and returns `size` items from the beginning of array.
+func (a *SortedTArray[T]) PopLefts(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	if size >= len(a.array) {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[0:size]
+	a.array = a.array[size:]
+	return value
+}
+
+// PopRights pops and returns `size` items from the end of array.
+func (a *SortedTArray[T]) PopRights(size int) []T {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	index := len(a.array) - size
+	if index <= 0 {
+		array := a.array
+		a.array = a.array[:0]
+		return array
+	}
+	value := a.array[index:]
+	a.array = a.array[:index]
+	return value
+}
+
+// Range picks and returns items by range, like array[start:end].
+// Notice, if in concurrent-safe usage, it returns a copy of slice;
+// else a pointer to the underlying data.
+//
+// If `end` is negative, then the offset will start from the end of array.
+// If `end` is omitted, then the sequence will have everything from start up
+// until the end of the array.
+func (a *SortedTArray[T]) Range(start int, end ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]T)(nil)
+	if a.mu.IsSafe() {
+		array = make([]T, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// SubSlice returns a slice of elements from the array as specified
+// by the `offset` and `size` parameters.
+// If in concurrent safe usage, it returns a copy of the slice; else a pointer.
+//
+// If offset is non-negative, the sequence will start at that offset in the array.
+// If offset is negative, the sequence will start that far from the end of the array.
+//
+// If length is given and is positive, then the sequence will have up to that many elements in it.
+// If the array is shorter than the length, then only the available array elements will be present.
+// If length is given and is negative then the sequence will stop that many elements from the end of the array.
+// If it is omitted, then the sequence will have everything from offset up until the end of the array.
+//
+// Any possibility crossing the left border of array, it will fail.
+func (a *SortedTArray[T]) SubSlice(offset int, length ...int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]T, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
+}
+
+// Sum returns the sum of values in an array.
+func (a *SortedTArray[T]) Sum() (sum int) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += gconv.Int(v)
+	}
+	return
+}
+
+// Len returns the length of array.
+func (a *SortedTArray[T]) Len() int {
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
+}
+
+// Slice returns the underlying data of array.
+// Note that, if it's in concurrent-safe usage, it returns a copy of underlying data,
+// or else a pointer to the underlying data.
+func (a *SortedTArray[T]) Slice() []T {
+	var array []T
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array = make([]T, len(a.array))
+		copy(array, a.array)
+	} else {
+		array = a.array
+	}
+	return array
+}
+
+// Interfaces returns current array as []any.
+func (a *SortedTArray[T]) Interfaces() []any {
+	return tToAnySlice(a.Slice())
+}
+
+// Contains checks whether a value exists in the array.
+func (a *SortedTArray[T]) Contains(value T) bool {
+	return a.Search(value) != -1
+}
+
+// Search searches array by `value`, returns the index of `value`,
+// or returns -1 if not exists.
+func (a *SortedTArray[T]) Search(value T) (index int) {
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
+}
+
+// Binary search.
+// It returns the last compared index and the result.
+// If `result` equals to 0, it means the value at `index` is equals to `value`.
+// If `result` lesser than 0, it means the value at `index` is lesser than `value`.
+// If `result` greater than 0, it means the value at `index` is greater than `value`.
+func (a *SortedTArray[T]) binSearch(value T, lock bool) (index int, result int) {
+	if lock {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+	}
+	if len(a.array) == 0 {
+		return -1, -2
+	}
+	min := 0
+	max := len(a.array) - 1
+	mid := 0
+	cmp := -2
+	for min <= max {
+		mid = min + (max-min)/2
+		cmp = a.getComparator()(value, a.array[mid])
+		switch {
+		case cmp < 0:
+			max = mid - 1
+		case cmp > 0:
+			min = mid + 1
+		default:
+			return mid, cmp
+		}
+	}
+	return mid, cmp
+}
+
+// SetUnique sets unique mark to the array,
+// which means it does not contain any repeated items.
+// It also does unique check, remove all repeated items.
+func (a *SortedTArray[T]) SetUnique(unique bool) *SortedTArray[T] {
+	oldUnique := a.unique
+	a.unique = unique
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
+	return a
+}
+
+// Unique uniques the array, clear repeated items.
+func (a *SortedTArray[T]) Unique() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	for i := 0; i < len(a.array)-1; {
+		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+2:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Clone returns a new array, which is a copy of current array.
+func (a *SortedTArray[T]) Clone() (newArray *SortedTArray[T]) {
+	a.mu.RLock()
+	array := make([]T, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedTArrayFrom[T](array, a.comparator, a.mu.IsSafe())
+}
+
+// Clear deletes all items of current array.
+func (a *SortedTArray[T]) Clear() *SortedTArray[T] {
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]T, 0)
+	}
+	a.mu.Unlock()
+	return a
+}
+
+// LockFunc locks writing by callback function `f`.
+func (a *SortedTArray[T]) LockFunc(f func(array []T)) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+
+	// Keep the array always sorted.
+	defer a.getSorter()(a.array, a.getComparator())
+
+	f(a.array)
+	return a
+}
+
+// RLockFunc locks reading by callback function `f`.
+func (a *SortedTArray[T]) RLockFunc(f func(array []T)) *SortedTArray[T] {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
+}
+
+// Merge merges `array` into current array.
+// The parameter `array` can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *SortedTArray[T]) Merge(array any) *SortedTArray[T] {
+	var vals []T
+	switch v := array.(type) {
+	case *SortedTArray[T]:
+		vals = v.Slice()
+	case *TArray[T]:
+		vals = v.Slice()
+	case []T:
+		vals = v
+	default:
+		interfaces := gconv.Interfaces(v)
+		if err := gconv.Scan(interfaces, &vals); err != nil {
+			panic(err)
+		}
+	}
+
+	return a.Add(vals...)
+}
+
+// Chunk splits an array into multiple arrays,
+// the size of each array is determined by `size`.
+// The last chunk may contain less than size elements.
+func (a *SortedTArray[T]) Chunk(size int) [][]T {
+	if size < 1 {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	length := len(a.array)
+	chunks := int(math.Ceil(float64(length) / float64(size)))
+	var n [][]T
+	for i, end := 0, 0; chunks > 0; chunks-- {
+		end = (i + 1) * size
+		if end > length {
+			end = length
+		}
+		n = append(n, a.array[i*size:end])
+		i++
+	}
+	return n
+}
+
+// Rand randomly returns one item from array(no deleting).
+func (a *SortedTArray[T]) Rand() (value T, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		found = false
+		return
+	}
+	return a.array[grand.Intn(len(a.array))], true
+}
+
+// Rands randomly returns `size` items from array(no deleting).
+func (a *SortedTArray[T]) Rands(size int) []T {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	array := make([]T, size)
+	for i := 0; i < size; i++ {
+		array[i] = a.array[grand.Intn(len(a.array))]
+	}
+	return array
+}
+
+// Join joins array elements with a string `glue`.
+func (a *SortedTArray[T]) Join(glue string) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return ""
+	}
+	buffer := bytes.NewBuffer(nil)
+	for k, v := range a.array {
+		buffer.WriteString(gconv.String(v))
+		if k != len(a.array)-1 {
+			buffer.WriteString(glue)
+		}
+	}
+	return buffer.String()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *SortedTArray[T]) CountValues() map[T]int {
+	m := make(map[T]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// Iterator is alias of IteratorAsc.
+func (a *SortedTArray[T]) Iterator(f func(k int, v T) bool) {
+	a.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the array readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *SortedTArray[T]) IteratorAsc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for k, v := range a.array {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// IteratorDesc iterates the array readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (a *SortedTArray[T]) IteratorDesc(f func(k int, v T) bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for i := len(a.array) - 1; i >= 0; i-- {
+		if !f(i, a.array[i]) {
+			break
+		}
+	}
+}
+
+// String returns current array as a string, which implements like json.Marshal does.
+func (a *SortedTArray[T]) String() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte('[')
+	s := ""
+	for k, v := range a.array {
+		s = gconv.String(v)
+		if gstr.IsNumeric(s) {
+			buffer.WriteString(s)
+		} else {
+			buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
+		}
+		if k != len(a.array)-1 {
+			buffer.WriteByte(',')
+		}
+	}
+	buffer.WriteByte(']')
+	return buffer.String()
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+// Note that do not use pointer as its receiver here.
+func (a SortedTArray[T]) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+// Note that the comparator is set as string comparator in default.
+func (a *SortedTArray[T]) UnmarshalJSON(b []byte) error {
+	if a.comparator == nil {
+		a.array = make([]T, 0)
+		a.comparator = gutil.ComparatorTStr
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if err := json.UnmarshalUseNumber(b, &a.array); err != nil {
+		return err
+	}
+	if a.comparator != nil && a.array != nil {
+		a.getSorter()(a.array, a.comparator)
+	}
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+// Note that the comparator is set as string comparator in default.
+func (a *SortedTArray[T]) UnmarshalValue(value any) (err error) {
+	if a.comparator == nil {
+		a.comparator = gutil.ComparatorTStr
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		err = json.UnmarshalUseNumber(gconv.Bytes(value), &a.array)
+	default:
+		if err = gconv.Scan(value, &a.array); err != nil {
+			return
+		}
+	}
+	if a.comparator != nil && a.array != nil {
+		a.getSorter()(a.array, a.comparator)
+	}
+	return err
+}
+
+// FilterNil removes all nil value of the array.
+func (a *SortedTArray[T]) FilterNil() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Filter iterates array and filters elements using custom callback function.
+// It removes the element from array if callback function `filter` returns true,
+// it or else does nothing and continues iterating.
+func (a *SortedTArray[T]) Filter(filter func(index int, value T) bool) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if filter(i, a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// FilterEmpty removes all empty value of the array.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
+func (a *SortedTArray[T]) FilterEmpty() *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// Walk applies a user supplied function `f` to every item of array.
+func (a *SortedTArray[T]) Walk(f func(value T) T) *SortedTArray[T] {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	// Keep the array always sorted.
+	defer a.getSorter()(a.array, a.getComparator())
+
+	for i, v := range a.array {
+		a.array[i] = f(v)
+	}
+	return a
+}
+
+// IsEmpty checks whether the array is empty.
+func (a *SortedTArray[T]) IsEmpty() bool {
+	return a.Len() == 0
+}
+
+// getComparator returns the comparator if it's previously set,
+// or else it panics.
+func (a *SortedTArray[T]) getComparator() func(a, b T) int {
+	if a.comparator == nil {
+		a.comparator = gutil.ComparatorTStr
+	}
+	return a.comparator
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (a *SortedTArray[T]) DeepCopy() any {
+	if a == nil {
+		return nil
+	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]T, len(a.array))
+	for i, v := range a.array {
+		newSlice[i], _ = deepcopy.Copy(v).(T)
+	}
+	return NewSortedTArrayFrom[T](newSlice, a.comparator, a.mu.IsSafe())
+}

container/garray/garray_z_example_sorted_str_test.go

@@ -381,7 +381,7 @@ func ExampleSortedStrArray_LockFunc() {
 	fmt.Println(s)
 
 	// Output:
-	// ["a","b","GF fans"]
+	// ["GF fans","a","b"]
 }
 
 func ExampleSortedStrArray_RLockFunc() {

container/garray/garray_z_example_sorted_t_test.go

@@ -0,0 +1,576 @@
+// 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 garray_test
+
+import (
+	"fmt"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+func ExampleSortedTArray_Walk() {
+	var array garray.SortedTArray[string]
+	array.SetComparator(gutil.ComparatorT)
+	tables := g.SliceStr{"user", "user_detail"}
+	prefix := "gf_"
+	array.Append(tables...)
+	// Add prefix for given table names.
+	array.Walk(func(value string) string {
+		return prefix + value
+	})
+	fmt.Println(array.Slice())
+
+	// Output:
+	// [gf_user gf_user_detail]
+}
+
+func ExampleNewSortedTArray() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.Append("b")
+	s.Append("d")
+	s.Append("c")
+	s.Append("a")
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleNewSortedTArraySize() {
+	s := garray.NewSortedTArraySize[string](3, gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c"})
+	fmt.Println(s.Slice(), s.Len(), cap(s.Slice()))
+
+	// Output:
+	// [a b c d] 4 4
+}
+
+func ExampleNewSortedTArrayFromCopy() {
+	s := garray.NewSortedTArrayFromCopy(g.SliceStr{"b", "d", "c", "a"}, gutil.ComparatorT)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleSortedTArray_At() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "d", "c", "a"}, gutil.ComparatorT)
+	sAt := s.At(2)
+	fmt.Println(s)
+	fmt.Println(sAt)
+
+	// Output:
+	// ["a","b","c","d"]
+	// c
+
+}
+
+func ExampleSortedTArray_Get() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "d", "c", "a", "e"}, gutil.ComparatorT)
+	sGet, sBool := s.Get(3)
+	fmt.Println(s)
+	fmt.Println(sGet, sBool)
+
+	// Output:
+	// ["a","b","c","d","e"]
+	// d true
+}
+
+func ExampleSortedTArray_SetArray() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c"})
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+}
+
+func ExampleSortedTArray_SetUnique() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"b", "d", "a", "c", "c", "a"})
+	fmt.Println(s.SetUnique(true))
+
+	// Output:
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Sum() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray([]string{"5", "3", "2"})
+	fmt.Println(s)
+	a := s.Sum()
+	fmt.Println(a)
+
+	// Output:
+	// [2,3,5]
+	// 10
+}
+
+func ExampleSortedTArray_Sort() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "a", "c"})
+	fmt.Println(s)
+	a := s.Sort()
+	fmt.Println(a)
+
+	// Output:
+	// ["a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Remove() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	s.Remove(1)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// [a c d]
+}
+
+func ExampleSortedTArray_RemoveValue() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	s.RemoveValue("b")
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// [a c d]
+}
+
+func ExampleSortedTArray_PopLeft() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	r, _ := s.PopLeft()
+	fmt.Println(r)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// a
+	// [b c d]
+}
+
+func ExampleSortedTArray_PopRight() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s.Slice())
+	r, _ := s.PopRight()
+	fmt.Println(r)
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d]
+	// d
+	// [a b c]
+}
+
+func ExampleSortedTArray_PopRights() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopRights(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// [g h]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleSortedTArray_Rand() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r, _ := s.PopRand()
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// May Output:
+	// b
+	// ["a","c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_PopRands() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopRands(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// May Output:
+	// [d a]
+	// ["b","c","e","f","g","h"]
+}
+
+func ExampleSortedTArray_PopLefts() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.PopLefts(2)
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// [a b]
+	// ["c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_Range() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Range(2, 5)
+	fmt.Println(r)
+
+	// Output:
+	// [c d e]
+}
+
+func ExampleSortedTArray_SubSlice() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.SubSlice(3, 4)
+	fmt.Println(s.Slice())
+	fmt.Println(r)
+
+	// Output:
+	// [a b c d e f g h]
+	// [d e f g]
+}
+
+func ExampleSortedTArray_Add() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.Add("b", "d", "c", "a")
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_Append() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"b", "d", "c", "a"})
+	fmt.Println(s)
+	s.Append("f", "e", "g")
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d"]
+	// ["a","b","c","d","e","f","g"]
+}
+
+func ExampleSortedTArray_Len() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Len())
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// 8
+}
+
+func ExampleSortedTArray_Slice() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s.Slice())
+
+	// Output:
+	// [a b c d e f g h]
+}
+
+func ExampleSortedTArray_Interfaces() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Interfaces()
+	fmt.Println(r)
+
+	// Output:
+	// [a b c d e f g h]
+}
+
+func ExampleSortedTArray_Clone() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	r := s.Clone()
+	fmt.Println(r)
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// ["a","b","c","d","e","f","g","h"]
+}
+
+func ExampleSortedTArray_Clear() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Clear())
+	fmt.Println(s)
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// []
+	// []
+}
+
+func ExampleSortedTArray_Contains() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s.Contains("e"))
+	fmt.Println(s.Contains("E"))
+	fmt.Println(s.Contains("z"))
+
+	// Output:
+	// true
+	// false
+	// false
+}
+
+func ExampleSortedTArray_Search() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"})
+	fmt.Println(s)
+	fmt.Println(s.Search("e"))
+	fmt.Println(s.Search("E"))
+	fmt.Println(s.Search("z"))
+
+	// Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// 4
+	// -1
+	// -1
+}
+
+func ExampleSortedTArray_Unique() {
+	s := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s.SetArray(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"})
+	fmt.Println(s)
+	fmt.Println(s.Unique())
+
+	// Output:
+	// ["a","b","c","c","c","d","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_LockFunc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.LockFunc(func(array []string) {
+		array[len(array)-1] = "GF fans"
+	})
+	fmt.Println(s)
+
+	// Output:
+	// ["GF fans","a","b"]
+}
+
+func ExampleSortedTArray_RLockFunc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.RLockFunc(func(array []string) {
+		array[len(array)-1] = "GF fans"
+		fmt.Println(array[len(array)-1])
+	})
+	fmt.Println(s)
+
+	// Output:
+	// GF fans
+	// ["a","b","GF fans"]
+}
+
+func ExampleSortedTArray_Merge() {
+	s1 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s2 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	s1.SetArray(g.SliceStr{"b", "c", "a"})
+	s2.SetArray(g.SliceStr{"e", "d", "f"})
+	fmt.Println(s1)
+	fmt.Println(s2)
+	s1.Merge(s2)
+	fmt.Println(s1)
+
+	// Output:
+	// ["a","b","c"]
+	// ["d","e","f"]
+	// ["a","b","c","d","e","f"]
+}
+
+func ExampleSortedTArray_Chunk() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	r := s.Chunk(3)
+	fmt.Println(r)
+
+	// Output:
+	// [[a b c] [d e f] [g h]]
+}
+
+func ExampleSortedTArray_Rands() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	fmt.Println(s)
+	fmt.Println(s.Rands(3))
+
+	// May Output:
+	// ["a","b","c","d","e","f","g","h"]
+	// [h g c]
+}
+
+func ExampleSortedTArray_Join() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"c", "b", "a", "d", "f", "e", "h", "g"}, gutil.ComparatorT)
+	fmt.Println(s.Join(","))
+
+	// Output:
+	// a,b,c,d,e,f,g,h
+}
+
+func ExampleSortedTArray_CountValues() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"a", "b", "c", "c", "c", "d", "d"}, gutil.ComparatorT)
+	fmt.Println(s.CountValues())
+
+	// Output:
+	// map[a:1 b:1 c:3 d:2]
+}
+
+func ExampleSortedTArray_Iterator() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.Iterator(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleSortedTArray_IteratorAsc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.IteratorAsc(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 0 a
+	// 1 b
+	// 2 c
+}
+
+func ExampleSortedTArray_IteratorDesc() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s.IteratorDesc(func(k int, v string) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 2 c
+	// 1 b
+	// 0 a
+}
+
+func ExampleSortedTArray_String() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	fmt.Println(s.String())
+
+	// Output:
+	// ["a","b","c"]
+}
+
+func ExampleSortedTArray_MarshalJSON() {
+	type Student struct {
+		ID     int
+		Name   string
+		Levels garray.SortedTArray[string]
+	}
+	r := garray.NewSortedTArrayFrom(g.SliceStr{"b", "c", "a"}, gutil.ComparatorT)
+	s := Student{
+		ID:     1,
+		Name:   "john",
+		Levels: *r,
+	}
+	b, _ := json.Marshal(s)
+	fmt.Println(string(b))
+
+	// Output:
+	// {"ID":1,"Name":"john","Levels":["a","b","c"]}
+}
+
+func ExampleSortedTArray_UnmarshalJSON() {
+	b := []byte(`{"Id":1,"Name":"john","Lessons":["Math","English","Sport"]}`)
+	type Student struct {
+		Id      int
+		Name    string
+		Lessons *garray.StrArray
+	}
+	s := Student{}
+	json.Unmarshal(b, &s)
+	fmt.Println(s)
+
+	// Output:
+	// {1 john ["Math","English","Sport"]}
+}
+
+func ExampleSortedTArray_UnmarshalValue() {
+	type Student struct {
+		Name    string
+		Lessons *garray.StrArray
+	}
+	var s *Student
+	gconv.Struct(g.Map{
+		"name":    "john",
+		"lessons": []byte(`["Math","English","Sport"]`),
+	}, &s)
+	fmt.Println(s)
+
+	var s1 *Student
+	gconv.Struct(g.Map{
+		"name":    "john",
+		"lessons": g.SliceStr{"Math", "English", "Sport"},
+	}, &s1)
+	fmt.Println(s1)
+
+	// Output:
+	// &{john ["Math","English","Sport"]}
+	// &{john ["Math","English","Sport"]}
+}
+
+func ExampleSortedTArray_Filter() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	fmt.Println(s)
+	fmt.Println(s.Filter(func(index int, value string) bool {
+		return empty.IsEmpty(value)
+	}))
+
+	// Output:
+	// ["","","","a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_FilterEmpty() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	fmt.Println(s)
+	fmt.Println(s.FilterEmpty())
+
+	// Output:
+	// ["","","","a","b","c","d"]
+	// ["a","b","c","d"]
+}
+
+func ExampleSortedTArray_IsEmpty() {
+	s := garray.NewSortedTArrayFrom(g.SliceStr{"b", "a", "", "c", "", "", "d"}, gutil.ComparatorT)
+	fmt.Println(s.IsEmpty())
+	s1 := garray.NewSortedTArray[string](gutil.ComparatorT)
+	fmt.Println(s1.IsEmpty())
+
+	// Output:
+	// false
+	// true
+}

container/garray/garray_z_unit_normal_t_test.go

@@ -0,0 +1,856 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func Test_TArray_Basic(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewTArrayFrom(expect)
+		array2 := garray.NewTArrayFrom(expect)
+		array3 := garray.NewTArrayFrom([]int{})
+
+		t.Assert(array.Slice(), expect)
+		t.Assert(array.Interfaces(), expect)
+		err := array.Set(0, 100) // 100, 1, 2, 3
+		t.AssertNil(err)
+
+		err = array.Set(100, 100)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.IsEmpty(), false)
+
+		copyArray := array.DeepCopy()
+		ca := copyArray.(*garray.TArray[int])
+		ca.Set(0, 1)
+		cval, _ := ca.Get(0)
+		val, _ := array.Get(0)
+		t.AssertNE(cval, val)
+
+		v, ok := array.Get(0)
+		t.Assert(v, 100)
+		t.Assert(ok, true)
+
+		v, ok = array.Get(1)
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+
+		v, ok = array.Get(4)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+
+		t.Assert(array.Search(100), 0)
+		t.Assert(array3.Search(100), -1)
+		t.Assert(array.Contains(100), true)
+
+		v, ok = array.Remove(0) // 1, 2, 3
+		t.Assert(v, 100)
+		t.Assert(ok, true)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array.Remove(-1)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array.Remove(100000)
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.Slice(), []int{1, 2, 3})
+
+		v, ok = array2.Remove(3) // 0 1 2
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+
+		v, ok = array2.Remove(1) // 0 2
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+
+		t.Assert(array.Contains(100), false)
+		array.Append(4) // 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{2, 2, 3, 4})
+		t.Assert(array.Len(), 4)
+		array.InsertBefore(0, 100) // 100, 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{100, 2, 2, 3, 4})
+		array.InsertAfter(0, 200) // 100, 200, 2, 2, 3, 4
+		t.Assert(array.Slice(), []int{100, 200, 2, 2, 3, 4})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		t.Assert(array.Slice(), []int{100, 200, 2, 2, 3, 300, 4, 400})
+		t.Assert(array.Clear().Len(), 0)
+		err = array.InsertBefore(99, 9900)
+		t.AssertNE(err, nil)
+		err = array.InsertAfter(99, 9900)
+		t.AssertNE(err, nil)
+
+		t.Assert(array.String(), "[]")
+	})
+}
+
+func TestTArray_Sort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect1 := []any{0, 1, 2, 3}
+		expect2 := []any{3, 2, 1, 0}
+		array := garray.NewTArray[int]()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.SortFunc(func(v1, v2 int) bool {
+			return v1 < v2
+		})
+		t.Assert(array.Slice(), expect1)
+		array.SortFunc(func(v1, v2 int) bool {
+			return v1 > v2
+		})
+		t.Assert(array.Slice(), expect2)
+	})
+}
+
+func TestTArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []int{1, 2, 3, 4, 5})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		expect := []int{}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Unique().Slice(), []int{})
+	})
+}
+
+func TestTArray_PushAndPop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		expect := []any{0, 1, 2, 3}
+		array := garray.NewTArrayFrom(expect)
+		t.Assert(array.Slice(), expect)
+
+		v, ok := array.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, true)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+
+		v, ok = array.PopRand()
+		t.AssertIN(v, []any{1, 2})
+		t.Assert(ok, true)
+
+		v, ok = array.PopRand()
+		t.AssertIN(v, []any{1, 2})
+		t.Assert(ok, true)
+
+		t.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		t.Assert(array.Slice(), []any{1, 2})
+	})
+}
+
+func TestTArray_PopRands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{100, 200, 300, 400, 500, 600}
+		array := garray.NewFromCopy(a1)
+		t.AssertIN(array.PopRands(2), []any{100, 200, 300, 400, 500, 600})
+	})
+}
+
+func TestTArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopLefts(2), g.Slice{1, 2})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{3})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopRights(2), g.Slice{2, 3})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{1})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestTArray_PopLeftsAndPopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.New()
+		v, ok := array.PopLeft()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopLefts(10), nil)
+
+		v, ok = array.PopRight()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopRights(10), nil)
+
+		v, ok = array.PopRand()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+		t.Assert(array.PopRands(10), nil)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		value1 := []any{0, 1, 2, 3, 4, 5, 6}
+		value2 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(value1)
+		array2 := garray.NewTArrayFrom(value2)
+		t.Assert(array1.PopLefts(2), []any{0, 1})
+		t.Assert(array1.Slice(), []any{2, 3, 4, 5, 6})
+		t.Assert(array1.PopRights(2), []any{5, 6})
+		t.Assert(array1.Slice(), []any{2, 3, 4})
+		t.Assert(array1.PopRights(20), []any{2, 3, 4})
+		t.Assert(array1.Slice(), []any{})
+		t.Assert(array2.PopLefts(20), []any{0, 1, 2, 3, 4, 5, 6})
+		t.Assert(array2.Slice(), []any{})
+	})
+}
+
+func TestTArray_Range(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		value1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(value1)
+		array2 := garray.NewTArrayFrom(value1, true)
+		t.Assert(array1.Range(0, 1), []any{0})
+		t.Assert(array1.Range(1, 2), []any{1})
+		t.Assert(array1.Range(0, 2), []any{0, 1})
+		t.Assert(array1.Range(-1, 10), value1)
+		t.Assert(array1.Range(10, 2), nil)
+		t.Assert(array2.Range(1, 3), []any{1, 2})
+	})
+}
+
+func TestTArray_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		func1 := func(v1, v2 any) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		i1 := []any{0, 1, 2, 3}
+		i2 := []any{4, 5, 6, 7}
+		array1 := garray.NewTArrayFrom(i1)
+		array2 := garray.NewTArrayFrom(i2)
+		t.Assert(array1.Merge(array2).Slice(), []any{0, 1, 2, 3, 4, 5, 6, 7})
+
+		// s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i3 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i4 := garray.NewTArrayFrom([]any{3})
+		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s5 := garray.NewSortedStrArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewTArrayFrom(i1)
+
+		t.Assert(a1.Merge(s2).Len(), 6)
+		t.Assert(a1.Merge(i3).Len(), 9)
+		t.Assert(a1.Merge(i4).Len(), 10)
+		t.Assert(a1.Merge(s3).Len(), 12)
+		t.Assert(a1.Merge(s4).Len(), 14)
+		t.Assert(a1.Merge(s5).Len(), 16)
+		t.Assert(a1.Merge(s6).Len(), 19)
+	})
+}
+
+func TestTArray_Fill(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0}
+		a2 := []any{0}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a2, true)
+
+		t.Assert(array1.Fill(1, 2, 100), nil)
+		t.Assert(array1.Slice(), []any{0, 100, 100})
+
+		t.Assert(array2.Fill(0, 2, 100), nil)
+		t.Assert(array2.Slice(), []any{100, 100})
+
+		t.AssertNE(array2.Fill(-1, 2, 100), nil)
+		t.Assert(array2.Slice(), []any{100, 100})
+	})
+}
+
+func TestTArray_Chunk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []any{1, 2})
+		t.Assert(chunks[1], []any{3, 4})
+		t.Assert(chunks[2], []any{5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []any{1, 2, 3})
+		t.Assert(chunks[1], []any{4, 5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []any{1, 2})
+		t.Assert(chunks[1], []any{3, 4})
+		t.Assert(chunks[2], []any{5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []any{1, 2, 3})
+		t.Assert(chunks[1], []any{4, 5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+}
+
+func TestTArray_Pad(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Pad(3, 1).Slice(), []any{0, 1, 1})
+		t.Assert(array1.Pad(-4, 1).Slice(), []any{1, 0, 1, 1})
+		t.Assert(array1.Pad(3, 1).Slice(), []any{1, 0, 1, 1})
+	})
+}
+
+func TestTArray_SubSlice(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a1, true)
+		t.Assert(array1.SubSlice(0, 2), []any{0, 1})
+		t.Assert(array1.SubSlice(2, 2), []any{2, 3})
+		t.Assert(array1.SubSlice(5, 8), []any{5, 6})
+		t.Assert(array1.SubSlice(9, 1), nil)
+		t.Assert(array1.SubSlice(-2, 2), []any{5, 6})
+		t.Assert(array1.SubSlice(-9, 2), nil)
+		t.Assert(array1.SubSlice(1, -2), nil)
+		t.Assert(array2.SubSlice(0, 2), []any{0, 1})
+	})
+}
+
+func TestTArray_Rand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(len(array1.Rands(2)), 2)
+		t.Assert(len(array1.Rands(10)), 10)
+		t.AssertIN(array1.Rands(1)[0], a1)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1)
+		i1, ok := a1.Rand()
+		t.Assert(ok, true)
+		t.Assert(a1.Contains(i1), true)
+		t.Assert(a1.Len(), 4)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		rand, found := array1.Rand()
+		t.AssertNil(rand)
+		t.Assert(found, false)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		rand := array1.Rands(1)
+		t.AssertNil(rand)
+	})
+}
+
+func TestTArray_Shuffle(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Shuffle().Len(), 7)
+	})
+}
+
+func TestTArray_Reverse(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Reverse().Slice(), []any{6, 5, 4, 3, 2, 1, 0})
+	})
+}
+
+func TestTArray_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Join("."), `0.1.2.3.4.5.6`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, `"a"`, `\a`}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.Join("."), `0.1."a".\a`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(len(array1.Join(".")), 0)
+	})
+}
+
+func TestTArray_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewTArrayFrom(a1)
+		t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
+		array1 = nil
+		t.Assert(array1.String(), "")
+	})
+}
+
+func TestTArray_Replace(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a2 := []any{"a", "b", "c"}
+		a3 := []any{"m", "n", "p", "z", "x", "y", "d", "u"}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.Replace(a2)
+		t.Assert(array2.Len(), 7)
+		t.Assert(array2.Contains("b"), true)
+		t.Assert(array2.Contains(4), true)
+		t.Assert(array2.Contains("v"), false)
+		array3 := array1.Replace(a3)
+		t.Assert(array3.Len(), 7)
+		t.Assert(array3.Contains(4), false)
+		t.Assert(array3.Contains("p"), true)
+		t.Assert(array3.Contains("u"), false)
+	})
+}
+
+func TestTArray_SetArray(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a2 := []any{"a", "b", "c"}
+
+		array1 := garray.NewTArrayFrom(a1)
+		array1 = array1.SetArray(a2)
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1.Contains("b"), true)
+		t.Assert(array1.Contains("5"), false)
+	})
+}
+
+func TestTArray_Sum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3}
+		a2 := []any{"a", "b", "c"}
+		a3 := []any{"a", "1", "2"}
+
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := garray.NewTArrayFrom(a2)
+		array3 := garray.NewTArrayFrom(a3)
+
+		t.Assert(array1.Sum(), 6)
+		t.Assert(array2.Sum(), 0)
+		t.Assert(array3.Sum(), 3)
+
+	})
+}
+
+func TestTArray_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{0, 1, 2, 3}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.Clone()
+
+		t.Assert(array1.Len(), 4)
+		t.Assert(array2.Sum(), 6)
+		t.AssertEQ(array1, array2)
+
+	})
+}
+
+func TestTArray_CountValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []any{"a", "b", "c", "d", "e", "d"}
+		array1 := garray.NewTArrayFrom(a1)
+		array2 := array1.CountValues()
+		t.Assert(len(array2), 5)
+		t.Assert(array2["b"], 1)
+		t.Assert(array2["d"], 2)
+	})
+}
+
+func TestTArray_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.LockFunc(func(n1 []any) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestTArray_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "c", "d"}
+		a1 := garray.NewTArrayFrom(s1, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		// go1
+		go a1.RLockFunc(func(n1 []any) { // read lock
+			time.Sleep(2 * time.Second) // sleep 2 s
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // wait go1 do line lock for 0.01s. Then do.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // wait for go1 done.
+
+		//  Prevent CI jitter, in milliseconds.
+		t.AssertLT(t2-t1, 20) // Go1 acquired a read lock, so when Go2 reads, it is not blocked.
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestTArray_Json(t *testing.T) {
+	// pointer
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "d", "c"}
+		a1 := garray.NewTArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.New()
+		err2 = json.UnmarshalUseNumber(b2, &a2)
+		t.Assert(err2, nil)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.Array
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+	})
+	// value.
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []any{"a", "b", "d", "c"}
+		a1 := *garray.NewTArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.New()
+		err2 = json.UnmarshalUseNumber(b2, &a2)
+		t.Assert(err2, nil)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.Array
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+	})
+	// pointer
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.Array
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+	// value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.Array
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+}
+
+func TestTArray_Iterator(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.Iterator(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorAsc(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorDesc(func(k int, v any) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.Iterator(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorAsc(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorDesc(func(k int, v any) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+}
+
+func TestTArray_RemoveValue(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(array.RemoveValue("e"), false)
+		t.Assert(array.RemoveValue("b"), true)
+		t.Assert(array.RemoveValue("a"), true)
+		t.Assert(array.RemoveValue("c"), true)
+		t.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestTArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewTArrayFrom(slice)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.Slice{"d"})
+	})
+}
+
+func TestTArray_UnmarshalValue(t *testing.T) {
+	type V struct {
+		Name  string
+		Array *garray.Array
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[1,2,3]`),
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{1, 2, 3},
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestTArray_FilterNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewTArrayFromCopy(values)
+		t.Assert(array.FilterNil().Slice(), values)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		t.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewTArrayFromCopy(values)
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsNil(value)
+		}).Slice(), values)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsNil(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{1, 2, 3, 4})
+
+		t.Assert(array.Filter(func(index int, value any) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{1, 2, 3, 4})
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestTArray_Walk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewTArrayFrom(g.Slice{"1", "2"})
+		t.Assert(array.Walk(func(value any) any {
+			return "key-" + gconv.String(value)
+		}), g.Slice{"key-1", "key-2"})
+	})
+}

container/garray/garray_z_unit_sorted_any_test.go

@@ -939,25 +939,30 @@ func TestSortedArray_Filter(t *testing.T) {
 
 func TestSortedArray_FilterNil(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		values := g.Slice{0, 1, 2, 3, 4, "", nil, g.Slice{}}
 		array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
 		t.Assert(array.FilterNil().Slice(), g.Slice{0, "", g.Slice{}, 1, 2, 3, 4})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil}, gutil.ComparatorInt)
+		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, nil, 3, 4, nil}, gutil.ComparatorInt)
 		t.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
 	})
 }
 
 func TestSortedArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
-		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 0, -1, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
+		t.Assert(array.FilterEmpty(), g.Slice{-1, 1, 2, 3, 4})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3, 4}, gutil.ComparatorInt)
 		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedArrayFrom(values, gutil.ComparatorString)
+		t.Assert(array.FilterEmpty().Slice(), g.Slice{-1, -2, 1, 2, 3, 4})
+	})
 }
 
 func TestSortedArray_Walk(t *testing.T) {

container/garray/garray_z_unit_sorted_int_test.go

@@ -794,8 +794,22 @@ func TestSortedIntArray_Filter(t *testing.T) {
 
 func TestSortedIntArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
-		t.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, -1, 2, 3, 4, 0})
+		t.Assert(array.FilterEmpty(), g.SliceInt{-1, 1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 0, 0, 0, 0, 0, 1})
+		array.SetComparator(func(a, b int) int {
+			if a == b {
+				return 0
+			}
+			if a < b {
+				return 1
+			} else {
+				return -1
+			}
+		})
+		t.Assert(array.FilterEmpty(), g.SliceInt{1})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3, 4})

container/garray/garray_z_unit_sorted_str_test.go

@@ -806,9 +806,23 @@ func TestSortedStrArray_Filter(t *testing.T) {
 
 func TestSortedStrArray_FilterEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "", "2", "0", ""})
 		t.Assert(array.FilterEmpty(), g.SliceStr{"0", "1", "2"})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "", "", "2", "0", "a", "b"})
+		array.SetComparator(func(a, b string) int {
+			if a == b {
+				return 0
+			}
+			if a < b {
+				return 1
+			} else {
+				return -1
+			}
+		})
+		t.Assert(array.FilterEmpty(), g.SliceStr{"b", "a", "2", "0"})
+	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2"})
 		t.Assert(array.FilterEmpty(), g.SliceStr{"1", "2"})

container/garray/garray_z_unit_sorted_t_test.go

@@ -0,0 +1,924 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
+)
+
+func TestSortedTArray_NewSortedTArrayFrom(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		a2 := []string{"h", "j", "i", "k"}
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(v1, v2)
+		}
+		func2 := func(v1, v2 string) int {
+			return -1
+		}
+		array1 := garray.NewSortedTArrayFrom(a1, func1)
+		array2 := garray.NewSortedTArrayFrom(a2, func2)
+
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+
+		t.Assert(array2.Len(), 4)
+		t.Assert(array2, []string{"k", "i", "j", "h"})
+	})
+}
+
+func TestNewSortedTArrayFromCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 string) int {
+			return -1
+		}
+		array1 := garray.NewSortedTArrayFromCopy(a1, func1)
+		array2 := garray.NewSortedTArrayFromCopy(a1, func2)
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+		t.Assert(array1.Len(), 3)
+		t.Assert(array2, []string{"c", "f", "a"})
+	})
+}
+
+func TestSortedTArray_SetArray(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		a2 := []string{"e", "h", "g", "k"}
+
+		func1 := func(v1, v2 string) int {
+			return strings.Compare(v1, v2)
+		}
+
+		array1 := garray.NewSortedTArrayFrom(a1, func1)
+		array1.SetArray(a2)
+		t.Assert(array1.Len(), 4)
+		t.Assert(array1, []string{"e", "g", "h", "k"})
+	})
+
+}
+
+func TestSortedTArray_Sort(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array1.Sort()
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"a", "c", "f"})
+	})
+
+}
+
+func TestSortedTArray_Get(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		v, ok := array1.Get(2)
+		t.Assert(v, "f")
+		t.Assert(ok, true)
+
+		v, ok = array1.Get(1)
+		t.Assert(v, "c")
+		t.Assert(ok, true)
+
+		v, ok = array1.Get(99)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+	})
+
+}
+
+func TestSortedTArray_At(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "f", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		v := array1.At(2)
+		t.Assert(v, "f")
+	})
+}
+
+func TestSortedTArray_Remove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1, ok := array1.Remove(1)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "b")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1.Contains("b"), false)
+
+		v, ok := array1.Remove(-1)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
+		v, ok = array1.Remove(100000)
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+
+		i2, ok := array1.Remove(0)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i2), "a")
+		t.Assert(array1.Len(), 2)
+		t.Assert(array1.Contains("a"), false)
+
+		i3, ok := array1.Remove(1)
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i3), "d")
+		t.Assert(array1.Len(), 1)
+		t.Assert(array1.Contains("d"), false)
+	})
+
+}
+
+func TestSortedTArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedTArrayFrom(
+			[]string{"a", "d", "c", "b"},
+			gutil.ComparatorT,
+		)
+		i1, ok := array1.PopLeft()
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "a")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []any{"b", "c", "d"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3}, gutil.ComparatorT)
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array1 := garray.NewSortedTArrayFrom(
+			[]string{"a", "d", "c", "b"},
+			gutil.ComparatorT,
+		)
+		i1, ok := array1.PopRight()
+		t.Assert(ok, true)
+		t.Assert(gconv.String(i1), "d")
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []any{"a", "b", "c"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3}, gutil.ComparatorT)
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1, ok := array1.PopRand()
+		t.Assert(ok, true)
+		t.AssertIN(i1, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 3)
+
+	})
+}
+
+func TestSortedTArray_PopRands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopRands(2)
+		t.Assert(len(i1), 2)
+		t.AssertIN(i1, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 2)
+
+		i2 := array1.PopRands(3)
+		t.Assert(len(i2), 2)
+		t.AssertIN(i2, []string{"a", "d", "c", "b"})
+		t.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedTArray_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArray[int](gutil.ComparatorT)
+		v, ok := array.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopLefts(10), nil)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopRights(10), nil)
+
+		v, ok = array.PopRand()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+		t.Assert(array.PopRands(10), nil)
+	})
+}
+
+func TestSortedTArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopLefts(2)
+		t.Assert(len(i1), 2)
+		t.AssertIN(i1, []string{"a", "d", "c", "b", "e", "f"})
+		t.Assert(array1.Len(), 4)
+
+		i2 := array1.PopLefts(5)
+		t.Assert(len(i2), 4)
+		t.AssertIN(i2, []string{"a", "d", "c", "b", "e", "f"})
+		t.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedTArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		i1 := array1.PopRights(2)
+		t.Assert(len(i1), 2)
+		t.Assert(i1, []string{"e", "f"})
+		t.Assert(array1.Len(), 4)
+
+		i2 := array1.PopRights(10)
+		t.Assert(len(i2), 4)
+		t.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedTArray_Range(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array2 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT, true)
+		i1 := array1.Range(2, 5)
+		t.Assert(i1, []string{"c", "d", "e"})
+		t.Assert(array1.Len(), 6)
+
+		i2 := array1.Range(7, 5)
+		t.Assert(len(i2), 0)
+		i2 = array1.Range(-1, 2)
+		t.Assert(i2, []string{"a", "b"})
+
+		i2 = array1.Range(4, 10)
+		t.Assert(len(i2), 2)
+		t.Assert(i2, []string{"e", "f"})
+
+		t.Assert(array2.Range(1, 3), []string{"b", "c"})
+
+	})
+}
+
+func TestSortedTArray_Sum(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+		a2 := []string{"1", "2", "3", "b", "e", "f"}
+		a3 := []string{"4", "5", "6"}
+		array1 := garray.NewSortedTArrayFrom(a1, gutil.ComparatorT)
+		array2 := garray.NewSortedTArrayFrom(a2, gutil.ComparatorT)
+		array3 := garray.NewSortedTArrayFrom(a3, gutil.ComparatorT)
+		t.Assert(array1.Sum(), 0)
+		t.Assert(array2.Sum(), 6)
+		t.Assert(array3.Sum(), 15)
+
+	})
+}
+
+func TestSortedTArray_Clone(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array2 := array1.Clone()
+		t.Assert(array1, array2)
+		array1.Remove(1)
+		t.AssertNE(array1, array2)
+
+	})
+}
+
+func TestSortedTArray_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e", "f"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Len(), 6)
+		array1.Clear()
+		t.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedTArray_Chunk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1 := array1.Chunk(2)
+		t.Assert(len(i1), 3)
+		t.Assert(i1[0], []any{"a", "b"})
+		t.Assert(i1[2], []any{"e"})
+
+		i1 = array1.Chunk(0)
+		t.Assert(len(i1), 0)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int32{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []int32{1, 2, 3})
+		t.Assert(chunks[1], []int32{4, 5})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(2)
+		t.Assert(len(chunks), 3)
+		t.Assert(chunks[0], []int{1, 2})
+		t.Assert(chunks[1], []int{3, 4})
+		t.Assert(chunks[2], []int{5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		chunks := array1.Chunk(3)
+		t.Assert(len(chunks), 2)
+		t.Assert(chunks[0], []int{1, 2, 3})
+		t.Assert(chunks[1], []int{4, 5, 6})
+		t.Assert(array1.Chunk(0), nil)
+	})
+}
+
+func TestSortedTArray_SubSlice(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "b", "e"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array2 := garray.NewSortedTArrayFrom(a1, nil, true)
+		i1 := array1.SubSlice(2, 3)
+		t.Assert(len(i1), 3)
+		t.Assert(i1, []string{"c", "d", "e"})
+
+		i1 = array1.SubSlice(2, 6)
+		t.Assert(len(i1), 3)
+		t.Assert(i1, []string{"c", "d", "e"})
+
+		i1 = array1.SubSlice(7, 2)
+		t.Assert(len(i1), 0)
+
+		s1 := array1.SubSlice(1, -2)
+		t.Assert(s1, nil)
+
+		s1 = array1.SubSlice(-9, 2)
+		t.Assert(s1, nil)
+		t.Assert(array2.SubSlice(1, 3), []string{"b", "c", "d"})
+
+	})
+}
+
+func TestSortedTArray_Rand(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1, ok := array1.Rand()
+		t.Assert(ok, true)
+		t.AssertIN(i1, []string{"a", "d", "c"})
+		t.Assert(array1.Len(), 3)
+
+		array2 := garray.NewSortedTArrayFrom([]string{}, nil)
+		v, ok := array2.Rand()
+		t.Assert(ok, false)
+		t.Assert(v, nil)
+	})
+}
+
+func TestSortedTArray_Rands(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		i1 := array1.Rands(2)
+		t.AssertIN(i1, []string{"a", "d", "c"})
+		t.Assert(len(i1), 2)
+		t.Assert(array1.Len(), 3)
+
+		i1 = array1.Rands(4)
+		t.Assert(len(i1), 4)
+
+		array2 := garray.NewSortedTArrayFrom([]string{}, nil)
+		v := array2.Rands(1)
+		t.Assert(v, nil)
+	})
+}
+
+func TestSortedTArray_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c"}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join(","), `a,c,d`)
+		t.Assert(array1.Join("."), `a.c.d`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"0", "1", `"a"`, `\a`}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join("."), `"a".0.1.\a`)
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.Join("."), "")
+	})
+}
+
+func TestSortedTArray_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"0", "1", "a", "b"}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		t.Assert(array1.String(), `[0,1,"a","b"]`)
+
+		array1 = nil
+		t.Assert(array1.String(), "")
+	})
+}
+
+func TestSortedTArray_CountValues(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"a", "d", "c", "c"}
+
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		m1 := array1.CountValues()
+		t.Assert(len(m1), 3)
+		t.Assert(m1["c"], 2)
+		t.Assert(m1["a"], 1)
+
+	})
+}
+
+func TestSortedTArray_SetUnique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array1.SetUnique(true)
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []int{1, 2, 3, 4, 5})
+	})
+}
+
+func TestSortedTArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedTArrayFrom(a1, nil)
+		array1.Unique()
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []int{1, 2, 3, 4, 5})
+
+		array2 := garray.NewSortedTArrayFrom([]int{}, nil)
+		array2.Unique()
+		t.Assert(array2.Len(), 0)
+		t.Assert(array2, []int{})
+	})
+}
+
+func TestSortedTArray_LockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.LockFunc(func(n1 []string) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedTArray_RLockFunc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		// go1
+		go a1.RLockFunc(func(n1 []string) { // 读写锁
+			time.Sleep(2 * time.Second) // 暂停2秒
+			n1[2] = "g"
+			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		})
+
+		// go2
+		go func() {
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+			a1.Len()
+			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
+		}()
+
+		t1 := <-ch1
+		t2 := <-ch1
+		<-ch2 // 等待go1完成
+
+		// 防止ci抖动,以豪秒为单位
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候不会被阻塞。
+		t.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedTArray_Merge(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+
+		s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]any{3})
+		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedTArrayFrom([]int{4, 5}, nil)
+		s5 := garray.NewSortedStrArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+
+		t.Assert(a1.Merge(s2).Len(), 6)
+		t.Assert(a1.Merge(i1).Len(), 9)
+		t.Assert(a1.Merge(i2).Len(), 10)
+		t.Assert(a1.Merge(s3).Len(), 12)
+		t.Assert(a1.Merge(s4).Len(), 14)
+		t.Assert(a1.Merge(s5).Len(), 16)
+		t.Assert(a1.Merge(s6).Len(), 19)
+	})
+}
+
+func TestSortedTArray_Json(t *testing.T) {
+	// array pointer
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		s2 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.NewSortedTArray[string](nil)
+		err1 = json.UnmarshalUseNumber(b2, &a2)
+		t.AssertNil(err1)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedTArray[string]
+		a3.SetComparator(nil)
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		s2 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedTArrayFrom(s1, nil)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
+
+		a2 := garray.NewSortedTArray[string](nil)
+		err1 = json.UnmarshalUseNumber(b2, &a2)
+		t.AssertNil(err1)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedTArray[string]
+		a3.SetComparator(nil)
+		err := json.UnmarshalUseNumber(b2, &a3)
+		t.AssertNil(err)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array pointer
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.SortedTArray[int]
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.AssertNE(user.Scores, nil)
+		t.Assert(user.Scores.Len(), 3)
+
+		v, ok := user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores *garray.SortedTArray[int]
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.AssertNil(err)
+
+		user := new(User)
+		err = json.UnmarshalUseNumber(b, user)
+		t.AssertNil(err)
+		t.Assert(user.Name, data["Name"])
+		t.AssertNE(user.Scores, nil)
+		t.Assert(user.Scores.Len(), 3)
+
+		v, ok := user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.Assert(v, 0)
+		t.Assert(ok, false)
+	})
+}
+
+func TestSortedTArray_Iterator(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		array.Iterator(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorAsc(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array.IteratorDesc(func(k int, v string) bool {
+			t.Assert(v, slice[k])
+			return true
+		})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.Iterator(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorAsc(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		index := 0
+		array.IteratorDesc(func(k int, v string) bool {
+			index++
+			return false
+		})
+		t.Assert(index, 1)
+	})
+}
+
+func TestSortedTArray_RemoveValue(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(array.RemoveValue("e"), false)
+		t.Assert(array.RemoveValue("b"), true)
+		t.Assert(array.RemoveValue("a"), true)
+		t.Assert(array.RemoveValue("c"), true)
+		t.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestSortedTArray_RemoveValues(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedTArrayFrom(slice, nil)
+	gtest.C(t, func(t *gtest.T) {
+		array.RemoveValues("a", "b", "c")
+		t.Assert(array.Slice(), g.SliceStr{"d"})
+	})
+}
+
+func TestSortedTArray_UnmarshalValue(t *testing.T) {
+	type V struct {
+		Name  string
+		Array *garray.SortedTArray[int]
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[2,3,1]`),
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var v *V
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.SliceInt{2, 3, 1},
+		}, &v)
+		t.AssertNil(err)
+		t.Assert(v.Name, "john")
+		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+func TestSortedTArray_Filter(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.SliceInt{0, 1, 2, 3, 4, -1, -2}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value < 0
+		}).Slice(), g.Slice{0, 1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFromCopy(g.SliceInt{-1, 1, 2, 3, 4, -2}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return value < 0
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0, 0}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3, 4}, nil)
+		t.Assert(array.Filter(func(index int, value int) bool {
+			return empty.IsEmpty(value)
+		}), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestSortedTArray_FilterNil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		values := g.SliceInt{0, 1, 2, 3, 4, -1, -2}
+		array := garray.NewSortedTArrayFromCopy(values, gutil.ComparatorT)
+		t.Assert(array.FilterNil().Slice(), g.SliceInt{-2, -1, 0, 1, 2, 3, 4})
+	})
+
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.FilterNil().Slice(), g.Slice{"", -1, -2, 0, 1, 2, 3, 4, []any{}})
+	})
+}
+
+func TestSortedTArray_FilterEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0, 0}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceInt{1, 2, 3, 4}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceStr{"a", "", "b", "c", ""}, nil)
+		t.Assert(array.FilterEmpty(), g.Slice{"a", "b", "c"})
+	})
+	gtest.C(t, func(t *gtest.T) {
+		values := g.Slice{0, 1, 2, 3, 4, -1, -2, nil, []any{}, ""}
+		array := garray.NewSortedTArrayFromCopy(values, nil)
+		t.Assert(array.FilterEmpty().Slice(), g.Slice{-1, -2, 1, 2, 3, 4})
+	})
+}
+
+func TestSortedTArray_Walk(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom(g.SliceStr{"1", "2"}, nil)
+		t.Assert(array.Walk(func(value string) string {
+			return "key-" + value
+		}), g.Slice{"key-1", "key-2"})
+	})
+}
+
+func TestSortedTArray_IsEmpty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom([]string{}, nil)
+		t.Assert(array.IsEmpty(), true)
+	})
+}
+
+func TestSortedTArray_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedTArrayFrom([]int{1, 2, 3, 4, 5}, nil)
+		copyArray := array.DeepCopy().(*garray.SortedTArray[int])
+		array.Add(6)
+		copyArray.Add(7)
+		cval, _ := copyArray.Get(5)
+		val, _ := array.Get(5)
+		t.AssertNE(cval, val)
+	})
+}

container/glist/glist_t.go

@@ -0,0 +1,721 @@
+// 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 glist
+
+import (
+	"bytes"
+	"container/list"
+
+	"github.com/gogf/gf/v2/internal/deepcopy"
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+// TElement is an element of a linked list.
+type TElement[T any] struct {
+	// Next and previous pointers in the doubly-linked list of elements.
+	// To simplify the implementation, internally a list l is implemented
+	// as a ring, such that &l.root is both the next element of the last
+	// list element (l.Back()) and the previous element of the first list
+	// element (l.Front()).
+	next, prev *TElement[T]
+
+	// The list to which this element belongs.
+	list *TList[T]
+
+	// The value stored with this element.
+	Value T
+}
+
+// Next returns the next list element or nil.
+func (e *TElement[T]) Next() *TElement[T] {
+	if p := e.next; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// Prev returns the previous list element or nil.
+func (e *TElement[T]) Prev() *TElement[T] {
+	if p := e.prev; e.list != nil && p != &e.list.root {
+		return p
+	}
+	return nil
+}
+
+// TList is a doubly linked list containing a concurrent-safe/unsafe switch.
+// The switch should be set when its initialization and cannot be changed then.
+
+type TList[T any] struct {
+	mu   rwmutex.RWMutex
+	root TElement[T] // sentinel list element, only &root, root.prev, and root.next are used
+	len  int         // current list length excluding (this) sentinel element
+}
+
+// NewT creates and returns a new empty doubly linked list.
+func NewT[T any](safe ...bool) *TList[T] {
+	l := &TList[T]{
+		mu: rwmutex.Create(safe...),
+	}
+	return l.init()
+}
+
+// NewTFrom creates and returns a list from a copy of given slice `array`.
+// The parameter `safe` is used to specify whether using list in concurrent-safety,
+// which is false in default.
+func NewTFrom[T any](array []T, safe ...bool) *TList[T] {
+	l := NewT[T](safe...)
+	for _, v := range array {
+		l.insertValue(v, l.root.prev)
+	}
+	return l
+}
+
+// PushFront inserts a new element `e` with value `v` at the front of list `l` and returns `e`.
+func (l *TList[T]) PushFront(v T) (e *TElement[T]) {
+	l.mu.Lock()
+	l.lazyInit()
+	e = l.insertValue(v, &l.root)
+	l.mu.Unlock()
+	return
+}
+
+// PushBack inserts a new element `e` with value `v` at the back of list `l` and returns `e`.
+func (l *TList[T]) PushBack(v T) (e *TElement[T]) {
+	l.mu.Lock()
+	l.lazyInit()
+	e = l.insertValue(v, l.root.prev)
+	l.mu.Unlock()
+	return
+}
+
+// PushFronts inserts multiple new elements with values `values` at the front of list `l`.
+func (l *TList[T]) PushFronts(values []T) {
+	l.mu.Lock()
+	l.lazyInit()
+	for _, v := range values {
+		l.insertValue(v, &l.root)
+	}
+	l.mu.Unlock()
+}
+
+// PushBacks inserts multiple new elements with values `values` at the back of list `l`.
+func (l *TList[T]) PushBacks(values []T) {
+	l.mu.Lock()
+	l.lazyInit()
+	for _, v := range values {
+		l.insertValue(v, l.root.prev)
+	}
+	l.mu.Unlock()
+}
+
+// PopBack removes the element from back of `l` and returns the value of the element.
+func (l *TList[T]) PopBack() (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if l.len == 0 {
+		return
+	}
+	return l.remove(l.root.prev)
+}
+
+// PopFront removes the element from front of `l` and returns the value of the element.
+func (l *TList[T]) PopFront() (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if l.len == 0 {
+		return
+	}
+	return l.remove(l.root.next)
+}
+
+// PopBacks removes `max` elements from back of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopBacks(max int) (values []T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	length := l.len
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]T, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.remove(l.root.prev)
+		}
+	}
+	return
+}
+
+// PopFronts removes `max` elements from front of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopFronts(max int) (values []T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	length := l.len
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]T, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.remove(l.root.next)
+		}
+	}
+	return
+}
+
+// PopBackAll removes all elements from back of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopBackAll() []T {
+	return l.PopBacks(-1)
+}
+
+// PopFrontAll removes all elements from front of `l`
+// and returns values of the removed elements as slice.
+func (l *TList[T]) PopFrontAll() []T {
+	return l.PopFronts(-1)
+}
+
+// FrontAll copies and returns values of all elements from front of `l` as slice.
+func (l *TList[T]) FrontAll() (values []T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		values = make([]T, length)
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			values[i] = e.Value
+		}
+	}
+	return
+}
+
+// BackAll copies and returns values of all elements from back of `l` as slice.
+func (l *TList[T]) BackAll() (values []T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		values = make([]T, length)
+		for i, e := 0, l.back(); i < length; i, e = i+1, e.Prev() {
+			values[i] = e.Value
+		}
+	}
+	return
+}
+
+// FrontValue returns value of the first element of `l` or zero value of T if the list is empty.
+func (l *TList[T]) FrontValue() (value T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	if e := l.front(); e != nil {
+		value = e.Value
+	}
+	return
+}
+
+// BackValue returns value of the last element of `l` or zero value of T if the list is empty.
+func (l *TList[T]) BackValue() (value T) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	if e := l.back(); e != nil {
+		value = e.Value
+	}
+	return
+}
+
+// Front returns the first element of list `l` or nil if the list is empty.
+func (l *TList[T]) Front() (e *TElement[T]) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	e = l.front()
+	return
+}
+
+// Back returns the last element of list `l` or nil if the list is empty.
+func (l *TList[T]) Back() (e *TElement[T]) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+
+	e = l.back()
+	return
+}
+
+// Len returns the number of elements of list `l`.
+// The complexity is O(1).
+func (l *TList[T]) Len() (length int) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	length = l.len
+	return
+}
+
+// Size is alias of Len.
+func (l *TList[T]) Size() int {
+	return l.Len()
+}
+
+// MoveBefore moves element `e` to its new position before `p`.
+// If `e` or `p` is not an element of `l`, or `e` == `p`, the list is not modified.
+// The element and `p` must not be nil.
+func (l *TList[T]) MoveBefore(e, p *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	if e.list != l || e == p || p.list != l {
+		return
+	}
+	l.move(e, p.prev)
+}
+
+// MoveAfter moves element `e` to its new position after `p`.
+// If `e` or `p` is not an element of `l`, or `e` == `p`, the list is not modified.
+// The element and `p` must not be nil.
+func (l *TList[T]) MoveAfter(e, p *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	if e.list != l || e == p || p.list != l {
+		return
+	}
+	l.move(e, p)
+}
+
+// MoveToFront moves element `e` to the front of list `l`.
+// If `e` is not an element of `l`, the list is not modified.
+// The element must not be nil.
+func (l *TList[T]) MoveToFront(e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	if e.list != l || l.root.next == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, &l.root)
+}
+
+// MoveToBack moves element `e` to the back of list `l`.
+// If `e` is not an element of `l`, the list is not modified.
+// The element must not be nil.
+func (l *TList[T]) MoveToBack(e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+
+	if e.list != l || l.root.prev == e {
+		return
+	}
+	// see comment in List.Remove about initialization of l
+	l.move(e, l.root.prev)
+}
+
+// PushBackList inserts a copy of an other list at the back of list `l`.
+// The lists `l` and `other` may be the same, but they must not be nil.
+func (l *TList[T]) PushBackList(other *TList[T]) {
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	for i, e := other.len, other.front(); i > 0; i, e = i-1, e.Next() {
+		l.insertValue(e.Value, l.root.prev)
+	}
+}
+
+// PushFrontList inserts a copy of an other list at the front of list `l`.
+// The lists `l` and `other` may be the same, but they must not be nil.
+func (l *TList[T]) PushFrontList(other *TList[T]) {
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+
+	for i, e := other.len, other.back(); i > 0; i, e = i-1, e.Prev() {
+		l.insertValue(e.Value, &l.root)
+	}
+}
+
+// InsertAfter inserts a new element `e` with value `v` immediately after `p` and returns `e`.
+// If `p` is not an element of `l`, the list is not modified.
+// The `p` must not be nil.
+func (l *TList[T]) InsertAfter(p *TElement[T], v T) (e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+	if p.list != l {
+		return nil
+	}
+	e = l.insertValue(v, p)
+	return
+}
+
+// InsertBefore inserts a new element `e` with value `v` immediately before `p` and returns `e`.
+// If `p` is not an element of `l`, the list is not modified.
+// The `p` must not be nil.
+func (l *TList[T]) InsertBefore(p *TElement[T], v T) (e *TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.lazyInit()
+	if p.list != l {
+		return nil
+	}
+	e = l.insertValue(v, p.prev)
+	return
+}
+
+// Remove removes `e` from `l` if `e` is an element of list `l`.
+// It returns the element value e.Value.
+// The element must not be nil.
+func (l *TList[T]) Remove(e *TElement[T]) (value T) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	return l.remove(e)
+}
+
+// Removes removes multiple elements `es` from `l` if `es` are elements of list `l`.
+func (l *TList[T]) Removes(es []*TElement[T]) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.lazyInit()
+	for _, e := range es {
+		l.remove(e)
+	}
+}
+
+// RemoveAll removes all elements from list `l`.
+func (l *TList[T]) RemoveAll() {
+	l.mu.Lock()
+	l.init()
+	l.mu.Unlock()
+}
+
+// Clear is alias of RemoveAll.
+func (l *TList[T]) Clear() {
+	l.RemoveAll()
+}
+
+// ToList converts TList[T] to list.List
+func (l *TList[T]) ToList() *list.List {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	return l.toList()
+}
+
+// toList converts TList[T] to list.List
+func (l *TList[T]) toList() *list.List {
+	l.lazyInit()
+
+	nl := list.New()
+
+	for e := l.front(); e != nil; e = e.Next() {
+		nl.PushBack(e.Value)
+	}
+	return nl
+}
+
+// AppendList append list.List to the end
+func (l *TList[T]) AppendList(nl *list.List) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	l.appendList(nl)
+}
+
+// appendList append list.List to the end
+func (l *TList[T]) appendList(nl *list.List) {
+	if nl.Len() == 0 {
+		return
+	}
+
+	l.lazyInit()
+
+	for e := nl.Front(); e != nil; e = e.Next() {
+		if v, ok := e.Value.(T); ok {
+			l.insertValue(v, l.root.prev)
+		}
+	}
+}
+
+// AssignList assigns list.List to now TList[T].
+// It will clear TList[T] first, and append the list.List.
+// Note: Elements in nl that are not assignable to T are silently skipped.
+// Returns the number of skipped (incompatible) elements.
+func (l *TList[T]) AssignList(nl *list.List) int {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	return l.assignList(nl)
+}
+
+// assignList assigns list.List to now TList[T].
+// It will clear TList[T] first, and append the list.List.
+// Returns the number of skipped (incompatible) elements.
+func (l *TList[T]) assignList(nl *list.List) int {
+	l.init()
+	if nl.Len() == 0 {
+		return 0
+	}
+	skipped := 0
+	for e := nl.Front(); e != nil; e = e.Next() {
+		if v, ok := e.Value.(T); ok {
+			l.insertValue(v, l.root.prev)
+		} else {
+			skipped++
+		}
+	}
+	return skipped
+}
+
+// RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
+func (l *TList[T]) RLockFunc(f func(list *list.List)) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	f(l.toList())
+}
+
+// LockFunc locks writing with given callback function `f` within RWMutex.Lock.
+func (l *TList[T]) LockFunc(f func(list *list.List)) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	nl := l.toList()
+	f(nl)
+	l.assignList(nl)
+}
+
+// Iterator is alias of IteratorAsc.
+func (l *TList[T]) Iterator(f func(e *TElement[T]) bool) {
+	l.IteratorAsc(f)
+}
+
+// IteratorAsc iterates the list readonly in ascending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (l *TList[T]) IteratorAsc(f func(e *TElement[T]) bool) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			if !f(e) {
+				break
+			}
+		}
+	}
+}
+
+// IteratorDesc iterates the list readonly in descending order with given callback function `f`.
+// If `f` returns true, then it continues iterating; or false to stop.
+func (l *TList[T]) IteratorDesc(f func(e *TElement[T]) bool) {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.back(); i < length; i, e = i+1, e.Prev() {
+			if !f(e) {
+				break
+			}
+		}
+	}
+}
+
+// Join joins list elements with a string `glue`.
+func (l *TList[T]) Join(glue string) string {
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	l.lazyInit()
+
+	buffer := bytes.NewBuffer(nil)
+	length := l.len
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			buffer.WriteString(gconv.String(e.Value))
+			if i != length-1 {
+				buffer.WriteString(glue)
+			}
+		}
+	}
+	return buffer.String()
+}
+
+// String returns current list as a string.
+func (l *TList[T]) String() string {
+	if l == nil {
+		return ""
+	}
+	return "[" + l.Join(",") + "]"
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (l TList[T]) MarshalJSON() ([]byte, error) {
+	return json.Marshal(l.FrontAll())
+}
+
+// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
+func (l *TList[T]) UnmarshalJSON(b []byte) error {
+	var array []T
+	if err := json.UnmarshalUseNumber(b, &array); err != nil {
+		return err
+	}
+	l.init()
+	l.PushBacks(array)
+	return nil
+}
+
+// UnmarshalValue is an interface implement which sets any type of value for list.
+func (l *TList[T]) UnmarshalValue(value any) (err error) {
+	var array []T
+	switch value.(type) {
+	case string, []byte:
+		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
+	default:
+		anyArray := gconv.SliceAny(value)
+		if err = gconv.Scan(anyArray, &array); err != nil {
+			return
+		}
+	}
+	l.init()
+	l.PushBacks(array)
+	return err
+}
+
+// DeepCopy implements interface for deep copy of current type.
+func (l *TList[T]) DeepCopy() any {
+	if l == nil {
+		return nil
+	}
+
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+
+	l.lazyInit()
+
+	var (
+		length  = l.len
+		valuesT = make([]T, length)
+	)
+	if length > 0 {
+		for i, e := 0, l.front(); i < length; i, e = i+1, e.Next() {
+			valuesT[i] = deepcopy.Copy(e.Value).(T)
+		}
+	}
+	return NewTFrom(valuesT, l.mu.IsSafe())
+}
+
+// Init initializes or clears list l.
+func (l *TList[T]) init() *TList[T] {
+	l.root.next = &l.root
+	l.root.prev = &l.root
+	l.len = 0
+	return l
+}
+
+// lazyInit lazily initializes a zero List value.
+func (l *TList[T]) lazyInit() {
+	if l.root.next == nil {
+		l.init()
+	}
+}
+
+// insert inserts e after at, increments l.len, and returns e.
+func (l *TList[T]) insert(e, at *TElement[T]) *TElement[T] {
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+	e.list = l
+	l.len++
+	return e
+}
+
+// insertValue is a convenience wrapper for insert(&Element{Value: v}, at).
+func (l *TList[T]) insertValue(v T, at *TElement[T]) *TElement[T] {
+	return l.insert(&TElement[T]{Value: v}, at)
+}
+
+// remove removes e from its list, decrements l.len
+func (l *TList[T]) remove(e *TElement[T]) (val T) {
+	if e.list != l {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+	e.next = nil // avoid memory leaks
+	e.prev = nil // avoid memory leaks
+	e.list = nil
+	l.len--
+
+	return e.Value
+}
+
+// move moves e to next to at.
+func (l *TList[T]) move(e, at *TElement[T]) {
+	if e == at {
+		return
+	}
+	e.prev.next = e.next
+	e.next.prev = e.prev
+
+	e.prev = at
+	e.next = at.next
+	e.prev.next = e
+	e.next.prev = e
+}
+
+// front returns the first element of list l or nil if the list is empty.
+func (l *TList[T]) front() *TElement[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.next
+}
+
+// back returns the last element of list l or nil if the list is empty.
+func (l *TList[T]) back() *TElement[T] {
+	if l.len == 0 {
+		return nil
+	}
+	return l.root.prev
+}

container/glist/glist_z_bench_t_test.go

@@ -0,0 +1,61 @@
+// 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.
+
+// go test *.go -bench=".*" -benchmem
+
+package glist
+
+import (
+	"testing"
+)
+
+var (
+	lt = NewT[any](true)
+)
+
+func Benchmark_T_PushBack(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			lt.PushBack(i)
+			i++
+		}
+	})
+}
+
+func Benchmark_T_PushFront(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			lt.PushFront(i)
+			i++
+		}
+	})
+}
+
+func Benchmark_T_Len(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.Len()
+		}
+	})
+}
+
+func Benchmark_T_PopFront(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.PopFront()
+		}
+	})
+}
+
+func Benchmark_T_PopBack(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			lt.PopBack()
+		}
+	})
+}

container/glist/glist_z_example_t_test.go

@@ -0,0 +1,689 @@
+// 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 glist_test
+
+import (
+	"container/list"
+	"fmt"
+
+	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/frame/g"
+)
+
+func ExampleNewT() {
+	n := 10
+	l := glist.NewT[any]()
+	for i := 0; i < n; i++ {
+		l.PushBack(i)
+	}
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+	fmt.Println(l.BackAll())
+
+	for i := 0; i < n; i++ {
+		fmt.Print(l.PopFront())
+	}
+
+	fmt.Println()
+	fmt.Println(l.Len())
+
+	// Output:
+	// 10
+	// [0,1,2,3,4,5,6,7,8,9]
+	// [0 1 2 3 4 5 6 7 8 9]
+	// [9 8 7 6 5 4 3 2 1 0]
+	// 0123456789
+	// 0
+}
+
+func ExampleNewTFrom() {
+	n := 10
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+	fmt.Println(l.BackAll())
+
+	for i := 0; i < n; i++ {
+		fmt.Print(l.PopFront())
+	}
+
+	fmt.Println()
+	fmt.Println(l.Len())
+
+	// Output:
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+	// [1 2 3 4 5 6 7 8 9 10]
+	// [10 9 8 7 6 5 4 3 2 1]
+	// 12345678910
+	// 0
+}
+
+func ExampleTList_PushFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushFront(0)
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [0,1,2,3,4,5]
+}
+
+func ExampleTList_PushBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushBack(6)
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,6]
+}
+
+func ExampleTList_PushFronts() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushFronts(g.Slice{0, -1, -2, -3, -4})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 10
+	// [-4,-3,-2,-1,0,1,2,3,4,5]
+}
+
+func ExampleTList_PushBacks() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.PushBacks(g.Slice{6, 7, 8, 9, 10})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+}
+
+func ExampleTList_PopBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBack())
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// 4
+	// [1,2,3,4]
+}
+
+func ExampleTList_PopFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFront())
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 1
+	// 4
+	// [2,3,4,5]
+}
+
+func ExampleTList_PopBacks() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBacks(2))
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [5 4]
+	// 3
+	// [1,2,3]
+}
+
+func ExampleTList_PopFronts() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFronts(2))
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1 2]
+	// 3
+	// [3,4,5]
+}
+
+func ExampleTList_PopBackAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopBackAll())
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [5 4 3 2 1]
+	// 0
+}
+
+func ExampleTList_PopFrontAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+	fmt.Println(l.PopFrontAll())
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1 2 3 4 5]
+	// 0
+}
+
+func ExampleTList_FrontAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.FrontAll())
+
+	// Output:
+	// [1,2,3,4,5]
+	// [1 2 3 4 5]
+}
+
+func ExampleTList_BackAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.BackAll())
+
+	// Output:
+	// [1,2,3,4,5]
+	// [5 4 3 2 1]
+}
+
+func ExampleTList_FrontValue() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.FrontValue())
+
+	// Output:
+	// [1,2,3,4,5]
+	// 1
+}
+
+func ExampleTList_BackValue() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l)
+	fmt.Println(l.BackValue())
+
+	// Output:
+	// [1,2,3,4,5]
+	// 5
+}
+
+func ExampleTList_Front() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Front().Value)
+	fmt.Println(l)
+
+	e := l.Front()
+	l.InsertBefore(e, 0)
+	l.InsertAfter(e, "a")
+
+	fmt.Println(l)
+
+	// Output:
+	// 1
+	// [1,2,3,4,5]
+	// [0,1,a,2,3,4,5]
+}
+
+func ExampleTList_Back() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Back().Value)
+	fmt.Println(l)
+
+	e := l.Back()
+	l.InsertBefore(e, "a")
+	l.InsertAfter(e, 6)
+
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// [1,2,3,4,a,5,6]
+}
+
+func ExampleTList_Len() {
+	l := glist.NewTFrom[any](g.Slice{1, 2, 3, 4, 5})
+
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+}
+
+func ExampleTList_Size() {
+	l := glist.NewTFrom[any](g.Slice{1, 2, 3, 4, 5})
+
+	fmt.Println(l.Size())
+
+	// Output:
+	// 5
+}
+
+func ExampleTList_MoveBefore() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	e := l.PushBack(6)
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	l.MoveBefore(e, l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e = &glist.TElement[any]{Value: 7}
+	l.MoveBefore(e, l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,6]
+	// 6
+	// [6,1,2,3,4,5]
+	// 6
+	// [6,1,2,3,4,5]
+}
+
+func ExampleTList_MoveAfter() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	e := l.PushFront(0)
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	l.MoveAfter(e, l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e = &glist.TElement[any]{Value: -1}
+	l.MoveAfter(e, l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 6
+	// [0,1,2,3,4,5]
+	// 6
+	// [1,2,3,4,5,0]
+	// 6
+	// [1,2,3,4,5,0]
+}
+
+func ExampleTList_MoveToFront() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	l.MoveToFront(l.Back())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e := &glist.TElement[any]{Value: 6}
+	l.MoveToFront(e)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [5,1,2,3,4]
+	// 5
+	// [5,1,2,3,4]
+}
+
+func ExampleTList_MoveToBack() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// element of `l`
+	l.MoveToBack(l.Front())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// not element of `l`
+	e := &glist.TElement[any]{Value: 0}
+	l.MoveToBack(e)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [2,3,4,5,1]
+	// 5
+	// [2,3,4,5,1]
+}
+
+func ExampleTList_PushBackList() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	other := glist.NewTFrom[any](g.Slice{6, 7, 8, 9, 10})
+
+	fmt.Println(other.Size())
+	fmt.Println(other)
+
+	l.PushBackList(other)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [6,7,8,9,10]
+	// 10
+	// [1,2,3,4,5,6,7,8,9,10]
+}
+
+func ExampleTList_PushFrontList() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	other := glist.NewTFrom[any](g.Slice{-4, -3, -2, -1, 0})
+
+	fmt.Println(other.Size())
+	fmt.Println(other)
+
+	l.PushFrontList(other)
+
+	fmt.Println(l.Size())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 5
+	// [-4,-3,-2,-1,0]
+	// 10
+	// [-4,-3,-2,-1,0,1,2,3,4,5]
+}
+
+func ExampleTList_InsertAfter() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.InsertAfter(l.Front(), "a")
+	l.InsertAfter(l.Back(), "b")
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 7
+	// [1,a,2,3,4,5,b]
+}
+
+func ExampleTList_InsertBefore() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.InsertBefore(l.Front(), "a")
+	l.InsertBefore(l.Back(), "b")
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 7
+	// [a,1,2,3,4,b,5]
+}
+
+func ExampleTList_Remove() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	fmt.Println(l.Remove(l.Front()))
+	fmt.Println(l.Remove(l.Back()))
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 1
+	// 5
+	// 3
+	// [2,3,4]
+}
+
+func ExampleTList_Removes() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.Removes([]*glist.TElement[any]{l.Front(), l.Back()})
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 3
+	// [2,3,4]
+}
+
+func ExampleTList_RemoveAll() {
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 5, 1).Slice())
+
+	fmt.Println(l.Len())
+	fmt.Println(l)
+
+	l.RemoveAll()
+
+	fmt.Println(l.Len())
+
+	// Output:
+	// 5
+	// [1,2,3,4,5]
+	// 0
+}
+
+func ExampleTList_RLockFunc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from head.
+	l.RLockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
+				fmt.Print(e.Value)
+			}
+		}
+	})
+	fmt.Println()
+	// iterate reading from tail.
+	l.RLockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Back(); i < length; i, e = i+1, e.Prev() {
+				fmt.Print(e.Value)
+			}
+		}
+	})
+
+	fmt.Println()
+	// Output:
+	// 12345678910
+	// 10987654321
+}
+
+func ExampleTList_IteratorAsc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from head using IteratorAsc.
+	l.IteratorAsc(func(e *glist.TElement[any]) bool {
+		fmt.Print(e.Value)
+		return true
+	})
+
+	// Output:
+	// 12345678910
+}
+
+func ExampleTList_IteratorDesc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate reading from tail using IteratorDesc.
+	l.IteratorDesc(func(e *glist.TElement[any]) bool {
+		fmt.Print(e.Value)
+		return true
+	})
+	// Output:
+	// 10987654321
+}
+
+func ExampleTList_LockFunc() {
+	// concurrent-safe list.
+	l := glist.NewTFrom[any](garray.NewArrayRange(1, 10, 1).Slice(), true)
+	// iterate writing from head.
+	l.LockFunc(func(list *list.List) {
+		length := list.Len()
+		if length > 0 {
+			for i, e := 0, list.Front(); i < length; i, e = i+1, e.Next() {
+				if e.Value == 6 {
+					e.Value = "M"
+					break
+				}
+			}
+		}
+	})
+	fmt.Println(l)
+
+	// Output:
+	// [1,2,3,4,5,M,7,8,9,10]
+}
+
+func ExampleTList_Join() {
+	var l glist.TList[any]
+	l.PushBacks(g.Slice{"a", "b", "c", "d"})
+
+	fmt.Println(l.Join(","))
+
+	// Output:
+	// a,b,c,d
+}

container/glist/glist_z_unit_t_test.go

@@ -0,0 +1,933 @@
+// 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 glist
+
+import (
+	"container/list"
+	"testing"
+
+	"github.com/gogf/gf/v2/internal/json"
+	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+func checkTListLen(t *gtest.T, l *TList[any], len int) bool {
+	if n := l.Len(); n != len {
+		t.Errorf("l.Len() = %d, want %d", n, len)
+		return false
+	}
+	return true
+}
+
+func checkTListPointers(t *gtest.T, l *TList[any], es []*TElement[any]) {
+	if !checkTListLen(t, l, len(es)) {
+		return
+	}
+
+	i := 0
+	l.Iterator(func(e *TElement[any]) bool {
+		if e.Prev() != es[i].Prev() {
+			t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
+			return false
+		}
+		if e.Next() != es[i].Next() {
+			t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
+			return false
+		}
+		i++
+		return true
+	})
+}
+
+func TestTVar(t *testing.T) {
+	var l TList[any]
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+}
+
+func TestTBasic(t *testing.T) {
+	l := NewT[any]()
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		// fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		// fmt.Println(v)
+	}
+}
+
+func TestTList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		checkTListPointers(t, l, []*TElement[any]{})
+
+		// Single element list
+		e := l.PushFront("a")
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.MoveToFront(e)
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.MoveToBack(e)
+		checkTListPointers(t, l, []*TElement[any]{e})
+		l.Remove(e)
+		checkTListPointers(t, l, []*TElement[any]{})
+
+		// Bigger list
+		e2 := l.PushFront(2)
+		e1 := l.PushFront(1)
+		e3 := l.PushBack(3)
+		e4 := l.PushBack("banana")
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.Remove(e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e4})
+
+		l.MoveToFront(e3) // move from middle
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+
+		l.MoveToFront(e1)
+		l.MoveToBack(e3) // move from middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+
+		l.MoveToFront(e3) // move from back
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+		l.MoveToFront(e3) // should be no-op
+		checkTListPointers(t, l, []*TElement[any]{e3, e1, e4})
+
+		l.MoveToBack(e3) // move from front
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+		l.MoveToBack(e3) // should be no-op
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3})
+
+		e2 = l.InsertBefore(e1, 2) // insert before front
+		checkTListPointers(t, l, []*TElement[any]{e2, e1, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertBefore(e4, 2) // insert before middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertBefore(e3, 2) // insert before back
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		l.Remove(e2)
+
+		e2 = l.InsertAfter(e1, 2) // insert after front
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e4, e3})
+		l.Remove(e2)
+		e2 = l.InsertAfter(e4, 2) // insert after middle
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		l.Remove(e2)
+		e2 = l.InsertAfter(e3, 2) // insert after back
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e3, e2})
+		l.Remove(e2)
+
+		// Check standard iteration.
+		sum := 0
+		for e := l.Front(); e != nil; e = e.Next() {
+			if i, ok := e.Value.(int); ok {
+				sum += i
+			}
+		}
+		if sum != 4 {
+			t.Errorf("sum over l = %d, want 4", sum)
+		}
+
+		// Clear all elements by iterating
+		var next *TElement[any]
+		for e := l.Front(); e != nil; e = next {
+			next = e.Next()
+			l.Remove(e)
+		}
+		checkTListPointers(t, l, []*TElement[any]{})
+	})
+}
+
+func checkTList(t *gtest.T, l *TList[any], es []any) {
+	if !checkTListLen(t, l, len(es)) {
+		return
+	}
+
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+
+		switch e.Value.(type) {
+		case int:
+			if le := e.Value.(int); le != es[i] {
+				t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+			}
+			// default string
+		default:
+			if le := e.Value.(string); le != es[i] {
+				t.Errorf("elt[%v].Value() = %v, want %v", i, le, es[i])
+			}
+		}
+
+		i++
+	}
+
+	// for e := l.Front(); e != nil; e = e.Next() {
+	//	le := e.Value.(int)
+	//	if le != es[i] {
+	//		t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+	//	}
+	//	i++
+	// }
+}
+
+func TestTExtending(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l1 := NewT[any]()
+		l2 := NewT[any]()
+
+		l1.PushBack(1)
+		l1.PushBack(2)
+		l1.PushBack(3)
+
+		l2.PushBack(4)
+		l2.PushBack(5)
+
+		l3 := NewT[any]()
+		l3.PushBackList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushBackList(l2)
+		checkTList(t, l3, []any{1, 2, 3, 4, 5})
+
+		l3 = NewT[any]()
+		l3.PushFrontList(l2)
+		checkTList(t, l3, []any{4, 5})
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1, 2, 3, 4, 5})
+
+		checkTList(t, l1, []any{1, 2, 3})
+		checkTList(t, l2, []any{4, 5})
+
+		l3 = NewT[any]()
+		l3.PushBackList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushBackList(l3)
+		checkTList(t, l3, []any{1, 2, 3, 1, 2, 3})
+
+		l3 = NewT[any]()
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1, 2, 3})
+		l3.PushFrontList(l3)
+		checkTList(t, l3, []any{1, 2, 3, 1, 2, 3})
+
+		l3 = NewT[any]()
+		l1.PushBackList(l3)
+		checkTList(t, l1, []any{1, 2, 3})
+		l1.PushFrontList(l3)
+		checkTList(t, l1, []any{1, 2, 3})
+	})
+}
+
+func TestTRemove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		e1 := l.PushBack(1)
+		e2 := l.PushBack(2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2})
+		// e := l.Front()
+		// l.Remove(e)
+		// checkTListPointers(t, l, []*TElement[any]{e2})
+		// l.Remove(e)
+		// checkTListPointers(t, l, []*TElement[any]{e2})
+	})
+}
+
+func Test_T_Issue4103(t *testing.T) {
+	l1 := NewT[any]()
+	l1.PushBack(1)
+	l1.PushBack(2)
+
+	l2 := NewT[any]()
+	l2.PushBack(3)
+	l2.PushBack(4)
+
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		t.Errorf("l2.Len() = %d, want 2", n)
+	}
+
+	l1.InsertBefore(e, 8)
+	if n := l1.Len(); n != 3 {
+		t.Errorf("l1.Len() = %d, want 3", n)
+	}
+}
+
+func Test_T_Issue6349(t *testing.T) {
+	l := NewT[any]()
+	l.PushBack(1)
+	l.PushBack(2)
+
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		t.Errorf("e.value = %d, want 1", e.Value)
+	}
+	// if e.Next() != nil {
+	//    t.Errorf("e.Next() != nil")
+	// }
+	// if e.Prev() != nil {
+	//    t.Errorf("e.Prev() != nil")
+	// }
+}
+
+func TestTMove(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		e1 := l.PushBack(1)
+		e2 := l.PushBack(2)
+		e3 := l.PushBack(3)
+		e4 := l.PushBack(4)
+
+		l.MoveAfter(e3, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+		l.MoveBefore(e2, e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.MoveAfter(e3, e2)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+		l.MoveBefore(e2, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e2, e3, e4})
+
+		l.MoveBefore(e2, e4)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e2, e4})
+		e2, e3 = e3, e2
+
+		l.MoveBefore(e4, e1)
+		checkTListPointers(t, l, []*TElement[any]{e4, e1, e2, e3})
+		e1, e2, e3, e4 = e4, e1, e2, e3
+
+		l.MoveAfter(e4, e1)
+		checkTListPointers(t, l, []*TElement[any]{e1, e4, e2, e3})
+		e2, e3, e4 = e4, e2, e3
+
+		l.MoveAfter(e2, e3)
+		checkTListPointers(t, l, []*TElement[any]{e1, e3, e2, e4})
+		e2, e3 = e3, e2
+	})
+}
+
+// Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
+func TestTZeroList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var l1 = NewT[any]()
+		l1.PushFront(1)
+		checkTList(t, l1, []any{1})
+
+		var l2 = NewT[any]()
+		l2.PushBack(1)
+		checkTList(t, l2, []any{1})
+
+		var l3 = NewT[any]()
+		l3.PushFrontList(l1)
+		checkTList(t, l3, []any{1})
+
+		var l4 = NewT[any]()
+		l4.PushBackList(l2)
+		checkTList(t, l4, []any{1})
+	})
+}
+
+// Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
+func TestTInsertBeforeUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.PushBack(2)
+		l.PushBack(3)
+		l.InsertBefore(new(TElement[any]), 1)
+		checkTList(t, l, []any{1, 2, 3})
+	})
+}
+
+// Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
+func TestTInsertAfterUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.PushBack(2)
+		l.PushBack(3)
+		l.InsertAfter(new(TElement[any]), 1)
+		checkTList(t, l, []any{1, 2, 3})
+	})
+}
+
+// Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
+func TestTMoveUnknownMark(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l1 := NewT[any]()
+		e1 := l1.PushBack(1)
+
+		l2 := NewT[any]()
+		e2 := l2.PushBack(2)
+
+		l1.MoveAfter(e1, e2)
+		checkTList(t, l1, []any{1})
+		checkTList(t, l2, []any{2})
+
+		l1.MoveBefore(e1, e2)
+		checkTList(t, l1, []any{1})
+		checkTList(t, l2, []any{2})
+	})
+}
+
+func TestTList_RemoveAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l.PushBack(1)
+		l.RemoveAll()
+		checkTList(t, l, []any{})
+		l.PushBack(2)
+		checkTList(t, l, []any{2})
+	})
+}
+
+func TestTList_PushFronts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2}
+		l.PushFronts(a1)
+		checkTList(t, l, []any{2, 1})
+		a1 = []any{3, 4, 5}
+		l.PushFronts(a1)
+		checkTList(t, l, []any{5, 4, 3, 2, 1})
+	})
+}
+
+func TestTList_PushBacks(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2}
+		l.PushBacks(a1)
+		checkTList(t, l, []any{1, 2})
+		a1 = []any{3, 4, 5}
+		l.PushBacks(a1)
+		checkTList(t, l, []any{1, 2, 3, 4, 5})
+	})
+}
+
+func TestTList_PopBacks(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		a2 := []any{"a", "c", "b", "e"}
+		l.PushFronts(a1)
+		i1 := l.PopBacks(2)
+		t.Assert(i1, []any{1, 2})
+
+		l.PushBacks(a2) // 4.3,a,c,b,e
+		i1 = l.PopBacks(3)
+		t.Assert(i1, []any{"e", "b", "c"})
+	})
+}
+
+func TestTList_PopFronts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopFronts(2)
+		t.Assert(i1, []any{4, 3})
+		t.Assert(l.Len(), 2)
+	})
+}
+
+func TestTList_PopBackAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopBackAll()
+		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_PopFrontAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.PopFrontAll()
+		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_FrontAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.FrontAll()
+		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_BackAll(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.BackAll()
+		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_FrontValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l2 := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.FrontValue()
+		t.Assert(gconv.Int(i1), 4)
+		t.Assert(l.Len(), 4)
+
+		i1 = l2.FrontValue()
+		t.Assert(i1, nil)
+	})
+}
+
+func TestTList_BackValue(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		l2 := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		i1 := l.BackValue()
+		t.Assert(gconv.Int(i1), 1)
+		t.Assert(l.Len(), 4)
+
+		i1 = l2.FrontValue()
+		t.Assert(i1, nil)
+	})
+}
+
+func TestTList_Back(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		t.Assert(e1.Value, 1)
+		t.Assert(l.Len(), 4)
+	})
+}
+
+func TestTList_Size(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		t.Assert(l.Size(), 4)
+		l.PopFront()
+		t.Assert(l.Size(), 3)
+	})
+}
+
+func TestTList_Removes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		l.Removes([]*TElement[any]{e1})
+		t.Assert(l.Len(), 3)
+
+		e2 := l.Back()
+		l.Removes([]*TElement[any]{e2})
+		t.Assert(l.Len(), 2)
+		checkTList(t, l, []any{4, 3})
+	})
+}
+
+func TestTList_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+		t.Assert(l.PopBack(), 9)
+		t.Assert(l.PopBacks(2), []any{8, 7})
+		t.Assert(l.PopFront(), 1)
+		t.Assert(l.PopFronts(2), []any{2, 3})
+	})
+}
+
+func TestTList_Clear(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		l.Clear()
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_IteratorAsc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 5, 6, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.Int(e1.Value) > 2
+		}
+		checkTList(t, l, []any{4, 3, 6, 5, 2, 1})
+		l.IteratorAsc(fun1)
+		checkTList(t, l, []any{4, 3, 6, 5, 2, 1})
+	})
+}
+
+func TestTList_IteratorDesc(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{1, 2, 3, 4}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.Int(e1.Value) > 6
+		}
+		l.IteratorDesc(fun1)
+		t.Assert(l.Len(), 4)
+		checkTList(t, l, []any{4, 3, 2, 1})
+	})
+}
+
+func TestTList_Iterator(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		a1 := []any{"a", "b", "c", "d", "e"}
+		l.PushFronts(a1)
+		e1 := l.Back()
+		fun1 := func(e *TElement[any]) bool {
+			return gconv.String(e1.Value) > "c"
+		}
+		checkTList(t, l, []any{"e", "d", "c", "b", "a"})
+		l.Iterator(fun1)
+		checkTList(t, l, []any{"e", "d", "c", "b", "a"})
+	})
+}
+
+func TestTList_Join(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		t.Assert(l.Join(","), `1,2,a,"b",\c`)
+		t.Assert(l.Join("."), `1.2.a."b".\c`)
+	})
+}
+
+func TestTList_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		t.Assert(l.String(), `[1,2,a,"b",\c]`)
+	})
+}
+
+func TestTList_Json(t *testing.T) {
+	// Marshal
+	gtest.C(t, func(t *gtest.T) {
+		a := []any{"a", "b", "c"}
+		l := NewT[any]()
+		l.PushBacks(a)
+		b1, err1 := json.Marshal(l)
+		b2, err2 := json.Marshal(a)
+		t.Assert(err1, err2)
+		t.Assert(b1, b2)
+	})
+	// Unmarshal
+	gtest.C(t, func(t *gtest.T) {
+		a := []any{"a", "b", "c"}
+		l := NewT[any]()
+		b, err := json.Marshal(a)
+		t.AssertNil(err)
+
+		err = json.UnmarshalUseNumber(b, l)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), a)
+	})
+	gtest.C(t, func(t *gtest.T) {
+		var l TList[any]
+		a := []any{"a", "b", "c"}
+		b, err := json.Marshal(a)
+		t.AssertNil(err)
+
+		err = json.UnmarshalUseNumber(b, &l)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), a)
+	})
+}
+
+func TestTList_UnmarshalValue(t *testing.T) {
+	type list struct {
+		Name string
+		List *TList[any]
+	}
+	// JSON
+	gtest.C(t, func(t *gtest.T) {
+		var tlist *list
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"list": []byte(`[1,2,3]`),
+		}, &tlist)
+		t.AssertNil(err)
+		t.Assert(tlist.Name, "john")
+		t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
+	})
+	// Map
+	gtest.C(t, func(t *gtest.T) {
+		var tlist *list
+		err := gconv.Struct(map[string]any{
+			"name": "john",
+			"list": []any{1, 2, 3},
+		}, &tlist)
+		t.AssertNil(err)
+		t.Assert(tlist.Name, "john")
+		t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_DeepCopy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, "a", `"b"`, `\c`})
+		copyList := l.DeepCopy()
+		cl := copyList.(*TList[any])
+		cl.PopBack()
+		t.AssertNE(l.Size(), cl.Size())
+	})
+	// Nil pointer deep copy
+	gtest.C(t, func(t *gtest.T) {
+		var l *TList[any]
+		copyList := l.DeepCopy()
+		t.AssertNil(copyList)
+	})
+}
+
+func TestTList_ToList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3, 4, 5})
+		nl := l.ToList()
+		t.Assert(nl.Len(), 5)
+
+		// Verify elements
+		i := 1
+		for e := nl.Front(); e != nil; e = e.Next() {
+			t.Assert(e.Value, i)
+			i++
+		}
+	})
+	// Empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		nl := l.ToList()
+		t.Assert(nl.Len(), 0)
+	})
+}
+
+func TestTList_AppendList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		nl.PushBack(4)
+		nl.PushBack(5)
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 5)
+		t.Assert(l.FrontAll(), []any{1, 2, 3, 4, 5})
+	})
+	// Append empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		l.AppendList(nl)
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+	// Append with type mismatch (should skip)
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		nl.PushBack(1)
+		nl.PushBack("string") // type mismatch
+		nl.PushBack(2)
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 2)
+		t.Assert(l.FrontAll(), []int{1, 2})
+	})
+}
+
+func TestTList_AssignList(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+		nl.PushBack(4)
+		nl.PushBack(5)
+		nl.PushBack(6)
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 0)
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{4, 5, 6})
+	})
+	// Assign empty list
+	gtest.C(t, func(t *gtest.T) {
+		l := NewTFrom([]any{1, 2, 3})
+		nl := list.New()
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 0)
+		t.Assert(l.Len(), 0)
+	})
+	// Assign with type mismatch (should return skipped count)
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		nl.PushBack(1)
+		nl.PushBack("string") // type mismatch
+		nl.PushBack(2)
+		nl.PushBack("another") // type mismatch
+
+		skipped := l.AssignList(nl)
+		t.Assert(skipped, 2)
+		t.Assert(l.Len(), 2)
+		t.Assert(l.FrontAll(), []int{1, 2})
+	})
+}
+
+func TestTList_String_Nil(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		var l *TList[any]
+		t.Assert(l.String(), "")
+	})
+}
+
+func TestTList_UnmarshalJSON_Error(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalJSON([]byte("invalid json"))
+		t.AssertNE(err, nil)
+	})
+}
+
+func TestTList_UnmarshalValue_String(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue(`[1,2,3]`)
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_UnmarshalValue_Bytes(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue([]byte(`[1,2,3]`))
+		t.AssertNil(err)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+}
+
+func TestTList_DeepCopy_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		copyList := l.DeepCopy()
+		cl := copyList.(*TList[any])
+		t.Assert(cl.Len(), 0)
+	})
+}
+
+func TestTList_AppendList_WithTypeMismatch(t *testing.T) {
+	// Test appendList internal function through AppendList with mixed types
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[int]()
+		nl := list.New()
+		// Only add non-matching types
+		nl.PushBack("string1")
+		nl.PushBack("string2")
+
+		l.AppendList(nl)
+		t.Assert(l.Len(), 0)
+	})
+}
+
+func TestTList_UnmarshalValue_Error(t *testing.T) {
+	// Test UnmarshalValue with data through default case
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		// Pass a slice directly through default case
+		_ = l.UnmarshalValue([]any{1, 2, 3})
+		t.Assert(l.Len(), 3)
+		t.Assert(l.FrontAll(), []any{1, 2, 3})
+	})
+	// Test UnmarshalValue error in string case
+	gtest.C(t, func(t *gtest.T) {
+		l := NewT[any]()
+		err := l.UnmarshalValue("invalid json")
+		t.AssertNE(err, nil)
+	})
+}

container/gmap/gmap.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gmap provides most commonly used map container which also support concurrent-safe/unsafe switch feature.

container/gmap/gmap_hash_any_any_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap

container/gmap/gmap_hash_int_any_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 

container/gmap/gmap_hash_int_int_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap

container/gmap/gmap_hash_int_str_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap

container/gmap/gmap_hash_str_any_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 

container/gmap/gmap_hash_str_int_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 

container/gmap/gmap_hash_str_str_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 

container/gmap/gmap_list_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap

container/gmap/gmap_tree_map.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap

container/gmap/gmap_z_basic_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_bench_maps_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem

container/gmap/gmap_z_bench_safe_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem

container/gmap/gmap_z_bench_syncmap_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem

container/gmap/gmap_z_bench_unsafe_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem

container/gmap/gmap_z_example_any_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_int_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_int_int_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_list_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_str_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_str_int_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_str_str_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_example_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_any_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_int_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_int_int_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_int_str_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_str_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_str_int_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_hash_str_str_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_list_map_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gmap/gmap_z_unit_tree_map_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap_test

container/gpool/gpool_z_example_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gpool_test

container/gqueue/gqueue.go

@@ -89,7 +89,7 @@ func (q *Queue) Close() {
 	if q.limit > 0 {
 		close(q.C)
 	} else {
-		for i := 0; i < defaultBatchSize; i++ {
+		for range defaultBatchSize {
 			q.Pop()
 		}
 	}
@@ -103,10 +103,17 @@ func (q *Queue) Len() (length int64) {
 	if q.limit > 0 {
 		return bufferedSize
 	}
+	// If the queue is unlimited and the buffered size is exactly the default size,
+	// it means there might be some data in the list not synchronized to channel yet.
+	// So we need to add 1 to the buffered size to make the result more accurate.
+	if bufferedSize == defaultQueueSize {
+		bufferedSize++
+	}
 	return int64(q.list.Size()) + bufferedSize
 }
 
 // Size is alias of Len.
+//
 // Deprecated: use Len instead.
 func (q *Queue) Size() int64 {
 	return q.Len()
@@ -126,7 +133,7 @@ func (q *Queue) asyncLoopFromListToChannel() {
 			if bufferLength := q.list.Len(); bufferLength > 0 {
 				// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
 				// If any error occurs here, it will be caught by recover and be ignored.
-				for i := 0; i < bufferLength; i++ {
+				for range bufferLength {
 					q.C <- q.list.PopFront()
 				}
 			} else {

container/gqueue/gqueue_z_unit_test.go

@@ -24,7 +24,7 @@ func TestQueue_Len(t *testing.T) {
 		)
 		for n := 10; n < maxTries; n++ {
 			q1 := gqueue.New(maxNum)
-			for i := 0; i < maxNum; i++ {
+			for i := range maxNum {
 				q1.Push(i)
 			}
 			t.Assert(q1.Len(), maxNum)
@@ -38,7 +38,7 @@ func TestQueue_Len(t *testing.T) {
 		)
 		for n := 10; n < maxTries; n++ {
 			q1 := gqueue.New()
-			for i := 0; i < maxNum; i++ {
+			for i := range maxNum {
 				q1.Push(i)
 			}
 			t.AssertLE(q1.Len(), maxNum)
@@ -50,7 +50,8 @@ func TestQueue_Len(t *testing.T) {
 func TestQueue_Basic(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q := gqueue.New()
-		for i := 0; i < 100; i++ {
+		defer q.Close()
+		for i := range 100 {
 			q.Push(i)
 		}
 		t.Assert(q.Pop(), 0)
@@ -61,6 +62,7 @@ func TestQueue_Basic(t *testing.T) {
 func TestQueue_Pop(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New()
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		q1.Push(3)
@@ -73,27 +75,28 @@ func TestQueue_Pop(t *testing.T) {
 func TestQueue_Close(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New()
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		// wait sync to channel
 		time.Sleep(10 * time.Millisecond)
 		t.Assert(q1.Len(), 2)
-		q1.Close()
 	})
 	gtest.C(t, func(t *gtest.T) {
 		q1 := gqueue.New(2)
+		defer q1.Close()
 		q1.Push(1)
 		q1.Push(2)
 		// wait sync to channel
 		time.Sleep(10 * time.Millisecond)
 		t.Assert(q1.Len(), 2)
-		q1.Close()
 	})
 }
 
 func Test_Issue2509(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		q := gqueue.New()
+		defer q.Close()
 		q.Push(1)
 		q.Push(2)
 		q.Push(3)
@@ -106,3 +109,22 @@ func Test_Issue2509(t *testing.T) {
 		t.Assert(q.Len(), 0)
 	})
 }
+
+// Issue #4376
+func TestIssue4376(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		gq := gqueue.New()
+		defer gq.Close()
+		cq := make(chan int, 100000)
+		defer close(cq)
+
+		for i := range 11603 {
+			gq.Push(i)
+			cq <- i
+		}
+		// May be not equal because of the async channel reading goroutine.
+		t.Log(gq.Len(), len(cq))
+		time.Sleep(50 * time.Millisecond)
+		t.Log(gq.Len(), len(cq))
+	})
+}

container/gset/gset_z_example_any_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test

container/gset/gset_z_example_int_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test

container/gset/gset_z_example_str_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gset_test

container/gtree/gtree_z_avl_tree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test

container/gtree/gtree_z_b_tree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test

container/gtree/gtree_z_example_avltree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test

container/gtree/gtree_z_example_btree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/Agogf/gf.
 
 package gtree_test

container/gtree/gtree_z_example_redblacktree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test

container/gtree/gtree_z_example_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/Agogf/gf.
 
 package gtree_test

container/gtree/gtree_z_redblack_tree_test.go

@@ -1,7 +1,7 @@
 // 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 gm file,
+// If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gtree_test

container/gvar/gvar_map.go

@@ -40,18 +40,21 @@ func (v *Var) MapStrVar(option ...MapOption) map[string]*Var {
 }
 
 // MapDeep converts and returns `v` as map[string]any recursively.
+//
 // Deprecated: used Map instead.
 func (v *Var) MapDeep(tags ...string) map[string]any {
 	return gconv.MapDeep(v.Val(), tags...)
 }
 
 // MapStrStrDeep converts and returns `v` as map[string]string recursively.
+//
 // Deprecated: used MapStrStr instead.
 func (v *Var) MapStrStrDeep(tags ...string) map[string]string {
 	return gconv.MapStrStrDeep(v.Val(), tags...)
 }
 
 // MapStrVarDeep converts and returns `v` as map[string]*Var recursively.
+//
 // Deprecated: used MapStrVar instead.
 func (v *Var) MapStrVarDeep(tags ...string) map[string]*Var {
 	m := v.MapDeep(tags...)
@@ -72,6 +75,7 @@ func (v *Var) Maps(option ...MapOption) []map[string]any {
 }
 
 // MapsDeep converts `value` to []map[string]any recursively.
+//
 // Deprecated: used Maps instead.
 func (v *Var) MapsDeep(tags ...string) []map[string]any {
 	return gconv.MapsDeep(v.Val(), tags...)

container/gvar/gvar_vars.go

@@ -15,14 +15,25 @@ type Vars []*Var
 
 // Strings converts and returns `vs` as []string.
 func (vs Vars) Strings() (s []string) {
+	s = make([]string, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.String())
 	}
 	return s
 }
 
+// Bools converts and returns `vs` as []bool.
+func (vs Vars) Bools() (s []bool) {
+	s = make([]bool, 0, len(vs))
+	for _, v := range vs {
+		s = append(s, v.Bool())
+	}
+	return s
+}
+
 // Interfaces converts and returns `vs` as []any.
 func (vs Vars) Interfaces() (s []any) {
+	s = make([]any, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Val())
 	}
@@ -31,6 +42,7 @@ func (vs Vars) Interfaces() (s []any) {
 
 // Float32s converts and returns `vs` as []float32.
 func (vs Vars) Float32s() (s []float32) {
+	s = make([]float32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Float32())
 	}
@@ -39,6 +51,7 @@ func (vs Vars) Float32s() (s []float32) {
 
 // Float64s converts and returns `vs` as []float64.
 func (vs Vars) Float64s() (s []float64) {
+	s = make([]float64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Float64())
 	}
@@ -47,6 +60,7 @@ func (vs Vars) Float64s() (s []float64) {
 
 // Ints converts and returns `vs` as []Int.
 func (vs Vars) Ints() (s []int) {
+	s = make([]int, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int())
 	}
@@ -55,6 +69,7 @@ func (vs Vars) Ints() (s []int) {
 
 // Int8s converts and returns `vs` as []int8.
 func (vs Vars) Int8s() (s []int8) {
+	s = make([]int8, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int8())
 	}
@@ -63,6 +78,7 @@ func (vs Vars) Int8s() (s []int8) {
 
 // Int16s converts and returns `vs` as []int16.
 func (vs Vars) Int16s() (s []int16) {
+	s = make([]int16, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int16())
 	}
@@ -71,6 +87,7 @@ func (vs Vars) Int16s() (s []int16) {
 
 // Int32s converts and returns `vs` as []int32.
 func (vs Vars) Int32s() (s []int32) {
+	s = make([]int32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int32())
 	}
@@ -79,6 +96,7 @@ func (vs Vars) Int32s() (s []int32) {
 
 // Int64s converts and returns `vs` as []int64.
 func (vs Vars) Int64s() (s []int64) {
+	s = make([]int64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Int64())
 	}
@@ -87,6 +105,7 @@ func (vs Vars) Int64s() (s []int64) {
 
 // Uints converts and returns `vs` as []uint.
 func (vs Vars) Uints() (s []uint) {
+	s = make([]uint, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint())
 	}
@@ -95,6 +114,7 @@ func (vs Vars) Uints() (s []uint) {
 
 // Uint8s converts and returns `vs` as []uint8.
 func (vs Vars) Uint8s() (s []uint8) {
+	s = make([]uint8, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint8())
 	}
@@ -103,6 +123,7 @@ func (vs Vars) Uint8s() (s []uint8) {
 
 // Uint16s converts and returns `vs` as []uint16.
 func (vs Vars) Uint16s() (s []uint16) {
+	s = make([]uint16, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint16())
 	}
@@ -111,6 +132,7 @@ func (vs Vars) Uint16s() (s []uint16) {
 
 // Uint32s converts and returns `vs` as []uint32.
 func (vs Vars) Uint32s() (s []uint32) {
+	s = make([]uint32, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint32())
 	}
@@ -119,6 +141,7 @@ func (vs Vars) Uint32s() (s []uint32) {
 
 // Uint64s converts and returns `vs` as []uint64.
 func (vs Vars) Uint64s() (s []uint64) {
+	s = make([]uint64, 0, len(vs))
 	for _, v := range vs {
 		s = append(s, v.Uint64())
 	}

container/gvar/gvar_z_unit_vars_test.go

@@ -22,6 +22,7 @@ func TestVars(t *testing.T) {
 			gvar.New(3),
 		}
 		t.AssertEQ(vs.Strings(), []string{"1", "2", "3"})
+		t.AssertEQ(vs.Bools(), []bool{true, true, true})
 		t.AssertEQ(vs.Interfaces(), []any{1, 2, 3})
 		t.AssertEQ(vs.Float32s(), []float32{1, 2, 3})
 		t.AssertEQ(vs.Float64s(), []float64{1, 2, 3})
@@ -38,6 +39,46 @@ func TestVars(t *testing.T) {
 	})
 }
 
+func TestVars_Bools(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with various boolean-like values
+		var vs = gvar.Vars{
+			gvar.New(true),
+			gvar.New(false),
+			gvar.New(1),
+			gvar.New(0),
+			gvar.New("true"),
+			gvar.New("false"),
+			gvar.New("1"),
+			gvar.New("0"),
+		}
+		expected := []bool{true, false, true, false, true, false, true, false}
+		t.AssertEQ(vs.Bools(), expected)
+	})
+}
+
+func TestVars_Empty(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with empty Vars
+		var vs = gvar.Vars{}
+		t.AssertEQ(vs.Strings(), []string{})
+		t.AssertEQ(vs.Bools(), []bool{})
+		t.AssertEQ(vs.Interfaces(), []any{})
+		t.AssertEQ(vs.Ints(), []int{})
+		t.AssertEQ(vs.Float64s(), []float64{})
+	})
+}
+
+func TestVars_SingleElement(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		// Test with single element
+		var vs = gvar.Vars{gvar.New(42)}
+		t.AssertEQ(vs.Strings(), []string{"42"})
+		t.AssertEQ(vs.Bools(), []bool{true})
+		t.AssertEQ(vs.Ints(), []int{42})
+	})
+}
+
 func TestVars_Scan(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {

contrib/config/apollo/apollo.go

@@ -19,9 +19,20 @@ import (
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gcfg"
 	"github.com/gogf/gf/v2/os/gctx"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
+const (
+	apolloNamespaceDelimiter = ","
+)
+
 // Config is the configuration object for apollo client.
 type Config struct {
 	AppID             string `v:"required"` // See apolloConfig.Config.
@@ -38,9 +49,10 @@ type Config struct {
 
 // Client implements gcfg.Adapter implementing using apollo service.
 type Client struct {
-	config Config        // Config object when created.
-	client agollo.Client // Apollo client.
-	value  *g.Var        // Configmap content cached. It is `*gjson.Json` value internally.
+	config   Config                // Config object when created.
+	client   agollo.Client         // Apollo client.
+	value    *g.Var                // Configmap content cached. It is `*gjson.Json` value internally.
+	watchers *gcfg.WatcherRegistry // Watchers for watching file changes.
 }
 
 // New creates and returns gcfg.Adapter implementing using apollo service.
@@ -54,8 +66,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 		config.NamespaceName = storage.GetDefaultNamespace()
 	}
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 	// Apollo client.
 	client.client, err = agollo.StartWithConfig(func() (*apolloConfig.AppConfig, error) {
@@ -89,11 +102,19 @@ func (c *Client) Available(ctx context.Context, resource ...string) (ok bool) {
 	if len(resource) == 0 && !c.value.IsNil() {
 		return true
 	}
-	var namespace = c.config.NamespaceName
+
+	namespaces := gstr.SplitAndTrim(c.config.NamespaceName, apolloNamespaceDelimiter)
 	if len(resource) > 0 {
-		namespace = resource[0]
+		namespaces = resource
 	}
-	return c.client.GetConfig(namespace) != nil
+
+	for _, namespace := range namespaces {
+		if c.client.GetConfig(namespace) == nil {
+			return false
+		}
+	}
+
+	return true
 }
 
 // Get retrieves and returns value by specified `pattern` in current resource.
@@ -132,18 +153,47 @@ func (c *Client) OnNewestChange(event *storage.FullChangeEvent) {
 }
 
 func (c *Client) updateLocalValue(ctx context.Context) (err error) {
-	var j = gjson.New(nil)
-	cache := c.client.GetConfigCache(c.config.NamespaceName)
-	cache.Range(func(key, value any) bool {
-		err = j.Set(gconv.String(key), value)
-		if err != nil {
-			return false
-		}
-		return true
-	})
-	cache.Clear()
+	j := gjson.New(nil)
+	content := gjson.New(nil, true)
+
+	for _, namespace := range gstr.SplitAndTrim(c.config.NamespaceName, apolloNamespaceDelimiter) {
+		cache := c.client.GetConfigCache(namespace)
+		cache.Range(func(key, value any) bool {
+			err = j.Set(gconv.String(key), value)
+			if err != nil {
+				return false
+			}
+			err = content.Set(gconv.String(key), value)
+			return err == nil
+		})
+		cache.Clear()
+	}
+
 	if err == nil {
 		c.value.Set(j)
+		adapterCtx := NewAdapterCtx(ctx).WithOperation(gcfg.OperationUpdate).WithNamespace(c.config.NamespaceName).
+			WithAppId(c.config.AppID).WithCluster(c.config.Cluster).WithContent(content)
+		c.notifyWatchers(adapterCtx.Ctx)
 	}
 	return
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}

contrib/config/apollo/apollo_adapter_ctx.go

@@ -0,0 +1,132 @@
+// 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 apollo implements gcfg.Adapter using apollo service.
+package apollo
+
+import (
+	"context"
+
+	"github.com/gogf/gf/v2/encoding/gjson"
+	"github.com/gogf/gf/v2/os/gcfg"
+	"github.com/gogf/gf/v2/os/gctx"
+)
+
+const (
+	// ContextKeyNamespace is the context key for namespace
+	ContextKeyNamespace gctx.StrKey = "namespace"
+	// ContextKeyAppId is the context key for appId
+	ContextKeyAppId gctx.StrKey = "appId"
+	// ContextKeyCluster is the context key for cluster
+	ContextKeyCluster gctx.StrKey = "cluster"
+)
+
+// ApolloAdapterCtx is the context adapter for Apollo configuration
+type ApolloAdapterCtx struct {
+	Ctx context.Context
+}
+
+// NewAdapterCtxWithCtx creates and returns a new ApolloAdapterCtx with the given context.
+func NewAdapterCtxWithCtx(ctx context.Context) *ApolloAdapterCtx {
+	if ctx == nil {
+		ctx = context.Background()
+	}
+	return &ApolloAdapterCtx{Ctx: ctx}
+}
+
+// NewAdapterCtx creates and returns a new ApolloAdapterCtx.
+// If context is provided, it will be used; otherwise, a background context is created.
+func NewAdapterCtx(ctx ...context.Context) *ApolloAdapterCtx {
+	if len(ctx) > 0 {
+		return NewAdapterCtxWithCtx(ctx[0])
+	}
+	return NewAdapterCtxWithCtx(context.Background())
+}
+
+// GetAdapterCtx creates a new ApolloAdapterCtx with the given context
+func GetAdapterCtx(ctx context.Context) *ApolloAdapterCtx {
+	return NewAdapterCtxWithCtx(ctx)
+}
+
+// WithOperation sets the operation in the context
+func (a *ApolloAdapterCtx) WithOperation(operation gcfg.OperationType) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyOperation, operation)
+	return a
+}
+
+// WithNamespace sets the namespace in the context
+func (a *ApolloAdapterCtx) WithNamespace(namespace string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyNamespace, namespace)
+	return a
+}
+
+// WithAppId sets the appId in the context
+func (a *ApolloAdapterCtx) WithAppId(appId string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyAppId, appId)
+	return a
+}
+
+// WithCluster sets the cluster in the context
+func (a *ApolloAdapterCtx) WithCluster(cluster string) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, ContextKeyCluster, cluster)
+	return a
+}
+
+// WithContent sets the content in the context
+func (a *ApolloAdapterCtx) WithContent(content *gjson.Json) *ApolloAdapterCtx {
+	a.Ctx = context.WithValue(a.Ctx, gcfg.ContextKeyContent, content)
+	return a
+}
+
+// GetNamespace retrieves the namespace from the context
+func (a *ApolloAdapterCtx) GetNamespace() string {
+	if v := a.Ctx.Value(ContextKeyNamespace); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetAppId retrieves the appId from the context
+func (a *ApolloAdapterCtx) GetAppId() string {
+	if v := a.Ctx.Value(ContextKeyAppId); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetCluster retrieves the cluster from the context
+func (a *ApolloAdapterCtx) GetCluster() string {
+	if v := a.Ctx.Value(ContextKeyCluster); v != nil {
+		if s, ok := v.(string); ok {
+			return s
+		}
+	}
+	return ""
+}
+
+// GetContent retrieves the content from the context
+func (a *ApolloAdapterCtx) GetContent() *gjson.Json {
+	if v := a.Ctx.Value(gcfg.ContextKeyContent); v != nil {
+		if s, ok := v.(*gjson.Json); ok {
+			return s
+		}
+	}
+	return gjson.New(nil)
+}
+
+// GetOperation retrieves the operation from the context
+func (a *ApolloAdapterCtx) GetOperation() gcfg.OperationType {
+	if v := a.Ctx.Value(gcfg.ContextKeyOperation); v != nil {
+		if s, ok := v.(gcfg.OperationType); ok {
+			return s
+		}
+	}
+	return ""
+}

contrib/config/apollo/go.mod

@@ -4,7 +4,7 @@ go 1.23.0
 
 require (
 	github.com/apolloconfig/agollo/v4 v4.3.1
-	github.com/gogf/gf/v2 v2.9.3
+	github.com/gogf/gf/v2 v2.9.5
 )
 
 require (
@@ -20,15 +20,15 @@ require (
 	github.com/grokify/html-strip-tags-go v0.1.0 // indirect
 	github.com/hashicorp/hcl v1.0.0 // indirect
 	github.com/magiconair/properties v1.8.10 // indirect
-	github.com/mattn/go-colorable v0.1.14 // indirect
+	github.com/mattn/go-colorable v0.1.13 // indirect
 	github.com/mattn/go-isatty v0.0.20 // indirect
 	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mitchellh/mapstructure v1.4.1 // indirect
 	github.com/olekukonko/errors v1.1.0 // indirect
 	github.com/olekukonko/ll v0.0.9 // indirect
-	github.com/olekukonko/tablewriter v1.0.9 // indirect
+	github.com/olekukonko/tablewriter v1.1.0 // indirect
 	github.com/pelletier/go-toml v1.9.3 // indirect
-	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rivo/uniseg v0.2.0 // indirect
 	github.com/spf13/afero v1.6.0 // indirect
 	github.com/spf13/cast v1.3.1 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
@@ -36,13 +36,13 @@ require (
 	github.com/spf13/viper v1.8.1 // indirect
 	github.com/subosito/gotenv v1.2.0 // indirect
 	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
-	go.opentelemetry.io/otel v1.37.0 // indirect
-	go.opentelemetry.io/otel/metric v1.37.0 // indirect
-	go.opentelemetry.io/otel/sdk v1.37.0 // indirect
-	go.opentelemetry.io/otel/trace v1.37.0 // indirect
-	golang.org/x/net v0.43.0 // indirect
+	go.opentelemetry.io/otel v1.38.0 // indirect
+	go.opentelemetry.io/otel/metric v1.38.0 // indirect
+	go.opentelemetry.io/otel/sdk v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	golang.org/x/net v0.40.0 // indirect
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
 	gopkg.in/ini.v1 v1.62.0 // indirect
 	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect

contrib/config/apollo/go.sum

@@ -204,9 +204,10 @@ github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPK
 github.com/magiconair/properties v1.8.10 h1:s31yESBquKXCV9a/ScB3ESkOjUYYv+X0rg8SYxI99mE=
 github.com/magiconair/properties v1.8.10/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
 github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU=
-github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
-github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
+github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA=
+github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg=
 github.com/mattn/go-isatty v0.0.3/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4=
+github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
@@ -228,8 +229,8 @@ github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5
 github.com/olekukonko/errors v1.1.0/go.mod h1:ppzxA5jBKcO1vIpCXQ9ZqgDh8iwODz6OXIGKU8r5m4Y=
 github.com/olekukonko/ll v0.0.9 h1:Y+1YqDfVkqMWuEQMclsF9HUR5+a82+dxJuL1HHSRpxI=
 github.com/olekukonko/ll v0.0.9/go.mod h1:En+sEW0JNETl26+K8eZ6/W4UQ7CYSrrgg/EdIYT2H8g=
-github.com/olekukonko/tablewriter v1.0.9 h1:XGwRsYLC2bY7bNd93Dk51bcPZksWZmLYuaTHR0FqfL8=
-github.com/olekukonko/tablewriter v1.0.9/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v1.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
+github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c/go.mod h1:lzWF7FIEvWOWxwDKqyGYQf6ZUaNfKdP144TG7ZOy1lc=
 github.com/pelletier/go-toml v1.9.3 h1:zeC5b1GviRUyKYd6OJPvBU/mcVDVoL1OhT17FCt5dSQ=
 github.com/pelletier/go-toml v1.9.3/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c=
@@ -239,13 +240,12 @@ github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZb
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI=
 github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
-github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
-github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc=
 github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
@@ -269,8 +269,8 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
 github.com/subosito/gotenv v1.2.0 h1:Slr1R9HxAlEKefgq5jn9U+DnETlIUa6HfgEzj0g5d7s=
 github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw=
 github.com/tevid/gohamcrest v1.1.1 h1:ou+xSqlIw1xfGTg1uq1nif/htZ2S3EzRqLm2BP+tYU0=
@@ -292,14 +292,16 @@ go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
 go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E=
 go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
 go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
-go.opentelemetry.io/otel v1.37.0 h1:9zhNfelUvx0KBfu/gb+ZgeAfAgtWrfHJZcAqFC228wQ=
-go.opentelemetry.io/otel v1.37.0/go.mod h1:ehE/umFRLnuLa/vSccNq9oS1ErUlkkK71gMcN34UG8I=
-go.opentelemetry.io/otel/metric v1.37.0 h1:mvwbQS5m0tbmqML4NqK+e3aDiO02vsf/WgbsdpcPoZE=
-go.opentelemetry.io/otel/metric v1.37.0/go.mod h1:04wGrZurHYKOc+RKeye86GwKiTb9FKm1WHtO+4EVr2E=
-go.opentelemetry.io/otel/sdk v1.37.0 h1:ItB0QUqnjesGRvNcmAcU0LyvkVyGJ2xftD29bWdDvKI=
-go.opentelemetry.io/otel/sdk v1.37.0/go.mod h1:VredYzxUvuo2q3WRcDnKDjbdvmO0sCzOvVAiY+yUkAg=
-go.opentelemetry.io/otel/trace v1.37.0 h1:HLdcFNbRQBE2imdSEgm/kwqmQj1Or1l/7bW6mxVK7z4=
-go.opentelemetry.io/otel/trace v1.37.0/go.mod h1:TlgrlQ+PtQO5XFerSPUYG0JSgGyryXewPGyayAWSBS0=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
 go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
@@ -383,8 +385,8 @@ golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc=
 golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM=
-golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
-golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
+golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
+golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
 golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
 golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
 golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
@@ -449,6 +451,7 @@ golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI=
 golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
@@ -460,8 +463,8 @@ golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

contrib/config/consul/consul.go

@@ -21,6 +21,12 @@ import (
 	"github.com/gogf/gf/v2/os/glog"
 )
 
+var (
+	// Compile-time checking for interface implementation.
+	_ gcfg.Adapter        = (*Client)(nil)
+	_ gcfg.WatcherAdapter = (*Client)(nil)
+)
+
 // Config is the configuration object for consul client.
 type Config struct {
 	// api.Config in consul package
@@ -41,6 +47,8 @@ type Client struct {
 	client *api.Client
 	// Configmap content cached. It is `*gjson.Json` value internally.
 	value *g.Var
+	// Watchers for watching file changes.
+	watchers *gcfg.WatcherRegistry
 }
 
 // New creates and returns gcfg.Adapter implementing using consul service.
@@ -55,8 +63,9 @@ func New(ctx context.Context, config Config) (adapter gcfg.Adapter, err error) {
 	}
 
 	client := &Client{
-		config: config,
-		value:  g.NewVar(nil, true),
+		config:   config,
+		value:    g.NewVar(nil, true),
+		watchers: gcfg.NewWatcherRegistry(),
 	}
 
 	client.client, err = api.NewClient(&config.ConsulConfig)
@@ -156,13 +165,26 @@ func (c *Client) addWatcher() (err error) {
 		if v, ok = raw.(*api.KVPair); !ok {
 			return
 		}
-
-		if err = c.doUpdate(v.Value); err != nil {
+		err = c.doUpdate(v.Value)
+		if err != nil {
 			c.config.Logger.Errorf(
 				context.Background(),
 				"watch config from consul path %+v update failed: %s",
 				c.config.Path, err,
 			)
+		} else {
+			var m *gjson.Json
+			m, err = gjson.LoadContent(v.Value, true)
+			if err != nil {
+				c.config.Logger.Errorf(
+					context.Background(),
+					"watch config from consul path %+v parse failed: %s",
+					c.config.Path, err,
+				)
+			} else {
+				adapterCtx := NewAdapterCtx().WithOperation(gcfg.OperationUpdate).WithPath(c.config.Path).WithContent(m)
+				c.notifyWatchers(adapterCtx.Ctx)
+			}
 		}
 	}
 
@@ -173,6 +195,7 @@ func (c *Client) addWatcher() (err error) {
 	return nil
 }
 
+// startAsynchronousWatch starts the asynchronous watch.
 func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
 	if err := plan.Run(c.config.ConsulConfig.Address); err != nil {
 		c.config.Logger.Errorf(
@@ -182,3 +205,23 @@ func (c *Client) startAsynchronousWatch(plan *watch.Plan) {
 		)
 	}
 }
+
+// AddWatcher adds a watcher for the specified configuration file.
+func (c *Client) AddWatcher(name string, f func(ctx context.Context)) {
+	c.watchers.Add(name, f)
+}
+
+// RemoveWatcher removes the watcher for the specified configuration file.
+func (c *Client) RemoveWatcher(name string) {
+	c.watchers.Remove(name)
+}
+
+// GetWatcherNames returns all watcher names.
+func (c *Client) GetWatcherNames() []string {
+	return c.watchers.GetNames()
+}
+
+// notifyWatchers notifies all watchers.
+func (c *Client) notifyWatchers(ctx context.Context) {
+	c.watchers.Notify(ctx)
+}