TODO updates; version updates

gaes encryption and decryption add CFB mode

.gitignore

@@ -7,7 +7,6 @@
 .settings/
 .vscode/
 vender/
-log/
 composer.lock
 gitpush.sh
 pkg/

.travis.yml

@@ -26,6 +26,10 @@ before_install:
 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

@@ -12,8 +12,12 @@
 |[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|￥66.60
+|Hades|alipay|￥66.66
+|蔡蔡|wechat|￥666.00
 |上海金保证网络科技|bank|￥2000.00
 
 

README.MD

@@ -1,21 +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>
 
-<!--
-GoFrame is a modular, loose-coupled, production-ready and most-powerful application development framework of golang. Providing a series of core components and dozens of practical modules, such as: cache, logging, containers, timer, validator, database orm, etc. Supporting web server integrated with router, cookie, session, logger, configure, template, https, hooks, rewrites and many more features. 
--->
-
-`GF(GoFrame)` is a modular, loose-coupled, production-ready and most-powerful 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

README_ZH.MD

@@ -2,16 +2,16 @@
 <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)
 
 </div>
 
-`GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
+`GF(Go Frame)`是一款模块化、高性能、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
 并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
 
 

TODO.MD

@@ -48,7 +48,7 @@
 1. 改进gdb对pgsql/mssql/oracle的支持，使用方法覆盖的方式改进操作，而不是完全依靠正则替换的方式；
 1. gdb的Cache缓存功能增加可自定义缓存接口，以便支持外部缓存功能，缓存接口可以通过io.ReadWriter接口实现；
 1. grpool增加支持阻塞添加任务接口；
-
+1. gdb.Model在链式安全的对象创建中增加sync.Pool的使用；
 
 
 # DONE

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"
+	"bytes"
 	"fmt"
+	"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 {
@@ -22,42 +23,42 @@ type IntArray struct {
 }
 
 // NewIntArray creates and returns an empty array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <reverse> controls whether sort
+// 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.
@@ -577,4 +615,4 @@ func (a *IntArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return fmt.Sprint(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"
+	"fmt"
+	"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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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,100 @@ 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()
+	return fmt.Sprint(a.array)
+}

g/container/garray/garray_normal_string.go

@@ -7,14 +7,15 @@
 package garray
 
 import (
-    "bytes"
+	"bytes"
 	"fmt"
+	"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 {
@@ -23,42 +24,42 @@ type StringArray struct {
 }
 
 // NewStringArray creates and returns an empty array.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <reverse> controls whether sort
+// 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.

g/container/garray/garray_sorted_int.go

@@ -7,378 +7,436 @@
 package garray
 
 import (
-    "bytes"
+	"bytes"
 	"fmt"
+	"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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 &SortedIntArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+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 param <reverse> controls whether sort
+// 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) == 0
+	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) {
-    index, _ = a.binSearch(value, true)
-    return
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
-    if 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.
@@ -386,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.
@@ -497,4 +540,4 @@ func (a *SortedIntArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return fmt.Sprint(a.array)
-}
+}

g/container/garray/garray_sorted_interface.go

@@ -7,379 +7,437 @@
 package garray
 
 import (
-    "bytes"
+	"bytes"
 	"fmt"
+	"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.
-// The param <unsafe> used to specify whether using array in un-concurrent-safety, which is false in default.
-// The param <comparator> used to compare values to sort in array,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety, which is false in default.
+// The parameter <comparator> used to compare values to sort in array,
 // 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using array in un-concurrent-safety,
 // which is false in default.
-func NewSortedArrayFromCopy(array []interface{}, unsafe...bool) *SortedArray {
-    newArray := make([]interface{}, len(array))
-    copy(newArray, array)
-    return &SortedArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+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 param <reverse> controls whether sort
+// 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) == 0
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedArray) Search(value interface{}) (index int) {
-    index, _ = a.binSearch(value, true)
-    return
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
-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
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
+func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result int) {
+	if 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.
@@ -387,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.
@@ -498,4 +541,4 @@ func (a *SortedArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return fmt.Sprint(a.array)
-}
+}

g/container/garray/garray_sorted_string.go

@@ -7,373 +7,431 @@
 package garray
 
 import (
-    "bytes"
+	"bytes"
 	"fmt"
+	"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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using array in un-concurrent-safety,
+// 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 &SortedStringArray{
-        mu    : rwmutex.New(unsafe...),
-        array : newArray,
-    }
+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 param <reverse> controls whether sort
+// 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) == 0
+	return a.Search(value) != -1
 }
 
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedStringArray) Search(value string) (index int) {
-    index, _ = a.binSearch(value, true)
-    return
+	if i, r := a.binSearch(value, true); r == 0 {
+		return i
+	}
+	return -1
 }
 
 // Binary search.
+// It returns the last compared index and the result.
+// If <result> equals to 0, it means the value at <index> is equals to <value>.
+// If <result> lesser than 0, it means the value at <index> is lesser than <value>.
+// If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *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.
@@ -381,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.
@@ -492,4 +535,4 @@ func (a *SortedStringArray) String() string {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return fmt.Sprint(a.array)
-}
+}

g/container/garray/garray_z_bench_test.go

@@ -9,35 +9,35 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"testing"
 )
 
 var (
-    sortedIntArray = garray.NewSortedIntArray()
+	sortedIntArray = garray.NewSortedIntArray()
 )
 
 func BenchmarkSortedIntArray_Add(b *testing.B) {
-    b.N = 1000
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.Add(i)
-    }
+	b.N = 1000
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.Add(i)
+	}
 }
 
 func BenchmarkSortedIntArray_Search(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.Search(i)
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.Search(i)
+	}
 }
 
 func BenchmarkSortedIntArray_PopLeft(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.PopLeft()
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.PopLeft()
+	}
 }
 
 func BenchmarkSortedIntArray_PopRight(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sortedIntArray.PopLeft()
-    }
+	for i := 0; i < b.N; i++ {
+		sortedIntArray.PopLeft()
+	}
 }

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

@@ -9,75 +9,86 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "github.com/gogf/gf/g/util/gconv"
-    "strings"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"testing"
 )
 
 func Test_IntArray_Unique(t *testing.T) {
-    expect := []int{1, 2, 3, 4, 5, 6}
-    array  := garray.NewIntArray()
-    array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
-    array.Unique()
-    gtest.Assert(array.Slice(), expect)
+	expect := []int{1, 2, 3, 4, 5, 6}
+	array := garray.NewIntArray()
+	array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
+	array.Unique()
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedIntArray1(t *testing.T) {
-    expect := []int{0,1,2,3,4,5,6,7,8,9,10}
-    array  := garray.NewSortedIntArray()
-    for i := 10; i > -1; i-- {
-        array.Add(i)
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	array := garray.NewSortedIntArray()
+	for i := 10; i > -1; i-- {
+		array.Add(i)
+	}
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedIntArray2(t *testing.T) {
-    expect := []int{0,1,2,3,4,5,6,7,8,9,10}
-    array  := garray.NewSortedIntArray()
-    for i := 0; i <= 10; i++ {
-        array.Add(i)
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+	array := garray.NewSortedIntArray()
+	for i := 0; i <= 10; i++ {
+		array.Add(i)
+	}
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedStringArray1(t *testing.T) {
-    expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedStringArray()
-    for i := 10; i > -1; i-- {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+	array := garray.NewSortedStringArray()
+	for i := 10; i > -1; i-- {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedStringArray2(t *testing.T) {
-    expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedStringArray()
-    for i := 0; i <= 10; i++ {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+	array := garray.NewSortedStringArray()
+	for i := 0; i <= 10; i++ {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.Slice(), expect)
 }
 
 func Test_SortedArray1(t *testing.T) {
-    expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedArray(func(v1, v2 interface{}) int {
-        return strings.Compare(gconv.String(v1), gconv.String(v2))
-    })
-    for i := 10; i > -1; i-- {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
+	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+	array := garray.NewSortedArray(func(v1, v2 interface{}) int {
+		return strings.Compare(gconv.String(v1), gconv.String(v2))
+	})
+	for i := 10; i > -1; i-- {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.Slice(), expect)
 }
 
 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 {
-        return strings.Compare(gconv.String(v1), gconv.String(v2))
-    })
-    for i := 0; i <= 10; i++ {
-        array.Add(gconv.String(i))
-    }
-    gtest.Assert(array.Slice(), expect)
-}
+	expect := []string{"0", "1", "10", "2", "3", "4", "5", "6", "7", "8", "9"}
+	array := garray.NewSortedArray(func(v1, v2 interface{}) int {
+		return strings.Compare(gconv.String(v1), gconv.String(v2))
+	})
+	for i := 0; i <= 10; i++ {
+		array.Add(gconv.String(i))
+	}
+	gtest.Assert(array.Slice(), expect)
+}
+
+func TestNewFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
+		array1 := garray.NewFromCopy(a1)
+		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,193 +9,615 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"testing"
+
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
 )
 
 func Test_IntArray_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{0, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(expect)
-        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(array.Contains(100), true)
-        gtest.Assert(array.Remove(0),     100)
-        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(), []int{100, 200, 1, 2, 3, 4})
-        array.InsertBefore(5, 300)
-        array.InsertAfter(6, 400)
-        gtest.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
-        gtest.Assert(array.Clear().Len(), 0)
-    })
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewIntArrayFrom(expect)
+		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(array.Contains(100), true)
+		gtest.Assert(array.Remove(0), 100)
+		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(), []int{100, 200, 1, 2, 3, 4})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		gtest.Assert(array.Slice(), []int{100, 200, 1, 2, 3, 300, 4, 400})
+		gtest.Assert(array.Clear().Len(), 0)
+	})
 }
 
 func TestIntArray_Sort(t *testing.T) {
-    gtest.Case(t, func() {
-        expect1 := []int{0, 1, 2, 3}
-        expect2 := []int{3, 2, 1, 0}
-        array   := garray.NewIntArray()
-        for i := 3; i >= 0; i-- {
-            array.Append(i)
-        }
-        array.Sort()
-        gtest.Assert(array.Slice(), expect1)
-        array.Sort(true)
-        gtest.Assert(array.Slice(), expect2)
-    })
+	gtest.Case(t, func() {
+		expect1 := []int{0, 1, 2, 3}
+		expect2 := []int{3, 2, 1, 0}
+		array := garray.NewIntArray()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.Sort()
+		gtest.Assert(array.Slice(), expect1)
+		array.Sort(true)
+		gtest.Assert(array.Slice(), expect2)
+	})
 }
 
 func TestIntArray_Unique(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{1, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(expect)
-        gtest.Assert(array.Unique().Slice(), []int{1, 2, 3})
-    })
+	gtest.Case(t, func() {
+		expect := []int{1, 1, 2, 3}
+		array := garray.NewIntArrayFrom(expect)
+		gtest.Assert(array.Unique().Slice(), []int{1, 2, 3})
+	})
 }
 
 func TestIntArray_PushAndPop(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []int{0, 1, 2, 3}
-        array  := garray.NewIntArrayFrom(expect)
-        gtest.Assert(array.Slice(),     expect)
-        gtest.Assert(array.PopLeft(),   0)
-        gtest.Assert(array.PopRight(),  3)
-        gtest.AssertIN(array.PopRand(), []int{1, 2})
-        gtest.AssertIN(array.PopRand(), []int{1, 2})
-        gtest.Assert(array.Len(), 0)
-        array.PushLeft(1).PushRight(2)
-        gtest.Assert(array.Slice(),    []int{1, 2})
-    })
+	gtest.Case(t, func() {
+		expect := []int{0, 1, 2, 3}
+		array := garray.NewIntArrayFrom(expect)
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.PopLeft(), 0)
+		gtest.Assert(array.PopRight(), 3)
+		gtest.AssertIN(array.PopRand(), []int{1, 2})
+		gtest.AssertIN(array.PopRand(), []int{1, 2})
+		gtest.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		gtest.Assert(array.Slice(), []int{1, 2})
+	})
 }
 
 func TestIntArray_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []int{0,1,2,3,4,5,6}
-        value2 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(value1)
-        array2 := garray.NewIntArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []int{0,1})
-        gtest.Assert(array1.Slice(), []int{2,3,4,5,6})
-        gtest.Assert(array1.PopRights(2), []int{5,6})
-        gtest.Assert(array1.Slice(), []int{2,3,4})
-        gtest.Assert(array1.PopRights(20), []int{2,3,4})
-        gtest.Assert(array1.Slice(), []int{})
-        gtest.Assert(array2.PopLefts(20), []int{0,1,2,3,4,5,6})
-        gtest.Assert(array2.Slice(), []int{})
-    })
+	gtest.Case(t, func() {
+		value1 := []int{0, 1, 2, 3, 4, 5, 6}
+		value2 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(value1)
+		array2 := garray.NewIntArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []int{0, 1})
+		gtest.Assert(array1.Slice(), []int{2, 3, 4, 5, 6})
+		gtest.Assert(array1.PopRights(2), []int{5, 6})
+		gtest.Assert(array1.Slice(), []int{2, 3, 4})
+		gtest.Assert(array1.PopRights(20), []int{2, 3, 4})
+		gtest.Assert(array1.Slice(), []int{})
+		gtest.Assert(array2.PopLefts(20), []int{0, 1, 2, 3, 4, 5, 6})
+		gtest.Assert(array2.Slice(), []int{})
+	})
 }
 
 func TestIntArray_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(value1)
-        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(-1, 10), value1)
-    })
+	gtest.Case(t, func() {
+		value1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(value1)
+		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)
+	})
 }
 
 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})
-    })
+	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})
+	})
 }
 
 func TestIntArray_Fill(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0}
-        a2 := []int{0}
-        array1 := garray.NewIntArrayFrom(a1)
-        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.Case(t, func() {
+		a1 := []int{0}
+		a2 := []int{0}
+		array1 := garray.NewIntArrayFrom(a1)
+		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})
+	})
 }
 
 func TestIntArray_Chunk(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{1,2,3,4,5}
-        array1 := garray.NewIntArrayFrom(a1)
-        chunks := array1.Chunk(2)
-        gtest.Assert(len(chunks), 3)
-        gtest.Assert(chunks[0], []int{1,2})
-        gtest.Assert(chunks[1], []int{3,4})
-        gtest.Assert(chunks[2], []int{5})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []int{1, 2})
+		gtest.Assert(chunks[1], []int{3, 4})
+		gtest.Assert(chunks[2], []int{5})
+	})
 }
 
 func TestIntArray_Pad(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Pad(3,  1).Slice(), []int{0,1,1})
-        gtest.Assert(array1.Pad(-4, 1).Slice(), []int{1,0,1,1})
-        gtest.Assert(array1.Pad(3,  1).Slice(), []int{1,0,1,1})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Pad(3, 1).Slice(), []int{0, 1, 1})
+		gtest.Assert(array1.Pad(-4, 1).Slice(), []int{1, 0, 1, 1})
+		gtest.Assert(array1.Pad(3, 1).Slice(), []int{1, 0, 1, 1})
+	})
 }
 
 func TestIntArray_SubSlice(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        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.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		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)
+	})
 }
 
 func TestIntArray_Rand(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(len(array1.Rands(2)),  2)
-        gtest.Assert(len(array1.Rands(10)), 7)
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-        gtest.AssertIN(array1.Rand(), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), 2)
+		gtest.Assert(len(array1.Rands(10)), 7)
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+		gtest.AssertIN(array1.Rand(), a1)
+	})
 }
 
 func TestIntArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{100, 200, 300, 400, 500, 600}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{100, 200, 300, 400, 500, 600}
+		array := garray.NewIntArrayFrom(a1)
+		ns1 := array.PopRands(2)
+		gtest.AssertIN(ns1, []int{100, 200, 300, 400, 500, 600})
+		gtest.AssertIN(len(ns1), 2)
+
+		ns2 := array.PopRands(7)
+		gtest.AssertIN(len(ns2), 6)
+		gtest.AssertIN(ns2, []int{100, 200, 300, 400, 500, 600})
+
+	})
 }
 
 func TestIntArray_Shuffle(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Shuffle().Len(), 7)
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Shuffle().Len(), 7)
+	})
 }
 
 func TestIntArray_Reverse(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Reverse().Slice(), []int{6,5,4,3,2,1,0})
-    })
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Reverse().Slice(), []int{6, 5, 4, 3, 2, 1, 0})
+	})
 }
 
 func TestIntArray_Join(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []int{0,1,2,3,4,5,6}
-        array1 := garray.NewIntArrayFrom(a1)
-        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
-    })
-}
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestNewSortedIntArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		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")
+	})
+}
+
+func TestNewSortedIntArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 5, 2, 1, 4, 3, 6}
+		array1 := garray.NewSortedIntArrayFromCopy(a1, false)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestSortedIntArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 1, 2, 3}
+		a2 := []int{4, 5, 6}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := array1.SetArray(a2)
+
+		gtest.Assert(array2.Len(), 3)
+		gtest.Assert(array2.Search(3), -1)
+		gtest.Assert(array2.Search(5), 1)
+		gtest.Assert(array2.Search(6), 2)
+	})
+}
+
+func TestSortedIntArray_Sort(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{0, 3, 2, 1}
+
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := array1.Sort()
+
+		gtest.Assert(array2.Len(), 4)
+		gtest.Assert(array2, []int{0, 1, 2, 3})
+
+	})
+}
+
+func TestSortedIntArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 0}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		gtest.Assert(array1.Get(0), 0)
+		gtest.Assert(array1.Get(1), 1)
+		gtest.Assert(array1.Get(3), 5)
+
+	})
+}
+
+func TestSortedIntArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 0}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.Remove(2)
+		gtest.Assert(i1, 3)
+		gtest.Assert(array1.Search(5), 2)
+
+		// 再次删除剩下的数组中的第一个
+		i2 := array1.Remove(0)
+		gtest.Assert(i2, 0)
+		gtest.Assert(array1.Search(5), 1)
+
+		a2 := []int{1, 3, 4}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		i3 := array2.Remove(1)
+		gtest.Assert(array2.Search(1), 0)
+		gtest.Assert(i3, 3)
+		i3 = array2.Remove(1)
+		gtest.Assert(array2.Search(4), -1)
+		gtest.Assert(i3, 4)
+
+	})
+}
+
+func TestSortedIntArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopLeft()
+		gtest.Assert(i1, 1)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(1), -1)
+
+	})
+}
+
+func TestSortedIntArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopRight()
+		gtest.Assert(i1, 5)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(5), -1)
+	})
+}
+
+func TestSortedIntArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		i1 := array1.PopRand()
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Search(i1), -1)
+		gtest.AssertIN(i1, []int{1, 3, 5, 2})
+	})
+}
+
+func TestSortedIntArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopRands(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.AssertIN(ns1, []int{1, 3, 5, 2})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopRands(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.Assert(len(ns2), 4)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+
+	})
+}
+
+func TestSortedIntArray_PopLefts(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopLefts(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(ns1, []int{1, 2})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopLefts(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+
+	})
+}
+
+func TestSortedIntArray_PopRights(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.PopRights(2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(ns1, []int{3, 5})
+
+		a2 := []int{1, 3, 5, 2}
+		array2 := garray.NewSortedIntArrayFrom(a2)
+		ns2 := array2.PopRights(5)
+		gtest.Assert(array2.Len(), 0)
+		gtest.AssertIN(ns2, []int{1, 3, 5, 2})
+	})
+}
+
+func TestSortedIntArray_Range(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5, 2, 6, 7}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Range(1, 4)
+		gtest.Assert(len(ns1), 3)
+		gtest.Assert(ns1, []int{2, 3, 5})
+
+		ns2 := array1.Range(5, 4)
+		gtest.Assert(len(ns2), 0)
+
+		ns3 := array1.Range(-1, 4)
+		gtest.Assert(len(ns3), 4)
+
+		nsl := array1.Range(5, 8)
+		gtest.Assert(len(nsl), 1)
+
+	})
+}
+
+func TestSortedIntArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		n1 := array1.Sum()
+		gtest.Assert(n1, 9)
+	})
+}
+
+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)
+	})
+}
+
+func TestSortedIntArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array2.Len(), 3)
+		gtest.Assert(array2, array1)
+	})
+}
+
+func TestSortedIntArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 3, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedIntArray_Chunk(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Chunk(2) //按每几个元素切成一个数组
+		ns2 := array1.Chunk(-1)
+		gtest.Assert(len(ns1), 3)
+		gtest.Assert(ns1[0], []int{1, 2})
+		gtest.Assert(ns1[2], []int{5})
+		gtest.Assert(len(ns2), 0)
+
+	})
+}
+
+func TestSortedIntArray_SubSlice(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.SubSlice(1, 2)
+		gtest.Assert(len(ns1), 2)
+		gtest.Assert(ns1, []int{2, 3})
+
+		ns2 := array1.SubSlice(7, 2)
+		gtest.Assert(len(ns2), 0)
+
+		ns3 := array1.SubSlice(3, 5)
+		gtest.Assert(len(ns3), 2)
+		gtest.Assert(ns3, []int{4, 5})
+
+		ns4 := array1.SubSlice(3, 1)
+		gtest.Assert(len(ns4), 1)
+		gtest.Assert(ns4, []int{4})
+	})
+}
+
+func TestSortedIntArray_Rand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Rand() //按每几个元素切成一个数组
+		gtest.AssertIN(ns1, a1)
+	})
+}
+
+func TestSortedIntArray_Rands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.Rands(2) //按每几个元素切成一个数组
+		gtest.AssertIN(ns1, a1)
+		gtest.Assert(len(ns1), 2)
+
+		ns2 := array1.Rands(6) //按每几个元素切成一个数组
+		gtest.AssertIN(ns2, a1)
+		gtest.Assert(len(ns2), 5)
+	})
+}
+
+func TestSortedIntArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 3}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		ns1 := array1.CountValues() //按每几个元素切成一个数组
+		gtest.Assert(len(ns1), 5)
+		gtest.Assert(ns1[2], 1)
+		gtest.Assert(ns1[3], 2)
+	})
+}
+
+func TestSortedIntArray_SetUnique(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 3}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array1.SetUnique(true)
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(array1, []int{1, 2, 3, 4, 5})
+
+	})
+}
+
+func TestIntArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		a2 := []int{6, 7}
+		array1 := garray.NewIntArrayFrom(a1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1, []int{6, 7})
+
+	})
+}
+
+func TestIntArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		a2 := []int{6, 7}
+		a3 := []int{9, 10, 11, 12, 13}
+		array1 := garray.NewIntArrayFrom(a1)
+		array1.Replace(a2)
+		gtest.Assert(array1, []int{6, 7, 3, 5})
+
+		array1.Replace(a3)
+		gtest.Assert(array1, []int{9, 10, 11, 12})
+	})
+}
+
+func TestIntArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+	})
+}
+
+func TestIntArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array1, array2)
+	})
+}
+
+func TestArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Get(2), 3)
+		gtest.Assert(array1.Len(), 4)
+	})
+}
+
+func TestIntArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		gtest.Assert(array1.Sum(), 11)
+	})
+}
+
+func TestIntArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 3}
+		array1 := garray.NewIntArrayFrom(a1)
+		m1 := array1.CountValues()
+		gtest.Assert(len(m1), 4)
+		gtest.Assert(m1[1], 1)
+		gtest.Assert(m1[3], 2)
+	})
+}
+
+func TestNewIntArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 3}
+		array1 := garray.NewIntArrayFromCopy(a1)
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(array1, a1)
+	})
+}
+
+func TestIntArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 5, 4}
+		array1 := garray.NewIntArrayFrom(a1)
+		n1 := array1.Remove(1)
+		gtest.Assert(n1, 2)
+		gtest.Assert(array1.Len(), 4)
+
+		n1 = array1.Remove(0)
+		gtest.Assert(n1, 1)
+		gtest.Assert(array1.Len(), 3)
+
+		n1 = array1.Remove(2)
+		gtest.Assert(n1, 4)
+		gtest.Assert(array1.Len(), 2)
+	})
+}

g/container/garray/garray_z_unit_interface_test.go

@@ -9,196 +9,670 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"testing"
 )
 
 func Test_Array_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{0, 1, 2, 3}
-        array  := garray.NewArrayFrom(expect)
-        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(array.Contains(100), true)
-        gtest.Assert(array.Remove(0),     100)
-        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})
-        array.InsertBefore(5, 300)
-        array.InsertAfter(6, 400)
-        gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 300, 4, 400})
-        gtest.Assert(array.Clear().Len(), 0)
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{0, 1, 2, 3}
+		array := garray.NewArrayFrom(expect)
+		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(array.Contains(100), true)
+		gtest.Assert(array.Remove(0), 100)
+		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})
+		array.InsertBefore(5, 300)
+		array.InsertAfter(6, 400)
+		gtest.Assert(array.Slice(), []interface{}{100, 200, 1, 2, 3, 300, 4, 400})
+		gtest.Assert(array.Clear().Len(), 0)
+	})
 }
 
 func TestArray_Sort(t *testing.T) {
-    gtest.Case(t, func() {
-        expect1 := []interface{}{0, 1, 2, 3}
-        expect2 := []interface{}{3, 2, 1, 0}
-        array   := garray.NewArray()
-        for i := 3; i >= 0; i-- {
-            array.Append(i)
-        }
-        array.SortFunc(func(v1, v2 interface{}) bool {
-            return v1.(int) < v2.(int)
-        })
-        gtest.Assert(array.Slice(), expect1)
-        array.SortFunc(func(v1, v2 interface{}) bool {
-            return v1.(int) > v2.(int)
-        })
-        gtest.Assert(array.Slice(), expect2)
-    })
+	gtest.Case(t, func() {
+		expect1 := []interface{}{0, 1, 2, 3}
+		expect2 := []interface{}{3, 2, 1, 0}
+		array := garray.NewArray()
+		for i := 3; i >= 0; i-- {
+			array.Append(i)
+		}
+		array.SortFunc(func(v1, v2 interface{}) bool {
+			return v1.(int) < v2.(int)
+		})
+		gtest.Assert(array.Slice(), expect1)
+		array.SortFunc(func(v1, v2 interface{}) bool {
+			return v1.(int) > v2.(int)
+		})
+		gtest.Assert(array.Slice(), expect2)
+	})
 }
 
 func TestArray_Unique(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{1, 1, 2, 3}
-        array  := garray.NewArrayFrom(expect)
-        gtest.Assert(array.Unique().Slice(), []interface{}{1, 2, 3})
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{1, 1, 2, 3}
+		array := garray.NewArrayFrom(expect)
+		gtest.Assert(array.Unique().Slice(), []interface{}{1, 2, 3})
+	})
 }
 
 func TestArray_PushAndPop(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []interface{}{0, 1, 2, 3}
-        array  := garray.NewArrayFrom(expect)
-        gtest.Assert(array.Slice(),     expect)
-        gtest.Assert(array.PopLeft(),   0)
-        gtest.Assert(array.PopRight(),  3)
-        gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
-        gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
-        gtest.Assert(array.Len(), 0)
-        array.PushLeft(1).PushRight(2)
-        gtest.Assert(array.Slice(),    []interface{}{1, 2})
-    })
+	gtest.Case(t, func() {
+		expect := []interface{}{0, 1, 2, 3}
+		array := garray.NewArrayFrom(expect)
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.PopLeft(), 0)
+		gtest.Assert(array.PopRight(), 3)
+		gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
+		gtest.AssertIN(array.PopRand(), []interface{}{1, 2})
+		gtest.Assert(array.Len(), 0)
+		array.PushLeft(1).PushRight(2)
+		gtest.Assert(array.Slice(), []interface{}{1, 2})
+	})
 }
 
 func TestArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{100, 200, 300, 400, 500, 600}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{100, 200, 300, 400, 500, 600}
+		array := garray.NewFromCopy(a1)
+		gtest.AssertIN(array.PopRands(2), a1)
+	})
 }
 
 func TestArray_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []interface{}{0,1,2,3,4,5,6}
-        value2 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(value1)
-        array2 := garray.NewArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []interface{}{0,1})
-        gtest.Assert(array1.Slice(), []interface{}{2,3,4,5,6})
-        gtest.Assert(array1.PopRights(2), []interface{}{5,6})
-        gtest.Assert(array1.Slice(), []interface{}{2,3,4})
-        gtest.Assert(array1.PopRights(20), []interface{}{2,3,4})
-        gtest.Assert(array1.Slice(), []interface{}{})
-        gtest.Assert(array2.PopLefts(20), []interface{}{0,1,2,3,4,5,6})
-        gtest.Assert(array2.Slice(), []interface{}{})
-    })
+	gtest.Case(t, func() {
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		value2 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(value1)
+		array2 := garray.NewArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []interface{}{0, 1})
+		gtest.Assert(array1.Slice(), []interface{}{2, 3, 4, 5, 6})
+		gtest.Assert(array1.PopRights(2), []interface{}{5, 6})
+		gtest.Assert(array1.Slice(), []interface{}{2, 3, 4})
+		gtest.Assert(array1.PopRights(20), []interface{}{2, 3, 4})
+		gtest.Assert(array1.Slice(), []interface{}{})
+		gtest.Assert(array2.PopLefts(20), []interface{}{0, 1, 2, 3, 4, 5, 6})
+		gtest.Assert(array2.Slice(), []interface{}{})
+	})
 }
 
 func TestArray_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(value1)
-        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.Case(t, func() {
+		value1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(value1)
+		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)
+	})
 }
 
 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)
-        gtest.Assert(array1.Merge(array2).Slice(), []interface{}{0,1,2,3,4,5,6,7})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		a2 := []interface{}{4, 5, 6, 7}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		gtest.Assert(array1.Merge(array2).Slice(), []interface{}{0, 1, 2, 3, 4, 5, 6, 7})
+	})
 }
 
 func TestArray_Fill(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0}
-        a2 := []interface{}{0}
-        array1 := garray.NewArrayFrom(a1)
-        array2 := garray.NewArrayFrom(a2)
-        gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0,100,100})
-        gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100,100})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0}
+		a2 := []interface{}{0}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		gtest.Assert(array1.Fill(1, 2, 100).Slice(), []interface{}{0, 100, 100})
+		gtest.Assert(array2.Fill(0, 2, 100).Slice(), []interface{}{100, 100})
+	})
 }
 
 func TestArray_Chunk(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{1,2,3,4,5}
-        array1 := garray.NewArrayFrom(a1)
-        chunks := array1.Chunk(2)
-        gtest.Assert(len(chunks), 3)
-        gtest.Assert(chunks[0], []interface{}{1,2})
-        gtest.Assert(chunks[1], []interface{}{3,4})
-        gtest.Assert(chunks[2], []interface{}{5})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5}
+		array1 := garray.NewArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []interface{}{1, 2})
+		gtest.Assert(chunks[1], []interface{}{3, 4})
+		gtest.Assert(chunks[2], []interface{}{5})
+	})
 }
 
 func TestArray_Pad(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Pad(3,  1).Slice(), []interface{}{0,1,1})
-        gtest.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1,0,1,1})
-        gtest.Assert(array1.Pad(3,  1).Slice(), []interface{}{1,0,1,1})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Pad(3, 1).Slice(), []interface{}{0, 1, 1})
+		gtest.Assert(array1.Pad(-4, 1).Slice(), []interface{}{1, 0, 1, 1})
+		gtest.Assert(array1.Pad(3, 1).Slice(), []interface{}{1, 0, 1, 1})
+	})
 }
 
 func TestArray_SubSlice(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        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.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		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})
+	})
 }
 
 func TestArray_Rand(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(len(array1.Rands(2)),  2)
-        gtest.Assert(len(array1.Rands(10)), 7)
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), 2)
+		gtest.Assert(len(array1.Rands(10)), 7)
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+	})
 }
 
 func TestArray_Shuffle(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Shuffle().Len(), 7)
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Shuffle().Len(), 7)
+	})
 }
 
 func TestArray_Reverse(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Reverse().Slice(), []interface{}{6,5,4,3,2,1,0})
-    })
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Reverse().Slice(), []interface{}{6, 5, 4, 3, 2, 1, 0})
+	})
 }
 
 func TestArray_Join(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{0,1,2,3,4,5,6}
-        array1 := garray.NewArrayFrom(a1)
-        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
-    })
-}
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"m", "n", "p", "z", "x", "y", "d", "u"}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.Replace(a2)
+		gtest.Assert(array2.Len(), 7)
+		gtest.Assert(array2.Contains("b"), true)
+		gtest.Assert(array2.Contains(4), true)
+		gtest.Assert(array2.Contains("v"), false)
+		array3 := array1.Replace(a3)
+		gtest.Assert(array3.Len(), 7)
+		gtest.Assert(array3.Contains(4), false)
+		gtest.Assert(array3.Contains("p"), true)
+		gtest.Assert(array3.Contains("u"), false)
+	})
+}
+
+func TestArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3, 4, 5, 6}
+		a2 := []interface{}{"a", "b", "c"}
+
+		array1 := garray.NewArrayFrom(a1)
+		array1 = array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("b"), true)
+		gtest.Assert(array1.Contains("5"), false)
+	})
+}
+
+func TestArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		a2 := []interface{}{"a", "b", "c"}
+		a3 := []interface{}{"a", "1", "2"}
+
+		array1 := garray.NewArrayFrom(a1)
+		array2 := garray.NewArrayFrom(a2)
+		array3 := garray.NewArrayFrom(a3)
+
+		gtest.Assert(array1.Sum(), 6)
+		gtest.Assert(array2.Sum(), 0)
+		gtest.Assert(array3.Sum(), 3)
+
+	})
+}
+
+func TestArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{0, 1, 2, 3}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.Clone()
+
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array2.Sum(), 6)
+		gtest.AssertEQ(array1, array2)
+
+	})
+}
+
+func TestArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "b", "c", "d", "e", "d"}
+		array1 := garray.NewArrayFrom(a1)
+		array2 := array1.CountValues()
+		gtest.Assert(len(array2), 5)
+		gtest.Assert(array2["b"], 1)
+		gtest.Assert(array2["d"], 2)
+	})
+}
+
+func TestSortedArray_NewSortedArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"h", "j", "i", "k"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 interface{}) int {
+			return -1
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := garray.NewSortedArrayFrom(a2, func2)
+
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+
+		gtest.Assert(array2.Len(), 4)
+		gtest.Assert(array2, []interface{}{"k", "i", "j", "h"})
+	})
+}
+
+func TestNewSortedArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		func2 := func(v1, v2 interface{}) int {
+			return -1
+		}
+		array1 := garray.NewSortedArrayFromCopy(a1, func1)
+		array2 := garray.NewSortedArrayFromCopy(a1, func2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array2, []interface{}{"c", "f", "a"})
+	})
+}
+
+func TestSortedArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		a2 := []interface{}{"e", "h", "g", "k"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1, []interface{}{"e", "g", "h", "k"})
+	})
+
+}
+
+func TestSortedArray_Sort(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1.Sort()
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "f"})
+	})
+
+}
+
+func TestSortedArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "f", "c"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		gtest.Assert(array1.Get(2), "f")
+		gtest.Assert(array1.Get(1), "c")
+	})
+
+}
+
+func TestSortedArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Remove(1)
+		gtest.Assert(gconv.String(i1), "b")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("b"), false)
+
+		i2 := array1.Remove(0)
+		gtest.Assert(gconv.String(i2), "a")
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1.Contains("a"), false)
+
+		i3 := array1.Remove(1)
+		gtest.Assert(gconv.String(i3), "d")
+		gtest.Assert(array1.Len(), 1)
+		gtest.Assert(array1.Contains("d"), false)
+	})
+
+}
+
+func TestSortedArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopLeft()
+		gtest.Assert(gconv.String(i1), "a")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"b", "c", "d"})
+	})
+
+}
+
+func TestSortedArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRight()
+		gtest.Assert(gconv.String(i1), "d")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "b", "c"})
+	})
+
+}
+
+func TestSortedArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRand()
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 3)
+
+	})
+}
+
+func TestSortedArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRands(2)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 2)
+
+		i2 := array1.PopRands(3)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i2, []interface{}{"a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedArray_PopLefts(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopLefts(2)
+		gtest.Assert(len(i1), 2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
+		gtest.Assert(array1.Len(), 4)
+
+		i2 := array1.PopLefts(5)
+		gtest.Assert(len(i2), 4)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedArray_PopRights(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.PopRights(2)
+		gtest.Assert(len(i1), 2)
+		gtest.Assert(i1, []interface{}{"e", "f"})
+		gtest.Assert(array1.Len(), 4)
+
+		i2 := array1.PopRights(10)
+		gtest.Assert(len(i2), 4)
+
+	})
+}
+
+func TestSortedArray_Range(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Range(2, 5)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+		gtest.Assert(array1.Len(), 6)
+
+		i2 := array1.Range(7, 5)
+		gtest.Assert(len(i2), 0)
+		i2 = array1.Range(-1, 2)
+		gtest.Assert(i2, []interface{}{"a", "b"})
+
+		i2 = array1.Range(4, 10)
+		gtest.Assert(len(i2), 2)
+		gtest.Assert(i2, []interface{}{"e", "f"})
+
+	})
+}
+
+func TestSortedArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+		a2 := []interface{}{"1", "2", "3", "b", "e", "f"}
+		a3 := []interface{}{"4", "5", "6"}
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := garray.NewSortedArrayFrom(a2, func1)
+		array3 := garray.NewSortedArrayFrom(a3, func1)
+		gtest.Assert(array1.Sum(), 0)
+		gtest.Assert(array2.Sum(), 6)
+		gtest.Assert(array3.Sum(), 15)
+
+	})
+}
+
+func TestSortedArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array2 := array1.Clone()
+		gtest.Assert(array1, array2)
+		array1.Remove(1)
+		gtest.AssertNE(array1, array2)
+
+	})
+}
+
+func TestSortedArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e", "f"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		gtest.Assert(array1.Len(), 6)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedArray_Chunk(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Chunk(2)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1[0], []interface{}{"a", "b"})
+		gtest.Assert(i1[2], []interface{}{"e"})
+
+		i1 = array1.Chunk(0)
+		gtest.Assert(len(i1), 0)
+	})
+}
+
+func TestSortedArray_SubSlice(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "b", "e"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.SubSlice(2, 3)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+
+		i1 = array1.SubSlice(2, 6)
+		gtest.Assert(len(i1), 3)
+		gtest.Assert(i1, []interface{}{"c", "d", "e"})
+
+		i1 = array1.SubSlice(7, 2)
+		gtest.Assert(len(i1), 0)
+
+	})
+}
+
+func TestSortedArray_Rand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Rand()
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c"})
+		gtest.Assert(array1.Len(), 3)
+	})
+}
+
+func TestSortedArray_Rands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		i1 := array1.Rands(2)
+		gtest.AssertIN(i1, []interface{}{"a", "d", "c"})
+		gtest.Assert(len(i1), 2)
+		gtest.Assert(array1.Len(), 3)
+
+		i1 = array1.Rands(4)
+		gtest.Assert(len(i1), 3)
+	})
+}
+
+func TestSortedArray_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		gtest.Assert(array1.Join(","), "a,c,d")
+		gtest.Assert(array1.Join("."), "a.c.d")
+
+	})
+}
+
+func TestSortedArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		m1 := array1.CountValues()
+		gtest.Assert(len(m1), 3)
+		gtest.Assert(m1["c"], 2)
+		gtest.Assert(m1["a"], 1)
+
+	})
+}
+
+func TestSortedArray_SetUnique(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []interface{}{"a", "d", "c", "c"}
+
+		func1 := func(v1, v2 interface{}) int {
+			return strings.Compare(gconv.String(v1), gconv.String(v2))
+		}
+		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1.SetUnique(true)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1, []interface{}{"a", "c", "d"})
+	})
+}

g/container/garray/garray_z_unit_string_test.go

@@ -9,193 +9,631 @@
 package garray_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/test/gtest"
-    "github.com/gogf/gf/g/util/gconv"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
+	"testing"
 )
 
 func Test_StringArray_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []string{"0", "1", "2", "3"}
-        array  := garray.NewStringArrayFrom(expect)
-        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(array.Contains("100"), true)
-        gtest.Assert(array.Remove(0),     100)
-        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(), []string{"100", "200", "1", "2", "3", "4"})
-        array.InsertBefore(5, "300")
-        array.InsertAfter(6, "400")
-        gtest.Assert(array.Slice(), []string{"100", "200", "1", "2", "3", "300", "4", "400"})
-        gtest.Assert(array.Clear().Len(), 0)
-    })
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "2", "3"}
+		array := garray.NewStringArrayFrom(expect)
+		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(array.Contains("100"), true)
+		gtest.Assert(array.Remove(0), 100)
+		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(), []string{"100", "200", "1", "2", "3", "4"})
+		array.InsertBefore(5, "300")
+		array.InsertAfter(6, "400")
+		gtest.Assert(array.Slice(), []string{"100", "200", "1", "2", "3", "300", "4", "400"})
+		gtest.Assert(array.Clear().Len(), 0)
+	})
 }
 
 func TestStringArray_Sort(t *testing.T) {
-    gtest.Case(t, func() {
-        expect1 := []string{"0", "1", "2", "3"}
-        expect2 := []string{"3", "2", "1", "0"}
-        array   := garray.NewStringArray()
-        for i := 3; i >= 0; i-- {
-            array.Append(gconv.String(i))
-        }
-        array.Sort()
-        gtest.Assert(array.Slice(), expect1)
-        array.Sort(true)
-        gtest.Assert(array.Slice(), expect2)
-    })
+	gtest.Case(t, func() {
+		expect1 := []string{"0", "1", "2", "3"}
+		expect2 := []string{"3", "2", "1", "0"}
+		array := garray.NewStringArray()
+		for i := 3; i >= 0; i-- {
+			array.Append(gconv.String(i))
+		}
+		array.Sort()
+		gtest.Assert(array.Slice(), expect1)
+		array.Sort(true)
+		gtest.Assert(array.Slice(), expect2)
+	})
 }
 
 func TestStringArray_Unique(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []string{"1", "1", "2", "3"}
-        array  := garray.NewStringArrayFrom(expect)
-        gtest.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
-    })
+	gtest.Case(t, func() {
+		expect := []string{"1", "1", "2", "3"}
+		array := garray.NewStringArrayFrom(expect)
+		gtest.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
+	})
 }
 
 func TestStringArray_PushAndPop(t *testing.T) {
-    gtest.Case(t, func() {
-        expect := []string{"0", "1", "2", "3"}
-        array  := garray.NewStringArrayFrom(expect)
-        gtest.Assert(array.Slice(),     expect)
-        gtest.Assert(array.PopLeft(),   "0")
-        gtest.Assert(array.PopRight(),  "3")
-        gtest.AssertIN(array.PopRand(), []string{"1", "2"})
-        gtest.AssertIN(array.PopRand(), []string{"1", "2"})
-        gtest.Assert(array.Len(), 0)
-        array.PushLeft("1").PushRight("2")
-        gtest.Assert(array.Slice(),    []string{"1", "2"})
-    })
+	gtest.Case(t, func() {
+		expect := []string{"0", "1", "2", "3"}
+		array := garray.NewStringArrayFrom(expect)
+		gtest.Assert(array.Slice(), expect)
+		gtest.Assert(array.PopLeft(), "0")
+		gtest.Assert(array.PopRight(), "3")
+		gtest.AssertIN(array.PopRand(), []string{"1", "2"})
+		gtest.AssertIN(array.PopRand(), []string{"1", "2"})
+		gtest.Assert(array.Len(), 0)
+		array.PushLeft("1").PushRight("2")
+		gtest.Assert(array.Slice(), []string{"1", "2"})
+	})
 }
 
 func TestStringArray_PopLeftsAndPopRights(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []string{"0","1","2","3","4","5","6"}
-        value2 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(value1)
-        array2 := garray.NewStringArrayFrom(value2)
-        gtest.Assert(array1.PopLefts(2), []interface{}{"0","1"})
-        gtest.Assert(array1.Slice(), []interface{}{"2","3","4","5","6"})
-        gtest.Assert(array1.PopRights(2), []interface{}{"5","6"})
-        gtest.Assert(array1.Slice(), []interface{}{"2","3","4"})
-        gtest.Assert(array1.PopRights(20), []interface{}{"2","3","4"})
-        gtest.Assert(array1.Slice(), []interface{}{})
-        gtest.Assert(array2.PopLefts(20), []interface{}{"0","1","2","3","4","5","6"})
-        gtest.Assert(array2.Slice(), []interface{}{})
-    })
+	gtest.Case(t, func() {
+		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		value2 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(value1)
+		array2 := garray.NewStringArrayFrom(value2)
+		gtest.Assert(array1.PopLefts(2), []interface{}{"0", "1"})
+		gtest.Assert(array1.Slice(), []interface{}{"2", "3", "4", "5", "6"})
+		gtest.Assert(array1.PopRights(2), []interface{}{"5", "6"})
+		gtest.Assert(array1.Slice(), []interface{}{"2", "3", "4"})
+		gtest.Assert(array1.PopRights(20), []interface{}{"2", "3", "4"})
+		gtest.Assert(array1.Slice(), []interface{}{})
+		gtest.Assert(array2.PopLefts(20), []interface{}{"0", "1", "2", "3", "4", "5", "6"})
+		gtest.Assert(array2.Slice(), []interface{}{})
+	})
 }
 
 func TestString_Range(t *testing.T) {
-    gtest.Case(t, func() {
-        value1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(value1)
-        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.Case(t, func() {
+		value1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(value1)
+		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)
+	})
 }
 
 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)
-        gtest.Assert(array1.Merge(array2).Slice(), []string{"0","1","2","3","4","5","6","7"})
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3"}
+		a2 := []string{"4", "5", "6", "7"}
+		array1 := garray.NewStringArrayFrom(a1)
+		array2 := garray.NewStringArrayFrom(a2)
+		gtest.Assert(array1.Merge(array2).Slice(), []string{"0", "1", "2", "3", "4", "5", "6", "7"})
+	})
 }
 
 func TestStringArray_Fill(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0"}
-        a2 := []string{"0"}
-        array1 := garray.NewStringArrayFrom(a1)
-        array2 := garray.NewStringArrayFrom(a2)
-        gtest.Assert(array1.Fill(1, 2, "100").Slice(), []string{"0","100","100"})
-        gtest.Assert(array2.Fill(0, 2, "100").Slice(), []string{"100","100"})
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0"}
+		a2 := []string{"0"}
+		array1 := garray.NewStringArrayFrom(a1)
+		array2 := garray.NewStringArrayFrom(a2)
+		gtest.Assert(array1.Fill(1, 2, "100").Slice(), []string{"0", "100", "100"})
+		gtest.Assert(array2.Fill(0, 2, "100").Slice(), []string{"100", "100"})
+		s1 := array2.Fill(-1, 2, "100")
+		gtest.Assert(s1.Len(), 2)
+	})
 }
 
 func TestStringArray_Chunk(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"1","2","3","4","5"}
-        array1 := garray.NewStringArrayFrom(a1)
-        chunks := array1.Chunk(2)
-        gtest.Assert(len(chunks), 3)
-        gtest.Assert(chunks[0], []string{"1","2"})
-        gtest.Assert(chunks[1], []string{"3","4"})
-        gtest.Assert(chunks[2], []string{"5"})
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5"}
+		array1 := garray.NewStringArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []string{"1", "2"})
+		gtest.Assert(chunks[1], []string{"3", "4"})
+		gtest.Assert(chunks[2], []string{"5"})
+		gtest.Assert(len(array1.Chunk(0)), 0)
+
+	})
 }
 
 func TestStringArray_Pad(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0"}
-        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(array1.Pad(3,  "1").Slice(), []string{"0","1","1"})
-        gtest.Assert(array1.Pad(-4, "1").Slice(), []string{"1","0","1","1"})
-        gtest.Assert(array1.Pad(3,  "1").Slice(), []string{"1","0","1","1"})
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Pad(3, "1").Slice(), []string{"0", "1", "1"})
+		gtest.Assert(array1.Pad(-4, "1").Slice(), []string{"1", "0", "1", "1"})
+		gtest.Assert(array1.Pad(3, "1").Slice(), []string{"1", "0", "1", "1"})
+	})
 }
 
 func TestStringArray_SubSlice(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(a1)
-        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.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		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"})
+	})
 }
 
 func TestStringArray_Rand(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(len(array1.Rands(2)),  "2")
-        gtest.Assert(len(array1.Rands(10)), "7")
-        gtest.AssertIN(array1.Rands(1)[0], a1)
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(len(array1.Rands(2)), "2")
+		gtest.Assert(len(array1.Rands(10)), "7")
+		gtest.AssertIN(array1.Rands(1)[0], a1)
+		gtest.Assert(len(array1.Rand()), 1)
+		gtest.AssertIN(array1.Rand(), a1)
+
+	})
 }
 
 func TestStringArray_PopRands(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []interface{}{"100", "200", "300", "400", "500", "600"}
-        array := garray.NewFromCopy(a1)
-        gtest.AssertIN(array.PopRands(2), a1)
-    })
+	gtest.Case(t, func() {
+		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, ","))
+
+	})
 }
 
 func TestStringArray_Shuffle(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(array1.Shuffle().Len(), 7)
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Shuffle().Len(), 7)
+	})
 }
 
 func TestStringArray_Reverse(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(array1.Reverse().Slice(), []string{"6","5","4","3","2","1","0"})
-    })
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Reverse().Slice(), []string{"6", "5", "4", "3", "2", "1", "0"})
+	})
 }
 
 func TestStringArray_Join(t *testing.T) {
-    gtest.Case(t, func() {
-        a1 := []string{"0","1","2","3","4","5","6"}
-        array1 := garray.NewStringArrayFrom(a1)
-        gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
-    })
-}
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Join("."), "0.1.2.3.4.5.6")
+	})
+}
+
+func TestNewStringArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := garray.NewStringArrayFromCopy(a1)
+		a3 := garray.NewStringArrayFromCopy(a1, true)
+		gtest.Assert(a2.Contains("1"), true)
+		gtest.Assert(a2.Len(), 7)
+		gtest.Assert(a2, a3)
+	})
+}
+
+func TestStringArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := []string{"a", "b", "c", "d"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Contains("2"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.SetArray(a2)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1.Len(), 4)
+	})
+}
+
+func TestStringArray_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		a2 := []string{"a", "b", "c", "d"}
+		a3 := []string{"o", "p", "q", "x", "y", "z", "w", "r", "v"}
+		array1 := garray.NewStringArrayFrom(a1)
+		gtest.Assert(array1.Contains("2"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.Replace(a2)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1.Contains("5"), true)
+		gtest.Assert(array1.Len(), 7)
+
+		array1 = array1.Replace(a3)
+		gtest.Assert(array1.Contains("2"), false)
+		gtest.Assert(array1.Contains("c"), false)
+		gtest.Assert(array1.Contains("5"), false)
+		gtest.Assert(array1.Contains("p"), true)
+		gtest.Assert(array1.Contains("r"), false)
+		gtest.Assert(array1.Len(), 7)
+
+	})
+}
+
+func TestStringArray_Sum(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)
+		array2 := garray.NewStringArrayFrom(a2)
+		gtest.Assert(array1.Sum(), 21)
+		gtest.Assert(array2.Sum(), 18)
+	})
+}
+
+//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"}
+		array1 := garray.NewStringArrayFrom(a1)
+		str1 := array1.PopRand()
+		gtest.Assert(strings.Contains("0,1,2,3,4,5,6", str1), true)
+		gtest.Assert(array1.Len(), 6)
+	})
+}
+
+func TestStringArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array2, array1)
+		gtest.Assert(array2.Len(), 7)
+	})
+}
+
+func TestStringArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"0", "1", "2", "3", "4", "4", "6"}
+		array1 := garray.NewStringArrayFrom(a1)
+
+		m1 := array1.CountValues()
+		gtest.Assert(len(m1), 6)
+		gtest.Assert(m1["2"], 1)
+		gtest.Assert(m1["4"], 2)
+
+	})
+}
+
+func TestNewSortedStringArrayFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStringArrayFrom(a1, true)
+		gtest.Assert(s1, []string{"a", "b", "c", "d"})
+		s2 := garray.NewSortedStringArrayFrom(a1, false)
+		gtest.Assert(s2, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestNewSortedStringArrayFromCopy(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		s1 := garray.NewSortedStringArrayFromCopy(a1, true)
+		gtest.Assert(s1.Len(), 4)
+		gtest.Assert(s1, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestSortedStringArray_SetArray(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		a2 := []string{"f", "g", "h"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array1.SetArray(a2)
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("d"), false)
+		gtest.Assert(array1.Contains("b"), false)
+		gtest.Assert(array1.Contains("g"), true)
+
+	})
+}
+
+func TestSortedStringArray_Sort(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+
+		gtest.Assert(array1, []string{"a", "b", "c", "d"})
+		array1.Sort() //todo 这个SortedStringArray.sort这个方法没有必要，
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("c"), true)
+		gtest.Assert(array1, []string{"a", "b", "c", "d"})
+	})
+}
+
+func TestSortedStringArray_Get(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Get(2), "c")
+		gtest.Assert(array1.Get(0), "a")
+
+	})
+}
+
+func TestSortedStringArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Remove(2), "c")
+		gtest.Assert(array1.Get(2), "d")
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(array1.Contains("c"), false)
+
+		gtest.Assert(array1.Remove(0), "a")
+		gtest.Assert(array1.Len(), 2)
+		gtest.Assert(array1.Contains("a"), false)
+
+		// 此时array1里的元素只剩下2个
+		gtest.Assert(array1.Remove(1), "d")
+		gtest.Assert(array1.Len(), 1)
+
+	})
+}
+
+func TestSortedStringArray_PopLeft(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopLeft()
+		gtest.Assert(s1, "a")
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("a"), false)
+	})
+}
+
+func TestSortedStringArray_PopRight(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRight()
+		gtest.Assert(s1, "e")
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains("e"), false)
+	})
+}
+
+func TestSortedStringArray_PopRand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRand()
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 4)
+		gtest.Assert(array1.Contains(s1), false)
+	})
+}
+
+func TestSortedStringArray_PopRands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRands(2)
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.PopRands(4)
+		gtest.Assert(len(s1), 3)
+		gtest.AssertIN(s1, []string{"e", "a", "d", "c", "b"})
+	})
+}
+
+func TestSortedStringArray_PopLefts(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopLefts(2)
+		gtest.Assert(s1, []string{"a", "b"})
+		gtest.Assert(array1.Len(), 3)
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.PopLefts(4)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"c", "d", "e"})
+	})
+}
+
+func TestSortedStringArray_PopRights(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.PopRights(2)
+		gtest.Assert(s1, []string{"f", "g"})
+		gtest.Assert(array1.Len(), 5)
+		gtest.Assert(len(s1), 2)
+		s1 = array1.PopRights(6)
+		gtest.Assert(len(s1), 5)
+		gtest.Assert(s1, []string{"a", "b", "c", "d", "e"})
+		gtest.Assert(array1.Len(), 0)
+	})
+}
+
+func TestSortedStringArray_Range(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.Range(2, 4)
+		gtest.Assert(len(s1), 2)
+		gtest.Assert(s1, []string{"c", "d"})
+
+		s1 = array1.Range(-1, 2)
+		gtest.Assert(len(s1), 2)
+		gtest.Assert(s1, []string{"a", "b"})
+
+		s1 = array1.Range(4, 8)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"e", "f", "g"})
+	})
+}
+
+func TestSortedStringArray_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		a2 := []string{"1", "2", "3", "4", "a"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := garray.NewSortedStringArrayFrom(a2)
+		gtest.Assert(array1.Sum(), 0)
+		gtest.Assert(array2.Sum(), 10)
+	})
+}
+
+func TestSortedStringArray_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.Clone()
+		gtest.Assert(array1, array2)
+		array1.Remove(1)
+		gtest.Assert(array2.Len(), 7)
+	})
+}
+
+func TestSortedStringArray_Clear(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array1.Clear()
+		gtest.Assert(array1.Len(), 0)
+
+	})
+}
+
+func TestSortedStringArray_SubSlice(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.SubSlice(1, 3)
+		gtest.Assert(len(s1), 3)
+		gtest.Assert(s1, []string{"b", "c", "d"})
+		gtest.Assert(array1.Len(), 7)
+
+		s2 := array1.SubSlice(1, 10)
+		gtest.Assert(len(s2), 6)
+
+		s3 := array1.SubSlice(10, 2)
+		gtest.Assert(len(s3), 0)
+
+	})
+}
+
+func TestSortedStringArray_Len(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "c", "b", "f", "g"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Len(), 7)
+
+	})
+}
+
+func TestSortedStringArray_Rand(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.AssertIN(array1.Rand(), []string{"e", "a", "d"})
+
+	})
+}
+
+func TestSortedStringArray_Rands(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		s1 := array1.Rands(2)
+
+		gtest.AssertIN(s1, []string{"e", "a", "d"})
+		gtest.Assert(len(s1), 2)
+
+		s1 = array1.Rands(4)
+		gtest.AssertIN(s1, []string{"e", "a", "d"})
+		gtest.Assert(len(s1), 3)
+	})
+}
+
+func TestSortedStringArray_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		gtest.Assert(array1.Join(","), "a,d,e")
+		gtest.Assert(array1.Join("."), "a.d.e")
+	})
+}
+
+func TestSortedStringArray_CountValues(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		m1 := array1.CountValues()
+		gtest.Assert(m1["a"], 2)
+		gtest.Assert(m1["d"], 1)
+
+	})
+}
+
+func TestSortedStringArray_Chunk(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.Chunk(2)
+		gtest.Assert(len(array2), 3)
+		gtest.Assert(len(array2[0]), 2)
+		gtest.Assert(array2[1], []string{"c", "d"})
+	})
+}
+
+func TestSortedStringArray_SetUnique(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewSortedStringArrayFrom(a1)
+		array2 := array1.SetUnique(true)
+		gtest.Assert(array2.Len(), 4)
+		gtest.Assert(array2, []string{"a", "c", "d", "e"})
+	})
+}
+
+func TestStringArray_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		a1 := []string{"e", "a", "d", "a", "c"}
+		array1 := garray.NewStringArrayFrom(a1)
+		s1 := array1.Remove(1)
+		gtest.Assert(s1, "a")
+		gtest.Assert(array1.Len(), 4)
+		s1 = array1.Remove(3)
+		gtest.Assert(s1, "c")
+		gtest.Assert(array1.Len(), 3)
+
+	})
+}

g/container/gchan/gchan.go

@@ -10,55 +10,61 @@
 package gchan
 
 import (
-    "errors"
-    "github.com/gogf/gf/g/container/gtype"
+	"errors"
+
+	"github.com/gogf/gf/g/container/gtype"
 )
 
 // Graceful channel.
 type Chan struct {
-    channel chan interface{}
-    closed  *gtype.Bool
+	channel chan interface{}
+	closed  *gtype.Bool
 }
 
 // New creates a graceful channel with given <limit>.
 func New(limit int) *Chan {
-    return &Chan {
-	    channel : make(chan interface{}, limit),
-        closed  : gtype.NewBool(),
-    }
+	return &Chan{
+		channel: make(chan interface{}, limit),
+		closed:  gtype.NewBool(),
+	}
 }
 
 // Push pushes <value> to channel.
 // It is safe to be called repeatedly.
 func (c *Chan) Push(value interface{}) error {
-    if c.closed.Val() {
-        return errors.New("channel is closed")
-    }
-    c.channel <- value
-    return nil
+	if c.closed.Val() {
+		return errors.New("channel is closed")
+	}
+	c.channel <- value
+	return nil
 }
 
 // Pop pops value from channel.
 // If there's no value in channel, it would block to wait.
 // If the channel is closed, it will return a nil value immediately.
 func (c *Chan) Pop() interface{} {
-    return <- c.channel
+	return <-c.channel
 }
 
 // Close closes the channel.
 // It is safe to be called repeatedly.
 func (c *Chan) Close() {
-    if !c.closed.Set(true) {
-        close(c.channel)
-    }
+	if !c.closed.Set(true) {
+		close(c.channel)
+	}
 }
 
 // See Len.
 func (c *Chan) Size() int {
-    return c.Len()
+	return c.Len()
 }
 
 // Len returns the length of the channel.
 func (c *Chan) Len() int {
 	return len(c.channel)
-}
+}
+
+// Cap returns the capacity of the channel.
+func (c *Chan) Cap() int {
+	return cap(c.channel)
+}

g/container/gchan/gchan_bench_test.go

@@ -1,32 +0,0 @@
-// 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=".*"
-
-package gchan_test
-
-import (
-    "testing"
-    "github.com/gogf/gf/g/container/gchan"
-)
-
-var length = 10000000
-var q1 = gchan.New(length)
-var q2 = make(chan int, length)
-
-func BenchmarkGchanPushAndPop(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        q1.Push(i)
-        q1.Pop()
-    }
-}
-
-func BenchmarkChannelPushAndPop(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        q2 <- i
-        <- q2
-    }
-}

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/gchan/gchan_z_unit_test.go

@@ -0,0 +1,47 @@
+package gchan_test
+
+import (
+	"errors"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gchan"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_Gchan(t *testing.T) {
+	gtest.Case(t, func() {
+		ch := gchan.New(10)
+
+		gtest.Assert(ch.Cap(), 10)
+		gtest.Assert(ch.Push(1), nil)
+		gtest.Assert(ch.Len(), 1)
+		gtest.Assert(ch.Size(), 1)
+		ch.Pop()
+		gtest.Assert(ch.Len(), 0)
+		gtest.Assert(ch.Size(), 0)
+		ch.Close()
+		gtest.Assert(ch.Push(1), errors.New("channel is closed"))
+
+		ch = gchan.New(0)
+		ch1 := gchan.New(0)
+		go func() {
+			var i = 0
+			for {
+				v := ch.Pop()
+				if v == nil {
+					ch1.Push(i)
+					break
+				}
+				gtest.Assert(v, i)
+				i++
+			}
+		}()
+
+		for index := 0; index < 10; index++ {
+			ch.Push(index)
+		}
+		ch.Close()
+		gtest.Assert(ch1.Pop(), 10)
+		ch1.Close()
+	})
+}

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,83 +129,83 @@ 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
 }
 
-// Alias of Len.
+// Size is alias of Len.
 func (l *List) Size() int {
 	return l.Len()
 }
@@ -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,45 @@
 package glist
 
 import (
-    "testing"
+	"testing"
 )
 
 var (
-    l  = New()
-    bn = 20000000
+	l  = New()
+	bn = 20000000
 )
 
 func Benchmark_PushBack(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PushBack(i)
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		l.PushBack(i)
+	}
 }
 
 func Benchmark_PushFront(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PushFront(i)
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		l.PushFront(i)
+	}
 }
 
 func Benchmark_Len(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.Len()
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		l.Len()
+	}
 }
 
 func Benchmark_PopFront(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PopFront()
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		l.PopFront()
+	}
 }
 
 func Benchmark_PopBack(b *testing.B) {
-    b.N = bn
-    for i := 0; i < b.N; i++ {
-        l.PopBack()
-    }
+	b.N = bn
+	for i := 0; i < b.N; i++ {
+		l.PopBack()
+	}
 }
-
-
-

g/container/glist/glist_z_unit_test.go

@@ -7,361 +7,577 @@
 package glist
 
 import (
-    "container/list"
-    "testing"
+	"container/list"
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/util/gconv"
+
+	"testing"
 )
 
 // 检查链表长度
 func checkListLen(t *testing.T, l *List, len int) bool {
-    if n := l.Len(); n != len {
-        t.Errorf("l.Len() = %d, want %d", n, len)
-        return false
-    }
-    return true
+	if n := l.Len(); n != len {
+		t.Errorf("l.Len() = %d, want %d", n, len)
+		return false
+	}
+	return true
 }
 
 // 检查指针地址
 func checkListPointers(t *testing.T, l *List, es []*Element) {
-    if !checkListLen(t, l, len(es)) {
-        return
-    }
-    l.RLockFunc(func(list *list.List) {
-        for i, e := 0, l.list.Front(); i < list.Len(); i, e = i + 1, e.Next() {
-            if e.Prev() != es[i].Prev() {
-                t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
-            }
-            if e.Next() != es[i].Next() {
-                t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
-            }
-        }
-    })
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
+	l.RLockFunc(func(list *list.List) {
+		for i, e := 0, l.list.Front(); i < list.Len(); i, e = i+1, e.Next() {
+			if e.Prev() != es[i].Prev() {
+				t.Errorf("list[%d].Prev = %p, want %p", i, e.Prev(), es[i].Prev())
+			}
+			if e.Next() != es[i].Next() {
+				t.Errorf("list[%d].Next = %p, want %p", i, e.Next(), es[i].Next())
+			}
+		}
+	})
 }
 
 func TestBasic(t *testing.T) {
-    l := New()
-    l.PushFront(1)
-    l.PushFront(2)
-    if v := l.PopBack(); v != 1 {
-        t.Errorf("EXPECT %v, GOT %v", 1, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopBack(); v != 2 {
-        t.Errorf("EXPECT %v, GOT %v", 2, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopBack(); v != nil {
-        t.Errorf("EXPECT %v, GOT %v", nil, v)
-    } else {
-        //fmt.Println(v)
-    }
-    l.PushBack(1)
-    l.PushBack(2)
-    if v := l.PopFront(); v != 1 {
-        t.Errorf("EXPECT %v, GOT %v", 1, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopFront(); v != 2 {
-        t.Errorf("EXPECT %v, GOT %v", 2, v)
-    } else {
-        //fmt.Println(v)
-    }
-    if v := l.PopFront(); v != nil {
-        t.Errorf("EXPECT %v, GOT %v", nil, v)
-    } else {
-        //fmt.Println(v)
-    }
+	l := New()
+	l.PushFront(1)
+	l.PushFront(2)
+	if v := l.PopBack(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopBack(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopBack(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		//fmt.Println(v)
+	}
+	l.PushBack(1)
+	l.PushBack(2)
+	if v := l.PopFront(); v != 1 {
+		t.Errorf("EXPECT %v, GOT %v", 1, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopFront(); v != 2 {
+		t.Errorf("EXPECT %v, GOT %v", 2, v)
+	} else {
+		//fmt.Println(v)
+	}
+	if v := l.PopFront(); v != nil {
+		t.Errorf("EXPECT %v, GOT %v", nil, v)
+	} else {
+		//fmt.Println(v)
+	}
 }
 
 func TestList(t *testing.T) {
-    l := New()
-    checkListPointers(t, l, []*Element{})
+	l := New()
+	checkListPointers(t, l, []*Element{})
 
-    // Single element list
-    e := l.PushFront("a")
-    checkListPointers(t, l, []*Element{e})
-    l.MoveToFront(e)
-    checkListPointers(t, l, []*Element{e})
-    l.MoveToBack(e)
-    checkListPointers(t, l, []*Element{e})
-    l.Remove(e)
-    checkListPointers(t, l, []*Element{})
+	// Single element list
+	e := l.PushFront("a")
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToFront(e)
+	checkListPointers(t, l, []*Element{e})
+	l.MoveToBack(e)
+	checkListPointers(t, l, []*Element{e})
+	l.Remove(e)
+	checkListPointers(t, l, []*Element{})
 
-    // Bigger list
-    e2 := l.PushFront(2)
-    e1 := l.PushFront(1)
-    e3 := l.PushBack(3)
-    e4 := l.PushBack("banana")
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	// Bigger list
+	e2 := l.PushFront(2)
+	e1 := l.PushFront(1)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack("banana")
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.Remove(e2)
-    checkListPointers(t, l, []*Element{e1, e3, e4})
+	l.Remove(e2)
+	checkListPointers(t, l, []*Element{e1, e3, e4})
 
-    l.MoveToFront(e3) // move from middle
-    checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // move from middle
+	checkListPointers(t, l, []*Element{e3, e1, e4})
 
-    l.MoveToFront(e1)
-    l.MoveToBack(e3) // move from middle
-    checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToFront(e1)
+	l.MoveToBack(e3) // move from middle
+	checkListPointers(t, l, []*Element{e1, e4, e3})
 
-    l.MoveToFront(e3) // move from back
-    checkListPointers(t, l, []*Element{e3, e1, e4})
-    l.MoveToFront(e3) // should be no-op
-    checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // move from back
+	checkListPointers(t, l, []*Element{e3, e1, e4})
+	l.MoveToFront(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e3, e1, e4})
 
-    l.MoveToBack(e3) // move from front
-    checkListPointers(t, l, []*Element{e1, e4, e3})
-    l.MoveToBack(e3) // should be no-op
-    checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToBack(e3) // move from front
+	checkListPointers(t, l, []*Element{e1, e4, e3})
+	l.MoveToBack(e3) // should be no-op
+	checkListPointers(t, l, []*Element{e1, e4, e3})
 
-    e2 = l.InsertBefore(2, e1) // insert before front
-    checkListPointers(t, l, []*Element{e2, e1, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertBefore(2, e4) // insert before middle
-    checkListPointers(t, l, []*Element{e1, e2, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertBefore(2, e3) // insert before back
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    l.Remove(e2)
+	e2 = l.InsertBefore(2, e1) // insert before front
+	checkListPointers(t, l, []*Element{e2, e1, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e4) // insert before middle
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertBefore(2, e3) // insert before back
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
 
-    e2 = l.InsertAfter(2, e1) // insert after front
-    checkListPointers(t, l, []*Element{e1, e2, e4, e3})
-    l.Remove(e2)
-    e2 = l.InsertAfter(2, e4) // insert after middle
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    l.Remove(e2)
-    e2 = l.InsertAfter(2, e3) // insert after back
-    checkListPointers(t, l, []*Element{e1, e4, e3, e2})
-    l.Remove(e2)
+	e2 = l.InsertAfter(2, e1) // insert after front
+	checkListPointers(t, l, []*Element{e1, e2, e4, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e4) // insert after middle
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	l.Remove(e2)
+	e2 = l.InsertAfter(2, e3) // insert after back
+	checkListPointers(t, l, []*Element{e1, e4, e3, e2})
+	l.Remove(e2)
 
-    // Check standard iteration.
-    sum := 0
-    for e := l.Front(); e != nil; e = e.Next() {
-        if i, ok := e.Value.(int); ok {
-            sum += i
-        }
-    }
-    if sum != 4 {
-        t.Errorf("sum over l = %d, want 4", sum)
-    }
+	// Check standard iteration.
+	sum := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+		if i, ok := e.Value.(int); ok {
+			sum += i
+		}
+	}
+	if sum != 4 {
+		t.Errorf("sum over l = %d, want 4", sum)
+	}
 
-    // Clear all elements by iterating
-    var next *Element
-    for e := l.Front(); e != nil; e = next {
-        next = e.Next()
-        l.Remove(e)
-    }
-    checkListPointers(t, l, []*Element{})
+	// Clear all elements by iterating
+	var next *Element
+	for e := l.Front(); e != nil; e = next {
+		next = e.Next()
+		l.Remove(e)
+	}
+	checkListPointers(t, l, []*Element{})
 }
 
 func checkList(t *testing.T, l *List, es []interface{}) {
-    if !checkListLen(t, l, len(es)) {
-        return
-    }
+	if !checkListLen(t, l, len(es)) {
+		return
+	}
 
-    i := 0
-    for e := l.Front(); e != nil; e = e.Next() {
-        le := e.Value.(int)
-        if le != es[i] {
-            t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
-        }
-        i++
-    }
+	i := 0
+	for e := l.Front(); e != nil; e = e.Next() {
+
+		switch e.Value.(type) {
+		case int:
+			if le := e.Value.(int); le != es[i] {
+				t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+			}
+			// default string
+		default:
+			if le := e.Value.(string); le != es[i] {
+				t.Errorf("elt[%v].Value() = %v, want %v", i, le, es[i])
+			}
+		}
+
+		i++
+	}
+
+	//for e := l.Front(); e != nil; e = e.Next() {
+	//	le := e.Value.(int)
+	//	if le != es[i] {
+	//		t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
+	//	}
+	//	i++
+	//}
 }
 
 func TestExtending(t *testing.T) {
-    l1 := New()
-    l2 := New()
+	l1 := New()
+	l2 := New()
 
-    l1.PushBack(1)
-    l1.PushBack(2)
-    l1.PushBack(3)
+	l1.PushBack(1)
+	l1.PushBack(2)
+	l1.PushBack(3)
 
-    l2.PushBack(4)
-    l2.PushBack(5)
+	l2.PushBack(4)
+	l2.PushBack(5)
 
-    l3 := New()
-    l3.PushBackList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushBackList(l2)
-    checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+	l3 := New()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l2)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
-    l3 = New()
-    l3.PushFrontList(l2)
-    checkList(t, l3, []interface{}{4, 5})
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
+	l3 = New()
+	l3.PushFrontList(l2)
+	checkList(t, l3, []interface{}{4, 5})
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3, 4, 5})
 
-    checkList(t, l1, []interface{}{1, 2, 3})
-    checkList(t, l2, []interface{}{4, 5})
+	checkList(t, l1, []interface{}{1, 2, 3})
+	checkList(t, l2, []interface{}{4, 5})
 
-    l3 = New()
-    l3.PushBackList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushBackList(l3)
-    checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+	l3 = New()
+	l3.PushBackList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushBackList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
-    l3 = New()
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1, 2, 3})
-    l3.PushFrontList(l3)
-    checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
+	l3 = New()
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1, 2, 3})
+	l3.PushFrontList(l3)
+	checkList(t, l3, []interface{}{1, 2, 3, 1, 2, 3})
 
-    l3 = New()
-    l1.PushBackList(l3)
-    checkList(t, l1, []interface{}{1, 2, 3})
-    l1.PushFrontList(l3)
-    checkList(t, l1, []interface{}{1, 2, 3})
+	l3 = New()
+	l1.PushBackList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
+	l1.PushFrontList(l3)
+	checkList(t, l1, []interface{}{1, 2, 3})
 }
 
 func TestRemove(t *testing.T) {
-    l := New()
-    e1 := l.PushBack(1)
-    e2 := l.PushBack(2)
-    checkListPointers(t, l, []*Element{e1, e2})
-    //e := l.Front()
-    //l.Remove(e)
-    //checkListPointers(t, l, []*Element{e2})
-    //l.Remove(e)
-    //checkListPointers(t, l, []*Element{e2})
+	l := New()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	checkListPointers(t, l, []*Element{e1, e2})
+	//e := l.Front()
+	//l.Remove(e)
+	//checkListPointers(t, l, []*Element{e2})
+	//l.Remove(e)
+	//checkListPointers(t, l, []*Element{e2})
 }
 
 func TestIssue4103(t *testing.T) {
-    l1 := New()
-    l1.PushBack(1)
-    l1.PushBack(2)
+	l1 := New()
+	l1.PushBack(1)
+	l1.PushBack(2)
 
-    l2 := New()
-    l2.PushBack(3)
-    l2.PushBack(4)
+	l2 := New()
+	l2.PushBack(3)
+	l2.PushBack(4)
 
-    e := l1.Front()
-    l2.Remove(e) // l2 should not change because e is not an element of l2
-    if n := l2.Len(); n != 2 {
-        t.Errorf("l2.Len() = %d, want 2", n)
-    }
+	e := l1.Front()
+	l2.Remove(e) // l2 should not change because e is not an element of l2
+	if n := l2.Len(); n != 2 {
+		t.Errorf("l2.Len() = %d, want 2", n)
+	}
 
-    l1.InsertBefore(8, e)
-    if n := l1.Len(); n != 3 {
-        t.Errorf("l1.Len() = %d, want 3", n)
-    }
+	l1.InsertBefore(8, e)
+	if n := l1.Len(); n != 3 {
+		t.Errorf("l1.Len() = %d, want 3", n)
+	}
 }
 
 func TestIssue6349(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
 
-    e := l.Front()
-    l.Remove(e)
-    if e.Value != 1 {
-        t.Errorf("e.value = %d, want 1", e.Value)
-    }
-    //if e.Next() != nil {
-    //    t.Errorf("e.Next() != nil")
-    //}
-    //if e.Prev() != nil {
-    //    t.Errorf("e.Prev() != nil")
-    //}
+	e := l.Front()
+	l.Remove(e)
+	if e.Value != 1 {
+		t.Errorf("e.value = %d, want 1", e.Value)
+	}
+	//if e.Next() != nil {
+	//    t.Errorf("e.Next() != nil")
+	//}
+	//if e.Prev() != nil {
+	//    t.Errorf("e.Prev() != nil")
+	//}
 }
 
 func TestMove(t *testing.T) {
-    l := New()
-    e1 := l.PushBack(1)
-    e2 := l.PushBack(2)
-    e3 := l.PushBack(3)
-    e4 := l.PushBack(4)
+	l := New()
+	e1 := l.PushBack(1)
+	e2 := l.PushBack(2)
+	e3 := l.PushBack(3)
+	e4 := l.PushBack(4)
 
-    l.MoveAfter(e3, e3)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
-    l.MoveBefore(e2, e2)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveAfter(e3, e3)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveBefore(e2, e2)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.MoveAfter(e3, e2)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
-    l.MoveBefore(e2, e3)
-    checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveAfter(e3, e2)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
+	l.MoveBefore(e2, e3)
+	checkListPointers(t, l, []*Element{e1, e2, e3, e4})
 
-    l.MoveBefore(e2, e4)
-    checkListPointers(t, l, []*Element{e1, e3, e2, e4})
-    e2, e3 = e3, e2
+	l.MoveBefore(e2, e4)
+	checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+	e2, e3 = e3, e2
 
-    l.MoveBefore(e4, e1)
-    checkListPointers(t, l, []*Element{e4, e1, e2, e3})
-    e1, e2, e3, e4 = e4, e1, e2, e3
+	l.MoveBefore(e4, e1)
+	checkListPointers(t, l, []*Element{e4, e1, e2, e3})
+	e1, e2, e3, e4 = e4, e1, e2, e3
 
-    l.MoveAfter(e4, e1)
-    checkListPointers(t, l, []*Element{e1, e4, e2, e3})
-    e2, e3, e4 = e4, e2, e3
+	l.MoveAfter(e4, e1)
+	checkListPointers(t, l, []*Element{e1, e4, e2, e3})
+	e2, e3, e4 = e4, e2, e3
 
-    l.MoveAfter(e2, e3)
-    checkListPointers(t, l, []*Element{e1, e3, e2, e4})
-    e2, e3 = e3, e2
+	l.MoveAfter(e2, e3)
+	checkListPointers(t, l, []*Element{e1, e3, e2, e4})
+	e2, e3 = e3, e2
 }
 
 // Test PushFront, PushBack, PushFrontList, PushBackList with uninitialized List
 func TestZeroList(t *testing.T) {
-    var l1 = New()
-    l1.PushFront(1)
-    checkList(t, l1, []interface{}{1})
+	var l1 = New()
+	l1.PushFront(1)
+	checkList(t, l1, []interface{}{1})
 
-    var l2 = New()
-    l2.PushBack(1)
-    checkList(t, l2, []interface{}{1})
+	var l2 = New()
+	l2.PushBack(1)
+	checkList(t, l2, []interface{}{1})
 
-    var l3 = New()
-    l3.PushFrontList(l1)
-    checkList(t, l3, []interface{}{1})
+	var l3 = New()
+	l3.PushFrontList(l1)
+	checkList(t, l3, []interface{}{1})
 
-    var l4 = New()
-    l4.PushBackList(l2)
-    checkList(t, l4, []interface{}{1})
+	var l4 = New()
+	l4.PushBackList(l2)
+	checkList(t, l4, []interface{}{1})
 }
 
 // Test that a list l is not modified when calling InsertBefore with a mark that is not an element of l.
 func TestInsertBeforeUnknownMark(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
-    l.PushBack(3)
-    l.InsertBefore(1, new(Element))
-    checkList(t, l, []interface{}{1, 2, 3})
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertBefore(1, new(Element))
+	checkList(t, l, []interface{}{1, 2, 3})
 }
 
 // Test that a list l is not modified when calling InsertAfter with a mark that is not an element of l.
 func TestInsertAfterUnknownMark(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.PushBack(2)
-    l.PushBack(3)
-    l.InsertAfter(1, new(Element))
-    checkList(t, l, []interface{}{1, 2, 3})
+	l := New()
+	l.PushBack(1)
+	l.PushBack(2)
+	l.PushBack(3)
+	l.InsertAfter(1, new(Element))
+	checkList(t, l, []interface{}{1, 2, 3})
 }
 
 // Test that a list l is not modified when calling MoveAfter or MoveBefore with a mark that is not an element of l.
 func TestMoveUnknownMark(t *testing.T) {
-    l1 := New()
-    e1 := l1.PushBack(1)
+	l1 := New()
+	e1 := l1.PushBack(1)
 
-    l2 := New()
-    e2 := l2.PushBack(2)
+	l2 := New()
+	e2 := l2.PushBack(2)
 
-    l1.MoveAfter(e1, e2)
-    checkList(t, l1, []interface{}{1})
-    checkList(t, l2, []interface{}{2})
+	l1.MoveAfter(e1, e2)
+	checkList(t, l1, []interface{}{1})
+	checkList(t, l2, []interface{}{2})
 
-    l1.MoveBefore(e1, e2)
-    checkList(t, l1, []interface{}{1})
-    checkList(t, l2, []interface{}{2})
+	l1.MoveBefore(e1, e2)
+	checkList(t, l1, []interface{}{1})
+	checkList(t, l2, []interface{}{2})
 }
 
 func TestList_RemoveAll(t *testing.T) {
-    l := New()
-    l.PushBack(1)
-    l.RemoveAll()
-    checkList(t, l, []interface{}{})
-    l.PushBack(2)
-    checkList(t, l, []interface{}{2})
-}
+	l := New()
+	l.PushBack(1)
+	l.RemoveAll()
+	checkList(t, l, []interface{}{})
+	l.PushBack(2)
+	checkList(t, l, []interface{}{2})
+}
+
+func TestList_PushFronts(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2}
+	l.PushFronts(a1)
+	checkList(t, l, []interface{}{2, 1})
+	a1 = []interface{}{3, 4, 5}
+	l.PushFronts(a1)
+	checkList(t, l, []interface{}{5, 4, 3, 2, 1})
+}
+
+func TestList_PushBacks(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2}
+	l.PushBacks(a1)
+	checkList(t, l, []interface{}{1, 2})
+	a1 = []interface{}{3, 4, 5}
+	l.PushBacks(a1)
+	checkList(t, l, []interface{}{1, 2, 3, 4, 5})
+}
+
+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"})
+
+}
+
+func TestList_PopFronts(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopFronts(2)
+	gtest.Assert(i1, []interface{}{"4", "3"})
+	gtest.Assert(l.Len(), 2)
+}
+
+func TestList_PopBackAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopBackAll()
+	gtest.Assert(i1, []interface{}{1, 2, 3, 4})
+	gtest.Assert(l.Len(), 0)
+
+}
+
+func TestList_PopFrontAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.PopFrontAll()
+	gtest.Assert(i1, []interface{}{4, 3, 2, 1})
+	gtest.Assert(l.Len(), 0)
+}
+
+func TestList_FrontAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.FrontAll()
+	gtest.Assert(i1, []interface{}{4, 3, 2, 1})
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_BackAll(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.BackAll()
+	gtest.Assert(i1, []interface{}{1, 2, 3, 4})
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_FrontValue(t *testing.T) {
+	l := New()
+	l2 := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.FrontValue()
+	gtest.Assert(gconv.Int(i1), 4)
+	gtest.Assert(l.Len(), 4)
+
+	i1 = l2.FrontValue()
+	gtest.Assert(i1, nil)
+}
+
+func TestList_BackValue(t *testing.T) {
+	l := New()
+	l2 := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	i1 := l.BackValue()
+	gtest.Assert(gconv.Int(i1), 1)
+	gtest.Assert(l.Len(), 4)
+
+	i1 = l2.FrontValue()
+	gtest.Assert(i1, nil)
+
+}
+
+func TestList_Back(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	gtest.Assert(e1.Value, 1)
+	gtest.Assert(l.Len(), 4)
+}
+
+func TestList_Size(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	gtest.Assert(l.Size(), 4)
+	l.PopFront()
+	gtest.Assert(l.Size(), 3)
+}
+
+func TestList_Removes(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	l.Removes([]*Element{e1})
+	gtest.Assert(l.Len(), 3)
+
+	e2 := l.Back()
+	l.Removes([]*Element{e2})
+	gtest.Assert(l.Len(), 2)
+	checkList(t, l, []interface{}{4, 3})
+
+}
+
+func TestList_Clear(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	l.Clear()
+	gtest.Assert(l.Len(), 0)
+}
+
+func TestList_IteratorAsc(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 5, 6, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.Int(e1.Value) > 2 {
+			return true
+		}
+		return false
+	}
+	checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+	l.IteratorAsc(fun1)
+	checkList(t, l, []interface{}{4, 3, 6, 5, 2, 1})
+}
+
+func TestList_IteratorDesc(t *testing.T) {
+	l := New()
+	a1 := []interface{}{1, 2, 3, 4}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.Int(e1.Value) > 6 {
+			return true
+		}
+		return false
+	}
+	l.IteratorDesc(fun1)
+	gtest.Assert(l.Len(), 4)
+	checkList(t, l, []interface{}{4, 3, 2, 1})
+}
+
+func TestList_Iterator(t *testing.T) {
+	l := New()
+	a1 := []interface{}{"a", "b", "c", "d", "e"}
+	l.PushFronts(a1)
+	e1 := l.Back()
+	fun1 := func(e *Element) bool {
+		if gconv.String(e1.Value) > "c" {
+			return true
+		}
+		return false
+	}
+	checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+	l.Iterator(fun1)
+	checkList(t, l, []interface{}{"e", "d", "c", "b", "a"})
+}

g/container/gmap/gmap.go

@@ -8,11 +8,11 @@
 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.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func New(unsafe ...bool) *Map {
 	return NewAnyAnyMap(unsafe...)
@@ -21,14 +21,14 @@ func New(unsafe ...bool) *Map {
 // NewFrom 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.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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...)
 }
 
 // NewHashMap returns an empty hash map.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // which is false in default, means concurrent-safe.
 func NewHashMap(unsafe ...bool) *Map {
 	return NewAnyAnyMap(unsafe...)
@@ -37,8 +37,8 @@ func NewHashMap(unsafe ...bool) *Map {
 // NewHashMapFrom 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.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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

@@ -12,72 +12,72 @@ import (
 )
 
 type AnyAnyMap struct {
-    mu   *rwmutex.RWMutex
-    data map[interface{}]interface{}
+	mu   *rwmutex.RWMutex
+	data map[interface{}]interface{}
 }
 
 // NewAnyAnyMap returns an empty hash map.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // 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 +91,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 +107,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 +134,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 +148,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 +181,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 +213,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 +233,98 @@ 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
+	}
+}

g/container/gmap/gmap_hash_int_any_map.go

@@ -10,7 +10,7 @@ package gmap
 import (
 	"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 {
@@ -19,40 +19,40 @@ type IntAnyMap struct {
 }
 
 // NewIntAnyMap returns an empty IntAnyMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// 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 +62,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 +92,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 +109,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 +150,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 +183,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 +213,120 @@ 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
+	}
+}

g/container/gmap/gmap_hash_int_int_map.go

@@ -7,7 +7,7 @@
 package gmap
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type IntIntMap struct {
@@ -16,40 +16,40 @@ type IntIntMap struct {
 }
 
 // NewIntIntMap returns an empty IntIntMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// 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 +59,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 +89,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 +102,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 +139,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 +191,118 @@ 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
+	}
 }

g/container/gmap/gmap_hash_int_str_map.go

@@ -17,12 +17,12 @@ type IntStrMap struct {
 }
 
 // NewIntStrMap returns an empty IntStrMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // 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 +31,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 +213,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 +227,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++

g/container/gmap/gmap_hash_str_any_map.go

@@ -19,12 +19,12 @@ type StrAnyMap struct {
 }
 
 // NewStrAnyMap returns an empty StrAnyMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // 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 +33,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 +238,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 +252,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++

g/container/gmap/gmap_hash_str_int_map.go

@@ -18,12 +18,12 @@ type StrIntMap struct {
 }
 
 // NewStrIntMap returns an empty StrIntMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // 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 +32,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 +216,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 +230,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++

g/container/gmap/gmap_hash_str_str_map.go

@@ -8,7 +8,7 @@
 package gmap
 
 import (
-    "github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type StrStrMap struct {
@@ -17,28 +17,28 @@ type StrStrMap struct {
 }
 
 // NewStrStrMap returns an empty StrStrMap object.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// 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 +50,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 +73,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 +194,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 +215,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 +229,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 +266,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.

g/container/gmap/gmap_link_map.go

@@ -13,57 +13,57 @@ import (
 )
 
 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.
 // ListMap is backed by a hash table to store values and doubly-linked list to store ordering.
-// The param <unsafe> used to specify whether using map in un-concurrent-safety,
+// The parameter <unsafe> used to specify whether using map in un-concurrent-safety,
 // 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 +75,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 +88,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 +96,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 +138,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 +156,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 +183,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 +197,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 +230,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 +262,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 +286,81 @@ 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
+	})
+}

g/container/gmap/gmap_tree_map.go

@@ -14,17 +14,17 @@ import (
 type TreeMap = gtree.RedBlackTree
 
 // NewTreeMap instantiates a tree map with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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...)
 }
 
 // NewTreeMapFrom instantiates a tree map with the custom comparator and <data> map.
 // 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.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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

@@ -19,9 +19,9 @@ 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)
-    }
+	for i := 0; i < b.N; i++ {
+		hashMap.Set(i, i)
+	}
 }
 
 func Benchmark_ListMap_Set(b *testing.B) {
@@ -37,9 +37,9 @@ func Benchmark_TreeMap_Set(b *testing.B) {
 }
 
 func Benchmark_HashMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-	    hashMap.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		hashMap.Get(i)
+	}
 }
 
 func Benchmark_ListMap_Get(b *testing.B) {

g/container/gmap/gmap_z_bench_safe_test.go

@@ -10,101 +10,98 @@ package gmap_test
 
 import (
 	"github.com/gogf/gf/g/container/gmap"
+	"strconv"
 	"testing"
-    "strconv"
 )
 
 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 iim = gmap.NewIntIntMap()
+var iifm = gmap.NewIntAnyMap()
+var ism = gmap.NewIntStrMap()
+var sim = gmap.NewStrIntMap()
+var sifm = gmap.NewStrAnyMap()
+var ssm = gmap.NewStrStrMap()
 
 func Benchmark_IntIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iim.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		iim.Set(i, i)
+	}
 }
 
 func Benchmark_IntAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifm.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		iifm.Set(i, i)
+	}
 }
 
 func Benchmark_IntStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ism.Set(i, strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ism.Set(i, strconv.Itoa(i))
+	}
 }
 
 func Benchmark_AnyAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififm.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		ififm.Set(i, i)
+	}
 }
 
 func Benchmark_StrIntMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sim.Set(strconv.Itoa(i), i)
-    }
+	for i := 0; i < b.N; i++ {
+		sim.Set(strconv.Itoa(i), i)
+	}
 }
 
 func Benchmark_StrAnyMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifm.Set(strconv.Itoa(i), i)
-    }
+	for i := 0; i < b.N; i++ {
+		sifm.Set(strconv.Itoa(i), i)
+	}
 }
 
 func Benchmark_StrStrMap_Set(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssm.Set(strconv.Itoa(i), strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ssm.Set(strconv.Itoa(i), strconv.Itoa(i))
+	}
 }
 
-
-
 func Benchmark_IntIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iim.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		iim.Get(i)
+	}
 }
 
 func Benchmark_IntAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        iifm.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		iifm.Get(i)
+	}
 }
 
 func Benchmark_IntStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ism.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ism.Get(i)
+	}
 }
 
 func Benchmark_AnyAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ififm.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ififm.Get(i)
+	}
 }
 
 func Benchmark_StrIntMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sim.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		sim.Get(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_StrAnyMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        sifm.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		sifm.Get(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_StrStrMap_Get(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ssm.Get(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		ssm.Get(strconv.Itoa(i))
+	}
 }
-

g/container/gmap/gmap_z_bench_syncmap_test.go

@@ -9,48 +9,46 @@
 package gmap_test
 
 import (
-    "testing"
-    "github.com/gogf/gf/g/container/gmap"
-    "sync"
+	"github.com/gogf/gf/g/container/gmap"
+	"sync"
+	"testing"
 )
 
-
 var m1 = gmap.NewIntIntMap()
 var m2 = sync.Map{}
 
 func BenchmarkGmapSet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Set(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		m1.Set(i, i)
+	}
 }
 
 func BenchmarkSyncmapSet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Store(i, i)
-    }
+	for i := 0; i < b.N; i++ {
+		m2.Store(i, i)
+	}
 }
 
 func BenchmarkGmapGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Get(i)
-    }
+	for i := 0; i < b.N; i++ {
+		m1.Get(i)
+	}
 }
 
 func BenchmarkSyncmapGet(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Load(i)
-    }
+	for i := 0; i < b.N; i++ {
+		m2.Load(i)
+	}
 }
 
 func BenchmarkGmapRemove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m1.Remove(i)
-    }
+	for i := 0; i < b.N; i++ {
+		m1.Remove(i)
+	}
 }
 
 func BenchmarkSyncmapRmove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        m2.Delete(i)
-    }
+	for i := 0; i < b.N; i++ {
+		m2.Delete(i)
+	}
 }
-

g/container/gmap/gmap_z_bench_unsafe_test.go

@@ -10,105 +10,102 @@ package gmap_test
 
 import (
 	"github.com/gogf/gf/g/container/gmap"
+	"strconv"
 	"testing"
-    "strconv"
 )
 
 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)
 
 // 写入性能测试
 
 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))
+	}
 }
 
-
 // 读取性能测试
 
-
 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

@@ -0,0 +1,92 @@
+package gpool_test
+
+import (
+	"errors"
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/container/gpool"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+var nf gpool.NewFunc = func() (i interface{}, e error) {
+	return "hello", nil
+}
+
+var assertIndex int = 0
+var ef gpool.ExpireFunc = func(i interface{}) {
+	assertIndex++
+	gtest.Assert(i, assertIndex)
+}
+
+func Test_Gpool(t *testing.T) {
+	gtest.Case(t, func() {
+		//
+		//expire = 0
+		p1 := gpool.New(0, nf)
+		p1.Put(1)
+		p1.Put(2)
+		time.Sleep(1 * time.Second)
+		//test won't be timeout
+		v1, err1 := p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, 1)
+		//test clear
+		p1.Clear()
+		gtest.Assert(p1.Size(), 0)
+		//test newFunc
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, "hello")
+		//put data again
+		p1.Put(3)
+		p1.Put(4)
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, 3)
+		//test close
+		p1.Close()
+		v1, err1 = p1.Get()
+		gtest.Assert(err1, nil)
+		gtest.Assert(v1, "hello")
+
+	})
+
+	gtest.Case(t, func() {
+		//
+		//expire > 0
+		p2 := gpool.New(2000, nil, ef)
+		for index := 0; index < 10; index++ {
+			p2.Put(index)
+		}
+		gtest.Assert(p2.Size(), 10)
+		v2, err2 := p2.Get()
+		gtest.Assert(err2, nil)
+		gtest.Assert(v2, 0)
+		//test timeout expireFunc
+		time.Sleep(3 * time.Second)
+		v2, err2 = p2.Get()
+		gtest.Assert(err2, errors.New("pool is empty"))
+		gtest.Assert(v2, nil)
+		//test close expireFunc
+		for index := 0; index < 10; index++ {
+			p2.Put(index)
+		}
+		gtest.Assert(p2.Size(), 10)
+		v2, err2 = p2.Get()
+		gtest.Assert(err2, nil)
+		gtest.Assert(v2, 0)
+		assertIndex = 0
+		p2.Close()
+		time.Sleep(3 * time.Second)
+	})
+
+	gtest.Case(t, func() {
+		//
+		//expire < 0
+		p3 := gpool.New(-1, nil)
+		v3, err3 := p3.Get()
+		gtest.Assert(err3, errors.New("pool is empty"))
+		gtest.Assert(v3, nil)
+	})
+}

g/container/gqueue/gqueue.go

@@ -19,100 +19,121 @@
 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 {
+		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.
+	// 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)
+	}
+	for i := 0; i < gDEFAULT_MAX_BATCH_SIZE; i++ {
+		q.Pop()
+	}
 }
 
-// Size returns the length of the queue.
+// Len returns the length of the queue.
+func (q *Queue) Len() (length int) {
+	if q.list != nil {
+		length += q.list.Len()
+	}
+	length += len(q.C)
+	return
+}
+
+// Size is alias of Len.
 func (q *Queue) Size() int {
-    return len(q.C) + q.list.Len()
+	return q.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 param <unsafe> used to specify whether using set in un-concurrent-safety,
+// 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 {
@@ -19,46 +19,46 @@ type IntSet struct {
 }
 
 // New create and returns a new set, which contains un-repeated items.
-// The param <unsafe> used to specify whether using set in un-concurrent-safety,
+// 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"
 )
@@ -19,32 +19,32 @@ type StringSet struct {
 }
 
 // New create and returns a new set, which contains un-repeated items.
-// The param <unsafe> used to specify whether using set in un-concurrent-safety,
+// 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

@@ -9,122 +9,122 @@
 package gset_test
 
 import (
-    "testing"
-    "strconv"
-    "github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/container/gset"
+	"strconv"
+	"testing"
 )
 
-var ints       = gset.NewIntSet()
-var itfs       = gset.NewSet()
-var strs       = gset.NewStringSet()
+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)
 
 func Benchmark_IntSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Add(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ints.Add(i)
+	}
 }
 
 func Benchmark_IntSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Contains(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ints.Contains(i)
+	}
 }
 
 func Benchmark_IntSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Remove(i)
-    }
+	for i := 0; i < b.N; i++ {
+		ints.Remove(i)
+	}
 }
 
 func Benchmark_Set_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Add(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfs.Add(i)
+	}
 }
 
 func Benchmark_Set_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Contains(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfs.Contains(i)
+	}
 }
 
 func Benchmark_Set_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Remove(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfs.Remove(i)
+	}
 }
 
 func Benchmark_StringSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Add(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		strs.Add(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_StringSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Contains(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		strs.Contains(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_StringSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strs.Remove(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		strs.Remove(strconv.Itoa(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++ {
+		intsUnsafe.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++ {
+		intsUnsafe.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++ {
+		intsUnsafe.Remove(i)
+	}
 }
 
 func Benchmark_Unsafe_Set_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Add(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfsUnsafe.Add(i)
+	}
 }
 
 func Benchmark_Unsafe_Set_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Contains(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfsUnsafe.Contains(i)
+	}
 }
 
 func Benchmark_Unsafe_Set_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Remove(i)
-    }
+	for i := 0; i < b.N; i++ {
+		itfsUnsafe.Remove(i)
+	}
 }
 
 func Benchmark_Unsafe_StringSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Add(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		strsUnsafe.Add(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_Unsafe_StringSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Contains(strconv.Itoa(i))
-    }
+	for i := 0; i < b.N; i++ {
+		strsUnsafe.Contains(strconv.Itoa(i))
+	}
 }
 
 func Benchmark_Unsafe_StringSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        strsUnsafe.Remove(strconv.Itoa(i))
-    }
-}
+	for i := 0; i < b.N; i++ {
+		strsUnsafe.Remove(strconv.Itoa(i))
+	}
+}

g/container/gset/gset_z_unit_int_test.go

@@ -9,152 +9,208 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+	"testing"
 )
 
 func TestIntSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(1).Add(2)
-        s.Add([]int{3,4}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN(1, s.Slice())
-        gtest.AssertIN(2, s.Slice())
-        gtest.AssertIN(3, s.Slice())
-        gtest.AssertIN(4, s.Slice())
-        gtest.AssertNI(0, s.Slice())
-        gtest.Assert(s.Contains(4), true)
-        gtest.Assert(s.Contains(5), false)
-        s.Remove(1)
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]int{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestIntSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v int) bool {
-            a1.Append(1)
-            return false
-        })
-        s.Iterator(func(v int) bool {
-            a2.Append(1)
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v int) bool {
+			a1.Append(1)
+			return false
+		})
+		s.Iterator(func(v int) bool {
+			a2.Append(1)
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestIntSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewIntSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[int]struct{}) {
-            delete(m, 1)
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[int]struct{}) {
-            gtest.Assert(m, map[int]struct{}{
-                3 : struct{}{},
-                2 : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewIntSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[int]struct{}) {
+			delete(m, 1)
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[int]struct{}) {
+			gtest.Assert(m, map[int]struct{}{
+				3: struct{}{},
+				2: struct{}{},
+			})
+		})
+	})
 }
 
 func TestIntSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s3 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s3 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestIntSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s3 := gset.NewIntSet()
-        s1.Add(1).Add(2)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s3 := gset.NewIntSet()
+		s1.Add(1).Add(2)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestIntSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2)
-        s2.Add(3).Add(4)
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2)
+		s2.Add(3).Add(4)
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestIntSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), false)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), false)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestIntSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestIntSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewIntSet()
-        s2 := gset.NewIntSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(4), true)
-        gtest.Assert(s3.Contains(5), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(4), true)
+		gtest.Assert(s3.Contains(5), true)
+	})
+}
+
+func TestIntSet_Size(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet(true)
+		s1.Add(1).Add(2).Add(3)
+		gtest.Assert(s1.Size(), 3)
+
+	})
+
+}
+
+func TestIntSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s2 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Merge(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(5), true)
+		gtest.Assert(s3.Contains(6), false)
+	})
+}
+
+func TestIntSet_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s3 := s1.Join(",")
+		gtest.Assert(strings.Contains(s3, "3"), true)
+
+	})
+}
+
+func TestIntSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(1).Add(2).Add(3)
+		s2 := gset.NewIntSet()
+		s2.Add(5).Add(6).Add(7)
+		gtest.Assert(s2.Sum(), 18)
+
+	})
+
+}
+
+func TestIntSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSet()
+		s1.Add(4).Add(2).Add(3)
+		gtest.AssertIN(s1.Pop(1), []int{4, 2, 3})
+		gtest.AssertIN(s1.Pop(5), []int{4, 2, 3})
+		gtest.Assert(s1.Size(), 3)
+	})
+}

g/container/gset/gset_z_unit_string_test.go

@@ -9,152 +9,248 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+	"testing"
 )
 
 func TestStringSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("1").Add("2")
-        s.Add([]string{"3","4"}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN("1", s.Slice())
-        gtest.AssertIN("2", s.Slice())
-        gtest.AssertIN("3", s.Slice())
-        gtest.AssertIN("4", s.Slice())
-        gtest.AssertNI("0", s.Slice())
-        gtest.Assert(s.Contains("4"), true)
-        gtest.Assert(s.Contains("5"), false)
-        s.Remove("1")
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("1").Add("2")
+		s.Add([]string{"3", "4"}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN("1", s.Slice())
+		gtest.AssertIN("2", s.Slice())
+		gtest.AssertIN("3", s.Slice())
+		gtest.AssertIN("4", s.Slice())
+		gtest.AssertNI("0", s.Slice())
+		gtest.Assert(s.Contains("4"), true)
+		gtest.Assert(s.Contains("5"), false)
+		s.Remove("1")
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestStringSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("2").Add("3")
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("2").Add("3")
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v string) bool {
-            a1.Append("1")
-            return false
-        })
-        s.Iterator(func(v string) bool {
-            a2.Append("1")
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v string) bool {
+			a1.Append("1")
+			return false
+		})
+		s.Iterator(func(v string) bool {
+			a2.Append("1")
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestStringSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewStringSet()
-        s.Add("1").Add("2").Add("3")
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[string]struct{}) {
-            delete(m, "1")
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[string]struct{}) {
-            gtest.Assert(m, map[string]struct{}{
-                "3" : struct{}{},
-                "2" : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewStringSet()
+		s.Add("1").Add("2").Add("3")
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[string]struct{}) {
+			delete(m, "1")
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[string]struct{}) {
+			gtest.Assert(m, map[string]struct{}{
+				"3": struct{}{},
+				"2": struct{}{},
+			})
+		})
+	})
 }
 
 func TestStringSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s3 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("1").Add("2").Add("3")
-        s3.Add("1").Add("2").Add("3").Add("4")
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s3 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("1").Add("2").Add("3")
+		s3.Add("1").Add("2").Add("3").Add("4")
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestStringSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s3 := gset.NewStringSet()
-        s1.Add("1").Add("2")
-        s2.Add("1").Add("2").Add("3")
-        s3.Add("1").Add("2").Add("3").Add("4")
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s3 := gset.NewStringSet()
+		s1.Add("1").Add("2")
+		s2.Add("1").Add("2").Add("3")
+		s3.Add("1").Add("2").Add("3").Add("4")
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestStringSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2")
-        s2.Add("3").Add("4")
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains("1"), true)
-        gtest.Assert(s3.Contains("2"), true)
-        gtest.Assert(s3.Contains("3"), true)
-        gtest.Assert(s3.Contains("4"), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2")
+		s2.Add("3").Add("4")
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("2"), true)
+		gtest.Assert(s3.Contains("3"), true)
+		gtest.Assert(s3.Contains("4"), true)
+	})
 }
 
 func TestStringSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains("1"), true)
-        gtest.Assert(s3.Contains("2"), true)
-        gtest.Assert(s3.Contains("3"), false)
-        gtest.Assert(s3.Contains("4"), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("2"), true)
+		gtest.Assert(s3.Contains("3"), false)
+		gtest.Assert(s3.Contains("4"), false)
+	})
 }
 
 func TestStringSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains("1"), false)
-        gtest.Assert(s3.Contains("2"), false)
-        gtest.Assert(s3.Contains("3"), true)
-        gtest.Assert(s3.Contains("4"), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains("1"), false)
+		gtest.Assert(s3.Contains("2"), false)
+		gtest.Assert(s3.Contains("3"), true)
+		gtest.Assert(s3.Contains("4"), false)
+	})
 }
 
 func TestStringSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewStringSet()
-        s2 := gset.NewStringSet()
-        s1.Add("1").Add("2").Add("3")
-        s2.Add("3").Add("4").Add("5")
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains("1"), false)
-        gtest.Assert(s3.Contains("2"), false)
-        gtest.Assert(s3.Contains("4"), true)
-        gtest.Assert(s3.Contains("5"), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains("1"), false)
+		gtest.Assert(s3.Contains("2"), false)
+		gtest.Assert(s3.Contains("4"), true)
+		gtest.Assert(s3.Contains("5"), true)
+	})
+}
+
+func TestNewIntSetFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewIntSetFrom([]int{1, 2, 3, 4})
+		s2 := gset.NewIntSetFrom([]int{5, 6, 7, 8})
+		gtest.Assert(s1.Contains(3), true)
+		gtest.Assert(s1.Contains(5), false)
+		gtest.Assert(s2.Contains(3), false)
+		gtest.Assert(s2.Contains(5), true)
+	})
+}
+
+func TestStringSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSet()
+		s2 := gset.NewStringSet()
+		s1.Add("1").Add("2").Add("3")
+		s2.Add("3").Add("4").Add("5")
+		s3 := s1.Merge(s2)
+		gtest.Assert(s3.Contains("1"), true)
+		gtest.Assert(s3.Contains("6"), false)
+		gtest.Assert(s3.Contains("4"), true)
+		gtest.Assert(s3.Contains("5"), true)
+	})
+}
+
+func TestNewStringSetFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		gtest.Assert(s1.Contains("b"), true)
+		gtest.Assert(s1.Contains("d"), false)
+	})
+}
+
+func TestStringSet_Join(t *testing.T) {
+	s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+	str1 := s1.Join(",")
+	gtest.Assert(strings.Contains(str1, "b"), true)
+	gtest.Assert(strings.Contains(str1, "d"), false)
+}
+
+func TestStringSet_String(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		str1 := s1.String()
+		gtest.Assert(strings.Contains(str1, "b"), true)
+		gtest.Assert(strings.Contains(str1, "d"), false)
+	})
+
+}
+
+func TestStringSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		s2 := gset.NewIntSetFrom([]int{2, 3, 4}, true)
+		gtest.Assert(s1.Sum(), 0)
+		gtest.Assert(s2.Sum(), 9)
+	})
+}
+
+func TestStringSet_Size(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		gtest.Assert(s1.Size(), 3)
+
+	})
+}
+
+func TestStringSet_Remove(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		s1 = s1.Remove("b")
+		gtest.Assert(s1.Contains("b"), false)
+		gtest.Assert(s1.Contains("c"), true)
+	})
+}
+
+func TestStringSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		str1 := s1.Pop(1)
+		gtest.Assert(strings.Contains("a,b,c", str1), true)
+	})
+}
+
+func TestStringSet_Pops(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewStringSetFrom([]string{"a", "b", "c"}, true)
+		strs1 := s1.Pops(2)
+		gtest.AssertIN(strs1, []string{"a", "b", "c"})
+		gtest.Assert(len(strs1), 2)
+		str2 := s1.Pops(7)
+		gtest.AssertIN(str2, []string{"a", "b", "c"})
+	})
+}

g/container/gset/gset_z_unit_test.go

@@ -9,152 +9,260 @@
 package gset_test
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gset"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gset"
+	"github.com/gogf/gf/g/test/gtest"
+	"strings"
+
+	"testing"
 )
 
+func TestSet_New(t *testing.T) {
+	gtest.Case(t, func() {
+		s := gset.New()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]interface{}{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
+}
+
 func TestSet_Basic(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(1).Add(2)
-        s.Add([]interface{}{3,4}...)
-        gtest.Assert(s.Size(), 4)
-        gtest.AssertIN(1, s.Slice())
-        gtest.AssertIN(2, s.Slice())
-        gtest.AssertIN(3, s.Slice())
-        gtest.AssertIN(4, s.Slice())
-        gtest.AssertNI(0, s.Slice())
-        gtest.Assert(s.Contains(4), true)
-        gtest.Assert(s.Contains(5), false)
-        s.Remove(1)
-        gtest.Assert(s.Size(), 3)
-        s.Clear()
-        gtest.Assert(s.Size(), 0)
-    })
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(1).Add(2)
+		s.Add([]interface{}{3, 4}...)
+		gtest.Assert(s.Size(), 4)
+		gtest.AssertIN(1, s.Slice())
+		gtest.AssertIN(2, s.Slice())
+		gtest.AssertIN(3, s.Slice())
+		gtest.AssertIN(4, s.Slice())
+		gtest.AssertNI(0, s.Slice())
+		gtest.Assert(s.Contains(4), true)
+		gtest.Assert(s.Contains(5), false)
+		s.Remove(1)
+		gtest.Assert(s.Size(), 3)
+		s.Clear()
+		gtest.Assert(s.Size(), 0)
+	})
 }
 
 func TestSet_Iterator(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
 
-        a1 := garray.New()
-        a2 := garray.New()
-        s.Iterator(func(v interface{}) bool {
-            a1.Append(1)
-            return false
-        })
-        s.Iterator(func(v interface{}) bool {
-            a2.Append(1)
-            return true
-        })
-        gtest.Assert(a1.Len(), 1)
-        gtest.Assert(a2.Len(), 3)
-    })
+		a1 := garray.New()
+		a2 := garray.New()
+		s.Iterator(func(v interface{}) bool {
+			a1.Append(1)
+			return false
+		})
+		s.Iterator(func(v interface{}) bool {
+			a2.Append(1)
+			return true
+		})
+		gtest.Assert(a1.Len(), 1)
+		gtest.Assert(a2.Len(), 3)
+	})
 }
 
 func TestSet_LockFunc(t *testing.T) {
-    gtest.Case(t, func() {
-        s := gset.NewSet()
-        s.Add(1).Add(2).Add(3)
-        gtest.Assert(s.Size(), 3)
-        s.LockFunc(func(m map[interface{}]struct{}) {
-            delete(m, 1)
-        })
-        gtest.Assert(s.Size(), 2)
-        s.RLockFunc(func(m map[interface{}]struct{}) {
-            gtest.Assert(m, map[interface{}]struct{}{
-                3 : struct{}{},
-                2 : struct{}{},
-            })
-        })
-    })
+	gtest.Case(t, func() {
+		s := gset.NewSet()
+		s.Add(1).Add(2).Add(3)
+		gtest.Assert(s.Size(), 3)
+		s.LockFunc(func(m map[interface{}]struct{}) {
+			delete(m, 1)
+		})
+		gtest.Assert(s.Size(), 2)
+		s.RLockFunc(func(m map[interface{}]struct{}) {
+			gtest.Assert(m, map[interface{}]struct{}{
+				3: struct{}{},
+				2: struct{}{},
+			})
+		})
+	})
 }
 
 func TestSet_Equal(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s3 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.Equal(s2), true)
-        gtest.Assert(s1.Equal(s3), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s3 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Equal(s2), true)
+		gtest.Assert(s1.Equal(s3), false)
+	})
 }
 
 func TestSet_IsSubsetOf(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s3 := gset.NewSet()
-        s1.Add(1).Add(2)
-        s2.Add(1).Add(2).Add(3)
-        s3.Add(1).Add(2).Add(3).Add(4)
-        gtest.Assert(s1.IsSubsetOf(s2), true)
-        gtest.Assert(s2.IsSubsetOf(s3), true)
-        gtest.Assert(s1.IsSubsetOf(s3), true)
-        gtest.Assert(s2.IsSubsetOf(s1), false)
-        gtest.Assert(s3.IsSubsetOf(s2), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s3 := gset.NewSet()
+		s1.Add(1).Add(2)
+		s2.Add(1).Add(2).Add(3)
+		s3.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.IsSubsetOf(s2), true)
+		gtest.Assert(s2.IsSubsetOf(s3), true)
+		gtest.Assert(s1.IsSubsetOf(s3), true)
+		gtest.Assert(s2.IsSubsetOf(s1), false)
+		gtest.Assert(s3.IsSubsetOf(s2), false)
+	})
 }
 
 func TestSet_Union(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2)
-        s2.Add(3).Add(4)
-        s3 := s1.Union(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), true)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2)
+		s2.Add(3).Add(4)
+		s3 := s1.Union(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), true)
+	})
 }
 
 func TestSet_Diff(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Diff(s2)
-        gtest.Assert(s3.Contains(1), true)
-        gtest.Assert(s3.Contains(2), true)
-        gtest.Assert(s3.Contains(3), false)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Diff(s2)
+		gtest.Assert(s3.Contains(1), true)
+		gtest.Assert(s3.Contains(2), true)
+		gtest.Assert(s3.Contains(3), false)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestSet_Intersect(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Intersect(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(3), true)
-        gtest.Assert(s3.Contains(4), false)
-    })
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Intersect(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s3.Contains(4), false)
+	})
 }
 
 func TestSet_Complement(t *testing.T) {
-    gtest.Case(t, func() {
-        s1 := gset.NewSet()
-        s2 := gset.NewSet()
-        s1.Add(1).Add(2).Add(3)
-        s2.Add(3).Add(4).Add(5)
-        s3 := s1.Complement(s2)
-        gtest.Assert(s3.Contains(1), false)
-        gtest.Assert(s3.Contains(2), false)
-        gtest.Assert(s3.Contains(4), true)
-        gtest.Assert(s3.Contains(5), true)
-    })
-}
+	gtest.Case(t, func() {
+		s1 := gset.NewSet()
+		s2 := gset.NewSet()
+		s1.Add(1).Add(2).Add(3)
+		s2.Add(3).Add(4).Add(5)
+		s3 := s1.Complement(s2)
+		gtest.Assert(s3.Contains(1), false)
+		gtest.Assert(s3.Contains(2), false)
+		gtest.Assert(s3.Contains(4), true)
+		gtest.Assert(s3.Contains(5), true)
+	})
+}
+
+func TestNewFrom(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.NewFrom("a")
+		s2 := gset.NewFrom("b", false)
+		s3 := gset.NewFrom(3, true)
+		s4 := gset.NewFrom([]string{"s1", "s2"}, true)
+		gtest.Assert(s1.Contains("a"), true)
+		gtest.Assert(s2.Contains("b"), true)
+		gtest.Assert(s3.Contains(3), true)
+		gtest.Assert(s4.Contains("s1"), true)
+		gtest.Assert(s4.Contains("s3"), false)
+
+	})
+}
+
+func TestNew(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New()
+		s1.Add("a").Add(2)
+		s2 := gset.New(true)
+		s2.Add("b").Add(3)
+		gtest.Assert(s1.Contains("a"), true)
+
+	})
+}
+
+func TestSet_Join(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add("a").Add("a1").Add("b").Add("c")
+		str1 := s1.Join(",")
+		gtest.Assert(strings.Contains(str1, "a1"), true)
+
+	})
+}
+
+func TestSet_String(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add("a").Add("a2").Add("b").Add("c")
+		str1 := s1.String()
+		gtest.Assert(strings.Contains(str1, "a2"), true)
+
+	})
+}
+
+func TestSet_Merge(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s2 := gset.New(true)
+		s1.Add("a").Add("a2").Add("b").Add("c")
+		s2.Add("b").Add("b1").Add("e").Add("f")
+		ss := s1.Merge(s2)
+		gtest.Assert(ss.Contains("a2"), true)
+		gtest.Assert(ss.Contains("b1"), true)
+
+	})
+}
+
+func TestSet_Sum(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.Assert(s1.Sum(), int(10))
+
+	})
+}
+
+func TestSet_Pop(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.AssertIN(s1.Pop(1), []int{1, 2, 3, 4})
+	})
+}
+
+func TestSet_Pops(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := gset.New(true)
+		s1.Add(1).Add(2).Add(3).Add(4)
+		gtest.AssertIN(s1.Pops(1), []int{1, 2, 3, 4})
+		gtest.AssertIN(s1.Pops(6), []int{1, 2, 3, 4})
+		gtest.Assert(len(s1.Pops(2)), 2)
+	})
+}

g/container/gtree/gtree_avltree.go

@@ -29,20 +29,20 @@ type AVLTreeNode struct {
 	b        int8
 }
 
-// NewAVLTree instantiates an AVL tree with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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,
 	}
 }
 
-// NewAVLTreeFrom instantiates an AVL tree with the custom comparator and data map.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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 +88,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 +120,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)
@@ -222,7 +225,7 @@ func (tree *AVLTree) Contains(key interface{}) bool {
 	return ok
 }
 
-// Remove remove the node from the tree by key.
+// Remove removes the node from the tree by key.
 // Key should adhere to the comparator's type assertion, otherwise method panics.
 func (tree *AVLTree) Remove(key interface{}) (value interface{}) {
 	tree.mu.Lock()
@@ -254,7 +257,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 +270,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 +286,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,15 +301,15 @@ 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
 }
 
-// Floor Finds floor node of the input key, return the floor node or nil if no ceiling is found.
+// Floor Finds floor node of the input key, return the floor node or nil if no floor node is found.
 // Second return parameter is true if floor was found, otherwise false.
 //
 // Floor node is defined as the largest node that is smaller than or equal to the given node.
@@ -317,14 +320,15 @@ func (tree *AVLTree) Right() *AVLTreeNode {
 func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found = false
 	n := tree.root
 	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:
+		case c == 0:
+			return n, true
+		case c < 0:
+			n = n.children[0]
+		case c > 0:
 			floor, found = n, true
 			n = n.children[1]
 		}
@@ -335,7 +339,7 @@ func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 	return nil, false
 }
 
-// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling is found.
+// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found.
 // Second return parameter is true if ceiling was found, otherwise false.
 //
 // Ceiling node is defined as the smallest node that is larger than or equal to the given node.
@@ -343,19 +347,20 @@ func (tree *AVLTree) Floor(key interface{}) (floor *AVLTreeNode, found bool) {
 // all nodes in the tree is smaller than the given node.
 //
 // Key should adhere to the comparator's type assertion, otherwise method panics.
-func (tree *AVLTree) Ceiling(key interface{}) (floor *AVLTreeNode, found bool) {
+func (tree *AVLTree) Ceiling(key interface{}) (ceiling *AVLTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found = false
 	n := tree.root
 	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:
-				floor, 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 {
@@ -403,7 +408,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())
@@ -421,13 +426,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)
@@ -441,7 +446,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)
@@ -490,7 +495,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
@@ -514,7 +519,7 @@ func (tree *AVLTree) remove(key interface{}, qp **AVLTreeNode) (value interface{
 	if fix {
 		return value, removeFix(int8(-c), qp)
 	}
-	return nil, false
+	return value, false
 }
 
 func removeMin(qp **AVLTreeNode, minKey *interface{}, minVal *interface{}) bool {
@@ -570,9 +575,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
 	}
 
@@ -599,15 +604,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
@@ -698,4 +703,4 @@ func output(node *AVLTreeNode, prefix string, isTail bool, str *string) {
 		}
 		output(node.children[0], newPrefix, true, str)
 	}
-}
+}

g/container/gtree/gtree_btree.go

@@ -19,8 +19,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.
@@ -37,24 +37,24 @@ type BTreeEntry struct {
 }
 
 // NewBTree instantiates a B-tree with <m> (maximum number of children) and a custom key comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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 param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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 +121,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 +268,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 +281,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 +328,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 +372,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 +396,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 +407,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 +426,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 +448,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 +466,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
 		}
 	}
@@ -503,9 +503,9 @@ func (tree *BTree) isLeaf(node *BTreeNode) bool {
 	return len(node.Children) == 0
 }
 
-func (tree *BTree) isFull(node *BTreeNode) bool {
-	return len(node.Entries) == tree.maxEntries()
-}
+//func (tree *BTree) isFull(node *BTreeNode) bool {
+//	return len(node.Entries) == tree.maxEntries()
+//}
 
 func (tree *BTree) shouldSplit(node *BTreeNode) bool {
 	return len(node.Entries) > tree.maxEntries()
@@ -534,14 +534,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 +646,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 +663,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 +741,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 +794,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 +821,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 +844,4 @@ 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]
-}
+}

g/container/gtree/gtree_redblacktree.go

@@ -36,20 +36,20 @@ type RedBlackTreeNode struct {
 	parent *RedBlackTreeNode
 }
 
-// NewRedBlackTree instantiates a red-black tree with the custom comparator.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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,
 	}
 }
 
-// NewRedBlackTreeFrom instantiates a red-black tree with the custom comparator and <data> map.
-// The param <unsafe> used to specify whether using tree in un-concurrent-safety,
+// 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 +86,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 +94,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 +143,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 +251,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 +311,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 +324,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 +350,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 +364,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
@@ -393,70 +393,70 @@ func (tree *RedBlackTree) rightNode() *RedBlackTreeNode {
 	return p
 }
 
-// Floor Finds floor node of the input <key>, return the floor node or nil if no floor is found.
+// Floor Finds floor node of the input key, return the floor node or nil if no floor node is found.
+// Second return parameter is true if floor was found, otherwise false.
 //
 // Floor node is defined as the largest node that its key is smaller than or equal to the given <key>.
 // A floor node may not be found, either because the tree is empty, or because
 // all nodes in the tree are larger than the given node.
-func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode) {
+func (tree *RedBlackTree) Floor(key interface{}) (floor *RedBlackTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found := false
-	node  := tree.root
-	for node != nil {
-		compare := tree.comparator(key, node.Key)
+	n := tree.root
+	for n != nil {
+		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0:
-				return node
-			case compare < 0:
-				node = node.left
-			case compare > 0:
-				floor, found = node, true
-				node         = node.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 {
-		return floor
+		return
 	}
-	return nil
+	return nil, false
 }
 
-// Ceiling finds ceiling node of the input <key>, return the ceiling node or nil if no ceiling is found.
+// Ceiling finds ceiling node of the input key, return the ceiling node or nil if no ceiling node is found.
+// Second return parameter is true if ceiling was found, otherwise false.
 //
 // Ceiling node is defined as the smallest node that its key is larger than or equal to the given <key>.
 // A ceiling node may not be found, either because the tree is empty, or because
 // all nodes in the tree are smaller than the given node.
-func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode) {
+func (tree *RedBlackTree) Ceiling(key interface{}) (ceiling *RedBlackTreeNode, found bool) {
 	tree.mu.RLock()
 	defer tree.mu.RUnlock()
-	found := false
-	node  := tree.root
-	for node != nil {
-		compare := tree.comparator(key, node.Key)
+	n := tree.root
+	for n != nil {
+		compare := tree.comparator(key, n.Key)
 		switch {
-			case compare == 0:
-				return node
-			case compare < 0:
-				ceiling, found = node, true
-				node           = node.left
-			case compare > 0:
-				node = node.right
+		case compare == 0:
+			return n, true
+		case compare > 0:
+			n = n.right
+		case compare < 0:
+			ceiling, found = n, true
+			n = n.left
 		}
 	}
 	if found {
-		return ceiling
+		return
 	}
-	return nil
+	return nil, false
 }
 
 // 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()
@@ -490,7 +490,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()
@@ -563,7 +563,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())
@@ -615,9 +615,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
@@ -654,7 +657,7 @@ func (tree *RedBlackTree) rotateLeft(node *RedBlackTreeNode) {
 	if right.left != nil {
 		right.left.parent = node
 	}
-	right.left  = node
+	right.left = node
 	node.parent = right
 }
 
@@ -665,7 +668,7 @@ func (tree *RedBlackTree) rotateRight(node *RedBlackTreeNode) {
 	if left.right != nil {
 		left.right.parent = node
 	}
-	left.right  = node
+	left.right = node
 	node.parent = left
 }
 
@@ -797,14 +800,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)
 	}
@@ -829,4 +832,4 @@ func (tree *RedBlackTree) nodeColor(node *RedBlackTreeNode) color {
 		return black
 	}
 	return node.color
-}
+}

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/gtype_z_unit_test.go

@@ -0,0 +1,291 @@
+package gtype_test
+
+import (
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+type Temp struct {
+	Name string
+	Age  int
+}
+
+func Test_Bool(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBool(true)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(false), true)
+		gtest.AssertEQ(iClone.Val(), false)
+
+		i1 := gtype.NewBool(false)
+		iClone1 := i1.Clone()
+		gtest.AssertEQ(iClone1.Set(true), false)
+		gtest.AssertEQ(iClone1.Val(), true)
+
+		//空参测试
+		i2 := gtype.NewBool()
+		gtest.AssertEQ(i2.Val(), false)
+	})
+}
+
+func Test_Byte(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 127
+		i := gtype.NewByte(byte(0))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(byte(1)), byte(0))
+		gtest.AssertEQ(iClone.Val(), byte(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(byte(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewByte()
+		gtest.AssertEQ(i1.Val(), byte(0))
+	})
+}
+
+func Test_Bytes(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBytes([]byte("abc"))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set([]byte("123")), []byte("abc"))
+		gtest.AssertEQ(iClone.Val(), []byte("123"))
+
+		//空参测试
+		i1 := gtype.NewBytes()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_String(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewString("abc")
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set("123"), "abc")
+		gtest.AssertEQ(iClone.Val(), "123")
+
+		//空参测试
+		i1 := gtype.NewString()
+		gtest.AssertEQ(i1.Val(), "")
+	})
+}
+
+func Test_Interface(t *testing.T) {
+	gtest.Case(t, func() {
+		t := Temp{Name: "gf", Age: 18}
+		t1 := Temp{Name: "gf", Age: 19}
+		i := gtype.New(t)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(t1), t)
+		gtest.AssertEQ(iClone.Val().(Temp), t1)
+
+		//空参测试
+		i1 := gtype.New()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_Float32(t *testing.T) {
+	gtest.Case(t, func() {
+		//var wg sync.WaitGroup
+		//addTimes := 100
+		i := gtype.NewFloat32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float32(0))
+		gtest.AssertEQ(iClone.Val(), float32(0.1))
+		// for index := 0; index < addTimes; index++ {
+		// 	wg.Add(1)
+		// 	go func() {
+		// 	defer wg.Done()
+		// 	i.Add(0.2)
+		// 	fmt.Println(i.Val())
+		// 	}()
+		// }
+		// wg.Wait()
+		// gtest.AssertEQ(100.0, i.Val())
+
+		//空参测试
+		i1 := gtype.NewFloat32()
+		gtest.AssertEQ(i1.Val(), float32(0))
+	})
+}
+
+func Test_Float64(t *testing.T) {
+	gtest.Case(t, func() {
+		//var wg sync.WaitGroup
+		//addTimes := 100
+		i := gtype.NewFloat64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float64(0))
+		gtest.AssertEQ(iClone.Val(), float64(0.1))
+		// for index := 0; index < addTimes; index++ {
+		// 	wg.Add(1)
+		// 	go func() {
+		// 	defer wg.Done()
+		// 	i.Add(0.1)
+		// 	fmt.Println(i.Val())
+		// 	}()
+		// }
+		// wg.Wait()
+		// gtest.AssertEQ(100.0, i.Val())
+
+		//空参测试
+		i1 := gtype.NewFloat64()
+		gtest.AssertEQ(i1.Val(), float64(0))
+	})
+}
+
+func Test_Int(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), 0)
+		gtest.AssertEQ(iClone.Val(), 1)
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(addTimes, i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt()
+		gtest.AssertEQ(i1.Val(), 0)
+	})
+}
+
+func Test_Int32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int32(0))
+		gtest.AssertEQ(iClone.Val(), int32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt32()
+		gtest.AssertEQ(i1.Val(), int32(0))
+	})
+}
+
+func Test_Int64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int64(0))
+		gtest.AssertEQ(iClone.Val(), int64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt64()
+		gtest.AssertEQ(i1.Val(), int64(0))
+	})
+}
+
+func Test_Uint(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint(0))
+		gtest.AssertEQ(iClone.Val(), uint(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint()
+		gtest.AssertEQ(i1.Val(), uint(0))
+	})
+}
+
+func Test_Uint32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint32(0))
+		gtest.AssertEQ(iClone.Val(), uint32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint32()
+		gtest.AssertEQ(i1.Val(), uint32(0))
+	})
+}
+
+func Test_Uint64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint64(0))
+		gtest.AssertEQ(iClone.Val(), uint64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint64()
+		gtest.AssertEQ(i1.Val(), uint64(0))
+	})
+}

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,179 @@
 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"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/util/gconv"
+	"time"
 )
 
+// 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 param <unsafe> used to specify whether using Var in un-concurrent-safety,
+// 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
 }
 
 // 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()
 }
 
 // Time converts and returns <v> as time.Time.
-// The param <format> specifies the format of the time string using gtime,
+// 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 param <format> specifies the format of the time string using gtime,
+// 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 param <objPointer> should be a pointer to a struct instance.
-// The param <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...)
+// The parameter <objPointer> 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) 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()) }
+// IsNil checks whether <v> is nil.
+func (v *Var) IsNil() bool {
+	return v.Val() == nil
+}
 
-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()) }
+// Bytes converts and returns <v> as []byte.
+func (v *Var) Bytes() []byte {
+	return gconv.Bytes(v.Val())
+}
 
-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()) }
+// String converts and returns <v> as string.
+func (v *Var) String() string {
+	return gconv.String(v.Val())
+}
 
-func (v *Var) Float32()        float32         { return gconv.Float32(v.Val()) }
-func (v *Var) Float64()        float64         { return gconv.Float64(v.Val()) }
+// Bool converts and returns <v> as bool.
+func (v *Var) Bool() bool {
+	return gconv.Bool(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()) }
+// 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())
+}

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

@@ -11,57 +11,140 @@ package gaes_test
 import (
 	"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          = []byte("pibigstar")
+	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")
-	key_24 = []byte("123456789123456789123456")
-	key_32 = []byte("12345678912345678912345678912345")
-	keys   = []byte("12345678912345678912345678912346")
+	iv         = []byte("Hello My GoFrame")
+	key_16     = []byte("1234567891234567")
+	key_17     = []byte("12345678912345670")
+	key_24     = []byte("123456789123456789123456")
+	key_32     = []byte("12345678912345678912345678912345")
+	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) {
 	gtest.Case(t, func() {
-		_, err := gaes.Encrypt(content, key_16)
+		data, err := gaes.Encrypt(content, key_16)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_24)
+		gtest.Assert(data, []byte(content_16))
+		data, err = gaes.Encrypt(content, key_24)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_32)
+		gtest.Assert(data, []byte(content_24))
+		data, err = gaes.Encrypt(content, key_32)
 		gtest.Assert(err, nil)
-		_, err = gaes.Encrypt(content, key_16, iv)
+		gtest.Assert(data, []byte(content_32))
+		data, err = gaes.Encrypt(content, key_16, iv)
 		gtest.Assert(err, nil)
+		gtest.Assert(data, []byte(content_16_iv))
+		data, err = gaes.Encrypt(content, key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(data, []byte(content_32_iv))
 	})
 }
 
 func TestDecrypt(t *testing.T) {
 	gtest.Case(t, func() {
-		encrypt, err := gaes.Encrypt(content, key_16)
-		decrypt, err := gaes.Decrypt(encrypt, key_16)
+		decrypt, err := gaes.Decrypt([]byte(content_16), key_16)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_24)
-		decrypt, err = gaes.Decrypt(encrypt, key_24)
+		decrypt, err = gaes.Decrypt([]byte(content_24), key_24)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32)
-		decrypt, err = gaes.Decrypt(encrypt, key_32)
+		decrypt, err = gaes.Decrypt([]byte(content_32), key_32)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, key_32, iv)
+		decrypt, err = gaes.Decrypt([]byte(content_16_iv), key_16, iv)
 		gtest.Assert(err, nil)
-		gtest.Assert(string(decrypt), string(content))
+		gtest.Assert(decrypt, content)
 
-		encrypt, err = gaes.Encrypt(content, key_32, iv)
-		decrypt, err = gaes.Decrypt(encrypt, keys, iv)
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(decrypt, content)
+
+		decrypt, err = gaes.Decrypt([]byte(content_32_iv), keys, iv)
 		gtest.Assert(err, "invalid padding")
 	})
 }
+
+func TestEncryptErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// encrypt key error
+		_, err := gaes.Encrypt(content, key_err)
+		gtest.AssertNE(err, nil)
+	})
+}
+
+func TestDecryptErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// decrypt key error
+		encrypt, err := gaes.Encrypt(content, key_16)
+		_, err = gaes.Decrypt(encrypt, key_err)
+		gtest.AssertNE(err, nil)
+
+		// decrypt content too short error
+		_, err = gaes.Decrypt([]byte("test"), key_16)
+		gtest.AssertNE(err, nil)
+
+		// decrypt content size error
+		_, err = gaes.Decrypt(key_17, key_16)
+		gtest.AssertNE(err, nil)
+	})
+}
+
+func TestPKCS5UnPaddingErr(t *testing.T) {
+	gtest.Case(t, func() {
+		// PKCS5UnPadding blockSize zero
+		_, err := gaes.PKCS5UnPadding(content, 0)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len zero
+		_, err = gaes.PKCS5UnPadding([]byte(""), 16)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len > blockSize
+		_, err = gaes.PKCS5UnPadding(key_17, 16)
+		gtest.AssertNE(err, nil)
+
+		// PKCS5UnPadding src len > blockSize
+		_, err = gaes.PKCS5UnPadding(key_32_err, 32)
+		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

@@ -12,10 +12,11 @@ import (
 	"testing"
 
 	"github.com/gogf/gf/g/crypto/gcrc32"
+	"github.com/gogf/gf/g/crypto/gmd5"
 	"github.com/gogf/gf/g/test/gtest"
 )
 
-func TestEncrypt(t *testing.T) {
+func TestEncryptString(t *testing.T) {
 	gtest.Case(t, func() {
 		s := "pibigstar"
 		result := 693191136
@@ -25,3 +26,19 @@ func TestEncrypt(t *testing.T) {
 		gtest.AssertEQ(int(encrypt2), result)
 	})
 }
+
+func TestEncrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		s := "pibigstar"
+		result := 693191136
+		encrypt1 := gcrc32.Encrypt(s)
+		encrypt2 := gcrc32.Encrypt([]byte(s))
+		gtest.AssertEQ(int(encrypt1), result)
+		gtest.AssertEQ(int(encrypt2), result)
+
+		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/internal/errors"
+	"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 = errors.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, "")
 	})
 
-
 }