improve skip checks for internal/debug

日常更新

.gitignore

@@ -7,7 +7,6 @@
 .settings/
 .vscode/
 vender/
-log/
 composer.lock
 gitpush.sh
 pkg/
@@ -16,4 +15,3 @@ cbuild
 **/.DS_Store
 .vscode/
 go.sum
-

.travis.yml

@@ -21,11 +21,15 @@ addons:
   - local
 
 before_install:
-- pwd
+  - mysql -e 'CREATE DATABASE IF NOT EXISTS test;'
 
 install:
 - cat /etc/hosts
 
+before_script:
+- find . -name "*.go" | xargs gofmt -w
+- git diff --exit-code
+
 script:
 - cd g
 - GOARCH=386 go test -v ./...

DONATOR.MD

@@ -4,7 +4,7 @@
 | Name | Channel | Amount
 |---|---|---
 |[hailaz](https://gitee.com/hailaz)|gitee|￥20.00
-|[ireadx](https://github.com/ireadx)|alipay|￥201.00
+|[ireadx](https://github.com/ireadx)|alipay|￥301.00
 |[mg91](https://gitee.com/mg91)|gitee|￥10.00
 |[pibigstar](https://github.com/pibigstar)|alipay|￥10.00
 |[tiangenglan](https://gitee.com/tiangenglan)|gitee|￥30.00
@@ -12,9 +12,13 @@
 |[zhuhuan12](https://gitee.com/zhuhuan12)|gitee|￥50.00
 |[zfan_codes](https://gitee.com/zfan_codes)|gitee|￥10.00
 |[arden](https://github.com/arden)|alipay|￥10.00
+|x*z|wechat|￥20.00
 |潘兄|wechat|￥100.00
 |Fly的狐狸|wechat|￥100.00
+|全|alipay|￥100.00
 |土豆相公|alipay|￥66.60
+|Hades|alipay|￥66.66
+|蔡蔡|wechat|￥666.00
 |上海金保证网络科技|bank|￥2000.00
 
 

README.MD

@@ -1,17 +1,17 @@
-# GoFrame 
+# GoFrame
 <div align=center>
 <img src="https://goframe.org/logo.png" width="100"/>
 
-[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
-[![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
-[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf) 
+[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf/g#pkg-subdirectories)
+[![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf)
+[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
 [![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)
 
 </div>
 
-`GF(GoFrame)` is a modular, full-featured and production-ready application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features. 
+`GF(GoFrame)` is a modular, full-featured and production-ready application development framework of golang. Providing a series of core components and dozens of practical modules, such as: memcache, configure, validator, logging, array/queue/set/map containers, timer/timing tasks, file/memory lock, object pool, database ORM, etc. Supporting web server integrated with router, cookie, session, logger, template, https, hooks, rewrites and many more features.
 
 
 # Installation
@@ -40,6 +40,7 @@ golang version >= 1.10
 
 # Quick Start
 
+## Hello World
 ```go
 package main
 
@@ -56,8 +57,231 @@ func main() {
     s.Run()
 }
 ```
+## Rich Router
+```go
+package main
 
-[View More..](https://goframe.org/start/index)
+import (
+    "github.com/gogf/gf/g/net/ghttp"
+    "github.com/gogf/gf/g"
+)
+
+func main() {
+    s := g.Server()
+    s.BindHandler("/{class}-{course}/:name/*act", func(r *ghttp.Request) {
+        r.Response.Writeln(r.Get("class"))
+        r.Response.Writeln(r.Get("course"))
+        r.Response.Writeln(r.Get("name"))
+        r.Response.Writeln(r.Get("act"))
+    })
+    s.SetPort(8199)
+    s.Run()
+}
+```
+## Group Routers
+```go
+package main
+
+import (
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/net/ghttp"
+)
+
+type Object struct {}
+
+func (o *Object) Show(r *ghttp.Request) {
+	r.Response.Writeln("Object Show")
+}
+
+func (o *Object) Delete(r *ghttp.Request) {
+	r.Response.Writeln("Object REST Delete")
+}
+
+func Handler(r *ghttp.Request) {
+	r.Response.Writeln("Handler")
+}
+
+func HookHandler(r *ghttp.Request) {
+	r.Response.Writeln("Hook Handler")
+}
+
+func main() {
+	s     := g.Server()
+	obj   := new(Object)
+	group := s.Group("/api")
+	group.ALL ("*",            HookHandler, ghttp.HOOK_BEFORE_SERVE)
+	group.ALL ("/handler",     Handler)
+	group.ALL ("/obj",         obj)
+	group.GET ("/obj/showit",  obj, "Show")
+	group.REST("/obj/rest",    obj)
+	s.SetPort(8199)
+	s.Run()
+}
+```
+or
+```go
+func main() {
+	s   := g.Server()
+	obj := new(Object)
+	s.Group("/api").Bind([]ghttp.GroupItem{
+		{"ALL",  "*",            HookHandler, ghttp.HOOK_BEFORE_SERVE},
+		{"ALL",  "/handler",     Handler},
+		{"ALL",  "/obj",         obj},
+		{"GET",  "/obj/showit",  obj, "Show"},
+		{"REST", "/obj/rest",    obj},
+	})
+	s.SetPort(8199)
+	s.Run()
+}
+```
+## Multi ports & domains
+```go
+package main
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
+)
+
+func Hello1(r *ghttp.Request) {
+    r.Response.Write("127.0.0.1: Hello1!")
+}
+
+func Hello2(r *ghttp.Request) {
+    r.Response.Write("localhost: Hello2!")
+}
+
+func main() {
+    s := g.Server()
+    s.Domain("127.0.0.1").BindHandler("/", Hello1)
+    s.Domain("localhost").BindHandler("/", Hello2)
+    s.SetPort(8100, 8200, 8300)
+    s.Run()
+}
+```
+## Template Engine
+```go
+package main
+
+import (
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/net/ghttp"
+)
+
+func main() {
+	s := g.Server()
+	s.BindHandler("/template", func(r *ghttp.Request) {
+		r.Response.WriteTpl("index.tpl", g.Map{
+			"id":   123,
+			"name": "john",
+		})
+	})
+	s.SetPort(8199)
+	s.Run()
+}
+```
+## File Uploading
+```go
+func Upload(r *ghttp.Request) {
+    if f, h, e := r.FormFile("upload-file"); e == nil {
+        defer f.Close()
+        name   := gfile.Basename(h.Filename)
+        buffer := make([]byte, h.Size)
+        f.Read(buffer)
+        gfile.PutBinContents("/tmp/" + name, buffer)
+        r.Response.Write(name + " uploaded successly")
+    } else {
+        r.Response.Write(e.Error())
+    }
+}
+```
+
+## ORM Operations
+
+### 1. Retrieving instance
+```go
+db := g.DB()
+db := g.DB("user-center")
+```
+### 2. Chaining Operations
+
+`Where + string`
+```go
+// SELECT * FROM user WHERE uid>1 LIMIT 0,10
+r, err := db.Table("user").Where("uid > ?", 1).Limit(0, 10).Select()
+
+// SELECT uid,name FROM user WHERE uid>1 LIMIT 0,10
+r, err := db.Table("user").Fileds("uid,name").Where("uid > ?", 1).Limit(0, 10).Select()
+
+// SELECT * FROM user WHERE uid=1
+r, err := db.Table("user").Where("u.uid=1",).One()
+r, err := db.Table("user").Where("u.uid", 1).One()
+r, err := db.Table("user").Where("u.uid=?", 1).One()
+// SELECT * FROM user WHERE (uid=1) AND (name='john')
+r, err := db.Table("user").Where("uid", 1).Where("name", "john").One()
+r, err := db.Table("user").Where("uid=?", 1).And("name=?", "john").One()
+// SELECT * FROM user WHERE (uid=1) OR (name='john')
+r, err := db.Table("user").Where("uid=?", 1).Or("name=?", "john").One()
+```
+`Where + map`
+```go
+// SELECT * FROM user WHERE uid=1 AND name='john'
+r, err := db.Table("user").Where(g.Map{"uid" : 1, "name" : "john"}).One()
+// SELECT * FROM user WHERE uid=1 AND age>18
+r, err := db.Table("user").Where(g.Map{"uid" : 1, "age>" : 18}).One()
+```
+`Where + struct/*struct`
+```go
+type User struct {
+    Id       int    `json:"uid"`
+    UserName string `gconv:"name"`
+}
+// SELECT * FROM user WHERE uid =1 AND name='john'
+r, err := db.Table("user").Where(User{ Id : 1, UserName : "john"}).One()
+// SELECT * FROM user WHERE uid =1
+r, err := db.Table("user").Where(&User{ Id : 1}).One()
+```
+### 3. Update & Delete
+```go
+// UPDATE user SET name='john guo' WHERE name='john'
+r, err := db.Table("user").Data(gdb.Map{"name" : "john guo"}).Where("name=?", "john").Update()
+r, err := db.Table("user").Data("name='john guo'").Where("name=?", "john").Update()
+// UPDATE user SET status=1 ORDER BY login_time asc LIMIT 10
+r, err := db.Table("user").Data("status", 1).OrderBy("login_time asc").Limit(10).Update
+
+// DELETE FROM user WHERE uid=10
+r, err := db.Table("user").Where("uid=?", 10).Delete()
+// DELETE FROM user ORDER BY login_time asc LIMIT 10
+r, err := db.Table("user").OrderBy("login_time asc").Limit(10).Delete()
+```
+### 4. Insert & Replace & Save
+```go
+r, err := db.Table("user").Data(g.Map{"name": "john"}).Insert()
+r, err := db.Table("user").Data(g.Map{"uid": 10000, "name": "john"}).Replace()
+r, err := db.Table("user").Data(g.Map{"uid": 10001, "name": "john"}).Save()
+```
+### 5. Transaction
+```go
+if tx, err := db.Begin(); err == nil {
+    r, err := tx.Save("user", g.Map{
+        "uid"  :  1,
+        "name" : "john",
+    })
+    tx.Commit()
+}
+```
+### 6. Error Handling
+```go
+func GetOrderInfo(id int) (order *Order, err error) {
+    err = g.DB().Table("order").Where("id", id).Struct(&order)
+    if err != nil && err == sql.ErrNoRows {
+        err = nil
+    }
+    return
+}
+```
+
+[More Features...](https://goframe.org/start/index)
 
 
 # License

README_ZH.MD

@@ -2,9 +2,9 @@
 <div align=center>
 <img src="https://goframe.org/logo.png" width="100"/>
 
-[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
+[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf/g#pkg-subdirectories) 
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
-[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf)](https://goreportcard.com/report/github.com/gogf/gf) 
+[![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
 [![Production Ready](https://img.shields.io/badge/production-ready-blue.svg)](https://github.com/gogf/gf)
 [![License](https://img.shields.io/github/license/gogf/gf.svg?style=flat)](https://github.com/gogf/gf)

RELEASE.MD

@@ -1,4 +1,76 @@
-# `v1.7.0`
+# `v1.8.0` (2019-07-15)
+
+## 新功能改进
+1. 框架目前 `69` 个开发模块（不包括内部模块），原生代码 `65302` 行（不包含第三包依赖包），单元测试覆盖率达到`77%`；
+1. 新增`gerror`错误处理模块：https://goframe.org/errors/gerror/index
+1. 改进`gcharset`字符编码转换模块，支持更多的字符集：https://goframe.org/encoding/gcharset/index
+1. 新增`gmutex`模块，基于`channel`实现的高级互斥锁模块，支持更丰富的互斥锁特性：https://goframe.org/os/gmutex/index
+1. 改进`glog`日志模块：
+    - 新增日志异步输出特性：https://goframe.org/os/glog/async
+    - 新增`Flags`额外功能特性：https://goframe.org/os/glog/flags
+    - 新增`Json`数据格式输出：https://goframe.org/os/glog/json
+    - 新增自定义`Writer`接口特性：https://goframe.org/os/glog/writer
+    - **修改`Backtrace`名称为`Stack`，并改进调用堆栈输出格式；**
+    - 新增`Expose`方法暴露内部默认`Logger`对象；
+1. 改进`gdb`数据库ORM模块：
+    - **改进错误处理，当数据库操作没有查询到数据时，`error`返回`sql.ErrNoRows`**：https://goframe.org/database/gdb/error
+    - 改进`Update`/`Delete`方法支持`Order BY`及`LIMIT`特性；
+    - 数据库链式操作及方法操作中，预处理变量参数支持`slice`参数：https://goframe.org/database/gdb/chaining/model
+    - **修改`Priority`权重配置名称为`Weight`；**
+    - 新增`Debug`配置，可配置开启/关闭调试特性：https://goframe.org/database/gdb/config
+    - 新增`Offset`方法，该方法为可选链式操作方法，`pgsql`数据库可直接通过`Limit`方法第二个参数自动识别为`Offset`语法；
+    - 改进数据库动态切换特性，支持不同数据库类型的当前操作数据库切换；
+    - 改进简化配置文件结构：https://goframe.org/database/gdb/config
+1. 改进`gconv`数据转换模块：
+    - 对结构体对象转换时支持更多的标签：`gconv/c/json`；
+    - 支持`*struct/[]struct/[]*struct`自动初始化创建对象/数组：https://goframe.org/util/gconv/struct
+    - 新增`Strusts/StrctsDeep`方法，用于结构体数组的递归转换；
+    - 新增`StructDeep`方法，用于对结构体对象的递归转换；
+    - 新增`MapDeep`方法，用于对结构体属性的递归转换；
+1. 改进`ghttp`模块：
+    - 改进`ghttp`模块的分组路由功能，完善逻辑处理细节，程序更加稳健；
+    - 改进`ghttp.Request.Get*ToStruct`方法，支持`params/param/p`标签，支持结构体递归转换，并且支持`**struct`参数的对象自动初始化；
+    - 改进`ghttp.CORSDefault`的跨域设置参数，`AllowOrigin`参数调整为`*`；
+1. 改进`gvalid`数据校验模块：
+    - 增加对校验标签`gvalid/valid/v`的支持；
+    - 改进`CheckStruct`支持对结构体对象的递归校验：https://goframe.org/util/gvalid/checkstruct
+1. 改进`gtcp`TCP通信模块：
+    - 改进通信包协议设计，更加轻量级高效：https://goframe.org/net/gtcp/conn/pkg
+    - 改进`TCP Server`增加对`TLS`的支持：https://goframe.org/net/gtcp/tls
+    - 增加`Server.Cloce`服务端关闭方法；
+1. 改进`gproc`模块的通信数据结构，并使用`gtcp`的轻量级包协议重构消息发送逻辑；
+1. 改进`gqueue`模块增加数据同步缓冲机制，解决大数据量下的内存占用及延迟问题；
+1. 改进`gmlock`模块，使用`gmutex`模块替换内部的互斥锁，增加更多的操作方法；
+1. 改进`gaes`加密模块，增加`CBC`模式的加密/解密方法：
+1. 改进`garray.Range/SubSlice`方法，改进设计，提高性能；
+1. 改进`gjson`/`gparser`模块实现`MarshalJSON`接口以实现自定义的`JSON`数据格式转换；
+1. **改进`crypto`分类下模块的方法返回值，增加`error`错误变量返回，以保证更严谨的接口设计风格；**
+1. **改进`gbase64`模块，输入输出类型发生改变，并增加多个相关方法；**
+1. 改进`gflock`修改方法名`UnLock`为`Unlock`，新增`IsRLocked`方法；
+1. 新增`gfile.CopyFile/CopyDir`方法，用于文件及目录的复制；
+1. 改进`gjson/gparser/gvar/gcfg`模块增加更多的类型转换方法；
+1. 改进`gcache`模块，过期时间参数支持`time.Duration`类型；
+1. 新增`internal/structs`包，强大且便捷的结构体解析，并改进框架中所有涉及到结构体反射处理的模块；
+1. 改进`gbinary`增加封装方法对`BigEndian`的支持；
+
+## Bug Fix
+1. 修复`garray.Search`返回值问题；
+1. 修复`garray.Contains`, `garray.New*ArrayFromCopy`方法逻辑问题；
+1. 修复`gjson.Remove`删除`slice`参数问题；
+1. 修复`gtree.AVLTree.Remove`方法返回值问题；
+1. 修复`gqueue.Size`不准确的大小问题；
+1. 修复`queue.Close`问题；
+1. 修复`gcache.GetOrSetLockFunc`当回调函数返回`nil`结果时的死锁问题；
+1. 修复`gfsnotify.Add`方法默认递归监控添加失效问题；
+1. 修复`gdb.Model.Scan`在某些参数类型下的失效问题；
+
+## 注意事项
+
+请注意以上粗体文字部分，如有使用，在您升级时可能会出现不兼容性。
+
+
+
+# `v1.7.0` (2019-06-10)
 ## 新功能/改进
 1. 重构改进`glog`模块：
     - 去掉日志模块所有的锁机制，改为无锁设计，执行性能更加高效

TODO.MD

@@ -48,8 +48,8 @@
 1. 改进gdb对pgsql/mssql/oracle的支持，使用方法覆盖的方式改进操作，而不是完全依靠正则替换的方式；
 1. gdb的Cache缓存功能增加可自定义缓存接口，以便支持外部缓存功能，缓存接口可以通过io.ReadWriter接口实现；
 1. grpool增加支持阻塞添加任务接口；
-
-
+1. gdb.Model在链式安全的对象创建中增加sync.Pool的使用；
+1. 增加g.Table快捷方法以方便操作数据表，但是得考虑后续模型操作设计，特别是脚手架的模型管理；
 
 # DONE
 1.  gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；

g/container/garray/garray.go

@@ -6,4 +6,3 @@
 
 // Package garray provides concurrent-safe/unsafe arrays.
 package garray
-

g/container/garray/garray_func.go

@@ -6,15 +6,14 @@
 
 package garray
 
-
 type apiSliceInterface interface {
-    Slice() []interface{}
+	Slice() []interface{}
 }
 
 type apiSliceInt interface {
-    Slice() []int
+	Slice() []int
 }
 
 type apiSliceString interface {
-    Slice() []string
-}
+	Slice() []string
+}

g/container/garray/garray_normal_int.go

@@ -7,13 +7,14 @@
 package garray
 
 import (
-    "bytes"
-	"fmt"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+
 	"github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 type IntArray struct {
@@ -24,40 +25,40 @@ type IntArray struct {
 // NewIntArray creates and returns an empty array.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewIntArray(unsafe...bool) *IntArray {
+func NewIntArray(unsafe ...bool) *IntArray {
 	return NewIntArraySize(0, 0, unsafe...)
 }
 
 // NewIntArraySize create and returns an array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewIntArraySize(size int, cap int, unsafe...bool) *IntArray {
-    return &IntArray{
-        mu    : rwmutex.New(unsafe...),
-        array : make([]int, size, cap),
-    }
+func NewIntArraySize(size int, cap int, unsafe ...bool) *IntArray {
+	return &IntArray{
+		mu:    rwmutex.New(unsafe...),
+		array: make([]int, size, cap),
+	}
 }
 
 // NewIntArrayFrom creates and returns an array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
+func NewIntArrayFrom(array []int, unsafe ...bool) *IntArray {
 	return &IntArray{
-        mu    : rwmutex.New(unsafe...),
-        array : array,
-    }
+		mu:    rwmutex.New(unsafe...),
+		array: array,
+	}
 }
 
 // NewIntArrayFromCopy creates and returns an array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewIntArrayFromCopy(array []int, unsafe...bool) *IntArray {
-    newArray := make([]int, len(array))
-    copy(newArray, array)
-    return &IntArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+func NewIntArrayFromCopy(array []int, unsafe ...bool) *IntArray {
+	newArray := make([]int, len(array))
+	copy(newArray, array)
+	return &IntArray{
+		mu:    rwmutex.New(unsafe...),
+		array: newArray,
+	}
 }
 
 // Get returns the value of the specified index,
@@ -79,83 +80,83 @@ func (a *IntArray) Set(index int, value int) *IntArray {
 
 // SetArray sets the underlying slice array with the given <array>.
 func (a *IntArray) SetArray(array []int) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array = array
-    return a
+	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.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
+	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.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += v
-    }
-    return
+	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.mu.Lock()
-    defer a.mu.Unlock()
-    if len(reverse) > 0 && reverse[0] {
-        sort.Slice(a.array, func(i, j int) bool {
-            if a.array[i] < a.array[j] {
-                return false
-            }
-            return true
-        })
-    } else {
-        sort.Ints(a.array)
-    }
-    return a
+func (a *IntArray) Sort(reverse ...bool) *IntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(reverse) > 0 && reverse[0] {
+		sort.Slice(a.array, func(i, j int) bool {
+			if a.array[i] < a.array[j] {
+				return false
+			}
+			return true
+		})
+	} else {
+		sort.Ints(a.array)
+	}
+	return a
 }
 
 // SortFunc sorts the array by custom function <less>.
 func (a *IntArray) SortFunc(less func(v1, v2 int) bool) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    sort.Slice(a.array, func(i, j int) bool {
-        return less(a.array[i], a.array[j])
-    })
-    return a
+	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 <value> to the front of <index>.
 func (a *IntArray) InsertBefore(index int, value int) *IntArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index : ]...)
-	a.array = append(a.array[0 : index], value)
+	rear := append([]int{}, a.array[index:]...)
+	a.array = append(a.array[0:index], value)
 	a.array = append(a.array, rear...)
-    return a
+	return a
 }
 
 // InsertAfter inserts the <value> to the back of <index>.
 func (a *IntArray) InsertAfter(index int, value int) *IntArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index + 1:]...)
-	a.array = append(a.array[0 : index + 1], value)
+	rear := append([]int{}, a.array[index+1:]...)
+	a.array = append(a.array[0:index+1], value)
 	a.array = append(a.array, rear...)
-    return a
+	return a
 }
 
 // Remove removes an item by index.
@@ -164,139 +165,191 @@ func (a *IntArray) Remove(index int) int {
 	defer a.mu.Unlock()
 	// Determine array boundaries when deleting to improve deletion efficiency.
 	if index == 0 {
-		value  := a.array[0]
-		a.array = a.array[1 : ]
+		value := a.array[0]
+		a.array = a.array[1:]
 		return value
-	} else if index == len(a.array) - 1 {
-		value  := a.array[index]
-		a.array = a.array[: index]
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
 		return value
 	}
 	// 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 : ]...)
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
 	return value
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
-func (a *IntArray) PushLeft(value...int) *IntArray {
-    a.mu.Lock()
-    a.array = append(value, a.array...)
-    a.mu.Unlock()
-    return a
+func (a *IntArray) PushLeft(value ...int) *IntArray {
+	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.mu.Lock()
-    a.array = append(a.array, value...)
-    a.mu.Unlock()
-    return a
+func (a *IntArray) PushRight(value ...int) *IntArray {
+	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.
 func (a *IntArray) PopLeft() int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *IntArray) PopRight() int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *IntArray) PopRand() int {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *IntArray) PopRands(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]int, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]int, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *IntArray) PopLefts(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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 *IntArray) PopRights(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *IntArray) Range(start, end int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]int)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]int, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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 *IntArray) Range(start int, end ...int) []int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]int)(nil)
+	if a.mu.IsSafe() {
+		array = make([]int, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// 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 *IntArray) SubSlice(offset int, length ...int) []int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]int, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
 }
 
 // See PushRight.
-func (a *IntArray) Append(value...int) *IntArray {
+func (a *IntArray) Append(value ...int) *IntArray {
 	a.mu.Lock()
 	a.array = append(a.array, value...)
-    a.mu.Unlock()
-    return a
+	a.mu.Unlock()
+	return a
 }
 
 // Len returns the length of array.
@@ -325,26 +378,26 @@ func (a *IntArray) Slice() []int {
 
 // Clone returns a new array, which is a copy of current array.
 func (a *IntArray) Clone() (newArray *IntArray) {
-    a.mu.RLock()
-    array := make([]int, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewIntArrayFrom(array, !a.mu.IsSafe())
+	a.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.mu.Lock()
 	if len(a.array) > 0 {
-        a.array = make([]int, 0)
-    }
-    a.mu.Unlock()
-    return a
+		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 {
-    return a.Search(value) != -1
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
@@ -369,10 +422,10 @@ func (a *IntArray) Search(value int) int {
 // Unique uniques the array, clear repeated items.
 func (a *IntArray) Unique() *IntArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array) - 1; i++ {
+	for i := 0; i < len(a.array)-1; i++ {
 		for j := i + 1; j < len(a.array); j++ {
 			if a.array[i] == a.array[j] {
-				a.array = append(a.array[ : j], a.array[j + 1 : ]...)
+				a.array = append(a.array[:j], a.array[j+1:]...)
 			}
 		}
 	}
@@ -385,7 +438,7 @@ func (a *IntArray) LockFunc(f func(array []int)) *IntArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	f(a.array)
-    return a
+	return a
 }
 
 // RLockFunc locks reading by callback function <f>.
@@ -393,7 +446,7 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	f(a.array)
-    return a
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -401,58 +454,64 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *IntArray) Merge(array interface{}) *IntArray {
-    switch v := array.(type) {
-        case *Array:             a.Append(gconv.Ints(v.Slice())...)
-        case *IntArray:          a.Append(gconv.Ints(v.Slice())...)
-        case *StringArray:       a.Append(gconv.Ints(v.Slice())...)
-        case *SortedArray:       a.Append(gconv.Ints(v.Slice())...)
-        case *SortedIntArray:    a.Append(gconv.Ints(v.Slice())...)
-        case *SortedStringArray: a.Append(gconv.Ints(v.Slice())...)
-        default:
-            a.Append(gconv.Ints(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Append(gconv.Ints(v.Slice())...)
+	case *IntArray:
+		a.Append(gconv.Ints(v.Slice())...)
+	case *StringArray:
+		a.Append(gconv.Ints(v.Slice())...)
+	case *SortedArray:
+		a.Append(gconv.Ints(v.Slice())...)
+	case *SortedIntArray:
+		a.Append(gconv.Ints(v.Slice())...)
+	case *SortedStringArray:
+		a.Append(gconv.Ints(v.Slice())...)
+	default:
+		a.Append(gconv.Ints(array)...)
+	}
+	return a
 }
 
 // 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) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if startIndex < 0 {
-        startIndex = 0
-    }
-    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 a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if startIndex < 0 {
+		startIndex = 0
+	}
+	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 a
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by <size>.
 // The last chunk may contain less than size elements.
 func (a *IntArray) Chunk(size int) [][]int {
-    if size < 1 {
-        return nil
-    }
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    chunks := int(math.Ceil(float64(length) / float64(size)))
-    var n [][]int
-    for i, end := 0, 0; chunks > 0; chunks-- {
-        end = (i + 1) * size
-        if end > length {
-            end = length
-        }
-        n = append(n, a.array[i*size : end])
-        i++
-    }
-    return n
+	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>.
@@ -460,105 +519,84 @@ func (a *IntArray) Chunk(size int) [][]int {
 // If the absolute value of <size> is less than or equal to the length of the array
 // then no padding takes place.
 func (a *IntArray) Pad(size int, value int) *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-        return a
-    }
-    n := size
-    if size < 0 {
-        n = -size
-    }
-    n   -= len(a.array)
-    tmp := make([]int, n)
-    for i := 0; i < n; i++ {
-        tmp[i] = value
-    }
-    if size > 0 {
-        a.array = append(a.array, tmp...)
-    } else {
-        a.array = append(tmp, a.array...)
-    }
-    return a
-}
-
-// 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.
-func (a *IntArray) SubSlice(offset, size int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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() int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *IntArray) Rands(size int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]int, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]int, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Shuffle randomly shuffles the array.
 func (a *IntArray) Shuffle() *IntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    for i, v := range grand.Perm(len(a.array)) {
-        a.array[i], a.array[v] = a.array[v], a.array[i]
-    }
-    return a
+	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.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
+	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.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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.
@@ -576,5 +614,13 @@ func (a *IntArray) CountValues() map[int]int {
 func (a *IntArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
-	return fmt.Sprint(a.array)
-}
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *IntArray) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}

g/container/garray/garray_normal_interface.go

@@ -7,387 +7,440 @@
 package garray
 
 import (
-    "bytes"
-    "fmt"
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 type Array struct {
-    mu    *rwmutex.RWMutex
-    array []interface{}
+	mu    *rwmutex.RWMutex
+	array []interface{}
 }
 
 // New creates and returns an empty array.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func New(unsafe...bool) *Array {
-    return NewArraySize(0, 0, unsafe...)
+func New(unsafe ...bool) *Array {
+	return NewArraySize(0, 0, unsafe...)
 }
 
 // See New.
-func NewArray(unsafe...bool) *Array {
-    return NewArraySize(0, 0, unsafe...)
+func NewArray(unsafe ...bool) *Array {
+	return NewArraySize(0, 0, unsafe...)
 }
 
 // NewArraySize create and returns an array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewArraySize(size int, cap int, unsafe...bool) *Array {
-    return &Array{
-        mu    : rwmutex.New(unsafe...),
-        array : make([]interface{}, size, cap),
-    }
+func NewArraySize(size int, cap int, unsafe ...bool) *Array {
+	return &Array{
+		mu:    rwmutex.New(unsafe...),
+		array: make([]interface{}, size, cap),
+	}
 }
 
 // See NewArrayFrom.
-func NewFrom(array []interface{}, unsafe...bool) *Array {
-    return NewArrayFrom(array, unsafe...)
+func NewFrom(array []interface{}, unsafe ...bool) *Array {
+	return NewArrayFrom(array, unsafe...)
 }
 
 // See NewArrayFromCopy.
-func NewFromCopy(array []interface{}, unsafe...bool) *Array {
-    return NewArrayFromCopy(array, unsafe...)
+func NewFromCopy(array []interface{}, unsafe ...bool) *Array {
+	return NewArrayFromCopy(array, unsafe...)
 }
 
 // NewArrayFrom creates and returns an array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewArrayFrom(array []interface{}, unsafe...bool) *Array {
-    return &Array{
-        mu    : rwmutex.New(unsafe...),
-        array : array,
-    }
+func NewArrayFrom(array []interface{}, unsafe ...bool) *Array {
+	return &Array{
+		mu:    rwmutex.New(unsafe...),
+		array: array,
+	}
 }
 
 // NewArrayFromCopy creates and returns an array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewArrayFromCopy(array []interface{}, unsafe...bool) *Array {
-    newArray := make([]interface{}, len(array))
-    copy(newArray, array)
-    return &Array{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+func NewArrayFromCopy(array []interface{}, unsafe ...bool) *Array {
+	newArray := make([]interface{}, len(array))
+	copy(newArray, array)
+	return &Array{
+		mu:    rwmutex.New(unsafe...),
+		array: newArray,
+	}
 }
 
 // Get returns the value of the specified index,
 // the caller should notice the boundary of the array.
 func (a *Array) Get(index int) interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    value := a.array[index]
-    return value
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
 }
 
 // Set sets value to specified index.
 func (a *Array) Set(index int, value interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array[index] = value
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array[index] = value
+	return a
 }
 
 // SetArray sets the underlying slice array with the given <array>.
 func (a *Array) SetArray(array []interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array = array
-    return a
+	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 *Array) Replace(array []interface{}) *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
+	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 *Array) Sum() (sum int) {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += gconv.Int(v)
-    }
-    return
+	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 *Array) SortFunc(less func(v1, v2 interface{}) bool) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    sort.Slice(a.array, func(i, j int) bool {
-        return less(a.array[i], a.array[j])
-    })
-    return a
+	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 <value> to the front of <index>.
 func (a *Array) InsertBefore(index int, value interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    rear   := append([]interface{}{}, a.array[index : ]...)
-    a.array = append(a.array[0 : index], value)
-    a.array = append(a.array, rear...)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	rear := append([]interface{}{}, a.array[index:]...)
+	a.array = append(a.array[0:index], value)
+	a.array = append(a.array, rear...)
+	return a
 }
 
 // InsertAfter inserts the <value> to the back of <index>.
 func (a *Array) InsertAfter(index int, value interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    rear   := append([]interface{}{}, a.array[index + 1 : ]...)
-    a.array = append(a.array[0 : index + 1], value)
-    a.array = append(a.array, rear...)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	rear := append([]interface{}{}, a.array[index+1:]...)
+	a.array = append(a.array[0:index+1], value)
+	a.array = append(a.array, rear...)
+	return a
 }
 
 // Remove removes an item by index.
 func (a *Array) Remove(index int) interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	// Determine array boundaries when deleting to improve deletion efficiency。
-    if index == 0 {
-        value  := a.array[0]
-        a.array = a.array[1 : ]
-        return value
-    } else if index == len(a.array) - 1 {
-        value  := a.array[index]
-        a.array = a.array[: index]
-        return value
-    }
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value
+	}
 	// 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
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
-func (a *Array) PushLeft(value...interface{}) *Array {
-    a.mu.Lock()
-    a.array = append(value, a.array...)
-    a.mu.Unlock()
-    return a
+func (a *Array) PushLeft(value ...interface{}) *Array {
+	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 *Array) PushRight(value...interface{}) *Array {
-    a.mu.Lock()
-    a.array = append(a.array, value...)
-    a.mu.Unlock()
-    return a
+func (a *Array) PushRight(value ...interface{}) *Array {
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
+	return a
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *Array) PopRand() interface{} {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *Array) PopRands(size int) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]interface{}, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]interface{}, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 func (a *Array) PopLeft() interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *Array) PopRight() interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *Array) PopLefts(size int) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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 *Array) PopRights(size int) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *Array) Range(start, end int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]interface{})(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]interface{}, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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 *Array) 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
+// 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 *Array) 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]
+	}
 }
 
 // See PushRight.
-func (a *Array) Append(value...interface{}) *Array {
-    a.PushRight(value...)
-    return a
+func (a *Array) Append(value ...interface{}) *Array {
+	a.PushRight(value...)
+	return a
 }
 
 // Len returns the length of array.
 func (a *Array) Len() int {
-    a.mu.RLock()
-    length := len(a.array)
-    a.mu.RUnlock()
-    return length
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
 }
 
 // Slice returns the underlying data of array.
 // Notice, if in concurrent-safe usage, it returns a copy of slice;
 // else a pointer to the underlying data.
 func (a *Array) Slice() []interface{} {
-    array := ([]interface{})(nil)
-    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
+	array := ([]interface{})(nil)
+	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
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *Array) Clone() (newArray *Array) {
-    a.mu.RLock()
-    array := make([]interface{}, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewArrayFrom(array, !a.mu.IsSafe())
+	a.mu.RLock()
+	array := make([]interface{}, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewArrayFrom(array, !a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *Array) Clear() *Array {
-    a.mu.Lock()
-    if len(a.array) > 0 {
-        a.array = make([]interface{}, 0)
-    }
-    a.mu.Unlock()
-    return a
+	a.mu.Lock()
+	if len(a.array) > 0 {
+		a.array = make([]interface{}, 0)
+	}
+	a.mu.Unlock()
+	return a
 }
 
 // Contains checks whether a value exists in the array.
 func (a *Array) Contains(value interface{}) bool {
-    return a.Search(value) != -1
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *Array) Search(value interface{}) int {
-    if len(a.array) == 0 {
-        return -1
-    }
-    a.mu.RLock()
-    result := -1
-    for index, v := range a.array {
-        if v == value {
-            result = index
-            break
-        }
-    }
-    a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return -1
+	}
+	a.mu.RLock()
+	result := -1
+	for index, v := range a.array {
+		if v == value {
+			result = index
+			break
+		}
+	}
+	a.mu.RUnlock()
 
-    return result
+	return result
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *Array) Unique() *Array {
-    a.mu.Lock()
-    for i := 0; i < len(a.array) - 1; i++ {
-        for j := i + 1; j < len(a.array); j++ {
-            if a.array[i] == a.array[j] {
-                a.array = append(a.array[ : j], a.array[j + 1 : ]...)
-            }
-        }
-    }
-    a.mu.Unlock()
-    return a
+	a.mu.Lock()
+	for i := 0; i < len(a.array)-1; i++ {
+		for j := i + 1; j < len(a.array); j++ {
+			if a.array[i] == a.array[j] {
+				a.array = append(a.array[:j], a.array[j+1:]...)
+			}
+		}
+	}
+	a.mu.Unlock()
+	return a
 }
 
 // LockFunc locks writing by callback function <f>.
 func (a *Array) LockFunc(f func(array []interface{})) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    f(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+	return a
 }
 
 // RLockFunc locks reading by callback function <f>.
 func (a *Array) RLockFunc(f func(array []interface{})) *Array {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    f(a.array)
-    return a
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -395,58 +448,64 @@ func (a *Array) RLockFunc(f func(array []interface{})) *Array {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *Array) Merge(array interface{}) *Array {
-    switch v := array.(type) {
-        case *Array:             a.Append(gconv.Interfaces(v.Slice())...)
-        case *IntArray:          a.Append(gconv.Interfaces(v.Slice())...)
-        case *StringArray:       a.Append(gconv.Interfaces(v.Slice())...)
-        case *SortedArray:       a.Append(gconv.Interfaces(v.Slice())...)
-        case *SortedIntArray:    a.Append(gconv.Interfaces(v.Slice())...)
-        case *SortedStringArray: a.Append(gconv.Interfaces(v.Slice())...)
-        default:
-            a.Append(gconv.Interfaces(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	case *IntArray:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	case *StringArray:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	case *SortedArray:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	case *SortedIntArray:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	case *SortedStringArray:
+		a.Append(gconv.Interfaces(v.Slice())...)
+	default:
+		a.Append(gconv.Interfaces(array)...)
+	}
+	return a
 }
 
 // Fill fills an array with num entries of the value <value>,
 // keys starting at the <startIndex> parameter.
 func (a *Array) Fill(startIndex int, num int, value interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if startIndex < 0 {
-        startIndex = 0
-    }
-    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 a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if startIndex < 0 {
+		startIndex = 0
+	}
+	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 a
 }
 
 // Chunk splits an array into multiple arrays,
 // the size of each array is determined by <size>.
 // The last chunk may contain less than size elements.
 func (a *Array) Chunk(size int) [][]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
+	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
 }
 
 // Pad pads array to the specified length with <value>.
@@ -454,121 +513,108 @@ func (a *Array) Chunk(size int) [][]interface{} {
 // If the absolute value of <size> is less than or equal to the length of the array
 // then no padding takes place.
 func (a *Array) Pad(size int, val interface{}) *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size == 0 || (size > 0 && size < len(a.array)) || (size < 0 && size > -len(a.array)) {
-        return a
-    }
-    n := size
-    if size < 0 {
-        n = -size
-    }
-    n   -= len(a.array)
-    tmp := make([]interface{}, 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
-}
-
-// 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.
-func (a *Array) SubSlice(offset, size int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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([]interface{}, 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 *Array) Rand() interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *Array) Rands(size int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]interface{}, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]interface{}, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Shuffle randomly shuffles the array.
 func (a *Array) Shuffle() *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    for i, v := range grand.Perm(len(a.array)) {
-        a.array[i], a.array[v] = a.array[v], a.array[i]
-    }
-    return a
+	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 *Array) Reverse() *Array {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    for i, j := 0, len(a.array) - 1; i < j; i, j = i + 1, j - 1 {
-        a.array[i], a.array[j] = a.array[j], a.array[i]
-    }
-    return a
+	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 *Array) Join(glue string) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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 *Array) 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
+	m := make(map[interface{}]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
 }
 
 // String returns current array as a string.
 func (a *Array) String() string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return fmt.Sprint(a.array)
-}
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *Array) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}

g/container/garray/garray_normal_string.go

@@ -7,14 +7,15 @@
 package garray
 
 import (
-    "bytes"
-	"fmt"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+	"strings"
+
 	"github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
-    "strings"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 type StringArray struct {
@@ -25,40 +26,40 @@ type StringArray struct {
 // NewStringArray creates and returns an empty array.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewStringArray(unsafe...bool) *StringArray {
-    return NewStringArraySize(0, 0, unsafe...)
+func NewStringArray(unsafe ...bool) *StringArray {
+	return NewStringArraySize(0, 0, unsafe...)
 }
 
 // NewStringArraySize create and returns an array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewStringArraySize(size int, cap int, unsafe...bool) *StringArray {
-    return &StringArray{
-        mu    : rwmutex.New(unsafe...),
-        array : make([]string, size, cap),
-    }
+func NewStringArraySize(size int, cap int, unsafe ...bool) *StringArray {
+	return &StringArray{
+		mu:    rwmutex.New(unsafe...),
+		array: make([]string, size, cap),
+	}
 }
 
 // NewStringArrayFrom creates and returns an array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewStringArrayFrom(array []string, unsafe...bool) *StringArray {
-	return &StringArray {
-		mu    : rwmutex.New(unsafe...),
-		array : array,
+func NewStringArrayFrom(array []string, unsafe ...bool) *StringArray {
+	return &StringArray{
+		mu:    rwmutex.New(unsafe...),
+		array: array,
 	}
 }
 
 // NewStringArrayFromCopy creates and returns an array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewStringArrayFromCopy(array []string, unsafe...bool) *StringArray {
-    newArray := make([]string, len(array))
-    copy(newArray, array)
-    return &StringArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+func NewStringArrayFromCopy(array []string, unsafe ...bool) *StringArray {
+	newArray := make([]string, len(array))
+	copy(newArray, array)
+	return &StringArray{
+		mu:    rwmutex.New(unsafe...),
+		array: newArray,
+	}
 }
 
 // Get returns the value of the specified index,
@@ -75,88 +76,88 @@ func (a *StringArray) Set(index int, value string) *StringArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	a.array[index] = value
-    return a
+	return a
 }
 
 // SetArray sets the underlying slice array with the given <array>.
 func (a *StringArray) SetArray(array []string) *StringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array = array
-    return a
+	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 *StringArray) Replace(array []string) *StringArray {
-    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
+	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 *StringArray) Sum() (sum int) {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += gconv.Int(v)
-    }
-    return
+	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 *StringArray) Sort(reverse...bool) *StringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if len(reverse) > 0 && reverse[0] {
-        sort.Slice(a.array, func(i, j int) bool {
-            if strings.Compare(a.array[i], a.array[j]) < 0 {
-                return false
-            }
-            return true
-        })
-    } else {
-        sort.Strings(a.array)
-    }
-    return a
+func (a *StringArray) Sort(reverse ...bool) *StringArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if len(reverse) > 0 && reverse[0] {
+		sort.Slice(a.array, func(i, j int) bool {
+			if strings.Compare(a.array[i], a.array[j]) < 0 {
+				return false
+			}
+			return true
+		})
+	} else {
+		sort.Strings(a.array)
+	}
+	return a
 }
 
 // SortFunc sorts the array by custom function <less>.
 func (a *StringArray) SortFunc(less func(v1, v2 string) bool) *StringArray {
-    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
+	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 <value> to the front of <index>.
 func (a *StringArray) InsertBefore(index int, value string) *StringArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index : ]...)
-	a.array = append(a.array[0 : index], value)
+	rear := append([]string{}, a.array[index:]...)
+	a.array = append(a.array[0:index], value)
 	a.array = append(a.array, rear...)
-    return a
+	return a
 }
 
 // InsertAfter inserts the <value> to the back of <index>.
 func (a *StringArray) InsertAfter(index int, value string) *StringArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index + 1:]...)
-	a.array = append(a.array[ 0: index + 1], value)
+	rear := append([]string{}, a.array[index+1:]...)
+	a.array = append(a.array[0:index+1], value)
 	a.array = append(a.array, rear...)
-    return a
+	return a
 }
 
 // Remove removes an item by index.
@@ -165,139 +166,191 @@ func (a *StringArray) Remove(index int) string {
 	defer a.mu.Unlock()
 	// Determine array boundaries when deleting to improve deletion efficiency。
 	if index == 0 {
-		value  := a.array[0]
-		a.array = a.array[1 : ]
+		value := a.array[0]
+		a.array = a.array[1:]
 		return value
-	} else if index == len(a.array) - 1 {
-		value  := a.array[index]
-		a.array = a.array[: index]
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
 		return value
 	}
 	// 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 : ]...)
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
 	return value
 }
 
 // PushLeft pushes one or multiple items to the beginning of array.
-func (a *StringArray) PushLeft(value...string) *StringArray {
-    a.mu.Lock()
-    a.array = append(value, a.array...)
-    a.mu.Unlock()
-    return a
+func (a *StringArray) PushLeft(value ...string) *StringArray {
+	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 *StringArray) PushRight(value...string) *StringArray {
-    a.mu.Lock()
-    a.array = append(a.array, value...)
-    a.mu.Unlock()
-    return a
+func (a *StringArray) PushRight(value ...string) *StringArray {
+	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.
 func (a *StringArray) PopLeft() string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *StringArray) PopRight() string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *StringArray) PopRand() string {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *StringArray) PopRands(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]string, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]string, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *StringArray) PopLefts(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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 *StringArray) PopRights(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *StringArray) Range(start, end int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]string)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]string, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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 *StringArray) Range(start int, end ...int) []string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]string)(nil)
+	if a.mu.IsSafe() {
+		array = make([]string, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// 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 *StringArray) SubSlice(offset int, length ...int) []string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]string, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
 }
 
 // See PushRight.
-func (a *StringArray) Append(value...string) *StringArray {
+func (a *StringArray) Append(value ...string) *StringArray {
 	a.mu.Lock()
 	a.array = append(a.array, value...)
 	a.mu.Unlock()
-    return a
+	return a
 }
 
 // Len returns the length of array.
@@ -326,26 +379,26 @@ func (a *StringArray) Slice() []string {
 
 // Clone returns a new array, which is a copy of current array.
 func (a *StringArray) Clone() (newArray *StringArray) {
-    a.mu.RLock()
-    array := make([]string, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewStringArrayFrom(array, !a.mu.IsSafe())
+	a.mu.RLock()
+	array := make([]string, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewStringArrayFrom(array, !a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *StringArray) Clear() *StringArray {
-    a.mu.Lock()
-    if len(a.array) > 0 {
-        a.array = make([]string, 0)
-    }
-    a.mu.Unlock()
-    return a
+	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 *StringArray) Contains(value string) bool {
-    return a.Search(value) != -1
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
@@ -369,10 +422,10 @@ func (a *StringArray) Search(value string) int {
 // Unique uniques the array, clear repeated items.
 func (a *StringArray) Unique() *StringArray {
 	a.mu.Lock()
-	for i := 0; i < len(a.array) - 1; i++ {
+	for i := 0; i < len(a.array)-1; i++ {
 		for j := i + 1; j < len(a.array); j++ {
 			if a.array[i] == a.array[j] {
-				a.array = append(a.array[ : j], a.array[j + 1 : ]...)
+				a.array = append(a.array[:j], a.array[j+1:]...)
 			}
 		}
 	}
@@ -385,7 +438,7 @@ func (a *StringArray) LockFunc(f func(array []string)) *StringArray {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	f(a.array)
-    return a
+	return a
 }
 
 // RLockFunc locks reading by callback function <f>.
@@ -393,7 +446,7 @@ func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	f(a.array)
-    return a
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -401,58 +454,64 @@ func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *StringArray) Merge(array interface{}) *StringArray {
-    switch v := array.(type) {
-        case *Array:             a.Append(gconv.Strings(v.Slice())...)
-        case *IntArray:          a.Append(gconv.Strings(v.Slice())...)
-        case *StringArray:       a.Append(gconv.Strings(v.Slice())...)
-        case *SortedArray:       a.Append(gconv.Strings(v.Slice())...)
-        case *SortedIntArray:    a.Append(gconv.Strings(v.Slice())...)
-        case *SortedStringArray: a.Append(gconv.Strings(v.Slice())...)
-        default:
-            a.Append(gconv.Strings(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Append(gconv.Strings(v.Slice())...)
+	case *IntArray:
+		a.Append(gconv.Strings(v.Slice())...)
+	case *StringArray:
+		a.Append(gconv.Strings(v.Slice())...)
+	case *SortedArray:
+		a.Append(gconv.Strings(v.Slice())...)
+	case *SortedIntArray:
+		a.Append(gconv.Strings(v.Slice())...)
+	case *SortedStringArray:
+		a.Append(gconv.Strings(v.Slice())...)
+	default:
+		a.Append(gconv.Strings(array)...)
+	}
+	return a
 }
 
 // Fill fills an array with num entries of the value <value>,
 // keys starting at the <startIndex> parameter.
 func (a *StringArray) Fill(startIndex int, num int, value string) *StringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if startIndex < 0 {
-        startIndex = 0
-    }
-    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 a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if startIndex < 0 {
+		startIndex = 0
+	}
+	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 a
 }
 
 // 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 *StringArray) Chunk(size int) [][]string {
-    if size < 1 {
-        return nil
-    }
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    chunks := int(math.Ceil(float64(length) / float64(size)))
-    var n [][]string
-    for i, end := 0, 0; chunks > 0; chunks-- {
-        end = (i + 1) * size
-        if end > length {
-            end = length
-        }
-        n = append(n, a.array[i*size : end])
-        i++
-    }
-    return n
+	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>.
@@ -460,105 +519,84 @@ func (a *StringArray) 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 *StringArray) Pad(size int, value string) *StringArray {
-    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
-}
-
-// 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.
-func (a *StringArray) SubSlice(offset, size int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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 *StringArray) Rand() string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *StringArray) Rands(size int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]string, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]string, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Shuffle randomly shuffles the array.
 func (a *StringArray) Shuffle() *StringArray {
-    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
+	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 *StringArray) Reverse() *StringArray {
-    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
+	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 *StringArray) Join(glue string) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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.
@@ -576,5 +614,13 @@ func (a *StringArray) CountValues() map[string]int {
 func (a *StringArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
-	return fmt.Sprint(a.array)
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *StringArray) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
 }

g/container/garray/garray_sorted_int.go

@@ -7,286 +7,339 @@
 package garray
 
 import (
-    "bytes"
-	"fmt"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+
 	"github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 // It's using increasing order in default.
 type SortedIntArray struct {
-    mu          *rwmutex.RWMutex
-    array       []int
-    unique      *gtype.Bool          // Whether enable unique feature(false)
-    comparator func(v1, v2 int) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
+	mu         *rwmutex.RWMutex
+	array      []int
+	unique     *gtype.Bool          // Whether enable unique feature(false)
+	comparator func(v1, v2 int) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
 // NewSortedIntArray creates and returns an empty sorted array.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedIntArray(unsafe...bool) *SortedIntArray {
-    return NewSortedIntArraySize(0, unsafe...)
+func NewSortedIntArray(unsafe ...bool) *SortedIntArray {
+	return NewSortedIntArraySize(0, unsafe...)
 }
 
 // NewSortedIntArraySize create and returns an sorted array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedIntArraySize(cap int, unsafe...bool) *SortedIntArray {
-    return &SortedIntArray {
-        mu          : rwmutex.New(unsafe...),
-        array       : make([]int, 0, cap),
-        unique      : gtype.NewBool(),
-        comparator : func(v1, v2 int) int {
-            if v1 < v2 {
-                return -1
-            }
-            if v1 > v2 {
-                return 1
-            }
-            return 0
-        },
-    }
+func NewSortedIntArraySize(cap int, unsafe ...bool) *SortedIntArray {
+	return &SortedIntArray{
+		mu:     rwmutex.New(unsafe...),
+		array:  make([]int, 0, cap),
+		unique: gtype.NewBool(),
+		comparator: func(v1, v2 int) int {
+			if v1 < v2 {
+				return -1
+			}
+			if v1 > v2 {
+				return 1
+			}
+			return 0
+		},
+	}
 }
 
 // NewIntArrayFrom creates and returns an sorted array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedIntArrayFrom(array []int, unsafe...bool) *SortedIntArray {
-    a := NewSortedIntArraySize(0, unsafe...)
-    a.array = array
-    sort.Ints(a.array)
-    return a
+func NewSortedIntArrayFrom(array []int, unsafe ...bool) *SortedIntArray {
+	a := NewSortedIntArraySize(0, unsafe...)
+	a.array = array
+	sort.Ints(a.array)
+	return a
 }
 
 // NewSortedIntArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedIntArrayFromCopy(array []int, unsafe...bool) *SortedIntArray {
-    newArray := make([]int, len(array))
-    copy(newArray, array)
-    return NewSortedIntArrayFrom(newArray, unsafe...)
+func NewSortedIntArrayFromCopy(array []int, unsafe ...bool) *SortedIntArray {
+	newArray := make([]int, len(array))
+	copy(newArray, array)
+	return NewSortedIntArrayFrom(newArray, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <array>.
 func (a *SortedIntArray) SetArray(array []int) *SortedIntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array = array
-    sort.Ints(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	sort.Ints(a.array)
+	return a
 }
 
 // Sort sorts the array in increasing order.
 // The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedIntArray) Sort() *SortedIntArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    sort.Ints(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	sort.Ints(a.array)
+	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
-func (a *SortedIntArray) Add(values...int) *SortedIntArray {
-    if len(values) == 0 {
-        return a
-    }
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    for _, value := range values {
-        index, cmp := a.binSearch(value, false)
-        if a.unique.Val() && 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
+func (a *SortedIntArray) Add(values ...int) *SortedIntArray {
+	if len(values) == 0 {
+		return a
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for _, value := range values {
+		index, cmp := a.binSearch(value, false)
+		if a.unique.Val() && 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 of the specified index,
 // the caller should notice the boundary of the array.
 func (a *SortedIntArray) Get(index int) int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    value := a.array[index]
-    return value
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
 }
 
 // Remove removes an item by index.
 func (a *SortedIntArray) Remove(index int) int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	// Determine array boundaries when deleting to improve deletion efficiency.
-    if index == 0 {
-        value  := a.array[0]
-        a.array = a.array[1 : ]
-        return value
-    } else if index == len(a.array) - 1 {
-        value  := a.array[index]
-        a.array = a.array[: index]
-        return value
-    }
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value
+	}
 	// 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
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedIntArray) PopLeft() int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *SortedIntArray) PopRight() int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *SortedIntArray) PopRand() int {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *SortedIntArray) PopRands(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]int, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]int, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *SortedIntArray) PopLefts(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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 *SortedIntArray) PopRights(size int) []int {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *SortedIntArray) Range(start, end int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]int)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]int, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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 *SortedIntArray) Range(start int, end ...int) []int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]int)(nil)
+	if a.mu.IsSafe() {
+		array = make([]int, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// 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 *SortedIntArray) SubSlice(offset int, length ...int) []int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]int, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
 }
 
 // Len returns the length of array.
 func (a *SortedIntArray) Len() int {
-    a.mu.RLock()
-    length := len(a.array)
-    a.mu.RUnlock()
-    return length
+	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.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += v
-    }
-    return
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		sum += v
+	}
+	return
 }
 
 // Slice returns the underlying data of array.
 // Notice, if in concurrent-safe usage, it returns a copy of slice;
 // else a pointer to the underlying data.
 func (a *SortedIntArray) Slice() []int {
-    array := ([]int)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]int, len(a.array))
-        copy(array, a.array)
-    } else {
-        array = a.array
-    }
-    return array
+	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
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedIntArray) Contains(value int) bool {
-    return a.Search(value) != -1
+	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) {
-    if i, r := a.binSearch(value, true); r == 0 {
-    	return i
-    }
-    return -1
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
@@ -295,93 +348,95 @@ func (a *SortedIntArray) Search(value int) (index int) {
 // 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 len(a.array) == 0 {
-        return -1, -2
-    }
-    if lock {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-    }
-    min := 0
-    max := len(a.array) - 1
-    mid := 0
-    cmp := -2
-    for min <= max {
-        mid = int((min + max) / 2)
-        cmp = a.comparator(value, a.array[mid])
-        switch {
-            case cmp < 0 : max = mid - 1
-            case cmp > 0 : min = mid + 1
-            default :
-                return mid, cmp
-        }
-    }
-    return mid, cmp
+	if len(a.array) == 0 {
+		return -1, -2
+	}
+	if lock {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+	}
+	min := 0
+	max := len(a.array) - 1
+	mid := 0
+	cmp := -2
+	for min <= max {
+		mid = int((min + max) / 2)
+		cmp = a.comparator(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 {
-    oldUnique := a.unique.Val()
-    a.unique.Set(unique)
-    if unique && oldUnique != unique {
-        a.Unique()
-    }
-    return a
+	oldUnique := a.unique.Val()
+	a.unique.Set(unique)
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
+	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedIntArray) Unique() *SortedIntArray {
-    a.mu.Lock()
-    i := 0
-    for {
-        if i == len(a.array) - 1 {
-            break
-        }
-        if a.comparator(a.array[i], a.array[i + 1]) == 0 {
-            a.array = append(a.array[ : i + 1], a.array[i + 1 + 1 : ]...)
-        } else {
-            i++
-        }
-    }
-    a.mu.Unlock()
-    return a
+	a.mu.Lock()
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.comparator(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+1+1:]...)
+		} else {
+			i++
+		}
+	}
+	a.mu.Unlock()
+	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
-    a.mu.RLock()
-    array := make([]int, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewSortedIntArrayFrom(array, !a.mu.IsSafe())
+	a.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.mu.Lock()
-    if len(a.array) > 0 {
-        a.array = make([]int, 0)
-    }
-    a.mu.Unlock()
-    return a
+	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.mu.Lock()
-    defer a.mu.Unlock()
-    f(a.array)
-    return a
+	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.mu.RLock()
-    defer a.mu.RUnlock()
-    f(a.array)
-    return a
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -389,99 +444,84 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray {
-    switch v := array.(type) {
-        case *Array:             a.Add(gconv.Ints(v.Slice())...)
-        case *IntArray:          a.Add(gconv.Ints(v.Slice())...)
-        case *StringArray:       a.Add(gconv.Ints(v.Slice())...)
-        case *SortedArray:       a.Add(gconv.Ints(v.Slice())...)
-        case *SortedIntArray:    a.Add(gconv.Ints(v.Slice())...)
-        case *SortedStringArray: a.Add(gconv.Ints(v.Slice())...)
-        default:
-            a.Add(gconv.Ints(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Add(gconv.Ints(v.Slice())...)
+	case *IntArray:
+		a.Add(gconv.Ints(v.Slice())...)
+	case *StringArray:
+		a.Add(gconv.Ints(v.Slice())...)
+	case *SortedArray:
+		a.Add(gconv.Ints(v.Slice())...)
+	case *SortedIntArray:
+		a.Add(gconv.Ints(v.Slice())...)
+	case *SortedStringArray:
+		a.Add(gconv.Ints(v.Slice())...)
+	default:
+		a.Add(gconv.Ints(array)...)
+	}
+	return a
 }
 
 // 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 *SortedIntArray) Chunk(size int) [][]int {
-    if size < 1 {
-        return nil
-    }
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    chunks := int(math.Ceil(float64(length) / float64(size)))
-    var n [][]int
-    for i, end := 0, 0; chunks > 0; chunks-- {
-        end = (i + 1) * size
-        if end > length {
-            end = length
-        }
-        n = append(n, a.array[i*size : end])
-        i++
-    }
-    return n
-}
-
-// 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.
-func (a *SortedIntArray) SubSlice(offset, size int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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() int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *SortedIntArray) Rands(size int) []int {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]int, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]int, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Join joins array elements with a string <glue>.
 func (a *SortedIntArray) Join(glue string) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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.
@@ -499,5 +539,13 @@ func (a *SortedIntArray) CountValues() map[int]int {
 func (a *SortedIntArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
-	return fmt.Sprint(a.array)
-}
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *SortedIntArray) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}

g/container/garray/garray_sorted_interface.go

@@ -7,22 +7,23 @@
 package garray
 
 import (
-    "bytes"
-	"fmt"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+
 	"github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 // It's using increasing order in default.
 type SortedArray struct {
-    mu          *rwmutex.RWMutex
-    array       []interface{}
-    unique      *gtype.Bool                  // Whether enable unique feature(false)
-    comparator  func(v1, v2 interface{}) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
+	mu         *rwmutex.RWMutex
+	array      []interface{}
+	unique     *gtype.Bool                  // Whether enable unique feature(false)
+	comparator func(v1, v2 interface{}) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
 // NewSortedArray creates and returns an empty sorted array.
@@ -31,254 +32,306 @@ type SortedArray struct {
 // if it returns value < 0, means v1 < v2;
 // if it returns value = 0, means v1 = v2;
 // if it returns value > 0, means v1 > v2;
-func NewSortedArray(comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
-    return NewSortedArraySize(0, comparator, unsafe...)
+func NewSortedArray(comparator func(v1, v2 interface{}) int, unsafe ...bool) *SortedArray {
+	return NewSortedArraySize(0, comparator, unsafe...)
 }
 
 // NewSortedArraySize create and returns an sorted array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedArraySize(cap int, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
-    return &SortedArray{
-        mu         : rwmutex.New(unsafe...),
-        unique     : gtype.NewBool(),
-        array      : make([]interface{}, 0, cap),
-        comparator : comparator,
-    }
+func NewSortedArraySize(cap int, comparator func(v1, v2 interface{}) int, unsafe ...bool) *SortedArray {
+	return &SortedArray{
+		mu:         rwmutex.New(unsafe...),
+		unique:     gtype.NewBool(),
+		array:      make([]interface{}, 0, cap),
+		comparator: comparator,
+	}
 }
 
 // NewSortedArrayFrom creates and returns an sorted array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedArrayFrom(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
-    a := NewSortedArraySize(0, comparator, unsafe...)
-    a.array = array
-    sort.Slice(a.array, func(i, j int) bool {
-        return a.comparator(a.array[i], a.array[j]) < 0
-    })
-    return a
+func NewSortedArrayFrom(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe ...bool) *SortedArray {
+	a := NewSortedArraySize(0, comparator, unsafe...)
+	a.array = array
+	sort.Slice(a.array, func(i, j int) bool {
+		return a.comparator(a.array[i], a.array[j]) < 0
+	})
+	return a
 }
 
 // NewSortedArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedArrayFromCopy(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
-    newArray := make([]interface{}, len(array))
-    copy(newArray, array)
-    return NewSortedArrayFrom(newArray, comparator, unsafe...)
+func NewSortedArrayFromCopy(array []interface{}, comparator func(v1, v2 interface{}) int, unsafe ...bool) *SortedArray {
+	newArray := make([]interface{}, len(array))
+	copy(newArray, array)
+	return NewSortedArrayFrom(newArray, comparator, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <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.comparator(a.array[i], a.array[j]) < 0
-    })
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	sort.Slice(a.array, func(i, j int) bool {
+		return a.comparator(a.array[i], a.array[j]) < 0
+	})
+	return a
 }
 
 // Sort sorts the array in increasing order.
 // The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order
 func (a *SortedArray) Sort() *SortedArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    sort.Slice(a.array, func(i, j int) bool {
-        return a.comparator(a.array[i], a.array[j]) < 0
-    })
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	sort.Slice(a.array, func(i, j int) bool {
+		return a.comparator(a.array[i], a.array[j]) < 0
+	})
+	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
-func (a *SortedArray) Add(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.Val() && cmp == 0 {
-            continue
-        }
-        if index < 0 {
-            a.array = append(a.array, value)
-            continue
-        }
-        if cmp > 0 {
-            index++
-        }
-        rear   := append([]interface{}{}, a.array[index : ]...)
-        a.array = append(a.array[0 : index], value)
-        a.array = append(a.array, rear...)
-    }
-    return a
+func (a *SortedArray) Add(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.Val() && cmp == 0 {
+			continue
+		}
+		if index < 0 {
+			a.array = append(a.array, value)
+			continue
+		}
+		if cmp > 0 {
+			index++
+		}
+		rear := append([]interface{}{}, a.array[index:]...)
+		a.array = append(a.array[0:index], value)
+		a.array = append(a.array, rear...)
+	}
+	return a
 }
 
 // Get returns the value of the specified index,
 // the caller should notice the boundary of the array.
 func (a *SortedArray) Get(index int) interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    value := a.array[index]
-    return value
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
 }
 
 // Remove removes an item by index.
 func (a *SortedArray) Remove(index int) interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
+	a.mu.Lock()
+	defer a.mu.Unlock()
 	// Determine array boundaries when deleting to improve deletion efficiency.
-    if index == 0 {
-        value  := a.array[0]
-        a.array = a.array[1 : ]
-        return value
-    } else if index == len(a.array) - 1 {
-        value  := a.array[index]
-        a.array = a.array[: index]
-        return value
-    }
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value
+	}
 	// 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
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedArray) PopLeft() interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *SortedArray) PopRight() interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *SortedArray) PopRand() interface{} {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *SortedArray) PopRands(size int) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]interface{}, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]interface{}, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *SortedArray) PopLefts(size int) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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) []interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *SortedArray) Range(start, end int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]interface{})(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]interface{}, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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) []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
+// 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 *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.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += gconv.Int(v)
-    }
-    return
+	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.mu.RLock()
-    length := len(a.array)
-    a.mu.RUnlock()
-    return length
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
 }
 
 // Slice returns the underlying data of array.
 // Notice, if in concurrent-safe usage, it returns a copy of slice;
 // else a pointer to the underlying data.
 func (a *SortedArray) Slice() []interface{} {
-    array := ([]interface{})(nil)
-    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
+	array := ([]interface{})(nil)
+	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
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedArray) Contains(value interface{}) bool {
-    return a.Search(value) != -1
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
@@ -295,94 +348,96 @@ func (a *SortedArray) Search(value interface{}) (index int) {
 // 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 len(a.array) == 0 {
-        return -1, -2
-    }
-    if lock {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-    }
-    min := 0
-    max := len(a.array) - 1
-    mid := 0
-    cmp := -2
-    for min <= max {
-        mid = int((min + max) / 2)
-        cmp = a.comparator(value, a.array[mid])
-        switch {
-            case cmp < 0 : max = mid - 1
-            case cmp > 0 : min = mid + 1
-            default :
-                return mid, cmp
-        }
-    }
-    return mid, cmp
+func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result int) {
+	if len(a.array) == 0 {
+		return -1, -2
+	}
+	if lock {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+	}
+	min := 0
+	max := len(a.array) - 1
+	mid := 0
+	cmp := -2
+	for min <= max {
+		mid = int((min + max) / 2)
+		cmp = a.comparator(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 *SortedArray) SetUnique(unique bool) *SortedArray {
-    oldUnique := a.unique.Val()
-    a.unique.Set(unique)
-    if unique && oldUnique != unique {
-        a.Unique()
-    }
-    return a
+	oldUnique := a.unique.Val()
+	a.unique.Set(unique)
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
+	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedArray) Unique() *SortedArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    i := 0
-    for {
-        if i == len(a.array) - 1 {
-            break
-        }
-        if a.comparator(a.array[i], a.array[i + 1]) == 0 {
-            a.array = append(a.array[ : i + 1], a.array[i + 1 + 1 : ]...)
-        } else {
-            i++
-        }
-    }
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.comparator(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.mu.RLock()
-    array := make([]interface{}, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewSortedArrayFrom(array, a.comparator, !a.mu.IsSafe())
+	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.mu.Lock()
-    if len(a.array) > 0 {
-        a.array = make([]interface{}, 0)
-    }
-    a.mu.Unlock()
-    return a
+	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 []interface{})) *SortedArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    f(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+	return a
 }
 
 // RLockFunc locks reading by callback function <f>.
 func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    f(a.array)
-    return a
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -390,99 +445,84 @@ func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray {
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedArray) Merge(array interface{}) *SortedArray {
-    switch v := array.(type) {
-        case *Array:             a.Add(gconv.Interfaces(v.Slice())...)
-        case *IntArray:          a.Add(gconv.Interfaces(v.Slice())...)
-        case *StringArray:       a.Add(gconv.Interfaces(v.Slice())...)
-        case *SortedArray:       a.Add(gconv.Interfaces(v.Slice())...)
-        case *SortedIntArray:    a.Add(gconv.Interfaces(v.Slice())...)
-        case *SortedStringArray: a.Add(gconv.Interfaces(v.Slice())...)
-        default:
-            a.Add(gconv.Interfaces(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	case *IntArray:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	case *StringArray:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	case *SortedArray:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	case *SortedIntArray:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	case *SortedStringArray:
+		a.Add(gconv.Interfaces(v.Slice())...)
+	default:
+		a.Add(gconv.Interfaces(array)...)
+	}
+	return a
 }
 
 // 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) [][]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
-}
-
-// 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.
-func (a *SortedArray) SubSlice(offset, size int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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() interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *SortedArray) Rands(size int) []interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]interface{}, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]interface{}, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Join joins array elements with a string <glue>.
 func (a *SortedArray) Join(glue string) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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.
@@ -500,5 +540,13 @@ func (a *SortedArray) CountValues() map[interface{}]int {
 func (a *SortedArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
-	return fmt.Sprint(a.array)
-}
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *SortedArray) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}

g/container/garray/garray_sorted_string.go

@@ -7,272 +7,325 @@
 package garray
 
 import (
-    "bytes"
-	"fmt"
+	"bytes"
+	"encoding/json"
+	"math"
+	"sort"
+	"strings"
+
 	"github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/util/grand"
-    "math"
-    "sort"
-    "strings"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 // It's using increasing order in default.
 type SortedStringArray struct {
-    mu          *rwmutex.RWMutex
-    array       []string
-    unique      *gtype.Bool             // Whether enable unique feature(false)
-    comparator func(v1, v2 string) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
+	mu         *rwmutex.RWMutex
+	array      []string
+	unique     *gtype.Bool             // Whether enable unique feature(false)
+	comparator func(v1, v2 string) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
 // NewSortedStringArray creates and returns an empty sorted array.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedStringArray(unsafe...bool) *SortedStringArray {
-    return NewSortedStringArraySize(0, unsafe...)
+func NewSortedStringArray(unsafe ...bool) *SortedStringArray {
+	return NewSortedStringArraySize(0, unsafe...)
 }
 
 // NewSortedStringArraySize create and returns an sorted array with given size and cap.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedStringArraySize(cap int, unsafe...bool) *SortedStringArray {
-    return &SortedStringArray {
-        mu          : rwmutex.New(unsafe...),
-        array       : make([]string, 0, cap),
-        unique      : gtype.NewBool(),
-        comparator : func(v1, v2 string) int {
-            return strings.Compare(v1, v2)
-        },
-    }
+func NewSortedStringArraySize(cap int, unsafe ...bool) *SortedStringArray {
+	return &SortedStringArray{
+		mu:     rwmutex.New(unsafe...),
+		array:  make([]string, 0, cap),
+		unique: gtype.NewBool(),
+		comparator: func(v1, v2 string) int {
+			return strings.Compare(v1, v2)
+		},
+	}
 }
 
 // NewSortedStringArrayFrom creates and returns an sorted array with given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedStringArrayFrom(array []string, unsafe...bool) *SortedStringArray {
-    a := NewSortedStringArraySize(0, unsafe...)
-    a.array = array
-    sort.Strings(a.array)
-    return a
+func NewSortedStringArrayFrom(array []string, unsafe ...bool) *SortedStringArray {
+	a := NewSortedStringArraySize(0, unsafe...)
+	a.array = array
+	sort.Strings(a.array)
+	return a
 }
 
 // NewSortedStringArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
 // The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedStringArrayFromCopy(array []string, unsafe...bool) *SortedStringArray {
-    newArray := make([]string, len(array))
-    copy(newArray, array)
-    return NewSortedStringArrayFrom(newArray, unsafe...)
+func NewSortedStringArrayFromCopy(array []string, unsafe ...bool) *SortedStringArray {
+	newArray := make([]string, len(array))
+	copy(newArray, array)
+	return NewSortedStringArrayFrom(newArray, unsafe...)
 }
 
 // SetArray sets the underlying slice array with the given <array>.
 func (a *SortedStringArray) SetArray(array []string) *SortedStringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array = array
-    sort.Strings(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	a.array = array
+	sort.Strings(a.array)
+	return a
 }
 
 // Sort sorts the array in increasing order.
 // The parameter <reverse> controls whether sort
 // in increasing order(default) or decreasing order.
 func (a *SortedStringArray) Sort() *SortedStringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    sort.Strings(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	sort.Strings(a.array)
+	return a
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
-func (a *SortedStringArray) Add(values...string) *SortedStringArray {
-    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.Val() && 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
+func (a *SortedStringArray) Add(values ...string) *SortedStringArray {
+	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.Val() && 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 of the specified index,
 // the caller should notice the boundary of the array.
 func (a *SortedStringArray) Get(index int) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    value := a.array[index]
-    return value
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
 }
 
 // Remove removes an item by index.
 func (a *SortedStringArray) Remove(index int) string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    // Determine array boundaries when deleting to improve deletion efficiency.
-    if index == 0 {
-        value  := a.array[0]
-        a.array = a.array[1 : ]
-        return value
-    } else if index == len(a.array) - 1 {
-        value  := a.array[index]
-        a.array = a.array[: index]
-        return value
-    }
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	// Determine array boundaries when deleting to improve deletion efficiency.
+	if index == 0 {
+		value := a.array[0]
+		a.array = a.array[1:]
+		return value
+	} else if index == len(a.array)-1 {
+		value := a.array[index]
+		a.array = a.array[:index]
+		return value
+	}
 	// 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
+	value := a.array[index]
+	a.array = append(a.array[:index], a.array[index+1:]...)
+	return value
 }
 
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedStringArray) PopLeft() string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	value := a.array[0]
+	a.array = a.array[1:]
+	return value
 }
 
 // PopRight pops and returns an item from the end of array.
 func (a *SortedStringArray) PopRight() string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index  := len(a.array) - 1
-    value  := a.array[index]
-    a.array = a.array[: index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - 1
+	value := a.array[index]
+	a.array = a.array[:index]
+	return value
 }
 
 // PopRand randomly pops and return an item out of array.
 func (a *SortedStringArray) PopRand() string {
-    return a.Remove(grand.Intn(len(a.array)))
+	return a.Remove(grand.Intn(len(a.array)))
 }
 
 // PopRands randomly pops and returns <size> items out of array.
 func (a *SortedStringArray) PopRands(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    array := make([]string, size)
-    for i := 0; i < size; i++ {
-        index   := grand.Intn(len(a.array))
-        array[i] = a.array[index]
-        a.array  = append(a.array[ : index], a.array[index + 1 : ]...)
-    }
-    return array
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	array := make([]string, size)
+	for i := 0; i < size; i++ {
+		index := grand.Intn(len(a.array))
+		array[i] = a.array[index]
+		a.array = append(a.array[:index], a.array[index+1:]...)
+	}
+	return array
 }
 
 // PopLefts pops and returns <size> items from the beginning of array.
 func (a *SortedStringArray) PopLefts(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    length := len(a.array)
-    if size > length {
-        size = length
-    }
-    value  := a.array[0 : size]
-    a.array = a.array[size : ]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	length := len(a.array)
+	if size > length {
+		size = length
+	}
+	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 *SortedStringArray) PopRights(size int) []string {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    index := len(a.array) - size
-    if index < 0 {
-        index = 0
-    }
-    value  := a.array[index :]
-    a.array = a.array[ : index]
-    return value
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	index := len(a.array) - size
+	if index < 0 {
+		index = 0
+	}
+	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.
-func (a *SortedStringArray) Range(start, end int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    if start > length || start > end {
-        return nil
-    }
-    if start < 0 {
-        start = 0
-    }
-    if end > length {
-        end = length
-    }
-    array  := ([]string)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]string, end - start)
-        copy(array, a.array[start : end])
-    } else {
-        array = a.array[start : end]
-    }
-    return array
+//
+// 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 *SortedStringArray) Range(start int, end ...int) []string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	offsetEnd := len(a.array)
+	if len(end) > 0 && end[0] < offsetEnd {
+		offsetEnd = end[0]
+	}
+	if start > offsetEnd {
+		return nil
+	}
+	if start < 0 {
+		start = 0
+	}
+	array := ([]string)(nil)
+	if a.mu.IsSafe() {
+		array = make([]string, offsetEnd-start)
+		copy(array, a.array[start:offsetEnd])
+	} else {
+		array = a.array[start:offsetEnd]
+	}
+	return array
+}
+
+// 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 *SortedStringArray) SubSlice(offset int, length ...int) []string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	size := len(a.array)
+	if len(length) > 0 {
+		size = length[0]
+	}
+	if offset > len(a.array) {
+		return nil
+	}
+	if offset < 0 {
+		offset = len(a.array) + offset
+		if offset < 0 {
+			return nil
+		}
+	}
+	if size < 0 {
+		offset += size
+		size = -size
+		if offset < 0 {
+			return nil
+		}
+	}
+	end := offset + size
+	if end > len(a.array) {
+		end = len(a.array)
+		size = len(a.array) - offset
+	}
+	if a.mu.IsSafe() {
+		s := make([]string, size)
+		copy(s, a.array[offset:])
+		return s
+	} else {
+		return a.array[offset:end]
+	}
 }
 
 // Sum returns the sum of values in an array.
 func (a *SortedStringArray) Sum() (sum int) {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    for _, v := range a.array {
-        sum += gconv.Int(v)
-    }
-    return
+	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 *SortedStringArray) Len() int {
-    a.mu.RLock()
-    length := len(a.array)
-    a.mu.RUnlock()
-    return length
+	a.mu.RLock()
+	length := len(a.array)
+	a.mu.RUnlock()
+	return length
 }
 
 // Slice returns the underlying data of array.
 // Notice, if in concurrent-safe usage, it returns a copy of slice;
 // else a pointer to the underlying data.
 func (a *SortedStringArray) Slice() []string {
-    array := ([]string)(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-        array = make([]string, len(a.array))
-        copy(array, a.array)
-    } else {
-        array = a.array
-    }
-    return array
+	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
 }
 
 // Contains checks whether a value exists in the array.
 func (a *SortedStringArray) Contains(value string) bool {
-    return a.Search(value) != -1
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
@@ -290,93 +343,95 @@ func (a *SortedStringArray) Search(value string) (index int) {
 // 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 *SortedStringArray) binSearch(value string, lock bool) (index int, result int) {
-    if len(a.array) == 0 {
-        return -1, -2
-    }
-    if lock {
-        a.mu.RLock()
-        defer a.mu.RUnlock()
-    }
-    min := 0
-    max := len(a.array) - 1
-    mid := 0
-    cmp := -2
-    for min <= max {
-        mid = int((min + max) / 2)
-        cmp = a.comparator(value, a.array[mid])
-        switch {
-            case cmp < 0 : max = mid - 1
-            case cmp > 0 : min = mid + 1
-            default :
-                return mid, cmp
-        }
-    }
-    return mid, cmp
+	if len(a.array) == 0 {
+		return -1, -2
+	}
+	if lock {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+	}
+	min := 0
+	max := len(a.array) - 1
+	mid := 0
+	cmp := -2
+	for min <= max {
+		mid = int((min + max) / 2)
+		cmp = a.comparator(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 *SortedStringArray) SetUnique(unique bool) *SortedStringArray {
-    oldUnique := a.unique.Val()
-    a.unique.Set(unique)
-    if unique && oldUnique != unique {
-        a.Unique()
-    }
-    return a
+	oldUnique := a.unique.Val()
+	a.unique.Set(unique)
+	if unique && oldUnique != unique {
+		a.Unique()
+	}
+	return a
 }
 
 // Unique uniques the array, clear repeated items.
 func (a *SortedStringArray) Unique() *SortedStringArray {
-    a.mu.Lock()
-    i := 0
-    for {
-        if i == len(a.array) - 1 {
-            break
-        }
-        if a.comparator(a.array[i], a.array[i + 1]) == 0 {
-            a.array = append(a.array[ : i + 1], a.array[i + 1 + 1 : ]...)
-        } else {
-            i++
-        }
-    }
-    a.mu.Unlock()
-    return a
+	a.mu.Lock()
+	i := 0
+	for {
+		if i == len(a.array)-1 {
+			break
+		}
+		if a.comparator(a.array[i], a.array[i+1]) == 0 {
+			a.array = append(a.array[:i+1], a.array[i+1+1:]...)
+		} else {
+			i++
+		}
+	}
+	a.mu.Unlock()
+	return a
 }
 
 // Clone returns a new array, which is a copy of current array.
 func (a *SortedStringArray) Clone() (newArray *SortedStringArray) {
-    a.mu.RLock()
-    array := make([]string, len(a.array))
-    copy(array, a.array)
-    a.mu.RUnlock()
-    return NewSortedStringArrayFrom(array, !a.mu.IsSafe())
+	a.mu.RLock()
+	array := make([]string, len(a.array))
+	copy(array, a.array)
+	a.mu.RUnlock()
+	return NewSortedStringArrayFrom(array, !a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
 func (a *SortedStringArray) Clear() *SortedStringArray {
-    a.mu.Lock()
-    if len(a.array) > 0 {
-        a.array = make([]string, 0)
-    }
-    a.mu.Unlock()
-    return a
+	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 *SortedStringArray) LockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    f(a.array)
-    return a
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+	return a
 }
 
 // RLockFunc locks reading by callback function <f>.
 func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    f(a.array)
-    return a
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+	return a
 }
 
 // Merge merges <array> into current array.
@@ -384,99 +439,84 @@ func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray
 // The difference between Merge and Append is Append supports only specified slice type,
 // but Merge supports more parameter types.
 func (a *SortedStringArray) Merge(array interface{}) *SortedStringArray {
-    switch v := array.(type) {
-        case *Array:             a.Add(gconv.Strings(v.Slice())...)
-        case *IntArray:          a.Add(gconv.Strings(v.Slice())...)
-        case *StringArray:       a.Add(gconv.Strings(v.Slice())...)
-        case *SortedArray:       a.Add(gconv.Strings(v.Slice())...)
-        case *SortedIntArray:    a.Add(gconv.Strings(v.Slice())...)
-        case *SortedStringArray: a.Add(gconv.Strings(v.Slice())...)
-        default:
-            a.Add(gconv.Strings(array)...)
-    }
-    return a
+	switch v := array.(type) {
+	case *Array:
+		a.Add(gconv.Strings(v.Slice())...)
+	case *IntArray:
+		a.Add(gconv.Strings(v.Slice())...)
+	case *StringArray:
+		a.Add(gconv.Strings(v.Slice())...)
+	case *SortedArray:
+		a.Add(gconv.Strings(v.Slice())...)
+	case *SortedIntArray:
+		a.Add(gconv.Strings(v.Slice())...)
+	case *SortedStringArray:
+		a.Add(gconv.Strings(v.Slice())...)
+	default:
+		a.Add(gconv.Strings(array)...)
+	}
+	return a
 }
 
 // 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 *SortedStringArray) Chunk(size int) [][]string {
-    if size < 1 {
-        return nil
-    }
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    length := len(a.array)
-    chunks := int(math.Ceil(float64(length) / float64(size)))
-    var n [][]string
-    for i, end := 0, 0; chunks > 0; chunks-- {
-        end = (i + 1) * size
-        if end > length {
-            end = length
-        }
-        n = append(n, a.array[i*size : end])
-        i++
-    }
-    return n
-}
-
-// 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.
-func (a *SortedStringArray) SubSlice(offset, size int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if offset > len(a.array) {
-        return nil
-    }
-    if offset + size > 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:]
-    }
+	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 *SortedStringArray) Rand() string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    return a.array[grand.Intn(len(a.array))]
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return a.array[grand.Intn(len(a.array))]
 }
 
 // Rands randomly returns <size> items from array(no deleting).
 func (a *SortedStringArray) Rands(size int) []string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    if size > len(a.array) {
-        size = len(a.array)
-    }
-    n := make([]string, size)
-    for i, v := range grand.Perm(len(a.array)) {
-        n[i] = a.array[v]
-        if i == size - 1 {
-            break
-        }
-    }
-    return n
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if size > len(a.array) {
+		size = len(a.array)
+	}
+	n := make([]string, size)
+	for i, v := range grand.Perm(len(a.array)) {
+		n[i] = a.array[v]
+		if i == size-1 {
+			break
+		}
+	}
+	return n
 }
 
 // Join joins array elements with a string <glue>.
 func (a *SortedStringArray) Join(glue string) string {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    buffer := bytes.NewBuffer(nil)
-    for k, v := range a.array {
-        buffer.WriteString(gconv.String(v))
-        if k != len(a.array) - 1 {
-            buffer.WriteString(glue)
-        }
-    }
-    return buffer.String()
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	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.
@@ -494,5 +534,13 @@ func (a *SortedStringArray) CountValues() map[string]int {
 func (a *SortedStringArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
-	return fmt.Sprint(a.array)
-}
+	jsonContent, _ := json.Marshal(a.array)
+	return string(jsonContent)
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (a *SortedStringArray) MarshalJSON() ([]byte, error) {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return json.Marshal(a.array)
+}

g/container/garray/garray_z_bench_test.go

@@ -9,8 +9,9 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/g/container/garray"
 	"testing"
+
+	"github.com/gogf/gf/g/container/garray"
 )
 
 var (

g/container/garray/garray_z_example_test.go

@@ -7,105 +7,105 @@
 package garray_test
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
 )
 
 func Example_basic() {
-    // 创建普通的数组，默认并发安全(带锁)
-    a := garray.New()
+	// 创建普通的数组，默认并发安全(带锁)
+	a := garray.New()
 
-    // 添加数据项
-    for i := 0; i < 10; i++ {
-        a.Append(i)
-    }
+	// 添加数据项
+	for i := 0; i < 10; i++ {
+		a.Append(i)
+	}
 
-    // 获取当前数组长度
-    fmt.Println(a.Len())
+	// 获取当前数组长度
+	fmt.Println(a.Len())
 
-    // 获取当前数据项列表
-    fmt.Println(a.Slice())
+	// 获取当前数据项列表
+	fmt.Println(a.Slice())
 
-    // 获取指定索引项
-    fmt.Println(a.Get(6))
+	// 获取指定索引项
+	fmt.Println(a.Get(6))
 
-    // 查找指定数据项是否存在
-    fmt.Println(a.Contains(6))
-    fmt.Println(a.Contains(100))
+	// 查找指定数据项是否存在
+	fmt.Println(a.Contains(6))
+	fmt.Println(a.Contains(100))
 
-    // 在指定索引前插入数据项
-    a.InsertAfter(9, 11)
-    // 在指定索引后插入数据项
-    a.InsertBefore(10, 10)
+	// 在指定索引前插入数据项
+	a.InsertAfter(9, 11)
+	// 在指定索引后插入数据项
+	a.InsertBefore(10, 10)
 
-    fmt.Println(a.Slice())
+	fmt.Println(a.Slice())
 
-    // 修改指定索引的数据项
-    a.Set(0, 100)
-    fmt.Println(a.Slice())
+	// 修改指定索引的数据项
+	a.Set(0, 100)
+	fmt.Println(a.Slice())
 
-    // 搜索数据项，返回搜索到的索引位置
-    fmt.Println(a.Search(5))
+	// 搜索数据项，返回搜索到的索引位置
+	fmt.Println(a.Search(5))
 
-    // 删除指定索引的数据项
-    a.Remove(0)
-    fmt.Println(a.Slice())
+	// 删除指定索引的数据项
+	a.Remove(0)
+	fmt.Println(a.Slice())
 
-    // 清空数组
-    fmt.Println(a.Slice())
-    a.Clear()
-    fmt.Println(a.Slice())
+	// 清空数组
+	fmt.Println(a.Slice())
+	a.Clear()
+	fmt.Println(a.Slice())
 
-    // Output:
-    // 10
-    // [0 1 2 3 4 5 6 7 8 9]
-    // 6
-    // true
-    // false
-    // [0 1 2 3 4 5 6 7 8 9 10 11]
-    // [100 1 2 3 4 5 6 7 8 9 10 11]
-    // 5
-    // [1 2 3 4 5 6 7 8 9 10 11]
-    // [1 2 3 4 5 6 7 8 9 10 11]
-    // []
+	// Output:
+	// 10
+	// [0 1 2 3 4 5 6 7 8 9]
+	// 6
+	// true
+	// false
+	// [0 1 2 3 4 5 6 7 8 9 10 11]
+	// [100 1 2 3 4 5 6 7 8 9 10 11]
+	// 5
+	// [1 2 3 4 5 6 7 8 9 10 11]
+	// [1 2 3 4 5 6 7 8 9 10 11]
+	// []
 }
 
 func Example_rand() {
-    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
-    // 随机返回两个数据项(不删除)
-    fmt.Println(array.Rands(2))
-    fmt.Println(array.PopRand())
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	// 随机返回两个数据项(不删除)
+	fmt.Println(array.Rands(2))
+	fmt.Println(array.PopRand())
 }
 
 func Example_pop() {
-    array := garray.NewFrom([]interface{}{1,2,3,4,5,6,7,8,9})
-    fmt.Println(array.PopLeft())
-    fmt.Println(array.PopLefts(2))
-    fmt.Println(array.PopRight())
-    fmt.Println(array.PopRights(2))
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+	fmt.Println(array.PopLeft())
+	fmt.Println(array.PopLefts(2))
+	fmt.Println(array.PopRight())
+	fmt.Println(array.PopRights(2))
 
-    // Output:
-    // 1
-    // [2 3]
-    // 9
-    // [7 8]
+	// Output:
+	// 1
+	// [2 3]
+	// 9
+	// [7 8]
 }
 
 func Example_merge() {
-    array1 := garray.NewFrom([]interface{}{1,2})
-    array2 := garray.NewFrom([]interface{}{3,4})
-    slice1 := []interface{}{5,6}
-    slice2 := []int{7,8}
-    slice3 := []string{"9","0"}
-    fmt.Println(array1.Slice())
-    array1.Merge(array1)
-    array1.Merge(array2)
-    array1.Merge(slice1)
-    array1.Merge(slice2)
-    array1.Merge(slice3)
-    fmt.Println(array1.Slice())
+	array1 := garray.NewFrom([]interface{}{1, 2})
+	array2 := garray.NewFrom([]interface{}{3, 4})
+	slice1 := []interface{}{5, 6}
+	slice2 := []int{7, 8}
+	slice3 := []string{"9", "0"}
+	fmt.Println(array1.Slice())
+	array1.Merge(array1)
+	array1.Merge(array2)
+	array1.Merge(slice1)
+	array1.Merge(slice2)
+	array1.Merge(slice3)
+	fmt.Println(array1.Slice())
 
-    // Output:
-    // [1 2]
-    // [1 2 1 2 3 4 5 6 7 8 9 0]
-}
+	// Output:
+	// [1 2]
+	// [1 2 1 2 3 4 5 6 7 8 9 0]
+}

g/container/garray/garray_z_unit_basic_test.go

@@ -31,6 +31,7 @@ func Test_SortedIntArray1(t *testing.T) {
 		array.Add(i)
 	}
 	gtest.Assert(array.Slice(), expect)
+	gtest.Assert(array.Add().Slice(), expect)
 }
 
 func Test_SortedIntArray2(t *testing.T) {
@@ -44,11 +45,15 @@ func Test_SortedIntArray2(t *testing.T) {
 
 func Test_SortedStringArray1(t *testing.T) {
 	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedStringArray()
+	array1 := garray.NewSortedStringArray()
+	array2 := garray.NewSortedStringArray(true)
 	for i := 10; i > -1; i-- {
-		array.Add(gconv.String(i))
+		array1.Add(gconv.String(i))
+		array2.Add(gconv.String(i))
 	}
-	gtest.Assert(array.Slice(), expect)
+	gtest.Assert(array1.Slice(), expect)
+	gtest.Assert(array2.Slice(), expect)
+
 }
 
 func Test_SortedStringArray2(t *testing.T) {
@@ -58,6 +63,8 @@ func Test_SortedStringArray2(t *testing.T) {
 		array.Add(gconv.String(i))
 	}
 	gtest.Assert(array.Slice(), expect)
+	array.Add()
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedArray1(t *testing.T) {
@@ -73,13 +80,18 @@ func Test_SortedArray1(t *testing.T) {
 
 func Test_SortedArray2(t *testing.T) {
 	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
-	array := garray.NewSortedArray(func(v1, v2 interface{}) int {
+	func1 := func(v1, v2 interface{}) int {
 		return strings.Compare(gconv.String(v1), gconv.String(v2))
-	})
+	}
+	array := garray.NewSortedArray(func1)
+	array2 := garray.NewSortedArray(func1, true)
 	for i := 0; i <= 10; i++ {
 		array.Add(gconv.String(i))
+		array2.Add(gconv.String(i))
 	}
 	gtest.Assert(array.Slice(), expect)
+	gtest.Assert(array.Add().Slice(), expect)
+	gtest.Assert(array2.Slice(), expect)
 }
 
 func TestNewFromCopy(t *testing.T) {
@@ -89,6 +101,5 @@ func TestNewFromCopy(t *testing.T) {
 		gtest.AssertIN(array1.PopRands(2), a1)
 		gtest.Assert(len(array1.PopRands(1)), 1)
 		gtest.Assert(len(array1.PopRands(9)), 3)
-
 	})
 }

g/container/garray/garray_z_unit_int_test.go

@@ -9,20 +9,26 @@
 package garray_test
 
 import (
+	"github.com/gogf/gf/g/util/gconv"
+	"testing"
+	"time"
+
 	"github.com/gogf/gf/g/container/garray"
 	"github.com/gogf/gf/g/test/gtest"
-	"testing"
 )
 
 func Test_IntArray_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		expect := []int{0, 1, 2, 3}
+		expect2 := []int{}
 		array := garray.NewIntArrayFrom(expect)
+		array2 := garray.NewIntArrayFrom(expect2)
 		gtest.Assert(array.Slice(), expect)
 		array.Set(0, 100)
 		gtest.Assert(array.Get(0), 100)
 		gtest.Assert(array.Get(1), 1)
 		gtest.Assert(array.Search(100), 0)
+		gtest.Assert(array2.Search(100), -1)
 		gtest.Assert(array.Contains(100), true)
 		gtest.Assert(array.Remove(0), 100)
 		gtest.Assert(array.Contains(100), false)
@@ -43,13 +49,16 @@ func TestIntArray_Sort(t *testing.T) {
 		expect1 := []int{0, 1, 2, 3}
 		expect2 := []int{3, 2, 1, 0}
 		array := garray.NewIntArray()
+		array2 := garray.NewIntArray(true)
 		for i := 3; i >= 0; i-- {
 			array.Append(i)
+			array2.Append(i)
 		}
 		array.Sort()
 		gtest.Assert(array.Slice(), expect1)
 		array.Sort(true)
 		gtest.Assert(array.Slice(), expect2)
+		gtest.Assert(array2.Slice(), expect2)
 	})
 }
 
@@ -97,20 +106,48 @@ func TestIntArray_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		value1 := []int{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewIntArrayFrom(value1)
+		array2 := garray.NewIntArrayFrom(value1, true)
 		gtest.Assert(array1.Range(0, 1), []int{0})
 		gtest.Assert(array1.Range(1, 2), []int{1})
 		gtest.Assert(array1.Range(0, 2), []int{0, 1})
+		gtest.Assert(array1.Range(10, 2), nil)
 		gtest.Assert(array1.Range(-1, 10), value1)
+		gtest.Assert(array2.Range(1, 2), []int{1})
 	})
 }
 
 func TestIntArray_Merge(t *testing.T) {
 	gtest.Case(t, func() {
-		a1 := []int{0, 1, 2, 3}
-		a2 := []int{4, 5, 6, 7}
-		array1 := garray.NewIntArrayFrom(a1)
-		array2 := garray.NewIntArrayFrom(a2)
-		gtest.Assert(array1.Merge(array2).Slice(), []int{0, 1, 2, 3, 4, 5, 6, 7})
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		n1 := []int{0, 1, 2, 3}
+		n2 := []int{4, 5, 6, 7}
+		i1 := []interface{}{"1", "2"}
+		s1 := []string{"a", "b", "c"}
+		s2 := []string{"e", "f"}
+		a1 := garray.NewIntArrayFrom(n1)
+		a2 := garray.NewIntArrayFrom(n2)
+		a3 := garray.NewArrayFrom(i1)
+		a4 := garray.NewStringArrayFrom(s1)
+
+		a5 := garray.NewSortedStringArrayFrom(s2)
+		a6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+
+		a7 := garray.NewSortedStringArrayFrom(s1)
+		a8 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+
+		gtest.Assert(a1.Merge(a2).Slice(), []int{0, 1, 2, 3, 4, 5, 6, 7})
+		gtest.Assert(a1.Merge(a3).Len(), 10)
+		gtest.Assert(a1.Merge(a4).Len(), 13)
+		gtest.Assert(a1.Merge(a5).Len(), 15)
+		gtest.Assert(a1.Merge(a6).Len(), 18)
+		gtest.Assert(a1.Merge(a7).Len(), 21)
+		gtest.Assert(a1.Merge(a8).Len(), 23)
 	})
 }
 
@@ -122,6 +159,7 @@ func TestIntArray_Fill(t *testing.T) {
 		array2 := garray.NewIntArrayFrom(a2)
 		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []int{0, 100, 100})
 		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []int{100, 100})
+		gtest.Assert(array2.Fill(-1, 2, 100).Slice(), []int{100, 100})
 	})
 }
 
@@ -134,6 +172,7 @@ func TestIntArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[0], []int{1, 2})
 		gtest.Assert(chunks[1], []int{3, 4})
 		gtest.Assert(chunks[2], []int{5})
+		gtest.Assert(array1.Chunk(0), nil)
 	})
 }
 
@@ -151,9 +190,23 @@ func TestIntArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewIntArrayFrom(a1)
+		array2 := garray.NewIntArrayFrom(a1, true)
+		gtest.Assert(array1.SubSlice(6), []int{6})
+		gtest.Assert(array1.SubSlice(5), []int{5, 6})
+		gtest.Assert(array1.SubSlice(8), nil)
 		gtest.Assert(array1.SubSlice(0, 2), []int{0, 1})
 		gtest.Assert(array1.SubSlice(2, 2), []int{2, 3})
 		gtest.Assert(array1.SubSlice(5, 8), []int{5, 6})
+		gtest.Assert(array1.SubSlice(-1, 1), []int{6})
+		gtest.Assert(array1.SubSlice(-1, 9), []int{6})
+		gtest.Assert(array1.SubSlice(-2, 3), []int{5, 6})
+		gtest.Assert(array1.SubSlice(-7, 3), []int{0, 1, 2})
+		gtest.Assert(array1.SubSlice(-8, 3), nil)
+		gtest.Assert(array1.SubSlice(-1, -3), []int{3, 4, 5})
+		gtest.Assert(array1.SubSlice(-9, 3), nil)
+		gtest.Assert(array1.SubSlice(1, -1), []int{0})
+		gtest.Assert(array1.SubSlice(1, -3), nil)
+		gtest.Assert(array2.SubSlice(0, 2), []int{0, 1})
 	})
 }
 
@@ -179,7 +232,6 @@ func TestIntArray_PopRands(t *testing.T) {
 		ns2 := array.PopRands(7)
 		gtest.AssertIN(len(ns2), 6)
 		gtest.AssertIN(ns2, []int{100, 200, 300, 400, 500, 600})
-
 	})
 }
 
@@ -212,6 +264,7 @@ func TestNewSortedIntArrayFrom(t *testing.T) {
 		a1 := []int{0, 3, 2, 1, 4, 5, 6}
 		array1 := garray.NewSortedIntArrayFrom(a1, true)
 		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+		gtest.Assert(array1.Slice(), a1)
 	})
 }
 
@@ -246,7 +299,6 @@ func TestSortedIntArray_Sort(t *testing.T) {
 
 		gtest.Assert(array2.Len(), 4)
 		gtest.Assert(array2, []int{0, 1, 2, 3})
-
 	})
 }
 
@@ -257,7 +309,6 @@ func TestSortedIntArray_Get(t *testing.T) {
 		gtest.Assert(array1.Get(0), 0)
 		gtest.Assert(array1.Get(1), 1)
 		gtest.Assert(array1.Get(3), 5)
-
 	})
 }
 
@@ -282,7 +333,6 @@ func TestSortedIntArray_Remove(t *testing.T) {
 		i3 = array2.Remove(1)
 		gtest.Assert(array2.Search(4), -1)
 		gtest.Assert(i3, 4)
-
 	})
 }
 
@@ -294,7 +344,6 @@ func TestSortedIntArray_PopLeft(t *testing.T) {
 		gtest.Assert(i1, 1)
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1.Search(1), -1)
-
 	})
 }
 
@@ -334,7 +383,6 @@ func TestSortedIntArray_PopRands(t *testing.T) {
 		gtest.Assert(array2.Len(), 0)
 		gtest.Assert(len(ns2), 4)
 		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
-
 	})
 }
 
@@ -351,7 +399,6 @@ func TestSortedIntArray_PopLefts(t *testing.T) {
 		ns2 := array2.PopLefts(5)
 		gtest.Assert(array2.Len(), 0)
 		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
-
 	})
 }
 
@@ -375,6 +422,7 @@ func TestSortedIntArray_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{1, 3, 5, 2, 6, 7}
 		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := garray.NewSortedIntArrayFrom(a1, true)
 		ns1 := array1.Range(1, 4)
 		gtest.Assert(len(ns1), 3)
 		gtest.Assert(ns1, []int{2, 3, 5})
@@ -387,7 +435,7 @@ func TestSortedIntArray_Range(t *testing.T) {
 
 		nsl := array1.Range(5, 8)
 		gtest.Assert(len(nsl), 1)
-
+		gtest.Assert(array2.Range(1, 2), []int{2})
 	})
 }
 
@@ -404,7 +452,6 @@ func TestSortedIntArray_Contains(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{1, 3, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
-		//gtest.Assert(array1.Contains(3),true) //todo 这一行应该返回true
 		gtest.Assert(array1.Contains(4), false)
 	})
 }
@@ -425,7 +472,6 @@ func TestSortedIntArray_Clear(t *testing.T) {
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		array1.Clear()
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -435,12 +481,10 @@ func TestSortedIntArray_Chunk(t *testing.T) {
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		ns1 := array1.Chunk(2) //按每几个元素切成一个数组
 		ns2 := array1.Chunk(-1)
-		t.Log(ns1)
 		gtest.Assert(len(ns1), 3)
 		gtest.Assert(ns1[0], []int{1, 2})
 		gtest.Assert(ns1[2], []int{5})
 		gtest.Assert(len(ns2), 0)
-
 	})
 }
 
@@ -448,6 +492,7 @@ func TestSortedIntArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{1, 2, 3, 4, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := garray.NewSortedIntArrayFrom(a1, true)
 		ns1 := array1.SubSlice(1, 2)
 		gtest.Assert(len(ns1), 2)
 		gtest.Assert(ns1, []int{2, 3})
@@ -462,6 +507,10 @@ func TestSortedIntArray_SubSlice(t *testing.T) {
 		ns4 := array1.SubSlice(3, 1)
 		gtest.Assert(len(ns4), 1)
 		gtest.Assert(ns4, []int{4})
+		gtest.Assert(array1.SubSlice(-1, 1), []int{5})
+		gtest.Assert(array1.SubSlice(-9, 1), nil)
+		gtest.Assert(array1.SubSlice(1, -9), nil)
+		gtest.Assert(array2.SubSlice(1, 2), []int{2, 3})
 	})
 }
 
@@ -506,7 +555,6 @@ func TestSortedIntArray_SetUnique(t *testing.T) {
 		array1.SetUnique(true)
 		gtest.Assert(array1.Len(), 5)
 		gtest.Assert(array1, []int{1, 2, 3, 4, 5})
-
 	})
 }
 
@@ -518,7 +566,6 @@ func TestIntArray_SetArray(t *testing.T) {
 		array1.SetArray(a2)
 		gtest.Assert(array1.Len(), 2)
 		gtest.Assert(array1, []int{6, 7})
-
 	})
 }
 
@@ -608,3 +655,171 @@ func TestIntArray_Remove(t *testing.T) {
 		gtest.Assert(array1.Len(), 2)
 	})
 }
+
+func TestIntArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []int{1, 2, 3, 4}
+		a1 := garray.NewIntArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		//go1
+		go a1.LockFunc(func(n1 []int) { //读写锁
+			time.Sleep(2 * time.Second) //暂停2秒
+			n1[2] = 6
+			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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains(6), true)
+	})
+}
+
+func TestIntArray_SortFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []int{1, 4, 3, 2}
+		a1 := garray.NewIntArrayFrom(s1)
+		func1 := func(v1, v2 int) bool {
+			return v1 < v2
+		}
+		a11 := a1.SortFunc(func1)
+		gtest.Assert(a11, []int{1, 2, 3, 4})
+
+	})
+}
+
+func TestIntArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []int{1, 2, 3, 4}
+		a1 := garray.NewIntArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		//go1
+		go a1.RLockFunc(func(n1 []int) { //读锁
+			time.Sleep(2 * time.Second) //暂停1秒
+			n1[2] = 6
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		gtest.Assert(a1.Contains(6), true)
+	})
+}
+
+func TestSortedIntArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []int{1, 2, 3, 4}
+		a1 := garray.NewSortedIntArrayFrom(s1)
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		//go1
+		go a1.LockFunc(func(n1 []int) { //读写锁
+			time.Sleep(2 * time.Second) //暂停2秒
+			n1[2] = 6
+			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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains(6), true)
+	})
+}
+
+func TestSortedIntArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []int{1, 2, 3, 4}
+		a1 := garray.NewSortedIntArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		//go1
+		go a1.RLockFunc(func(n1 []int) { //读锁
+			time.Sleep(2 * time.Second) //暂停1秒
+			n1[2] = 6
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		gtest.Assert(a1.Contains(6), true)
+	})
+}
+
+func TestSortedIntArray_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+		i0 := []int{1, 2, 3, 4}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
+		s3 := garray.NewStringArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+		s5 := garray.NewSortedStringArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewSortedIntArrayFrom(i0)
+
+		gtest.Assert(a1.Merge(s2).Len(), 6)
+		gtest.Assert(a1.Merge(i1).Len(), 9)
+		gtest.Assert(a1.Merge(i2).Len(), 10)
+		gtest.Assert(a1.Merge(s3).Len(), 12)
+		gtest.Assert(a1.Merge(s4).Len(), 14)
+		gtest.Assert(a1.Merge(s5).Len(), 16)
+		gtest.Assert(a1.Merge(s6).Len(), 19)
+	})
+}

g/container/garray/garray_z_unit_interface_test.go

@@ -14,28 +14,36 @@ import (
 	"github.com/gogf/gf/g/util/gconv"
 	"strings"
 	"testing"
+	"time"
 )
 
 func Test_Array_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		expect := []interface{}{0, 1, 2, 3}
 		array := garray.NewArrayFrom(expect)
+		array2 := garray.NewArrayFrom(expect)
+		array3 := garray.NewArrayFrom([]interface{}{})
 		gtest.Assert(array.Slice(), expect)
 		array.Set(0, 100)
 		gtest.Assert(array.Get(0), 100)
 		gtest.Assert(array.Get(1), 1)
 		gtest.Assert(array.Search(100), 0)
+		gtest.Assert(array3.Search(100), -1)
 		gtest.Assert(array.Contains(100), true)
 		gtest.Assert(array.Remove(0), 100)
+
+		gtest.Assert(array2.Remove(3), 3)
+		gtest.Assert(array2.Remove(1), 1)
+
 		gtest.Assert(array.Contains(100), false)
 		array.Append(4)
 		gtest.Assert(array.Len(), 4)
 		array.InsertBefore(0, 100)
 		array.InsertAfter(0, 200)
-		gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 4})
+		gtest.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 4})
 		array.InsertBefore(5, 300)
 		array.InsertAfter(6, 400)
-		gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 300, 4, 400})
+		gtest.Assert(array.Slice(), []interface{}{100, 200, 2, 2, 3, 300, 4, 400})
 		gtest.Assert(array.Clear().Len(), 0)
 	})
 }
@@ -111,20 +119,48 @@ func TestArray_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(value1)
+		array2 := garray.NewArrayFrom(value1, true)
 		gtest.Assert(array1.Range(0, 1), []interface{}{0})
 		gtest.Assert(array1.Range(1, 2), []interface{}{1})
 		gtest.Assert(array1.Range(0, 2), []interface{}{0, 1})
 		gtest.Assert(array1.Range(-1, 10), value1)
+		gtest.Assert(array1.Range(10, 2), nil)
+		gtest.Assert(array2.Range(1, 3), []interface{}{1, 2})
 	})
 }
 
 func TestArray_Merge(t *testing.T) {
 	gtest.Case(t, func() {
-		a1 := []interface{}{0, 1, 2, 3}
-		a2 := []interface{}{4, 5, 6, 7}
-		array1 := garray.NewArrayFrom(a1)
-		array2 := garray.NewArrayFrom(a2)
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		i1 := []interface{}{0, 1, 2, 3}
+		i2 := []interface{}{4, 5, 6, 7}
+		array1 := garray.NewArrayFrom(i1)
+		array2 := garray.NewArrayFrom(i2)
 		gtest.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([]interface{}{3})
+		s3 := garray.NewStringArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+		s5 := garray.NewSortedStringArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewArrayFrom(i1)
+
+		gtest.Assert(a1.Merge(s2).Len(), 6)
+		gtest.Assert(a1.Merge(i3).Len(), 9)
+		gtest.Assert(a1.Merge(i4).Len(), 10)
+		gtest.Assert(a1.Merge(s3).Len(), 12)
+		gtest.Assert(a1.Merge(s4).Len(), 14)
+		gtest.Assert(a1.Merge(s5).Len(), 16)
+		gtest.Assert(a1.Merge(s6).Len(), 19)
 	})
 }
 
@@ -133,9 +169,10 @@ func TestArray_Fill(t *testing.T) {
 		a1 := []interface{}{0}
 		a2 := []interface{}{0}
 		array1 := garray.NewArrayFrom(a1)
-		array2 := garray.NewArrayFrom(a2)
+		array2 := garray.NewArrayFrom(a2, true)
 		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0, 100, 100})
 		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100, 100})
+		gtest.Assert(array2.Fill(-1, 2, 100).Slice(), []interface{}{100, 100})
 	})
 }
 
@@ -148,6 +185,7 @@ func TestArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[0], []interface{}{1, 2})
 		gtest.Assert(chunks[1], []interface{}{3, 4})
 		gtest.Assert(chunks[2], []interface{}{5})
+		gtest.Assert(array1.Chunk(0), nil)
 	})
 }
 
@@ -165,9 +203,15 @@ func TestArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
 		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a1, true)
 		gtest.Assert(array1.SubSlice(0, 2), []interface{}{0, 1})
 		gtest.Assert(array1.SubSlice(2, 2), []interface{}{2, 3})
 		gtest.Assert(array1.SubSlice(5, 8), []interface{}{5, 6})
+		gtest.Assert(array1.SubSlice(9, 1), nil)
+		gtest.Assert(array1.SubSlice(-2, 2), []interface{}{5, 6})
+		gtest.Assert(array1.SubSlice(-9, 2), nil)
+		gtest.Assert(array1.SubSlice(1, -2), nil)
+		gtest.Assert(array2.SubSlice(0, 2), []interface{}{0, 1})
 	})
 }
 
@@ -179,6 +223,14 @@ func TestArray_Rand(t *testing.T) {
 		gtest.Assert(len(array1.Rands(10)), 7)
 		gtest.AssertIN(array1.Rands(1)[0], a1)
 	})
+
+	gtest.Case(t, func() {
+		s1 := []interface{}{"a", "b", "c", "d"}
+		a1 := garray.NewArrayFrom(s1)
+		i1 := a1.Rand()
+		gtest.Assert(a1.Contains(i1), true)
+		gtest.Assert(a1.Len(), 4)
+	})
 }
 
 func TestArray_Shuffle(t *testing.T) {
@@ -496,6 +548,7 @@ func TestSortedArray_Range(t *testing.T) {
 			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)
 		gtest.Assert(i1, []interface{}{"c", "d", "e"})
 		gtest.Assert(array1.Len(), 6)
@@ -509,6 +562,8 @@ func TestSortedArray_Range(t *testing.T) {
 		gtest.Assert(len(i2), 2)
 		gtest.Assert(i2, []interface{}{"e", "f"})
 
+		gtest.Assert(array2.Range(1, 3), []interface{}{"b", "c"})
+
 	})
 }
 
@@ -587,6 +642,7 @@ func TestSortedArray_SubSlice(t *testing.T) {
 			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)
 		gtest.Assert(len(i1), 3)
 		gtest.Assert(i1, []interface{}{"c", "d", "e"})
@@ -598,6 +654,13 @@ func TestSortedArray_SubSlice(t *testing.T) {
 		i1 = array1.SubSlice(7, 2)
 		gtest.Assert(len(i1), 0)
 
+		s1 := array1.SubSlice(1, -2)
+		gtest.Assert(s1, nil)
+
+		s1 = array1.SubSlice(-9, 2)
+		gtest.Assert(s1, nil)
+		gtest.Assert(array2.SubSlice(1, 3), []interface{}{"b", "c", "d"})
+
 	})
 }
 
@@ -676,3 +739,168 @@ func TestSortedArray_SetUnique(t *testing.T) {
 		gtest.Assert(array1, []interface{}{"a", "c", "d"})
 	})
 }
+
+func TestSortedArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		s1 := []interface{}{"a", "b", "c", "d"}
+		a1 := garray.NewSortedArrayFrom(s1, func1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		//go1
+		go a1.LockFunc(func(n1 []interface{}) { //读写锁
+			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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		s1 := []interface{}{"a", "b", "c", "d"}
+		a1 := garray.NewSortedArrayFrom(s1, func1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		//go1
+		go a1.RLockFunc(func(n1 []interface{}) { //读写锁
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候不会被阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedArray_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		s1 := []interface{}{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
+		s3 := garray.NewStringArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+		s5 := garray.NewSortedStringArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+
+		a1 := garray.NewSortedArrayFrom(s1, func1)
+
+		gtest.Assert(a1.Merge(s2).Len(), 6)
+		gtest.Assert(a1.Merge(i1).Len(), 9)
+		gtest.Assert(a1.Merge(i2).Len(), 10)
+		gtest.Assert(a1.Merge(s3).Len(), 12)
+		gtest.Assert(a1.Merge(s4).Len(), 14)
+		gtest.Assert(a1.Merge(s5).Len(), 16)
+		gtest.Assert(a1.Merge(s6).Len(), 19)
+
+	})
+}
+
+func TestArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []interface{}{"a", "b", "c", "d"}
+		a1 := garray.NewArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 3)
+		//go1
+		go a1.LockFunc(func(n1 []interface{}) { //读写锁
+			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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []interface{}{"a", "b", "c", "d"}
+		a1 := garray.NewArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		//go1
+		go a1.RLockFunc(func(n1 []interface{}) { //读锁
+			time.Sleep(2 * time.Second) //暂停1秒
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}

g/container/garray/garray_z_unit_string_test.go

@@ -14,12 +14,15 @@ import (
 	"github.com/gogf/gf/g/util/gconv"
 	"strings"
 	"testing"
+	"time"
 )
 
 func Test_StringArray_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		expect := []string{"0", "1", "2", "3"}
 		array := garray.NewStringArrayFrom(expect)
+		array2 := garray.NewStringArrayFrom(expect, true)
+		array3 := garray.NewStringArrayFrom([]string{})
 		gtest.Assert(array.Slice(), expect)
 		array.Set(0, "100")
 		gtest.Assert(array.Get(0), 100)
@@ -37,6 +40,8 @@ func Test_StringArray_Basic(t *testing.T) {
 		array.InsertAfter(6, "400")
 		gtest.Assert(array.Slice(), []string{"100", "200", "1", "2", "3", "300", "4", "400"})
 		gtest.Assert(array.Clear().Len(), 0)
+		gtest.Assert(array2.Slice(), expect)
+		gtest.Assert(array3.Search("100"), -1)
 	})
 }
 
@@ -99,20 +104,48 @@ func TestString_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStringArrayFrom(value1)
+		array2 := garray.NewStringArrayFrom(value1, true)
 		gtest.Assert(array1.Range(0, 1), []interface{}{"0"})
 		gtest.Assert(array1.Range(1, 2), []interface{}{"1"})
 		gtest.Assert(array1.Range(0, 2), []interface{}{"0", "1"})
 		gtest.Assert(array1.Range(-1, 10), value1)
+		gtest.Assert(array1.Range(10, 1), nil)
+		gtest.Assert(array2.Range(0, 1), []interface{}{"0"})
 	})
 }
 
 func TestStringArray_Merge(t *testing.T) {
 	gtest.Case(t, func() {
-		a1 := []string{"0", "1", "2", "3"}
-		a2 := []string{"4", "5", "6", "7"}
-		array1 := garray.NewStringArrayFrom(a1)
-		array2 := garray.NewStringArrayFrom(a2)
+		a11 := []string{"0", "1", "2", "3"}
+		a21 := []string{"4", "5", "6", "7"}
+		array1 := garray.NewStringArrayFrom(a11)
+		array2 := garray.NewStringArrayFrom(a21)
 		gtest.Assert(array1.Merge(array2).Slice(), []string{"0", "1", "2", "3", "4", "5", "6", "7"})
+
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
+		s3 := garray.NewStringArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+		s5 := garray.NewSortedStringArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewStringArrayFrom(s1)
+
+		gtest.Assert(a1.Merge(s2).Len(), 6)
+		gtest.Assert(a1.Merge(i1).Len(), 9)
+		gtest.Assert(a1.Merge(i2).Len(), 10)
+		gtest.Assert(a1.Merge(s3).Len(), 12)
+		gtest.Assert(a1.Merge(s4).Len(), 14)
+		gtest.Assert(a1.Merge(s5).Len(), 16)
+		gtest.Assert(a1.Merge(s6).Len(), 19)
 	})
 }
 
@@ -139,7 +172,6 @@ func TestStringArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[1], []string{"3", "4"})
 		gtest.Assert(chunks[2], []string{"5"})
 		gtest.Assert(len(array1.Chunk(0)), 0)
-
 	})
 }
 
@@ -157,9 +189,15 @@ func TestStringArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
 		array1 := garray.NewStringArrayFrom(a1)
+		array2 := garray.NewStringArrayFrom(a1, true)
 		gtest.Assert(array1.SubSlice(0, 2), []string{"0", "1"})
 		gtest.Assert(array1.SubSlice(2, 2), []string{"2", "3"})
 		gtest.Assert(array1.SubSlice(5, 8), []string{"5", "6"})
+		gtest.Assert(array1.SubSlice(8, 2), nil)
+		gtest.Assert(array1.SubSlice(1, -2), nil)
+		gtest.Assert(array1.SubSlice(-5, 2), []string{"2", "3"})
+		gtest.Assert(array1.SubSlice(-10, 1), nil)
+		gtest.Assert(array2.SubSlice(0, 2), []string{"0", "1"})
 	})
 }
 
@@ -172,7 +210,6 @@ func TestStringArray_Rand(t *testing.T) {
 		gtest.AssertIN(array1.Rands(1)[0], a1)
 		gtest.Assert(len(array1.Rand()), 1)
 		gtest.AssertIN(array1.Rand(), a1)
-
 	})
 }
 
@@ -181,10 +218,9 @@ func TestStringArray_PopRands(t *testing.T) {
 		a1 := []string{"a", "b", "c", "d", "e", "f", "g"}
 		a2 := []string{"1", "2", "3", "4", "5", "6", "7"}
 		array1 := garray.NewStringArrayFrom(a1)
-		//todo gtest.AssertIN(array1.PopRands(1),a1)
 		gtest.AssertIN(array1.PopRands(1), strings.Join(a1, ","))
 		gtest.AssertNI(array1.PopRands(1), strings.Join(a2, ","))
-
+		gtest.Assert(len(array1.PopRands(10)), 5)
 	})
 }
 
@@ -275,26 +311,6 @@ func TestStringArray_Sum(t *testing.T) {
 	})
 }
 
-//func TestStringArray_SortFunc(t *testing.T) {
-//    gtest.Case(t, func() {
-//        a1 := []string{"0","1","2","3","4","5","6"}
-//        //a2 := []string{"0","a","3","4","5","6"}
-//        array1 := garray.NewStringArrayFrom(a1)
-//
-//        lesss:=func(v1,v2 string)bool{
-//            if v1>v2{
-//                return true
-//            }
-//            return false
-//        }
-//        gtest.Assert(array1.Len(),7)
-//        gtest.Assert(lesss("1","2"),false)
-//        gtest.Assert(array1.SortFunc(lesss("1","2"))  ,false)
-//
-//
-//    })
-//}
-
 func TestStringArray_PopRand(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
@@ -324,7 +340,6 @@ func TestStringArray_CountValues(t *testing.T) {
 		gtest.Assert(len(m1), 6)
 		gtest.Assert(m1["2"], 1)
 		gtest.Assert(m1["4"], 2)
-
 	})
 }
 
@@ -357,7 +372,6 @@ func TestSortedStringArray_SetArray(t *testing.T) {
 		gtest.Assert(array1.Contains("d"), false)
 		gtest.Assert(array1.Contains("b"), false)
 		gtest.Assert(array1.Contains("g"), true)
-
 	})
 }
 
@@ -367,7 +381,7 @@ func TestSortedStringArray_Sort(t *testing.T) {
 		array1 := garray.NewSortedStringArrayFrom(a1)
 
 		gtest.Assert(array1, []string{"a", "b", "c", "d"})
-		array1.Sort() //todo 这个SortedStringArray.sort这个方法没有必要，
+		array1.Sort()
 		gtest.Assert(array1.Len(), 4)
 		gtest.Assert(array1.Contains("c"), true)
 		gtest.Assert(array1, []string{"a", "b", "c", "d"})
@@ -380,7 +394,6 @@ func TestSortedStringArray_Get(t *testing.T) {
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		gtest.Assert(array1.Get(2), "c")
 		gtest.Assert(array1.Get(0), "a")
-
 	})
 }
 
@@ -400,7 +413,6 @@ func TestSortedStringArray_Remove(t *testing.T) {
 		// 此时array1里的元素只剩下2个
 		gtest.Assert(array1.Remove(1), "d")
 		gtest.Assert(array1.Len(), 1)
-
 	})
 }
 
@@ -486,6 +498,7 @@ func TestSortedStringArray_Range(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := garray.NewSortedStringArrayFrom(a1, true)
 		s1 := array1.Range(2, 4)
 		gtest.Assert(len(s1), 2)
 		gtest.Assert(s1, []string{"c", "d"})
@@ -497,6 +510,11 @@ func TestSortedStringArray_Range(t *testing.T) {
 		s1 = array1.Range(4, 8)
 		gtest.Assert(len(s1), 3)
 		gtest.Assert(s1, []string{"e", "f", "g"})
+		gtest.Assert(array1.Range(10, 2), nil)
+
+		s2 := array2.Range(2, 4)
+		gtest.Assert(s2, []string{"c", "d"})
+
 	})
 }
 
@@ -528,7 +546,6 @@ func TestSortedStringArray_Clear(t *testing.T) {
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		array1.Clear()
 		gtest.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -536,6 +553,7 @@ func TestSortedStringArray_SubSlice(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := garray.NewSortedStringArrayFrom(a1, true)
 		s1 := array1.SubSlice(1, 3)
 		gtest.Assert(len(s1), 3)
 		gtest.Assert(s1, []string{"b", "c", "d"})
@@ -547,6 +565,16 @@ func TestSortedStringArray_SubSlice(t *testing.T) {
 		s3 := array1.SubSlice(10, 2)
 		gtest.Assert(len(s3), 0)
 
+		s3 = array1.SubSlice(-5, 2)
+		gtest.Assert(s3, []string{"c", "d"})
+
+		s3 = array1.SubSlice(-10, 2)
+		gtest.Assert(s3, nil)
+
+		s3 = array1.SubSlice(1, -2)
+		gtest.Assert(s3, nil)
+
+		gtest.Assert(array2.SubSlice(1, 3), []string{"b", "c", "d"})
 	})
 }
 
@@ -564,7 +592,6 @@ func TestSortedStringArray_Rand(t *testing.T) {
 		a1 := []string{"e", "a", "d"}
 		array1 := garray.NewSortedStringArrayFrom(a1)
 		gtest.AssertIN(array1.Rand(), []string{"e", "a", "d"})
-
 	})
 }
 
@@ -611,6 +638,7 @@ func TestSortedStringArray_Chunk(t *testing.T) {
 		gtest.Assert(len(array2), 3)
 		gtest.Assert(len(array2[0]), 2)
 		gtest.Assert(array2[1], []string{"c", "d"})
+		gtest.Assert(array1.Chunk(0), nil)
 	})
 }
 
@@ -634,6 +662,174 @@ func TestStringArray_Remove(t *testing.T) {
 		s1 = array1.Remove(3)
 		gtest.Assert(s1, "c")
 		gtest.Assert(array1.Len(), 3)
-
+	})
+}
+
+func TestStringArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewStringArrayFrom(s1, true)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		//go1
+		go a1.RLockFunc(func(n1 []string) { //读锁
+			time.Sleep(2 * time.Second) //暂停1秒
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedStringArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedStringArrayFrom(s1)
+
+		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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedStringArray_RLockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewSortedStringArrayFrom(s1)
+
+		ch1 := make(chan int64, 3)
+		ch2 := make(chan int64, 1)
+		//go1
+		go a1.RLockFunc(func(n1 []string) { //读锁
+			time.Sleep(2 * time.Second) //暂停1秒
+			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抖动,以豪秒为单位
+		gtest.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		gtest.Assert(a1.Contains("g"), true)
+	})
+}
+
+func TestSortedStringArray_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		func1 := func(v1, v2 interface{}) int {
+			if gconv.Int(v1) < gconv.Int(v2) {
+				return 0
+			}
+			return 1
+		}
+
+		s1 := []string{"a", "b", "c", "d"}
+		s2 := []string{"e", "f"}
+		i1 := garray.NewIntArrayFrom([]int{1, 2, 3})
+		i2 := garray.NewArrayFrom([]interface{}{3})
+		s3 := garray.NewStringArrayFrom([]string{"g", "h"})
+		s4 := garray.NewSortedArrayFrom([]interface{}{4, 5}, func1)
+		s5 := garray.NewSortedStringArrayFrom(s2)
+		s6 := garray.NewSortedIntArrayFrom([]int{1, 2, 3})
+		a1 := garray.NewSortedStringArrayFrom(s1)
+
+		gtest.Assert(a1.Merge(s2).Len(), 6)
+		gtest.Assert(a1.Merge(i1).Len(), 9)
+		gtest.Assert(a1.Merge(i2).Len(), 10)
+		gtest.Assert(a1.Merge(s3).Len(), 12)
+		gtest.Assert(a1.Merge(s4).Len(), 14)
+		gtest.Assert(a1.Merge(s5).Len(), 16)
+		gtest.Assert(a1.Merge(s6).Len(), 19)
+	})
+}
+
+func TestStringArray_SortFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []string{"a", "d", "c", "b"}
+		a1 := garray.NewStringArrayFrom(s1)
+		func1 := func(v1, v2 string) bool {
+			return v1 < v2
+		}
+		a11 := a1.SortFunc(func1)
+		gtest.Assert(a11, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestStringArray_LockFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := []string{"a", "b", "c", "d"}
+		a1 := garray.NewStringArrayFrom(s1)
+
+		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抖动,以豪秒为单位
+		gtest.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		gtest.Assert(a1.Contains("g"), true)
 	})
 }

g/container/gchan/gchan_example_test.go

@@ -0,0 +1,29 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). 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 gchan_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/g/container/gchan"
+)
+
+func Example_basic() {
+	n := 10
+	c := gchan.New(n)
+	for i := 0; i < n; i++ {
+		c.Push(i)
+	}
+	fmt.Println(c.Len(), c.Cap())
+	for i := 0; i < n; i++ {
+		fmt.Print(c.Pop())
+	}
+	c.Close()
+
+	// Output:
+	//10 10
+	//0123456789
+}

g/container/glist/glist.go

@@ -9,119 +9,115 @@
 package glist
 
 import (
-    "container/list"
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"container/list"
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type (
 	List struct {
-	    mu   *rwmutex.RWMutex
-	    list *list.List
+		mu   *rwmutex.RWMutex
+		list *list.List
 	}
 
 	Element = list.Element
 )
 
 // New creates and returns a new empty doubly linked list.
-func New(unsafe...bool) *List {
-	return &List {
-	    mu   : rwmutex.New(unsafe...),
-	    list : list.New(),
-    }
+func New(unsafe ...bool) *List {
+	return &List{
+		mu:   rwmutex.New(unsafe...),
+		list: list.New(),
+	}
 }
 
 // PushFront inserts a new element <e> with value <v> at the front of list <l> and returns <e>.
 func (l *List) PushFront(v interface{}) (e *Element) {
-    l.mu.Lock()
-    e = l.list.PushFront(v)
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	e = l.list.PushFront(v)
+	l.mu.Unlock()
+	return
 }
 
 // PushBack inserts a new element <e> with value <v> at the back of list <l> and returns <e>.
 func (l *List) PushBack(v interface{}) (e *Element) {
-    l.mu.Lock()
-    e = l.list.PushBack(v)
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	e = l.list.PushBack(v)
+	l.mu.Unlock()
+	return
 }
 
 // PushFronts inserts multiple new elements with values <values> at the front of list <l>.
 func (l *List) PushFronts(values []interface{}) {
-    l.mu.Lock()
+	l.mu.Lock()
 	for _, v := range values {
-        l.list.PushFront(v)
+		l.list.PushFront(v)
 	}
-    l.mu.Unlock()
+	l.mu.Unlock()
 }
 
 // PushBacks inserts multiple new elements with values <values> at the back of list <l>.
 func (l *List) PushBacks(values []interface{}) {
-    l.mu.Lock()
-    for _, v := range values {
-        l.list.PushBack(v)
-    }
-    l.mu.Unlock()
+	l.mu.Lock()
+	for _, v := range values {
+		l.list.PushBack(v)
+	}
+	l.mu.Unlock()
 }
 
 // PopBack removes the element from back of <l> and returns the value of the element.
 func (l *List) PopBack() (value interface{}) {
-    l.mu.Lock()
+	l.mu.Lock()
 	if e := l.list.Back(); e != nil {
-        value = l.list.Remove(e)
+		value = l.list.Remove(e)
 	}
-    l.mu.Unlock()
+	l.mu.Unlock()
 	return
 }
 
 // PopFront removes the element from front of <l> and returns the value of the element.
 func (l *List) PopFront() (value interface{}) {
-    l.mu.Lock()
-    if e := l.list.Front(); e != nil {
-        value = l.list.Remove(e)
-    }
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	if e := l.list.Front(); e != nil {
+		value = l.list.Remove(e)
+	}
+	l.mu.Unlock()
+	return
 }
 
 // PopBacks removes <max> elements from back of <l>
 // and returns values of the removed elements as slice.
 func (l *List) PopBacks(max int) (values []interface{}) {
-    l.mu.Lock()
-    length := l.list.Len()
-    if length > 0 {
-        if max > 0 && max < length {
-            length = max
-        }
-        tempe := (*Element)(nil)
-        values = make([]interface{}, length)
-        for i := 0; i < length; i++ {
-            tempe     = l.list.Back()
-            values[i] = l.list.Remove(tempe)
-        }
-    }
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	length := l.list.Len()
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]interface{}, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.list.Remove(l.list.Back())
+		}
+	}
+	l.mu.Unlock()
+	return
 }
 
 // PopFronts removes <max> elements from front of <l>
 // and returns values of the removed elements as slice.
 func (l *List) PopFronts(max int) (values []interface{}) {
-    l.mu.RLock()
-    length := l.list.Len()
-    if length > 0 {
-        if max > 0 && max < length {
-            length = max
-        }
-        tempe := (*Element)(nil)
-        values = make([]interface{}, length)
-        for i := 0; i < length; i++ {
-            tempe     = l.list.Front()
-            values[i] = l.list.Remove(tempe)
-        }
-    }
-    l.mu.RUnlock()
-    return
+	l.mu.Lock()
+	length := l.list.Len()
+	if length > 0 {
+		if max > 0 && max < length {
+			length = max
+		}
+		values = make([]interface{}, length)
+		for i := 0; i < length; i++ {
+			values[i] = l.list.Remove(l.list.Front())
+		}
+	}
+	l.mu.Unlock()
+	return
 }
 
 // PopBackAll removes all elements from back of <l>
@@ -133,79 +129,79 @@ func (l *List) PopBackAll() []interface{} {
 // PopFrontAll removes all elements from front of <l>
 // and returns values of the removed elements as slice.
 func (l *List) PopFrontAll() []interface{} {
-    return l.PopFronts(-1)
+	return l.PopFronts(-1)
 }
 
 // FrontAll copies and returns values of all elements from front of <l> as slice.
 func (l *List) FrontAll() (values []interface{}) {
-    l.mu.RLock()
-    length := l.list.Len()
-    if length > 0 {
-        values = make([]interface{}, length)
-        for i, e := 0, l.list.Front(); i < length; i, e = i + 1, e.Next() {
-            values[i] = e.Value
-        }
-    }
-    l.mu.RUnlock()
-    return
+	l.mu.RLock()
+	length := l.list.Len()
+	if length > 0 {
+		values = make([]interface{}, length)
+		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
+			values[i] = e.Value
+		}
+	}
+	l.mu.RUnlock()
+	return
 }
 
 // BackAll copies and returns values of all elements from back of <l> as slice.
 func (l *List) BackAll() (values []interface{}) {
-    l.mu.RLock()
+	l.mu.RLock()
 	length := l.list.Len()
 	if length > 0 {
-        values = make([]interface{}, length)
-        for i, e := 0, l.list.Back(); i < length; i, e = i + 1, e.Prev() {
-            values[i] = e.Value
-        }
-    }
-    l.mu.RUnlock()
+		values = make([]interface{}, length)
+		for i, e := 0, l.list.Back(); i < length; i, e = i+1, e.Prev() {
+			values[i] = e.Value
+		}
+	}
+	l.mu.RUnlock()
 	return
 }
 
 // FrontValue returns value of the first element of <l> or nil if the list is empty.
 func (l *List) FrontValue() (value interface{}) {
-    l.mu.RLock()
-    if e := l.list.Front(); e != nil {
-        value = e.Value
-    }
-    l.mu.RUnlock()
-    return
+	l.mu.RLock()
+	if e := l.list.Front(); e != nil {
+		value = e.Value
+	}
+	l.mu.RUnlock()
+	return
 }
 
 // BackValue returns value of the last element of <l> or nil if the list is empty.
 func (l *List) BackValue() (value interface{}) {
-    l.mu.RLock()
-    if e := l.list.Back(); e != nil {
-        value = e.Value
-    }
-    l.mu.RUnlock()
-    return
+	l.mu.RLock()
+	if e := l.list.Back(); e != nil {
+		value = e.Value
+	}
+	l.mu.RUnlock()
+	return
 }
 
 // Front returns the first element of list <l> or nil if the list is empty.
 func (l *List) Front() (e *Element) {
-    l.mu.RLock()
-    e = l.list.Front()
-    l.mu.RUnlock()
-    return
+	l.mu.RLock()
+	e = l.list.Front()
+	l.mu.RUnlock()
+	return
 }
 
 // Back returns the last element of list <l> or nil if the list is empty.
 func (l *List) Back() (e *Element) {
-    l.mu.RLock()
-    e = l.list.Back()
-    l.mu.RUnlock()
-    return
+	l.mu.RLock()
+	e = l.list.Back()
+	l.mu.RUnlock()
+	return
 }
 
 // Len returns the number of elements of list <l>.
 // The complexity is O(1).
 func (l *List) Len() (length int) {
-    l.mu.RLock()
-    length = l.list.Len()
-    l.mu.RUnlock()
+	l.mu.RLock()
+	length = l.list.Len()
+	l.mu.RUnlock()
 	return
 }
 
@@ -218,107 +214,107 @@ func (l *List) Size() int {
 // 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 *List) MoveBefore(e, p *Element) {
-    l.mu.Lock()
-    l.list.MoveBefore(e, p)
-    l.mu.Unlock()
+	l.mu.Lock()
+	l.list.MoveBefore(e, p)
+	l.mu.Unlock()
 }
 
 // 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 *List) MoveAfter(e, p *Element) {
-    l.mu.Lock()
-    l.list.MoveAfter(e, p)
-    l.mu.Unlock()
+	l.mu.Lock()
+	l.list.MoveAfter(e, p)
+	l.mu.Unlock()
 }
 
 // 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 *List) MoveToFront(e *Element) {
-    l.mu.Lock()
-    l.list.MoveToFront(e)
-    l.mu.Unlock()
+	l.mu.Lock()
+	l.list.MoveToFront(e)
+	l.mu.Unlock()
 }
 
 // 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 *List) MoveToBack(e *Element) {
-    l.mu.Lock()
-    l.list.MoveToBack(e)
-    l.mu.Unlock()
+	l.mu.Lock()
+	l.list.MoveToBack(e)
+	l.mu.Unlock()
 }
 
 // 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 *List) PushBackList(other *List) {
-    if l != other {
-        other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
-    l.mu.Lock()
-    l.list.PushBackList(other.list)
-    l.mu.Unlock()
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	l.list.PushBackList(other.list)
+	l.mu.Unlock()
 }
 
 // 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 *List) PushFrontList(other *List) {
-    if l != other {
-        other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
-    l.mu.Lock()
-    l.list.PushFrontList(other.list)
-    l.mu.Unlock()
+	if l != other {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	l.mu.Lock()
+	l.list.PushFrontList(other.list)
+	l.mu.Unlock()
 }
 
 // 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(v interface{}, p *Element) (e *Element) {
-    l.mu.Lock()
-    e = l.list.InsertAfter(v, p)
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	e = l.list.InsertAfter(v, p)
+	l.mu.Unlock()
+	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 *List) InsertBefore(v interface{}, p *Element) (e *Element) {
-    l.mu.Lock()
-    e = l.list.InsertBefore(v, p)
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	e = l.list.InsertBefore(v, p)
+	l.mu.Unlock()
+	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 *List) Remove(e *Element) (value interface{}) {
-    l.mu.Lock()
-    value = l.list.Remove(e)
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	value = l.list.Remove(e)
+	l.mu.Unlock()
+	return
 }
 
 // Removes removes multiple elements <es> from <l> if <es> are elements of list <l>.
 func (l *List) Removes(es []*Element) {
-    l.mu.Lock()
-    for _, e := range es {
-        l.list.Remove(e)
-    }
-    l.mu.Unlock()
-    return
+	l.mu.Lock()
+	for _, e := range es {
+		l.list.Remove(e)
+	}
+	l.mu.Unlock()
+	return
 }
 
 // RemoveAll removes all elements from list <l>.
 func (l *List) RemoveAll() {
-    l.mu.Lock()
-    l.list = list.New()
-    l.mu.Unlock()
+	l.mu.Lock()
+	l.list = list.New()
+	l.mu.Unlock()
 }
 
 // See RemoveAll().
@@ -328,30 +324,30 @@ func (l *List) Clear() {
 
 // RLockFunc locks reading with given callback function <f> within RWMutex.RLock.
 func (l *List) RLockFunc(f func(list *list.List)) {
-    l.mu.RLock()
-    defer l.mu.RUnlock()
-    f(l.list)
+	l.mu.RLock()
+	defer l.mu.RUnlock()
+	f(l.list)
 }
 
 // LockFunc locks writing with given callback function <f> within RWMutex.Lock.
 func (l *List) LockFunc(f func(list *list.List)) {
-    l.mu.Lock()
-    defer l.mu.Unlock()
-    f(l.list)
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	f(l.list)
 }
 
 // Iterator is alias of IteratorAsc.
-func (l *List) Iterator(f func (e *Element) bool) {
+func (l *List) Iterator(f func(e *Element) bool) {
 	l.IteratorAsc(f)
 }
 
 // IteratorAsc iterates the list in ascending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (l *List) IteratorAsc(f func (e *Element) bool) {
+func (l *List) IteratorAsc(f func(e *Element) bool) {
 	l.mu.RLock()
 	length := l.list.Len()
 	if length > 0 {
-		for i, e := 0, l.list.Front(); i < length; i, e = i + 1, e.Next() {
+		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
 			if !f(e) {
 				break
 			}
@@ -362,15 +358,15 @@ func (l *List) IteratorAsc(f func (e *Element) bool) {
 
 // IteratorDesc iterates the list in descending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (l *List) IteratorDesc(f func (e *Element) bool) {
+func (l *List) IteratorDesc(f func(e *Element) bool) {
 	l.mu.RLock()
 	length := l.list.Len()
 	if length > 0 {
-		for i, e := 0, l.list.Back(); i < length; i, e = i + 1, e.Prev() {
+		for i, e := 0, l.list.Back(); i < length; i, e = i+1, e.Prev() {
 			if !f(e) {
 				break
 			}
 		}
 	}
 	l.mu.RUnlock()
-}
+}

g/container/glist/glist_example_test.go

@@ -0,0 +1,36 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). 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 (
+	"fmt"
+	"github.com/gogf/gf/g/container/glist"
+)
+
+func Example_basic() {
+	n := 10
+	l := glist.New()
+	for i := 0; i < n; i++ {
+		l.PushBack(i)
+	}
+	fmt.Println(l.Len())
+	fmt.Println(l.FrontAll())
+	fmt.Println(l.BackAll())
+	for i := 0; i < n; i++ {
+		fmt.Print(l.PopFront())
+	}
+	l.Clear()
+	fmt.Println()
+	fmt.Println(l.Len())
+
+	// Output:
+	//10
+	//[0 1 2 3 4 5 6 7 8 9]
+	//[9 8 7 6 5 4 3 2 1 0]
+	//0123456789
+	//0
+}

g/container/glist/glist_z_bench_test.go

@@ -9,48 +9,53 @@
 package glist
 
 import (
-    "testing"
+	"testing"
 )
 
 var (
-    l  = New()
-    bn = 20000000
+	l = New()
 )
 
 func Benchmark_PushBack(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PushBack(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			l.PushBack(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_PushFront(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PushFront(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			l.PushFront(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_Len(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.Len()
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			l.Len()
+		}
+	})
 }
 
 func Benchmark_PopFront(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PopFront()
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			l.PopFront()
+		}
+	})
 }
 
 func Benchmark_PopBack(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PopBack()
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		for pb.Next() {
+			l.PopBack()
+		}
+	})
 }
-
-
-

g/container/glist/glist_z_unit_test.go

@@ -8,6 +8,7 @@ package glist
 
 import (
 	"container/list"
+
 	"github.com/gogf/gf/g/test/gtest"
 	"github.com/gogf/gf/g/util/gconv"
 
@@ -407,17 +408,18 @@ func TestList_PushBacks(t *testing.T) {
 }
 
 func TestList_PopBacks(t *testing.T) {
-	l := New()
-	a1 := []interface{}{1, 2, 3, 4}
-	a2 := []interface{}{"a", "c", "b", "e"}
-	l.PushFronts(a1)
-	i1 := l.PopBacks(2)
-	gtest.Assert(i1, []interface{}{"1", "2"})
-
-	l.PushBacks(a2) //4.3,a,c,b,e
-	i1 = l.PopBacks(3)
-	gtest.Assert(i1, []interface{}{"e", "b", "c"})
+	gtest.Case(t, func() {
+		l := New()
+		a1 := []interface{}{1, 2, 3, 4}
+		a2 := []interface{}{"a", "c", "b", "e"}
+		l.PushFronts(a1)
+		i1 := l.PopBacks(2)
+		gtest.Assert(i1, []interface{}{1, 2})
 
+		l.PushBacks(a2) //4.3,a,c,b,e
+		i1 = l.PopBacks(3)
+		gtest.Assert(i1, []interface{}{"e", "b", "c"})
+	})
 }
 
 func TestList_PopFronts(t *testing.T) {
@@ -425,7 +427,7 @@ func TestList_PopFronts(t *testing.T) {
 	a1 := []interface{}{1, 2, 3, 4}
 	l.PushFronts(a1)
 	i1 := l.PopFronts(2)
-	gtest.Assert(i1, []interface{}{"4", "3"})
+	gtest.Assert(i1, []interface{}{4, 3})
 	gtest.Assert(l.Len(), 2)
 }
 

g/container/gmap/gmap.go

@@ -8,7 +8,7 @@
 package gmap
 
 // Map based on hash table, alias of AnyAnyMap.
-type Map     = AnyAnyMap
+type Map = AnyAnyMap
 type HashMap = AnyAnyMap
 
 // New returns an empty hash map.
@@ -23,7 +23,7 @@ func New(unsafe ...bool) *Map {
 // there might be some concurrent-safe issues when changing the map outside.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewFrom(data map[interface{}]interface{}, unsafe...bool) *Map {
+func NewFrom(data map[interface{}]interface{}, unsafe ...bool) *Map {
 	return NewAnyAnyMapFrom(data, unsafe...)
 }
 
@@ -39,6 +39,6 @@ func NewHashMap(unsafe ...bool) *Map {
 // there might be some concurrent-safe issues when changing the map outside.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewHashMapFrom(data map[interface{}]interface{}, unsafe...bool) *Map {
+func NewHashMapFrom(data map[interface{}]interface{}, unsafe ...bool) *Map {
 	return NewAnyAnyMapFrom(data, unsafe...)
-}
+}

g/container/gmap/gmap_hash_any_any_map.go

@@ -7,13 +7,17 @@
 package gmap
 
 import (
+	"encoding/json"
+
+	"github.com/gogf/gf/g/util/gconv"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type AnyAnyMap struct {
-    mu   *rwmutex.RWMutex
-    data map[interface{}]interface{}
+	mu   *rwmutex.RWMutex
+	data map[interface{}]interface{}
 }
 
 // NewAnyAnyMap returns an empty hash map.
@@ -21,63 +25,63 @@ type AnyAnyMap struct {
 // which is false in default, means concurrent-safe.
 func NewAnyAnyMap(unsafe ...bool) *AnyAnyMap {
 	return &AnyAnyMap{
-		mu   : rwmutex.New(unsafe...),
-		data : make(map[interface{}]interface{}),
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[interface{}]interface{}),
 	}
 }
 
 // NewAnyAnyMapFrom 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[interface{}]interface{}, unsafe...bool) *AnyAnyMap {
-    return &AnyAnyMap{
-        mu   : rwmutex.New(unsafe...),
-	    data : data,
-    }
+func NewAnyAnyMapFrom(data map[interface{}]interface{}, unsafe ...bool) *AnyAnyMap {
+	return &AnyAnyMap{
+		mu:   rwmutex.New(unsafe...),
+		data: data,
+	}
 }
 
 // Iterator iterates the hash map with custom callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (m *AnyAnyMap) Iterator(f func (k interface{}, v interface{}) bool) {
-    m.mu.RLock()
-    defer m.mu.RUnlock()
-    for k, v := range m.data {
-        if !f(k, v) {
-            break
-        }
-    }
+func (m *AnyAnyMap) Iterator(f func(k interface{}, v interface{}) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	for k, v := range m.data {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
 func (m *AnyAnyMap) Clone(unsafe ...bool) *AnyAnyMap {
-    return NewFrom(m.Map(), unsafe ...)
+	return NewFrom(m.Map(), unsafe...)
 }
 
 // Map returns a copy of the data of the hash map.
 func (m *AnyAnyMap) Map() map[interface{}]interface{} {
-    m.mu.RLock()
+	m.mu.RLock()
 	data := make(map[interface{}]interface{}, len(m.data))
-    for k, v := range m.data {
-	    data[k] = v
-    }
-    m.mu.RUnlock()
-    return data
+	for k, v := range m.data {
+		data[k] = v
+	}
+	m.mu.RUnlock()
+	return data
 }
 
 // Set sets key-value to the hash map.
 func (m *AnyAnyMap) Set(key interface{}, val interface{}) {
-    m.mu.Lock()
-    m.data[key] = val
-    m.mu.Unlock()
+	m.mu.Lock()
+	m.data[key] = val
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the hash map.
 func (m *AnyAnyMap) Sets(data map[interface{}]interface{}) {
-    m.mu.Lock()
-    for k, v := range data {
-        m.data[k] = v
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	for k, v := range data {
+		m.data[k] = v
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given <key>.
@@ -91,10 +95,10 @@ func (m *AnyAnyMap) Search(key interface{}) (value interface{}, found bool) {
 
 // Get returns the value by given <key>.
 func (m *AnyAnyMap) Get(key interface{}) interface{} {
-    m.mu.RLock()
-    val, _ := m.data[key]
-    m.mu.RUnlock()
-    return val
+	m.mu.RLock()
+	val, _ := m.data[key]
+	m.mu.RUnlock()
+	return val
 }
 
 // doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
@@ -107,26 +111,26 @@ func (m *AnyAnyMap) Get(key interface{}) interface{} {
 //
 // It returns value with given <key>.
 func (m *AnyAnyMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if v, ok := m.data[key]; ok {
-        return v
-    }
-    if f, ok := value.(func() interface {}); ok {
-        value = f()
-    }
-    m.data[key] = value
-    return value
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if v, ok := m.data[key]; ok {
+		return v
+	}
+	if f, ok := value.(func() interface{}); ok {
+		value = f()
+	}
+	m.data[key] = value
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or set value with given <value> if not exist and returns this 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
-    }
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
@@ -134,10 +138,10 @@ func (m *AnyAnyMap) GetOrSet(key interface{}, value interface{}) interface{} {
 // and returns this value.
 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
-    }
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -148,10 +152,10 @@ func (m *AnyAnyMap) GetOrSetFunc(key interface{}, f func() interface{}) interfac
 // with mutex.Lock of the hash map.
 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
-    }
+		return m.doSetWithLockCheck(key, f)
+	} else {
+		return v
+	}
 }
 
 // GetVar returns a gvar.Var with the value by given <key>.
@@ -181,11 +185,11 @@ func (m *AnyAnyMap) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *
 // SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
 // It returns false if <key> exists, and <value> would be ignored.
 func (m *AnyAnyMap) SetIfNotExist(key interface{}, value interface{}) bool {
-    if !m.Contains(key) {
-        m.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
@@ -213,13 +217,13 @@ func (m *AnyAnyMap) SetIfNotExistFuncLock(key interface{}, f func() interface{})
 
 // Remove deletes value from map by given <key>, and return this deleted value.
 func (m *AnyAnyMap) Remove(key interface{}) interface{} {
-    m.mu.Lock()
-    val, exists := m.data[key]
-    if exists {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
-    return val
+	m.mu.Lock()
+	val, exists := m.data[key]
+	if exists {
+		delete(m.data, key)
+	}
+	m.mu.Unlock()
+	return val
 }
 
 // Removes batch deletes values of the map by keys.
@@ -233,98 +237,103 @@ func (m *AnyAnyMap) Removes(keys []interface{}) {
 
 // Keys returns all keys of the map as a slice.
 func (m *AnyAnyMap) Keys() []interface{} {
-    m.mu.RLock()
-    keys  := make([]interface{}, len(m.data))
-    index := 0
-    for key := range m.data {
-        keys[index] = key
-        index++
-    }
-    m.mu.RUnlock()
-    return keys
+	m.mu.RLock()
+	keys := make([]interface{}, 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 *AnyAnyMap) Values() []interface{} {
-    m.mu.RLock()
-    values := make([]interface{}, len(m.data))
-	index  := 0
-    for _, value := range m.data {
-        values[index] = value
-        index++
-    }
-    m.mu.RUnlock()
-    return values
+	m.mu.RLock()
+	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 *AnyAnyMap) Contains(key interface{}) bool {
-    m.mu.RLock()
-    _, exists := m.data[key]
-    m.mu.RUnlock()
-    return exists
+	m.mu.RLock()
+	_, exists := m.data[key]
+	m.mu.RUnlock()
+	return exists
 }
 
 // Size returns the size of the map.
 func (m *AnyAnyMap) Size() int {
-    m.mu.RLock()
-    length := len(m.data)
-    m.mu.RUnlock()
-    return length
+	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.mu.RLock()
-    empty := len(m.data) == 0
-    m.mu.RUnlock()
-    return empty
+	m.mu.RLock()
+	empty := len(m.data) == 0
+	m.mu.RUnlock()
+	return empty
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *AnyAnyMap) Clear() {
-    m.mu.Lock()
-    m.data = make(map[interface{}]interface{})
-    m.mu.Unlock()
+	m.mu.Lock()
+	m.data = make(map[interface{}]interface{})
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function <f> within RWMutex.Lock.
 func (m *AnyAnyMap) LockFunc(f func(m map[interface{}]interface{})) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    f(m.data)
+	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[interface{}]interface{})) {
-    m.mu.RLock()
-    defer m.mu.RUnlock()
-    f(m.data)
+	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[interface{}]interface{}, len(m.data))
-    for k, v := range m.data {
-        n[v] = k
-    }
-    m.data = n
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	n := make(map[interface{}]interface{}, len(m.data))
+	for k, v := range m.data {
+		n[v] = k
+	}
+	m.data = n
 }
 
 // Merge merges two hash maps.
 // The <other> map will be merged into the map <m>.
 func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if other != m {
-	    other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
-    for k, v := range other.data {
-        m.data[k] = v
-    }
-}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *AnyAnyMap) MarshalJSON() ([]byte, error) {
+	return json.Marshal(gconv.Map(m.Map()))
+}

g/container/gmap/gmap_hash_int_any_map.go

@@ -8,9 +8,11 @@
 package gmap
 
 import (
+	"encoding/json"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
 type IntAnyMap struct {
@@ -21,38 +23,38 @@ type IntAnyMap struct {
 // NewIntAnyMap returns an empty IntAnyMap object.
 // The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
-func NewIntAnyMap(unsafe...bool) *IntAnyMap {
+func NewIntAnyMap(unsafe ...bool) *IntAnyMap {
 	return &IntAnyMap{
-        mu   : rwmutex.New(unsafe...),
-		data : make(map[int]interface{}),
-    }
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[int]interface{}),
+	}
 }
 
 // NewIntAnyMapFrom 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]interface{}, unsafe...bool) *IntAnyMap {
-    return &IntAnyMap{
-        mu   : rwmutex.New(unsafe...),
-	    data : data,
-    }
+func NewIntAnyMapFrom(data map[int]interface{}, unsafe ...bool) *IntAnyMap {
+	return &IntAnyMap{
+		mu:   rwmutex.New(unsafe...),
+		data: data,
+	}
 }
 
 // Iterator iterates the hash map 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 interface{}) bool) {
-    m.mu.RLock()
-    defer m.mu.RUnlock()
-    for k, v := range m.data {
-        if !f(k, v) {
-            break
-        }
-    }
+func (m *IntAnyMap) Iterator(f func(k int, v interface{}) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	for k, v := range m.data {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
 func (m *IntAnyMap) Clone() *IntAnyMap {
-    return NewIntAnyMapFrom(m.Map(), !m.mu.IsSafe())
+	return NewIntAnyMapFrom(m.Map(), !m.mu.IsSafe())
 }
 
 // Map returns a copy of the data of the hash map.
@@ -62,7 +64,7 @@ func (m *IntAnyMap) Map() map[int]interface{} {
 	for k, v := range m.data {
 		data[k] = v
 	}
-    m.mu.RUnlock()
+	m.mu.RUnlock()
 	return data
 }
 
@@ -92,14 +94,13 @@ func (m *IntAnyMap) Search(key int) (value interface{}, found bool) {
 }
 
 // Get returns the value by given <key>.
-func (m *IntAnyMap) Get(key int) (interface{}) {
+func (m *IntAnyMap) Get(key int) interface{} {
 	m.mu.RLock()
 	val, _ := m.data[key]
 	m.mu.RUnlock()
 	return val
 }
 
-
 // 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.
@@ -110,38 +111,38 @@ func (m *IntAnyMap) Get(key int) (interface{}) {
 //
 // It returns value with given <key>.
 func (m *IntAnyMap) doSetWithLockCheck(key int, value interface{}) interface{} {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    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
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	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 set value with given <value> if not exist and returns this 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
-    }
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with return value of callback function <f> if not exist and returns this value.
 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
-    }
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -151,10 +152,10 @@ func (m *IntAnyMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
 // with mutex.Lock of the hash map.
 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
-    }
+		return m.doSetWithLockCheck(key, f)
+	} else {
+		return v
+	}
 }
 
 // GetVar returns a gvar.Var with the value by given <key>.
@@ -184,11 +185,11 @@ func (m *IntAnyMap) GetVarOrSetFuncLock(key int, f func() interface{}) *gvar.Var
 // SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
 // It returns false if <key> exists, and <value> would be ignored.
 func (m *IntAnyMap) SetIfNotExist(key int, value interface{}) bool {
-    if !m.Contains(key) {
-        m.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
@@ -214,121 +215,127 @@ func (m *IntAnyMap) SetIfNotExistFuncLock(key int, f func() interface{}) bool {
 	return false
 }
 
-
 // Removes batch deletes values of the map by keys.
 func (m *IntAnyMap) Removes(keys []int) {
-    m.mu.Lock()
-    for _, key := range keys {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	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) interface{} {
-    m.mu.Lock()
-    val, exists := m.data[key]
-    if exists {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
-    return val
+	m.mu.Lock()
+	val, exists := m.data[key]
+	if exists {
+		delete(m.data, key)
+	}
+	m.mu.Unlock()
+	return val
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntAnyMap) Keys() []int {
-    m.mu.RLock()
-    keys  := make([]int, len(m.data))
-    index := 0
-    for key := range m.data {
-        keys[index] = key
-        index++
-    }
-    m.mu.RUnlock()
-    return keys
+	m.mu.RLock()
+	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() []interface{} {
-    m.mu.RLock()
-    values := make([]interface{}, len(m.data))
-    index  := 0
-    for _, value := range m.data {
-        values[index] = value
-        index++
-    }
-    m.mu.RUnlock()
-    return values
+	m.mu.RLock()
+	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.mu.RLock()
-    _, exists := m.data[key]
-    m.mu.RUnlock()
-    return exists
+	m.mu.RLock()
+	_, exists := m.data[key]
+	m.mu.RUnlock()
+	return exists
 }
 
 // Size returns the size of the map.
 func (m *IntAnyMap) Size() int {
-    m.mu.RLock()
-    length := len(m.data)
-    m.mu.RUnlock()
-    return length
+	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.mu.RLock()
-    empty := len(m.data) == 0
-    m.mu.RUnlock()
-    return empty
+	m.mu.RLock()
+	empty := len(m.data) == 0
+	m.mu.RUnlock()
+	return empty
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntAnyMap) Clear() {
-    m.mu.Lock()
-    m.data = make(map[int]interface{})
-    m.mu.Unlock()
+	m.mu.Lock()
+	m.data = make(map[int]interface{})
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function <f> within RWMutex.Lock.
 func (m *IntAnyMap) LockFunc(f func(m map[int]interface{})) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    f(m.data)
+	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]interface{})) {
-    m.mu.RLock()
-    defer m.mu.RUnlock()
-    f(m.data)
+	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]interface{}, len(m.data))
-    for k, v := range m.data {
-        n[gconv.Int(v)] = k
-    }
-    m.data = n
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	n := make(map[int]interface{}, len(m.data))
+	for k, v := range m.data {
+		n[gconv.Int(v)] = k
+	}
+	m.data = n
 }
 
 // Merge merges two hash maps.
 // The <other> map will be merged into the map <m>.
 func (m *IntAnyMap) Merge(other *IntAnyMap) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if other != m {
-	    other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
-    for k, v := range other.data {
-        m.data[k] = v
-    }
-}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *IntAnyMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
+}

g/container/gmap/gmap_hash_int_int_map.go

@@ -7,7 +7,9 @@
 package gmap
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"encoding/json"
+
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type IntIntMap struct {
@@ -18,38 +20,38 @@ type IntIntMap struct {
 // NewIntIntMap returns an empty IntIntMap object.
 // The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
-func NewIntIntMap(unsafe...bool) *IntIntMap {
+func NewIntIntMap(unsafe ...bool) *IntIntMap {
 	return &IntIntMap{
-        mu   : rwmutex.New(unsafe...),
-		data : make(map[int]int),
-    }
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[int]int),
+	}
 }
 
 // NewIntIntMapFrom 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 NewIntIntMapFrom(data map[int]int, unsafe...bool) *IntIntMap {
-    return &IntIntMap{
-        mu   : rwmutex.New(unsafe...),
-	    data : data,
-    }
+func NewIntIntMapFrom(data map[int]int, unsafe ...bool) *IntIntMap {
+	return &IntIntMap{
+		mu:   rwmutex.New(unsafe...),
+		data: data,
+	}
 }
 
 // Iterator iterates the hash map 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.mu.RLock()
-    defer m.mu.RUnlock()
-    for k, v := range m.data {
-        if !f(k, v) {
-            break
-        }
-    }
+func (m *IntIntMap) Iterator(f func(k int, v int) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	for k, v := range m.data {
+		if !f(k, v) {
+			break
+		}
+	}
 }
 
 // Clone returns a new hash map with copy of current map data.
 func (m *IntIntMap) Clone() *IntIntMap {
-    return NewIntIntMapFrom(m.Map(), !m.mu.IsSafe())
+	return NewIntIntMapFrom(m.Map(), !m.mu.IsSafe())
 }
 
 // Map returns a copy of the data of the hash map.
@@ -59,7 +61,7 @@ func (m *IntIntMap) Map() map[int]int {
 	for k, v := range m.data {
 		data[k] = v
 	}
-    m.mu.RUnlock()
+	m.mu.RUnlock()
 	return data
 }
 
@@ -89,7 +91,7 @@ func (m *IntIntMap) Search(key int) (value int, found bool) {
 }
 
 // Get returns the value by given <key>.
-func (m *IntIntMap) Get(key int) (int) {
+func (m *IntIntMap) Get(key int) int {
 	m.mu.RLock()
 	val, _ := m.data[key]
 	m.mu.RUnlock()
@@ -102,34 +104,34 @@ func (m *IntIntMap) Get(key int) (int) {
 //
 // It returns value with given <key>.
 func (m *IntIntMap) doSetWithLockCheck(key int, value int) int {
-    m.mu.Lock()
-    if v, ok := m.data[key]; ok {
-        m.mu.Unlock()
-        return v
-    }
-    m.data[key] = value
-    m.mu.Unlock()
-    return value
+	m.mu.Lock()
+	if v, ok := m.data[key]; ok {
+		m.mu.Unlock()
+		return v
+	}
+	m.data[key] = value
+	m.mu.Unlock()
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or set value with given <value> if not exist and returns this value.
 func (m *IntIntMap) GetOrSet(key int, value int) int {
 	if v, ok := m.Search(key); !ok {
-        return m.doSetWithLockCheck(key, value)
-    } else {
-        return v
-    }
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
 // or sets value with return value of callback function <f> if not exist and returns this value.
 func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
 	if v, ok := m.Search(key); !ok {
-        return m.doSetWithLockCheck(key, f())
-    } else {
-        return v
-    }
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -139,27 +141,27 @@ func (m *IntIntMap) GetOrSetFunc(key int, f func() int) int {
 // with mutex.Lock of the hash map.
 func (m *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
 	if v, ok := m.Search(key); !ok {
-        m.mu.Lock()
-        defer m.mu.Unlock()
-        if v, ok = m.data[key]; ok {
-            return v
-        }
-        v = f()
-        m.data[key] = v
-        return v
-    } else {
-        return v
-    }
+		m.mu.Lock()
+		defer m.mu.Unlock()
+		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, then return true.
 // It returns false if <key> exists, and <value> would be ignored.
 func (m *IntIntMap) SetIfNotExist(key int, value int) bool {
-    if !m.Contains(key) {
-        m.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
@@ -191,118 +193,125 @@ func (m *IntIntMap) SetIfNotExistFuncLock(key int, f func() int) bool {
 
 // Removes batch deletes values of the map by keys.
 func (m *IntIntMap) Removes(keys []int) {
-    m.mu.Lock()
-    for _, key := range keys {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	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) int {
-    m.mu.Lock()
-    val, exists := m.data[key]
-    if exists {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
-    return val
+	m.mu.Lock()
+	val, exists := m.data[key]
+	if exists {
+		delete(m.data, key)
+	}
+	m.mu.Unlock()
+	return val
 }
 
 // Keys returns all keys of the map as a slice.
 func (m *IntIntMap) Keys() []int {
-    m.mu.RLock()
-    keys  := make([]int, len(m.data))
-    index := 0
-    for key := range m.data {
-        keys[index] = key
-        index++
-    }
-    m.mu.RUnlock()
-    return keys
+	m.mu.RLock()
+	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.mu.RLock()
-    values := make([]int, len(m.data))
-	index  := 0
-    for _, value := range m.data {
-        values[index] = value
-        index++
-    }
-    m.mu.RUnlock()
-    return values
+	m.mu.RLock()
+	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.mu.RLock()
-    _, exists := m.data[key]
-    m.mu.RUnlock()
-    return exists
+	m.mu.RLock()
+	_, exists := m.data[key]
+	m.mu.RUnlock()
+	return exists
 }
 
 // Size returns the size of the map.
 func (m *IntIntMap) Size() int {
-    m.mu.RLock()
-    length := len(m.data)
-    m.mu.RUnlock()
-    return length
+	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.mu.RLock()
-    empty := len(m.data) == 0
-    m.mu.RUnlock()
-    return empty
+	m.mu.RLock()
+	empty := len(m.data) == 0
+	m.mu.RUnlock()
+	return empty
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *IntIntMap) Clear() {
-    m.mu.Lock()
-    m.data = make(map[int]int)
-    m.mu.Unlock()
+	m.mu.Lock()
+	m.data = make(map[int]int)
+	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.mu.Lock()
-    defer m.mu.Unlock()
-    f(m.data)
+	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.mu.RLock()
-    defer m.mu.RUnlock()
-    f(m.data)
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	f(m.data)
 }
 
 // Flip exchanges key-value of the map to value-key.
 func (m *IntIntMap) Flip() {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    n := make(map[int]int, len(m.data))
-    for k, v := range m.data {
-        n[v] = k
-    }
-    m.data = n
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	n := make(map[int]int, len(m.data))
+	for k, v := range m.data {
+		n[v] = k
+	}
+	m.data = n
 }
 
 // Merge merges two hash maps.
 // The <other> map will be merged into the map <m>.
 func (m *IntIntMap) Merge(other *IntIntMap) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if other != m {
-	    other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
-    for k, v := range other.data {
-        m.data[k] = v
-    }
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.data {
+		m.data[k] = v
+	}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *IntIntMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
 }

g/container/gmap/gmap_hash_int_str_map.go

@@ -7,6 +7,8 @@
 package gmap
 
 import (
+	"encoding/json"
+
 	"github.com/gogf/gf/g/internal/rwmutex"
 	"github.com/gogf/gf/g/util/gconv"
 )
@@ -21,8 +23,8 @@ type IntStrMap struct {
 // which is false in default, means concurrent-safe.
 func NewIntStrMap(unsafe ...bool) *IntStrMap {
 	return &IntStrMap{
-		mu   : rwmutex.New(unsafe...),
-		data :  make(map[int]string),
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[int]string),
 	}
 }
 
@@ -31,8 +33,8 @@ func NewIntStrMap(unsafe ...bool) *IntStrMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewIntStrMapFrom(data map[int]string, unsafe ...bool) *IntStrMap {
 	return &IntStrMap{
-		mu   : rwmutex.New(unsafe...),
-		data : data,
+		mu:   rwmutex.New(unsafe...),
+		data: data,
 	}
 }
 
@@ -213,7 +215,7 @@ func (m *IntStrMap) Remove(key int) string {
 // Keys returns all keys of the map as a slice.
 func (m *IntStrMap) Keys() []int {
 	m.mu.RLock()
-	keys  := make([]int, len(m.data))
+	keys := make([]int, len(m.data))
 	index := 0
 	for key := range m.data {
 		keys[index] = key
@@ -227,7 +229,7 @@ func (m *IntStrMap) Keys() []int {
 func (m *IntStrMap) Values() []string {
 	m.mu.RLock()
 	values := make([]string, len(m.data))
-	index  := 0
+	index := 0
 	for _, value := range m.data {
 		values[index] = value
 		index++
@@ -307,3 +309,10 @@ func (m *IntStrMap) Merge(other *IntStrMap) {
 		m.data[k] = v
 	}
 }
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *IntStrMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
+}

g/container/gmap/gmap_hash_str_any_map.go

@@ -8,6 +8,8 @@
 package gmap
 
 import (
+	"encoding/json"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
 	"github.com/gogf/gf/g/util/gconv"
@@ -23,8 +25,8 @@ type StrAnyMap struct {
 // which is false in default, means concurrent-safe.
 func NewStrAnyMap(unsafe ...bool) *StrAnyMap {
 	return &StrAnyMap{
-		mu   : rwmutex.New(unsafe...),
-		data : make(map[string]interface{}),
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[string]interface{}),
 	}
 }
 
@@ -33,8 +35,8 @@ func NewStrAnyMap(unsafe ...bool) *StrAnyMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewStrAnyMapFrom(data map[string]interface{}, unsafe ...bool) *StrAnyMap {
 	return &StrAnyMap{
-		mu   : rwmutex.New(unsafe...),
-		data : data,
+		mu:   rwmutex.New(unsafe...),
+		data: data,
 	}
 }
 
@@ -238,7 +240,7 @@ func (m *StrAnyMap) Remove(key string) interface{} {
 // Keys returns all keys of the map as a slice.
 func (m *StrAnyMap) Keys() []string {
 	m.mu.RLock()
-	keys  := make([]string, len(m.data))
+	keys := make([]string, len(m.data))
 	index := 0
 	for key := range m.data {
 		keys[index] = key
@@ -252,7 +254,7 @@ func (m *StrAnyMap) Keys() []string {
 func (m *StrAnyMap) Values() []interface{} {
 	m.mu.RLock()
 	values := make([]interface{}, len(m.data))
-	index  := 0
+	index := 0
 	for _, value := range m.data {
 		values[index] = value
 		index++
@@ -332,3 +334,10 @@ func (m *StrAnyMap) Merge(other *StrAnyMap) {
 		m.data[k] = v
 	}
 }
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *StrAnyMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
+}

g/container/gmap/gmap_hash_str_int_map.go

@@ -8,6 +8,8 @@
 package gmap
 
 import (
+	"encoding/json"
+
 	"github.com/gogf/gf/g/internal/rwmutex"
 	"github.com/gogf/gf/g/util/gconv"
 )
@@ -22,8 +24,8 @@ type StrIntMap struct {
 // which is false in default, means concurrent-safe.
 func NewStrIntMap(unsafe ...bool) *StrIntMap {
 	return &StrIntMap{
-		mu   : rwmutex.New(unsafe...),
-		data : make(map[string]int),
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[string]int),
 	}
 }
 
@@ -32,8 +34,8 @@ func NewStrIntMap(unsafe ...bool) *StrIntMap {
 // there might be some concurrent-safe issues when changing the map outside.
 func NewStrIntMapFrom(data map[string]int, unsafe ...bool) *StrIntMap {
 	return &StrIntMap{
-		mu   : rwmutex.New(unsafe...),
-		data : data,
+		mu:   rwmutex.New(unsafe...),
+		data: data,
 	}
 }
 
@@ -216,7 +218,7 @@ func (m *StrIntMap) Remove(key string) int {
 // Keys returns all keys of the map as a slice.
 func (m *StrIntMap) Keys() []string {
 	m.mu.RLock()
-	keys  := make([]string, len(m.data))
+	keys := make([]string, len(m.data))
 	index := 0
 	for key := range m.data {
 		keys[index] = key
@@ -230,7 +232,7 @@ func (m *StrIntMap) Keys() []string {
 func (m *StrIntMap) Values() []int {
 	m.mu.RLock()
 	values := make([]int, len(m.data))
-	index  := 0
+	index := 0
 	for _, value := range m.data {
 		values[index] = value
 		index++
@@ -310,3 +312,10 @@ func (m *StrIntMap) Merge(other *StrIntMap) {
 		m.data[k] = v
 	}
 }
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *StrIntMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
+}

g/container/gmap/gmap_hash_str_str_map.go

@@ -8,7 +8,9 @@
 package gmap
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"encoding/json"
+
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type StrStrMap struct {
@@ -19,26 +21,26 @@ type StrStrMap struct {
 // NewStrStrMap returns an empty StrStrMap object.
 // The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
-func NewStrStrMap(unsafe...bool) *StrStrMap {
+func NewStrStrMap(unsafe ...bool) *StrStrMap {
 	return &StrStrMap{
-		data  : make(map[string]string),
-        mu : rwmutex.New(unsafe...),
+		data: make(map[string]string),
+		mu:   rwmutex.New(unsafe...),
 	}
 }
 
 // NewStrStrMapFrom 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 NewStrStrMapFrom(data map[string]string, unsafe...bool) *StrStrMap {
-    return &StrStrMap{
-        mu   : rwmutex.New(unsafe...),
-	    data : data,
-    }
+func NewStrStrMapFrom(data map[string]string, unsafe ...bool) *StrStrMap {
+	return &StrStrMap{
+		mu:   rwmutex.New(unsafe...),
+		data: data,
+	}
 }
 
 // Iterator iterates the hash map with custom callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (m *StrStrMap) Iterator(f func (k string, v string) bool) {
+func (m *StrStrMap) Iterator(f func(k string, v string) bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	for k, v := range m.data {
@@ -50,18 +52,18 @@ func (m *StrStrMap) Iterator(f func (k string, v string) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *StrStrMap) Clone() *StrStrMap {
-    return NewStrStrMapFrom(m.Map(), !m.mu.IsSafe())
+	return NewStrStrMapFrom(m.Map(), !m.mu.IsSafe())
 }
 
 // Map returns a copy of the data of the hash map.
 func (m *StrStrMap) Map() map[string]string {
-    m.mu.RLock()
+	m.mu.RLock()
 	data := make(map[string]string, len(m.data))
-    for k, v := range m.data {
-	    data[k] = v
-    }
-    m.mu.RUnlock()
-    return data
+	for k, v := range m.data {
+		data[k] = v
+	}
+	m.mu.RUnlock()
+	return data
 }
 
 // Set sets key-value to the hash map.
@@ -73,11 +75,11 @@ func (m *StrStrMap) Set(key string, val string) {
 
 // Sets batch sets key-values to the hash map.
 func (m *StrStrMap) Sets(data map[string]string) {
-    m.mu.Lock()
-    for k, v := range data {
-        m.data[k] = v
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	for k, v := range data {
+		m.data[k] = v
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given <key>.
@@ -194,11 +196,11 @@ func (m *StrStrMap) SetIfNotExistFuncLock(key string, f func() string) bool {
 
 // Removes batch deletes values of the map by keys.
 func (m *StrStrMap) Removes(keys []string) {
-    m.mu.Lock()
-    for _, key := range keys {
-        delete(m.data, key)
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	for _, key := range keys {
+		delete(m.data, key)
+	}
+	m.mu.Unlock()
 }
 
 // Remove deletes value from map by given <key>, and return this deleted value.
@@ -215,13 +217,13 @@ func (m *StrStrMap) Remove(key string) string {
 // Keys returns all keys of the map as a slice.
 func (m *StrStrMap) Keys() []string {
 	m.mu.RLock()
-	keys  := make([]string, len(m.data))
+	keys := make([]string, len(m.data))
 	index := 0
 	for key := range m.data {
 		keys[index] = key
 		index++
 	}
-    m.mu.RUnlock()
+	m.mu.RUnlock()
 	return keys
 }
 
@@ -229,7 +231,7 @@ func (m *StrStrMap) Keys() []string {
 func (m *StrStrMap) Values() []string {
 	m.mu.RLock()
 	values := make([]string, len(m.data))
-	index  := 0
+	index := 0
 	for _, value := range m.data {
 		values[index] = value
 		index++
@@ -266,9 +268,9 @@ func (m *StrStrMap) IsEmpty() bool {
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
 func (m *StrStrMap) Clear() {
-    m.mu.Lock()
-    m.data = make(map[string]string)
-    m.mu.Unlock()
+	m.mu.Lock()
+	m.data = make(map[string]string)
+	m.mu.Unlock()
 }
 
 // LockFunc locks writing with given callback function <f> within RWMutex.Lock.
@@ -309,3 +311,10 @@ func (m *StrStrMap) Merge(other *StrStrMap) {
 		m.data[k] = v
 	}
 }
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *StrStrMap) MarshalJSON() ([]byte, error) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	return json.Marshal(m.data)
+}

g/container/gmap/gmap_link_map.go

@@ -7,20 +7,24 @@
 package gmap
 
 import (
+	"encoding/json"
+
+	"github.com/gogf/gf/g/util/gconv"
+
 	"github.com/gogf/gf/g/container/glist"
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type ListMap struct {
-    mu   *rwmutex.RWMutex
-    data map[interface{}]*glist.Element
-    list *glist.List
+	mu   *rwmutex.RWMutex
+	data map[interface{}]*glist.Element
+	list *glist.List
 }
 
 type gListMapNode struct {
-	key     interface{}
-	value   interface{}
+	key   interface{}
+	value interface{}
 }
 
 // NewListMap returns an empty link map.
@@ -29,41 +33,41 @@ type gListMapNode struct {
 // which is false in default, means concurrent-safe.
 func NewListMap(unsafe ...bool) *ListMap {
 	return &ListMap{
-		mu   : rwmutex.New(unsafe...),
-		data : make(map[interface{}]*glist.Element),
-		list : glist.New(true),
+		mu:   rwmutex.New(unsafe...),
+		data: make(map[interface{}]*glist.Element),
+		list: glist.New(true),
 	}
 }
 
 // NewListMapFrom returns a link 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 NewListMapFrom(data map[interface{}]interface{}, unsafe...bool) *ListMap {
-    m := NewListMap(unsafe...)
-    m.Sets(data)
-    return m
+func NewListMapFrom(data map[interface{}]interface{}, unsafe ...bool) *ListMap {
+	m := NewListMap(unsafe...)
+	m.Sets(data)
+	return m
 }
 
 // Iterator is alias of IteratorAsc.
-func (m *ListMap) Iterator(f func (key, value interface{}) bool) {
+func (m *ListMap) Iterator(f func(key, value interface{}) bool) {
 	m.IteratorAsc(f)
 }
 
 // IteratorAsc iterates the map in ascending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (m *ListMap) IteratorAsc(f func (key interface{}, value interface{}) bool) {
-    m.mu.RLock()
-    defer m.mu.RUnlock()
-    node := (*gListMapNode)(nil)
-    m.list.IteratorAsc(func(e *glist.Element) bool {
-    	node = e.Value.(*gListMapNode)
-	    return f(node.key, node.value)
-    })
+func (m *ListMap) IteratorAsc(f func(key interface{}, value interface{}) bool) {
+	m.mu.RLock()
+	defer m.mu.RUnlock()
+	node := (*gListMapNode)(nil)
+	m.list.IteratorAsc(func(e *glist.Element) bool {
+		node = e.Value.(*gListMapNode)
+		return f(node.key, node.value)
+	})
 }
 
 // IteratorDesc iterates the map in descending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (m *ListMap) IteratorDesc(f func (key interface{}, value interface{}) bool) {
+func (m *ListMap) IteratorDesc(f func(key interface{}, value interface{}) bool) {
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	node := (*gListMapNode)(nil)
@@ -75,7 +79,7 @@ func (m *ListMap) IteratorDesc(f func (key interface{}, value interface{}) bool)
 
 // Clone returns a new link map with copy of current map data.
 func (m *ListMap) Clone(unsafe ...bool) *ListMap {
-   return NewListMapFrom(m.Map(), unsafe ...)
+	return NewListMapFrom(m.Map(), unsafe...)
 }
 
 // Clear deletes all data of the map, it will remake a new underlying data map.
@@ -88,7 +92,7 @@ func (m *ListMap) Clear() {
 
 // Map returns a copy of the data of the map.
 func (m *ListMap) Map() map[interface{}]interface{} {
-    m.mu.RLock()
+	m.mu.RLock()
 	node := (*gListMapNode)(nil)
 	data := make(map[interface{}]interface{}, len(m.data))
 	m.list.IteratorAsc(func(e *glist.Element) bool {
@@ -96,32 +100,32 @@ func (m *ListMap) Map() map[interface{}]interface{} {
 		data[node.key] = node.value
 		return true
 	})
-    m.mu.RUnlock()
-    return data
+	m.mu.RUnlock()
+	return data
 }
 
 // Set sets key-value to the map.
 func (m *ListMap) Set(key interface{}, value interface{}) {
-    m.mu.Lock()
-    if e, ok := m.data[key]; !ok {
-	    m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-    } else {
-    	e.Value     = &gListMapNode{key, value}
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	if e, ok := m.data[key]; !ok {
+		m.data[key] = m.list.PushBack(&gListMapNode{key, value})
+	} else {
+		e.Value = &gListMapNode{key, value}
+	}
+	m.mu.Unlock()
 }
 
 // Sets batch sets key-values to the map.
 func (m *ListMap) Sets(data map[interface{}]interface{}) {
-    m.mu.Lock()
-    for key, value := range data {
-	    if e, ok := m.data[key]; !ok {
-		    m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-	    } else {
-		    e.Value     = &gListMapNode{key, value}
-	    }
-    }
-    m.mu.Unlock()
+	m.mu.Lock()
+	for key, value := range data {
+		if e, ok := m.data[key]; !ok {
+			m.data[key] = m.list.PushBack(&gListMapNode{key, value})
+		} else {
+			e.Value = &gListMapNode{key, value}
+		}
+	}
+	m.mu.Unlock()
 }
 
 // Search searches the map with given <key>.
@@ -138,12 +142,12 @@ func (m *ListMap) Search(key interface{}) (value interface{}, found bool) {
 
 // Get returns the value by given <key>.
 func (m *ListMap) Get(key interface{}) (value interface{}) {
-    m.mu.RLock()
-    if e, ok := m.data[key]; ok {
-    	value = e.Value.(*gListMapNode).value
-    }
-    m.mu.RUnlock()
-    return
+	m.mu.RLock()
+	if e, ok := m.data[key]; ok {
+		value = e.Value.(*gListMapNode).value
+	}
+	m.mu.RUnlock()
+	return
 }
 
 // doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
@@ -156,26 +160,26 @@ func (m *ListMap) Get(key interface{}) (value interface{}) {
 //
 // It returns value with given <key>.
 func (m *ListMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if e, ok := m.data[key]; ok {
-        return e.Value.(*gListMapNode).value
-    }
-    if f, ok := value.(func() interface {}); ok {
-        value = f()
-    }
-    m.data[key] = m.list.PushBack(&gListMapNode{key, value})
-    return value
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if e, ok := m.data[key]; ok {
+		return e.Value.(*gListMapNode).value
+	}
+	if f, ok := value.(func() interface{}); ok {
+		value = f()
+	}
+	m.data[key] = m.list.PushBack(&gListMapNode{key, value})
+	return value
 }
 
 // GetOrSet returns the value by key,
 // or set value with given <value> if not exist and returns this value.
 func (m *ListMap) GetOrSet(key interface{}, value interface{}) interface{} {
 	if v, ok := m.Search(key); !ok {
-        return m.doSetWithLockCheck(key, value)
-    } else {
-        return v
-    }
+		return m.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFunc returns the value by key,
@@ -183,10 +187,10 @@ func (m *ListMap) GetOrSet(key interface{}, value interface{}) interface{} {
 // and returns this value.
 func (m *ListMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
 	if v, ok := m.Search(key); !ok {
-        return m.doSetWithLockCheck(key, f())
-    } else {
-        return v
-    }
+		return m.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
 // GetOrSetFuncLock returns the value by key,
@@ -197,10 +201,10 @@ func (m *ListMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{
 // with mutex.Lock of the map.
 func (m *ListMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
 	if v, ok := m.Search(key); !ok {
-        return m.doSetWithLockCheck(key, f)
-    } else {
-        return v
-    }
+		return m.doSetWithLockCheck(key, f)
+	} else {
+		return v
+	}
 }
 
 // GetVar returns a gvar.Var with the value by given <key>.
@@ -230,11 +234,11 @@ func (m *ListMap) GetVarOrSetFuncLock(key interface{}, f func() interface{}) *gv
 // SetIfNotExist sets <value> to the map if the <key> does not exist, then return true.
 // It returns false if <key> exists, and <value> would be ignored.
 func (m *ListMap) SetIfNotExist(key interface{}, value interface{}) bool {
-    if !m.Contains(key) {
-        m.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+	if !m.Contains(key) {
+		m.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
 // SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
@@ -262,14 +266,14 @@ func (m *ListMap) SetIfNotExistFuncLock(key interface{}, f func() interface{}) b
 
 // Remove deletes value from map by given <key>, and return this deleted value.
 func (m *ListMap) Remove(key interface{}) (value interface{}) {
-    m.mu.Lock()
-    if e, ok := m.data[key]; ok {
-    	value = e.Value.(*gListMapNode).value
-        delete(m.data, key)
-        m.list.Remove(e)
-    }
-    m.mu.Unlock()
-    return
+	m.mu.Lock()
+	if e, ok := m.data[key]; ok {
+		value = e.Value.(*gListMapNode).value
+		delete(m.data, key)
+		m.list.Remove(e)
+	}
+	m.mu.Unlock()
+	return
 }
 
 // Removes batch deletes values of the map by keys.
@@ -286,81 +290,86 @@ func (m *ListMap) Removes(keys []interface{}) {
 
 // Keys returns all keys of the map as a slice in ascending order.
 func (m *ListMap) Keys() []interface{} {
-    m.mu.RLock()
-    keys  := make([]interface{}, m.list.Len())
-    index := 0
-    m.list.IteratorAsc(func(e *glist.Element) bool {
-	    keys[index] = e.Value.(*gListMapNode).key
-	    index++
-	    return true
-    })
-    m.mu.RUnlock()
-    return keys
+	m.mu.RLock()
+	keys := make([]interface{}, m.list.Len())
+	index := 0
+	m.list.IteratorAsc(func(e *glist.Element) bool {
+		keys[index] = e.Value.(*gListMapNode).key
+		index++
+		return true
+	})
+	m.mu.RUnlock()
+	return keys
 }
 
 // Values returns all values of the map as a slice.
 func (m *ListMap) Values() []interface{} {
-    m.mu.RLock()
-    values := make([]interface{}, m.list.Len())
-	index  := 0
+	m.mu.RLock()
+	values := make([]interface{}, m.list.Len())
+	index := 0
 	m.list.IteratorAsc(func(e *glist.Element) bool {
 		values[index] = e.Value.(*gListMapNode).value
 		index++
 		return true
 	})
-    m.mu.RUnlock()
-    return values
+	m.mu.RUnlock()
+	return values
 }
 
 // Contains checks whether a key exists.
 // It returns true if the <key> exists, or else false.
 func (m *ListMap) Contains(key interface{}) (ok bool) {
-    m.mu.RLock()
-    _, ok = m.data[key]
-    m.mu.RUnlock()
-    return
+	m.mu.RLock()
+	_, ok = m.data[key]
+	m.mu.RUnlock()
+	return
 }
 
 // Size returns the size of the map.
 func (m *ListMap) Size() (size int) {
-    m.mu.RLock()
-    size = len(m.data)
-    m.mu.RUnlock()
-    return
+	m.mu.RLock()
+	size = len(m.data)
+	m.mu.RUnlock()
+	return
 }
 
 // IsEmpty checks whether the map is empty.
 // It returns true if map is empty, or else false.
 func (m *ListMap) IsEmpty() bool {
-    return m.Size() == 0
+	return m.Size() == 0
 }
 
 // Flip exchanges key-value of the map to value-key.
 func (m *ListMap) Flip() {
-    data := m.Map()
-    m.Clear()
-    for key, value := range data {
-    	m.Set(value, key)
-    }
+	data := m.Map()
+	m.Clear()
+	for key, value := range data {
+		m.Set(value, key)
+	}
 }
 
 // Merge merges two link maps.
 // The <other> map will be merged into the map <m>.
 func (m *ListMap) Merge(other *ListMap) {
-    m.mu.Lock()
-    defer m.mu.Unlock()
-    if other != m {
-	    other.mu.RLock()
-        defer other.mu.RUnlock()
-    }
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	if other != m {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
 	node := (*gListMapNode)(nil)
-    other.list.IteratorAsc(func(e *glist.Element) bool {
-	    node = e.Value.(*gListMapNode)
-	    if e, ok := m.data[node.key]; !ok {
-		    m.data[node.key] = m.list.PushBack(&gListMapNode{node.key, node.value})
-	    } else {
-		    e.Value = &gListMapNode{node.key, node.value}
-	    }
-	    return true
-    })
-}
+	other.list.IteratorAsc(func(e *glist.Element) bool {
+		node = e.Value.(*gListMapNode)
+		if e, ok := m.data[node.key]; !ok {
+			m.data[node.key] = m.list.PushBack(&gListMapNode{node.key, node.value})
+		} else {
+			e.Value = &gListMapNode{node.key, node.value}
+		}
+		return true
+	})
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (m *ListMap) MarshalJSON() ([]byte, error) {
+	return json.Marshal(gconv.Map(m.Map()))
+}

g/container/gmap/gmap_tree_map.go

@@ -16,7 +16,7 @@ type TreeMap = gtree.RedBlackTree
 // NewTreeMap instantiates a tree map with the custom comparator.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewTreeMap(comparator func(v1, v2 interface{}) int, unsafe...bool) *TreeMap {
+func NewTreeMap(comparator func(v1, v2 interface{}) int, unsafe ...bool) *TreeMap {
 	return gtree.NewRedBlackTree(comparator, unsafe...)
 }
 
@@ -25,6 +25,6 @@ func NewTreeMap(comparator func(v1, v2 interface{}) int, unsafe...bool) *TreeMap
 // there might be some concurrent-safe issues when changing the map outside.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewTreeMapFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *TreeMap {
+func NewTreeMapFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe ...bool) *TreeMap {
 	return gtree.NewRedBlackTreeFrom(comparator, data, unsafe...)
-}
+}

g/container/gmap/gmap_z_basic_test.go

@@ -68,8 +68,8 @@ func Test_Map_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_Map_Iterator(t *testing.T){
-	expect :=map[interface{}]interface{}{1: 1, "key1": "val1"}
+func Test_Map_Iterator(t *testing.T) {
+	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
 
 	m := gmap.NewFrom(expect)
 	m.Iterator(func(k interface{}, v interface{}) bool {
@@ -91,8 +91,8 @@ func Test_Map_Iterator(t *testing.T){
 	gtest.Assert(j, 1)
 }
 
-func Test_Map_Lock(t *testing.T){
-	expect :=map[interface{}]interface{}{1: 1, "key1": "val1"}
+func Test_Map_Lock(t *testing.T) {
+	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
 
 	m := gmap.NewFrom(expect)
 	m.LockFunc(func(m map[interface{}]interface{}) {

g/container/gmap/gmap_z_bench_maps_test.go

@@ -9,9 +9,10 @@
 package gmap_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/g/container/gmap"
 	"github.com/gogf/gf/g/util/gutil"
-	"testing"
 )
 
 var hashMap = gmap.New()
@@ -19,37 +20,61 @@ var listMap = gmap.NewListMap()
 var treeMap = gmap.NewTreeMap(gutil.ComparatorInt)
 
 func Benchmark_HashMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-	    hashMap.Set(i, i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			hashMap.Set(i, i)
+			i++
+		}
+	})
 }
 
 func Benchmark_ListMap_Set(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		listMap.Set(i, i)
-	}
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			listMap.Set(i, i)
+			i++
+		}
+	})
 }
 
 func Benchmark_TreeMap_Set(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		treeMap.Set(i, i)
-	}
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			treeMap.Set(i, i)
+			i++
+		}
+	})
 }
 
 func Benchmark_HashMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-	    hashMap.Get(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			hashMap.Get(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_ListMap_Get(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		listMap.Get(i)
-	}
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			listMap.Get(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_TreeMap_Get(b *testing.B) {
-	for i := 0; i < b.N; i++ {
-		treeMap.Get(i)
-	}
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			treeMap.Get(i)
+			i++
+		}
+	})
 }

g/container/gmap/gmap_z_bench_safe_test.go

@@ -9,102 +9,162 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/g/container/gmap"
+	"strconv"
 	"testing"
-    "strconv"
+
+	"github.com/gogf/gf/g/container/gmap"
 )
 
-var ififm = gmap.New()
-var iim   = gmap.NewIntIntMap()
-var iifm  = gmap.NewIntAnyMap()
-var ism   = gmap.NewIntStrMap()
-var sim   = gmap.NewStrIntMap()
-var sifm  = gmap.NewStrAnyMap()
-var ssm   = gmap.NewStrStrMap()
+var anyAnyMap = gmap.NewAnyAnyMap()
+var intIntMap = gmap.NewIntIntMap()
+var intAnyMap = gmap.NewIntAnyMap()
+var intStrMap = gmap.NewIntStrMap()
+var strIntMap = gmap.NewStrIntMap()
+var strAnyMap = gmap.NewStrAnyMap()
+var strStrMap = gmap.NewStrStrMap()
 
 func Benchmark_IntIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iim.Set(i, i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intIntMap.Set(i, i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifm.Set(i, i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intAnyMap.Set(i, i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ism.Set(i, strconv.Itoa(i))
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intStrMap.Set(i, "123456789")
+			i++
+		}
+	})
 }
 
 func Benchmark_AnyAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififm.Set(i, i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			anyAnyMap.Set(i, i)
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sim.Set(strconv.Itoa(i), i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strIntMap.Set(strconv.Itoa(i), i)
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifm.Set(strconv.Itoa(i), i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strAnyMap.Set(strconv.Itoa(i), i)
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssm.Set(strconv.Itoa(i), strconv.Itoa(i))
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strStrMap.Set(strconv.Itoa(i), "123456789")
+			i++
+		}
+	})
 }
 
-
-
 func Benchmark_IntIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iim.Get(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intIntMap.Get(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifm.Get(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intAnyMap.Get(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ism.Get(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intStrMap.Get(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_AnyAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififm.Get(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			anyAnyMap.Get(i)
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sim.Get(strconv.Itoa(i))
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strIntMap.Get(strconv.Itoa(i))
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifm.Get(strconv.Itoa(i))
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strAnyMap.Get(strconv.Itoa(i))
+			i++
+		}
+	})
 }
 
+// Note that there's additional performance cost for string conversion.
 func Benchmark_StrStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssm.Get(strconv.Itoa(i))
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strStrMap.Get(strconv.Itoa(i))
+			i++
+		}
+	})
 }
-

g/container/gmap/gmap_z_bench_syncmap_test.go

@@ -9,48 +9,71 @@
 package gmap_test
 
 import (
-    "testing"
-    "github.com/gogf/gf/g/container/gmap"
-    "sync"
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gmap"
 )
 
+var gm = gmap.NewIntIntMap()
+var sm = sync.Map{}
 
-var m1 = gmap.NewIntIntMap()
-var m2 = sync.Map{}
-
-func BenchmarkGmapSet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Set(i, i)
-    }
+func Benchmark_GMapSet(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			gm.Set(i, i)
+			i++
+		}
+	})
 }
 
-func BenchmarkSyncmapSet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Store(i, i)
-    }
+func Benchmark_SyncMapSet(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			sm.Store(i, i)
+			i++
+		}
+	})
 }
 
-func BenchmarkGmapGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Get(i)
-    }
+func Benchmark_GMapGet(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			gm.Get(i)
+			i++
+		}
+	})
 }
 
-func BenchmarkSyncmapGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Load(i)
-    }
+func Benchmark_SyncMapGet(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			sm.Load(i)
+			i++
+		}
+	})
 }
 
-func BenchmarkGmapRemove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Remove(i)
-    }
+func Benchmark_GMapRemove(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			gm.Remove(i)
+			i++
+		}
+	})
 }
 
-func BenchmarkSyncmapRmove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Delete(i)
-    }
+func Benchmark_SyncMapRmove(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			sm.Delete(i)
+			i++
+		}
+	})
 }
-

g/container/gmap/gmap_z_bench_unsafe_test.go

@@ -9,106 +9,104 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/g/container/gmap"
+	"strconv"
 	"testing"
-    "strconv"
+
+	"github.com/gogf/gf/g/container/gmap"
 )
 
 var ififmUnsafe = gmap.New(true)
-var iimUnsafe   = gmap.NewIntIntMap(true)
-var iifmUnsafe  = gmap.NewIntAnyMap(true)
-var ismUnsafe   = gmap.NewIntStrMap(true)
-var simUnsafe   = gmap.NewStrIntMap(true)
-var sifmUnsafe  = gmap.NewStrAnyMap(true)
-var ssmUnsafe   = gmap.NewStrStrMap(true)
+var iimUnsafe = gmap.NewIntIntMap(true)
+var iifmUnsafe = gmap.NewIntAnyMap(true)
+var ismUnsafe = gmap.NewIntStrMap(true)
+var simUnsafe = gmap.NewStrIntMap(true)
+var sifmUnsafe = gmap.NewStrAnyMap(true)
+var ssmUnsafe = gmap.NewStrStrMap(true)
 
-// 写入性能测试
+// Writing benchmarks.
 
 func Benchmark_Unsafe_IntIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iimUnsafe.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		iimUnsafe.Set(i, i)
+	}
 }
 
 func Benchmark_Unsafe_IntAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifmUnsafe.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		iifmUnsafe.Set(i, i)
+	}
 }
 
 func Benchmark_Unsafe_IntStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ismUnsafe.Set(i, strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ismUnsafe.Set(i, strconv.Itoa(i))
+	}
 }
 
 func Benchmark_Unsafe_AnyAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififmUnsafe.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		ififmUnsafe.Set(i, i)
+	}
 }
 
 func Benchmark_Unsafe_StrIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        simUnsafe.Set(strconv.Itoa(i), i)
-    }
+	for i := 0; i < b.N; i++ {
+		simUnsafe.Set(strconv.Itoa(i), i)
+	}
 }
 
 func Benchmark_Unsafe_StrAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifmUnsafe.Set(strconv.Itoa(i), i)
-    }
+	for i := 0; i < b.N; i++ {
+		sifmUnsafe.Set(strconv.Itoa(i), i)
+	}
 }
 
 func Benchmark_Unsafe_StrStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssmUnsafe.Set(strconv.Itoa(i), strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ssmUnsafe.Set(strconv.Itoa(i), strconv.Itoa(i))
+	}
 }
 
-
-// 读取性能测试
-
+// Reading benchmarks.
 
 func Benchmark_Unsafe_IntIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iimUnsafe.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		iimUnsafe.Get(i)
+	}
 }
 
 func Benchmark_Unsafe_IntAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifmUnsafe.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		iifmUnsafe.Get(i)
+	}
 }
 
 func Benchmark_Unsafe_IntStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ismUnsafe.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ismUnsafe.Get(i)
+	}
 }
 
 func Benchmark_Unsafe_AnyAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififmUnsafe.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ififmUnsafe.Get(i)
+	}
 }
 
 func Benchmark_Unsafe_StrIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        simUnsafe.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		simUnsafe.Get(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_Unsafe_StrAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifmUnsafe.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		sifmUnsafe.Get(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_Unsafe_StrStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssmUnsafe.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ssmUnsafe.Get(strconv.Itoa(i))
+	}
 }
-

g/container/gmap/gmap_z_example_test.go

@@ -60,12 +60,11 @@ func Example_Normal_Basic() {
 	fmt.Println(m.Size())
 
 }
-func Example_Normal_Merge(){
+func Example_Normal_Merge() {
 	m1 := gmap.New()
 	m2 := gmap.New()
-	m1.Set("key1","val1")
-	m2.Set("key2","val2")
+	m1.Set("key1", "val1")
+	m2.Set("key2", "val2")
 	m1.Merge(m2)
 	fmt.Println(m1.Map())
 }
-

g/container/gmap/gmap_z_int_any_test.go

@@ -74,9 +74,9 @@ func Test_IntAnyMap_Batch(t *testing.T) {
 	m.Removes([]int{1, 2})
 	gtest.Assert(m.Map(), map[int]interface{}{3: 3})
 }
-func Test_IntAnyMap_Iterator(t *testing.T){
+func Test_IntAnyMap_Iterator(t *testing.T) {
 	expect := map[int]interface{}{1: 1, 2: "2"}
-	m      := gmap.NewIntAnyMapFrom(expect)
+	m := gmap.NewIntAnyMapFrom(expect)
 	m.Iterator(func(k int, v interface{}) bool {
 		gtest.Assert(expect[k], v)
 		return true
@@ -95,10 +95,9 @@ func Test_IntAnyMap_Iterator(t *testing.T){
 	gtest.Assert(i, "2")
 	gtest.Assert(j, 1)
 
-
 }
 
-func Test_IntAnyMap_Lock(t *testing.T){
+func Test_IntAnyMap_Lock(t *testing.T) {
 	expect := map[int]interface{}{1: 1, 2: "2"}
 	m := gmap.NewIntAnyMapFrom(expect)
 	m.LockFunc(func(m map[int]interface{}) {

g/container/gmap/gmap_z_int_int_test.go

@@ -75,9 +75,9 @@ func Test_IntIntMap_Batch(t *testing.T) {
 	gtest.Assert(m.Map(), map[int]int{3: 3})
 }
 
-func Test_IntIntMap_Iterator(t *testing.T){
+func Test_IntIntMap_Iterator(t *testing.T) {
 	expect := map[int]int{1: 1, 2: 2}
-	m      := gmap.NewIntIntMapFrom(expect)
+	m := gmap.NewIntIntMapFrom(expect)
 	m.Iterator(func(k int, v int) bool {
 		gtest.Assert(expect[k], v)
 		return true
@@ -97,9 +97,9 @@ func Test_IntIntMap_Iterator(t *testing.T){
 	gtest.Assert(j, 1)
 }
 
-func Test_IntIntMap_Lock(t *testing.T){
+func Test_IntIntMap_Lock(t *testing.T) {
 	expect := map[int]int{1: 1, 2: 2}
-	m      := gmap.NewIntIntMapFrom(expect)
+	m := gmap.NewIntIntMapFrom(expect)
 	m.LockFunc(func(m map[int]int) {
 		gtest.Assert(m, expect)
 	})

g/container/gmap/gmap_z_int_str_test.go

@@ -74,13 +74,13 @@ func Test_IntStrMap_Batch(t *testing.T) {
 	m := gmap.NewIntStrMap()
 
 	m.Sets(map[int]string{1: "a", 2: "b", 3: "c"})
-	gtest.Assert(m.Map(), map[int]string{1: "a", 2: "b",3: "c"})
+	gtest.Assert(m.Map(), map[int]string{1: "a", 2: "b", 3: "c"})
 	m.Removes([]int{1, 2})
 	gtest.Assert(m.Map(), map[int]interface{}{3: "c"})
 }
-func Test_IntStrMap_Iterator(t *testing.T){
+func Test_IntStrMap_Iterator(t *testing.T) {
 	expect := map[int]string{1: "a", 2: "b"}
-	m      := gmap.NewIntStrMapFrom(expect)
+	m := gmap.NewIntStrMapFrom(expect)
 	m.Iterator(func(k int, v string) bool {
 		gtest.Assert(expect[k], v)
 		return true
@@ -100,10 +100,10 @@ func Test_IntStrMap_Iterator(t *testing.T){
 	gtest.Assert(j, 1)
 }
 
-func Test_IntStrMap_Lock(t *testing.T){
+func Test_IntStrMap_Lock(t *testing.T) {
 
 	expect := map[int]string{1: "a", 2: "b", 3: "c"}
-	m      := gmap.NewIntStrMapFrom(expect)
+	m := gmap.NewIntStrMapFrom(expect)
 	m.LockFunc(func(m map[int]string) {
 		gtest.Assert(m, expect)
 	})

g/container/gmap/gmap_z_link_map_test.go

@@ -65,8 +65,8 @@ func Test_List_Map_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_List_Map_Iterator(t *testing.T){
-	expect :=map[interface{}]interface{}{1: 1, "key1": "val1"}
+func Test_List_Map_Iterator(t *testing.T) {
+	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
 
 	m := gmap.NewListMapFrom(expect)
 	m.Iterator(func(k interface{}, v interface{}) bool {
@@ -115,6 +115,6 @@ func Test_List_Map_Order(t *testing.T) {
 	m.Set("k1", "v1")
 	m.Set("k2", "v2")
 	m.Set("k3", "v3")
-	gtest.Assert(m.Keys(),   g.Slice{"k1", "k2", "k3"})
+	gtest.Assert(m.Keys(), g.Slice{"k1", "k2", "k3"})
 	gtest.Assert(m.Values(), g.Slice{"v1", "v2", "v3"})
 }

g/container/gmap/gmap_z_str_any_test.go

@@ -97,7 +97,7 @@ func Test_StrAnyMap_Iterator(t *testing.T) {
 func Test_StrAnyMap_Lock(t *testing.T) {
 	expect := map[string]interface{}{"a": true, "b": false}
 
-	m      := gmap.NewStrAnyMapFrom(expect)
+	m := gmap.NewStrAnyMapFrom(expect)
 	m.LockFunc(func(m map[string]interface{}) {
 		gtest.Assert(m, expect)
 	})

g/container/gmap/gmap_z_str_int_test.go

@@ -99,7 +99,7 @@ func Test_StrIntMap_Iterator(t *testing.T) {
 func Test_StrIntMap_Lock(t *testing.T) {
 	expect := map[string]int{"a": 1, "b": 2}
 
-	m      := gmap.NewStrIntMapFrom(expect)
+	m := gmap.NewStrIntMapFrom(expect)
 	m.LockFunc(func(m map[string]int) {
 		gtest.Assert(m, expect)
 	})

g/container/gmap/gmap_z_str_str_test.go

@@ -97,7 +97,7 @@ func Test_StrStrMap_Iterator(t *testing.T) {
 func Test_StrStrMap_Lock(t *testing.T) {
 	expect := map[string]string{"a": "a", "b": "b"}
 
-	m      := gmap.NewStrStrMapFrom(expect)
+	m := gmap.NewStrStrMapFrom(expect)
 	m.LockFunc(func(m map[string]string) {
 		gtest.Assert(m, expect)
 	})

g/container/gmap/gmap_z_tree_map_test.go

@@ -13,7 +13,6 @@ import (
 	"testing"
 )
 
-
 func Test_Tree_Map_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		m := gmap.NewTreeMap(gutil.ComparatorString)
@@ -66,7 +65,7 @@ func Test_Tree_Map_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_Tree_Map_Iterator(t *testing.T){
+func Test_Tree_Map_Iterator(t *testing.T) {
 	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
 
 	m := gmap.NewTreeMapFrom(gutil.ComparatorString, expect)
@@ -100,4 +99,4 @@ func Test_Tree_Map_Clone(t *testing.T) {
 	m_clone.Remove("key1")
 	//修改clone map,原 map 不影响
 	gtest.AssertIN("key1", m.Keys())
-}
+}

g/container/gpool/gpool.go

@@ -8,39 +8,39 @@
 package gpool
 
 import (
-    "errors"
-    "github.com/gogf/gf/g/container/glist"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
+	"errors"
+	"time"
+
+	"github.com/gogf/gf/g/container/glist"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/os/gtimer"
 )
 
 // Object-Reusable Pool.
 type Pool struct {
-    list       *glist.List                // Available/idle list.
-    closed     *gtype.Bool                // Whether the pool is closed.
-    Expire     int64                      // Max idle time(ms), after which it is recycled.
-    NewFunc    func()(interface{}, error) // Callback function to create item.
-    ExpireFunc func(interface{})          // Expired destruction function for objects.
-                                          // This function needs to be defined when the pool object
-                                          // needs to perform additional destruction operations.
-                                          // Eg: net.Conn, os.File, etc.
+	list       *glist.List                 // Available/idle list.
+	closed     *gtype.Bool                 // Whether the pool is closed.
+	Expire     int64                       // Max idle time(ms), after which it is recycled.
+	NewFunc    func() (interface{}, error) // Callback function to create item.
+	ExpireFunc func(interface{})           // Expired destruction function for objects.
+	// This function needs to be defined when the pool object
+	// needs to perform additional destruction operations.
+	// Eg: net.Conn, os.File, etc.
 }
 
 // Pool item.
 type poolItem struct {
-    expire int64               // Expire time(millisecond).
-    value  interface{}         // Value.
+	expire int64       // Expire time(millisecond).
+	value  interface{} // Value.
 }
 
 // Creation function for object.
-type NewFunc    func() (interface{}, error)
+type NewFunc func() (interface{}, error)
 
 // Destruction function for object.
 type ExpireFunc func(interface{})
 
-
 // New returns a new object pool.
 // To ensure execution efficiency, the expiration time cannot be modified once it is set.
 //
@@ -49,95 +49,96 @@ type ExpireFunc func(interface{})
 // expire < 0 : immediate expired after use;
 // expire > 0 : timeout expired;
 // Note that the expiration time unit is ** milliseconds **.
-func New(expire int, newFunc NewFunc, expireFunc...ExpireFunc) *Pool {
-    r := &Pool {
-        list    : glist.New(),
-        closed  : gtype.NewBool(),
-        Expire  : int64(expire),
-        NewFunc : newFunc,
-    }
-    if len(expireFunc) > 0 {
-        r.ExpireFunc = expireFunc[0]
-    }
-    gtimer.AddSingleton(time.Second, r.checkExpire)
-    return r
+func New(expire int, newFunc NewFunc, expireFunc ...ExpireFunc) *Pool {
+	r := &Pool{
+		list:    glist.New(),
+		closed:  gtype.NewBool(),
+		Expire:  int64(expire),
+		NewFunc: newFunc,
+	}
+	if len(expireFunc) > 0 {
+		r.ExpireFunc = expireFunc[0]
+	}
+	gtimer.AddSingleton(time.Second, r.checkExpire)
+	return r
 }
 
 // Put puts an item to pool.
 func (p *Pool) Put(value interface{}) {
-    item := &poolItem {
-        value : value,
-    }
-    if p.Expire == 0 {
-        item.expire = 0
-    } else {
-        item.expire = gtime.Millisecond() + p.Expire
-    }
-    p.list.PushBack(item)
+	item := &poolItem{
+		value: value,
+	}
+	if p.Expire == 0 {
+		item.expire = 0
+	} else {
+		item.expire = gtime.Millisecond() + p.Expire
+	}
+	p.list.PushBack(item)
 }
 
 // Clear clears pool, which means it will remove all items from pool.
 func (p *Pool) Clear() {
-    p.list.RemoveAll()
+	p.list.RemoveAll()
 }
 
 // Get picks an item from pool.
 func (p *Pool) Get() (interface{}, error) {
-    for !p.closed.Val() {
-        if r := p.list.PopFront(); r != nil {
-            f := r.(*poolItem)
-            if f.expire == 0 || f.expire > gtime.Millisecond() {
-                return f.value, nil
-            }
-        } else {
-            break
-        }
-    }
-    if p.NewFunc != nil {
-        return p.NewFunc()
-    }
-    return nil, errors.New("pool is empty")
+	for !p.closed.Val() {
+		if r := p.list.PopFront(); r != nil {
+			f := r.(*poolItem)
+			if f.expire == 0 || f.expire > gtime.Millisecond() {
+				return f.value, nil
+			}
+		} else {
+			break
+		}
+	}
+	if p.NewFunc != nil {
+		return p.NewFunc()
+	}
+	return nil, errors.New("pool is empty")
 }
 
 // Size returns the count of available items of pool.
 func (p *Pool) Size() int {
-    return p.list.Len()
+	return p.list.Len()
 }
 
 // Close closes the pool. If <p> has ExpireFunc,
 // then it automatically closes all items using this function before it's closed.
 func (p *Pool) Close() {
-    p.closed.Set(true)
+	p.closed.Set(true)
 }
 
 // checkExpire removes expired items from pool every second.
 func (p *Pool) checkExpire() {
-    if p.closed.Val() {
-    	// If p has ExpireFunc,
-    	// then it must close all items using this function.
-    	if p.ExpireFunc != nil {
-		    for {
-			    if r := p.list.PopFront(); r != nil {
-				    p.ExpireFunc(r.(*poolItem).value)
-			    } else {
-				    break
-			    }
-		    }
-	    }
-        gtimer.Exit()
-    }
-    for {
-        if r := p.list.PopFront(); r != nil {
-            item := r.(*poolItem)
-            if item.expire == 0 || item.expire > gtime.Millisecond() {
-                p.list.PushFront(item)
-                break
-            }
-            if p.ExpireFunc != nil {
-                p.ExpireFunc(item.value)
-            }
-        } else {
-            break
-        }
-    }
-}
+	if p.closed.Val() {
+		// If p has ExpireFunc,
+		// then it must close all items using this function.
+		if p.ExpireFunc != nil {
+			for {
+				if r := p.list.PopFront(); r != nil {
+					p.ExpireFunc(r.(*poolItem).value)
+				} else {
+					break
+				}
+			}
+		}
+		gtimer.Exit()
+	}
+	for {
+		// TODO Do not use Pop and Push mechanism, which is not graceful.
+		if r := p.list.PopFront(); r != nil {
+			item := r.(*poolItem)
+			if item.expire == 0 || item.expire > gtime.Millisecond() {
+				p.list.PushFront(item)
+				break
+			}
+			if p.ExpireFunc != nil {
+				p.ExpireFunc(item.value)
+			}
+		} else {
+			break
+		}
+	}
+}

g/container/gpool/gpool_bench_test.go

@@ -10,33 +10,33 @@ package gpool_test
 
 import (
 	"github.com/gogf/gf/g/container/gpool"
+	"sync"
 	"testing"
-    "sync"
 )
 
-var pool  = gpool.New(99999999, nil)
+var pool = gpool.New(99999999, nil)
 var syncp = sync.Pool{}
 
 func BenchmarkGPoolPut(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        pool.Put(i)
-    }
+	for i := 0; i < b.N; i++ {
+		pool.Put(i)
+	}
 }
 
 func BenchmarkGPoolGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        pool.Get()
-    }
+	for i := 0; i < b.N; i++ {
+		pool.Get()
+	}
 }
 
 func BenchmarkSyncPoolPut(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        syncp.Put(i)
-    }
+	for i := 0; i < b.N; i++ {
+		syncp.Put(i)
+	}
 }
 
 func BenchmarkGpoolGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        syncp.Get()
-    }
-}
+	for i := 0; i < b.N; i++ {
+		syncp.Get()
+	}
+}

g/container/gpool/gpool_z_unit_test.go

@@ -1,7 +1,14 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). 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 gpool_test
 
 import (
 	"errors"
+	"github.com/gogf/gf/g"
 	"testing"
 	"time"
 
@@ -30,7 +37,7 @@ func Test_Gpool(t *testing.T) {
 		//test won't be timeout
 		v1, err1 := p1.Get()
 		gtest.Assert(err1, nil)
-		gtest.Assert(v1, 1)
+		gtest.AssertIN(v1, g.Slice{1, 2})
 		//test clear
 		p1.Clear()
 		gtest.Assert(p1.Size(), 0)
@@ -43,13 +50,12 @@ func Test_Gpool(t *testing.T) {
 		p1.Put(4)
 		v1, err1 = p1.Get()
 		gtest.Assert(err1, nil)
-		gtest.Assert(v1, 3)
+		gtest.AssertIN(v1, g.Slice{3, 4})
 		//test close
 		p1.Close()
 		v1, err1 = p1.Get()
 		gtest.Assert(err1, nil)
 		gtest.Assert(v1, "hello")
-
 	})
 
 	gtest.Case(t, func() {

g/container/gqueue/gqueue.go

@@ -19,95 +19,112 @@
 package gqueue
 
 import (
-    "github.com/gogf/gf/g/container/glist"
-    "math"
+	"github.com/gogf/gf/g/container/glist"
+	"github.com/gogf/gf/g/container/gtype"
+	"math"
 )
 
 type Queue struct {
-    limit     int              // Limit for queue size.
-    list      *glist.List      // Underlying list structure for data maintaining.
-    events    chan struct{}    // Events for data writing.
-    closed    chan struct{}    // Events for queue closing.
-    C         chan interface{} // Underlying channel for data reading.
+	limit  int              // Limit for queue size.
+	list   *glist.List      // Underlying list structure for data maintaining.
+	closed *gtype.Bool      // Whether queue is closed.
+	events chan struct{}    // Events for data writing.
+	C      chan interface{} // Underlying channel for data reading.
 }
 
 const (
-    // Size for queue buffer.
-    gDEFAULT_QUEUE_SIZE = 10000
+	// Size for queue buffer.
+	gDEFAULT_QUEUE_SIZE = 10000
+	// Max batch size per-fetching from list.
+	gDEFAULT_MAX_BATCH_SIZE = 10
 )
 
 // New returns an empty queue object.
 // Optional parameter <limit> is used to limit the size of the queue, which is unlimited in default.
 // When <limit> is given, the queue will be static and high performance which is comparable with stdlib channel.
-func New(limit...int) *Queue {
-    q := &Queue {
-        closed : make(chan struct{}, 0),
-    }
-    if len(limit) > 0 {
-        q.limit  = limit[0]
-        q.C      = make(chan interface{}, limit[0])
-    } else {
-        q.list   = glist.New()
-        q.events = make(chan struct{}, math.MaxInt32)
-        q.C      = make(chan interface{}, gDEFAULT_QUEUE_SIZE)
-        go q.startAsyncLoop()
-    }
-    return q
+func New(limit ...int) *Queue {
+	q := &Queue{
+		closed: gtype.NewBool(),
+	}
+	if len(limit) > 0 && limit[0] > 0 {
+		q.limit = limit[0]
+		q.C = make(chan interface{}, limit[0])
+	} else {
+		q.list = glist.New()
+		q.events = make(chan struct{}, math.MaxInt32)
+		q.C = make(chan interface{}, gDEFAULT_QUEUE_SIZE)
+		go q.startAsyncLoop()
+	}
+	return q
 }
 
 // startAsyncLoop starts an asynchronous goroutine,
 // which handles the data synchronization from list <q.list> to channel <q.C>.
 func (q *Queue) startAsyncLoop() {
-    for {
-        select {
-            case <- q.closed:
-                return
-            case <- q.events:
-                for {
-                    if length := q.list.Len(); length > 0 {
-                        array := make([]interface{}, length)
-                        for i := 0; i < length; i++ {
-                            if e := q.list.Front(); e != nil {
-                                array[i] = q.list.Remove(e)
-                            } else {
-                                break
-                            }
-                        }
-                        for _, v := range array {
-                           q.C <- v
-                        }
-                    } else {
-                        break
-                    }
-                }
-        }
-    }
+	defer func() {
+		if q.closed.Val() {
+			_ = recover()
+		}
+	}()
+	for !q.closed.Val() {
+		<-q.events
+		for !q.closed.Val() {
+			if length := q.list.Len(); length > 0 {
+				if length > gDEFAULT_MAX_BATCH_SIZE {
+					length = gDEFAULT_MAX_BATCH_SIZE
+				}
+				for _, v := range q.list.PopFronts(length) {
+					// When q.C is closed, it will panic here, especially q.C is being blocked for writing.
+					// If any error occurs here, it will be caught by recover and be ignored.
+					q.C <- v
+				}
+			} else {
+				break
+			}
+		}
+		// Clear q.events to remain just one event to do the next synchronization check.
+		for i := 0; i < len(q.events)-1; i++ {
+			<-q.events
+		}
+	}
+	// It should be here to close q.C if <q> is unlimited size.
+	// It's the sender's responsibility to close channel when it should be closed.
+	close(q.C)
 }
 
 // Push pushes the data <v> into the queue.
 // Note that it would panics if Push is called after the queue is closed.
 func (q *Queue) Push(v interface{}) {
-    if q.limit > 0 {
-        q.C <- v
-    } else {
-        q.list.PushBack(v)
-        q.events <- struct{}{}
-    }
+	if q.limit > 0 {
+		q.C <- v
+	} else {
+		q.list.PushBack(v)
+		if len(q.events) < gDEFAULT_QUEUE_SIZE {
+			q.events <- struct{}{}
+		}
+	}
 }
 
 // Pop pops an item from the queue in FIFO way.
 // Note that it would return nil immediately if Pop is called after the queue is closed.
 func (q *Queue) Pop() interface{} {
-    return <- q.C
+	return <-q.C
 }
 
 // Close closes the queue.
 // Notice: It would notify all goroutines return immediately,
 // which are being blocked reading using Pop method.
 func (q *Queue) Close() {
-    close(q.C)
-    close(q.events)
-    close(q.closed)
+	q.closed.Set(true)
+	if q.events != nil {
+		close(q.events)
+	}
+	if q.limit > 0 {
+		close(q.C)
+	}
+	for i := 0; i < gDEFAULT_MAX_BATCH_SIZE; i++ {
+		q.Pop()
+	}
 }
 
 // Len returns the length of the queue.
@@ -116,7 +133,7 @@ func (q *Queue) Len() (length int) {
 		length += q.list.Len()
 	}
 	length += len(q.C)
-    return
+	return
 }
 
 // Size is alias of Len.

g/container/gqueue/gqueue_bench_test.go

@@ -9,42 +9,42 @@
 package gqueue_test
 
 import (
-    "testing"
-    "github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/container/gqueue"
+	"testing"
 )
 
-var bn        = 20000000
-var length    = 1000000
-var qstatic   = gqueue.New(length)
-var qdynamic  = gqueue.New()
-var cany      = make(chan interface{}, length)
+var bn = 20000000
+var length = 1000000
+var qstatic = gqueue.New(length)
+var qdynamic = gqueue.New()
+var cany = make(chan interface{}, length)
 
 func Benchmark_Gqueue_StaticPushAndPop(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        qstatic.Push(i)
-        qstatic.Pop()
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		qstatic.Push(i)
+		qstatic.Pop()
+	}
 }
 
 func Benchmark_Gqueue_DynamicPush(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        qdynamic.Push(i)
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		qdynamic.Push(i)
+	}
 }
 
 func Benchmark_Gqueue_DynamicPop(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        qdynamic.Pop()
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		qdynamic.Pop()
+	}
 }
 
 func Benchmark_Channel_PushAndPop(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        cany <- i
-        <- cany
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		cany <- i
+		<-cany
+	}
 }

g/container/gqueue/gqueue_unit_test.go

@@ -0,0 +1,54 @@
+// Copyright 2017 gf Author(https://github.com/gogf/gf). 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 gqueue_test
+
+import (
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func TestQueue_Len(t *testing.T) {
+	max := 100
+	for n := 10; n < max; n++ {
+		q1 := gqueue.New(max)
+		for i := 0; i < max; i++ {
+			q1.Push(i)
+		}
+		gtest.Assert(q1.Len(), max)
+		gtest.Assert(q1.Size(), max)
+	}
+}
+
+func TestQueue_Basic(t *testing.T) {
+	q := gqueue.New()
+	for i := 0; i < 100; i++ {
+		q.Push(i)
+	}
+	gtest.Assert(q.Pop(), 0)
+	gtest.Assert(q.Pop(), 1)
+}
+
+func TestQueue_Pop(t *testing.T) {
+	q1 := gqueue.New()
+	q1.Push(1)
+	q1.Push(2)
+	q1.Push(3)
+	q1.Push(4)
+	i1 := q1.Pop()
+	gtest.Assert(i1, 1)
+}
+
+func TestQueue_Close(t *testing.T) {
+	q1 := gqueue.New()
+	q1.Push(1)
+	q1.Push(2)
+	gtest.Assert(q1.Len(), 2)
+	q1.Close()
+}

g/container/gring/gring.go

@@ -8,118 +8,118 @@
 package gring
 
 import (
-    "container/ring"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"container/ring"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type Ring struct {
-    mu    *rwmutex.RWMutex
-    ring  *ring.Ring       // Underlying ring.
-    len   *gtype.Int       // Length(already used size).
-    cap   *gtype.Int       // Capability(>=len).
-    dirty *gtype.Bool      // Dirty, which means the len and cap should be recalculated.
-                           // It's marked dirty when the size of ring changes.
+	mu    *rwmutex.RWMutex
+	ring  *ring.Ring  // Underlying ring.
+	len   *gtype.Int  // Length(already used size).
+	cap   *gtype.Int  // Capability(>=len).
+	dirty *gtype.Bool // Dirty, which means the len and cap should be recalculated.
+	// It's marked dirty when the size of ring changes.
 }
 
-func New(cap int, unsafe...bool) *Ring {
-    return &Ring {
-        mu    : rwmutex.New(unsafe...),
-        ring  : ring.New(cap),
-        len   : gtype.NewInt(),
-        cap   : gtype.NewInt(cap),
-        dirty : gtype.NewBool(),
-    }
+func New(cap int, unsafe ...bool) *Ring {
+	return &Ring{
+		mu:    rwmutex.New(unsafe...),
+		ring:  ring.New(cap),
+		len:   gtype.NewInt(),
+		cap:   gtype.NewInt(cap),
+		dirty: gtype.NewBool(),
+	}
 }
 
 // Val returns the item's value of current position.
 func (r *Ring) Val() interface{} {
-    r.mu.RLock()
-    v := r.ring.Value
-    r.mu.RUnlock()
-    return v
+	r.mu.RLock()
+	v := r.ring.Value
+	r.mu.RUnlock()
+	return v
 }
 
 // Len returns the size of ring.
 func (r *Ring) Len() int {
-    r.checkAndUpdateLenAndCap()
-    return r.len.Val()
+	r.checkAndUpdateLenAndCap()
+	return r.len.Val()
 }
 
 // Cap returns the capacity of ring.
 func (r *Ring) Cap() int {
-    r.checkAndUpdateLenAndCap()
-    return r.cap.Val()
+	r.checkAndUpdateLenAndCap()
+	return r.cap.Val()
 }
 
 // Checks and updates the len and cap of ring when ring is dirty.
-func (r *Ring) checkAndUpdateLenAndCap()  {
-    if !r.dirty.Val() {
-        return
-    }
-    totalLen := 0
-    emptyLen := 0
-    if r.ring != nil {
-        r.mu.RLock()
-        for p := r.ring.Next(); p != r.ring; p = p.Next() {
-            if p.Value == nil {
-                emptyLen++
-            }
-            totalLen++
-        }
-        r.mu.RUnlock()
-    }
-    r.cap.Set(totalLen)
-    r.len.Set(totalLen - emptyLen)
-    r.dirty.Set(false)
+func (r *Ring) checkAndUpdateLenAndCap() {
+	if !r.dirty.Val() {
+		return
+	}
+	totalLen := 0
+	emptyLen := 0
+	if r.ring != nil {
+		r.mu.RLock()
+		for p := r.ring.Next(); p != r.ring; p = p.Next() {
+			if p.Value == nil {
+				emptyLen++
+			}
+			totalLen++
+		}
+		r.mu.RUnlock()
+	}
+	r.cap.Set(totalLen)
+	r.len.Set(totalLen - emptyLen)
+	r.dirty.Set(false)
 }
 
 // Set sets value to the item of current position.
 func (r *Ring) Set(value interface{}) *Ring {
-    r.mu.Lock()
-    if r.ring.Value == nil {
-        r.len.Add(1)
-    }
-    r.ring.Value = value
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	if r.ring.Value == nil {
+		r.len.Add(1)
+	}
+	r.ring.Value = value
+	r.mu.Unlock()
+	return r
 }
 
 // Put sets <value> to current item of ring and moves position to next item.
 func (r *Ring) Put(value interface{}) *Ring {
-    r.mu.Lock()
-    if r.ring.Value == nil {
-        r.len.Add(1)
-    }
-    r.ring.Value = value
-    r.ring       = r.ring.Next()
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	if r.ring.Value == nil {
+		r.len.Add(1)
+	}
+	r.ring.Value = value
+	r.ring = r.ring.Next()
+	r.mu.Unlock()
+	return r
 }
 
 // Move moves n % r.Len() elements backward (n < 0) or forward (n >= 0)
 // in the ring and returns that ring element. r must not be empty.
 func (r *Ring) Move(n int) *Ring {
-    r.mu.Lock()
-    r.ring = r.ring.Move(n)
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	r.ring = r.ring.Move(n)
+	r.mu.Unlock()
+	return r
 }
 
 // Prev returns the previous ring element. r must not be empty.
 func (r *Ring) Prev() *Ring {
-    r.mu.Lock()
-    r.ring = r.ring.Prev()
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	r.ring = r.ring.Prev()
+	r.mu.Unlock()
+	return r
 }
 
 // Next returns the next ring element. r must not be empty.
 func (r *Ring) Next() *Ring {
-    r.mu.Lock()
-    r.ring = r.ring.Next()
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	r.ring = r.ring.Next()
+	r.mu.Unlock()
+	return r
 }
 
 // Link connects ring r with ring s such that r.Next()
@@ -139,14 +139,14 @@ func (r *Ring) Next() *Ring {
 // last element of s after insertion.
 //
 func (r *Ring) Link(s *Ring) *Ring {
-    r.mu.Lock()
-    s.mu.Lock()
-    r.ring.Link(s.ring)
-    s.mu.Unlock()
-    r.mu.Unlock()
-    r.dirty.Set(true)
-    s.dirty.Set(true)
-    return r
+	r.mu.Lock()
+	s.mu.Lock()
+	r.ring.Link(s.ring)
+	s.mu.Unlock()
+	r.mu.Unlock()
+	r.dirty.Set(true)
+	s.dirty.Set(true)
+	return r
 }
 
 // Unlink removes n % r.Len() elements from the ring r, starting
@@ -154,105 +154,105 @@ func (r *Ring) Link(s *Ring) *Ring {
 // The result is the removed subring. r must not be empty.
 //
 func (r *Ring) Unlink(n int) *Ring {
-    r.mu.Lock()
-    r.ring = r.ring.Unlink(n)
-    r.dirty.Set(true)
-    r.mu.Unlock()
-    return r
+	r.mu.Lock()
+	r.ring = r.ring.Unlink(n)
+	r.dirty.Set(true)
+	r.mu.Unlock()
+	return r
 }
 
 // RLockIteratorNext iterates and locks reading forward
 // with given callback function <f> within RWMutex.RLock.
 // If <f> returns true, then it continues iterating; or false to stop.
 func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
-    r.mu.RLock()
-    defer r.mu.RUnlock()
-    if !f(r.ring.Value) {
-        return
-    }
-    for p := r.ring.Next(); p != r.ring; p = p.Next() {
-        if !f(p.Value) {
-            break
-        }
-    }
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if !f(r.ring.Value) {
+		return
+	}
+	for p := r.ring.Next(); p != r.ring; p = p.Next() {
+		if !f(p.Value) {
+			break
+		}
+	}
 }
 
 // RLockIteratorPrev iterates and locks reading backward
 // with given callback function <f> within RWMutex.RLock.
 // If <f> returns true, then it continues iterating; or false to stop.
 func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
-    r.mu.RLock()
-    defer r.mu.RUnlock()
-    if !f(r.ring.Value) {
-        return
-    }
-    for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
-        if !f(p.Value) {
-            break
-        }
-    }
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if !f(r.ring.Value) {
+		return
+	}
+	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
+		if !f(p.Value) {
+			break
+		}
+	}
 }
 
 // LockIteratorNext iterates and locks writing forward
 // with given callback function <f> within RWMutex.RLock.
 // If <f> returns true, then it continues iterating; or false to stop.
 func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool) {
-    r.mu.RLock()
-    defer r.mu.RUnlock()
-    if !f(r.ring) {
-        return
-    }
-    for p := r.ring.Next(); p != r.ring; p = p.Next() {
-        if !f(p) {
-            break
-        }
-    }
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if !f(r.ring) {
+		return
+	}
+	for p := r.ring.Next(); p != r.ring; p = p.Next() {
+		if !f(p) {
+			break
+		}
+	}
 }
 
 // LockIteratorPrev iterates and locks writing backward
 // with given callback function <f> within RWMutex.RLock.
 // If <f> returns true, then it continues iterating; or false to stop.
 func (r *Ring) LockIteratorPrev(f func(item *ring.Ring) bool) {
-    r.mu.RLock()
-    defer r.mu.RUnlock()
-    if !f(r.ring) {
-        return
-    }
-    for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
-        if !f(p) {
-            break
-        }
-    }
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	if !f(r.ring) {
+		return
+	}
+	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
+		if !f(p) {
+			break
+		}
+	}
 }
 
 // SliceNext returns a copy of all item values as slice forward from current position.
 func (r *Ring) SliceNext() []interface{} {
-    s := make([]interface{}, 0)
-    r.mu.RLock()
-    if r.ring.Value != nil {
-        s = append(s, r.ring.Value)
-    }
-    for p := r.ring.Next(); p != r.ring; p = p.Next() {
-        if p.Value != nil {
-            s = append(s, p.Value)
-        }
-    }
-    r.mu.RUnlock()
-    return s
+	s := make([]interface{}, 0)
+	r.mu.RLock()
+	if r.ring.Value != nil {
+		s = append(s, r.ring.Value)
+	}
+	for p := r.ring.Next(); p != r.ring; p = p.Next() {
+		if p.Value != nil {
+			s = append(s, p.Value)
+		}
+	}
+	r.mu.RUnlock()
+	return s
 }
 
 // SlicePrev returns a copy of all item values as slice backward from current position.
 func (r *Ring) SlicePrev() []interface{} {
-    s := make([]interface{}, 0)
-    r.mu.RLock()
-    if r.ring.Value != nil {
-        s = append(s, r.ring.Value)
-    }
-    for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
-        if p.Value != nil {
-            s = append(s, p.Value)
-        }
-    }
-    r.mu.RUnlock()
-    return s
-}
+	s := make([]interface{}, 0)
+	r.mu.RLock()
+	if r.ring.Value != nil {
+		s = append(s, r.ring.Value)
+	}
+	for p := r.ring.Prev(); p != r.ring; p = p.Prev() {
+		if p.Value != nil {
+			s = append(s, p.Value)
+		}
+	}
+	r.mu.RUnlock()
+	return s
+}

g/container/gring/gring_test.go

@@ -9,38 +9,38 @@
 package gring
 
 import (
-    "testing"
+	"testing"
 )
 
 var length = 10000
-var r1     = New(length)
+var r1 = New(length)
 
 func BenchmarkRing_Put(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        r1.Put(i)
-    }
+	for i := 0; i < b.N; i++ {
+		r1.Put(i)
+	}
 }
 
 func BenchmarkRing_Next(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        r1.Next()
-    }
+	for i := 0; i < b.N; i++ {
+		r1.Next()
+	}
 }
 
 func BenchmarkRing_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        r1.Set(i)
-    }
+	for i := 0; i < b.N; i++ {
+		r1.Set(i)
+	}
 }
 
 func BenchmarkRing_Len(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        r1.Len()
-    }
+	for i := 0; i < b.N; i++ {
+		r1.Len()
+	}
 }
 
 func BenchmarkRing_Cap(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        r1.Cap()
-    }
-}
+	for i := 0; i < b.N; i++ {
+		r1.Cap()
+	}
+}

g/container/gring/gring_unit_test.go

@@ -7,10 +7,11 @@ import (
 	"github.com/gogf/gf/g/test/gtest"
 	"testing"
 )
+
 type Student struct {
 	position int
-	name    string
-	upgrade bool
+	name     string
+	upgrade  bool
 }
 
 func TestRing_Val(t *testing.T) {
@@ -18,19 +19,19 @@ func TestRing_Val(t *testing.T) {
 		//定义cap 为3的ring类型数据
 		r := gring.New(3, true)
 		//分别给3个元素初始化赋值
-		r.Put(&Student{1,"jimmy", true})
-		r.Put(&Student{2,"tom", true})
-		r.Put(&Student{3,"alon", false})
+		r.Put(&Student{1, "jimmy", true})
+		r.Put(&Student{2, "tom", true})
+		r.Put(&Student{3, "alon", false})
 
 		//元素取值并判断和预设值是否相等
-		gtest.Assert(r.Val().(*Student).name,"jimmy")
+		gtest.Assert(r.Val().(*Student).name, "jimmy")
 		//从当前位置往后移两个元素
 		r.Move(2)
-		gtest.Assert(r.Val().(*Student).name,"alon")
+		gtest.Assert(r.Val().(*Student).name, "alon")
 		//更新元素值
 		//测试 value == nil
 		r.Set(nil)
-		gtest.Assert(r.Val(),nil)
+		gtest.Assert(r.Val(), nil)
 		//测试value != nil
 		r.Set(&Student{3, "jack", true})
 	})
@@ -53,10 +54,10 @@ func TestRing_Position(t *testing.T) {
 		r.Put(2)
 		//往后移动1个元素
 		r.Next()
-		gtest.Assert(r.Val(),2)
+		gtest.Assert(r.Val(), 2)
 		//往前移动1个元素
 		r.Prev()
-		gtest.Assert(r.Val(),1)
+		gtest.Assert(r.Val(), 1)
 
 	})
 }
@@ -80,13 +81,13 @@ func TestRing_Link(t *testing.T) {
 func TestRing_Unlink(t *testing.T) {
 	gtest.Case(t, func() {
 		r := gring.New(5)
-		for i := 0; i< 5; i++  {
-			r.Put(i+1)
+		for i := 0; i < 5; i++ {
+			r.Put(i + 1)
 		}
 		// 1 2 3 4
 		// 删除当前位置往后的2个数据，返回被删除的数据
 		// 重新计算s len
-		s := r.Unlink(2)		// 2 3
+		s := r.Unlink(2) // 2 3
 		gtest.Assert(s.Val(), 2)
 		gtest.Assert(s.Len(), 1)
 	})
@@ -96,33 +97,33 @@ func TestRing_Slice(t *testing.T) {
 	gtest.Case(t, func() {
 		ringLen := 5
 		r := gring.New(ringLen)
-		for i := 0; i< ringLen; i++  {
-			r.Put(i+1)
+		for i := 0; i < ringLen; i++ {
+			r.Put(i + 1)
 		}
-		r.Move(2)	// 3
-		array := r.SliceNext()		// [3 4 5 1 2]
+		r.Move(2)              // 3
+		array := r.SliceNext() // [3 4 5 1 2]
 		gtest.Assert(array[0], 3)
 		gtest.Assert(len(array), 5)
 
 		//判断array是否等于[3 4 5 1 2]
-		ra := []int{3,4,5,1,2}
+		ra := []int{3, 4, 5, 1, 2}
 		gtest.Assert(ra, array)
 
 		//第3个元素设为nil
 		r.Set(nil)
-		array2 := r.SliceNext() 	//[4 5 1 2]
+		array2 := r.SliceNext() //[4 5 1 2]
 		//返回当前位置往后不为空的元素数组，长度为4
-		gtest.Assert(array2, g.Slice{4,5,1,2})
+		gtest.Assert(array2, g.Slice{4, 5, 1, 2})
 
-		array3 := r.SlicePrev() 	//[2 1 5 4]
-		gtest.Assert(array3, g.Slice{2,1,5,4})
+		array3 := r.SlicePrev() //[2 1 5 4]
+		gtest.Assert(array3, g.Slice{2, 1, 5, 4})
 
 		s := gring.New(ringLen)
-		for i := 0; i< ringLen; i++  {
-			s.Put(i+1)
+		for i := 0; i < ringLen; i++ {
+			s.Put(i + 1)
 		}
-		array4 := s.SlicePrev()	// []
-		gtest.Assert(array4, g.Slice{1,5,4,3,2})
+		array4 := s.SlicePrev() // []
+		gtest.Assert(array4, g.Slice{1, 5, 4, 3, 2})
 
 	})
 }
@@ -147,15 +148,15 @@ func TestRing_RLockIterator(t *testing.T) {
 			return true
 		})
 
-		for i := 0; i< ringLen; i++  {
-			r.Put(i+1)
+		for i := 0; i < ringLen; i++ {
+			r.Put(i + 1)
 		}
 
 		//回调函数返回true,RLockIteratorNext遍历5次,期望值分别是1、2、3、4、5
 		i := 0
 		r.RLockIteratorNext(func(v interface{}) bool {
 			gtest.Assert(v, i+1)
-			i++;
+			i++
 			return true
 		})
 
@@ -197,33 +198,32 @@ func TestRing_LockIterator(t *testing.T) {
 		})
 
 		//ring初始化元素值
-		for i := 0; i< ringLen; i++  {
-			r.Put(i+1)
+		for i := 0; i < ringLen; i++ {
+			r.Put(i + 1)
 		}
 
 		//往后遍历组成数据 [1,2,3,4,5]
-		array1 := g.Slice{1,2,3,4,5}
+		array1 := g.Slice{1, 2, 3, 4, 5}
 		ii := 0
 		r.LockIteratorNext(func(item *ring.Ring) bool {
 			//校验每一次遍历取值是否是期望值
 			gtest.Assert(item.Value, array1[ii])
-			ii++;
+			ii++
 			return true
 		})
 
 		//往后取3个元素组成数组
 		//获得 [1,5,4]
 		i := 0
-		a := g.Slice{1,5,4}
+		a := g.Slice{1, 5, 4}
 		r.LockIteratorPrev(func(item *ring.Ring) bool {
 			if i > 2 {
 				return false
 			}
 			gtest.Assert(item.Value, a[i])
-			i++;
+			i++
 			return true
 		})
 
-
 	})
-}
+}

g/container/gset/gset.go

@@ -8,240 +8,240 @@
 package gset
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "strings"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
 )
 
 type Set struct {
-    mu *rwmutex.RWMutex
-    m  map[interface{}]struct{}
+	mu *rwmutex.RWMutex
+	m  map[interface{}]struct{}
 }
 
 // New create and returns a new set, which contains un-repeated items.
 // The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
-func New(unsafe...bool) *Set {
-    return NewSet(unsafe...)
+func New(unsafe ...bool) *Set {
+	return NewSet(unsafe...)
 }
 
 // See New.
-func NewSet(unsafe...bool) *Set {
-    return &Set{
-        m  : make(map[interface{}]struct{}),
-        mu : rwmutex.New(unsafe...),
-    }
+func NewSet(unsafe ...bool) *Set {
+	return &Set{
+		m:  make(map[interface{}]struct{}),
+		mu: rwmutex.New(unsafe...),
+	}
 }
 
 // NewFrom returns a new set from <items>.
 // Parameter <items> can be either a variable of any type, or a slice.
-func NewFrom(items interface{}, unsafe...bool) *Set {
+func NewFrom(items interface{}, unsafe ...bool) *Set {
 	m := make(map[interface{}]struct{})
 	for _, v := range gconv.Interfaces(items) {
 		m[v] = struct{}{}
 	}
 	return &Set{
-		m  : m,
-		mu : rwmutex.New(unsafe...),
+		m:  m,
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
 // Iterator iterates the set with given callback function <f>,
 // if <f> returns true then continue iterating; or false to stop.
-func (set *Set) Iterator(f func (v interface{}) bool) *Set {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for k, _ := range set.m {
-        if !f(k) {
-            break
-        }
-    }
-    return set
+func (set *Set) Iterator(f func(v interface{}) bool) *Set {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for k, _ := range set.m {
+		if !f(k) {
+			break
+		}
+	}
+	return set
 }
 
 // Add adds one or multiple items to the set.
-func (set *Set) Add(item...interface{}) *Set {
-    set.mu.Lock()
-    for _, v := range item {
-        set.m[v] = struct{}{}
-    }
-    set.mu.Unlock()
-    return set
+func (set *Set) Add(item ...interface{}) *Set {
+	set.mu.Lock()
+	for _, v := range item {
+		set.m[v] = struct{}{}
+	}
+	set.mu.Unlock()
+	return set
 }
 
 // Contains checks whether the set contains <item>.
 func (set *Set) Contains(item interface{}) bool {
-    set.mu.RLock()
-    _, exists := set.m[item]
-    set.mu.RUnlock()
-    return exists
+	set.mu.RLock()
+	_, exists := set.m[item]
+	set.mu.RUnlock()
+	return exists
 }
 
 // Remove deletes <item> from set.
 func (set *Set) Remove(item interface{}) *Set {
-    set.mu.Lock()
-    delete(set.m, item)
-    set.mu.Unlock()
-    return set
+	set.mu.Lock()
+	delete(set.m, item)
+	set.mu.Unlock()
+	return set
 }
 
 // Size returns the size of the set.
 func (set *Set) Size() int {
-    set.mu.RLock()
-    l := len(set.m)
-    set.mu.RUnlock()
-    return l
+	set.mu.RLock()
+	l := len(set.m)
+	set.mu.RUnlock()
+	return l
 }
 
 // Clear deletes all items of the set.
 func (set *Set) Clear() *Set {
-    set.mu.Lock()
-    set.m = make(map[interface{}]struct{})
-    set.mu.Unlock()
-    return set
+	set.mu.Lock()
+	set.m = make(map[interface{}]struct{})
+	set.mu.Unlock()
+	return set
 }
 
 // Slice returns the a of items of the set as slice.
 func (set *Set) Slice() []interface{} {
-    set.mu.RLock()
-    i   := 0
-    ret := make([]interface{}, len(set.m))
-    for item := range set.m {
-        ret[i] = item
-        i++
-    }
-    set.mu.RUnlock()
-    return ret
+	set.mu.RLock()
+	i := 0
+	ret := make([]interface{}, len(set.m))
+	for item := range set.m {
+		ret[i] = item
+		i++
+	}
+	set.mu.RUnlock()
+	return ret
 }
 
 // Join joins items with a string <glue>.
 func (set *Set) Join(glue string) string {
-    return strings.Join(gconv.Strings(set.Slice()), ",")
+	return strings.Join(gconv.Strings(set.Slice()), ",")
 }
 
 // String returns items as a string, which are joined by char ','.
 func (set *Set) String() string {
-    return set.Join(",")
+	return set.Join(",")
 }
 
 // LockFunc locks writing with callback function <f>.
 func (set *Set) LockFunc(f func(m map[interface{}]struct{})) {
-    set.mu.Lock()
-    defer set.mu.Unlock()
-    f(set.m)
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	f(set.m)
 }
 
 // RLockFunc locks reading with callback function <f>.
 func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    f(set.m)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	f(set.m)
 }
 
 // Equal checks whether the two sets equal.
 func (set *Set) Equal(other *Set) bool {
-    if set == other {
-        return true
-    }
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    other.mu.RLock()
-    defer other.mu.RUnlock()
-    if len(set.m) != len(other.m) {
-        return false
-    }
-    for key := range set.m {
-        if _, ok := other.m[key]; !ok {
-            return false
-        }
-    }
-    return true
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	if len(set.m) != len(other.m) {
+		return false
+	}
+	for key := range set.m {
+		if _, ok := other.m[key]; !ok {
+			return false
+		}
+	}
+	return true
 }
 
 // IsSubsetOf checks whether the current set is a sub-set of <other>.
 func (set *Set) IsSubsetOf(other *Set) bool {
-    if set == other {
-        return true
-    }
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    other.mu.RLock()
-    defer other.mu.RUnlock()
-    for key := range set.m {
-        if _, ok := other.m[key]; !ok {
-            return false
-        }
-    }
-    return true
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key := range set.m {
+		if _, ok := other.m[key]; !ok {
+			return false
+		}
+	}
+	return true
 }
 
 // Union returns a new set which is the union of <set> and <others>.
 // Which means, all the items in <newSet> are in <set> or in <others>.
-func (set *Set) Union(others ... *Set) (newSet *Set) {
-    newSet = NewSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            newSet.m[k] = v
-        }
-        if set != other {
-            for k, v := range other.m {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
+func (set *Set) Union(others ...*Set) (newSet *Set) {
+	newSet = NewSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			newSet.m[k] = v
+		}
+		if set != other {
+			for k, v := range other.m {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
 
-    return
+	return
 }
 
 // Diff returns a new set which is the difference set from <set> to <others>.
 // Which means, all the items in <newSet> are in <set> but not in <others>.
-func (set *Set) Diff(others...*Set) (newSet *Set) {
-    newSet = NewSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set == other {
-            continue
-        }
-        other.mu.RLock()
-        for k, v := range set.m {
-            if _, ok := other.m[k]; !ok {
-                newSet.m[k] = v
-            }
-        }
-        other.mu.RUnlock()
-    }
-    return
+func (set *Set) Diff(others ...*Set) (newSet *Set) {
+	newSet = NewSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set == other {
+			continue
+		}
+		other.mu.RLock()
+		for k, v := range set.m {
+			if _, ok := other.m[k]; !ok {
+				newSet.m[k] = v
+			}
+		}
+		other.mu.RUnlock()
+	}
+	return
 }
 
 // Intersect returns a new set which is the intersection from <set> to <others>.
 // Which means, all the items in <newSet> are in <set> and also in <others>.
-func (set *Set) Intersect(others...*Set) (newSet *Set) {
-    newSet = NewSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            if _, ok := other.m[k]; ok {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
-    return
+func (set *Set) Intersect(others ...*Set) (newSet *Set) {
+	newSet = NewSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			if _, ok := other.m[k]; ok {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return
 }
 
 // Complement returns a new set which is the complement from <set> to <full>.
@@ -250,23 +250,23 @@ func (set *Set) Intersect(others...*Set) (newSet *Set) {
 // It returns the difference between <full> and <set>
 // if the given set <full> is not the full set of <set>.
 func (set *Set) Complement(full *Set) (newSet *Set) {
-    newSet = NewSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    if set != full {
-        full.mu.RLock()
-        defer full.mu.RUnlock()
-    }
-    for k, v := range full.m {
-        if _, ok := set.m[k]; !ok {
-            newSet.m[k] = v
-        }
-    }
-    return
+	newSet = NewSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	if set != full {
+		full.mu.RLock()
+		defer full.mu.RUnlock()
+	}
+	for k, v := range full.m {
+		if _, ok := set.m[k]; !ok {
+			newSet.m[k] = v
+		}
+	}
+	return
 }
 
 // Merge adds items from <others> sets into <set>.
-func (set *Set) Merge(others ... *Set) *Set {
+func (set *Set) Merge(others ...*Set) *Set {
 	set.mu.Lock()
 	defer set.mu.Unlock()
 	for _, other := range others {
@@ -322,4 +322,4 @@ func (set *Set) Pops(size int) []interface{} {
 		}
 	}
 	return array
-}
+}

g/container/gset/gset_int_set.go

@@ -8,9 +8,9 @@
 package gset
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
-    "github.com/gogf/gf/g/util/gconv"
-    "strings"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
 )
 
 type IntSet struct {
@@ -21,44 +21,44 @@ type IntSet struct {
 // New create and returns a new set, which contains un-repeated items.
 // The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
-func NewIntSet(unsafe...bool) *IntSet {
+func NewIntSet(unsafe ...bool) *IntSet {
 	return &IntSet{
-		m  : make(map[int]struct{}),
-		mu : rwmutex.New(unsafe...),
+		m:  make(map[int]struct{}),
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
 // NewIntSetFrom returns a new set from <items>.
-func NewIntSetFrom(items []int, unsafe...bool) *IntSet {
+func NewIntSetFrom(items []int, unsafe ...bool) *IntSet {
 	m := make(map[int]struct{})
 	for _, v := range items {
 		m[v] = struct{}{}
 	}
 	return &IntSet{
-		m  : m,
-		mu : rwmutex.New(unsafe...),
+		m:  m,
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
 // Iterator iterates the set with given callback function <f>,
 // if <f> returns true then continue iterating; or false to stop.
-func (set *IntSet) Iterator(f func (v int) bool) *IntSet {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
+func (set *IntSet) Iterator(f func(v int) bool) *IntSet {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
 	for k, _ := range set.m {
 		if !f(k) {
 			break
 		}
 	}
-    return set
+	return set
 }
 
 // Add adds one or multiple items to the set.
-func (set *IntSet) Add(item...int) *IntSet {
+func (set *IntSet) Add(item ...int) *IntSet {
 	set.mu.Lock()
-    for _, v := range item {
-        set.m[v] = struct{}{}
-    }
+	for _, v := range item {
+		set.m[v] = struct{}{}
+	}
 	set.mu.Unlock()
 	return set
 }
@@ -92,7 +92,7 @@ func (set *IntSet) Clear() *IntSet {
 	set.mu.Lock()
 	set.m = make(map[int]struct{})
 	set.mu.Unlock()
-    return set
+	return set
 }
 
 // Slice returns the a of items of the set as slice.
@@ -110,12 +110,12 @@ func (set *IntSet) Slice() []int {
 
 // Join joins items with a string <glue>.
 func (set *IntSet) Join(glue string) string {
-    return strings.Join(gconv.Strings(set.Slice()), ",")
+	return strings.Join(gconv.Strings(set.Slice()), ",")
 }
 
 // String returns items as a string, which are joined by char ','.
 func (set *IntSet) String() string {
-    return set.Join(",")
+	return set.Join(",")
 }
 
 // LockFunc locks writing with callback function <f>.
@@ -127,20 +127,20 @@ func (set *IntSet) LockFunc(f func(m map[int]struct{})) {
 
 // RLockFunc locks reading with callback function <f>.
 func (set *IntSet) RLockFunc(f func(m map[int]struct{})) {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    f(set.m)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	f(set.m)
 }
 
 // Equal checks whether the two sets equal.
 func (set *IntSet) Equal(other *IntSet) bool {
-    if set == other {
-        return true
-    }
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    other.mu.RLock()
-    defer other.mu.RUnlock()
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
 	if len(set.m) != len(other.m) {
 		return false
 	}
@@ -154,88 +154,88 @@ func (set *IntSet) Equal(other *IntSet) bool {
 
 // IsSubsetOf checks whether the current set is a sub-set of <other>.
 func (set *IntSet) IsSubsetOf(other *IntSet) bool {
-    if set == other {
-        return true
-    }
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    other.mu.RLock()
-    defer other.mu.RUnlock()
-    for key := range set.m {
-        if _, ok := other.m[key]; !ok {
-            return false
-        }
-    }
-    return true
+	if set == other {
+		return true
+	}
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	other.mu.RLock()
+	defer other.mu.RUnlock()
+	for key := range set.m {
+		if _, ok := other.m[key]; !ok {
+			return false
+		}
+	}
+	return true
 }
 
 // Union returns a new set which is the union of <set> and <other>.
 // Which means, all the items in <newSet> are in <set> or in <other>.
-func (set *IntSet) Union(others ... *IntSet) (newSet *IntSet) {
-    newSet = NewIntSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            newSet.m[k] = v
-        }
-        if set != other {
-            for k, v := range other.m {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
+func (set *IntSet) Union(others ...*IntSet) (newSet *IntSet) {
+	newSet = NewIntSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			newSet.m[k] = v
+		}
+		if set != other {
+			for k, v := range other.m {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
 
-    return
+	return
 }
 
 // Diff returns a new set which is the difference set from <set> to <other>.
 // Which means, all the items in <newSet> are in <set> but not in <other>.
-func (set *IntSet) Diff(others...*IntSet) (newSet *IntSet) {
-    newSet = NewIntSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set == other {
-            continue
-        }
-        other.mu.RLock()
-        for k, v := range set.m {
-            if _, ok := other.m[k]; !ok {
-                newSet.m[k] = v
-            }
-        }
-        other.mu.RUnlock()
-    }
-    return
+func (set *IntSet) Diff(others ...*IntSet) (newSet *IntSet) {
+	newSet = NewIntSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set == other {
+			continue
+		}
+		other.mu.RLock()
+		for k, v := range set.m {
+			if _, ok := other.m[k]; !ok {
+				newSet.m[k] = v
+			}
+		}
+		other.mu.RUnlock()
+	}
+	return
 }
 
 // Intersect returns a new set which is the intersection from <set> to <other>.
 // Which means, all the items in <newSet> are in <set> and also in <other>.
-func (set *IntSet) Intersect(others...*IntSet) (newSet *IntSet) {
-    newSet = NewIntSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            if _, ok := other.m[k]; ok {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
-    return
+func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
+	newSet = NewIntSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			if _, ok := other.m[k]; ok {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return
 }
 
 // Complement returns a new set which is the complement from <set> to <full>.
@@ -244,23 +244,23 @@ func (set *IntSet) Intersect(others...*IntSet) (newSet *IntSet) {
 // It returns the difference between <full> and <set>
 // if the given set <full> is not the full set of <set>.
 func (set *IntSet) Complement(full *IntSet) (newSet *IntSet) {
-    newSet = NewIntSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    if set != full {
-        full.mu.RLock()
-        defer full.mu.RUnlock()
-    }
-    for k, v := range full.m {
-        if _, ok := set.m[k]; !ok {
-            newSet.m[k] = v
-        }
-    }
-    return
+	newSet = NewIntSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	if set != full {
+		full.mu.RLock()
+		defer full.mu.RUnlock()
+	}
+	for k, v := range full.m {
+		if _, ok := set.m[k]; !ok {
+			newSet.m[k] = v
+		}
+	}
+	return
 }
 
 // Merge adds items from <others> sets into <set>.
-func (set *IntSet) Merge(others ... *IntSet) *IntSet {
+func (set *IntSet) Merge(others ...*IntSet) *IntSet {
 	set.mu.Lock()
 	defer set.mu.Unlock()
 	for _, other := range others {
@@ -316,4 +316,4 @@ func (set *IntSet) Pops(size int) []int {
 		}
 	}
 	return array
-}
+}

g/container/gset/gset_string_set.go

@@ -8,7 +8,7 @@
 package gset
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
 	"github.com/gogf/gf/g/util/gconv"
 	"strings"
 )
@@ -21,30 +21,30 @@ type StringSet struct {
 // New create and returns a new set, which contains un-repeated items.
 // The parameter <unsafe> used to specify whether using set in un-concurrent-safety,
 // which is false in default.
-func NewStringSet(unsafe...bool) *StringSet {
-	return &StringSet {
-		m  : make(map[string]struct{}),
-		mu : rwmutex.New(unsafe...),
+func NewStringSet(unsafe ...bool) *StringSet {
+	return &StringSet{
+		m:  make(map[string]struct{}),
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
 // NewStringSetFrom returns a new set from <items>.
-func NewStringSetFrom(items []string, unsafe...bool) *StringSet {
+func NewStringSetFrom(items []string, unsafe ...bool) *StringSet {
 	m := make(map[string]struct{})
 	for _, v := range items {
 		m[v] = struct{}{}
 	}
 	return &StringSet{
-		m  : m,
-		mu : rwmutex.New(unsafe...),
+		m:  m,
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
 // Iterator iterates the set with given callback function <f>,
 // if <f> returns true then continue iterating; or false to stop.
-func (set *StringSet) Iterator(f func (v string) bool) *StringSet {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
+func (set *StringSet) Iterator(f func(v string) bool) *StringSet {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
 	for k, _ := range set.m {
 		if !f(k) {
 			break
@@ -54,7 +54,7 @@ func (set *StringSet) Iterator(f func (v string) bool) *StringSet {
 }
 
 // Add adds one or multiple items to the set.
-func (set *StringSet) Add(item...string) *StringSet {
+func (set *StringSet) Add(item ...string) *StringSet {
 	set.mu.Lock()
 	for _, v := range item {
 		set.m[v] = struct{}{}
@@ -76,7 +76,7 @@ func (set *StringSet) Remove(item string) *StringSet {
 	set.mu.Lock()
 	delete(set.m, item)
 	set.mu.Unlock()
-    return set
+	return set
 }
 
 // Size returns the size of the set.
@@ -92,7 +92,7 @@ func (set *StringSet) Clear() *StringSet {
 	set.mu.Lock()
 	set.m = make(map[string]struct{})
 	set.mu.Unlock()
-    return set
+	return set
 }
 
 // Slice returns the a of items of the set as slice.
@@ -111,12 +111,12 @@ func (set *StringSet) Slice() []string {
 
 // Join joins items with a string <glue>.
 func (set *StringSet) Join(glue string) string {
-    return strings.Join(set.Slice(), ",")
+	return strings.Join(set.Slice(), ",")
 }
 
 // String returns items as a string, which are joined by char ','.
 func (set *StringSet) String() string {
-    return set.Join(",")
+	return set.Join(",")
 }
 
 // LockFunc locks writing with callback function <f>.
@@ -172,71 +172,71 @@ func (set *StringSet) IsSubsetOf(other *StringSet) bool {
 
 // Union returns a new set which is the union of <set> and <other>.
 // Which means, all the items in <newSet> are in <set> or in <other>.
-func (set *StringSet) Union(others ... *StringSet) (newSet *StringSet) {
-    newSet = NewStringSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            newSet.m[k] = v
-        }
-        if set != other {
-            for k, v := range other.m {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
+func (set *StringSet) Union(others ...*StringSet) (newSet *StringSet) {
+	newSet = NewStringSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			newSet.m[k] = v
+		}
+		if set != other {
+			for k, v := range other.m {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
 
-    return
+	return
 }
 
 // Diff returns a new set which is the difference set from <set> to <other>.
 // Which means, all the items in <newSet> are in <set> but not in <other>.
-func (set *StringSet) Diff(others...*StringSet) (newSet *StringSet) {
-    newSet = NewStringSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set == other {
-            continue
-        }
-        other.mu.RLock()
-        for k, v := range set.m {
-            if _, ok := other.m[k]; !ok {
-                newSet.m[k] = v
-            }
-        }
-        other.mu.RUnlock()
-    }
-    return
+func (set *StringSet) Diff(others ...*StringSet) (newSet *StringSet) {
+	newSet = NewStringSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set == other {
+			continue
+		}
+		other.mu.RLock()
+		for k, v := range set.m {
+			if _, ok := other.m[k]; !ok {
+				newSet.m[k] = v
+			}
+		}
+		other.mu.RUnlock()
+	}
+	return
 }
 
 // Intersect returns a new set which is the intersection from <set> to <other>.
 // Which means, all the items in <newSet> are in <set> and also in <other>.
-func (set *StringSet) Intersect(others...*StringSet) (newSet *StringSet) {
-    newSet = NewStringSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for _, other := range others {
-        if set != other {
-            other.mu.RLock()
-        }
-        for k, v := range set.m {
-            if _, ok := other.m[k]; ok {
-                newSet.m[k] = v
-            }
-        }
-        if set != other {
-            other.mu.RUnlock()
-        }
-    }
-    return
+func (set *StringSet) Intersect(others ...*StringSet) (newSet *StringSet) {
+	newSet = NewStringSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range set.m {
+			if _, ok := other.m[k]; ok {
+				newSet.m[k] = v
+			}
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return
 }
 
 // Complement returns a new set which is the complement from <set> to <full>.
@@ -245,23 +245,23 @@ func (set *StringSet) Intersect(others...*StringSet) (newSet *StringSet) {
 // It returns the difference between <full> and <set>
 // if the given set <full> is not the full set of <set>.
 func (set *StringSet) Complement(full *StringSet) (newSet *StringSet) {
-    newSet = NewStringSet(true)
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    if set != full {
-        full.mu.RLock()
-        defer full.mu.RUnlock()
-    }
-    for k, v := range full.m {
-        if _, ok := set.m[k]; !ok {
-            newSet.m[k] = v
-        }
-    }
-    return
+	newSet = NewStringSet(true)
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	if set != full {
+		full.mu.RLock()
+		defer full.mu.RUnlock()
+	}
+	for k, v := range full.m {
+		if _, ok := set.m[k]; !ok {
+			newSet.m[k] = v
+		}
+	}
+	return
 }
 
 // Merge adds items from <others> sets into <set>.
-func (set *StringSet) Merge(others ... *StringSet) *StringSet {
+func (set *StringSet) Merge(others ...*StringSet) *StringSet {
 	set.mu.Lock()
 	defer set.mu.Unlock()
 	for _, other := range others {
@@ -317,4 +317,4 @@ func (set *StringSet) Pops(size int) []string {
 		}
 	}
 	return array
-}
+}

g/container/gset/gset_z_bench_test.go

@@ -4,127 +4,170 @@
 // 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=".*"
+// go test *.go -bench=".*" -benchmem
 
 package gset_test
 
 import (
-    "testing"
-    "strconv"
-    "github.com/gogf/gf/g/container/gset"
+	"strconv"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gset"
 )
 
-var ints       = gset.NewIntSet()
-var itfs       = gset.NewSet()
-var strs       = gset.NewStringSet()
-var intsUnsafe = gset.NewIntSet(true)
-var itfsUnsafe = gset.NewSet(true)
-var strsUnsafe = gset.NewStringSet(true)
+var intSet = gset.NewIntSet()
+var anySet = gset.NewSet()
+var strSet = gset.NewStringSet()
+var intSetUnsafe = gset.NewIntSet(true)
+var anySetUnsafe = gset.NewSet(true)
+var strSetUnsafe = gset.NewStringSet(true)
 
 func Benchmark_IntSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Add(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intSet.Add(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Contains(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intSet.Contains(i)
+			i++
+		}
+	})
 }
 
 func Benchmark_IntSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Remove(i)
-    }
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			intSet.Remove(i)
+			i++
+		}
+	})
 }
 
-func Benchmark_Set_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Add(i)
-    }
+func Benchmark_AnySet_Add(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			anySet.Add(i)
+			i++
+		}
+	})
 }
 
-func Benchmark_Set_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Contains(i)
-    }
+func Benchmark_AnySet_Contains(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			anySet.Contains(i)
+			i++
+		}
+	})
 }
 
-func Benchmark_Set_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Remove(i)
-    }
+func Benchmark_AnySet_Remove(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			anySet.Remove(i)
+			i++
+		}
+	})
 }
 
-func Benchmark_StringSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Add(strconv.Itoa(i))
-    }
+// Note that there's additional performance cost for string conversion.
+func Benchmark_StrSet_Add(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strSet.Add(strconv.Itoa(i))
+			i++
+		}
+	})
 }
 
-func Benchmark_StringSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Contains(strconv.Itoa(i))
-    }
+// Note that there's additional performance cost for string conversion.
+func Benchmark_StrSet_Contains(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strSet.Contains(strconv.Itoa(i))
+			i++
+		}
+	})
 }
 
-func Benchmark_StringSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Remove(strconv.Itoa(i))
-    }
+// Note that there's additional performance cost for string conversion.
+func Benchmark_StrSet_Remove(b *testing.B) {
+	b.RunParallel(func(pb *testing.PB) {
+		i := 0
+		for pb.Next() {
+			strSet.Remove(strconv.Itoa(i))
+			i++
+		}
+	})
 }
 
 func Benchmark_Unsafe_IntSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        intsUnsafe.Add(i)
-    }
+	for i := 0; i < b.N; i++ {
+		intSetUnsafe.Add(i)
+	}
 }
 
 func Benchmark_Unsafe_IntSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        intsUnsafe.Contains(i)
-    }
+	for i := 0; i < b.N; i++ {
+		intSetUnsafe.Contains(i)
+	}
 }
 
 func Benchmark_Unsafe_IntSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        intsUnsafe.Remove(i)
-    }
+	for i := 0; i < b.N; i++ {
+		intSetUnsafe.Remove(i)
+	}
 }
 
-func Benchmark_Unsafe_Set_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Add(i)
-    }
+func Benchmark_Unsafe_AnySet_Add(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		anySetUnsafe.Add(i)
+	}
 }
 
-func Benchmark_Unsafe_Set_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Contains(i)
-    }
+func Benchmark_Unsafe_AnySet_Contains(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		anySetUnsafe.Contains(i)
+	}
 }
 
-func Benchmark_Unsafe_Set_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Remove(i)
-    }
+func Benchmark_Unsafe_AnySet_Remove(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		anySetUnsafe.Remove(i)
+	}
 }
 
-func Benchmark_Unsafe_StringSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Add(strconv.Itoa(i))
-    }
+// Note that there's additional performance cost for string conversion.
+func Benchmark_Unsafe_StrSet_Add(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		strSetUnsafe.Add(strconv.Itoa(i))
+	}
 }
 
-func Benchmark_Unsafe_StringSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Contains(strconv.Itoa(i))
-    }
+// Note that there's additional performance cost for string conversion.
+func Benchmark_Unsafe_StrSet_Contains(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		strSetUnsafe.Contains(strconv.Itoa(i))
+	}
 }
 
-func Benchmark_Unsafe_StringSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Remove(strconv.Itoa(i))
-    }
-}
+// Note that there's additional performance cost for string conversion.
+func Benchmark_Unsafe_StrSet_Remove(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		strSetUnsafe.Remove(strconv.Itoa(i))
+	}
+}

g/container/gtree/gtree_avltree.go

@@ -7,7 +7,9 @@
 package gtree
 
 import (
+	"encoding/json"
 	"fmt"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
 )
@@ -32,9 +34,9 @@ type AVLTreeNode struct {
 // NewAVLTree instantiates an AVL tree with the custom key comparator.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewAVLTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *AVLTree {
+func NewAVLTree(comparator func(v1, v2 interface{}) int, unsafe ...bool) *AVLTree {
 	return &AVLTree{
-		mu        : rwmutex.New(unsafe...),
+		mu:         rwmutex.New(unsafe...),
 		comparator: comparator,
 	}
 }
@@ -42,7 +44,7 @@ func NewAVLTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *AVLTree
 // NewAVLTreeFrom instantiates an AVL tree with the custom key comparator and data map.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewAVLTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *AVLTree {
+func NewAVLTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe ...bool) *AVLTree {
 	tree := NewAVLTree(comparator, unsafe...)
 	for k, v := range data {
 		tree.put(k, v, nil, &tree.root)
@@ -88,9 +90,12 @@ func (tree *AVLTree) doSearch(key interface{}) (value interface{}, found bool) {
 	for n != nil {
 		cmp := tree.comparator(key, n.Key)
 		switch {
-			case cmp == 0: return n.Value, true
-			case cmp  < 0: n = n.children[0]
-			case cmp  > 0: n = n.children[1]
+		case cmp == 0:
+			return n.Value, true
+		case cmp < 0:
+			n = n.children[0]
+		case cmp > 0:
+			n = n.children[1]
 		}
 	}
 	return nil, false
@@ -117,7 +122,7 @@ func (tree *AVLTree) doSetWithLockCheck(key interface{}, value interface{}) inte
 	if v, ok := tree.doSearch(key); ok {
 		return v
 	}
-	if f, ok := value.(func() interface {}); ok {
+	if f, ok := value.(func() interface{}); ok {
 		value = f()
 	}
 	tree.put(key, value, nil, &tree.root)
@@ -254,7 +259,7 @@ func (tree *AVLTree) Size() int {
 
 // Keys returns all keys in asc order.
 func (tree *AVLTree) Keys() []interface{} {
-	keys  := make([]interface{}, tree.Size())
+	keys := make([]interface{}, tree.Size())
 	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		keys[index] = key
@@ -267,7 +272,7 @@ func (tree *AVLTree) Keys() []interface{} {
 // Values returns all values in asc order based on the key.
 func (tree *AVLTree) Values() []interface{} {
 	values := make([]interface{}, tree.Size())
-	index  := 0
+	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		values[index] = value
 		index++
@@ -283,9 +288,9 @@ func (tree *AVLTree) Left() *AVLTreeNode {
 	defer tree.mu.RUnlock()
 	node := tree.bottom(0)
 	if tree.mu.IsSafe() {
-		return &AVLTreeNode {
-			Key   : node.Key,
-			Value : node.Value,
+		return &AVLTreeNode{
+			Key:   node.Key,
+			Value: node.Value,
 		}
 	}
 	return node
@@ -298,9 +303,9 @@ func (tree *AVLTree) Right() *AVLTreeNode {
 	defer tree.mu.RUnlock()
 	node := tree.bottom(1)
 	if tree.mu.IsSafe() {
-		return &AVLTreeNode {
-			Key   : node.Key,
-			Value : node.Value,
+		return &AVLTreeNode{
+			Key:   node.Key,
+			Value: node.Value,
 		}
 	}
 	return node
@@ -321,11 +326,13 @@ func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 	for n != nil {
 		c := tree.comparator(key, n.Key)
 		switch {
-			case c == 0: return n, true
-			case c  < 0: n = n.children[0]
-			case c  > 0:
-				floor, found = n, true
-				n = n.children[1]
+		case c == 0:
+			return n, true
+		case c < 0:
+			n = n.children[0]
+		case c > 0:
+			floor, found = n, true
+			n = n.children[1]
 		}
 	}
 	if found {
@@ -349,11 +356,13 @@ func (tree *AVLTree) Ceiling(key interface{}) (ceiling *AVLTreeNode, found bool)
 	for n != nil {
 		c := tree.comparator(key, n.Key)
 		switch {
-			case c == 0: return n, true
-			case c  > 0: n = n.children[1]
-			case c  < 0:
-				ceiling, found = n, true
-				n = n.children[0]
+		case c == 0:
+			return n, true
+		case c > 0:
+			n = n.children[1]
+		case c < 0:
+			ceiling, found = n, true
+			n = n.children[0]
 		}
 	}
 	if found {
@@ -401,7 +410,7 @@ func (tree *AVLTree) Map() map[interface{}]interface{} {
 // or else the comparator would panic.
 //
 // If the type of value is different with key, you pass the new <comparator>.
-func (tree *AVLTree) Flip(comparator...func(v1, v2 interface{}) int) {
+func (tree *AVLTree) Flip(comparator ...func(v1, v2 interface{}) int) {
 	t := (*AVLTree)(nil)
 	if len(comparator) > 0 {
 		t = NewAVLTree(comparator[0], !tree.mu.IsSafe())
@@ -419,13 +428,13 @@ func (tree *AVLTree) Flip(comparator...func(v1, v2 interface{}) int) {
 }
 
 // Iterator is alias of IteratorAsc.
-func (tree *AVLTree) Iterator(f func (key, value interface{}) bool) {
+func (tree *AVLTree) Iterator(f func(key, value interface{}) bool) {
 	tree.IteratorAsc(f)
 }
 
 // IteratorAsc iterates the tree in ascending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *AVLTree) IteratorAsc(f func (key, value interface{}) bool) {
+func (tree *AVLTree) IteratorAsc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.bottom(0)
@@ -439,7 +448,7 @@ func (tree *AVLTree) IteratorAsc(f func (key, value interface{}) bool) {
 
 // IteratorDesc iterates the tree in descending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *AVLTree) IteratorDesc(f func (key, value interface{}) bool) {
+func (tree *AVLTree) IteratorDesc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.bottom(1)
@@ -488,7 +497,7 @@ func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) (value interface{
 	if c == 0 {
 		tree.size--
 		value = q.Value
-		fix   = true
+		fix = true
 		if q.children[1] == nil {
 			if q.children[0] != nil {
 				q.children[0].parent = q.parent
@@ -568,9 +577,9 @@ func removeFix(c int8, t **AVLTreeNode) bool {
 
 	a := (c + 1) / 2
 	if s.children[a].b == 0 {
-		s   = rotate(c, s)
+		s = rotate(c, s)
 		s.b = -c
-		*t  = s
+		*t = s
 		return false
 	}
 
@@ -597,15 +606,15 @@ func doubleRotate(c int8, s *AVLTreeNode) *AVLTreeNode {
 	p := rotate(c, s)
 
 	switch {
-		default:
-			s.b = 0
-			r.b = 0
-		case p.b == c:
-			s.b = -c
-			r.b = 0
-		case p.b == -c:
-			s.b = 0
-			r.b = c
+	default:
+		s.b = 0
+		r.b = 0
+	case p.b == c:
+		s.b = -c
+		r.b = 0
+	case p.b == -c:
+		s.b = 0
+		r.b = c
 	}
 
 	p.b = 0
@@ -696,4 +705,9 @@ func output(node *AVLTreeNode, prefix string, isTail bool, str *string) {
 		}
 		output(node.children[0], newPrefix, true, str)
 	}
-}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree *AVLTree) MarshalJSON() ([]byte, error) {
+	return json.Marshal(tree.Map())
+}

g/container/gtree/gtree_btree.go

@@ -8,10 +8,12 @@ package gtree
 
 import (
 	"bytes"
+	"encoding/json"
 	"fmt"
+	"strings"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
-	"strings"
 )
 
 // BTree holds elements of the B-tree.
@@ -19,8 +21,8 @@ type BTree struct {
 	mu         *rwmutex.RWMutex
 	root       *BTreeNode
 	comparator func(v1, v2 interface{}) int
-	size       int    // Total number of keys in the tree
-	m          int    // order (maximum number of children)
+	size       int // Total number of keys in the tree
+	m          int // order (maximum number of children)
 }
 
 // BTreeNode is a single element within the tree.
@@ -40,21 +42,21 @@ type BTreeEntry struct {
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
 // Note that the <m> must be greater or equal than 3, or else it panics.
-func NewBTree(m int, comparator func(v1, v2 interface{}) int, unsafe...bool) *BTree {
+func NewBTree(m int, comparator func(v1, v2 interface{}) int, unsafe ...bool) *BTree {
 	if m < 3 {
 		panic("Invalid order, should be at least 3")
 	}
 	return &BTree{
-		comparator : comparator,
-		mu         : rwmutex.New(unsafe...),
-		m          : m,
+		comparator: comparator,
+		mu:         rwmutex.New(unsafe...),
+		m:          m,
 	}
 }
 
 // NewBTreeFrom instantiates a B-tree with <m> (maximum number of children), a custom key comparator and data map.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *BTree {
+func NewBTreeFrom(m int, comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe ...bool) *BTree {
 	tree := NewBTree(m, comparator, unsafe...)
 	for k, v := range data {
 		tree.doSet(k, v)
@@ -121,7 +123,7 @@ func (tree *BTree) doSetWithLockCheck(key interface{}, value interface{}) interf
 	if entry := tree.doSearch(key); entry != nil {
 		return entry.Value
 	}
-	if f, ok := value.(func() interface {}); ok {
+	if f, ok := value.(func() interface{}); ok {
 		value = f()
 	}
 	tree.doSet(key, value)
@@ -268,7 +270,7 @@ func (tree *BTree) Size() int {
 
 // Keys returns all keys in asc order.
 func (tree *BTree) Keys() []interface{} {
-	keys  := make([]interface{}, tree.Size())
+	keys := make([]interface{}, tree.Size())
 	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		keys[index] = key
@@ -281,7 +283,7 @@ func (tree *BTree) Keys() []interface{} {
 // Values returns all values in asc order based on the key.
 func (tree *BTree) Values() []interface{} {
 	values := make([]interface{}, tree.Size())
-	index  := 0
+	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		values[index] = value
 		index++
@@ -328,7 +330,7 @@ func (tree *BTree) Right() *BTreeEntry {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.right(tree.root)
-	return node.Entries[len(node.Entries) - 1]
+	return node.Entries[len(node.Entries)-1]
 }
 
 // String returns a string representation of container (for debugging purposes)
@@ -372,13 +374,13 @@ func (tree *BTree) Print() {
 }
 
 // Iterator is alias of IteratorAsc.
-func (tree *BTree) Iterator(f func (key, value interface{}) bool) {
+func (tree *BTree) Iterator(f func(key, value interface{}) bool) {
 	tree.IteratorAsc(f)
 }
 
 // IteratorAsc iterates the tree in ascending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *BTree) IteratorAsc(f func (key, value interface{}) bool) {
+func (tree *BTree) IteratorAsc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.left(tree.root)
@@ -396,8 +398,8 @@ loop:
 	// Find current entry position in current node
 	e, _ := tree.search(node, entry.Key)
 	// Try to go down to the child right of the current entry
-	if e + 1 < len(node.Children) {
-		node = node.Children[e + 1]
+	if e+1 < len(node.Children) {
+		node = node.Children[e+1]
 		// Try to go down to the child left of the current node
 		for len(node.Children) > 0 {
 			node = node.Children[0]
@@ -407,8 +409,8 @@ loop:
 		goto loop
 	}
 	// Above assures that we have reached a leaf node, so return the next entry in current node (if any)
-	if e + 1 < len(node.Entries) {
-		entry = node.Entries[e + 1]
+	if e+1 < len(node.Entries) {
+		entry = node.Entries[e+1]
 		goto loop
 	}
 	// Reached leaf node and there are no entries to the right of the current entry, so go up to the parent
@@ -426,14 +428,14 @@ loop:
 
 // IteratorDesc iterates the tree in descending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *BTree) IteratorDesc(f func (key, value interface{}) bool) {
+func (tree *BTree) IteratorDesc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.right(tree.root)
 	if node == nil {
 		return
 	}
-	entry := node.Entries[len(node.Entries) - 1]
+	entry := node.Entries[len(node.Entries)-1]
 loop:
 	if entry == nil {
 		return
@@ -448,15 +450,15 @@ loop:
 		node = node.Children[e]
 		// Try to go down to the child right of the current node
 		for len(node.Children) > 0 {
-			node = node.Children[len(node.Children) - 1]
+			node = node.Children[len(node.Children)-1]
 		}
 		// Return the right-most entry
-		entry = node.Entries[len(node.Entries) - 1]
+		entry = node.Entries[len(node.Entries)-1]
 		goto loop
 	}
 	// Above assures that we have reached a leaf node, so return the previous entry in current node (if any)
-	if e - 1 >= 0 {
-		entry = node.Entries[e - 1]
+	if e-1 >= 0 {
+		entry = node.Entries[e-1]
 		goto loop
 	}
 
@@ -466,8 +468,8 @@ loop:
 		// Find previous entry position in current node (note: search returns the first equal or bigger than entry)
 		e, _ := tree.search(node, entry.Key)
 		// Check that there is a previous entry position in current node
-		if e - 1 >= 0 {
-			entry = node.Entries[e - 1]
+		if e-1 >= 0 {
+			entry = node.Entries[e-1]
 			goto loop
 		}
 	}
@@ -534,14 +536,17 @@ func (tree *BTree) middle() int {
 
 // search searches only within the single node among its entries
 func (tree *BTree) search(node *BTreeNode, key interface{}) (index int, found bool) {
-	low, mid, high := 0, 0, len(node.Entries) - 1
+	low, mid, high := 0, 0, len(node.Entries)-1
 	for low <= high {
 		mid = (high + low) / 2
 		compare := tree.comparator(key, node.Entries[mid].Key)
 		switch {
-			case compare  > 0:  low = mid + 1
-			case compare  < 0: high = mid - 1
-			case compare == 0: return mid, true
+		case compare > 0:
+			low = mid + 1
+		case compare < 0:
+			high = mid - 1
+		case compare == 0:
+			return mid, true
 		}
 	}
 	return low, false
@@ -643,8 +648,8 @@ func (tree *BTree) splitNonRoot(node *BTreeNode) {
 
 func (tree *BTree) splitRoot() {
 	middle := tree.middle()
-	left   := &BTreeNode{Entries: append([]*BTreeEntry(nil), tree.root.Entries[:middle]...)}
-	right  := &BTreeNode{Entries: append([]*BTreeEntry(nil), tree.root.Entries[middle+1:]...)}
+	left := &BTreeNode{Entries: append([]*BTreeEntry(nil), tree.root.Entries[:middle]...)}
+	right := &BTreeNode{Entries: append([]*BTreeEntry(nil), tree.root.Entries[middle+1:]...)}
 
 	// Move children from the node to be split into left and right nodes
 	if !tree.isLeaf(tree.root) {
@@ -660,9 +665,9 @@ func (tree *BTree) splitRoot() {
 		Children: []*BTreeNode{left, right},
 	}
 
-	left.Parent  = newRoot
+	left.Parent = newRoot
 	right.Parent = newRoot
-	tree.root    = newRoot
+	tree.root = newRoot
 }
 
 func setParent(nodes []*BTreeNode, parent *BTreeNode) {
@@ -738,10 +743,10 @@ func (tree *BTree) delete(node *BTreeNode, index int) {
 	}
 
 	// deleting from an internal node
-	leftLargestNode       := tree.right(node.Children[index]) // largest node in the left sub-tree (assumed to exist)
+	leftLargestNode := tree.right(node.Children[index]) // largest node in the left sub-tree (assumed to exist)
 	leftLargestEntryIndex := len(leftLargestNode.Entries) - 1
-	node.Entries[index]    = leftLargestNode.Entries[leftLargestEntryIndex]
-	deletedKey            := leftLargestNode.Entries[leftLargestEntryIndex].Key
+	node.Entries[index] = leftLargestNode.Entries[leftLargestEntryIndex]
+	deletedKey := leftLargestNode.Entries[leftLargestEntryIndex].Key
 	tree.deleteEntry(leftLargestNode, leftLargestEntryIndex)
 	tree.rebalance(leftLargestNode, deletedKey)
 }
@@ -791,16 +796,16 @@ func (tree *BTree) rebalance(node *BTreeNode, deletedKey interface{}) {
 		// merge with right sibling
 		node.Entries = append(node.Entries, node.Parent.Entries[rightSiblingIndex-1])
 		node.Entries = append(node.Entries, rightSibling.Entries...)
-		deletedKey   = node.Parent.Entries[rightSiblingIndex-1].Key
+		deletedKey = node.Parent.Entries[rightSiblingIndex-1].Key
 		tree.deleteEntry(node.Parent, rightSiblingIndex-1)
 		tree.appendChildren(node.Parent.Children[rightSiblingIndex], node)
 		tree.deleteChild(node.Parent, rightSiblingIndex)
 	} else if leftSibling != nil {
 		// merge with left sibling
-		entries     := append([]*BTreeEntry(nil), leftSibling.Entries...)
-		entries      = append(entries, node.Parent.Entries[leftSiblingIndex])
+		entries := append([]*BTreeEntry(nil), leftSibling.Entries...)
+		entries = append(entries, node.Parent.Entries[leftSiblingIndex])
 		node.Entries = append(entries, node.Entries...)
-		deletedKey   = node.Parent.Entries[leftSiblingIndex].Key
+		deletedKey = node.Parent.Entries[leftSiblingIndex].Key
 		tree.deleteEntry(node.Parent, leftSiblingIndex)
 		tree.prependChildren(node.Parent.Children[leftSiblingIndex], node)
 		tree.deleteChild(node.Parent, leftSiblingIndex)
@@ -818,7 +823,7 @@ func (tree *BTree) rebalance(node *BTreeNode, deletedKey interface{}) {
 }
 
 func (tree *BTree) prependChildren(fromNode *BTreeNode, toNode *BTreeNode) {
-	children       := append([]*BTreeNode(nil), fromNode.Children...)
+	children := append([]*BTreeNode(nil), fromNode.Children...)
 	toNode.Children = append(children, toNode.Children...)
 	setParent(fromNode.Children, toNode)
 }
@@ -841,4 +846,9 @@ func (tree *BTree) deleteChild(node *BTreeNode, index int) {
 	copy(node.Children[index:], node.Children[index+1:])
 	node.Children[len(node.Children)-1] = nil
 	node.Children = node.Children[:len(node.Children)-1]
-}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree *BTree) MarshalJSON() ([]byte, error) {
+	return json.Marshal(tree.Map())
+}

g/container/gtree/gtree_redblacktree.go

@@ -7,7 +7,9 @@
 package gtree
 
 import (
+	"encoding/json"
 	"fmt"
+
 	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/internal/rwmutex"
 )
@@ -39,9 +41,9 @@ type RedBlackTreeNode struct {
 // NewRedBlackTree instantiates a red-black tree with the custom key comparator.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewRedBlackTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *RedBlackTree {
-	return &RedBlackTree {
-		mu        : rwmutex.New(unsafe...),
+func NewRedBlackTree(comparator func(v1, v2 interface{}) int, unsafe ...bool) *RedBlackTree {
+	return &RedBlackTree{
+		mu:         rwmutex.New(unsafe...),
 		comparator: comparator,
 	}
 }
@@ -49,7 +51,7 @@ func NewRedBlackTree(comparator func(v1, v2 interface{}) int, unsafe...bool) *Re
 // NewRedBlackTreeFrom instantiates a red-black tree with the custom key comparator and <data> map.
 // The parameter <unsafe> used to specify whether using tree in un-concurrent-safety,
 // which is false in default.
-func NewRedBlackTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe...bool) *RedBlackTree {
+func NewRedBlackTreeFrom(comparator func(v1, v2 interface{}) int, data map[interface{}]interface{}, unsafe ...bool) *RedBlackTree {
 	tree := NewRedBlackTree(comparator, unsafe...)
 	for k, v := range data {
 		tree.doSet(k, v)
@@ -86,7 +88,7 @@ func (tree *RedBlackTree) doSet(key interface{}, value interface{}) {
 	if tree.root == nil {
 		// Assert key is of comparator's type for initial tree
 		tree.comparator(key, key)
-		tree.root    = &RedBlackTreeNode{Key: key, Value: value, color: red}
+		tree.root = &RedBlackTreeNode{Key: key, Value: value, color: red}
 		insertedNode = tree.root
 	} else {
 		node := tree.root
@@ -94,26 +96,26 @@ func (tree *RedBlackTree) doSet(key interface{}, value interface{}) {
 		for loop {
 			compare := tree.comparator(key, node.Key)
 			switch {
-				case compare == 0:
-					//node.Key   = key
-					node.Value = value
-					return
-				case compare < 0:
-					if node.left == nil {
-						node.left    = &RedBlackTreeNode{Key: key, Value: value, color: red}
-						insertedNode = node.left
-						loop         = false
-					} else {
-						node = node.left
-					}
-				case compare > 0:
-					if node.right == nil {
-						node.right   = &RedBlackTreeNode{Key: key, Value: value, color: red}
-						insertedNode = node.right
-						loop         = false
-					} else {
-						node = node.right
-					}
+			case compare == 0:
+				//node.Key   = key
+				node.Value = value
+				return
+			case compare < 0:
+				if node.left == nil {
+					node.left = &RedBlackTreeNode{Key: key, Value: value, color: red}
+					insertedNode = node.left
+					loop = false
+				} else {
+					node = node.left
+				}
+			case compare > 0:
+				if node.right == nil {
+					node.right = &RedBlackTreeNode{Key: key, Value: value, color: red}
+					insertedNode = node.right
+					loop = false
+				} else {
+					node = node.right
+				}
 			}
 		}
 		insertedNode.parent = node
@@ -143,7 +145,7 @@ func (tree *RedBlackTree) doSetWithLockCheck(key interface{}, value interface{})
 	if node := tree.doSearch(key); node != nil {
 		return node.Value
 	}
-	if f, ok := value.(func() interface {}); ok {
+	if f, ok := value.(func() interface{}); ok {
 		value = f()
 	}
 	tree.doSet(key, value)
@@ -251,16 +253,16 @@ func (tree *RedBlackTree) Contains(key interface{}) bool {
 // doRemove removes the node from the tree by <key> without mutex.
 func (tree *RedBlackTree) doRemove(key interface{}) (value interface{}) {
 	child := (*RedBlackTreeNode)(nil)
-	node  := tree.doSearch(key)
+	node := tree.doSearch(key)
 	if node == nil {
 		return
 	}
 	value = node.Value
 	if node.left != nil && node.right != nil {
-		p         := node.left.maximumNode()
-		node.Key   = p.Key
+		p := node.left.maximumNode()
+		node.Key = p.Key
 		node.Value = p.Value
-		node       = p
+		node = p
 	}
 	if node.left == nil || node.right == nil {
 		if node.right == nil {
@@ -311,7 +313,7 @@ func (tree *RedBlackTree) Size() int {
 
 // Keys returns all keys in asc order.
 func (tree *RedBlackTree) Keys() []interface{} {
-	keys  := make([]interface{}, tree.Size())
+	keys := make([]interface{}, tree.Size())
 	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		keys[index] = key
@@ -324,7 +326,7 @@ func (tree *RedBlackTree) Keys() []interface{} {
 // Values returns all values in asc order based on the key.
 func (tree *RedBlackTree) Values() []interface{} {
 	values := make([]interface{}, tree.Size())
-	index  := 0
+	index := 0
 	tree.IteratorAsc(func(key, value interface{}) bool {
 		values[index] = value
 		index++
@@ -350,8 +352,8 @@ func (tree *RedBlackTree) Left() *RedBlackTreeNode {
 	node := tree.leftNode()
 	if tree.mu.IsSafe() {
 		return &RedBlackTreeNode{
-			Key   : node.Key,
-			Value : node.Value,
+			Key:   node.Key,
+			Value: node.Value,
 		}
 	}
 	return node
@@ -364,8 +366,8 @@ func (tree *RedBlackTree) Right() *RedBlackTreeNode {
 	node := tree.rightNode()
 	if tree.mu.IsSafe() {
 		return &RedBlackTreeNode{
-			Key   : node.Key,
-			Value : node.Value,
+			Key:   node.Key,
+			Value: node.Value,
 		}
 	}
 	return node
@@ -406,11 +408,13 @@ func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode, found
 	for n != nil {
 		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0: return n, true
-			case compare  < 0: n = n.left
-			case compare  > 0:
-				floor, found = n, true
-				n            = n.right
+		case compare == 0:
+			return n, true
+		case compare < 0:
+			n = n.left
+		case compare > 0:
+			floor, found = n, true
+			n = n.right
 		}
 	}
 	if found {
@@ -432,11 +436,13 @@ func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, f
 	for n != nil {
 		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0: return n, true
-			case compare  > 0: n = n.right
-			case compare  < 0:
-				ceiling, found = n, true
-				n              = n.left
+		case compare == 0:
+			return n, true
+		case compare > 0:
+			n = n.right
+		case compare < 0:
+			ceiling, found = n, true
+			n = n.left
 		}
 	}
 	if found {
@@ -446,13 +452,13 @@ func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, f
 }
 
 // Iterator is alias of IteratorAsc.
-func (tree *RedBlackTree) Iterator(f func (key, value interface{}) bool) {
+func (tree *RedBlackTree) Iterator(f func(key, value interface{}) bool) {
 	tree.IteratorAsc(f)
 }
 
 // IteratorAsc iterates the tree in ascending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *RedBlackTree) IteratorAsc(f func (key, value interface{}) bool) {
+func (tree *RedBlackTree) IteratorAsc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.leftNode()
@@ -486,7 +492,7 @@ loop:
 
 // IteratorDesc iterates the tree in descending order with given callback function <f>.
 // If <f> returns true, then it continues iterating; or false to stop.
-func (tree *RedBlackTree) IteratorDesc(f func (key, value interface{}) bool) {
+func (tree *RedBlackTree) IteratorDesc(f func(key, value interface{}) bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
 	node := tree.rightNode()
@@ -559,7 +565,7 @@ func (tree *RedBlackTree) Search(key interface{}) (value interface{}, found bool
 // or else the comparator would panic.
 //
 // If the type of value is different with key, you pass the new <comparator>.
-func (tree *RedBlackTree) Flip(comparator...func(v1, v2 interface{}) int) {
+func (tree *RedBlackTree) Flip(comparator ...func(v1, v2 interface{}) int) {
 	t := (*RedBlackTree)(nil)
 	if len(comparator) > 0 {
 		t = NewRedBlackTree(comparator[0], !tree.mu.IsSafe())
@@ -611,9 +617,12 @@ func (tree *RedBlackTree) doSearch(key interface{}) *RedBlackTreeNode {
 	for node != nil {
 		compare := tree.comparator(key, node.Key)
 		switch {
-			case compare == 0: return node
-			case compare  < 0: node = node.left
-			case compare  > 0: node = node.right
+		case compare == 0:
+			return node
+		case compare < 0:
+			node = node.left
+		case compare > 0:
+			node = node.right
 		}
 	}
 	return nil
@@ -650,7 +659,7 @@ func (tree *RedBlackTree) rotateLeft(node *RedBlackTreeNode) {
 	if right.left != nil {
 		right.left.parent = node
 	}
-	right.left  = node
+	right.left = node
 	node.parent = right
 }
 
@@ -661,7 +670,7 @@ func (tree *RedBlackTree) rotateRight(node *RedBlackTreeNode) {
 	if left.right != nil {
 		left.right.parent = node
 	}
-	left.right  = node
+	left.right = node
 	node.parent = left
 }
 
@@ -793,14 +802,14 @@ func (tree *RedBlackTree) deleteCase5(node *RedBlackTreeNode) {
 		tree.nodeColor(sibling) == black &&
 		tree.nodeColor(sibling.left) == red &&
 		tree.nodeColor(sibling.right) == black {
-		sibling.color      = red
+		sibling.color = red
 		sibling.left.color = black
 		tree.rotateRight(sibling)
 	} else if node == node.parent.right &&
 		tree.nodeColor(sibling) == black &&
 		tree.nodeColor(sibling.right) == red &&
 		tree.nodeColor(sibling.left) == black {
-		sibling.color       = red
+		sibling.color = red
 		sibling.right.color = black
 		tree.rotateLeft(sibling)
 	}
@@ -825,4 +834,9 @@ func (tree *RedBlackTree) nodeColor(node *RedBlackTreeNode) color {
 		return black
 	}
 	return node.color
-}
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (tree *RedBlackTree) MarshalJSON() ([]byte, error) {
+	return json.Marshal(tree.Map())
+}

g/container/gtree/gtree_z_avl_tree_test.go

@@ -7,13 +7,15 @@
 package gtree_test
 
 import (
+	"fmt"
+	"testing"
+
 	"github.com/gogf/gf/g/container/gtree"
+	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/test/gtest"
 	"github.com/gogf/gf/g/util/gutil"
-	"testing"
 )
 
-
 func Test_AVLTree_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		m := gtree.NewAVLTree(gutil.ComparatorString)
@@ -24,6 +26,7 @@ func Test_AVLTree_Basic(t *testing.T) {
 		gtest.Assert(m.Size(), 1)
 		gtest.Assert(m.IsEmpty(), false)
 
+		gtest.Assert(m.GetOrSet("key2", "val2"), "val2")
 		gtest.Assert(m.GetOrSet("key2", "val2"), "val2")
 		gtest.Assert(m.SetIfNotExist("key2", "val2"), false)
 
@@ -37,9 +40,14 @@ func Test_AVLTree_Basic(t *testing.T) {
 		gtest.AssertIN("val3", m.Values())
 		gtest.AssertIN("val1", m.Values())
 
+		m.Sets(map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
+
 		m.Flip()
 		gtest.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
 
+		m.Flip(gutil.ComparatorString)
+		gtest.Assert(m.Map(), map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
+
 		m.Clear()
 		gtest.Assert(m.Size(), 0)
 		gtest.Assert(m.IsEmpty(), true)
@@ -49,14 +57,45 @@ func Test_AVLTree_Basic(t *testing.T) {
 	})
 }
 func Test_AVLTree_Set_Fun(t *testing.T) {
-	m := gtree.NewAVLTree(gutil.ComparatorString)
-	m.GetOrSetFunc("fun", getValue)
-	m.GetOrSetFuncLock("funlock", getValue)
-	gtest.Assert(m.Get("funlock"), 3)
-	gtest.Assert(m.Get("fun"), 3)
-	m.GetOrSetFunc("fun", getValue)
-	gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
-	gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+	//GetOrSetFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTree(gutil.ComparatorString)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+	//SetIfNotExistFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTree(gutil.ComparatorString)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), true)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), true)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+
+}
+
+func Test_AVLTree_Get_Set_Var(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTree(gutil.ComparatorString)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), true)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), false)
+		gtest.AssertEQ(m.GetVarOrSet("key1", "val1"), gvar.New("val1", true))
+		gtest.AssertEQ(m.GetVar("key1"), gvar.New("val1", true))
+	})
+
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTree(gutil.ComparatorString)
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+	})
 }
 
 func Test_AVLTree_Batch(t *testing.T) {
@@ -66,27 +105,61 @@ func Test_AVLTree_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_AVLTree_Iterator(t *testing.T){
-	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
+
+func Test_AVLTree_Iterator(t *testing.T) {
+	keys := []string{"1", "key1", "key2", "key3", "key4"}
+	keyLen := len(keys)
+	index := 0
+
+	expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
 
 	m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect)
 	m.Iterator(func(k interface{}, v interface{}) bool {
+		gtest.Assert(k, keys[index])
+		index++
 		gtest.Assert(expect[k], v)
 		return true
 	})
-	// 断言返回值对遍历控制
-	i := 0
-	j := 0
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		i++
+
+	m.IteratorDesc(func(k interface{}, v interface{}) bool {
+		index--
+		gtest.Assert(k, keys[index])
+		gtest.Assert(expect[k], v)
 		return true
 	})
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		j++
-		return false
+
+	m.Print()
+	// 断言返回值对遍历控制
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
 	})
-	gtest.Assert(i, 2)
-	gtest.Assert(j, 1)
+
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
+	})
+
 }
 
 func Test_AVLTree_Clone(t *testing.T) {
@@ -100,4 +173,78 @@ func Test_AVLTree_Clone(t *testing.T) {
 	m_clone.Remove("key1")
 	//修改clone map,原 map 不影响
 	gtest.AssertIN("key1", m.Keys())
-}
+}
+
+func Test_AVLTree_LRNode(t *testing.T) {
+	expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
+	//safe
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+	//unsafe
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTreeFrom(gutil.ComparatorString, expect, true)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+}
+
+func Test_AVLTree_CeilingFloor(t *testing.T) {
+	expect := map[interface{}]interface{}{
+		20: "val20",
+		6:  "val6",
+		10: "val10",
+		12: "val12",
+		1:  "val1",
+		15: "val15",
+		19: "val19",
+		8:  "val8",
+		4:  "val4"}
+	//found and eq
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(8)
+		gtest.Assert(cf, true)
+		gtest.Assert(c.Value, "val8")
+		f, ff := m.Floor(20)
+		gtest.Assert(ff, true)
+		gtest.Assert(f.Value, "val20")
+	})
+	//found and neq
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(9)
+		gtest.Assert(cf, true)
+		gtest.Assert(c.Value, "val10")
+		f, ff := m.Floor(5)
+		gtest.Assert(ff, true)
+		gtest.Assert(f.Value, "val4")
+	})
+	//nofound
+	gtest.Case(t, func() {
+		m := gtree.NewAVLTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(21)
+		gtest.Assert(cf, false)
+		gtest.Assert(c, nil)
+		f, ff := m.Floor(-1)
+		gtest.Assert(ff, false)
+		gtest.Assert(f, nil)
+	})
+}
+
+func Test_AVLTree_Remove(t *testing.T) {
+	m := gtree.NewAVLTree(gutil.ComparatorInt)
+	for i := 1; i <= 50; i++ {
+		m.Set(i, fmt.Sprintf("val%d", i))
+	}
+	expect := m.Map()
+	gtest.Case(t, func() {
+		for k, v := range expect {
+			m1 := m.Clone()
+			gtest.Assert(m1.Remove(k), v)
+			gtest.Assert(m1.Remove(k), nil)
+		}
+	})
+}

g/container/gtree/gtree_z_b_tree_test.go

@@ -7,16 +7,22 @@
 package gtree_test
 
 import (
+	"fmt"
+	"testing"
+
 	"github.com/gogf/gf/g/container/gtree"
+	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/test/gtest"
 	"github.com/gogf/gf/g/util/gutil"
-	"testing"
 )
 
 func Test_BTree_Basic(t *testing.T) {
 	gtest.Case(t, func() {
 		m := gtree.NewBTree(3, gutil.ComparatorString)
 		m.Set("key1", "val1")
+
+		gtest.Assert(m.Height(), 1)
+
 		gtest.Assert(m.Keys(), []interface{}{"key1"})
 
 		gtest.Assert(m.Get("key1"), "val1")
@@ -44,15 +50,47 @@ func Test_BTree_Basic(t *testing.T) {
 		gtest.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
 	})
 }
+
 func Test_BTree_Set_Fun(t *testing.T) {
-	m := gtree.NewBTree(3, gutil.ComparatorString)
-	m.GetOrSetFunc("fun", getValue)
-	m.GetOrSetFuncLock("funlock", getValue)
-	gtest.Assert(m.Get("funlock"), 3)
-	gtest.Assert(m.Get("fun"), 3)
-	m.GetOrSetFunc("fun", getValue)
-	gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
-	gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+	//GetOrSetFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewBTree(3, gutil.ComparatorString)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+	//SetIfNotExistFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewBTree(3, gutil.ComparatorString)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), true)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), true)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+
+}
+
+func Test_BTree_Get_Set_Var(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gtree.NewBTree(3, gutil.ComparatorString)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), true)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), false)
+		gtest.AssertEQ(m.GetVarOrSet("key1", "val1"), gvar.New("val1", true))
+		gtest.AssertEQ(m.GetVar("key1"), gvar.New("val1", true))
+	})
+
+	gtest.Case(t, func() {
+		m := gtree.NewBTree(3, gutil.ComparatorString)
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+	})
 }
 
 func Test_BTree_Batch(t *testing.T) {
@@ -62,27 +100,61 @@ func Test_BTree_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_BTree_Iterator(t *testing.T){
-	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
+
+func Test_BTree_Iterator(t *testing.T) {
+	keys := []string{"1", "key1", "key2", "key3", "key4"}
+	keyLen := len(keys)
+	index := 0
+
+	expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
 
 	m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect)
 	m.Iterator(func(k interface{}, v interface{}) bool {
+		gtest.Assert(k, keys[index])
+		index++
 		gtest.Assert(expect[k], v)
 		return true
 	})
-	// 断言返回值对遍历控制
-	i := 0
-	j := 0
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		i++
+
+	m.IteratorDesc(func(k interface{}, v interface{}) bool {
+		index--
+		gtest.Assert(k, keys[index])
+		gtest.Assert(expect[k], v)
 		return true
 	})
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		j++
-		return false
+
+	m.Print()
+	// 断言返回值对遍历控制
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
 	})
-	gtest.Assert(i, 2)
-	gtest.Assert(j, 1)
+
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
+	})
+
 }
 
 func Test_BTree_Clone(t *testing.T) {
@@ -96,4 +168,35 @@ func Test_BTree_Clone(t *testing.T) {
 	m_clone.Remove("key1")
 	//修改clone map,原 map 不影响
 	gtest.AssertIN("key1", m.Keys())
-}
+}
+
+func Test_BTree_LRNode(t *testing.T) {
+	expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
+	//safe
+	gtest.Case(t, func() {
+		m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+	//unsafe
+	gtest.Case(t, func() {
+		m := gtree.NewBTreeFrom(3, gutil.ComparatorString, expect, true)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+}
+
+func Test_BTree_Remove(t *testing.T) {
+	m := gtree.NewBTree(3, gutil.ComparatorInt)
+	for i := 1; i <= 100; i++ {
+		m.Set(i, fmt.Sprintf("val%d", i))
+	}
+	expect := m.Map()
+	gtest.Case(t, func() {
+		for k, v := range expect {
+			m1 := m.Clone()
+			gtest.Assert(m1.Remove(k), v)
+			gtest.Assert(m1.Remove(k), nil)
+		}
+	})
+}

g/container/gtree/gtree_z_redblack_tree_test.go

@@ -7,10 +7,13 @@
 package gtree_test
 
 import (
+	"fmt"
+	"testing"
+
 	"github.com/gogf/gf/g/container/gtree"
+	"github.com/gogf/gf/g/container/gvar"
 	"github.com/gogf/gf/g/test/gtest"
 	"github.com/gogf/gf/g/util/gutil"
-	"testing"
 )
 
 func getValue() interface{} {
@@ -27,6 +30,7 @@ func Test_RedBlackTree_Basic(t *testing.T) {
 		gtest.Assert(m.Size(), 1)
 		gtest.Assert(m.IsEmpty(), false)
 
+		gtest.Assert(m.GetOrSet("key2", "val2"), "val2")
 		gtest.Assert(m.GetOrSet("key2", "val2"), "val2")
 		gtest.Assert(m.SetIfNotExist("key2", "val2"), false)
 
@@ -40,9 +44,14 @@ func Test_RedBlackTree_Basic(t *testing.T) {
 		gtest.AssertIN("val3", m.Values())
 		gtest.AssertIN("val1", m.Values())
 
+		m.Sets(map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
+
 		m.Flip()
 		gtest.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
 
+		m.Flip(gutil.ComparatorString)
+		gtest.Assert(m.Map(), map[interface{}]interface{}{"key3": "val3", "key1": "val1"})
+
 		m.Clear()
 		gtest.Assert(m.Size(), 0)
 		gtest.Assert(m.IsEmpty(), true)
@@ -51,15 +60,47 @@ func Test_RedBlackTree_Basic(t *testing.T) {
 		gtest.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
 	})
 }
+
 func Test_RedBlackTree_Set_Fun(t *testing.T) {
-	m := gtree.NewRedBlackTree(gutil.ComparatorString)
-	m.GetOrSetFunc("fun", getValue)
-	m.GetOrSetFuncLock("funlock", getValue)
-	gtest.Assert(m.Get("funlock"), 3)
-	gtest.Assert(m.Get("fun"), 3)
-	m.GetOrSetFunc("fun", getValue)
-	gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
-	gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+	//GetOrSetFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTree(gutil.ComparatorString)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFunc("fun", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.GetOrSetFuncLock("funlock", getValue), 3)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+	//SetIfNotExistFunc lock or unlock
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTree(gutil.ComparatorString)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), true)
+		gtest.Assert(m.SetIfNotExistFunc("fun", getValue), false)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), true)
+		gtest.Assert(m.SetIfNotExistFuncLock("funlock", getValue), false)
+		gtest.Assert(m.Get("funlock"), 3)
+		gtest.Assert(m.Get("fun"), 3)
+	})
+
+}
+
+func Test_RedBlackTree_Get_Set_Var(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTree(gutil.ComparatorString)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), true)
+		gtest.AssertEQ(m.SetIfNotExist("key1", "val1"), false)
+		gtest.AssertEQ(m.GetVarOrSet("key1", "val1"), gvar.New("val1", true))
+		gtest.AssertEQ(m.GetVar("key1"), gvar.New("val1", true))
+	})
+
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTree(gutil.ComparatorString)
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFunc("fun", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+		gtest.AssertEQ(m.GetVarOrSetFuncLock("funlock", getValue), gvar.New(3, true))
+	})
 }
 
 func Test_RedBlackTree_Batch(t *testing.T) {
@@ -69,27 +110,61 @@ func Test_RedBlackTree_Batch(t *testing.T) {
 	m.Removes([]interface{}{"key1", 1})
 	gtest.Assert(m.Map(), map[interface{}]interface{}{"key2": "val2", "key3": "val3"})
 }
-func Test_RedBlackTree_Iterator(t *testing.T){
-	expect := map[interface{}]interface{}{1: 1, "key1": "val1"}
+
+func Test_RedBlackTree_Iterator(t *testing.T) {
+	keys := []string{"1", "key1", "key2", "key3", "key4"}
+	keyLen := len(keys)
+	index := 0
+
+	expect := map[interface{}]interface{}{"key4": "val4", 1: 1, "key1": "val1", "key2": "val2", "key3": "val3"}
 
 	m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, expect)
 	m.Iterator(func(k interface{}, v interface{}) bool {
+		gtest.Assert(k, keys[index])
+		index++
 		gtest.Assert(expect[k], v)
 		return true
 	})
-	// 断言返回值对遍历控制
-	i := 0
-	j := 0
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		i++
+
+	m.IteratorDesc(func(k interface{}, v interface{}) bool {
+		index--
+		gtest.Assert(k, keys[index])
+		gtest.Assert(expect[k], v)
 		return true
 	})
-	m.Iterator(func(k interface{}, v interface{}) bool {
-		j++
-		return false
+
+	m.Print()
+	// 断言返回值对遍历控制
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.Iterator(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
 	})
-	gtest.Assert(i, 2)
-	gtest.Assert(j, 1)
+
+	gtest.Case(t, func() {
+		i := 0
+		j := 0
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			i++
+			return true
+		})
+		m.IteratorDesc(func(k interface{}, v interface{}) bool {
+			j++
+			return false
+		})
+		gtest.Assert(i, keyLen)
+		gtest.Assert(j, 1)
+	})
+
 }
 
 func Test_RedBlackTree_Clone(t *testing.T) {
@@ -103,4 +178,78 @@ func Test_RedBlackTree_Clone(t *testing.T) {
 	m_clone.Remove("key1")
 	//修改clone map,原 map 不影响
 	gtest.AssertIN("key1", m.Keys())
-}
+}
+
+func Test_RedBlackTree_LRNode(t *testing.T) {
+	expect := map[interface{}]interface{}{"key4": "val4", "key1": "val1", "key2": "val2", "key3": "val3"}
+	//safe
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, expect)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+	//unsafe
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTreeFrom(gutil.ComparatorString, expect, true)
+		gtest.Assert(m.Left().Key, "key1")
+		gtest.Assert(m.Right().Key, "key4")
+	})
+}
+
+func Test_RedBlackTree_CeilingFloor(t *testing.T) {
+	expect := map[interface{}]interface{}{
+		20: "val20",
+		6:  "val6",
+		10: "val10",
+		12: "val12",
+		1:  "val1",
+		15: "val15",
+		19: "val19",
+		8:  "val8",
+		4:  "val4"}
+	//found and eq
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(8)
+		gtest.Assert(cf, true)
+		gtest.Assert(c.Value, "val8")
+		f, ff := m.Floor(20)
+		gtest.Assert(ff, true)
+		gtest.Assert(f.Value, "val20")
+	})
+	//found and neq
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(9)
+		gtest.Assert(cf, true)
+		gtest.Assert(c.Value, "val10")
+		f, ff := m.Floor(5)
+		gtest.Assert(ff, true)
+		gtest.Assert(f.Value, "val4")
+	})
+	//nofound
+	gtest.Case(t, func() {
+		m := gtree.NewRedBlackTreeFrom(gutil.ComparatorInt, expect)
+		c, cf := m.Ceiling(21)
+		gtest.Assert(cf, false)
+		gtest.Assert(c, nil)
+		f, ff := m.Floor(-1)
+		gtest.Assert(ff, false)
+		gtest.Assert(f, nil)
+	})
+}
+
+func Test_RedBlackTree_Remove(t *testing.T) {
+	m := gtree.NewRedBlackTree(gutil.ComparatorInt)
+	for i := 1; i <= 100; i++ {
+		m.Set(i, fmt.Sprintf("val%d", i))
+	}
+	expect := m.Map()
+	gtest.Case(t, func() {
+		for k, v := range expect {
+			m1 := m.Clone()
+			gtest.Assert(m1.Remove(k), v)
+			gtest.Assert(m1.Remove(k), nil)
+		}
+	})
+}

g/container/gtype/bool.go

@@ -7,43 +7,55 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Bool struct {
-    value int32
+	value int32
 }
 
 // NewBool returns a concurrent-safe object for bool type,
 // with given initial value <value>.
-func NewBool(value...bool) *Bool {
-    t := &Bool{}
-    if len(value) > 0 {
-        if value[0] {
-            t.value = 1
-        } else {
-            t.value = 0
-        }
-    }
-    return t
+func NewBool(value ...bool) *Bool {
+	t := &Bool{}
+	if len(value) > 0 {
+		if value[0] {
+			t.value = 1
+		} else {
+			t.value = 0
+		}
+	}
+	return t
 }
 
 // Clone clones and returns a new concurrent-safe object for bool type.
-func (t *Bool) Clone() *Bool {
-    return NewBool(t.Val())
+func (v *Bool) Clone() *Bool {
+	return NewBool(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Bool) Set(value bool) (old bool) {
-    if value {
-        old = atomic.SwapInt32(&t.value, 1) == 1
-    } else {
-        old = atomic.SwapInt32(&t.value, 0) == 1
-    }
-    return
+func (v *Bool) Set(value bool) (old bool) {
+	if value {
+		old = atomic.SwapInt32(&v.value, 1) == 1
+	} else {
+		old = atomic.SwapInt32(&v.value, 0) == 1
+	}
+	return
 }
 
 // Val atomically loads t.valueue.
-func (t *Bool) Val() bool {
-    return atomic.LoadInt32(&t.value) > 0
+func (v *Bool) Val() bool {
+	return atomic.LoadInt32(&v.value) > 0
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Bool) Cas(old, new bool) bool {
+	var oldInt32, newInt32 int32
+	if old {
+		oldInt32 = 1
+	}
+	if new {
+		newInt32 = 1
+	}
+	return atomic.CompareAndSwapInt32(&v.value, oldInt32, newInt32)
 }

g/container/gtype/byte.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Byte struct {
@@ -16,31 +16,36 @@ type Byte struct {
 
 // NewByte returns a concurrent-safe object for byte type,
 // with given initial value <value>.
-func NewByte(value...byte) *Byte {
-    if len(value) > 0 {
-        return &Byte{
-	        value : int32(value[0]),
+func NewByte(value ...byte) *Byte {
+	if len(value) > 0 {
+		return &Byte{
+			value: int32(value[0]),
 		}
-    }
-    return &Byte{}
+	}
+	return &Byte{}
 }
 
 // Clone clones and returns a new concurrent-safe object for byte type.
-func (t *Byte) Clone() *Byte {
-    return NewByte(t.Val())
+func (v *Byte) Clone() *Byte {
+	return NewByte(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Byte) Set(value byte) (old byte) {
-    return byte(atomic.SwapInt32(&t.value, int32(value)))
+func (v *Byte) Set(value byte) (old byte) {
+	return byte(atomic.SwapInt32(&v.value, int32(value)))
 }
 
 // Val atomically loads t.value.
-func (t *Byte) Val() byte {
-    return byte(atomic.LoadInt32(&t.value))
+func (v *Byte) Val() byte {
+	return byte(atomic.LoadInt32(&v.value))
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Byte) Add(delta int) (new byte) {
-    return byte(atomic.AddInt32(&t.value, int32(delta)))
+func (v *Byte) Add(delta byte) (new byte) {
+	return byte(atomic.AddInt32(&v.value, int32(delta)))
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Byte) Cas(old, new byte) bool {
+	return atomic.CompareAndSwapInt32(&v.value, int32(old), int32(new))
 }

g/container/gtype/bytes.go

@@ -14,31 +14,31 @@ type Bytes struct {
 
 // NewBytes returns a concurrent-safe object for []byte type,
 // with given initial value <value>.
-func NewBytes(value...[]byte) *Bytes {
-    t := &Bytes{}
-    if len(value) > 0 {
-        t.value.Store(value[0])
-    }
-    return t
+func NewBytes(value ...[]byte) *Bytes {
+	t := &Bytes{}
+	if len(value) > 0 {
+		t.value.Store(value[0])
+	}
+	return t
 }
 
 // Clone clones and returns a new concurrent-safe object for []byte type.
-func (t *Bytes) Clone() *Bytes {
-    return NewBytes(t.Val())
+func (v *Bytes) Clone() *Bytes {
+	return NewBytes(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
 // Note: The parameter <value> cannot be nil.
-func (t *Bytes) Set(value []byte) (old []byte) {
-    old = t.Val()
-    t.value.Store(value)
-    return
+func (v *Bytes) Set(value []byte) (old []byte) {
+	old = v.Val()
+	v.value.Store(value)
+	return
 }
 
 // Val atomically loads t.value.
-func (t *Bytes) Val() []byte {
-    if s := t.value.Load(); s != nil {
-        return s.([]byte)
-    }
-    return nil
+func (v *Bytes) Val() []byte {
+	if s := v.value.Load(); s != nil {
+		return s.([]byte)
+	}
+	return nil
 }

g/container/gtype/float32.go

@@ -18,37 +18,37 @@ type Float32 struct {
 
 // NewFloat32 returns a concurrent-safe object for float32 type,
 // with given initial value <value>.
-func NewFloat32(value...float32) *Float32 {
-    if len(value) > 0 {
-        return &Float32{
-	        value : math.Float32bits(value[0]),
+func NewFloat32(value ...float32) *Float32 {
+	if len(value) > 0 {
+		return &Float32{
+			value: math.Float32bits(value[0]),
 		}
-    }
-    return &Float32{}
+	}
+	return &Float32{}
 }
 
 // Clone clones and returns a new concurrent-safe object for float32 type.
-func (t *Float32) Clone() *Float32 {
-    return NewFloat32(t.Val())
+func (v *Float32) Clone() *Float32 {
+	return NewFloat32(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Float32) Set(value float32) (old float32) {
-    return math.Float32frombits(atomic.SwapUint32(&t.value, math.Float32bits(value)))
+func (v *Float32) Set(value float32) (old float32) {
+	return math.Float32frombits(atomic.SwapUint32(&v.value, math.Float32bits(value)))
 }
 
 // Val atomically loads t.value.
-func (t *Float32) Val() float32 {
-    return math.Float32frombits(atomic.LoadUint32(&t.value))
+func (v *Float32) Val() float32 {
+	return math.Float32frombits(atomic.LoadUint32(&v.value))
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Float32) Add(delta float32) (new float32) {
+func (v *Float32) Add(delta float32) (new float32) {
 	for {
-		old := math.Float32frombits(t.value)
-		new  = old + delta
+		old := math.Float32frombits(v.value)
+		new = old + delta
 		if atomic.CompareAndSwapUint32(
-			(*uint32)(unsafe.Pointer(&t.value)),
+			(*uint32)(unsafe.Pointer(&v.value)),
 			math.Float32bits(old),
 			math.Float32bits(new),
 		) {
@@ -56,4 +56,9 @@ func (t *Float32) Add(delta float32) (new float32) {
 		}
 	}
 	return
-}
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Float32) Cas(old, new float32) bool {
+	return atomic.CompareAndSwapUint32(&v.value, uint32(old), uint32(new))
+}

g/container/gtype/float64.go

@@ -18,37 +18,37 @@ type Float64 struct {
 
 // NewFloat64 returns a concurrent-safe object for float64 type,
 // with given initial value <value>.
-func NewFloat64(value...float64) *Float64 {
-    if len(value) > 0 {
-        return &Float64{
-	        value : math.Float64bits(value[0]),
+func NewFloat64(value ...float64) *Float64 {
+	if len(value) > 0 {
+		return &Float64{
+			value: math.Float64bits(value[0]),
 		}
-    }
-    return &Float64{}
+	}
+	return &Float64{}
 }
 
 // Clone clones and returns a new concurrent-safe object for float64 type.
-func (t *Float64) Clone() *Float64 {
-    return NewFloat64(t.Val())
+func (v *Float64) Clone() *Float64 {
+	return NewFloat64(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Float64) Set(value float64) (old float64) {
-    return math.Float64frombits(atomic.SwapUint64(&t.value, math.Float64bits(value)))
+func (v *Float64) Set(value float64) (old float64) {
+	return math.Float64frombits(atomic.SwapUint64(&v.value, math.Float64bits(value)))
 }
 
 // Val atomically loads t.value.
-func (t *Float64) Val() float64 {
-    return math.Float64frombits(atomic.LoadUint64(&t.value))
+func (v *Float64) Val() float64 {
+	return math.Float64frombits(atomic.LoadUint64(&v.value))
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Float64) Add(delta float64) (new float64) {
+func (v *Float64) Add(delta float64) (new float64) {
 	for {
-		old := math.Float64frombits(t.value)
-		new  = old + delta
+		old := math.Float64frombits(v.value)
+		new = old + delta
 		if atomic.CompareAndSwapUint64(
-			(*uint64)(unsafe.Pointer(&t.value)),
+			(*uint64)(unsafe.Pointer(&v.value)),
 			math.Float64bits(old),
 			math.Float64bits(new),
 		) {
@@ -57,3 +57,8 @@ func (t *Float64) Add(delta float64) (new float64) {
 	}
 	return
 }
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Float64) Cas(old, new float64) bool {
+	return atomic.CompareAndSwapUint64(&v.value, uint64(old), uint64(new))
+}

g/container/gtype/gtype.go

@@ -10,6 +10,6 @@ package gtype
 type Type = Interface
 
 // See NewInterface.
-func New(value ... interface{}) *Type {
-    return NewInterface(value...)
-}
+func New(value ...interface{}) *Type {
+	return NewInterface(value...)
+}

g/container/gtype/gtype_test.go

@@ -9,203 +9,189 @@
 package gtype
 
 import (
-    "testing"
-    "strconv"
-    "github.com/gogf/gf/g/encoding/gbinary"
-    "sync/atomic"
+	"github.com/gogf/gf/g/encoding/gbinary"
+	"strconv"
+	"sync/atomic"
+	"testing"
 )
 
-var it    = NewInt()
-var it32  = NewInt32()
-var it64  = NewInt64()
-var uit   = NewUint()
+var it = NewInt()
+var it32 = NewInt32()
+var it64 = NewInt64()
+var uit = NewUint()
 var uit32 = NewUint32()
 var uit64 = NewUint64()
-var bl    = NewBool()
+var bl = NewBool()
 var bytes = NewBytes()
-var str   = NewString()
-var inf   = NewInterface()
+var str = NewString()
+var inf = NewInterface()
 
-var at    = atomic.Value{}
+var at = atomic.Value{}
 
 func BenchmarkInt_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        it.Set(i)
-    }
+	for i := 0; i < b.N; i++ {
+		it.Set(i)
+	}
 }
 
 func BenchmarkInt_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        it.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		it.Val()
+	}
 }
 
 func BenchmarkInt_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        it.Add(i)
-    }
+	for i := 0; i < b.N; i++ {
+		it.Add(i)
+	}
 }
 
 func BenchmarkInt32_Set(b *testing.B) {
-    for i := int32(0); i < int32(b.N); i++ {
-        it32.Set(i)
-    }
+	for i := int32(0); i < int32(b.N); i++ {
+		it32.Set(i)
+	}
 }
 
 func BenchmarkInt32_Val(b *testing.B) {
-    for i := int32(0); i < int32(b.N); i++ {
-        it32.Val()
-    }
+	for i := int32(0); i < int32(b.N); i++ {
+		it32.Val()
+	}
 }
 
 func BenchmarkInt32_Add(b *testing.B) {
-    for i := int32(0); i < int32(b.N); i++ {
-        it32.Add(i)
-    }
+	for i := int32(0); i < int32(b.N); i++ {
+		it32.Add(i)
+	}
 }
 
 func BenchmarkInt64_Set(b *testing.B) {
-    for i := int64(0); i < int64(b.N); i++ {
-        it64.Set(i)
-    }
+	for i := int64(0); i < int64(b.N); i++ {
+		it64.Set(i)
+	}
 }
 
 func BenchmarkInt64_Val(b *testing.B) {
-    for i := int64(0); i < int64(b.N); i++ {
-        it64.Val()
-    }
+	for i := int64(0); i < int64(b.N); i++ {
+		it64.Val()
+	}
 }
 
 func BenchmarkInt64_Add(b *testing.B) {
-    for i := int64(0); i < int64(b.N); i++ {
-        it64.Add(i)
-    }
+	for i := int64(0); i < int64(b.N); i++ {
+		it64.Add(i)
+	}
 }
 
-
-
 func BenchmarkUint_Set(b *testing.B) {
-    for i := uint(0); i < uint(b.N); i++ {
-        uit.Set(i)
-    }
+	for i := uint(0); i < uint(b.N); i++ {
+		uit.Set(i)
+	}
 }
 
 func BenchmarkUint_Val(b *testing.B) {
-    for i := uint(0); i < uint(b.N); i++ {
-        uit.Val()
-    }
+	for i := uint(0); i < uint(b.N); i++ {
+		uit.Val()
+	}
 }
 
 func BenchmarkUint_Add(b *testing.B) {
-    for i := uint(0); i < uint(b.N); i++ {
-        uit.Add(i)
-    }
+	for i := uint(0); i < uint(b.N); i++ {
+		uit.Add(i)
+	}
 }
 
-
-
 func BenchmarkUint32_Set(b *testing.B) {
-    for i := uint32(0); i < uint32(b.N); i++ {
-        uit32.Set(i)
-    }
+	for i := uint32(0); i < uint32(b.N); i++ {
+		uit32.Set(i)
+	}
 }
 
 func BenchmarkUint32_Val(b *testing.B) {
-    for i := uint32(0); i < uint32(b.N); i++ {
-        uit32.Val()
-    }
+	for i := uint32(0); i < uint32(b.N); i++ {
+		uit32.Val()
+	}
 }
 
 func BenchmarkUint32_Add(b *testing.B) {
-    for i := uint32(0); i < uint32(b.N); i++ {
-        uit32.Add(i)
-    }
+	for i := uint32(0); i < uint32(b.N); i++ {
+		uit32.Add(i)
+	}
 }
 
-
 func BenchmarkUint64_Set(b *testing.B) {
-    for i := uint64(0); i < uint64(b.N); i++ {
-        uit64.Set(i)
-    }
+	for i := uint64(0); i < uint64(b.N); i++ {
+		uit64.Set(i)
+	}
 }
 
 func BenchmarkUint64_Val(b *testing.B) {
-    for i := uint64(0); i < uint64(b.N); i++ {
-        uit64.Val()
-    }
+	for i := uint64(0); i < uint64(b.N); i++ {
+		uit64.Val()
+	}
 }
 
 func BenchmarkUint64_Add(b *testing.B) {
-    for i := uint64(0); i < uint64(b.N); i++ {
-        uit64.Add(i)
-    }
+	for i := uint64(0); i < uint64(b.N); i++ {
+		uit64.Add(i)
+	}
 }
 
-
-
 func BenchmarkBool_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        bl.Set(true)
-    }
+	for i := 0; i < b.N; i++ {
+		bl.Set(true)
+	}
 }
 
 func BenchmarkBool_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        bl.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		bl.Val()
+	}
 }
 
-
-
 func BenchmarkString_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        str.Set(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		str.Set(strconv.Itoa(i))
+	}
 }
 
 func BenchmarkString_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        str.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		str.Val()
+	}
 }
 
-
-
 func BenchmarkBytes_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        bytes.Set(gbinary.EncodeInt(i))
-    }
+	for i := 0; i < b.N; i++ {
+		bytes.Set(gbinary.EncodeInt(i))
+	}
 }
 
 func BenchmarkBytes_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        bytes.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		bytes.Val()
+	}
 }
 
-
 func BenchmarkInterface_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        inf.Set(i)
-    }
+	for i := 0; i < b.N; i++ {
+		inf.Set(i)
+	}
 }
 
 func BenchmarkInterface_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        inf.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		inf.Val()
+	}
 }
 
-
 func BenchmarkAtomicValue_Store(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        at.Store(i)
-    }
+	for i := 0; i < b.N; i++ {
+		at.Store(i)
+	}
 }
 
 func BenchmarkAtomicValue_Load(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        at.Load()
-    }
+	for i := 0; i < b.N; i++ {
+		at.Load()
+	}
 }
-

g/container/gtype/int.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Int struct {
@@ -16,31 +16,36 @@ type Int struct {
 
 // NewInt returns a concurrent-safe object for int type,
 // with given initial value <value>.
-func NewInt(value...int) *Int {
-    if len(value) > 0 {
-        return &Int{
-	        value : int64(value[0]),
+func NewInt(value ...int) *Int {
+	if len(value) > 0 {
+		return &Int{
+			value: int64(value[0]),
 		}
-    }
-    return &Int{}
+	}
+	return &Int{}
 }
 
 // Clone clones and returns a new concurrent-safe object for int type.
-func (t *Int) Clone() *Int {
-    return NewInt(t.Val())
+func (v *Int) Clone() *Int {
+	return NewInt(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Int) Set(value int) (old int) {
-    return int(atomic.SwapInt64(&t.value, int64(value)))
+func (v *Int) Set(value int) (old int) {
+	return int(atomic.SwapInt64(&v.value, int64(value)))
 }
 
 // Val atomically loads t.value.
-func (t *Int) Val() int {
-    return int(atomic.LoadInt64(&t.value))
+func (v *Int) Val() int {
+	return int(atomic.LoadInt64(&v.value))
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Int) Add(delta int) (new int) {
-    return int(atomic.AddInt64(&t.value, int64(delta)))
-}
+func (v *Int) Add(delta int) (new int) {
+	return int(atomic.AddInt64(&v.value, int64(delta)))
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Int) Cas(old, new int) bool {
+	return atomic.CompareAndSwapInt64(&v.value, int64(old), int64(new))
+}

g/container/gtype/int32.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Int32 struct {
@@ -16,31 +16,36 @@ type Int32 struct {
 
 // NewInt32 returns a concurrent-safe object for int32 type,
 // with given initial value <value>.
-func NewInt32(value...int32) *Int32 {
-    if len(value) > 0 {
-        return &Int32{
-	        value : value[0],
+func NewInt32(value ...int32) *Int32 {
+	if len(value) > 0 {
+		return &Int32{
+			value: value[0],
 		}
-    }
-    return &Int32{}
+	}
+	return &Int32{}
 }
 
 // Clone clones and returns a new concurrent-safe object for int32 type.
-func (t *Int32) Clone() *Int32 {
-    return NewInt32(t.Val())
+func (v *Int32) Clone() *Int32 {
+	return NewInt32(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Int32) Set(value int32) (old int32) {
-    return atomic.SwapInt32(&t.value, value)
+func (v *Int32) Set(value int32) (old int32) {
+	return atomic.SwapInt32(&v.value, value)
 }
 
 // Val atomically loads t.value.
-func (t *Int32) Val() int32 {
-    return atomic.LoadInt32(&t.value)
+func (v *Int32) Val() int32 {
+	return atomic.LoadInt32(&v.value)
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Int32) Add(delta int32) (new int32) {
-    return atomic.AddInt32(&t.value, delta)
-}
+func (v *Int32) Add(delta int32) (new int32) {
+	return atomic.AddInt32(&v.value, delta)
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Int32) Cas(old, new int32) bool {
+	return atomic.CompareAndSwapInt32(&v.value, old, new)
+}

g/container/gtype/int64.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Int64 struct {
@@ -16,31 +16,36 @@ type Int64 struct {
 
 // NewInt64 returns a concurrent-safe object for int64 type,
 // with given initial value <value>.
-func NewInt64(value...int64) *Int64 {
-    if len(value) > 0 {
-        return &Int64{
-	        value : value[0],
+func NewInt64(value ...int64) *Int64 {
+	if len(value) > 0 {
+		return &Int64{
+			value: value[0],
 		}
-    }
-    return &Int64{}
+	}
+	return &Int64{}
 }
 
 // Clone clones and returns a new concurrent-safe object for int64 type.
-func (t *Int64) Clone() *Int64 {
-    return NewInt64(t.Val())
+func (v *Int64) Clone() *Int64 {
+	return NewInt64(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Int64) Set(value int64) (old int64) {
-    return atomic.SwapInt64(&t.value, value)
+func (v *Int64) Set(value int64) (old int64) {
+	return atomic.SwapInt64(&v.value, value)
 }
 
 // Val atomically loads t.value.
-func (t *Int64) Val() int64 {
-    return atomic.LoadInt64(&t.value)
+func (v *Int64) Val() int64 {
+	return atomic.LoadInt64(&v.value)
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Int64) Add(delta int64) int64 {
-    return atomic.AddInt64(&t.value, delta)
-}
+func (v *Int64) Add(delta int64) (new int64) {
+	return atomic.AddInt64(&v.value, delta)
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Int64) Cas(old, new int64) bool {
+	return atomic.CompareAndSwapInt64(&v.value, old, new)
+}

g/container/gtype/interface.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Interface struct {
@@ -16,28 +16,28 @@ type Interface struct {
 
 // NewInterface returns a concurrent-safe object for interface{} type,
 // with given initial value <value>.
-func NewInterface(value...interface{}) *Interface {
-    t := &Interface{}
-    if len(value) > 0 && value[0] != nil {
-        t.value.Store(value[0])
-    }
-    return t
+func NewInterface(value ...interface{}) *Interface {
+	t := &Interface{}
+	if len(value) > 0 && value[0] != nil {
+		t.value.Store(value[0])
+	}
+	return t
 }
 
 // Clone clones and returns a new concurrent-safe object for interface{} type.
-func (t *Interface) Clone() *Interface {
-    return NewInterface(t.Val())
+func (v *Interface) Clone() *Interface {
+	return NewInterface(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
 // Note: The parameter <value> cannot be nil.
-func (t *Interface) Set(value interface{}) (old interface{}) {
-    old = t.Val()
-    t.value.Store(value)
-    return
+func (v *Interface) Set(value interface{}) (old interface{}) {
+	old = v.Val()
+	v.value.Store(value)
+	return
 }
 
 // Val atomically loads t.value.
-func (t *Interface) Val() interface{} {
-    return t.value.Load()
-}
+func (v *Interface) Val() interface{} {
+	return v.value.Load()
+}

g/container/gtype/string.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type String struct {
@@ -16,33 +16,31 @@ type String struct {
 
 // NewString returns a concurrent-safe object for string type,
 // with given initial value <value>.
-func NewString(value...string) *String {
-    t := &String{}
-    if len(value) > 0 {
-        t.value.Store(value[0])
-    }
-    return t
+func NewString(value ...string) *String {
+	t := &String{}
+	if len(value) > 0 {
+		t.value.Store(value[0])
+	}
+	return t
 }
 
 // Clone clones and returns a new concurrent-safe object for string type.
-func (t *String) Clone() *String {
-    return NewString(t.Val())
+func (v *String) Clone() *String {
+	return NewString(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *String) Set(value string) (old string) {
-    old = t.Val()
-    t.value.Store(value)
-    return
+func (v *String) Set(value string) (old string) {
+	old = v.Val()
+	v.value.Store(value)
+	return
 }
 
 // Val atomically loads t.value.
-func (t *String) Val() string {
-    s := t.value.Load()
-    if s != nil {
-        return s.(string)
-    }
-    return ""
+func (v *String) Val() string {
+	s := v.value.Load()
+	if s != nil {
+		return s.(string)
+	}
+	return ""
 }
-
-

g/container/gtype/uint.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Uint struct {
@@ -16,31 +16,36 @@ type Uint struct {
 
 // NewUint returns a concurrent-safe object for uint type,
 // with given initial value <value>.
-func NewUint(value...uint) *Uint {
-    if len(value) > 0 {
-        return &Uint{
-	        value : uint64(value[0]),
+func NewUint(value ...uint) *Uint {
+	if len(value) > 0 {
+		return &Uint{
+			value: uint64(value[0]),
 		}
-    }
-    return &Uint{}
+	}
+	return &Uint{}
 }
 
 // Clone clones and returns a new concurrent-safe object for uint type.
-func (t *Uint) Clone() *Uint {
-    return NewUint(t.Val())
+func (v *Uint) Clone() *Uint {
+	return NewUint(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Uint) Set(value uint) (old uint) {
-    return uint(atomic.SwapUint64(&t.value, uint64(value)))
+func (v *Uint) Set(value uint) (old uint) {
+	return uint(atomic.SwapUint64(&v.value, uint64(value)))
 }
 
 // Val atomically loads t.value.
-func (t *Uint) Val() uint {
-    return uint(atomic.LoadUint64(&t.value))
+func (v *Uint) Val() uint {
+	return uint(atomic.LoadUint64(&v.value))
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Uint) Add(delta uint) (new uint) {
-    return uint(atomic.AddUint64(&t.value, uint64(delta)))
-}
+func (v *Uint) Add(delta uint) (new uint) {
+	return uint(atomic.AddUint64(&v.value, uint64(delta)))
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Uint) Cas(old, new uint) bool {
+	return atomic.CompareAndSwapUint64(&v.value, uint64(old), uint64(new))
+}

g/container/gtype/uint32.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Uint32 struct {
@@ -16,31 +16,36 @@ type Uint32 struct {
 
 // NewUint32 returns a concurrent-safe object for uint32 type,
 // with given initial value <value>.
-func NewUint32(value...uint32) *Uint32 {
-    if len(value) > 0 {
-        return &Uint32{
-        	value : value[0],
+func NewUint32(value ...uint32) *Uint32 {
+	if len(value) > 0 {
+		return &Uint32{
+			value: value[0],
 		}
-    }
-    return &Uint32{}
+	}
+	return &Uint32{}
 }
 
 // Clone clones and returns a new concurrent-safe object for uint32 type.
-func (t *Uint32) Clone() *Uint32 {
-    return NewUint32(t.Val())
+func (v *Uint32) Clone() *Uint32 {
+	return NewUint32(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Uint32) Set(value uint32) (old uint32) {
-    return atomic.SwapUint32(&t.value, value)
+func (v *Uint32) Set(value uint32) (old uint32) {
+	return atomic.SwapUint32(&v.value, value)
 }
 
 // Val atomically loads t.value.
-func (t *Uint32) Val() uint32 {
-    return atomic.LoadUint32(&t.value)
+func (v *Uint32) Val() uint32 {
+	return atomic.LoadUint32(&v.value)
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Uint32) Add(delta uint32) (new uint32) {
-    return atomic.AddUint32(&t.value, delta)
-}
+func (v *Uint32) Add(delta uint32) (new uint32) {
+	return atomic.AddUint32(&v.value, delta)
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Uint32) Cas(old, new uint32) bool {
+	return atomic.CompareAndSwapUint32(&v.value, old, new)
+}

g/container/gtype/uint64.go

@@ -7,7 +7,7 @@
 package gtype
 
 import (
-    "sync/atomic"
+	"sync/atomic"
 )
 
 type Uint64 struct {
@@ -16,31 +16,36 @@ type Uint64 struct {
 
 // NewUint64 returns a concurrent-safe object for uint64 type,
 // with given initial value <value>.
-func NewUint64(value...uint64) *Uint64 {
-    if len(value) > 0 {
-        return &Uint64{
-	        value : value[0],
+func NewUint64(value ...uint64) *Uint64 {
+	if len(value) > 0 {
+		return &Uint64{
+			value: value[0],
 		}
-    }
-    return &Uint64{}
+	}
+	return &Uint64{}
 }
 
 // Clone clones and returns a new concurrent-safe object for uint64 type.
-func (t *Uint64) Clone() *Uint64 {
-    return NewUint64(t.Val())
+func (v *Uint64) Clone() *Uint64 {
+	return NewUint64(v.Val())
 }
 
 // Set atomically stores <value> into t.value and returns the previous value of t.value.
-func (t *Uint64) Set(value uint64) (old uint64) {
-    return atomic.SwapUint64(&t.value, value)
+func (v *Uint64) Set(value uint64) (old uint64) {
+	return atomic.SwapUint64(&v.value, value)
 }
 
 // Val atomically loads t.value.
-func (t *Uint64) Val() uint64 {
-    return atomic.LoadUint64(&t.value)
+func (v *Uint64) Val() uint64 {
+	return atomic.LoadUint64(&v.value)
 }
 
 // Add atomically adds <delta> to t.value and returns the new value.
-func (t *Uint64) Add(delta uint64) (new uint64) {
-    return atomic.AddUint64(&t.value, delta)
-}
+func (v *Uint64) Add(delta uint64) (new uint64) {
+	return atomic.AddUint64(&v.value, delta)
+}
+
+// Cas executes the compare-and-swap operation for value.
+func (v *Uint64) Cas(old, new uint64) bool {
+	return atomic.CompareAndSwapUint64(&v.value, old, new)
+}

g/container/gvar/gvar.go

@@ -8,104 +8,213 @@
 package gvar
 
 import (
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/util/gconv"
-    "time"
+	"encoding/json"
+	"time"
+
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
+// Var is an universal variable type.
 type Var struct {
-    value interface{} // Underlying value.
-    safe  bool        // Concurrent safe or not.
+	value interface{} // Underlying value.
+	safe  bool        // Concurrent safe or not.
 }
 
 // New returns a new Var with given <value>.
 // The parameter <unsafe> used to specify whether using Var in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
-func New(value interface{}, unsafe...bool) *Var {
-    v := &Var{}
-    if len(unsafe) == 0 || !unsafe[0] {
-        v.safe  = true
-        v.value = gtype.NewInterface(value)
-    } else {
-        v.value = value
-    }
-    return v
+func New(value interface{}, unsafe ...bool) *Var {
+	v := &Var{}
+	if len(unsafe) == 0 || !unsafe[0] {
+		v.safe = true
+		v.value = gtype.NewInterface(value)
+	} else {
+		v.value = value
+	}
+	return v
+}
+
+// MarshalJSON implements the interface MarshalJSON for json.Marshal.
+func (v *Var) MarshalJSON() ([]byte, error) {
+	return json.Marshal(v.Val())
 }
 
 // Set sets <value> to <v>, and returns the old value.
 func (v *Var) Set(value interface{}) (old interface{}) {
-    if v.safe {
-        old = v.value.(*gtype.Interface).Set(value)
-    } else {
-        old = v.value
-        v.value = value
-    }
-    return
+	if v.safe {
+		old = v.value.(*gtype.Interface).Set(value)
+	} else {
+		old = v.value
+		v.value = value
+	}
+	return
 }
 
 // Val returns the current value of <v>.
 func (v *Var) Val() interface{} {
-    if v.safe {
-        return v.value.(*gtype.Interface).Val()
-    } else {
-        return v.value
-    }
+	if v.safe {
+		return v.value.(*gtype.Interface).Val()
+	}
+	return v.value
 }
 
-// See Val().
+// Interface is alias of Val.
 func (v *Var) Interface() interface{} {
-    return v.Val()
+	return v.Val()
+}
+
+// IsNil checks whether <v> is nil.
+func (v *Var) IsNil() bool {
+	return v.Val() == nil
+}
+
+// Bytes converts and returns <v> as []byte.
+func (v *Var) Bytes() []byte {
+	return gconv.Bytes(v.Val())
+}
+
+// String converts and returns <v> as string.
+func (v *Var) String() string {
+	return gconv.String(v.Val())
+}
+
+// Bool converts and returns <v> as bool.
+func (v *Var) Bool() bool {
+	return gconv.Bool(v.Val())
+}
+
+// Int converts and returns <v> as int.
+func (v *Var) Int() int {
+	return gconv.Int(v.Val())
+}
+
+// Int8 converts and returns <v> as int8.
+func (v *Var) Int8() int8 {
+	return gconv.Int8(v.Val())
+}
+
+// Int16 converts and returns <v> as int16.
+func (v *Var) Int16() int16 {
+	return gconv.Int16(v.Val())
+}
+
+// Int32 converts and returns <v> as int32.
+func (v *Var) Int32() int32 {
+	return gconv.Int32(v.Val())
+}
+
+// Int64 converts and returns <v> as int64.
+func (v *Var) Int64() int64 {
+	return gconv.Int64(v.Val())
+}
+
+// Uint converts and returns <v> as uint.
+func (v *Var) Uint() uint {
+	return gconv.Uint(v.Val())
+}
+
+// Uint8 converts and returns <v> as uint8.
+func (v *Var) Uint8() uint8 {
+	return gconv.Uint8(v.Val())
+}
+
+// Uint16 converts and returns <v> as uint16.
+func (v *Var) Uint16() uint16 {
+	return gconv.Uint16(v.Val())
+}
+
+// Uint32 converts and returns <v> as uint32.
+func (v *Var) Uint32() uint32 {
+	return gconv.Uint32(v.Val())
+}
+
+// Uint64 converts and returns <v> as uint64.
+func (v *Var) Uint64() uint64 {
+	return gconv.Uint64(v.Val())
+}
+
+// Float32 converts and returns <v> as float32.
+func (v *Var) Float32() float32 {
+	return gconv.Float32(v.Val())
+}
+
+// Float64 converts and returns <v> as float64.
+func (v *Var) Float64() float64 {
+	return gconv.Float64(v.Val())
+}
+
+// Ints converts and returns <v> as []int.
+func (v *Var) Ints() []int {
+	return gconv.Ints(v.Val())
+}
+
+// Floats converts and returns <v> as []float64.
+func (v *Var) Floats() []float64 {
+	return gconv.Floats(v.Val())
+}
+
+// Strings converts and returns <v> as []string.
+func (v *Var) Strings() []string {
+	return gconv.Strings(v.Val())
+}
+
+// Interfaces converts and returns <v> as []interfaces{}.
+func (v *Var) Interfaces() []interface{} {
+	return gconv.Interfaces(v.Val())
 }
 
 // Time converts and returns <v> as time.Time.
 // The parameter <format> specifies the format of the time string using gtime,
 // eg: Y-m-d H:i:s.
-func (v *Var) Time(format...string) time.Time {
-    return gconv.Time(v.Val(), format...)
+func (v *Var) Time(format ...string) time.Time {
+	return gconv.Time(v.Val(), format...)
 }
 
-// TimeDuration converts and returns <v> as time.Duration.
+// Duration converts and returns <v> as time.Duration.
 // If value of <v> is string, then it uses time.ParseDuration for conversion.
 func (v *Var) Duration() time.Duration {
-    return gconv.Duration(v.Val())
+	return gconv.Duration(v.Val())
 }
 
 // GTime converts and returns <v> as *gtime.Time.
 // The parameter <format> specifies the format of the time string using gtime,
 // eg: Y-m-d H:i:s.
-func (v *Var) GTime(format...string) *gtime.Time {
-    return gconv.GTime(v.Val(), format...)
+func (v *Var) GTime(format ...string) *gtime.Time {
+	return gconv.GTime(v.Val(), format...)
 }
 
-// Struct maps value of <v> to <objPointer>.
-// The parameter <objPointer> should be a pointer to a struct instance.
+// Map converts <v> to map[string]interface{}.
+func (v *Var) Map(tags ...string) map[string]interface{} {
+	return gconv.Map(v.Val(), tags...)
+}
+
+// MapDeep converts <v> to map[string]interface{} recursively.
+func (v *Var) MapDeep(tags ...string) map[string]interface{} {
+	return gconv.MapDeep(v.Val(), tags...)
+}
+
+// Struct maps value of <v> to <pointer>.
+// The parameter <pointer> should be a pointer to a struct instance.
 // The parameter <mapping> is used to specify the key-to-attribute mapping rules.
-func (v *Var) Struct(pointer interface{}, mapping...map[string]string) error {
-    return gconv.Struct(v.Val(), pointer, mapping...)
+func (v *Var) Struct(pointer interface{}, mapping ...map[string]string) error {
+	return gconv.Struct(v.Val(), pointer, mapping...)
 }
 
-func (v *Var) IsNil()          bool            { return v.Val() == nil }
-func (v *Var) Bytes()          []byte          { return gconv.Bytes(v.Val()) }
-func (v *Var) String()         string          { return gconv.String(v.Val()) }
-func (v *Var) Bool()           bool            { return gconv.Bool(v.Val()) }
+// Struct maps value of <v> to <pointer> recursively.
+// The parameter <pointer> should be a pointer to a struct instance.
+// The parameter <mapping> is used to specify the key-to-attribute mapping rules.
+func (v *Var) StructDeep(pointer interface{}, mapping ...map[string]string) error {
+	return gconv.StructDeep(v.Val(), pointer, mapping...)
+}
 
-func (v *Var) Int()            int             { return gconv.Int(v.Val()) }
-func (v *Var) Int8()           int8            { return gconv.Int8(v.Val()) }
-func (v *Var) Int16()          int16           { return gconv.Int16(v.Val()) }
-func (v *Var) Int32()          int32           { return gconv.Int32(v.Val()) }
-func (v *Var) Int64()          int64           { return gconv.Int64(v.Val()) }
+// Structs converts <v> to given struct slice.
+func (v *Var) Structs(pointer interface{}, mapping ...map[string]string) (err error) {
+	return gconv.Structs(v.Val(), pointer, mapping...)
+}
 
-func (v *Var) Uint()           uint            { return gconv.Uint(v.Val()) }
-func (v *Var) Uint8()          uint8           { return gconv.Uint8(v.Val()) }
-func (v *Var) Uint16()         uint16          { return gconv.Uint16(v.Val()) }
-func (v *Var) Uint32()         uint32          { return gconv.Uint32(v.Val()) }
-func (v *Var) Uint64()         uint64          { return gconv.Uint64(v.Val()) }
-
-func (v *Var) Float32()        float32         { return gconv.Float32(v.Val()) }
-func (v *Var) Float64()        float64         { return gconv.Float64(v.Val()) }
-
-func (v *Var) Ints()           []int           { return gconv.Ints(v.Val()) }
-func (v *Var) Floats()         []float64       { return gconv.Floats(v.Val()) }
-func (v *Var) Strings()        []string        { return gconv.Strings(v.Val()) }
-func (v *Var) Interfaces()     []interface{}   { return gconv.Interfaces(v.Val()) }
+// StructsDeep converts <v> to given struct slice recursively.
+func (v *Var) StructsDeep(pointer interface{}, mapping ...map[string]string) (err error) {
+	return gconv.StructsDeep(v.Val(), pointer, mapping...)
+}

g/container/gvar/gvar_z_bench_test.go

@@ -13,133 +13,133 @@ import "testing"
 var vn = New(nil)
 
 func Benchmark_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Set(i)
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Set(i)
+	}
 }
 
 func Benchmark_Val(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Val()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Val()
+	}
 }
 
 func Benchmark_IsNil(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.IsNil()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.IsNil()
+	}
 }
 
 func Benchmark_Bytes(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Bytes()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Bytes()
+	}
 }
 
 func Benchmark_String(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.String()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.String()
+	}
 }
 
 func Benchmark_Bool(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Bool()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Bool()
+	}
 }
 
 func Benchmark_Int(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Int()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Int()
+	}
 }
 
 func Benchmark_Int8(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Int8()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Int8()
+	}
 }
 
 func Benchmark_Int16(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Int16()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Int16()
+	}
 }
 
 func Benchmark_Int32(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Int32()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Int32()
+	}
 }
 
 func Benchmark_Int64(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Int64()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Int64()
+	}
 }
 
 func Benchmark_Uint(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Uint()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Uint()
+	}
 }
 
 func Benchmark_Uint8(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Uint8()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Uint8()
+	}
 }
 
 func Benchmark_Uint16(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Uint16()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Uint16()
+	}
 }
 
 func Benchmark_Uint32(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Uint32()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Uint32()
+	}
 }
 
 func Benchmark_Uint64(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Uint64()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Uint64()
+	}
 }
 
 func Benchmark_Float32(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Float32()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Float32()
+	}
 }
 
 func Benchmark_Float64(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Float64()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Float64()
+	}
 }
 
 func Benchmark_Ints(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Ints()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Ints()
+	}
 }
 
 func Benchmark_Strings(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Strings()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Strings()
+	}
 }
 
 func Benchmark_Floats(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Floats()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Floats()
+	}
 }
 
 func Benchmark_Interfaces(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        vn.Interfaces()
-    }
+	for i := 0; i < b.N; i++ {
+		vn.Interfaces()
+	}
 }

g/crypto/gaes/gaes.go

@@ -8,93 +8,158 @@
 package gaes
 
 import (
-    "bytes"
-    "errors"
-    "crypto/aes"
-    "crypto/cipher"
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"errors"
 )
 
 const (
-    ivDefValue = "I Love Go Frame!"
+	ivDefValue = "I Love Go Frame!"
 )
 
-// AES加密, 使用CBC模式，注意key必须为16/24/32位长度，iv初始化向量为非必需参数
-func Encrypt(plainText []byte, key []byte, iv...[]byte) ([]byte, error) {
-    block, err := aes.NewCipher(key)
-    if err != nil {
-        return nil, err
-    }
-    blockSize := block.BlockSize()
-    plainText  = PKCS5Padding(plainText, blockSize)
-    ivValue   := ([]byte)(nil)
-    if len(iv) > 0 {
-        ivValue = iv[0]
-    } else {
-        ivValue = []byte(ivDefValue)
-    }
-    blockMode  := cipher.NewCBCEncrypter(block, ivValue)
-    cipherText := make([]byte, len(plainText))
-    blockMode.CryptBlocks(cipherText, plainText)
+// Encrypt is alias of EncryptCBC.
+func Encrypt(plainText []byte, key []byte, iv ...[]byte) ([]byte, error) {
+	return EncryptCBC(plainText, key, iv...)
+}
 
-    return cipherText, nil
+// Decrypt is alias of DecryptCBC.
+func Decrypt(cipherText []byte, key []byte, iv ...[]byte) ([]byte, error) {
+	return DecryptCBC(cipherText, key, iv...)
+}
+
+// AES加密, 使用CBC模式，注意key必须为16/24/32位长度，iv初始化向量为非必需参数。
+func EncryptCBC(plainText []byte, key []byte, iv ...[]byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	plainText = PKCS5Padding(plainText, blockSize)
+	ivValue := ([]byte)(nil)
+	if len(iv) > 0 {
+		ivValue = iv[0]
+	} else {
+		ivValue = []byte(ivDefValue)
+	}
+	blockMode := cipher.NewCBCEncrypter(block, ivValue)
+	cipherText := make([]byte, len(plainText))
+	blockMode.CryptBlocks(cipherText, plainText)
+
+	return cipherText, nil
 }
 
 // AES解密, 使用CBC模式，注意key必须为16/24/32位长度，iv初始化向量为非必需参数
-func Decrypt(cipherText []byte, key []byte, iv...[]byte) ([]byte, error) {
-    block, err := aes.NewCipher(key)
-    if err != nil {
-        return nil, err
-    }
-    blockSize := block.BlockSize()
-    if len(cipherText) < blockSize {
-        return nil, errors.New("cipherText too short")
-    }
-    ivValue := ([]byte)(nil)
-    if len(iv) > 0 {
-        ivValue = iv[0]
-    } else {
-        ivValue = []byte(ivDefValue)
-    }
-    if len(cipherText)%blockSize != 0 {
-        return nil, errors.New("cipherText is not a multiple of the block size")
-    }
-    blockModel := cipher.NewCBCDecrypter(block, ivValue)
-    plainText  := make([]byte, len(cipherText))
-    blockModel.CryptBlocks(plainText, cipherText)
-    plainText, e := PKCS5UnPadding(plainText, blockSize)
+func DecryptCBC(cipherText []byte, key []byte, iv ...[]byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	if len(cipherText) < blockSize {
+		return nil, errors.New("cipherText too short")
+	}
+	ivValue := ([]byte)(nil)
+	if len(iv) > 0 {
+		ivValue = iv[0]
+	} else {
+		ivValue = []byte(ivDefValue)
+	}
+	if len(cipherText)%blockSize != 0 {
+		return nil, errors.New("cipherText is not a multiple of the block size")
+	}
+	blockModel := cipher.NewCBCDecrypter(block, ivValue)
+	plainText := make([]byte, len(cipherText))
+	blockModel.CryptBlocks(plainText, cipherText)
+	plainText, e := PKCS5UnPadding(plainText, blockSize)
 	if e != nil {
 		return nil, e
 	}
-    return plainText, nil
+	return plainText, nil
 }
 
 func PKCS5Padding(src []byte, blockSize int) []byte {
-    padding := blockSize - len(src)%blockSize
-    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
-    return append(src, padtext...)
+	padding := blockSize - len(src)%blockSize
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+	return append(src, padtext...)
 }
 
 func PKCS5UnPadding(src []byte, blockSize int) ([]byte, error) {
-    length    := len(src)
-    if blockSize <= 0 {
-        return nil, errors.New("invalid blocklen")
-    }
+	length := len(src)
+	if blockSize <= 0 {
+		return nil, errors.New("invalid blocklen")
+	}
 
 	if length%blockSize != 0 || length == 0 {
 		return nil, errors.New("invalid data len")
 	}
 
-    unpadding := int(src[length - 1])
+	unpadding := int(src[length-1])
 	if unpadding > blockSize || unpadding == 0 {
 		return nil, errors.New("invalid padding")
 	}
 
-    padding := src[length - unpadding:]
+	padding := src[length-unpadding:]
 	for i := 0; i < unpadding; i++ {
 		if padding[i] != byte(unpadding) {
 			return nil, errors.New("invalid padding")
 		}
 	}
 
-    return src[:(length - unpadding)], nil
+	return src[:(length - unpadding)], nil
+}
+
+// AES加密, 使用CFB模式。
+// 注意key必须为16/24/32位长度，padding返回补位长度，iv初始化向量为非必需参数。
+func EncryptCFB(plainText []byte, key []byte, padding *int, iv ...[]byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	blockSize := block.BlockSize()
+	plainText, *padding = ZeroPadding(plainText, blockSize) //补位0
+	ivValue := ([]byte)(nil)
+	if len(iv) > 0 {
+		ivValue = iv[0]
+	} else {
+		ivValue = []byte(ivDefValue)
+	}
+	stream := cipher.NewCFBEncrypter(block, ivValue)
+	cipherText := make([]byte, len(plainText))
+	stream.XORKeyStream(cipherText, plainText)
+	return cipherText, nil
+}
+
+// AES解密, 使用CFB模式。
+// 注意key必须为16/24/32位长度，unpadding为去补位长度，iv初始化向量为非必需参数。
+func DecryptCFB(cipherText []byte, key []byte, unpadding int, iv ...[]byte) ([]byte, error) {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		return nil, err
+	}
+	if len(cipherText) < aes.BlockSize {
+		return nil, errors.New("cipherText too short")
+	}
+	ivValue := ([]byte)(nil)
+	if len(iv) > 0 {
+		ivValue = iv[0]
+	} else {
+		ivValue = []byte(ivDefValue)
+	}
+	stream := cipher.NewCFBDecrypter(block, ivValue)
+	plainText := make([]byte, len(cipherText))
+	stream.XORKeyStream(plainText, cipherText)
+	plainText = ZeroUnPadding(plainText, unpadding) //去补位0
+	return plainText, nil
+}
+
+func ZeroPadding(ciphertext []byte, blockSize int) ([]byte, int) {
+	padding := blockSize - len(ciphertext)%blockSize
+	padtext := bytes.Repeat([]byte{byte(0)}, padding)
+	return append(ciphertext, padtext...), padding
+}
+
+func ZeroUnPadding(plaintext []byte, unpadding int) []byte {
+	length := len(plaintext)
+	return plaintext[:(length - unpadding)]
 }

g/crypto/gaes/gaes_test.go

@@ -9,20 +9,21 @@
 package gaes_test
 
 import (
-	"github.com/gogf/gf/g/encoding/gbase64"
 	"testing"
 
+	"github.com/gogf/gf/g/encoding/gbase64"
+
 	"github.com/gogf/gf/g/crypto/gaes"
 	"github.com/gogf/gf/g/test/gtest"
 )
 
 var (
 	content          = []byte("pibigstar")
-	content_16, _    = gbase64.Decode("v1jqsGHId/H8onlVHR8Vaw==")
-	content_24, _    = gbase64.Decode("0TXOaj5KMoLhNWmJ3lxY1A==")
-	content_32, _    = gbase64.Decode("qM/Waw1kkWhrwzek24rCSA==")
-	content_16_iv, _ = gbase64.Decode("DqQUXiHgW/XFb6Qs98+hrA==")
-	content_32_iv, _ = gbase64.Decode("ZuLgAOii+lrD5KJoQ7yQ8Q==")
+	content_16, _    = gbase64.DecodeString("v1jqsGHId/H8onlVHR8Vaw==")
+	content_24, _    = gbase64.DecodeString("0TXOaj5KMoLhNWmJ3lxY1A==")
+	content_32, _    = gbase64.DecodeString("qM/Waw1kkWhrwzek24rCSA==")
+	content_16_iv, _ = gbase64.DecodeString("DqQUXiHgW/XFb6Qs98+hrA==")
+	content_32_iv, _ = gbase64.DecodeString("ZuLgAOii+lrD5KJoQ7yQ8Q==")
 	// iv 长度必须等于blockSize，只能为16
 	iv         = []byte("Hello My GoFrame")
 	key_16     = []byte("1234567891234567")
@@ -32,6 +33,10 @@ var (
 	keys       = []byte("12345678912345678912345678912346")
 	key_err    = []byte("1234")
 	key_32_err = []byte("1234567891234567891234567891234 ")
+
+	// cfb模式blockSize补位长度, add by zseeker
+	padding_size      = 16 - len(content)
+	content_16_cfb, _ = gbase64.DecodeString("oSmget3aBDT1nJnBp8u6kA==")
 )
 
 func TestEncrypt(t *testing.T) {
@@ -125,3 +130,21 @@ func TestPKCS5UnPaddingErr(t *testing.T) {
 		gtest.AssertNE(err, nil)
 	})
 }
+
+func TestEncryptCFB(t *testing.T) {
+	gtest.Case(t, func() {
+		var padding int = 0
+		data, err := gaes.EncryptCFB(content, key_16, &padding, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(padding, padding_size)
+		gtest.Assert(data, []byte(content_16_cfb))
+	})
+}
+
+func TestDecryptCFB(t *testing.T) {
+	gtest.Case(t, func() {
+		decrypt, err := gaes.DecryptCFB([]byte(content_16_cfb), key_16, padding_size, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(decrypt, content)
+	})
+}

g/crypto/gcrc32/gcrc32.go

@@ -20,10 +20,10 @@ func Encrypt(v interface{}) uint32 {
 
 // Deprecated.
 func EncryptString(v string) uint32 {
-    return crc32.ChecksumIEEE([]byte(v))
+	return crc32.ChecksumIEEE([]byte(v))
 }
 
 // Deprecated.
 func EncryptBytes(v []byte) uint32 {
-    return crc32.ChecksumIEEE(v)
+	return crc32.ChecksumIEEE(v)
 }

g/crypto/gcrc32/gcrc32_test.go

@@ -9,10 +9,10 @@
 package gcrc32_test
 
 import (
-	"github.com/gogf/gf/g/crypto/gmd5"
 	"testing"
 
 	"github.com/gogf/gf/g/crypto/gcrc32"
+	"github.com/gogf/gf/g/crypto/gmd5"
 	"github.com/gogf/gf/g/test/gtest"
 )
 
@@ -36,7 +36,7 @@ func TestEncrypt(t *testing.T) {
 		gtest.AssertEQ(int(encrypt1), result)
 		gtest.AssertEQ(int(encrypt2), result)
 
-		strmd5 := gmd5.Encrypt(s)
+		strmd5, _ := gmd5.Encrypt(s)
 		test1 := gcrc32.Encrypt(strmd5)
 		test2 := gcrc32.Encrypt([]byte(strmd5))
 		gtest.AssertEQ(test2, test1)

g/crypto/gdes/gdes.go

@@ -3,21 +3,19 @@
 // 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.
-//
-// @author wenzi1<liyz23@qq.com>
 
 // Package gdes provides useful API for DES encryption/decryption algorithms.
 package gdes
 
 import (
-	"crypto/des"
-	"crypto/cipher"
-	"errors"
 	"bytes"
+	"crypto/cipher"
+	"crypto/des"
+	"errors"
 )
 
 const (
-	NOPADDING    = iota
+	NOPADDING = iota
 	PKCS5PADDING
 )
 
@@ -29,7 +27,7 @@ func DesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
 	}
 
 	cipherText := make([]byte, len(text))
-	
+
 	block, err := des.NewCipher(key)
 	if err != nil {
 		return nil, err
@@ -37,7 +35,7 @@ func DesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
 
 	blockSize := block.BlockSize()
 	for i, count := 0, len(text)/blockSize; i < count; i++ {
-		begin, end := i * blockSize, i * blockSize + blockSize
+		begin, end := i*blockSize, i*blockSize+blockSize
 		block.Encrypt(cipherText[begin:end], text[begin:end])
 	}
 	return cipherText, nil
@@ -52,8 +50,8 @@ func DesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
 	}
 
 	blockSize := block.BlockSize()
-	for i, count := 0, len(text)/blockSize; i < count; i++{
-		begin, end := i * blockSize, i * blockSize + blockSize
+	for i, count := 0, len(text)/blockSize; i < count; i++ {
+		begin, end := i*blockSize, i*blockSize+blockSize
 		block.Decrypt(text[begin:end], cipherText[begin:end])
 	}
 
@@ -65,7 +63,7 @@ func DesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
 }
 
 // ECB模式3DES加密，密钥长度可以是16或24位长
-func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ( []byte, error) {
+func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ([]byte, error) {
 	if len(key) != 16 && len(key) != 24 {
 		return nil, errors.New("key length error")
 	}
@@ -75,7 +73,7 @@ func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ( []byte, er
 		return nil, err
 	}
 
-	newKey := make([]byte, 0)
+	var newKey []byte
 	if len(key) == 16 {
 		newKey = append([]byte{}, key...)
 		newKey = append(newKey, key[:8]...)
@@ -90,20 +88,20 @@ func TripleDesECBEncrypt(key []byte, clearText []byte, padding int) ( []byte, er
 
 	blockSize := block.BlockSize()
 	cipherText := make([]byte, len(text))
-	for i, count := 0, len(text) / blockSize; i < count; i++{
-		begin, end := i * blockSize, i * blockSize + blockSize
+	for i, count := 0, len(text)/blockSize; i < count; i++ {
+		begin, end := i*blockSize, i*blockSize+blockSize
 		block.Encrypt(cipherText[begin:end], text[begin:end])
 	}
 	return cipherText, nil
 }
 
 // ECB模式3DES解密，密钥长度可以是16或24位长
-func TripleDesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte,  error) {
+func TripleDesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte, error) {
 	if len(key) != 16 && len(key) != 24 {
 		return nil, errors.New("key length error")
 	}
 
-	newKey := make([]byte, 0)
+	var newKey []byte
 	if len(key) == 16 {
 		newKey = append([]byte{}, key...)
 		newKey = append(newKey, key[:8]...)
@@ -118,8 +116,8 @@ func TripleDesECBDecrypt(key []byte, cipherText []byte, padding int) ([]byte,  e
 
 	blockSize := block.BlockSize()
 	text := make([]byte, len(cipherText))
-	for i, count := 0, len(text) / blockSize; i < count; i++ {
-		begin, end := i * blockSize, i * blockSize + blockSize
+	for i, count := 0, len(text)/blockSize; i < count; i++ {
+		begin, end := i*blockSize, i*blockSize+blockSize
 		block.Decrypt(text[begin:end], cipherText[begin:end])
 	}
 
@@ -182,7 +180,7 @@ func TripleDesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) (
 		return nil, errors.New("key length invalid")
 	}
 
-	newKey := make([]byte, 0)
+	var newKey []byte
 	if len(key) == 16 {
 		newKey = append([]byte{}, key...)
 		newKey = append(newKey, key[:8]...)
@@ -212,12 +210,12 @@ func TripleDesCBCEncrypt(key []byte, clearText []byte, iv []byte, padding int) (
 }
 
 // CBC模式3DES解密
-func TripleDesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int) ( []byte,  error) {
+func TripleDesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int) ([]byte, error) {
 	if len(key) != 16 && len(key) != 24 {
 		return nil, errors.New("key length invalid")
 	}
 
-	newKey := make([]byte, 0)
+	var newKey []byte
 	if len(key) == 16 {
 		newKey = append([]byte{}, key...)
 		newKey = append(newKey, key[:8]...)
@@ -248,45 +246,45 @@ func TripleDesCBCDecrypt(key []byte, cipherText []byte, iv []byte, padding int)
 
 // PKCS5补位
 func PKCS5Padding(text []byte, blockSize int) []byte {
-	padding := blockSize - len(text) % blockSize
+	padding := blockSize - len(text)%blockSize
 	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
 	return append(text, padtext...)
 }
 
 // 去除PKCS5补位
-func PKCS5Unpadding(text []byte) []byte{
+func PKCS5Unpadding(text []byte) []byte {
 	length := len(text)
-	padtext := int(text[length - 1])
+	padtext := int(text[length-1])
 	return text[:(length - padtext)]
 }
 
 // 补位方法
-func Padding(text []byte, padding int)([]byte, error) {
+func Padding(text []byte, padding int) ([]byte, error) {
 	switch padding {
-		case NOPADDING:
-			if len(text) % 8 != 0 {
-				return nil, errors.New("text length invalid")
-			}
-		case PKCS5PADDING:
-			return PKCS5Padding(text, 8), nil
-		default:
-			return nil, errors.New("padding type error")
+	case NOPADDING:
+		if len(text)%8 != 0 {
+			return nil, errors.New("text length invalid")
+		}
+	case PKCS5PADDING:
+		return PKCS5Padding(text, 8), nil
+	default:
+		return nil, errors.New("padding type error")
 	}
 
 	return text, nil
 }
 
 // 去除补位方法
-func UnPadding(text []byte, padding int)([]byte, error) {
+func UnPadding(text []byte, padding int) ([]byte, error) {
 	switch padding {
-		case NOPADDING:
-			if len(text) % 8 != 0 {
-				return nil, errors.New("text length invalid")
-			}
-		case PKCS5PADDING:
-			return PKCS5Unpadding(text), nil
-		default:
-			return nil, errors.New("padding type error.")
+	case NOPADDING:
+		if len(text)%8 != 0 {
+			return nil, errors.New("text length invalid")
+		}
+	case PKCS5PADDING:
+		return PKCS5Unpadding(text), nil
+	default:
+		return nil, errors.New("padding type error.")
 	}
 	return text, nil
-}
+}

g/crypto/gdes/gdes_test.go

@@ -1,3 +1,9 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). 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 gdes_test
 
 import (
@@ -23,7 +29,7 @@ func TestDesECB(t *testing.T) {
 		// encrypt test
 		cipherText, err := gdes.DesECBEncrypt(key, text, padding)
 		gtest.AssertEQ(err, nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
 		gtest.AssertEQ(err, nil)
@@ -52,12 +58,12 @@ func TestDesECB(t *testing.T) {
 		errPadding := 5
 		result := "858b176da8b12503ad6a88b4fa37833d"
 		cipherText, err := gdes.DesECBEncrypt(key, text, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"12345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "12345678")
 
 		// err test
 		errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
@@ -77,12 +83,12 @@ func Test3DesECB(t *testing.T) {
 		result := "a23ee24b98c26263a23ee24b98c26263"
 		// encrypt test
 		cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"1234567812345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "1234567812345678")
 		// err test
 		errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
 		gtest.AssertNE(err, nil)
@@ -97,12 +103,12 @@ func Test3DesECB(t *testing.T) {
 		result := "37989b1effc07a6d00ff89a7d052e79f"
 		// encrypt test
 		cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"123456789")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "123456789")
 		// err test, when key is err, but text and padding is right
 		errEncrypt, err := gdes.TripleDesECBEncrypt(errKey, text, padding)
 		gtest.AssertNE(err, nil)
@@ -127,19 +133,19 @@ func TestDesCBC(t *testing.T) {
 		result := "40826a5800608c87585ca7c9efabee47"
 		// encrypt test
 		cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"1234567812345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "1234567812345678")
 		// encrypt err test.
 		errEncrypt, err := gdes.DesCBCEncrypt(errKey, text, iv, padding)
 		gtest.AssertNE(err, nil)
 		gtest.AssertEQ(errEncrypt, nil)
 		// the iv is err
 		errEncrypt, err = gdes.DesCBCEncrypt(key, text, errIv, padding)
-		//gtest.AssertNE(err,nil)
+		gtest.AssertNE(err, nil)
 		gtest.AssertEQ(errEncrypt, nil)
 		// the padding is err
 		errEncrypt, err = gdes.DesCBCEncrypt(key, text, iv, errPadding)
@@ -167,12 +173,12 @@ func TestDesCBC(t *testing.T) {
 		result := "40826a5800608c87100a25d86ac7c52c"
 		// encrypt test
 		cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"12345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "12345678")
 		// err test
 		errEncrypt, err := gdes.DesCBCEncrypt(key, text, errIv, padding)
 		gtest.AssertNE(err, nil)
@@ -189,12 +195,12 @@ func Test3DesCBC(t *testing.T) {
 		result := "bfde1394e265d5f738d5cab170c77c88"
 		// encrypt test
 		cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"1234567812345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "1234567812345678")
 		// encrypt err test
 		errEncrypt, err := gdes.TripleDesCBCEncrypt(errKey, text, iv, padding)
 		gtest.AssertNE(err, nil)
@@ -228,12 +234,12 @@ func Test3DesCBC(t *testing.T) {
 		result := "40826a5800608c87100a25d86ac7c52c"
 		// encrypt test
 		cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText), result)
 		// decrypt test
 		clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
-		gtest.AssertEQ(err,nil)
-		gtest.AssertEQ(string(clearText),"12345678")
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "12345678")
 	})
 
 }

g/crypto/gmd5/gmd5.go

@@ -8,41 +8,44 @@
 package gmd5
 
 import (
-    "crypto/md5"
-    "fmt"
-    "os"
-    "io"
-    "github.com/gogf/gf/g/util/gconv"
+	"crypto/md5"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/gogf/gf/g/errors/gerror"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
 // Encrypt encrypts any type of variable using MD5 algorithms.
 // It uses gconv package to convert <v> to its bytes type.
-func Encrypt(v interface{}) string {
-    h := md5.New()
-    h.Write([]byte(gconv.Bytes(v)))
-    return fmt.Sprintf("%x", h.Sum(nil))
-}
-
-
-// Deprecated.
-func EncryptString(v string) string {
+func Encrypt(v interface{}) (encrypt string, err error) {
 	h := md5.New()
-	h.Write([]byte(v))
-	return fmt.Sprintf("%x", h.Sum(nil))
+	if _, err = h.Write([]byte(gconv.Bytes(v))); err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
 }
 
+// EncryptString is alias of Encrypt.
+// Deprecated.
+func EncryptString(v string) (encrypt string, err error) {
+	return Encrypt(v)
+}
 
 // EncryptFile encrypts file content of <path> using MD5 algorithms.
-func EncryptFile(path string) string {
-    f, e := os.Open(path)
-    if e != nil {
-        return ""
-    }
-    defer f.Close()
-    h   := md5.New()
-    _, e = io.Copy(h, f)
-    if e != nil {
-        return ""
-    }
-    return fmt.Sprintf("%x", h.Sum(nil))
+func EncryptFile(path string) (encrypt string, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		err = gerror.Wrap(f.Close(), "file closing error")
+	}()
+	h := md5.New()
+	_, err = io.Copy(h, f)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("%x", h.Sum(nil)), nil
 }

g/crypto/gmd5/gmd5_test.go

@@ -30,12 +30,12 @@ type user struct {
 
 func TestEncrypt(t *testing.T) {
 	gtest.Case(t, func() {
-		encryptString := gmd5.Encrypt(s)
+		encryptString, _ := gmd5.Encrypt(s)
 		gtest.Assert(encryptString, result)
 
 		result := "1427562bb29f88a1161590b76398ab72"
-		encrypt := gmd5.Encrypt(123456)
-		gtest.AssertEQ(encrypt,result)
+		encrypt, _ := gmd5.Encrypt(123456)
+		gtest.AssertEQ(encrypt, result)
 	})
 
 	gtest.Case(t, func() {
@@ -45,14 +45,14 @@ func TestEncrypt(t *testing.T) {
 			age:      23,
 		}
 		result := "70917ebce8bd2f78c736cda63870fb39"
-		encrypt := gmd5.Encrypt(user)
-		gtest.AssertEQ(encrypt,result)
+		encrypt, _ := gmd5.Encrypt(user)
+		gtest.AssertEQ(encrypt, result)
 	})
 }
 
 func TestEncryptString(t *testing.T) {
 	gtest.Case(t, func() {
-		encryptString := gmd5.EncryptString(s)
+		encryptString, _ := gmd5.EncryptString(s)
 		gtest.Assert(encryptString, result)
 	})
 }
@@ -66,13 +66,12 @@ func TestEncryptFile(t *testing.T) {
 		defer os.Remove(path)
 		defer file.Close()
 		gtest.Assert(err, nil)
-		file.Write([]byte("Hello Go Frame"))
-		encryptFile := gmd5.EncryptFile(path)
+		_, _ = file.Write([]byte("Hello Go Frame"))
+		encryptFile, _ := gmd5.EncryptFile(path)
 		gtest.AssertEQ(encryptFile, result)
 		// when the file is not exist,encrypt will return empty string
-		errEncrypt := gmd5.EncryptFile(errorPath)
+		errEncrypt, _ := gmd5.EncryptFile(errorPath)
 		gtest.AssertEQ(errEncrypt, "")
 	})
 
-
 }

g/crypto/gsha1/gsha1.go

@@ -8,37 +8,41 @@
 package gsha1
 
 import (
-    "crypto/sha1"
-    "encoding/hex"
-    "os"
-    "io"
-    "github.com/gogf/gf/g/util/gconv"
+	"crypto/sha1"
+	"encoding/hex"
+	"io"
+	"os"
+
+	"github.com/gogf/gf/g/errors/gerror"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
 // Encrypt encrypts any type of variable using SHA1 algorithms.
 // It uses gconv package to convert <v> to its bytes type.
 func Encrypt(v interface{}) string {
-    r := sha1.Sum(gconv.Bytes(v))
-    return hex.EncodeToString(r[:])
-}
-
-// Deprecated.
-func EncryptString(s string) string {
-	r := sha1.Sum([]byte(s))
+	r := sha1.Sum(gconv.Bytes(v))
 	return hex.EncodeToString(r[:])
 }
 
+// EncryptString is alias of Encrypt.
+// Deprecated.
+func EncryptString(s string) string {
+	return Encrypt(s)
+}
+
 // EncryptFile encrypts file content of <path> using SHA1 algorithms.
-func EncryptFile(path string) string {
-    f, e := os.Open(path)
-    if e != nil {
-        return ""
-    }
-    defer f.Close()
-    h := sha1.New()
-    _, e = io.Copy(h, f)
-    if e != nil {
-        return ""
-    }
-    return hex.EncodeToString(h.Sum(nil))
-}
+func EncryptFile(path string) (encrypt string, err error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return "", err
+	}
+	defer func() {
+		err = gerror.Wrap(f.Close(), "file closing error")
+	}()
+	h := sha1.New()
+	_, err = io.Copy(h, f)
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(h.Sum(nil)), nil
+}

g/crypto/gsha1/gsha1_test.go

@@ -57,11 +57,11 @@ func TestEncryptFile(t *testing.T) {
 		defer os.Remove(path)
 		defer file.Close()
 		gtest.Assert(err, nil)
-		file.Write([]byte("Hello Go Frame"))
-		encryptFile := gsha1.EncryptFile(path)
+		_, _ = file.Write([]byte("Hello Go Frame"))
+		encryptFile, _ := gsha1.EncryptFile(path)
 		gtest.AssertEQ(encryptFile, result)
 		// when the file is not exist,encrypt will return empty string
-		errEncrypt := gsha1.EncryptFile(errPath)
-		gtest.AssertEQ(errEncrypt,"")
+		errEncrypt, _ := gsha1.EncryptFile(errPath)
+		gtest.AssertEQ(errEncrypt, "")
 	})
 }

g/database/gdb/gdb.go

@@ -11,51 +11,52 @@
 package gdb
 
 import (
-    "database/sql"
-    "errors"
-    "fmt"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/container/gring"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/container/gvar"
-    "github.com/gogf/gf/g/os/gcache"
-    "github.com/gogf/gf/g/util/grand"
-    "time"
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/container/gring"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/container/gvar"
+	"github.com/gogf/gf/g/os/gcache"
+	"github.com/gogf/gf/g/util/grand"
 )
 
 // 数据库操作接口
 type DB interface {
-    // 建立数据库连接方法(开发者一般不需要直接调用)
-    Open(config *ConfigNode) (*sql.DB, error)
+	// 建立数据库连接方法(开发者一般不需要直接调用)
+	Open(config *ConfigNode) (*sql.DB, error)
 
 	// SQL操作方法 API
 	Query(query string, args ...interface{}) (*sql.Rows, error)
 	Exec(sql string, args ...interface{}) (sql.Result, error)
-	Prepare(sql string, execOnMaster...bool) (*sql.Stmt, error)
+	Prepare(sql string, execOnMaster ...bool) (*sql.Stmt, error)
 
-    // 内部实现API的方法(不同数据库可覆盖这些方法实现自定义的操作)
-    doQuery(link dbLink, query string, args ...interface{}) (rows *sql.Rows, err error)
-    doExec(link dbLink, query string, args ...interface{}) (result sql.Result, err error)
-    doPrepare(link dbLink, query string) (*sql.Stmt, error)
-    doInsert(link dbLink, table string, data interface{}, option int, batch...int) (result sql.Result, err error)
-    doBatchInsert(link dbLink, table string, list interface{}, option int, batch...int) (result sql.Result, err error)
-    doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error)
-    doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error)
+	// 内部实现API的方法(不同数据库可覆盖这些方法实现自定义的操作)
+	doQuery(link dbLink, query string, args ...interface{}) (rows *sql.Rows, err error)
+	doExec(link dbLink, query string, args ...interface{}) (result sql.Result, err error)
+	doPrepare(link dbLink, query string) (*sql.Stmt, error)
+	doInsert(link dbLink, table string, data interface{}, option int, batch ...int) (result sql.Result, err error)
+	doBatchInsert(link dbLink, table string, list interface{}, option int, batch ...int) (result sql.Result, err error)
+	doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error)
+	doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error)
 
 	// 数据库查询
 	GetAll(query string, args ...interface{}) (Result, error)
 	GetOne(query string, args ...interface{}) (Record, error)
 	GetValue(query string, args ...interface{}) (Value, error)
-    GetCount(query string, args ...interface{}) (int, error)
-    GetStruct(objPointer interface{}, query string, args ...interface{}) error
-    GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error
-    GetScan(objPointer interface{}, query string, args ...interface{}) error
+	GetCount(query string, args ...interface{}) (int, error)
+	GetStruct(objPointer interface{}, query string, args ...interface{}) error
+	GetStructs(objPointerSlice interface{}, query string, args ...interface{}) error
+	GetScan(objPointer interface{}, query string, args ...interface{}) error
 
-    // 创建底层数据库master/slave链接对象
-    Master() (*sql.DB, error)
-    Slave() (*sql.DB, error)
+	// 创建底层数据库master/slave链接对象
+	Master() (*sql.DB, error)
+	Slave() (*sql.DB, error)
 
-    // Ping
+	// Ping
 	PingMaster() error
 	PingSlave() error
 
@@ -63,49 +64,52 @@ type DB interface {
 	Begin() (*TX, error)
 
 	// 数据表插入/更新/保存操作
-	Insert(table string, data interface{}, batch...int) (sql.Result, error)
-	Replace(table string, data interface{}, batch...int) (sql.Result, error)
-	Save(table string, data interface{}, batch...int) (sql.Result, error)
+	Insert(table string, data interface{}, batch ...int) (sql.Result, error)
+	Replace(table string, data interface{}, batch ...int) (sql.Result, error)
+	Save(table string, data interface{}, batch ...int) (sql.Result, error)
 
 	// 数据表插入/更新/保存操作(批量)
-	BatchInsert(table string, list interface{}, batch...int) (sql.Result, error)
-	BatchReplace(table string, list interface{}, batch...int) (sql.Result, error)
-	BatchSave(table string, list interface{}, batch...int) (sql.Result, error)
+	BatchInsert(table string, list interface{}, batch ...int) (sql.Result, error)
+	BatchReplace(table string, list interface{}, batch ...int) (sql.Result, error)
+	BatchSave(table string, list interface{}, batch ...int) (sql.Result, error)
 
 	// 数据修改/删除
 	Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error)
 	Delete(table string, condition interface{}, args ...interface{}) (sql.Result, error)
 
-	// 创建链式操作对象(Table为From的别名)
-	Table(tables string) *Model
+	// 创建链式操作对象
 	From(tables string) *Model
+	Table(tables string) *Model
 
 	// 设置管理
-    SetDebug(debug bool)
-    SetSchema(schema string)
-    GetQueriedSqls() []*Sql
+	SetDebug(debug bool)
+	SetSchema(schema string)
+	GetQueriedSqls() []*Sql
 	GetLastSql() *Sql
-    PrintQueriedSqls()
-    SetMaxIdleConns(n int)
-    SetMaxOpenConns(n int)
-    SetConnMaxLifetime(n int)
+	PrintQueriedSqls()
+	SetMaxIdleConnCount(n int)
+	SetMaxOpenConnCount(n int)
+	SetMaxConnLifetime(n int)
 
 	// 内部方法接口
-	getCache() (*gcache.Cache)
+	getCache() *gcache.Cache
 	getChars() (charLeft string, charRight string)
 	getDebug() bool
-    filterFields(table string, data map[string]interface{}) map[string]interface{}
-    convertValue(fieldValue interface{}, fieldType string) interface{}
-    getTableFields(table string) (map[string]string, error)
-    rowsToResult(rows *sql.Rows) (Result, error)
-    handleSqlBeforeExec(sql string) string
+	quoteWord(s string) string
+	setSchema(sqlDb *sql.DB, schema string) error
+	filterFields(table string, data map[string]interface{}) map[string]interface{}
+	formatWhere(where interface{}, args []interface{}) (newWhere string, newArgs []interface{})
+	convertValue(fieldValue []byte, fieldType string) interface{}
+	getTableFields(table string) (map[string]string, error)
+	rowsToResult(rows *sql.Rows) (Result, error)
+	handleSqlBeforeExec(sql string) string
 }
 
 // 执行底层数据库操作的核心接口
 type dbLink interface {
-    Query(query string, args ...interface{}) (*sql.Rows, error)
-    Exec(sql string, args ...interface{}) (sql.Result, error)
-    Prepare(sql string) (*sql.Stmt, error)
+	Query(query string, args ...interface{}) (*sql.Rows, error)
+	Exec(sql string, args ...interface{}) (sql.Result, error)
+	Prepare(sql string) (*sql.Stmt, error)
 }
 
 // 数据库链接对象
@@ -115,11 +119,11 @@ type dbBase struct {
 	debug            *gtype.Bool                  // (默认关闭)是否开启调试模式，当开启时会启用一些调试特性
 	sqls             *gring.Ring                  // (debug=true时有效)已执行的SQL列表
 	cache            *gcache.Cache                // 数据库缓存，包括底层连接池对象缓存及查询缓存；需要注意的是，事务查询不支持查询缓存
-    schema           *gtype.String                // 手动切换的数据库名称
-    tables           map[string]map[string]string // 数据库表结构
+	schema           *gtype.String                // 手动切换的数据库名称
+	tables           map[string]map[string]string // 数据库表结构
 	maxIdleConnCount *gtype.Int                   // 连接池最大限制的连接数
-    maxOpenConnCount *gtype.Int                   // 连接池最大打开的连接数
-    maxConnLifetime  *gtype.Int                   // (单位秒)连接对象可重复使用的时间长度
+	maxOpenConnCount *gtype.Int                   // 连接池最大打开的连接数
+	maxConnLifetime  *gtype.Int                   // (单位秒)连接对象可重复使用的时间长度
 }
 
 // 执行的SQL对象
@@ -142,23 +146,23 @@ type Record map[string]Value
 type Result []Record
 
 // 关联数组，绑定一条数据表记录(使用别名)
-type Map  = map[string]interface{}
+type Map = map[string]interface{}
 
 // 关联数组列表(索引从0开始的数组)，绑定多条记录(使用别名)
 type List = []Map
 
 const (
-    OPTION_INSERT               = 0
-    OPTION_REPLACE              = 1
-    OPTION_SAVE                 = 2
-    OPTION_IGNORE               = 3
-    gDEFAULT_BATCH_NUM          = 10 // Per count for batch insert/replace/save
-    gDEFAULT_CONN_MAX_LIFE_TIME = 30 // Max life time for per connection in pool.
+	OPTION_INSERT               = 0
+	OPTION_REPLACE              = 1
+	OPTION_SAVE                 = 2
+	OPTION_IGNORE               = 3
+	gDEFAULT_BATCH_NUM          = 10 // Per count for batch insert/replace/save
+	gDEFAULT_CONN_MAX_LIFE_TIME = 30 // Max life time for per connection in pool.
 )
 
 var (
-    // Instance map.
-    instances = gmap.NewStrAnyMap()
+	// Instance map.
+	instances = gmap.NewStrAnyMap()
 )
 
 // New creates ORM DB object with global configurations.
@@ -167,7 +171,7 @@ var (
 func New(name ...string) (db DB, err error) {
 	group := configs.defaultGroup
 	if len(name) > 0 {
-        group = name[0]
+		group = name[0]
 	}
 	configs.RLock()
 	defer configs.RUnlock()
@@ -176,34 +180,34 @@ func New(name ...string) (db DB, err error) {
 		return nil, errors.New("empty database configuration")
 	}
 	if _, ok := configs.config[group]; ok {
-	    if node, err := getConfigNodeByGroup(group, true); err == nil {
-	        base := &dbBase {
-                group            : group,
-                debug            : gtype.NewBool(),
-                cache            : gcache.New(),
-                schema           : gtype.NewString(),
-                maxIdleConnCount : gtype.NewInt(),
-                maxOpenConnCount : gtype.NewInt(),
-                maxConnLifetime  : gtype.NewInt(gDEFAULT_CONN_MAX_LIFE_TIME),
-            }
-            switch node.Type {
-                case "mysql":
-                    base.db = &dbMysql{dbBase  : base}
-                case "pgsql":
-                    base.db = &dbPgsql{dbBase  : base}
-                case "mssql":
-                    base.db = &dbMssql{dbBase  : base}
-                case "sqlite":
-                    base.db = &dbSqlite{dbBase : base}
-                case "oracle":
-                    base.db = &dbOracle{dbBase : base}
-                default:
-                    return nil, errors.New(fmt.Sprintf(`unsupported database type "%s"`, node.Type))
-            }
-            return base.db, nil
-        } else {
-            return nil, err
-        }
+		if node, err := getConfigNodeByGroup(group, true); err == nil {
+			base := &dbBase{
+				group:            group,
+				debug:            gtype.NewBool(),
+				cache:            gcache.New(),
+				schema:           gtype.NewString(),
+				maxIdleConnCount: gtype.NewInt(),
+				maxOpenConnCount: gtype.NewInt(),
+				maxConnLifetime:  gtype.NewInt(gDEFAULT_CONN_MAX_LIFE_TIME),
+			}
+			switch node.Type {
+			case "mysql":
+				base.db = &dbMysql{dbBase: base}
+			case "pgsql":
+				base.db = &dbPgsql{dbBase: base}
+			case "mssql":
+				base.db = &dbMssql{dbBase: base}
+			case "sqlite":
+				base.db = &dbSqlite{dbBase: base}
+			case "oracle":
+				base.db = &dbOracle{dbBase: base}
+			default:
+				return nil, errors.New(fmt.Sprintf(`unsupported database type "%s"`, node.Type))
+			}
+			return base.db, nil
+		} else {
+			return nil, err
+		}
 	} else {
 		return nil, errors.New(fmt.Sprintf("empty database configuration for item name '%s'", group))
 	}
@@ -213,47 +217,47 @@ func New(name ...string) (db DB, err error) {
 // The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
 func Instance(name ...string) (db DB, err error) {
-    group := configs.defaultGroup
-    if len(name) > 0 {
-        group = name[0]
-    }
-    v := instances.GetOrSetFuncLock(group, func() interface{} {
-        db, err = New(group)
-        return db
-    })
-    if v != nil {
-        return v.(DB), nil
-    }
-    return
+	group := configs.defaultGroup
+	if len(name) > 0 {
+		group = name[0]
+	}
+	v := instances.GetOrSetFuncLock(group, func() interface{} {
+		db, err = New(group)
+		return db
+	})
+	if v != nil {
+		return v.(DB), nil
+	}
+	return
 }
 
 // 获取指定数据库角色的一个配置项，内部根据权重计算负载均衡
 func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
-    if list, ok := configs.config[group]; ok {
-        // 将master, slave集群列表拆分出来
-        masterList := make(ConfigGroup, 0)
-        slaveList  := make(ConfigGroup, 0)
-        for i := 0; i < len(list); i++ {
-            if list[i].Role == "slave" {
-                slaveList = append(slaveList, list[i])
-            } else {
-                masterList = append(masterList, list[i])
-            }
-        }
-        if len(masterList) < 1 {
-            return nil, errors.New("at least one master node configuration's need to make sense")
-        }
-        if len(slaveList) < 1 {
-            slaveList = masterList
-        }
-        if master {
-            return getConfigNodeByPriority(masterList), nil
-        } else {
-            return getConfigNodeByPriority(slaveList), nil
-        }
-    } else {
-        return nil, errors.New(fmt.Sprintf("empty database configuration for item name '%s'", group))
-    }
+	if list, ok := configs.config[group]; ok {
+		// 将master, slave集群列表拆分出来
+		masterList := make(ConfigGroup, 0)
+		slaveList := make(ConfigGroup, 0)
+		for i := 0; i < len(list); i++ {
+			if list[i].Role == "slave" {
+				slaveList = append(slaveList, list[i])
+			} else {
+				masterList = append(masterList, list[i])
+			}
+		}
+		if len(masterList) < 1 {
+			return nil, errors.New("at least one master node configuration's need to make sense")
+		}
+		if len(slaveList) < 1 {
+			slaveList = masterList
+		}
+		if master {
+			return getConfigNodeByWeight(masterList), nil
+		} else {
+			return getConfigNodeByWeight(slaveList), nil
+		}
+	} else {
+		return nil, errors.New(fmt.Sprintf("empty database configuration for item name '%s'", group))
+	}
 }
 
 // 按照负载均衡算法(优先级配置)从数据库集群中选择一个配置节点出来使用
@@ -262,21 +266,21 @@ func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
 // 2、那么节点1的权重范围为[0, 99]，节点2的权重范围为[100, 199]，比例为1:1；
 // 3、假如计算出的随机数为99;
 // 4、那么选择的配置为节点1;
-func getConfigNodeByPriority(cg ConfigGroup) *ConfigNode {
+func getConfigNodeByWeight(cg ConfigGroup) *ConfigNode {
 	if len(cg) < 2 {
 		return &cg[0]
 	}
 	var total int
 	for i := 0; i < len(cg); i++ {
-		total += cg[i].Priority * 100
+		total += cg[i].Weight * 100
 	}
 	// 如果total为0表示所有连接都没有配置priority属性，那么默认都是1
 	if total == 0 {
-        for i := 0; i < len(cg); i++ {
-            cg[i].Priority = 1
-            total         += cg[i].Priority * 100
-        }
-    }
+		for i := 0; i < len(cg); i++ {
+			cg[i].Weight = 1
+			total += cg[i].Weight * 100
+		}
+	}
 	// 不能取到末尾的边界点
 	r := grand.Rand(0, total)
 	if r > 0 {
@@ -285,7 +289,7 @@ func getConfigNodeByPriority(cg ConfigGroup) *ConfigNode {
 	min := 0
 	max := 0
 	for i := 0; i < len(cg); i++ {
-		max = min + cg[i].Priority*100
+		max = min + cg[i].Weight*100
 		//fmt.Printf("r: %d, min: %d, max: %d\n", r, min, max)
 		if r >= min && r < max {
 			return &cg[i]
@@ -298,53 +302,61 @@ func getConfigNodeByPriority(cg ConfigGroup) *ConfigNode {
 
 // 获得底层数据库链接对象
 func (bs *dbBase) getSqlDb(master bool) (sqlDb *sql.DB, err error) {
-    // 负载均衡
-    node, err := getConfigNodeByGroup(bs.group, master)
-    if err != nil {
-        return nil, err
-    }
-    // 默认值设定
-    if node.Charset == "" {
-        node.Charset = "utf8"
-    }
-    v := bs.cache.GetOrSetFuncLock(node.String(), func() interface{} {
-        sqlDb, err = bs.db.Open(node)
-        if err != nil {
-            return nil
-        }
+	// 负载均衡
+	node, err := getConfigNodeByGroup(bs.group, master)
+	if err != nil {
+		return nil, err
+	}
+	// 默认值设定
+	if node.Charset == "" {
+		node.Charset = "utf8"
+	}
+	// 缓存连接对象(该对象其实是一个连接池对象)
+	v := bs.cache.GetOrSetFuncLock(node.String(), func() interface{} {
+		sqlDb, err = bs.db.Open(node)
+		if err != nil {
+			return nil
+		}
+		// 接口对象可能会覆盖这些连接参数，所以这里优先判断有误设置连接池属性。
+		// 若无设置则使用配置节点的连接池参数
+		if n := bs.maxIdleConnCount.Val(); n > 0 {
+			sqlDb.SetMaxIdleConns(n)
+		} else if node.MaxIdleConnCount > 0 {
+			sqlDb.SetMaxIdleConns(node.MaxIdleConnCount)
+		}
 
-        if n := bs.maxIdleConnCount.Val(); n > 0 {
-            sqlDb.SetMaxIdleConns(n)
-        } else if node.MaxIdleConnCount > 0 {
-            sqlDb.SetMaxIdleConns(node.MaxIdleConnCount)
-        }
+		if n := bs.maxOpenConnCount.Val(); n > 0 {
+			sqlDb.SetMaxOpenConns(n)
+		} else if node.MaxOpenConnCount > 0 {
+			sqlDb.SetMaxOpenConns(node.MaxOpenConnCount)
+		}
 
-        if n := bs.maxOpenConnCount.Val(); n > 0 {
-            sqlDb.SetMaxOpenConns(n)
-        } else if node.MaxOpenConnCount > 0 {
-            sqlDb.SetMaxOpenConns(node.MaxOpenConnCount)
-        }
-
-        if n := bs.maxConnLifetime.Val(); n > 0 {
-            sqlDb.SetConnMaxLifetime(time.Duration(n) * time.Second)
-        } else if node.MaxConnLifetime > 0 {
-            sqlDb.SetConnMaxLifetime(time.Duration(node.MaxConnLifetime) * time.Second)
-        }
-        return sqlDb
-    }, 0)
-    if v != nil && sqlDb == nil {
-        sqlDb = v.(*sql.DB)
-    }
-    // 是否手动选择数据库
-    if v := bs.schema.Val(); v != "" {
-        sqlDb.Exec("USE " + v)
-    }
-    return
+		if n := bs.maxConnLifetime.Val(); n > 0 {
+			sqlDb.SetConnMaxLifetime(time.Duration(n) * time.Second)
+		} else if node.MaxConnLifetime > 0 {
+			sqlDb.SetConnMaxLifetime(time.Duration(node.MaxConnLifetime) * time.Second)
+		}
+		return sqlDb
+	}, 0)
+	if v != nil && sqlDb == nil {
+		sqlDb = v.(*sql.DB)
+	}
+	// 是否开启调试模式
+	if node.Debug {
+		bs.db.SetDebug(node.Debug)
+	}
+	// 是否手动选择数据库
+	if v := bs.schema.Val(); v != "" {
+		if e := bs.db.setSchema(sqlDb, v); e != nil {
+			err = e
+		}
+	}
+	return
 }
 
 // 切换当前数据库对象操作的数据库。
 func (bs *dbBase) SetSchema(schema string) {
-    bs.schema.Set(schema)
+	bs.schema.Set(schema)
 }
 
 // 创建底层数据库master链接对象。
@@ -354,5 +366,5 @@ func (bs *dbBase) Master() (*sql.DB, error) {
 
 // 创建底层数据库slave链接对象。
 func (bs *dbBase) Slave() (*sql.DB, error) {
-    return bs.getSqlDb(false)
+	return bs.getSqlDb(false)
 }

g/database/gdb/gdb_batch_result.go

@@ -16,10 +16,10 @@ type batchSqlResult struct {
 
 // see sql.Result.RowsAffected
 func (r *batchSqlResult) RowsAffected() (int64, error) {
-    return r.rowsAffected, nil
+	return r.rowsAffected, nil
 }
 
 // see sql.Result.LastInsertId
 func (r *batchSqlResult) LastInsertId() (int64, error) {
-    return r.lastResult.LastInsertId()
-}
+	return r.lastResult.LastInsertId()
+}

g/database/gdb/gdb_config.go

@@ -3,180 +3,153 @@
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
-// 对常用关系数据库的封装管理包
 
 package gdb
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gring"
-    "sync"
+	"fmt"
+	"sync"
+
+	"github.com/gogf/gf/g/container/gring"
 )
 
 const (
-    DEFAULT_GROUP_NAME = "default" // 默认配置名称
+	DEFAULT_GROUP_NAME = "default" // 默认配置名称
 )
 
 // 数据库分组配置
-type Config      map[string]ConfigGroup
+type Config map[string]ConfigGroup
 
 // 数据库集群配置
 type ConfigGroup []ConfigNode
 
 // 数据库单项配置
-type ConfigNode  struct {
-    Host             string   // 地址
-    Port             string   // 端口
-    User             string   // 账号
-    Pass             string   // 密码
-    Name             string   // 数据库名称
-    Type             string   // 数据库类型：mysql, sqlite, mssql, pgsql, oracle(目前仅支持mysql)
-    Role             string   // (可选，默认为master)数据库的角色，用于主从操作分离，至少需要有一个master，参数值：master, slave
-    Charset          string   // (可选，默认为 utf8)编码，默认为 utf8
-    Priority         int      // (可选)用于负载均衡的权重计算，当集群中只有一个节点时，权重没有任何意义
-    LinkInfo         string   // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
-    MaxIdleConnCount int      // (可选)连接池最大限制的连接数
-    MaxOpenConnCount int      // (可选)连接池最大打开的连接数
-    MaxConnLifetime  int      // (可选，单位秒)连接对象可重复使用的时间长度
+type ConfigNode struct {
+	Host             string // 地址
+	Port             string // 端口
+	User             string // 账号
+	Pass             string // 密码
+	Name             string // 数据库名称
+	Type             string // 数据库类型：mysql, sqlite, mssql, pgsql, oracle
+	Role             string // (可选，默认为master)数据库的角色，用于主从操作分离，至少需要有一个master，参数值：master, slave
+	Debug            bool   // (可选)开启调试模式
+	Weight           int    // (可选)用于负载均衡的权重计算，当集群中只有一个节点时，权重没有任何意义
+	Charset          string // (可选，默认为 utf8)编码，默认为 utf8
+	LinkInfo         string // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
+	MaxIdleConnCount int    // (可选)连接池最大限制的连接数
+	MaxOpenConnCount int    // (可选)连接池最大打开的连接数
+	MaxConnLifetime  int    // (可选，单位秒)连接对象可重复使用的时间长度
 }
 
 // 数据库配置包内对象
 var configs struct {
-    sync.RWMutex        // 并发安全互斥锁
-    config       Config // 数据库分组配置
-    defaultGroup string // 默认数据库分组名称
+	sync.RWMutex        // 并发安全互斥锁
+	config       Config // 数据库分组配置
+	defaultGroup string // 默认数据库分组名称
 }
 
-// 数据库集群配置示例，支持主从处理，多数据库集群支持
-/*
-var DatabaseConfiguration = Config {
-    // 数据库集群配置名称
-    "default" : ConfigGroup {
-        {
-            Host     : "192.168.1.100",
-            Port     : "3306",
-            User     : "root",
-            Pass     : "123456",
-            Name     : "test",
-            Type     : "mysql",
-            Role     : "master",
-            Charset  : "utf8",
-            Priority : 100,
-        },
-        {
-            Host     : "192.168.1.101",
-            Port     : "3306",
-            User     : "root",
-            Pass     : "123456",
-            Name     : "test",
-            Type     : "mysql",
-            Role     : "slave",
-            Charset  : "utf8",
-            Priority : 100,
-        },
-    },
-}
-*/
-
 // 包初始化
 func init() {
-    configs.config       = make(Config)
-    configs.defaultGroup = DEFAULT_GROUP_NAME
+	configs.config = make(Config)
+	configs.defaultGroup = DEFAULT_GROUP_NAME
 }
 
 // 设置当前应用的数据库配置信息，进行全局数据库配置覆盖操作
-func SetConfig (config Config) {
-    defer instances.Clear()
-    configs.Lock()
-    defer configs.Unlock()
-    configs.config = config
+func SetConfig(config Config) {
+	defer instances.Clear()
+	configs.Lock()
+	defer configs.Unlock()
+	configs.config = config
 }
 
 // 添加数据库服务器集群配置
-func AddConfigGroup (group string, nodes ConfigGroup) {
-    defer instances.Clear()
-    configs.Lock()
-    defer configs.Unlock()
-    configs.config[group] = nodes
+func AddConfigGroup(group string, nodes ConfigGroup) {
+	defer instances.Clear()
+	configs.Lock()
+	defer configs.Unlock()
+	configs.config[group] = nodes
 }
 
 // 添加一台数据库服务器配置
-func AddConfigNode (group string, node ConfigNode) {
-    defer instances.Clear()
-    configs.Lock()
-    defer configs.Unlock()
-    configs.config[group] = append(configs.config[group], node)
+func AddConfigNode(group string, node ConfigNode) {
+	defer instances.Clear()
+	configs.Lock()
+	defer configs.Unlock()
+	configs.config[group] = append(configs.config[group], node)
 }
 
 // 添加默认链接的一台数据库服务器配置
-func AddDefaultConfigNode (node ConfigNode) {
-    AddConfigNode(DEFAULT_GROUP_NAME, node)
+func AddDefaultConfigNode(node ConfigNode) {
+	AddConfigNode(DEFAULT_GROUP_NAME, node)
 }
 
 // 添加默认链接的数据库服务器集群配置
-func AddDefaultConfigGroup (nodes ConfigGroup) {
-    AddConfigGroup(DEFAULT_GROUP_NAME, nodes)
+func AddDefaultConfigGroup(nodes ConfigGroup) {
+	AddConfigGroup(DEFAULT_GROUP_NAME, nodes)
 }
 
 // 添加一台数据库服务器配置
-func GetConfig (group string) ConfigGroup {
-    configs.RLock()
-    defer configs.RUnlock()
-    return configs.config[group]
+func GetConfig(group string) ConfigGroup {
+	configs.RLock()
+	defer configs.RUnlock()
+	return configs.config[group]
 }
 
 // 设置默认链接的数据库链接配置项(默认是 default)
-func SetDefaultGroup (name string) {
-    defer instances.Clear()
-    configs.Lock()
-    defer configs.Unlock()
-    configs.defaultGroup = name
+func SetDefaultGroup(name string) {
+	defer instances.Clear()
+	configs.Lock()
+	defer configs.Unlock()
+	configs.defaultGroup = name
 }
 
 // 获取默认链接的数据库链接配置项(默认是 default)
 func GetDefaultGroup() string {
-    defer instances.Clear()
-    configs.Lock()
-    defer configs.Unlock()
-    return configs.defaultGroup
+	defer instances.Clear()
+	configs.RLock()
+	defer configs.RUnlock()
+	return configs.defaultGroup
 }
 
 // 设置数据库连接池中空闲链接的大小
-func (bs *dbBase) SetMaxIdleConns(n int) {
-    bs.maxIdleConnCount.Set(n)
+func (bs *dbBase) SetMaxIdleConnCount(n int) {
+	bs.maxIdleConnCount.Set(n)
 }
 
 // 设置数据库连接池最大打开的链接数量
-func (bs *dbBase) SetMaxOpenConns(n int) {
-    bs.maxOpenConnCount.Set(n)
+func (bs *dbBase) SetMaxOpenConnCount(n int) {
+	bs.maxOpenConnCount.Set(n)
 }
 
 // 设置数据库连接可重复利用的时间，超过该时间则被关闭废弃
 // 如果 d <= 0 表示该链接会一直重复利用
-func (bs *dbBase) SetConnMaxLifetime(n int) {
-    bs.maxConnLifetime.Set(n)
+func (bs *dbBase) SetMaxConnLifetime(n int) {
+	bs.maxConnLifetime.Set(n)
 }
 
 // 节点配置转换为字符串
 func (node *ConfigNode) String() string {
-    if node.LinkInfo != "" {
-        return node.LinkInfo
-    }
-    return fmt.Sprintf(`%s@%s:%s,%s,%s,%s,%s,%d-%d-%d`, node.User, node.Host, node.Port,
-        node.Name, node.Type, node.Role, node.Charset,
-        node.MaxIdleConnCount, node.MaxOpenConnCount, node.MaxConnLifetime,
-    )
+	if node.LinkInfo != "" {
+		return node.LinkInfo
+	}
+	return fmt.Sprintf(`%s@%s:%s,%s,%s,%s,%s,%v,%d-%d-%d`, node.User, node.Host, node.Port,
+		node.Name, node.Type, node.Role, node.Charset, node.Debug,
+		node.MaxIdleConnCount, node.MaxOpenConnCount, node.MaxConnLifetime,
+	)
 }
 
 // 是否开启调试服务
 func (bs *dbBase) SetDebug(debug bool) {
-    bs.debug.Set(debug)
-    if debug && bs.sqls == nil {
-        bs.sqls = gring.New(gDEFAULT_DEBUG_SQL_LENGTH)
-    }
+	if bs.debug.Val() == debug {
+		return
+	}
+	bs.debug.Set(debug)
+	if debug && bs.sqls == nil {
+		bs.sqls = gring.New(gDEFAULT_DEBUG_SQL_LENGTH)
+	}
 }
 
 // 获取是否开启调试服务
 func (bs *dbBase) getDebug() bool {
-    return bs.debug.Val()
-}
+	return bs.debug.Val()
+}