garray updates

fix: #112

.gitee/ISSUE_TEMPLATE.MD

@@ -0,0 +1,34 @@
+<!-- 为更高效率地交流并解决问题，请按照以下模板提交issue，感谢！ -->
+
+### 1. 您当前使用的`Go`版本，及系统版本、系统架构？
+
+<!-- 使用 `go version` 命令查看，期望的结果如：`go 1.12, linux/amd64` -->
+
+
+### 2. 您当前使用的`GoFrame`框架版本？
+
+<!-- 框架版本可以查看自己项目下的 `go.mod`，或者框架文件 `version.go` -->
+
+
+### 3. 更新到最新的框架版本是否能够解决问题？
+
+<!-- 务必检查是否相同问题已在新版本中已修复 -->
+
+
+### 4. 问题描述？
+
+<!--
+请您尽可能地提供一份最短的，可复现问题的代码。
+代码尽可能地完整，最好是可以直接编译运行。
+-->
+
+
+
+### 5. 您期望得到的结果？
+
+
+
+### 6. 您实际得到的结果？
+
+
+

.github/ISSUE_TEMPLATE.MD

@@ -0,0 +1,36 @@
+<!-- Please answer these questions before submitting your issue. Thanks! -->
+
+### 1. What version of `Go` and system type/arch are you using?
+
+<!-- 
+Please paste the output of command `go version` from your terminal.
+What expect to see is like: `go 1.12, linux/amd64`
+-->
+
+
+### 2. What version of `GoFrame` are you using?
+
+<!-- You can find the GF version from your `go.mod`, or from the `version.go` in `GF` -->
+
+
+### 3. Can this issue be reproduced with the latest release?
+
+
+
+### 4. What did you do?
+
+<!--
+If possible, provide a copy of shortest codes for reproducing the error.
+A complete runnable program is best.
+-->
+
+
+
+### 5. What did you expect to see?
+
+
+
+### 6. What did you see instead?
+
+
+

.travis.yml

@@ -1,7 +1,8 @@
 language: go
 
 go:
-- "1.11.x"
+  - "1.11.x"
+  - "1.12.x"
 
 branches:
   only:
@@ -9,25 +10,27 @@ branches:
   - develop
 
 env:
-- GITEE_GF=$GOPATH/src/gitee.com/johng/gf GO111MODULE=on
+- GO111MODULE=on
 
 services:
 - mysql
+- redis-server
+
+addons:
+  hosts:
+  - local
 
 before_install:
 - pwd
 
 install:
-- pwd
-- mkdir -p $GITEE_GF
-- cp * $GITEE_GF -R
-- cd $GITEE_GF/g
+- cat /etc/hosts
 
 script:
+- cd g
 - GOARCH=386 go test -v ./...
 - GOARCH=amd64 go test -v ./... -race -coverprofile=coverage.txt -covermode=atomic
 
-
 after_success:
 - bash <(curl -s https://codecov.io/bash)
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2017 john@johng.cn http://johng.cn
+Copyright (c) 2017 john@goframe.org https://goframe.org
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.MD

@@ -1,28 +1,26 @@
 # GoFrame 
-<img align="right" height="150px" src="https://gfer.me/cover.png">
+<img align="right" height="150px" src="https://goframe.org/cover.png">
 
 [![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) 
-[![Documents](https://img.shields.io/badge/docs-100%25-green.svg)](https://gfer.me) 
+[![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)
-[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
-[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
 
 <!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/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: 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, lightweight, loosely coupled, high performance application development framework written in Go. Supporting graceful server, hot updates, multi-domain, multi-port, multi-service, HTTP/HTTPS, dynamic/hook routing and many more features. Providing a series of core components and dozens of practical modules.
+`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. 
 
 # Installation
 ```
-go get -u gitee.com/johng/gf
+go get -u github.com/gogf/gf
 ```
-or use `go.mod`
+or use `go.mod`:
 ```
-require gitee.com/johng/gf latest
+require github.com/gogf/gf latest
 ```
 
 # Limitation
@@ -32,11 +30,12 @@ golang version >= 1.9.2
 
 # Documentation
 
+* [APIDoc](https://godoc.org/github.com/gogf/gf)
 * [中文文档](https://goframe.org)
 
 # Architecture
 <div align=center>
-<img src="https://gfer.me/images/arch.png"/>
+<img src="https://goframe.org/images/arch.png"/>
 </div>
 
 # Quick Start
@@ -45,8 +44,8 @@ golang version >= 1.9.2
 package main
 
 import (
-    "gitee.com/johng/gf/g"
-    "gitee.com/johng/gf/g/net/ghttp"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
 )
 
 func main() {
@@ -58,47 +57,45 @@ func main() {
 }
 ```
 
-[View More..](https://gfer.me/start/index)
+[View More..](https://goframe.org/start/index)
 
 
 # License
 
 `GF` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.
 
-# Contributors(TOP 10)
 
-<a href="https://gitee.com/johng" target="_blank" title="John"><img src="https://gitee.com/uploads/27/1309327_johng.png?1530630243" width="60" align="left"></a>
+# Contributors
 
-<a href="https://gitee.com/wenzi1" target="_blank" title="蚊子"><img src="https://images.gitee.com/uploads/22/1923122_wenzi1.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zseeker" target="_blank" title="zseeker"><img src="https://gfer.me/images/contributors/zseeker.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/ymrjqyy" target="_blank" title="一墨染尽青衣颜"><img src="https://images.gitee.com/uploads/27/876827_ymrjqyy.png" width="60" align="left"></a>
-
-<a href="https://github.com/chenyang351" target="_blank" title="chenyang351"><img src="https://avatars1.githubusercontent.com/u/30063958?s=60&v=4" width="60" align="left"></a>
-
-<a href="https://gitee.com/wxkj" target="_blank" title="wxkj"><img src="https://gitee.com/uploads/56/91356_wxkj.png" width="60" align="left"></a>
-
-<a href="https://github.com/wxkj001" target="_blank" title="3wxkj001
-"><img src="https://avatars0.githubusercontent.com/u/7794279?s=60&v=4" width="60" align="left"></a>
-
-<a href="https://gitee.com/zhangjinfu" target="_blank" title="张金富"><img src="https://images.gitee.com/uploads/63/356163_zhangjinfu.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/garfieldkwong" target="_blank" title="GarfieldKwong"><img src="https://gfer.me/images/contributors/garfieldkwong.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/qq1054000800" target="_blank" title="hello"><img src="https://gitee.com/uploads/9/2209_qq1054000800.jpg" width="60" align="left"></a>
-
-<br /><br /><br />
+- [aloncn](https://github.com/aloncn)
+- [chenyang351](https://github.com/chenyang351)
+- [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://johng.cn)
+- [jroam](https://github.com/jroam)
+- [pibigstar](https://github.com/pibigstar)
+- [qq1054000800](https://gitee.com/qq1054000800)
+- [qq976739120](https://github.com/qq976739120)
+- [wenzi1](https://gitee.com/wenzi1)
+- [wxkj001](https://github.com/wxkj001)
+- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [youyixiao](https://github.com/youyixiao)
+- [zhangjinfu](https://gitee.com/zhangjinfu)
+- [zhaopengme](https://github.com/zhaopengme)
+- [zseeker](https://gitee.com/zseeker)
 
 # Donators
 
-<a href="https://gitee.com/zhuhuan12" target="_blank" title="zhuhuan12"><img src="https://gitee.com/uploads/39/751839_zhuhuan12.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/zfan_codes" target="_blank" title="范钟"><img src="https://images.gitee.com/uploads/32/2044832_zfan_codes.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/hailaz" target="_blank" title="HaiLaz"><img src="https://gitee.com/uploads/87/1273187_hailaz.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/mg91" target="_blank" title="mg91"><img src="https://images.gitee.com/uploads/30/1410930_mg91.png" width="60" align="left"></a>
+- [flyke-xu](https://gitee.com/flyke-xu)
+- [hailaz](https://gitee.com/hailaz)
+- [ireadx](https://github.com/ireadx)
+- [mg91](https://gitee.com/mg91)
+- [pibigstar](https://github.com/pibigstar)
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [wxkj](https://gitee.com/wxkj)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)
+
 
 
 

README_ZH.MD

@@ -1,23 +1,15 @@
 # GoFrame
-<img align="right" height="150px" src="https://gfer.me/cover.png">
+<img align="right" height="150px" src="https://goframe.org/cover.png">
 
 [![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) 
-[![Documents](https://img.shields.io/badge/docs-100%25-green.svg)](https://gfer.me) 
+[![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)
-[![Language](https://img.shields.io/badge/language-go-blue.svg)](https://github.com/gogf/gf)
-[![Release](https://img.shields.io/github/release/gogf/gf.svg?style=flat)](https://github.com/gogf/gf/releases)
 
-<!--
-[![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf)
-[![Code Helper](https://www.codetriage.com/gogf/gf/badges/users.svg)](https://www.codetriage.com/gogf/gf) 
---> 
-
-`GF(Go Frame)`是一款模块化、松耦合、轻量级、高性能的Go应用开发框架。支持热重启、热更新、多域名、多端口、多服务、HTTP/HTTPS、动态路由等特性
-，并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎、数据校验、分页管理、数据库ORM等等等等，
-并且提供了数十个内置核心开发模块集，如：缓存、日志、时间、命令行、二进制、文件锁、内存锁、对象池、连接池、数据编码、进程管理、进程通信、文件监控、定时任务、TCP/UDP组件、
-并发安全容器等等等等等等。
+`GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
+并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
 
 
 # 特点
@@ -31,13 +23,14 @@
 
 # 安装
 ```html
-go get -u gitee.com/johng/gf
+go get -u github.com/gogf/gf
 ```
 或者
-`go.mod`
+`go.mod`:
 ```
-require gitee.com/johng/gf latest
+require github.com/gogf/gf latest
 ```
+
 # 限制
 ```shell
 golang版本 >= 1.9.2
@@ -45,7 +38,7 @@ golang版本 >= 1.9.2
 
 # 架构
 <div align=center>
-<img src="https://gfer.me/images/arch.png"/>
+<img src="https://goframe.org/images/arch.png"/>
 </div>
 
 
@@ -61,8 +54,8 @@ golang版本 >= 1.9.2
 package main
 
 import (
-    "gitee.com/johng/gf/g"
-    "gitee.com/johng/gf/g/net/ghttp"
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/net/ghttp"
 )
 
 func main() {
@@ -74,36 +67,50 @@ func main() {
 }
 ```
 
-[更多..](https://gfer.me/start/index)
+[更多..](https://goframe.org/start/index)
 
 
 # 协议
 
 `GF` 使用非常友好的 [MIT](LICENSE) 开源协议进行发布，永久`100%`开源免费。
 
+# 捐赠
 
-# 贡献者(TOP 10)
+捐赠支持`GF`框架的研发，
+请在捐赠时备注您的`github`/`gitee`账号名称。
 
-<a href="https://gitee.com/johng" target="_blank" title="John"><img src="https://gitee.com/uploads/27/1309327_johng.png" width="60" align="left"></a>
-<a href="https://gitee.com/wenzi1" target="_blank" title="蚊子"><img src="https://images.gitee.com/uploads/22/1923122_wenzi1.png" width="60" align="left"></a>
-<a href="https://gitee.com/zseeker" target="_blank" title="zseeker"><img src="https://gfer.me/images/contributors/zseeker.png" width="60" align="left"></a>
-<a href="https://gitee.com/ymrjqyy" target="_blank" title="一墨染尽青衣颜"><img src="https://images.gitee.com/uploads/27/876827_ymrjqyy.png" width="60" align="left"></a>
-<a href="https://github.com/chenyang351" target="_blank" title="chenyang351"><img src="https://avatars1.githubusercontent.com/u/30063958?s=60&v=4" width="60" align="left"></a>
-<a href="https://gitee.com/wxkj" target="_blank" title="wxkj"><img src="https://gitee.com/uploads/56/91356_wxkj.png" width="60" align="left"></a>
-<a href="https://github.com/wxkj001" target="_blank" title="3wxkj001
-"><img src="https://avatars0.githubusercontent.com/u/7794279?s=60&v=4" width="60" align="left"></a>
-<a href="https://gitee.com/zhangjinfu" target="_blank" title="张金富"><img src="https://images.gitee.com/uploads/63/356163_zhangjinfu.png" width="60" align="left"></a>
-<a href="https://gitee.com/garfieldkwong" target="_blank" title="GarfieldKwong"><img src="https://gfer.me/images/contributors/garfieldkwong.png" width="60" align="left"></a>
-<a href="https://gitee.com/qq1054000800" target="_blank" title="hello"><img src="https://gitee.com/uploads/9/2209_qq1054000800.jpg" width="60" align="left"></a>
+<a href="https://goframe.org/images/donate.png" target="_blank">
+<img src="https://goframe.org/images/donate.png" width="300"/>
+</a>
 
-<br /><br /><br />
+# 贡献者
+
+- [aloncn](https://github.com/aloncn)
+- [chenyang351](https://github.com/chenyang351)
+- [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://johng.cn)
+- [jroam](https://github.com/jroam)
+- [pibigstar](https://github.com/pibigstar)
+- [qq1054000800](https://gitee.com/qq1054000800)
+- [qq976739120](https://github.com/qq976739120)
+- [wenzi1](https://gitee.com/wenzi1)
+- [wxkj001](https://github.com/wxkj001)
+- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [youyixiao](https://github.com/youyixiao)
+- [zhangjinfu](https://gitee.com/zhangjinfu)
+- [zhaopengme](https://github.com/zhaopengme)
+- [zseeker](https://gitee.com/zseeker)
 
 # 捐赠者
 
-<a href="https://gitee.com/zhuhuan12" target="_blank" title="zhuhuan12"><img src="https://gitee.com/uploads/39/751839_zhuhuan12.png" width="60" align="left"></a>
+- [flyke-xu](https://gitee.com/flyke-xu)
+- [hailaz](https://gitee.com/hailaz)
+- [ireadx](https://github.com/ireadx)
+- [mg91](https://gitee.com/mg91)
+- [pibigstar](https://github.com/pibigstar)
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [wxkj](https://gitee.com/wxkj)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)
 
-<a href="https://gitee.com/zfan_codes" target="_blank" title="范钟"><img src="https://images.gitee.com/uploads/32/2044832_zfan_codes.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/hailaz" target="_blank" title="HaiLaz"><img src="https://gitee.com/uploads/87/1273187_hailaz.png" width="60" align="left"></a>
-
-<a href="https://gitee.com/mg91" target="_blank" title="mg91"><img src="https://images.gitee.com/uploads/30/1410930_mg91.png" width="60" align="left"></a>

RELEASE.MD

@@ -1,3 +1,86 @@
+# `v1.6.0` (2019-04-09)
+
+## 新功能/改进
+1. `gcron`定时任务模块增加运行日志记录功能：https://goframe.org/os/gcron/index
+1. `gredis`增加全局分组配置功能，并增加更多的配置选项`maxIdle/maxActive/idleTimeout/maxConnLifetime`：https://goframe.org/database/gredis/index
+1. `gcfg`模块增加更多的默认配置文件检索路径，并且增加全局分组配置特性，增加`Instance`单例方法：https://goframe.org/os/gcfg/index
+1. `gview`模块增加更多的默认配置文件检索路径，并且增加`Instance`单例方法：https://goframe.org/os/gview/index
+1. `ghttp`模块新功能及改进：
+    - 新增`CORS`HTTP(S)跨域请求特性: https://goframe.org/net/ghttp/cors
+    - 增加`TLSConfig`配置功能；
+    - 去掉路由注册方法的`error`返回值，当产生注册错误时直接终端打印错误/输出到日志文件；
+    - 增加在`HTTP Code 302`跳转时的`Set-Cookie`支持；
+    - 增加对`SESSION ID`的安全性检查；
+    - 增加对基于`HTTPS`的`WebSocket`支持（`WSS`）：https://goframe.org/net/ghttp/websocket/index
+    - `Request`对象增加`Error`方法，用于输出自定义错误信息到`WebServer`错误日志中；
+    - 其他一些改进；
+1. `gdb`模块新功能及改进：
+    - 新增`Instance`单例管理方法；
+    - 新增`Structs/Scan`链式操作方法，`gdb.DB/TX`新增`GetStructs/GetScan`方法，用于结果集`struct`/`slice`映射转换：https://goframe.org/database/gdb/chaining
+    - 新增`Safe`链式操作方法（默认非并发安全），用于链式安全控制：https://goframe.org/database/gdb/chaining
+    - `Where`链式操作方法改进：
+        - 方法支持任意的`string/map/slice/struct/*struct`类型；
+        - 逻辑调整，当链式操作中存在多个`Where`方法调用时，自动转换为`And`条件；
+        - 支持`slice`条件参数，常用在`SELECT IN`查询中，例如：`Where("uid IN(?)", g.Slice{1,2,3})`；
+        - 支持在`map`类型条件参数的`key`中传递条件，例如：`Where(g.Map{"uid>?", uid})`；
+1. `gconv`及`gvalid`模块改进并去掉对私有`struct`方法属性的转换/校验；
+1. `gconv.Map`转换方法新增对`json tag`: `-`, `omitempty`的支持: https://goframe.org/util/gconv/map
+1. `gstr`模块新增 `ReplaceI/ReplaceIByArray/ReplaceIByMap`大小写非敏感替换方法；
+1. `gutil`模块增加`IsEmpty`方法，用于判断给定变量是否为空（整型0, 布尔false, slice/map长度为0, 其他为nil的情况，判断为空），并增加快捷方法`g.IsEmpty`；
+1. `gutil`模块增加`Export`方法，用于导出返回格式化打印的变量内容字符串，并增加快捷方法`g.Export`；
+1. `gspath`增加缓存及非缓存检索检索方法`Search`/`SearchWithCache`；
+1. `gjson`模块增加默认的`UseNumber`功能支持；
+1. `gmap`增加`SetIfNotExistFunc/SetIfNotExistFuncLock`方法；
+1. 迁移`greuseport`模块到新的仓库：https://github.com/gogf/greuseport
+1. 大量的单元测试完善；
+
+## Bug Fix
+1. 修复`gqueue`模块的资源竞争问题；
+1. 修复`gconv.GTime`转换失败问题；
+1. 修复`gconv.String`在转换`int`参数时字节溢出问题；
+1. 修复`ghttp.Request`的`HTTP Basic Auth`校验问题；
+1. 修复`gxml`针对于非`UTF-8`编码内容转换的并发安全问题；
+1. 修复`gtime`部分`Format`（`G`&`j`）格式失效问题；
+1. 修复`gudp.Conn`对象的`RemoteAddr`获取客户端连接地址方法问题；
+1. 修复`gmap/gcache`模块的`GetOrSetFuncLock`方法，增加对回调方法返回值的`nil`判断，只有非nil返回值才会被保存；
+
+
+
+# `v1.5.8` (2019-02-28)
+
+## 新特性
+1. 主库从`gitee`迁移到了`github`( https://github.com/gogf/gf )，`gitee`作为镜像站，用于国内的代码贡献及ISSUE提交，迁移说明详见：https://goframe.org/upgradeto150
+1. 对常用的`container`数组模块: `garray`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/garray
+1. 对常用的`container`集合模块: `gset`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gset
+1. 对常用的`container`MAP模块: `gmap`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/container/gmap
+1. 对常用的字符串模块: `gstr`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/g/text/gstr
+1. 改进`gform`中对`struct`/`*struct`参数的支持，`*Insert/*Save/*Replace/*Update/Where/Data`方法的参数调整为`interface{}`类型，并支持任意类型的: `string/map/slice/struct/*struct`参数传递，具体请参考：https://goframe.org/database/orm/chaining
+1. 新增/完善若干模块的单元测试用例, 包括：`gvalid`/`gregex`/`garray`/`gset`/`gmap`/`gstr`/`gconv`/`ghttp`/`gdb`；
+1. 由于`gkafka`模块比较重，且不是框架核心模块，因此将该模块迁移到新的仓库中独立管理，并去掉相关依赖包：https://github.com/gogf/gkafka
+1. 新增`greuseport`模块，用以实现TCP的`REUSEPORT`特性：https://godoc.org/github.com/gogf/gf/g/net/greuseport
+
+## 新功能/改进
+1. 去掉模板引擎内置变量中自动初始化`session`对象带来的内存占用问题；
+1. `ghttp.Client`改进，增加若干方法，详见：https://goframe.org/net/ghttp/client 
+1. `ghttp`分组路由增加`COMMON`方法，用以注册常用的`HTTP METHOD`(`GET/PUT/POST/DELETE`)路由；
+1. 更新框架依赖的`golang.org/x/sys`模块；
+1. 改进`gform`的批量操作(`Batch*`操作)返回结果对象，可以通过该结果对象获得批量操作准确的受影响记录行数；
+1. 将`gstr`/`gregex`模块从`util`分类迁移到了`text`分类目录下；
+1. 将`gtest`模块从`util`分类迁移到了`test`分类目录下；
+1. 完善`glog`方法注释；
+
+## Bug Fix
+1. 修复带点的邮件格式,用`gvalid.Check`的"`email`"规则不能匹配成功;
+1. 修复`gvalid.Check`在`regex`规则下的检查失败问题；
+1. 修复`gcron`模块定时规则中天和周不允许`?`符号的问题；
+1. 修复`ghttp.Server`在部分异常情况下仍然返回`200`状态码的问题；
+1. 修复`gfpool`模块中由于原子操作问题造成的高并发"内存泄露"问题；
+1. 修复分组路由注册对象/控制时，方法`Index`的路由仅能通过`/xxx/index`访问的问题；
+1. 修复模板引擎使用中，当不存在`config.toml`(即使没使用)配置文件时的报错问题；
+1. 其他一些修复；
+
+
+
 # `v1.4.6` (2019-01-24)
 
 ## 新特性
@@ -31,20 +114,20 @@
 # `v1.3.8` (2018-12-26)
 
 ## 新特性
-1. 对`gform`完成重构，以提高扩展性，并修复部分细节问题、完善单元测试用例([https://gfer.me/database/orm/index](https://gfer.me/database/orm/index))；
-1. `WebServer`路由注册新增分组路由特性([https://gfer.me/net/ghttp/group](https://gfer.me/net/ghttp/group));
-1. `WebServer`新增`Rewrite`路由重写特性([https://gfer.me/net/ghttp/static](https://gfer.me/net/ghttp/static));
+1. 对`gform`完成重构，以提高扩展性，并修复部分细节问题、完善单元测试用例([https://goframe.org/database/orm/index](https://goframe.org/database/orm/index))；
+1. `WebServer`路由注册新增分组路由特性([https://goframe.org/net/ghttp/group](https://goframe.org/net/ghttp/group));
+1. `WebServer`新增`Rewrite`路由重写特性([https://goframe.org/net/ghttp/static](https://goframe.org/net/ghttp/static));
 1. 增加框架运行时对开发环境的自动识别；
 1. 增加了`Travis CI`自动化构建/测试；
 
 ## 新功能
-1. 改进`WebServer`静态文件服务功能，增加`SetStaticPath`/`AddStaticPath`方法([https://gfer.me/net/ghttp/static](https://gfer.me/net/ghttp/static))；
-1. `gform`新增`Filter`链式操作方法，用于过滤参数中的非表字段键值对（[https://gfer.me/database/orm/linkop](https://gfer.me/database/orm/linkop)）；
+1. 改进`WebServer`静态文件服务功能，增加`SetStaticPath`/`AddStaticPath`方法([https://goframe.org/net/ghttp/static](https://goframe.org/net/ghttp/static))；
+1. `gform`新增`Filter`链式操作方法，用于过滤参数中的非表字段键值对（[https://goframe.org/database/orm/linkop](https://goframe.org/database/orm/linkop)）；
 1. `gcache`新增`Data`方法，用以获取所有的缓存数据项；
 1. `gredis`增加`GetConn`方法获取原生redis连接对象；
 
 ## 功能改进
-1. 改进`gform`的`Where`方法，支持`slice`类型的参数，并更方便地支持`in`操作查询（[https://gfer.me/database/orm/linkop](https://gfer.me/database/orm/linkop)）；
+1. 改进`gform`的`Where`方法，支持`slice`类型的参数，并更方便地支持`in`操作查询（[https://goframe.org/database/orm/linkop](https://goframe.org/database/orm/linkop)）；
 1. 改进`gproc`进程间通信数据结构，将`pid`字段从`16bit`扩展为`24bit`；
 1. 改进`gconv`/`gmap`/`garray`，增加若干操作方法；
 1. 改进`gview`模板引擎中的`date`内置函数，当给定的时间戳为空时打印当前的系统时间；
@@ -67,20 +150,20 @@
 
 # `v1.2.11` (2018-11-26)
 ## 新特性
-1. `ORM`新增对`SQLServer`及`Oracle`的支持([https://gfer.me/database/orm/database](https://gfer.me/database/orm/database))；
-1. 完成`gvalid`模块校验结果的顺序特性([https://gfer.me/util/gvalid/checkmap](https://gfer.me/util/gvalid/checkmap));
-1. 改进`ghttp.Request.Exit`，使得调用该方法时立即退出业务执行，开发者无需调用`Exit`方法时再使用`return`返回([https://gfer.me/net/ghttp/service/object](https://gfer.me/net/ghttp/service/object))；
-1. 模板引擎新增若干内置函数:`text/html/htmldecode/url/urldecode/date/compare/substr/strlimit/hidestr/highlight/toupper/tolower/nl2br` ([https://gfer.me/os/gview/funcs](https://gfer.me/os/gview/funcs));
-1. 模板引擎新增内置变量`Config` ([https://gfer.me/os/gview/vars](https://gfer.me/os/gview/vars));
+1. `ORM`新增对`SQLServer`及`Oracle`的支持([https://goframe.org/database/orm/database](https://goframe.org/database/orm/database))；
+1. 完成`gvalid`模块校验结果的顺序特性([https://goframe.org/util/gvalid/checkmap](https://goframe.org/util/gvalid/checkmap));
+1. 改进`ghttp.Request.Exit`，使得调用该方法时立即退出业务执行，开发者无需调用`Exit`方法时再使用`return`返回([https://goframe.org/net/ghttp/service/object](https://goframe.org/net/ghttp/service/object))；
+1. 模板引擎新增若干内置函数:`text/html/htmldecode/url/urldecode/date/compare/substr/strlimit/hidestr/highlight/toupper/tolower/nl2br` ([https://goframe.org/os/gview/funcs](https://goframe.org/os/gview/funcs));
+1. 模板引擎新增内置变量`Config` ([https://goframe.org/os/gview/vars](https://goframe.org/os/gview/vars));
 1. 改进`gconv.Struct`转换默认规则，支持不区分大小写的键名与属性名称匹配；
-1. `gform`配置文件支持`linkinfo`自定义数据库连接字段([https://gfer.me/database/orm/config](https://gfer.me/database/orm/config))；
-1. `gfsnotify`模块增加对特定回调的取消注册功能（[https://gfer.me/os/gfsnotify/index](https://gfer.me/os/gfsnotify/index)）；
+1. `gform`配置文件支持`linkinfo`自定义数据库连接字段([https://goframe.org/database/orm/config](https://goframe.org/database/orm/config))；
+1. `gfsnotify`模块增加对特定回调的取消注册功能（[https://goframe.org/os/gfsnotify/index](https://goframe.org/os/gfsnotify/index)）；
 
 
 
 ## 新功能
-1. 改进`ghttp.Request`，增加`SetParam/GetParam`请求流程自定义变量设置/获取方法，用于在请求流程中的回调函数共享变量（[https://gfer.me/net/ghttp/request](https://gfer.me/net/ghttp/request)）;
-1. 改进`ghttp.Response`，增加`ServeFileDownload`方法，用于WebServer引导客户端下载文件([https://gfer.me/net/ghttp/response](https://gfer.me/net/ghttp/response));
+1. 改进`ghttp.Request`，增加`SetParam/GetParam`请求流程自定义变量设置/获取方法，用于在请求流程中的回调函数共享变量（[https://goframe.org/net/ghttp/request](https://goframe.org/net/ghttp/request)）;
+1. 改进`ghttp.Response`，增加`ServeFileDownload`方法，用于WebServer引导客户端下载文件([https://goframe.org/net/ghttp/response](https://goframe.org/net/ghttp/response));
 1. `gvar`模块新增`gvar.VarRead`只读接口，用于控制对外只暴露数据读取功能；
 1. 增加`g.Throw`抛异常方法，`g.TryCatch`异常捕获方法封装;
 1. 改进`gcron`模块，增加自定义的Cron管理对象，增加`New/Start/Stop`方法;
@@ -88,9 +171,9 @@
 
 ## 功能改进
 1. WebServer添加`RouterCacheExpire`配置参数，用于设置路由检索缓存过期时间；
-1. WebServer允许同一`HOOK`事件被多次绑定注册，先注册的回调函数优先级更高([https://gfer.me/net/ghttp/service/hook](https://gfer.me/net/ghttp/service/hook));
+1. WebServer允许同一`HOOK`事件被多次绑定注册，先注册的回调函数优先级更高([https://goframe.org/net/ghttp/service/hook](https://goframe.org/net/ghttp/service/hook));
 1. 当前工作目录为系统临时目录时，`gcfg`/`gview`/`ghttp`模块默认不添加工作目录到搜索路径;
-1. 改进`WebSocket`默认支持跨域请求([https://gfer.me/net/ghttp/websocket](https://gfer.me/net/ghttp/websocket));
+1. 改进`WebSocket`默认支持跨域请求([https://goframe.org/net/ghttp/websocket](https://goframe.org/net/ghttp/websocket));
 1. 改进`gtime.Format`支持中文;
 1. 改进`gfsnotify`，支持编辑器对文件非执行标准编辑时(RENAME+CHMOD)的热更新问题;
 1. 改进`gtype.Set`方法，增加Set原子操作返回旧的变量值;
@@ -99,12 +182,12 @@
 1. `gstr`模块增加对中文截取方法;
 1. 改进`gtime.StrToTime`对常用时间格式匹配模式，新增`gtime.ParseTimeFromContent`方法;
 1. 修改配置管理、模板引擎、调试模式的环境变量名称为大写下划线标准格式;
-1. 改进`grand`模块随机数生成设计，底层使用`crypto/rand`+缓冲区实现高速的随机数生成([https://gfer.me/util/grand/index](https://gfer.me/util/grand/index));
+1. 改进`grand`模块随机数生成设计，底层使用`crypto/rand`+缓冲区实现高速的随机数生成([https://goframe.org/util/grand/index](https://goframe.org/util/grand/index));
 
 ## 问题修复
 1. 修复`gspath`模块在`windows`下搜索失效问题；
 1. 修复`gspath`模块Search时带有indexFiles的检索问题;
-1. bug fix INZS1([https://gitee.com/johng/gf/issues/INZS1](https://gitee.com/johng/gf/issues/INZS1));
+1. bug fix INZS1([https://github.com/gogf/gf/issues/INZS1](https://github.com/gogf/gf/issues/INZS1));
 1. 修复`gproc.ShellRun`在windows下的执行问题;
 
 
@@ -343,8 +426,8 @@
     12、gdb数据库ORM包增加And/Or条件链式方法，并改进Where/Data方法参数灵活性；
     13、对于新增加的模块，同时也增加了对应的开发文档，并梳理完善了现有的其他模块开发文档；
     14、修复ISSUE:
-        #IISWI gitee.com/johng/gf/issues/IISWI,
-        #IISMY gitee.com/johng/gf/issues/IISMY,
+        #IISWI github.com/gogf/gf/issues/IISWI,
+        #IISMY github.com/gogf/gf/issues/IISMY,
         反馈并跟踪完成第三方依赖mxj包的ISSUE修复(github.com/clbanning/mxj/issues/48)；
 
 

TODO.MD

@@ -1,23 +1,16 @@
 # ON THE WAY
 1. 增加图形验证码支持，至少支持数字和英文字母；
-1. 增加热编译工具，提高开发环境的开发/测试效率（媲美PHP开发效率）；
-1. 增加可选择性的orm tag特性，用以数据表记录与struct对象转换的键名属性映射；
-1. ghttp.Response增加输出内容后自动退出当前请求机制，不需要用户手动return，参考beego如何实现；
 1. Cookie&Session数据池化处理；
 1. ghttp.Client增加proxy特性；
 1. gtime增加对时区转换的封装，并简化失去转换时对类似+80500时区的支持；
 1. orm增加sqlite对Save方法的支持(去掉触发器语句);
 1. ghttp.Server增加Ip访问控制功能(DenyIps&AllowIps)；
-1. ghttp路由功能增加分组路由特性；
 1. ghttp增加返回数据压缩机制；
 1. gview中的template标签失效问题；
-1. gfile文件stat信息使用gfsnotify进行缓存更新改进；
 1. ghttp.Server增加proxy功能特性，本地proxy和远程proxy，本地即将路由规则映射；远程即反向代理；
 1. gjson对大json数据的解析效率问题；
 1. ghttp增加route name特性，并同时支持backend和template(提供内置函数)引用，可以通过RedirectRoute方法给定route name和路由参数跳转到指定的路由地址上；
-1. ghttp.Client自动Close机制；
 1. gvalid校验支持当第一个规则失败后便不再校验后续的规则，最好做成链式操作；
-1. 检查ghttp.Server超时问题；
 1. gvalid增加支持对[]rune的长度校验(一个中文占3个字节)；
 1. ghttp.Request增加对输入参数的自动HtmlEncode机制；
 1. 常量命名风格根据golint进行修改；
@@ -36,17 +29,22 @@
     - https://github.com/Masterminds/sprig
 1. gform参考 https://gohouse.github.io/gorose/dist/index.html 进行改进
 1. gtcp提供简便的包发送/接收方法(SendPkg/RecvPkg)以解决常见的TCP通信粘包问题，并完善文档（参考：https://www.cnblogs.com/kex1n/p/6502002.html）；
-1. gfile对于文件的读写强行使用了gfpool，在某些场景下不合适，需要考虑剥离开，并为开发者提供单独的指针池文件操作特性；
 1. 路由增加不区分大小写得匹配方式；
-1. str_ireplace: http://php.net/manual/en/function.str-ireplace.php
-1. strpos/stripos/strrpos/strripos: http://php.net/manual/en/function.stripos.php
 1. 改进WebServer获取POST参数处理逻辑，当提交非form数据时，例如json数据，针对某些方法可以直接解析；
 1. WebServer增加可选择的路由覆盖配置，默认情况下不覆盖；
-1. gkafka这个包比较重，未来从框架中剥离出来；
 1. grpool性能压测结果变慢的问题；
 1. 增加jumplist的数据结构容器；
 1. DelayQueue/PriorityQueue；
-1. gconv针对struct的转换增加json tag支持，gconv.Map默认也支持json tag;
+1. 权限管理模块；
+1. 从ghttp中剥离SESSION功能构成单独的模块gsession；
+1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
+1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
+1. gtcp增加对TLS加密通信的支持；
+1. 添加Save/Replace/BatchSave/BatchReplace方法对sqlite数据库的支持；
+1. 添加sqlite数据库的单元测试用例；
+1. gredis增加cluster支持；
+1. gset.Add/Remove/Contains方法增加批量操作支持；
+1. gmlock增加手动清理机制：当内存锁不再使用时，由调用端决定是否清理内存锁；
 
 # DONE
 1.  gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；
@@ -105,4 +103,19 @@
 1. gform对于MySQL字段类型为datetime类型的时区问题分析；
 1. 改进证书打开失败时的WebServer错误提示，前置HOOK校验后关闭后续的HOOK逻辑执行；
 1. 目前WebServer的HOOK是按照优先级执行的，需要增加覆盖特性；
-
+1. 更新跨域请求CORS相关功能文档；
+1. ghttp.Response增加输出内容后自动退出当前请求机制，不需要用户手动return，参考beego如何实现；
+1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
+1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；
+1. gdb的Data方法支持struct参数传入；
+1. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
+1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
+1. gconv针对struct的转换增加json tag支持，gconv.Map默认也支持json tag, 完善开发文档；
+1. 增加SO_REUSEPORT的支持；
+1. gkafka这个包比较重，未来从框架中剥离出来；
+1. str_ireplace: http://php.net/manual/en/function.str-ireplace.php
+1. strpos/stripos/strrpos/strripos: http://php.net/manual/en/function.stripos.php
+1. gfile对于文件的读写强行使用了gfpool，在某些场景下不合适，需要考虑剥离开，并为开发者提供单独的指针池文件操作特性；
+1. ghttp.Client自动Close机制；
+1. ghttp路由功能增加分组路由特性；
+1. 增加可选择性的orm tag特性，用以数据表记录与struct对象转换的键名属性映射；

g/container/container.go

@@ -1,7 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-package container

g/container/garray/garray.go

@@ -1,14 +1,9 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package garray provides kinds of concurrent-safe(alternative) arrays.
-//
-// 并发安全的数组.
+// Package garray provides concurrent-safe/unsafe arrays.
 package garray
 
-func New(size int, cap int, unsafe...bool) *Array {
-    return NewArray(size, cap, unsafe...)
-}

g/container/garray/garray_func.go

@@ -0,0 +1,20 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package garray
+
+
+type apiSliceInterface interface {
+    Slice() []interface{}
+}
+
+type apiSliceInt interface {
+    Slice() []int
+}
+
+type apiSliceString interface {
+    Slice() []string
+}

g/container/garray/garray_int.go

@@ -1,176 +0,0 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-package garray
-
-import (
-	"gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type IntArray struct {
-	mu    *rwmutex.RWMutex // 互斥锁
-	cap   int              // 初始化设置的数组容量
-	size  int              // 初始化设置的数组大小
-	array []int            // 底层数组
-}
-
-func NewIntArray(size int, cap int, unsafe...bool) *IntArray {
-	a := &IntArray{
-		mu : rwmutex.New(unsafe...),
-	}
-	a.size = size
-	if cap > 0 {
-		a.cap   = cap
-		a.array = make([]int, size, cap)
-	} else {
-		a.array = make([]int, size)
-	}
-	return a
-}
-
-// 获取指定索引的数据项, 调用方注意判断数组边界
-func (a *IntArray) Get(index int) int {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	value := a.array[index]
-	return value
-}
-
-// 设置指定索引的数据项, 调用方注意判断数组边界
-func (a *IntArray) Set(index int, value int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array[index] = value
-}
-
-// 在当前索引位置前插入一个数据项, 调用方注意判断数组边界
-func (a *IntArray) InsertBefore(index int, value int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index : ]...)
-	a.array = append(a.array[0 : index], value)
-	a.array = append(a.array, rear...)
-}
-
-// 在当前索引位置后插入一个数据项, 调用方注意判断数组边界
-func (a *IntArray) InsertAfter(index int, value int) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	rear   := append([]int{}, a.array[index + 1:]...)
-	a.array = append(a.array[0 : index + 1], value)
-	a.array = append(a.array, rear...)
-
-}
-
-// 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *IntArray) Remove(index int) int {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	// 边界删除判断，以提高删除效率
-	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
-	}
-	// 如果非边界删除，会涉及到数组创建，那么删除的效率差一些
-	value  := a.array[index]
-	a.array = append(a.array[ : index], a.array[index + 1 : ]...)
-	return value
-}
-
-// 追加数据项
-func (a *IntArray) Append(value...int) {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-    a.mu.Unlock()
-}
-
-// 数组长度
-func (a *IntArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
-}
-
-// 返回原始数据数组
-func (a *IntArray) Slice() []int {
-	array := ([]int)(nil)
-	if a.mu.IsSafe() {
-		a.mu.RLock()
-		array = make([]int, len(a.array))
-		for k, v := range a.array {
-			array[k] = v
-		}
-		a.mu.RUnlock()
-	} else {
-		array = a.array
-	}
-	return array
-}
-
-// 清空数据数组
-func (a *IntArray) Clear() {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		if a.cap > 0 {
-			a.array = make([]int, a.size, a.cap)
-		} else {
-			a.array = make([]int, a.size)
-		}
-	}
-    a.mu.Unlock()
-}
-
-// 查找指定数值的索引位置，返回索引位置，如果查找不到则返回-1
-func (a *IntArray) Search(value int) 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()
-
-	return result
-}
-
-// 清理数组中重复的元素项
-func (a *IntArray) Unique() *IntArray {
-	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
-}
-
-// 使用自定义方法执行加锁修改操作
-func (a *IntArray) LockFunc(f func(array []int)) {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
-	f(a.array)
-}
-
-// 使用自定义方法执行加锁读取操作
-func (a *IntArray) RLockFunc(f func(array []int)) {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
-	f(a.array)
-}

g/container/garray/garray_interface.go

@@ -1,194 +0,0 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-package garray
-
-import (
-    "gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type Array struct {
-    mu     *rwmutex.RWMutex  // 互斥锁
-    cap    int               // 初始化设置的数组容量
-    size   int               // 初始化设置的数组大小
-    array  []interface{}     // 底层数组
-}
-
-func NewArray(size int, cap int, unsafe...bool) *Array {
-    a := &Array{
-        mu : rwmutex.New(unsafe...),
-    }
-    a.size = size
-    if cap > 0 {
-        a.cap   = cap
-        a.array = make([]interface{}, size, cap)
-    } else {
-        a.array = make([]interface{}, size)
-    }
-    return a
-}
-
-// 获取指定索引的数据项, 调用方注意判断数组边界
-func (a *Array) Get(index int) interface{} {
-    a.mu.RLock()
-    defer a.mu.RUnlock()
-    value := a.array[index]
-    return value
-}
-
-// 设置指定索引的数据项, 调用方注意判断数组边界
-func (a *Array) Set(index int, value interface{}) {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    a.array[index] = value
-}
-
-// 在当前索引位置前插入一个数据项, 调用方注意判断数组边界
-func (a *Array) InsertBefore(index int, value interface{}) {
-    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...)
-}
-
-// 在当前索引位置前插入一个数据项, 调用方注意判断数组边界
-func (a *Array) InsertAfter(index int, value interface{}) {
-    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...)
-}
-
-// 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *Array) Remove(index int) interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    // 边界删除判断，以提高删除效率
-    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
-    }
-    // 如果非边界删除，会涉及到数组创建，那么删除的效率差一些
-    value  := a.array[index]
-    a.array = append(a.array[ : index], a.array[index + 1 : ]...)
-    return value
-}
-
-// 将最左端(索引为0)的数据项移出数组，并返回该数据项
-func (a *Array) PopLeft() interface{} {
-    a.mu.Lock()
-    defer a.mu.Unlock()
-    value  := a.array[0]
-    a.array = a.array[1 : ]
-    return value
-}
-
-// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
-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
-}
-
-// 追加数据项
-func (a *Array) Append(value...interface{}) {
-    a.mu.Lock()
-    a.array = append(a.array, value...)
-    a.mu.Unlock()
-}
-
-// 数组长度
-func (a *Array) Len() int {
-    a.mu.RLock()
-    length := len(a.array)
-    a.mu.RUnlock()
-    return length
-}
-
-// 返回原始数据数组
-func (a *Array) Slice() []interface{} {
-    array := ([]interface{})(nil)
-    if a.mu.IsSafe() {
-        a.mu.RLock()
-        array = make([]interface{}, len(a.array))
-        for k, v := range a.array {
-            array[k] = v
-        }
-        a.mu.RUnlock()
-    } else {
-        array = a.array
-    }
-    return array
-}
-
-// 清空数据数组
-func (a *Array) Clear() {
-    a.mu.Lock()
-    if len(a.array) > 0 {
-        if a.cap > 0 {
-            a.array = make([]interface{}, a.size, a.cap)
-        } else {
-            a.array = make([]interface{}, a.size)
-        }
-    }
-    a.mu.Unlock()
-}
-
-// 查找指定数值的索引位置，返回索引位置，如果查找不到则返回-1
-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()
-
-    return result
-}
-
-// 清理数组中重复的元素项
-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
-}
-
-// 使用自定义方法执行加锁修改操作
-func (a *Array) LockFunc(f func(array []interface{})) {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
-    f(a.array)
-}
-
-// 使用自定义方法执行加锁读取操作
-func (a *Array) RLockFunc(f func(array []interface{})) {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
-    f(a.array)
-}

g/container/garray/garray_normal_int.go

@@ -0,0 +1,580 @@
+// 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 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"
+)
+
+type IntArray struct {
+	mu    *rwmutex.RWMutex
+	array []int
+}
+
+// NewIntArray creates and returns an empty array.
+// The param <unsafe> used to specify whether using array in un-concurrent-safety,
+// which is false in default.
+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 with 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),
+    }
+}
+
+// NewIntArrayFrom creates and returns an array with given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default.
+func NewIntArrayFrom(array []int, unsafe...bool) *IntArray {
+	return &IntArray{
+        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 with 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,
+    }
+}
+
+// Get returns the value of the specified index,
+// the caller should notice the boundary of the array.
+func (a *IntArray) Get(index int) int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
+}
+
+// Set sets value to specified index.
+func (a *IntArray) Set(index int, value int) *IntArray {
+	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 *IntArray) SetArray(array []int) *IntArray {
+    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
+}
+
+// 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
+}
+
+// Sort sorts the array in increasing order.
+// The param <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
+}
+
+// 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
+}
+
+// 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)
+	a.array = append(a.array, rear...)
+    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)
+	a.array = append(a.array, rear...)
+    return a
+}
+
+// Remove removes an item by index.
+func (a *IntArray) Remove(index int) int {
+	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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// PopRand randomly pops and return an item out of array.
+func (a *IntArray) PopRand() int {
+    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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// See PushRight.
+func (a *IntArray) Append(value...int) *IntArray {
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+    a.mu.Unlock()
+    return a
+}
+
+// Len returns the length of array.
+func (a *IntArray) Len() int {
+	a.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 *IntArray) Slice() []int {
+	array := ([]int)(nil)
+	if a.mu.IsSafe() {
+		a.mu.RLock()
+		defer a.mu.RUnlock()
+		array = make([]int, len(a.array))
+		copy(array, a.array)
+	} else {
+		array = a.array
+	}
+	return array
+}
+
+// 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())
+}
+
+// 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
+}
+
+// Contains checks whether a value exists in the array.
+func (a *IntArray) Contains(value int) bool {
+    return a.Search(value) != -1
+}
+
+// Search searches array by <value>, returns the index of <value>,
+// or returns -1 if not exists.
+func (a *IntArray) Search(value int) int {
+	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
+}
+
+// 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 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 *IntArray) LockFunc(f func(array []int)) *IntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+    return a
+}
+
+// RLockFunc locks reading by callback function <f>.
+func (a *IntArray) RLockFunc(f func(array []int)) *IntArray {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+    return a
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Pad pads array to the specified length with <value>.
+// If size is positive then the array is padded on the right, or negative on the left.
+// If the absolute value of <size> is less than or equal to the length of the array
+// then no padding takes place.
+func (a *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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *IntArray) CountValues() map[int]int {
+	m := make(map[int]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// String returns current array as a string.
+func (a *IntArray) String() string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return fmt.Sprint(a.array)
+}

g/container/garray/garray_normal_interface.go

@@ -0,0 +1,574 @@
+// 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 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"
+)
+
+type Array struct {
+    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,
+// which is false in default.
+func New(unsafe...bool) *Array {
+    return NewArraySize(0, 0, unsafe...)
+}
+
+// See New.
+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 with 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),
+    }
+}
+
+// See NewArrayFrom.
+func NewFrom(array []interface{}, unsafe...bool) *Array {
+    return NewArrayFrom(array, unsafe...)
+}
+
+// See NewArrayFromCopy.
+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 with un-concurrent-safety,
+// which is false in default.
+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 with 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,
+    }
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Remove removes an item by index.
+func (a *Array) Remove(index int) interface{} {
+    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
+}
+
+// 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
+}
+
+// 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
+}
+
+// PopRand randomly pops and return an item out of array.
+func (a *Array) PopRand() interface{} {
+    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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// See PushRight.
+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
+}
+
+// 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
+}
+
+// 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())
+}
+
+// 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
+}
+
+// Contains checks whether a value exists in the array.
+func (a *Array) Contains(value interface{}) bool {
+    return a.Search(value) != -1
+}
+
+// Search searches array by <value>, returns the index of <value>,
+// or returns -1 if not exists.
+func (a *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()
+
+    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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Pad pads array to the specified length with <value>.
+// If size is positive then the array is padded on the right, or negative on the left.
+// If the absolute value of <size> is less than or equal to the length of the array
+// then no padding takes place.
+func (a *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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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()
+}
+
+// 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
+}
+
+// String returns current array as a string.
+func (a *Array) String() string {
+    a.mu.RLock()
+    defer a.mu.RUnlock()
+    return fmt.Sprint(a.array)
+}

g/container/garray/garray_normal_string.go

@@ -0,0 +1,580 @@
+// 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 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"
+    "strings"
+)
+
+type StringArray struct {
+	mu    *rwmutex.RWMutex
+	array []string
+}
+
+// NewStringArray creates and returns an empty array.
+// The param <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...)
+}
+
+// NewStringArraySize create and returns an array with given size and cap.
+// The param <unsafe> used to specify whether using array with 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),
+    }
+}
+
+// NewStringArrayFrom creates and returns an array with given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default.
+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 with 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,
+    }
+}
+
+// Get returns the value of the specified index,
+// the caller should notice the boundary of the array.
+func (a *StringArray) Get(index int) string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	value := a.array[index]
+	return value
+}
+
+// Set sets value to specified index.
+func (a *StringArray) Set(index int, value string) *StringArray {
+	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 *StringArray) SetArray(array []string) *StringArray {
+    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
+}
+
+// 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
+}
+
+// Sort sorts the array in increasing order.
+// The param <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
+}
+
+// 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
+}
+
+// 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)
+	a.array = append(a.array, rear...)
+    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)
+	a.array = append(a.array, rear...)
+    return a
+}
+
+// Remove removes an item by index.
+func (a *StringArray) 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
+	}
+	// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// PopRand randomly pops and return an item out of array.
+func (a *StringArray) PopRand() string {
+    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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// See PushRight.
+func (a *StringArray) Append(value...string) *StringArray {
+	a.mu.Lock()
+	a.array = append(a.array, value...)
+	a.mu.Unlock()
+    return a
+}
+
+// Len returns the length of array.
+func (a *StringArray) Len() int {
+	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 *StringArray) 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
+}
+
+// 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())
+}
+
+// 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
+}
+
+// Contains checks whether a value exists in the array.
+func (a *StringArray) Contains(value string) bool {
+    return a.Search(value) != -1
+}
+
+// Search searches array by <value>, returns the index of <value>,
+// or returns -1 if not exists.
+func (a *StringArray) Search(value string) int {
+	if len(a.array) == 0 {
+		return -1
+	}
+	a.mu.RLock()
+	result := -1
+	for index, v := range a.array {
+		if strings.Compare(v, value) == 0 {
+			result = index
+			break
+		}
+	}
+	a.mu.RUnlock()
+	return result
+}
+
+// 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 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 *StringArray) LockFunc(f func(array []string)) *StringArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	f(a.array)
+    return a
+}
+
+// RLockFunc locks reading by callback function <f>.
+func (a *StringArray) RLockFunc(f func(array []string)) *StringArray {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	f(a.array)
+    return a
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Pad pads array to the specified length with <value>.
+// If size is positive then the array is padded on the right, or negative on the left.
+// If the absolute value of <size> is less than or equal to the length of the array
+// then no padding takes place.
+func (a *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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *StringArray) CountValues() map[string]int {
+	m := make(map[string]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// String returns current array as a string.
+func (a *StringArray) String() string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return fmt.Sprint(a.array)
+}

g/container/garray/garray_sorted_int.go

@@ -1,27 +1,41 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package garray
 
 import (
-    "gitee.com/johng/gf/g/container/gtype"
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "bytes"
+	"fmt"
+	"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"
 )
 
-// 默认按照从低到高进行排序
+// It's using increasing order in default.
 type SortedIntArray struct {
-    mu          *rwmutex.RWMutex     // 互斥锁
-    cap         int                  // 初始化设置的数组容量
-    array       []int                // 底层数组
-    unique      *gtype.Bool          // 是否要求不能重复(默认false)
-    compareFunc func(v1, v2 int) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
+    mu          *rwmutex.RWMutex
+    array       []int
+    unique      *gtype.Bool          // Whether enable unique feature(false)
+    compareFunc func(v1, v2 int) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
-// 创建一个排序的int数组
-func NewSortedIntArray(cap int, unsafe...bool) *SortedIntArray {
+// NewSortedIntArray 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.
+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 with 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),
@@ -38,10 +52,51 @@ func NewSortedIntArray(cap int, unsafe...bool) *SortedIntArray {
     }
 }
 
-// 添加加数据项
-func (a *SortedIntArray) Add(values...int) {
+// NewIntArrayFrom creates and returns an sorted array with given slice <array>.
+// The param <unsafe> used to specify whether using array with 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
+}
+
+// NewSortedIntArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with 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,
+    }
+}
+
+// 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
+}
+
+// Sort sorts the array in increasing order.
+// The param <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
+}
+
+// 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
+        return a
     }
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -54,7 +109,6 @@ func (a *SortedIntArray) Add(values...int) {
             a.array = append(a.array, value)
             continue
         }
-        // 加到指定索引后面
         if cmp > 0 {
             index++
         }
@@ -62,9 +116,11 @@ func (a *SortedIntArray) Add(values...int) {
         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()
@@ -72,11 +128,11 @@ func (a *SortedIntArray) Get(index int) int {
     return value
 }
 
-// 删除指定索引的数据项, 调用方注意判断数组边界
+// Remove removes an item by index.
 func (a *SortedIntArray) Remove(index int) int {
     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 : ]
@@ -86,13 +142,15 @@ func (a *SortedIntArray) Remove(index int) int {
         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
 }
 
-// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+// PopLeft pops and returns an item from the beginning of array.
 func (a *SortedIntArray) PopLeft() int {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -101,7 +159,7 @@ func (a *SortedIntArray) PopLeft() int {
     return value
 }
 
-// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+// PopRight pops and returns an item from the end of array.
 func (a *SortedIntArray) PopRight() int {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -111,7 +169,82 @@ func (a *SortedIntArray) PopRight() int {
     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)))
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Len returns the length of array.
 func (a *SortedIntArray) Len() int {
     a.mu.RLock()
     length := len(a.array)
@@ -119,28 +252,45 @@ func (a *SortedIntArray) Len() int {
     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
+}
+
+// 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))
-        for k, v := range a.array {
-            array[k] = v
-        }
-        a.mu.RUnlock()
+        copy(array, a.array)
     } else {
         array = a.array
     }
     return array
 }
 
-// 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
-// 返回值: 最后比较位置, 比较结果
-func (a *SortedIntArray) Search(value int) (index int, result int) {
-    return a.binSearch(value, true)
+// Contains checks whether a value exists in the array.
+func (a *SortedIntArray) Contains(value int) bool {
+    return a.Search(value) == 0
 }
 
+// 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
+}
+
+// Binary search.
 func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
     if len(a.array) == 0 {
         return -1, -2
@@ -156,27 +306,30 @@ func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int)
     for min <= max {
         mid = int((min + max) / 2)
         cmp = a.compareFunc(value, a.array[mid])
-        switch cmp {
-            case -1 : max = mid - 1
-            case  1 : min = mid + 1
-            case  0 :
+        switch {
+            case cmp < 0 : max = mid - 1
+            case cmp > 0 : min = mid + 1
+            default :
                 return mid, cmp
         }
     }
     return mid, cmp
 }
 
-// 设置是否允许数组唯一
-func (a *SortedIntArray) SetUnique(unique bool) {
+// 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.doUnique()
+        a.Unique()
     }
+    return a
 }
 
-// 清理数组中重复的元素项
-func (a *SortedIntArray) doUnique() {
+// Unique uniques the array, clear repeated items.
+func (a *SortedIntArray) Unique() *SortedIntArray {
     a.mu.Lock()
     i := 0
     for {
@@ -190,27 +343,158 @@ func (a *SortedIntArray) doUnique() {
         }
     }
     a.mu.Unlock()
+    return a
 }
 
-// 清空数据数组
-func (a *SortedIntArray) Clear() {
+// 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())
+}
+
+// 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.cap)
+        a.array = make([]int, 0)
     }
     a.mu.Unlock()
+    return a
 }
 
-// 使用自定义方法执行加锁修改操作
-func (a *SortedIntArray) LockFunc(f func(array []int)) {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+// 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
 }
 
-// 使用自定义方法执行加锁读取操作
-func (a *SortedIntArray) RLockFunc(f func(array []int)) {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+// 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
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *SortedIntArray) CountValues() map[int]int {
+	m := make(map[int]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// String returns current array as a string.
+func (a *SortedIntArray) String() string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return fmt.Sprint(a.array)
 }

g/container/garray/garray_sorted_interface.go

@@ -1,26 +1,44 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package garray
 
 import (
-    "gitee.com/johng/gf/g/container/gtype"
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "bytes"
+	"fmt"
+	"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"
 )
 
-// 默认按照从低到高进行排序
+// It's using increasing order in default.
 type SortedArray struct {
-    mu          *rwmutex.RWMutex             // 互斥锁
-    cap         int                          // 初始化设置的数组容量
-    array       []interface{}                // 底层数组
-    unique      *gtype.Bool                  // 是否要求不能重复
-    compareFunc func(v1, v2 interface{}) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
+    mu          *rwmutex.RWMutex
+    array       []interface{}
+    unique      *gtype.Bool                  // Whether enable unique feature(false)
+    compareFunc func(v1, v2 interface{}) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
-func NewSortedArray(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
+// NewSortedArray creates and returns an empty sorted array.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety, which is false in default.
+// The param <compareFunc> 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(compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
+    return NewSortedArraySize(0, compareFunc, unsafe...)
+}
+
+// NewSortedArraySize create and returns an sorted array with given size and cap.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default.
+func NewSortedArraySize(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
     return &SortedArray{
         mu          : rwmutex.New(unsafe...),
         unique      : gtype.NewBool(),
@@ -29,10 +47,57 @@ func NewSortedArray(cap int, compareFunc func(v1, v2 interface{}) int, unsafe...
     }
 }
 
-// 添加加数据项
-func (a *SortedArray) Add(values...interface{}) {
+// NewSortedArrayFrom creates and returns an sorted array with given slice <array>.
+// The param <unsafe> used to specify whether using array with un-concurrent-safety,
+// which is false in default.
+func NewSortedArrayFrom(array []interface{}, compareFunc func(v1, v2 interface{}) int, unsafe...bool) *SortedArray {
+    a := NewSortedArraySize(0, compareFunc, unsafe...)
+    a.array = array
+    sort.Slice(a.array, func(i, j int) bool {
+        return a.compareFunc(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 with 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,
+    }
+}
+
+// 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.compareFunc(a.array[i], a.array[j]) < 0
+    })
+    return a
+}
+
+// Sort sorts the array in increasing order.
+// The param <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.compareFunc(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
+        return a
     }
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -45,7 +110,6 @@ func (a *SortedArray) Add(values...interface{}) {
             a.array = append(a.array, value)
             continue
         }
-        // 加到指定索引后面
         if cmp > 0 {
             index++
         }
@@ -53,9 +117,11 @@ func (a *SortedArray) Add(values...interface{}) {
         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()
@@ -63,11 +129,11 @@ func (a *SortedArray) Get(index int) interface{} {
     return value
 }
 
-// 删除指定索引的数据项, 调用方注意判断数组边界
+// Remove removes an item by index.
 func (a *SortedArray) Remove(index int) interface{} {
     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 : ]
@@ -77,13 +143,15 @@ func (a *SortedArray) Remove(index int) interface{} {
         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
 }
 
-// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+// PopLeft pops and returns an item from the beginning of array.
 func (a *SortedArray) PopLeft() interface{} {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -92,7 +160,7 @@ func (a *SortedArray) PopLeft() interface{} {
     return value
 }
 
-// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+// PopRight pops and returns an item from the end of array.
 func (a *SortedArray) PopRight() interface{} {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -102,7 +170,92 @@ func (a *SortedArray) PopRight() interface{} {
     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)))
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Len returns the length of array.
 func (a *SortedArray) Len() int {
     a.mu.RLock()
     length := len(a.array)
@@ -110,30 +263,35 @@ func (a *SortedArray) Len() int {
     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))
-        for k, v := range a.array {
-            array[k] = v
-        }
-        a.mu.RUnlock()
+        copy(array, a.array)
     } else {
         array = a.array
     }
     return array
 }
 
-// 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
-// 返回值: 最后比较位置, 比较结果
-func (a *SortedArray) Search(value interface{}) (index int, result int) {
-    return a.binSearch(value, true)
+// Contains checks whether a value exists in the array.
+func (a *SortedArray) Contains(value interface{}) bool {
+    return a.Search(value) == 0
 }
 
-// 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
-// 返回值: 最后比较位置, 比较结果
+// 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
+}
+
+// Binary search.
 func (a *SortedArray) binSearch(value interface{}, lock bool)(index int, result int) {
     if len(a.array) == 0 {
         return -1, -2
@@ -149,27 +307,30 @@ func (a *SortedArray) binSearch(value interface{}, lock bool)(index int, result
     for min <= max {
         mid = int((min + max) / 2)
         cmp = a.compareFunc(value, a.array[mid])
-        switch cmp {
-            case -1 : max = mid - 1
-            case  1 : min = mid + 1
-            case  0 :
+        switch {
+            case cmp < 0 : max = mid - 1
+            case cmp > 0 : min = mid + 1
+            default :
                 return mid, cmp
         }
     }
     return mid, cmp
 }
 
-// 设置是否允许数组唯一
-func (a *SortedArray) SetUnique(unique bool) {
+// 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.doUnique()
+        a.Unique()
     }
+    return a
 }
 
-// 清理数组中重复的元素项
-func (a *SortedArray) doUnique() {
+// Unique uniques the array, clear repeated items.
+func (a *SortedArray) Unique() *SortedArray {
     a.mu.Lock()
     defer a.mu.Unlock()
     i := 0
@@ -183,27 +344,158 @@ func (a *SortedArray) doUnique() {
             i++
         }
     }
+    return a
 }
 
-// 清空数据数组
-func (a *SortedArray) Clear() {
+// 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.compareFunc, !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.cap)
+        a.array = make([]interface{}, 0)
     }
     a.mu.Unlock()
+    return a
 }
 
-// 使用自定义方法执行加锁修改操作
-func (a *SortedArray) LockFunc(f func(array []interface{})) {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+// 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
 }
 
-// 使用自定义方法执行加锁读取操作
-func (a *SortedArray) RLockFunc(f func(array []interface{})) {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+// 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
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *SortedArray) CountValues() map[interface{}]int {
+	m := make(map[interface{}]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// String returns current array as a string.
+func (a *SortedArray) String() string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return fmt.Sprint(a.array)
 }

g/container/garray/garray_sorted_string.go

@@ -1,27 +1,42 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package garray
 
 import (
-    "gitee.com/johng/gf/g/container/gtype"
+    "bytes"
+	"fmt"
+	"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"
-    "gitee.com/johng/gf/g/internal/rwmutex"
 )
 
-// 默认按照从低到高进行排序
+// It's using increasing order in default.
 type SortedStringArray struct {
-    mu          *rwmutex.RWMutex        // 互斥锁
-    cap         int                     // 初始化设置的数组容量
-    array       []string                // 底层数组
-    unique      *gtype.Bool             // 是否要求不能重复
-    compareFunc func(v1, v2 string) int // 比较函数，返回值 -1: v1 < v2；0: v1 == v2；1: v1 > v2
+    mu          *rwmutex.RWMutex
+    array       []string
+    unique      *gtype.Bool             // Whether enable unique feature(false)
+    compareFunc func(v1, v2 string) int // Comparison function(it returns -1: v1 < v2; 0: v1 == v2; 1: v1 > v2)
 }
 
-func NewSortedStringArray(cap int, unsafe...bool) *SortedStringArray {
+// NewSortedStringArray 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.
+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 with 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),
@@ -32,10 +47,51 @@ func NewSortedStringArray(cap int, unsafe...bool) *SortedStringArray {
     }
 }
 
-// 添加加数据项
-func (a *SortedStringArray) Add(values...string) {
+// NewSortedStringArrayFrom creates and returns an sorted array with given slice <array>.
+// The param <unsafe> used to specify whether using array with 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
+}
+
+// NewSortedStringArrayFromCopy creates and returns an sorted array from a copy of given slice <array>.
+// The param <unsafe> used to specify whether using array with 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,
+    }
+}
+
+// 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
+}
+
+// Sort sorts the array in increasing order.
+// The param <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
+}
+
+// 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
+        return a
     }
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -48,7 +104,6 @@ func (a *SortedStringArray) Add(values...string) {
             a.array = append(a.array, value)
             continue
         }
-        // 加到指定索引后面
         if cmp > 0 {
             index++
         }
@@ -56,9 +111,11 @@ func (a *SortedStringArray) Add(values...string) {
         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()
@@ -66,11 +123,11 @@ func (a *SortedStringArray) Get(index int) string {
     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 : ]
@@ -80,13 +137,15 @@ func (a *SortedStringArray) Remove(index int) string {
         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
 }
 
-// 将最左端(索引为0)的数据项移出数组，并返回该数据项
+// PopLeft pops and returns an item from the beginning of array.
 func (a *SortedStringArray) PopLeft() string {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -95,7 +154,7 @@ func (a *SortedStringArray) PopLeft() string {
     return value
 }
 
-// 将最右端(索引为length - 1)的数据项移出数组，并返回该数据项
+// PopRight pops and returns an item from the end of array.
 func (a *SortedStringArray) PopRight() string {
     a.mu.Lock()
     defer a.mu.Unlock()
@@ -105,7 +164,92 @@ func (a *SortedStringArray) PopRight() string {
     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)))
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Len returns the length of array.
 func (a *SortedStringArray) Len() int {
     a.mu.RLock()
     length := len(a.array)
@@ -113,28 +257,35 @@ func (a *SortedStringArray) Len() int {
     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))
-        for k, v := range a.array {
-            array[k] = v
-        }
-        a.mu.RUnlock()
+        copy(array, a.array)
     } else {
         array = a.array
     }
     return array
 }
 
-// 查找指定数值的索引位置，返回索引位置(具体匹配位置或者最后对比位置)及查找结果
-// 返回值: 最后比较位置, 比较结果
-func (a *SortedStringArray) Search(value string) (index int, result int) {
-    return a.binSearch(value, true)
+// Contains checks whether a value exists in the array.
+func (a *SortedStringArray) Contains(value string) bool {
+    return a.Search(value) == 0
 }
 
+// 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
+}
+
+// Binary search.
 func (a *SortedStringArray) binSearch(value string, lock bool) (index int, result int) {
     if len(a.array) == 0 {
         return -1, -2
@@ -150,27 +301,30 @@ func (a *SortedStringArray) binSearch(value string, lock bool) (index int, resul
     for min <= max {
         mid = int((min + max) / 2)
         cmp = a.compareFunc(value, a.array[mid])
-        switch cmp {
-            case -1 : max = mid - 1
-            case  1 : min = mid + 1
-            case  0 :
+        switch {
+            case cmp < 0 : max = mid - 1
+            case cmp > 0 : min = mid + 1
+            default :
                 return mid, cmp
         }
     }
     return mid, cmp
 }
 
-// 设置是否允许数组唯一
-func (a *SortedStringArray) SetUnique(unique bool) {
+// 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.doUnique()
+        a.Unique()
     }
+    return a
 }
 
-// 清理数组中重复的元素项
-func (a *SortedStringArray) doUnique() {
+// Unique uniques the array, clear repeated items.
+func (a *SortedStringArray) Unique() *SortedStringArray {
     a.mu.Lock()
     i := 0
     for {
@@ -184,27 +338,158 @@ func (a *SortedStringArray) doUnique() {
         }
     }
     a.mu.Unlock()
+    return a
 }
 
-// 清空数据数组
-func (a *SortedStringArray) Clear() {
+// 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())
+}
+
+// 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.cap)
+        a.array = make([]string, 0)
     }
     a.mu.Unlock()
+    return a
 }
 
-// 使用自定义方法执行加锁修改操作
-func (a *SortedStringArray) LockFunc(f func(array []string)) {
-    a.mu.Lock(true)
-    defer a.mu.Unlock(true)
+// 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
 }
 
-// 使用自定义方法执行加锁读取操作
-func (a *SortedStringArray) RLockFunc(f func(array []string)) {
-    a.mu.RLock(true)
-    defer a.mu.RUnlock(true)
+// 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
+}
+
+// Merge merges <array> into current array.
+// The parameter <array> can be any garray or slice type.
+// The difference between Merge and Append is Append supports only specified slice type,
+// but Merge supports more parameter types.
+func (a *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
+}
+
+// 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:]
+    }
+}
+
+// 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))]
+}
+
+// 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
+}
+
+// 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()
+}
+
+// CountValues counts the number of occurrences of all values in the array.
+func (a *SortedStringArray) CountValues() map[string]int {
+	m := make(map[string]int)
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	for _, v := range a.array {
+		m[v]++
+	}
+	return m
+}
+
+// String returns current array as a string.
+func (a *SortedStringArray) String() string {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	return fmt.Sprint(a.array)
 }

g/container/garray/garray_string.go

@@ -1,175 +0,0 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-package garray
-
-import (
-	"strings"
-	"gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type StringArray struct {
-	mu    *rwmutex.RWMutex // 互斥锁
-	cap   int              // 初始化设置的数组容量
-	size  int              // 初始化设置的数组大小
-	array []string         // 底层数组
-}
-
-func NewStringArray(size int, cap int, unsafe...bool) *StringArray {
-	a := &StringArray{
-		mu : rwmutex.New(unsafe...),
-	}
-	a.size = size
-	if cap > 0 {
-		a.cap   = cap
-		a.array = make([]string, size, cap)
-	} else {
-		a.array = make([]string, size)
-	}
-	return a
-}
-
-// 获取指定索引的数据项, 调用方注意判断数组边界
-func (a *StringArray) Get(index int) string {
-	a.mu.RLock()
-	defer a.mu.RUnlock()
-	value := a.array[index]
-	return value
-}
-
-// 设置指定索引的数据项, 调用方注意判断数组边界
-func (a *StringArray) Set(index int, value string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	a.array[index] = value
-}
-
-// 在当前索引位置前插入一个数据项, 调用方注意判断数组边界
-func (a *StringArray) InsertBefore(index int, value string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index : ]...)
-	a.array = append(a.array[0 : index], value)
-	a.array = append(a.array, rear...)
-}
-
-// 在当前索引位置后插入一个数据项, 调用方注意判断数组边界
-func (a *StringArray) InsertAfter(index int, value string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	rear   := append([]string{}, a.array[index + 1:]...)
-	a.array = append(a.array[ 0: index + 1], value)
-	a.array = append(a.array, rear...)
-}
-
-// 删除指定索引的数据项, 调用方注意判断数组边界
-func (a *StringArray) Remove(index int) string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	// 边界删除判断，以提高删除效率
-	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
-	}
-	// 如果非边界删除，会涉及到数组创建，那么删除的效率差一些
-	value  := a.array[index]
-	a.array = append(a.array[ : index], a.array[index + 1 : ]...)
-	return value
-}
-
-// 追加数据项
-func (a *StringArray) Append(value...string) {
-	a.mu.Lock()
-	a.array = append(a.array, value...)
-	a.mu.Unlock()
-}
-
-// 数组长度
-func (a *StringArray) Len() int {
-	a.mu.RLock()
-	length := len(a.array)
-	a.mu.RUnlock()
-	return length
-}
-
-// 返回原始数据数组
-func (a *StringArray) Slice() []string {
-	array := ([]string)(nil)
-	if a.mu.IsSafe() {
-        a.mu.RLock()
-		array = make([]string, len(a.array))
-		for k, v := range a.array {
-            array[k] = v
-		}
-        a.mu.RUnlock()
-	} else {
-		array = a.array
-	}
-	return array
-}
-
-// 清空数据数组
-func (a *StringArray) Clear() {
-	a.mu.Lock()
-	if len(a.array) > 0 {
-		if a.cap > 0 {
-			a.array = make([]string, a.size, a.cap)
-		} else {
-			a.array = make([]string, a.size)
-		}
-	}
-	a.mu.Unlock()
-}
-
-// 查找指定数值的索引位置，返回索引位置，如果查找不到则返回-1
-func (a *StringArray) Search(value string) int {
-	if len(a.array) == 0 {
-		return -1
-	}
-	a.mu.RLock()
-	result := -1
-	for index, v := range a.array {
-		if strings.Compare(v, value) == 0 {
-			result = index
-			break
-		}
-	}
-	a.mu.RUnlock()
-	return result
-}
-
-// 清理数组中重复的元素项
-func (a *StringArray) Unique() *StringArray {
-	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
-}
-
-// 使用自定义方法执行加锁修改操作
-func (a *StringArray) LockFunc(f func(array []string)) {
-	a.mu.Lock(true)
-	defer a.mu.Unlock(true)
-	f(a.array)
-}
-
-// 使用自定义方法执行加锁读取操作
-func (a *StringArray) RLockFunc(f func(array []string)) {
-	a.mu.RLock(true)
-	defer a.mu.RUnlock(true)
-	f(a.array)
-}

g/container/garray/garray_z_bench_test.go

@@ -1,20 +1,20 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
 package garray_test
 
 import (
-    "gitee.com/johng/gf/g/container/garray"
+    "github.com/gogf/gf/g/container/garray"
     "testing"
 )
 
 var (
-    sortedIntArray = garray.NewSortedIntArray(0)
+    sortedIntArray = garray.NewSortedIntArray()
 )
 
 func BenchmarkSortedIntArray_Add(b *testing.B) {

g/container/garray/garray_z_example_test.go

@@ -0,0 +1,111 @@
+// 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 garray_test
+
+import (
+    "fmt"
+    "github.com/gogf/gf/g/container/garray"
+)
+
+func Example_basic() {
+    // 创建普通的数组，默认并发安全(带锁)
+    a := garray.New()
+
+    // 添加数据项
+    for i := 0; i < 10; i++ {
+        a.Append(i)
+    }
+
+    // 获取当前数组长度
+    fmt.Println(a.Len())
+
+    // 获取当前数据项列表
+    fmt.Println(a.Slice())
+
+    // 获取指定索引项
+    fmt.Println(a.Get(6))
+
+    // 查找指定数据项是否存在
+    fmt.Println(a.Contains(6))
+    fmt.Println(a.Contains(100))
+
+    // 在指定索引前插入数据项
+    a.InsertAfter(9, 11)
+    // 在指定索引后插入数据项
+    a.InsertBefore(10, 10)
+
+    fmt.Println(a.Slice())
+
+    // 修改指定索引的数据项
+    a.Set(0, 100)
+    fmt.Println(a.Slice())
+
+    // 搜索数据项，返回搜索到的索引位置
+    fmt.Println(a.Search(5))
+
+    // 删除指定索引的数据项
+    a.Remove(0)
+    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]
+    // []
+}
+
+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())
+}
+
+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))
+
+    // 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())
+
+    // Output:
+    // [1 2]
+    // [1 2 1 2 3 4 5 6 7 8 9 0]
+}

g/container/garray/garray_z_unit_basic_test.go

@@ -1,25 +1,24 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go
 
 package garray_test
 
 import (
-    "gitee.com/johng/gf/g/container/garray"
-    "gitee.com/johng/gf/g/util/gconv"
-    "gitee.com/johng/gf/g/util/gtest"
+    "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(0, 0)
+    array  := garray.NewIntArray()
     array.Append(1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6)
     array.Unique()
     gtest.Assert(array.Slice(), expect)
@@ -27,7 +26,7 @@ func Test_IntArray_Unique(t *testing.T) {
 
 func Test_SortedIntArray1(t *testing.T) {
     expect := []int{0,1,2,3,4,5,6,7,8,9,10}
-    array  := garray.NewSortedIntArray(0)
+    array  := garray.NewSortedIntArray()
     for i := 10; i > -1; i-- {
         array.Add(i)
     }
@@ -36,7 +35,7 @@ func Test_SortedIntArray1(t *testing.T) {
 
 func Test_SortedIntArray2(t *testing.T) {
     expect := []int{0,1,2,3,4,5,6,7,8,9,10}
-    array  := garray.NewSortedIntArray(0)
+    array  := garray.NewSortedIntArray()
     for i := 0; i <= 10; i++ {
         array.Add(i)
     }
@@ -45,7 +44,7 @@ func Test_SortedIntArray2(t *testing.T) {
 
 func Test_SortedStringArray1(t *testing.T) {
     expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedStringArray(0)
+    array  := garray.NewSortedStringArray()
     for i := 10; i > -1; i-- {
         array.Add(gconv.String(i))
     }
@@ -54,7 +53,7 @@ func Test_SortedStringArray1(t *testing.T) {
 
 func Test_SortedStringArray2(t *testing.T) {
     expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedStringArray(0)
+    array  := garray.NewSortedStringArray()
     for i := 0; i <= 10; i++ {
         array.Add(gconv.String(i))
     }
@@ -63,7 +62,7 @@ func Test_SortedStringArray2(t *testing.T) {
 
 func Test_SortedArray1(t *testing.T) {
     expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedArray(0, func(v1, v2 interface{}) int {
+    array  := garray.NewSortedArray(func(v1, v2 interface{}) int {
         return strings.Compare(gconv.String(v1), gconv.String(v2))
     })
     for i := 10; i > -1; i-- {
@@ -74,7 +73,7 @@ func Test_SortedArray1(t *testing.T) {
 
 func Test_SortedArray2(t *testing.T) {
     expect := []string{"0","1","10","2","3","4","5","6","7","8","9"}
-    array  := garray.NewSortedArray(0, func(v1, v2 interface{}) int {
+    array  := garray.NewSortedArray(func(v1, v2 interface{}) int {
         return strings.Compare(gconv.String(v1), gconv.String(v2))
     })
     for i := 0; i <= 10; i++ {

g/container/garray/garray_z_unit_int_test.go

@@ -0,0 +1,201 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+    "github.com/gogf/gf/g/container/garray"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_IntArray_Basic(t *testing.T) {
+    gtest.Case(t, func() {
+        expect := []int{0, 1, 2, 3}
+        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)
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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{})
+    })
+}
+
+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)
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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})
+    })
+}
+
+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")
+    })
+}

g/container/garray/garray_z_unit_interface_test.go

@@ -0,0 +1,204 @@
+// 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.
+
+// go test *.go
+
+package garray_test
+
+import (
+    "github.com/gogf/gf/g/container/garray"
+    "github.com/gogf/gf/g/test/gtest"
+    "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)
+    })
+}
+
+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)
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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)
+    })
+}
+
+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{}{})
+    })
+}
+
+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)
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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})
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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})
+    })
+}
+
+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")
+    })
+}

g/container/garray/garray_z_unit_string_test.go

@@ -0,0 +1,201 @@
+// 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.
+
+// go test *.go
+
+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"
+)
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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"})
+    })
+}
+
+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"})
+    })
+}
+
+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{}{})
+    })
+}
+
+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)
+    })
+}
+
+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"})
+    })
+}
+
+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"})
+    })
+}
+
+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"})
+    })
+}
+
+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"})
+    })
+}
+
+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"})
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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"})
+    })
+}
+
+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")
+    })
+}

g/container/gchan/gchan.go

@@ -1,53 +1,62 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package gchan provides graceful operations for channel.
+// Package gchan provides graceful channel for safe operations.
 //
-// 优雅的Channel操作.
+// It's safe to call Chan.Push/Close functions repeatedly.
 package gchan
 
 import (
     "errors"
-    "gitee.com/johng/gf/g/container/gtype"
+    "github.com/gogf/gf/g/container/gtype"
 )
 
 type Chan struct {
-    list   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 {
-        list   : make(chan interface{}, limit),
-        closed : gtype.NewBool(),
+	    channel : make(chan interface{}, limit),
+        closed  : gtype.NewBool(),
     }
 }
 
-// 将数据压入队列
-func (q *Chan) Push(v interface{}) error {
-    if q.closed.Val() {
+// 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("closed")
     }
-    q.list <- v
+    c.channel <- value
     return nil
 }
 
-// 先进先出地从队列取出一项数据，当没有数据可获取时，阻塞等待
-func (q *Chan) Pop() interface{} {
-    return <- q.list
+// Pop pops value from channel.
+// If there's no value in channel, it would block to wait.
+func (c *Chan) Pop() interface{} {
+    return <- c.channel
 }
 
-// 关闭队列(通知所有通过Pop阻塞的协程退出)
-func (q *Chan) Close() {
-    if !q.closed.Set(true) {
-        close(q.list)
+// Close closes the channel.
+// It is safe to be called repeatedly.
+func (c *Chan) Close() {
+    if !c.closed.Set(true) {
+        close(c.channel)
     }
 }
 
-// 获取当前队列大小
-func (q *Chan) Size() int {
-    return len(q.list)
+// See Len.
+func (c *Chan) Size() int {
+    return c.Len()
+}
+
+// Len returns the length of the channel.
+func (c *Chan) Len() int {
+	return len(c.channel)
 }

g/container/gchan/gchan_test.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*"
 
@@ -10,7 +10,7 @@ package gchan_test
 
 import (
     "testing"
-    "gitee.com/johng/gf/g/container/gchan"
+    "github.com/gogf/gf/g/container/gchan"
 )
 
 var length = 10000000

g/container/glist/glist.go

@@ -1,28 +1,26 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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 l file,
-// You can obtain one at https://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 //
 
-// Package glist provides a concurrent-safe(alternative) doubly linked list.
-//
-// 并发安全的双向链表.
+// Package glist provides a concurrent-safe/unsafe doubly linked list.
 package glist
 
 import (
     "container/list"
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/internal/rwmutex"
 )
 
-// 变长双向链表
-type List struct {
-    mu     *rwmutex.RWMutex
-    list   *list.List
-}
-
-type Element = list.Element
+type (
+	List struct {
+	    mu   *rwmutex.RWMutex
+	    list *list.List
+	}
 
+	Element = list.Element
+)
 
 // 获得一个变长链表指针
 func New(unsafe...bool) *List {

g/container/glist/glist_z_bench_test.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 

g/container/glist/glist_z_unit_test.go

@@ -1,8 +1,8 @@
-// Copyright 2019 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
 //
 // This Source Code Form is subject to the terms of the MIT License.
 // If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package glist
 

g/container/gmap/gmap.go

@@ -1,21 +1,318 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package gmap provides kinds of concurrent-safe(alternative) maps.
-//
-// 并发安全的哈希MAP.
+// Package gmap provides concurrent-safe/unsafe maps.
 package gmap
 
-// 默认的Map对象其实就是InterfaceInterfaceMap的别名。
-// 注意
-// 1、这个Map是所有并发安全Map中效率最低的，如果对效率要求比较高的场合，请合理选择对应数据类型的Map；
-// 2、这个Map的优点是使用简便，由于键值都是interface{}类型，因此对键值的数据类型要求不高；
-// 3、底层实现比较类似于sync.Map；
-type Map = InterfaceInterfaceMap
+import "github.com/gogf/gf/g/internal/rwmutex"
 
-func New(safe...bool) *Map {
-    return NewInterfaceInterfaceMap(safe...)
+type Map struct {
+    mu *rwmutex.RWMutex
+    m  map[interface{}]interface{}
+}
+
+// New returns an empty hash map.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
+func New(unsafe ...bool) *Map {
+    return NewMap(unsafe...)
+}
+
+// Alias of New. See New.
+func NewMap(unsafe ...bool) *Map {
+    return &Map{
+        m  : make(map[interface{}]interface{}),
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewFrom returns a hash map from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewFrom(m map[interface{}]interface{}, unsafe...bool) *Map {
+    return &Map{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewFromArray returns a hash map from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewFromArray(keys []interface{}, values []interface{}, unsafe...bool) *Map {
+    m := make(map[interface{}]interface{})
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = interface{}(nil)
+        }
+    }
+    return &Map{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *Map) Iterator(f func (k interface{}, v interface{}) bool) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    for k, v := range gm.m {
+        if !f(k, v) {
+            break
+        }
+    }
+}
+
+// Clone returns a new hash map with copy of current map data.
+func (gm *Map) Clone(unsafe ...bool) *Map {
+    return NewFrom(gm.Map(), unsafe ...)
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *Map) Map() map[interface{}]interface{} {
+    m := make(map[interface{}]interface{})
+    gm.mu.RLock()
+    for k, v := range gm.m {
+        m[k] = v
+    }
+    gm.mu.RUnlock()
+    return m
+}
+
+// Set sets key-value to the hash map.
+func (gm *Map) Set(key interface{}, val interface{}) {
+    gm.mu.Lock()
+    gm.m[key] = val
+    gm.mu.Unlock()
+}
+
+// BatchSet batch sets key-values to the hash map.
+func (gm *Map) BatchSet(m map[interface{}]interface{}) {
+    gm.mu.Lock()
+    for k, v := range m {
+        gm.m[k] = v
+    }
+    gm.mu.Unlock()
+}
+
+// Get returns the value by given <key>.
+func (gm *Map) Get(key interface{}) interface{} {
+    gm.mu.RLock()
+    val, _ := gm.m[key]
+    gm.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.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
+func (gm *Map) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if v, ok := gm.m[key]; ok {
+        return v
+    }
+    if f, ok := value.(func() interface {}); ok {
+        value = f()
+    }
+    gm.m[key] = value
+    return value
+}
+
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *Map) GetOrSet(key interface{}, value interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.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 (gm *Map) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.doSetWithLockCheck(key, f())
+    } else {
+        return v
+    }
+}
+
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *Map) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.doSetWithLockCheck(key, f)
+    } 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 (gm *Map) SetIfNotExist(key interface{}, value interface{}) bool {
+    if !gm.Contains(key) {
+        gm.doSetWithLockCheck(key, value)
+        return true
+    }
+    return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *Map) SetIfNotExistFunc(key interface{}, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *Map) SetIfNotExistFuncLock(key interface{}, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *Map) BatchRemove(keys []interface{}) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *Map) Remove(key interface{}) interface{} {
+    gm.mu.Lock()
+    val, exists := gm.m[key]
+    if exists {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
+    return val
+}
+
+// Keys returns all keys of the map as a slice.
+func (gm *Map) Keys() []interface{} {
+    gm.mu.RLock()
+    keys := make([]interface{}, 0)
+    for key, _ := range gm.m {
+        keys = append(keys, key)
+    }
+    gm.mu.RUnlock()
+    return keys
+}
+
+// Values returns all values of the map as a slice.
+func (gm *Map) Values() []interface{} {
+    gm.mu.RLock()
+    vals := make([]interface{}, 0)
+    for _, val := range gm.m {
+        vals = append(vals, val)
+    }
+    gm.mu.RUnlock()
+    return vals
+}
+
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *Map) Contains(key interface{}) bool {
+    gm.mu.RLock()
+    _, exists := gm.m[key]
+    gm.mu.RUnlock()
+    return exists
+}
+
+// Size returns the size of the map.
+func (gm *Map) Size() int {
+    gm.mu.RLock()
+    length := len(gm.m)
+    gm.mu.RUnlock()
+    return length
+}
+
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *Map) IsEmpty() bool {
+    gm.mu.RLock()
+    empty := len(gm.m) == 0
+    gm.mu.RUnlock()
+    return empty
+}
+
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *Map) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[interface{}]interface{})
+    gm.mu.Unlock()
+}
+
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *Map) LockFunc(f func(m map[interface{}]interface{})) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    f(gm.m)
+}
+
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *Map) RLockFunc(f func(m map[interface{}]interface{})) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *Map) Flip() {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    n := make(map[interface{}]interface{}, len(gm.m))
+    for i, v := range gm.m {
+        n[v] = i
+    }
+    gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *Map) Merge(other *Map) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range other.m {
+        gm.m[k] = v
+    }
 }

g/container/gmap/gmap_func.go

@@ -0,0 +1,8 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gmap
+

g/container/gmap/gmap_int_bool_map.go

@@ -1,14 +1,14 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type IntBoolMap struct {
@@ -16,6 +16,9 @@ type IntBoolMap struct {
     mu *rwmutex.RWMutex
 }
 
+// NewIntBoolMap returns an empty IntBoolMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntBoolMap(unsafe...bool) *IntBoolMap {
 	return &IntBoolMap{
         m  : make(map[int]bool),
@@ -23,201 +26,280 @@ func NewIntBoolMap(unsafe...bool) *IntBoolMap {
     }
 }
 
-// 哈希表克隆
-func (this *IntBoolMap) Clone() map[int]bool {
+// NewIntBoolMapFrom returns an IntBoolMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewIntBoolMapFrom(m map[int]bool, unsafe...bool) *IntBoolMap {
+    return &IntBoolMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewIntBoolMapFromArray returns an IntBoolMap from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewIntBoolMapFromArray(keys []int, values []bool, unsafe...bool) *IntBoolMap {
+    m := make(map[int]bool)
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = false
+        }
+    }
+    return &IntBoolMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Clone returns a new hash map with copy of current map data.
+func (gm *IntBoolMap) Clone() *IntBoolMap {
+    return NewIntBoolMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *IntBoolMap) Map() map[int]bool {
 	m := make(map[int]bool)
-	this.mu.RLock()
-	for k, v := range this.m {
+	gm.mu.RLock()
+	for k, v := range gm.m {
 		m[k] = v
 	}
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
 	return m
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *IntBoolMap) Iterator(f func (k int, v bool) bool) {
-    this.mu.RLock()
-    defer this.mu.RUnlock()
-    for k, v := range this.m {
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *IntBoolMap) Iterator(f func (k int, v bool) bool) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    for k, v := range gm.m {
         if !f(k, v) {
             break
         }
     }
 }
 
-// 设置键值对
-func (this *IntBoolMap) Set(key int, val bool) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *IntBoolMap) Set(key int, val bool) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *IntBoolMap) BatchSet(m map[int]bool) {
-	this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *IntBoolMap) BatchSet(m map[int]bool) {
+	gm.mu.Lock()
 	for k, v := range m {
-		this.m[k] = v
+		gm.m[k] = v
 	}
-	this.mu.Unlock()
+	gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *IntBoolMap) Get(key int) bool {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *IntBoolMap) Get(key int) bool {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *IntBoolMap) doSetWithLockCheck(key int, value bool) bool {
-    this.mu.Lock()
-    if v, ok := this.m[key]; ok {
-        this.mu.Unlock()
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *IntBoolMap) doSetWithLockCheck(key int, value bool) bool {
+    gm.mu.Lock()
+    if v, ok := gm.m[key]; ok {
+        gm.mu.Unlock()
         return v
     }
-    this.m[key] = value
-    this.mu.Unlock()
+    gm.m[key] = value
+    gm.mu.Unlock()
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *IntBoolMap) GetOrSet(key int, value bool) bool {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *IntBoolMap) GetOrSet(key int, value bool) bool {
+    gm.mu.RLock()
+    v, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        return this.doSetWithLockCheck(key, value)
+        return gm.doSetWithLockCheck(key, value)
     } else {
         return v
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *IntBoolMap) GetOrSetFunc(key int, f func() bool) bool {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+func (gm *IntBoolMap) GetOrSetFunc(key int, f func() bool) bool {
+    gm.mu.RLock()
+    v, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        return this.doSetWithLockCheck(key, f())
+        return gm.doSetWithLockCheck(key, f())
     } else {
         return v
     }
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
-    this.mu.RLock()
-    val, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
+    gm.mu.RLock()
+    val, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        this.mu.Lock()
-        defer this.mu.Unlock()
-        if v, ok := this.m[key]; ok {
-            this.mu.Unlock()
+        gm.mu.Lock()
+        defer gm.mu.Unlock()
+        if v, ok := gm.m[key]; ok {
             return v
         }
-        val         = f()
-        this.m[key] = val
+        val       = f()
+        gm.m[key] = val
         return val
     } else {
         return val
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *IntBoolMap) SetIfNotExist(key int, value bool) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
+// 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 (gm *IntBoolMap) SetIfNotExist(key int, value bool) bool {
+    if !gm.Contains(key) {
+        gm.doSetWithLockCheck(key, value)
         return true
     }
     return false
 }
 
-// 批量删除键值对
-func (this *IntBoolMap) BatchRemove(keys []int) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntBoolMap) SetIfNotExistFunc(key int, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *IntBoolMap) Remove(key int) bool {
-    this.mu.Lock()
-    val, exists := this.m[key]
-    if exists {
-        delete(this.m, key)
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntBoolMap) SetIfNotExistFuncLock(key int, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *IntBoolMap) BatchRemove(keys []int) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
     }
-    this.mu.Unlock()
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *IntBoolMap) Remove(key int) bool {
+    gm.mu.Lock()
+    val, exists := gm.m[key]
+    if exists {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
     return val
 }
 
-// 返回键列表
-func (this *IntBoolMap) Keys() []int {
-    this.mu.RLock()
+// Keys returns all keys of the map as a slice.
+func (gm *IntBoolMap) Keys() []int {
+    gm.mu.RLock()
     keys := make([]int, 0)
-    for key, _ := range this.m {
+    for key, _ := range gm.m {
         keys = append(keys, key)
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return keys
 }
 
-// 返回值列表(注意是随机排序)
-//func (this *IntBoolMap) Values() []bool {
-//    this.mu.RLock()
-//    vals := make([]bool, 0)
-//    for _, val := range this.m {
-//        vals = append(vals, val)
-//    }
-//    this.mu.RUnlock()
-//    return vals
-//}
-
-// 是否存在某个键
-func (this *IntBoolMap) Contains(key int) bool {
-	this.mu.RLock()
-	_, exists := this.m[key]
-	this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *IntBoolMap) Contains(key int) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
 	return exists
 }
 
-// 哈希表大小
-func (this *IntBoolMap) Size() int {
-    this.mu.RLock()
-    length := len(this.m)
-    this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *IntBoolMap) Size() int {
+    gm.mu.RLock()
+    length := len(gm.m)
+    gm.mu.RUnlock()
     return length
 }
 
-// 哈希表是否为空
-func (this *IntBoolMap) IsEmpty() bool {
-    this.mu.RLock()
-    empty := len(this.m) == 0
-    this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *IntBoolMap) IsEmpty() bool {
+    gm.mu.RLock()
+    empty := len(gm.m) == 0
+    gm.mu.RUnlock()
     return empty
 }
 
-// 清空哈希表
-func (this *IntBoolMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[int]bool)
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *IntBoolMap) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[int]bool)
+    gm.mu.Unlock()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *IntBoolMap) LockFunc(f func(m map[int]bool)) {
-    this.mu.Lock(true)
-    defer this.mu.Unlock(true)
-    f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *IntBoolMap) LockFunc(f func(m map[int]bool)) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    f(gm.m)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *IntBoolMap) RLockFunc(f func(m map[int]bool)) {
-    this.mu.RLock(true)
-    defer this.mu.RUnlock(true)
-    f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *IntBoolMap) RLockFunc(f func(m map[int]bool)) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    f(gm.m)
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntBoolMap) Merge(other *IntBoolMap) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range other.m {
+        gm.m[k] = v
+    }
 }

g/container/gmap/gmap_int_int_map.go

@@ -1,14 +1,14 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
 
 package gmap
 
 import (
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type IntIntMap struct {
@@ -16,6 +16,9 @@ type IntIntMap struct {
 	m  map[int]int
 }
 
+// NewIntIntMap returns an empty IntIntMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntIntMap(unsafe...bool) *IntIntMap {
 	return &IntIntMap{
         m  : make(map[int]int),
@@ -23,201 +26,302 @@ func NewIntIntMap(unsafe...bool) *IntIntMap {
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *IntIntMap) Iterator(f func (k int, v int) bool) {
-    this.mu.RLock()
-    defer this.mu.RUnlock()
-    for k, v := range this.m {
+// NewIntIntMapFrom returns an IntIntMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewIntIntMapFrom(m map[int]int, unsafe...bool) *IntIntMap {
+    return &IntIntMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewIntIntMapFromArray returns an IntIntMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewIntIntMapFromArray(keys []int, values []int, unsafe...bool) *IntIntMap {
+    m := make(map[int]int)
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = 0
+        }
+    }
+    return &IntIntMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *IntIntMap) Iterator(f func (k int, v int) bool) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    for k, v := range gm.m {
         if !f(k, v) {
             break
         }
     }
 }
 
-// 哈希表克隆
-func (this *IntIntMap) Clone() map[int]int {
+// Clone returns a new hash map with copy of current map data.
+func (gm *IntIntMap) Clone() *IntIntMap {
+    return NewIntIntMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *IntIntMap) Map() map[int]int {
 	m := make(map[int]int)
-	this.mu.RLock()
-	for k, v := range this.m {
+	gm.mu.RLock()
+	for k, v := range gm.m {
 		m[k] = v
 	}
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
 	return m
 }
 
-// 设置键值对
-func (this *IntIntMap) Set(key int, val int) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *IntIntMap) Set(key int, val int) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *IntIntMap) BatchSet(m map[int]int) {
-	this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *IntIntMap) BatchSet(m map[int]int) {
+	gm.mu.Lock()
 	for k, v := range m {
-		this.m[k] = v
+		gm.m[k] = v
 	}
-	this.mu.Unlock()
+	gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *IntIntMap) Get(key int) (int) {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *IntIntMap) Get(key int) (int) {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *IntIntMap) doSetWithLockCheck(key int, value int) int {
-    this.mu.Lock()
-    if v, ok := this.m[key]; ok {
-        this.mu.Unlock()
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *IntIntMap) doSetWithLockCheck(key int, value int) int {
+    gm.mu.Lock()
+    if v, ok := gm.m[key]; ok {
+        gm.mu.Unlock()
         return v
     }
-    this.m[key] = value
-    this.mu.Unlock()
+    gm.m[key] = value
+    gm.mu.Unlock()
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *IntIntMap) GetOrSet(key int, value int) int {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *IntIntMap) GetOrSet(key int, value int) int {
+    gm.mu.RLock()
+    v, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        return this.doSetWithLockCheck(key, value)
+        return gm.doSetWithLockCheck(key, value)
     } else {
         return v
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *IntIntMap) GetOrSetFunc(key int, f func() int) int {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+func (gm *IntIntMap) GetOrSetFunc(key int, f func() int) int {
+    gm.mu.RLock()
+    v, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        return this.doSetWithLockCheck(key, f())
+        return gm.doSetWithLockCheck(key, f())
     } else {
         return v
     }
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
-    this.mu.RLock()
-    val, ok := this.m[key]
-    this.mu.RUnlock()
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
+    gm.mu.RLock()
+    val, ok := gm.m[key]
+    gm.mu.RUnlock()
     if !ok {
-        this.mu.Lock()
-        defer this.mu.Unlock()
-        if v, ok := this.m[key]; ok {
-            this.mu.Unlock()
+        gm.mu.Lock()
+        defer gm.mu.Unlock()
+        if v, ok := gm.m[key]; ok {
             return v
         }
         val         = f()
-        this.m[key] = val
+        gm.m[key] = val
         return val
     } else {
         return val
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *IntIntMap) SetIfNotExist(key int, value int) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
+// 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 (gm *IntIntMap) SetIfNotExist(key int, value int) bool {
+    if !gm.Contains(key) {
+        gm.doSetWithLockCheck(key, value)
         return true
     }
     return false
 }
 
-// 批量删除键值对
-func (this *IntIntMap) BatchRemove(keys []int) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntIntMap) SetIfNotExistFunc(key int, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *IntIntMap) Remove(key int) int {
-    this.mu.Lock()
-    val, exists := this.m[key]
-    if exists {
-        delete(this.m, key)
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntIntMap) SetIfNotExistFuncLock(key int, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *IntIntMap) BatchRemove(keys []int) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
     }
-    this.mu.Unlock()
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *IntIntMap) Remove(key int) int {
+    gm.mu.Lock()
+    val, exists := gm.m[key]
+    if exists {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
     return val
 }
 
-// 返回键列表
-func (this *IntIntMap) Keys() []int {
-    this.mu.RLock()
+// Keys returns all keys of the map as a slice.
+func (gm *IntIntMap) Keys() []int {
+    gm.mu.RLock()
     keys := make([]int, 0)
-    for key, _ := range this.m {
+    for key, _ := range gm.m {
         keys = append(keys, key)
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return keys
 }
 
-// 返回值列表(注意是随机排序)
-func (this *IntIntMap) Values() []int {
-    this.mu.RLock()
+// Values returns all values of the map as a slice.
+func (gm *IntIntMap) Values() []int {
+    gm.mu.RLock()
     vals := make([]int, 0)
-    for _, val := range this.m {
+    for _, val := range gm.m {
         vals = append(vals, val)
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return vals
 }
 
-// 是否存在某个键
-func (this *IntIntMap) Contains(key int) bool {
-    this.mu.RLock()
-    _, exists := this.m[key]
-    this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *IntIntMap) Contains(key int) bool {
+    gm.mu.RLock()
+    _, exists := gm.m[key]
+    gm.mu.RUnlock()
     return exists
 }
 
-// 哈希表大小
-func (this *IntIntMap) Size() int {
-    this.mu.RLock()
-    length := len(this.m)
-    this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *IntIntMap) Size() int {
+    gm.mu.RLock()
+    length := len(gm.m)
+    gm.mu.RUnlock()
     return length
 }
 
-// 哈希表是否为空
-func (this *IntIntMap) IsEmpty() bool {
-    this.mu.RLock()
-    empty := len(this.m) == 0
-    this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *IntIntMap) IsEmpty() bool {
+    gm.mu.RLock()
+    empty := len(gm.m) == 0
+    gm.mu.RUnlock()
     return empty
 }
 
-// 清空哈希表
-func (this *IntIntMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[int]int)
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *IntIntMap) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[int]int)
+    gm.mu.Unlock()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *IntIntMap) LockFunc(f func(m map[int]int)) {
-    this.mu.Lock(true)
-    defer this.mu.Unlock(true)
-    f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *IntIntMap) LockFunc(f func(m map[int]int)) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    f(gm.m)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *IntIntMap) RLockFunc(f func(m map[int]int)) {
-    this.mu.RLock(true)
-    defer this.mu.RUnlock(true)
-    f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *IntIntMap) RLockFunc(f func(m map[int]int)) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *IntIntMap) Flip() {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    n := make(map[int]int, len(gm.m))
+    for k, v := range gm.m {
+        n[v] = k
+    }
+    gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntIntMap) Merge(other *IntIntMap) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range other.m {
+        gm.m[k] = v
+    }
 }

g/container/gmap/gmap_int_interface_map.go

@@ -1,19 +1,25 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
-import "gitee.com/johng/gf/g/internal/rwmutex"
+import (
+    "github.com/gogf/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/util/gconv"
+)
 
 type IntInterfaceMap struct {
 	mu *rwmutex.RWMutex
 	m  map[int]interface{}
 }
 
+// NewIntInterfaceMap returns an empty IntInterfaceMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewIntInterfaceMap(unsafe...bool) *IntInterfaceMap {
 	return &IntInterfaceMap{
         m  : make(map[int]interface{}),
@@ -21,186 +27,292 @@ func NewIntInterfaceMap(unsafe...bool) *IntInterfaceMap {
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *IntInterfaceMap) Iterator(f func (k int, v interface{}) bool) {
-    this.mu.RLock()
-    defer this.mu.RUnlock()
-    for k, v := range this.m {
+// NewIntInterfaceMapFrom returns an IntInterfaceMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewIntInterfaceMapFrom(m map[int]interface{}, unsafe...bool) *IntInterfaceMap {
+    return &IntInterfaceMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewFromArray returns a hash map from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewIntInterfaceMapFromArray(keys []int, values []interface{}, unsafe...bool) *IntInterfaceMap {
+    m := make(map[int]interface{})
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = interface{}(nil)
+        }
+    }
+    return &IntInterfaceMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *IntInterfaceMap) Iterator(f func (k int, v interface{}) bool) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    for k, v := range gm.m {
         if !f(k, v) {
             break
         }
     }
 }
 
-// 哈希表克隆
-func (this *IntInterfaceMap) Clone() map[int]interface{} {
+// Clone returns a new hash map with copy of current map data.
+func (gm *IntInterfaceMap) Clone() *IntInterfaceMap {
+    return NewIntInterfaceMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *IntInterfaceMap) Map() map[int]interface{} {
 	m := make(map[int]interface{})
-	this.mu.RLock()
-	for k, v := range this.m {
+	gm.mu.RLock()
+	for k, v := range gm.m {
 		m[k] = v
 	}
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
 	return m
 }
 
-// 设置键值对
-func (this *IntInterfaceMap) Set(key int, val interface{}) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *IntInterfaceMap) Set(key int, val interface{}) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *IntInterfaceMap) BatchSet(m map[int]interface{}) {
-	this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *IntInterfaceMap) BatchSet(m map[int]interface{}) {
+	gm.mu.Lock()
 	for k, v := range m {
-		this.m[k] = v
+		gm.m[k] = v
 	}
-	this.mu.Unlock()
+	gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *IntInterfaceMap) Get(key int) (interface{}) {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *IntInterfaceMap) Get(key int) (interface{}) {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *IntInterfaceMap) doSetWithLockCheck(key int, value interface{}) interface{} {
-    this.mu.Lock()
-    defer this.mu.Unlock()
-    if v, ok := this.m[key]; ok {
+
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
+func (gm *IntInterfaceMap) doSetWithLockCheck(key int, value interface{}) interface{} {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if v, ok := gm.m[key]; ok {
         return v
     }
     if f, ok := value.(func() interface {}); ok {
         value = f()
     }
-    this.m[key] = value
+    if value != nil {
+        gm.m[key] = value
+    }
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *IntInterfaceMap) GetOrSet(key int, value interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, value)
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *IntInterfaceMap) GetOrSet(key int, value interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.doSetWithLockCheck(key, value)
     } else {
         return v
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *IntInterfaceMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, f())
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+func (gm *IntInterfaceMap) GetOrSetFunc(key int, f func() interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.doSetWithLockCheck(key, f())
     } else {
         return v
     }
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *IntInterfaceMap) GetOrSetFuncLock(key int, f func() interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, f)
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *IntInterfaceMap) GetOrSetFuncLock(key int, f func() interface{}) interface{} {
+    if v := gm.Get(key); v == nil {
+        return gm.doSetWithLockCheck(key, f)
     } else {
         return v
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
+// 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 (gm *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
+    if !gm.Contains(key) {
+        gm.doSetWithLockCheck(key, value)
         return true
     }
     return false
 }
 
-// 批量删除键值对
-func (this *IntInterfaceMap) BatchRemove(keys []int) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntInterfaceMap) SetIfNotExistFunc(key int, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *IntInterfaceMap) Remove(key int) interface{} {
-    this.mu.Lock()
-    val, exists := this.m[key]
-    if exists {
-        delete(this.m, key)
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntInterfaceMap) SetIfNotExistFuncLock(key int, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *IntInterfaceMap) BatchRemove(keys []int) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
     }
-    this.mu.Unlock()
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *IntInterfaceMap) Remove(key int) interface{} {
+    gm.mu.Lock()
+    val, exists := gm.m[key]
+    if exists {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
     return val
 }
 
-// 返回键列表
-func (this *IntInterfaceMap) Keys() []int {
-    this.mu.RLock()
+// Keys returns all keys of the map as a slice.
+func (gm *IntInterfaceMap) Keys() []int {
+    gm.mu.RLock()
     keys := make([]int, 0)
-    for key, _ := range this.m {
+    for key, _ := range gm.m {
         keys = append(keys, key)
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return keys
 }
 
-// 返回值列表(注意是随机排序)
-func (this *IntInterfaceMap) Values() []interface{} {
-    this.mu.RLock()
+// Values returns all values of the map as a slice.
+func (gm *IntInterfaceMap) Values() []interface{} {
+    gm.mu.RLock()
     vals := make([]interface{}, 0)
-    for _, val := range this.m {
+    for _, val := range gm.m {
         vals = append(vals, val)
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return vals
 }
 
-// 是否存在某个键
-func (this *IntInterfaceMap) Contains(key int) bool {
-    this.mu.RLock()
-    _, exists := this.m[key]
-    this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *IntInterfaceMap) Contains(key int) bool {
+    gm.mu.RLock()
+    _, exists := gm.m[key]
+    gm.mu.RUnlock()
     return exists
 }
 
-// 哈希表大小
-func (this *IntInterfaceMap) Size() int {
-    this.mu.RLock()
-    length := len(this.m)
-    this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *IntInterfaceMap) Size() int {
+    gm.mu.RLock()
+    length := len(gm.m)
+    gm.mu.RUnlock()
     return length
 }
 
-// 哈希表是否为空
-func (this *IntInterfaceMap) IsEmpty() bool {
-    this.mu.RLock()
-    empty := len(this.m) == 0
-    this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *IntInterfaceMap) IsEmpty() bool {
+    gm.mu.RLock()
+    empty := len(gm.m) == 0
+    gm.mu.RUnlock()
     return empty
 }
 
-// 清空哈希表
-func (this *IntInterfaceMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[int]interface{})
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *IntInterfaceMap) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[int]interface{})
+    gm.mu.Unlock()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *IntInterfaceMap) LockFunc(f func(m map[int]interface{})) {
-    this.mu.Lock()
-    defer this.mu.Unlock()
-    f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *IntInterfaceMap) LockFunc(f func(m map[int]interface{})) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    f(gm.m)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *IntInterfaceMap) RLockFunc(f func(m map[int]interface{})) {
-    this.mu.RLock(true)
-    defer this.mu.RUnlock(true)
-    f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *IntInterfaceMap) RLockFunc(f func(m map[int]interface{})) {
+    gm.mu.RLock()
+    defer gm.mu.RUnlock()
+    f(gm.m)
 }
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *IntInterfaceMap) Flip() {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    n := make(map[int]interface{}, len(gm.m))
+    for k, v := range gm.m {
+        n[gconv.Int(v)] = k
+    }
+    gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntInterfaceMap) Merge(other *IntInterfaceMap) {
+    gm.mu.Lock()
+    defer gm.mu.Unlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
+    }
+    for k, v := range other.m {
+        gm.m[k] = v
+    }
+}

g/container/gmap/gmap_int_string_map.go

@@ -1,14 +1,14 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
-
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
 package gmap
 
 import (
-    "gitee.com/johng/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
 type IntStringMap struct {
@@ -16,208 +16,312 @@ type IntStringMap struct {
 	m  map[int]string
 }
 
-func NewIntStringMap(unsafe...bool) *IntStringMap {
+// NewIntStringMap returns an empty IntStringMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
+func NewIntStringMap(unsafe ...bool) *IntStringMap {
 	return &IntStringMap{
-        m  : make(map[int]string),
-        mu : rwmutex.New(unsafe...),
-    }
+		m:  make(map[int]string),
+		mu: rwmutex.New(unsafe...),
+	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *IntStringMap) Iterator(f func (k int, v string) bool) {
-    this.mu.RLock()
-    defer this.mu.RUnlock()
-    for k, v := range this.m {
-        if !f(k, v) {
-            break
-        }
-    }
+// NewIntStringMapFrom returns an IntStringMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewIntStringMapFrom(m map[int]string, unsafe ...bool) *IntStringMap {
+	return &IntStringMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
 }
 
-// 哈希表克隆
-func (this *IntStringMap) Clone() map[int]string {
+// NewIntStringMapFromArray returns an IntStringMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewIntStringMapFromArray(keys []int, values []string, unsafe ...bool) *IntStringMap {
 	m := make(map[int]string)
-	this.mu.RLock()
-	for k, v := range this.m {
+	l := len(values)
+	for i, k := range keys {
+		if i < l {
+			m[k] = values[i]
+		} else {
+			m[k] = ""
+		}
+	}
+	return &IntStringMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *IntStringMap) Iterator(f func(k int, v string) bool) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	for k, v := range gm.m {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// Clone returns a new hash map with copy of current map data.
+func (gm *IntStringMap) Clone() *IntStringMap {
+	return NewIntStringMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *IntStringMap) Map() map[int]string {
+	m := make(map[int]string)
+	gm.mu.RLock()
+	for k, v := range gm.m {
 		m[k] = v
 	}
-    this.mu.RUnlock()
+	gm.mu.RUnlock()
 	return m
 }
 
-// 设置键值对
-func (this *IntStringMap) Set(key int, val string) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *IntStringMap) Set(key int, val string) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *IntStringMap) BatchSet(m map[int]string) {
-	this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *IntStringMap) BatchSet(m map[int]string) {
+	gm.mu.Lock()
 	for k, v := range m {
-		this.m[k] = v
+		gm.m[k] = v
 	}
-	this.mu.Unlock()
+	gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *IntStringMap) Get(key int) string {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *IntStringMap) Get(key int) string {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *IntStringMap) doSetWithLockCheck(key int, value string) string {
-    this.mu.Lock()
-    if v, ok := this.m[key]; ok {
-        this.mu.Unlock()
-        return v
-    }
-    this.m[key] = value
-    this.mu.Unlock()
-    return value
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *IntStringMap) doSetWithLockCheck(key int, value string) string {
+	gm.mu.Lock()
+	if v, ok := gm.m[key]; ok {
+		gm.mu.Unlock()
+		return v
+	}
+	gm.m[key] = value
+	gm.mu.Unlock()
+	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *IntStringMap) GetOrSet(key int, value string) string {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        return this.doSetWithLockCheck(key, value)
-    } else {
-        return v
-    }
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *IntStringMap) GetOrSet(key int, value string) string {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		return gm.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *IntStringMap) GetOrSetFunc(key int, f func() string) string {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        return this.doSetWithLockCheck(key, f())
-    } 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 (gm *IntStringMap) GetOrSetFunc(key int, f func() string) string {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		return gm.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
-    this.mu.RLock()
-    val, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        this.mu.Lock()
-        defer this.mu.Unlock()
-        if v, ok := this.m[key]; ok {
-            this.mu.Unlock()
-            return v
-        }
-        val         = f()
-        this.m[key] = val
-        return val
-    } else {
-        return val
-    }
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
+	gm.mu.RLock()
+	val, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if v, ok := gm.m[key]; ok {
+			return v
+		}
+		val = f()
+		gm.m[key] = val
+		return val
+	} else {
+		return val
+	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *IntStringMap) SetIfNotExist(key int, value string) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+// 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 (gm *IntStringMap) SetIfNotExist(key int, value string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
-// 批量删除键值对
-func (this *IntStringMap) BatchRemove(keys []int) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *IntStringMap) SetIfNotExistFunc(key int, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *IntStringMap) Remove(key int) string {
-    this.mu.Lock()
-    val, exists := this.m[key]
-    if exists {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
-    return val
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *IntStringMap) SetIfNotExistFuncLock(key int, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
 }
 
-// 返回键列表
-func (this *IntStringMap) Keys() []int {
-    this.mu.RLock()
-    keys := make([]int, 0)
-    for key, _ := range this.m {
-        keys = append(keys, key)
-    }
-    this.mu.RUnlock()
-    return keys
+// BatchRemove batch deletes values of the map by keys.
+func (gm *IntStringMap) BatchRemove(keys []int) {
+	gm.mu.Lock()
+	for _, key := range keys {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
 }
 
-// 返回值列表(注意是随机排序)
-func (this *IntStringMap) Values() []string {
-    this.mu.RLock()
-    vals := make([]string, 0)
-    for _, val := range this.m {
-        vals = append(vals, val)
-    }
-    this.mu.RUnlock()
-    return vals
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *IntStringMap) Remove(key int) string {
+	gm.mu.Lock()
+	val, exists := gm.m[key]
+	if exists {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
+	return val
 }
 
-// 是否存在某个键
-func (this *IntStringMap) Contains(key int) bool {
-    this.mu.RLock()
-    _, exists := this.m[key]
-    this.mu.RUnlock()
-    return exists
+// Keys returns all keys of the map as a slice.
+func (gm *IntStringMap) Keys() []int {
+	gm.mu.RLock()
+	keys := make([]int, 0)
+	for key, _ := range gm.m {
+		keys = append(keys, key)
+	}
+	gm.mu.RUnlock()
+	return keys
 }
 
-// 哈希表大小
-func (this *IntStringMap) Size() int {
-    this.mu.RLock()
-    length := len(this.m)
-    this.mu.RUnlock()
-    return length
+// Values returns all values of the map as a slice.
+func (gm *IntStringMap) Values() []string {
+	gm.mu.RLock()
+	vals := make([]string, 0)
+	for _, val := range gm.m {
+		vals = append(vals, val)
+	}
+	gm.mu.RUnlock()
+	return vals
 }
 
-// 哈希表是否为空
-func (this *IntStringMap) IsEmpty() bool {
-    this.mu.RLock()
-    empty := len(this.m) == 0
-    this.mu.RUnlock()
-    return empty
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *IntStringMap) Contains(key int) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
+	return exists
 }
 
-// 清空哈希表
-func (this *IntStringMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[int]string)
-    this.mu.Unlock()
+// Size returns the size of the map.
+func (gm *IntStringMap) Size() int {
+	gm.mu.RLock()
+	length := len(gm.m)
+	gm.mu.RUnlock()
+	return length
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *IntStringMap) LockFunc(f func(m map[int]string)) {
-    this.mu.Lock(true)
-    defer this.mu.Unlock(true)
-    f(this.m)
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *IntStringMap) IsEmpty() bool {
+	gm.mu.RLock()
+	empty := len(gm.m) == 0
+	gm.mu.RUnlock()
+	return empty
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *IntStringMap) RLockFunc(f func(m map[int]string)) {
-    this.mu.RLock(true)
-    defer this.mu.RUnlock(true)
-    f(this.m)
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *IntStringMap) Clear() {
+	gm.mu.Lock()
+	gm.m = make(map[int]string)
+	gm.mu.Unlock()
+}
+
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *IntStringMap) LockFunc(f func(m map[int]string)) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	f(gm.m)
+}
+
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *IntStringMap) RLockFunc(f func(m map[int]string)) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *IntStringMap) Flip() {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	n := make(map[int]string, len(gm.m))
+	for k, v := range gm.m {
+		n[gconv.Int(v)] = gconv.String(k)
+	}
+	gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *IntStringMap) Merge(other *IntStringMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.m {
+		gm.m[k] = v
+	}
 }

g/container/gmap/gmap_interface_interface_map.go

@@ -1,208 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-//
-
-package gmap
-
-import (
-	"gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type InterfaceInterfaceMap struct {
-	mu *rwmutex.RWMutex
-	m  map[interface{}]interface{}
-}
-
-func NewInterfaceInterfaceMap(unsafe...bool) *InterfaceInterfaceMap {
-	return &InterfaceInterfaceMap{
-		m  : make(map[interface{}]interface{}),
-		mu : rwmutex.New(unsafe...),
-	}
-}
-
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *InterfaceInterfaceMap) Iterator(f func (k interface{}, v interface{}) bool) {
-	this.mu.RLock()
-	defer this.mu.RUnlock()
-	for k, v := range this.m {
-		if !f(k, v) {
-			break
-		}
-	}
-}
-
-// 哈希表克隆
-func (this *InterfaceInterfaceMap) Clone() map[interface{}]interface{} {
-    m := make(map[interface{}]interface{})
-    this.mu.RLock()
-    for k, v := range this.m {
-        m[k] = v
-    }
-    this.mu.RUnlock()
-    return m
-}
-
-// 设置键值对
-func (this *InterfaceInterfaceMap) Set(key interface{}, val interface{}) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
-}
-
-// 批量设置键值对
-func (this *InterfaceInterfaceMap) BatchSet(m map[interface{}]interface{}) {
-    this.mu.Lock()
-    for k, v := range m {
-        this.m[k] = v
-    }
-    this.mu.Unlock()
-}
-
-// 获取键值
-func (this *InterfaceInterfaceMap) Get(key interface{}) interface{} {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
-	return val
-}
-
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *InterfaceInterfaceMap) doSetWithLockCheck(key interface{}, value interface{}) interface{} {
-	this.mu.Lock()
-	defer this.mu.Unlock()
-	if v, ok := this.m[key]; ok {
-		return v
-	}
-	if f, ok := value.(func() interface {}); ok {
-		value = f()
-	}
-	this.m[key] = value
-	return value
-}
-
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *InterfaceInterfaceMap) GetOrSet(key interface{}, value interface{}) interface{} {
-	if v := this.Get(key); v == nil {
-		return this.doSetWithLockCheck(key, value)
-	} else {
-		return v
-	}
-}
-
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *InterfaceInterfaceMap) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
-	if v := this.Get(key); v == nil {
-		return this.doSetWithLockCheck(key, f())
-	} else {
-		return v
-	}
-}
-
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *InterfaceInterfaceMap) GetOrSetFuncLock(key interface{}, f func() interface{}) interface{} {
-	if v := this.Get(key); v == nil {
-		return this.doSetWithLockCheck(key, f)
-	} else {
-		return v
-	}
-}
-
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *InterfaceInterfaceMap) SetIfNotExist(key interface{}, value interface{}) bool {
-	if !this.Contains(key) {
-		this.doSetWithLockCheck(key, value)
-		return true
-	}
-	return false
-}
-
-// 批量删除键值对
-func (this *InterfaceInterfaceMap) BatchRemove(keys []interface{}) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
-}
-
-// 返回对应的键值，并删除该键值
-func (this *InterfaceInterfaceMap) Remove(key interface{}) interface{} {
-	this.mu.Lock()
-	val, exists := this.m[key]
-	if exists {
-		delete(this.m, key)
-	}
-	this.mu.Unlock()
-	return val
-}
-
-// 返回键列表
-func (this *InterfaceInterfaceMap) Keys() []interface{} {
-	this.mu.RLock()
-	keys := make([]interface{}, 0)
-	for key, _ := range this.m {
-		keys = append(keys, key)
-	}
-    this.mu.RUnlock()
-	return keys
-}
-
-// 返回值列表(注意是随机排序)
-func (this *InterfaceInterfaceMap) Values() []interface{} {
-	this.mu.RLock()
-	vals := make([]interface{}, 0)
-	for _, val := range this.m {
-		vals = append(vals, val)
-	}
-	this.mu.RUnlock()
-	return vals
-}
-
-// 是否存在某个键
-func (this *InterfaceInterfaceMap) Contains(key interface{}) bool {
-	this.mu.RLock()
-	_, exists := this.m[key]
-	this.mu.RUnlock()
-	return exists
-}
-
-// 哈希表大小
-func (this *InterfaceInterfaceMap) Size() int {
-	this.mu.RLock()
-	length := len(this.m)
-	this.mu.RUnlock()
-	return length
-}
-
-// 哈希表是否为空
-func (this *InterfaceInterfaceMap) IsEmpty() bool {
-	this.mu.RLock()
-	empty := len(this.m) == 0
-	this.mu.RUnlock()
-	return empty
-}
-
-// 清空哈希表
-func (this *InterfaceInterfaceMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[interface{}]interface{})
-    this.mu.Unlock()
-}
-
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *InterfaceInterfaceMap) LockFunc(f func(m map[interface{}]interface{})) {
-	this.mu.Lock(true)
-	defer this.mu.Unlock(true)
-	f(this.m)
-}
-
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *InterfaceInterfaceMap) RLockFunc(f func(m map[interface{}]interface{})) {
-	this.mu.RLock(true)
-	defer this.mu.RUnlock(true)
-	f(this.m)
-}

g/container/gmap/gmap_string_bool_map.go

@@ -1,14 +1,14 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"gitee.com/johng/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type StringBoolMap struct {
@@ -16,6 +16,9 @@ type StringBoolMap struct {
 	m  map[string]bool
 }
 
+// NewStringBoolMap returns an empty StringBoolMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringBoolMap(unsafe...bool) *StringBoolMap {
 	return &StringBoolMap{
 		m  : make(map[string]bool),
@@ -23,201 +26,283 @@ func NewStringBoolMap(unsafe...bool) *StringBoolMap {
 	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *StringBoolMap) Iterator(f func (k string, v bool) bool) {
-	this.mu.RLock()
-	defer this.mu.RUnlock()
-    for k, v := range this.m {
+// NewStringBoolMapFrom returns an StringBoolMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewStringBoolMapFrom(m map[string]bool, unsafe...bool) *StringBoolMap {
+    return &StringBoolMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewFromArray returns a hash map from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewStringBoolMapFromArray(keys []string, values []bool, unsafe...bool) *StringBoolMap {
+    m := make(map[string]bool)
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = false
+        }
+    }
+    return &StringBoolMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *StringBoolMap) Iterator(f func (k string, v bool) bool) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+    for k, v := range gm.m {
 		if !f(k, v) {
 			break
 		}
     }
 }
 
-// 哈希表克隆
-func (this *StringBoolMap) Clone() map[string]bool {
+// Clone returns a new hash map with copy of current map data.
+func (gm *StringBoolMap) Clone() *StringBoolMap {
+    return NewStringBoolMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *StringBoolMap) Map() map[string]bool {
     m := make(map[string]bool)
-    this.mu.RLock()
-    for k, v := range this.m {
+    gm.mu.RLock()
+    for k, v := range gm.m {
         m[k] = v
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return m
 }
 
-// 设置键值对
-func (this *StringBoolMap) Set(key string, val bool) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *StringBoolMap) Set(key string, val bool) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *StringBoolMap) BatchSet(m map[string]bool) {
-    this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *StringBoolMap) BatchSet(m map[string]bool) {
+    gm.mu.Lock()
     for k, v := range m {
-        this.m[k] = v
+        gm.m[k] = v
     }
-    this.mu.Unlock()
+    gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *StringBoolMap) Get(key string) bool {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *StringBoolMap) Get(key string) bool {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *StringBoolMap) doSetWithLockCheck(key string, value bool) bool {
-	this.mu.Lock()
-	if v, ok := this.m[key]; ok {
-		this.mu.Unlock()
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *StringBoolMap) doSetWithLockCheck(key string, value bool) bool {
+	gm.mu.Lock()
+	if v, ok := gm.m[key]; ok {
+		gm.mu.Unlock()
 		return v
 	}
-	this.m[key] = value
-	this.mu.Unlock()
+	gm.m[key] = value
+	gm.mu.Unlock()
 	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *StringBoolMap) GetOrSet(key string, value bool) bool {
-	this.mu.RLock()
-	v, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *StringBoolMap) GetOrSet(key string, value bool) bool {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		return this.doSetWithLockCheck(key, value)
+		return gm.doSetWithLockCheck(key, value)
 	} else {
 		return v
 	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *StringBoolMap) GetOrSetFunc(key string, f func() bool) bool {
-	this.mu.RLock()
-	v, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+func (gm *StringBoolMap) GetOrSetFunc(key string, f func() bool) bool {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		return this.doSetWithLockCheck(key, f())
+		return gm.doSetWithLockCheck(key, f())
 	} else {
 		return v
 	}
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
-	this.mu.RLock()
-	val, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
+	gm.mu.RLock()
+	val, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		this.mu.Lock()
-		defer this.mu.Unlock()
-		if v, ok := this.m[key]; ok {
-			this.mu.Unlock()
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if v, ok := gm.m[key]; ok {
 			return v
 		}
 		val         = f()
-		this.m[key] = val
+		gm.m[key] = val
 		return val
 	} else {
 		return val
 	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *StringBoolMap) SetIfNotExist(key string, value bool) bool {
-	if !this.Contains(key) {
-		this.doSetWithLockCheck(key, value)
+
+// 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 (gm *StringBoolMap) SetIfNotExist(key string, value bool) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, value)
 		return true
 	}
 	return false
 }
 
-// 批量删除键值对
-func (this *StringBoolMap) BatchRemove(keys []string) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringBoolMap) SetIfNotExistFunc(key string, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *StringBoolMap) Remove(key string) bool {
-	this.mu.Lock()
-	val, exists := this.m[key]
-	if exists {
-		delete(this.m, key)
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringBoolMap) SetIfNotExistFuncLock(key string, f func() bool) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
 	}
-	this.mu.Unlock()
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *StringBoolMap) BatchRemove(keys []string) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *StringBoolMap) Remove(key string) bool {
+	gm.mu.Lock()
+	val, exists := gm.m[key]
+	if exists {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
 	return val
 }
 
-// 返回键列表
-func (this *StringBoolMap) Keys() []string {
-	this.mu.RLock()
+// Keys returns all keys of the map as a slice.
+func (gm *StringBoolMap) Keys() []string {
+	gm.mu.RLock()
 	keys := make([]string, 0)
-	for key, _ := range this.m {
+	for key, _ := range gm.m {
 		keys = append(keys, key)
 	}
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
-//func (this *StringBoolMap) Values() []bool {
-//	this.mu.RLock()
-//	vals := make([]bool, 0)
-//	for _, val := range this.m {
-//		vals = append(vals, val)
-//	}
-//	this.mu.RUnlock()
-//	return vals
-//}
-
-// 是否存在某个键
-func (this *StringBoolMap) Contains(key string) bool {
-	this.mu.RLock()
-	_, exists := this.m[key]
-	this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *StringBoolMap) Contains(key string) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
 	return exists
 }
 
-// 哈希表大小
-func (this *StringBoolMap) Size() int {
-	this.mu.RLock()
-	length := len(this.m)
-	this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *StringBoolMap) Size() int {
+	gm.mu.RLock()
+	length := len(gm.m)
+	gm.mu.RUnlock()
 	return length
 }
 
-// 哈希表是否为空
-func (this *StringBoolMap) IsEmpty() bool {
-	this.mu.RLock()
-	empty := len(this.m) == 0
-	this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *StringBoolMap) IsEmpty() bool {
+	gm.mu.RLock()
+	empty := len(gm.m) == 0
+	gm.mu.RUnlock()
 	return empty
 }
 
-// 清空哈希表
-func (this *StringBoolMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[string]bool)
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *StringBoolMap) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[string]bool)
+    gm.mu.Unlock()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
-func (this *StringBoolMap) LockFunc(f func(m map[string]bool)) {
-	this.mu.Lock(true)
-	defer this.mu.Unlock(true)
-	f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *StringBoolMap) LockFunc(f func(m map[string]bool)) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	f(gm.m)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
-func (this *StringBoolMap) RLockFunc(f func(m map[string]bool)) {
-	this.mu.RLock(true)
-	defer this.mu.RUnlock(true)
-	f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *StringBoolMap) RLockFunc(f func(m map[string]bool)) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
 }
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringBoolMap) Merge(other *StringBoolMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.m {
+		gm.m[k] = v
+	}
+}

g/container/gmap/gmap_string_int_map.go

@@ -1,221 +1,330 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
-import "gitee.com/johng/gf/g/internal/rwmutex"
+import (
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+)
 
 type StringIntMap struct {
 	mu *rwmutex.RWMutex
 	m  map[string]int
 }
 
-func NewStringIntMap(unsafe...bool) *StringIntMap {
+// NewStringIntMap returns an empty StringIntMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
+func NewStringIntMap(unsafe ...bool) *StringIntMap {
 	return &StringIntMap{
-        m  : make(map[string]int),
-        mu : rwmutex.New(unsafe...),
-    }
-}
-
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *StringIntMap) Iterator(f func (k string, v int) bool) {
-    this.mu.RLock()
-    defer this.mu.RUnlock()
-    for k, v := range this.m {
-        if !f(k, v) {
-            break
-        }
-    }
-}
-
-// 哈希表克隆
-func (this *StringIntMap) Clone() map[string]int {
-    m := make(map[string]int)
-    this.mu.RLock()
-    for k, v := range this.m {
-        m[k] = v
-    }
-    this.mu.RUnlock()
-    return m
-}
-
-// 设置键值对
-func (this *StringIntMap) Set(key string, val int) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
-}
-
-// 批量设置键值对
-func (this *StringIntMap) BatchSet(m map[string]int) {
-	this.mu.Lock()
-	for k, v := range m {
-		this.m[k] = v
+		m:  make(map[string]int),
+		mu: rwmutex.New(unsafe...),
 	}
-	this.mu.Unlock()
 }
 
-// 获取键值
-func (this *StringIntMap) Get(key string) int {
-	this.mu.RLock()
-	val, _ := this.m[key]
-    this.mu.RUnlock()
+// NewStringIntMapFrom returns an StringIntMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewStringIntMapFrom(m map[string]int, unsafe ...bool) *StringIntMap {
+	return &StringIntMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
+}
+
+// NewStringIntMapFromArray returns an StringIntMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewStringIntMapFromArray(keys []string, values []int, unsafe ...bool) *StringIntMap {
+	m := make(map[string]int)
+	l := len(values)
+	for i, k := range keys {
+		if i < l {
+			m[k] = values[i]
+		} else {
+			m[k] = 0
+		}
+	}
+	return &StringIntMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *StringIntMap) Iterator(f func(k string, v int) bool) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	for k, v := range gm.m {
+		if !f(k, v) {
+			break
+		}
+	}
+}
+
+// Clone returns a new hash map with copy of current map data.
+func (gm *StringIntMap) Clone() *StringIntMap {
+	return NewStringIntMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *StringIntMap) Map() map[string]int {
+	m := make(map[string]int)
+	gm.mu.RLock()
+	for k, v := range gm.m {
+		m[k] = v
+	}
+	gm.mu.RUnlock()
+	return m
+}
+
+// Set sets key-value to the hash map.
+func (gm *StringIntMap) Set(key string, val int) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
+}
+
+// BatchSet batch sets key-values to the hash map.
+func (gm *StringIntMap) BatchSet(m map[string]int) {
+	gm.mu.Lock()
+	for k, v := range m {
+		gm.m[k] = v
+	}
+	gm.mu.Unlock()
+}
+
+// Get returns the value by given <key>.
+func (gm *StringIntMap) Get(key string) int {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *StringIntMap) doSetWithLockCheck(key string, value int) int {
-    this.mu.Lock()
-    if v, ok := this.m[key]; ok {
-        this.mu.Unlock()
-        return v
-    }
-    this.m[key] = value
-    this.mu.Unlock()
-    return value
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *StringIntMap) doSetWithLockCheck(key string, value int) int {
+	gm.mu.Lock()
+	if v, ok := gm.m[key]; ok {
+		gm.mu.Unlock()
+		return v
+	}
+	gm.m[key] = value
+	gm.mu.Unlock()
+	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *StringIntMap) GetOrSet(key string, value int) int {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        return this.doSetWithLockCheck(key, value)
-    } else {
-        return v
-    }
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *StringIntMap) GetOrSet(key string, value int) int {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		return gm.doSetWithLockCheck(key, value)
+	} else {
+		return v
+	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *StringIntMap) GetOrSetFunc(key string, f func() int) int {
-    this.mu.RLock()
-    v, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        return this.doSetWithLockCheck(key, f())
-    } 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 (gm *StringIntMap) GetOrSetFunc(key string, f func() int) int {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		return gm.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
-    this.mu.RLock()
-    val, ok := this.m[key]
-    this.mu.RUnlock()
-    if !ok {
-        this.mu.Lock()
-        defer this.mu.Unlock()
-        if v, ok := this.m[key]; ok {
-            this.mu.Unlock()
-            return v
-        }
-        val         = f()
-        this.m[key] = val
-        return val
-    } else {
-        return val
-    }
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
+	gm.mu.RLock()
+	val, ok := gm.m[key]
+	gm.mu.RUnlock()
+	if !ok {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if v, ok := gm.m[key]; ok {
+			return v
+		}
+		val = f()
+		gm.m[key] = val
+		return val
+	} else {
+		return val
+	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *StringIntMap) SetIfNotExist(key string, value int) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
+// 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 (gm *StringIntMap) SetIfNotExist(key string, value int) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
 }
 
-// 批量删除键值对
-func (this *StringIntMap) BatchRemove(keys []string) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringIntMap) SetIfNotExistFunc(key string, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *StringIntMap) Remove(key string) int {
-    this.mu.Lock()
-    val, exists := this.m[key]
-    if exists {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
-    return val
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringIntMap) SetIfNotExistFuncLock(key string, f func() int) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
+	}
+	return false
 }
 
-// 返回键列表
-func (this *StringIntMap) Keys() []string {
-    this.mu.RLock()
-    keys := make([]string, 0)
-    for key, _ := range this.m {
-        keys = append(keys, key)
-    }
-    this.mu.RUnlock()
-    return keys
+// BatchRemove batch deletes values of the map by keys.
+func (gm *StringIntMap) BatchRemove(keys []string) {
+	gm.mu.Lock()
+	for _, key := range keys {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
 }
 
-// 返回值列表(注意是随机排序)
-func (this *StringIntMap) Values() []int {
-    this.mu.RLock()
-    vals := make([]int, 0)
-    for _, val := range this.m {
-        vals = append(vals, val)
-    }
-    this.mu.RUnlock()
-    return vals
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *StringIntMap) Remove(key string) int {
+	gm.mu.Lock()
+	val, exists := gm.m[key]
+	if exists {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
+	return val
 }
 
-// 是否存在某个键
-func (this *StringIntMap) Contains(key string) bool {
-    this.mu.RLock()
-    _, exists := this.m[key]
-    this.mu.RUnlock()
-    return exists
+// Keys returns all keys of the map as a slice.
+func (gm *StringIntMap) Keys() []string {
+	gm.mu.RLock()
+	keys := make([]string, 0)
+	for key, _ := range gm.m {
+		keys = append(keys, key)
+	}
+	gm.mu.RUnlock()
+	return keys
 }
 
-// 哈希表大小
-func (this *StringIntMap) Size() int {
-    this.mu.RLock()
-    length := len(this.m)
-    this.mu.RUnlock()
-    return length
+// Values returns all values of the map as a slice.
+func (gm *StringIntMap) Values() []int {
+	gm.mu.RLock()
+	vals := make([]int, 0)
+	for _, val := range gm.m {
+		vals = append(vals, val)
+	}
+	gm.mu.RUnlock()
+	return vals
 }
 
-// 哈希表是否为空
-func (this *StringIntMap) IsEmpty() bool {
-    this.mu.RLock()
-    empty := len(this.m) == 0
-    this.mu.RUnlock()
-    return empty
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *StringIntMap) Contains(key string) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
+	return exists
 }
 
-// 清空哈希表
-func (this *StringIntMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[string]int)
-    this.mu.Unlock()
+// Size returns the size of the map.
+func (gm *StringIntMap) Size() int {
+	gm.mu.RLock()
+	length := len(gm.m)
+	gm.mu.RUnlock()
+	return length
 }
 
-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
-func (this *StringIntMap) LockFunc(f func(m map[string]int)) {
-    this.mu.Lock(true)
-    defer this.mu.Unlock(true)
-    f(this.m)
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *StringIntMap) IsEmpty() bool {
+	gm.mu.RLock()
+	empty := len(gm.m) == 0
+	gm.mu.RUnlock()
+	return empty
 }
 
-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
-func (this *StringIntMap) RLockFunc(f func(m map[string]int)) {
-    this.mu.RLock(true)
-    defer this.mu.RUnlock(true)
-    f(this.m)
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *StringIntMap) Clear() {
+	gm.mu.Lock()
+	gm.m = make(map[string]int)
+	gm.mu.Unlock()
+}
+
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *StringIntMap) LockFunc(f func(m map[string]int)) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	f(gm.m)
+}
+
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *StringIntMap) RLockFunc(f func(m map[string]int)) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *StringIntMap) Flip() {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	n := make(map[string]int, len(gm.m))
+	for k, v := range gm.m {
+		n[gconv.String(v)] = gconv.Int(k)
+	}
+	gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringIntMap) Merge(other *StringIntMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.m {
+		gm.m[k] = v
+	}
 }

g/container/gmap/gmap_string_interface_map.go

@@ -1,14 +1,15 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
 import (
-	"gitee.com/johng/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
 )
 
 type StringInterfaceMap struct {
@@ -16,193 +17,302 @@ type StringInterfaceMap struct {
 	m  map[string]interface{}
 }
 
-func NewStringInterfaceMap(unsafe...bool) *StringInterfaceMap {
+// NewStringInterfaceMap returns an empty StringInterfaceMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
+func NewStringInterfaceMap(unsafe ...bool) *StringInterfaceMap {
 	return &StringInterfaceMap{
-		m  : make(map[string]interface{}),
-		mu : rwmutex.New(unsafe...),
+		m:  make(map[string]interface{}),
+		mu: rwmutex.New(unsafe...),
 	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *StringInterfaceMap) Iterator(f func (k string, v interface{}) bool) {
-	this.mu.RLock()
-	defer this.mu.RUnlock()
-	for k, v := range this.m {
+// NewStringInterfaceMapFrom returns an StringInterfaceMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewStringInterfaceMapFrom(m map[string]interface{}, unsafe ...bool) *StringInterfaceMap {
+	return &StringInterfaceMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
+}
+
+// NewStringInterfaceMapFromArray returns an StringInterfaceMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewStringInterfaceMapFromArray(keys []string, values []interface{}, unsafe ...bool) *StringInterfaceMap {
+	m := make(map[string]interface{})
+	l := len(values)
+	for i, k := range keys {
+		if i < l {
+			m[k] = values[i]
+		} else {
+			m[k] = interface{}(nil)
+		}
+	}
+	return &StringInterfaceMap{
+		m:  m,
+		mu: rwmutex.New(unsafe...),
+	}
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *StringInterfaceMap) Iterator(f func(k string, v interface{}) bool) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	for k, v := range gm.m {
 		if !f(k, v) {
 			break
 		}
 	}
 }
 
-// 哈希表克隆
-func (this *StringInterfaceMap) Clone() map[string]interface{} {
-    m := make(map[string]interface{})
-    this.mu.RLock()
-    for k, v := range this.m {
-        m[k] = v
-    }
-    this.mu.RUnlock()
-    return m
+// Clone returns a new hash map with copy of current map data.
+func (gm *StringInterfaceMap) Clone() *StringInterfaceMap {
+	return NewStringInterfaceMapFrom(gm.Map(), !gm.mu.IsSafe())
 }
 
-// 设置键值对
-func (this *StringInterfaceMap) Set(key string, val interface{}) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
-}
-
-// 批量设置键值对
-func (this *StringInterfaceMap) BatchSet(m map[string]interface{}) {
-    this.mu.Lock()
-    for k, v := range m {
-        this.m[k] = v
-    }
-    this.mu.Unlock()
-}
-
-// 获取键值
-func (this *StringInterfaceMap) Get(key string) interface{} {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
-	return val
-}
-
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *StringInterfaceMap) doSetWithLockCheck(key string, value interface{}) interface{} {
-	this.mu.Lock()
-	defer this.mu.Unlock()
-    if v, ok := this.m[key]; ok {
-        return v
-    }
-    if f, ok := value.(func() interface {}); ok {
-        value = f()
-    }
-    this.m[key] = value
-    return value
-}
-
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *StringInterfaceMap) GetOrSet(key string, value interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, value)
-    } else {
-        return v
-    }
-}
-
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *StringInterfaceMap) GetOrSetFunc(key string, f func() interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, f())
-    } else {
-        return v
-    }
-}
-
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{}) interface{} {
-    if v := this.Get(key); v == nil {
-        return this.doSetWithLockCheck(key, f)
-    } else {
-        return v
-    }
-}
-
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool {
-    if !this.Contains(key) {
-        this.doSetWithLockCheck(key, value)
-        return true
-    }
-    return false
-}
-
-// 批量删除键值对
-func (this *StringInterfaceMap) BatchRemove(keys []string) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
-}
-
-// 返回对应的键值，并删除该键值
-func (this *StringInterfaceMap) Remove(key string) interface{} {
-	this.mu.Lock()
-	val, exists := this.m[key]
-	if exists {
-		delete(this.m, key)
+// Map returns a copy of the data of the hash map.
+func (gm *StringInterfaceMap) Map() map[string]interface{} {
+	m := make(map[string]interface{})
+	gm.mu.RLock()
+	for k, v := range gm.m {
+		m[k] = v
 	}
-	this.mu.Unlock()
+	gm.mu.RUnlock()
+	return m
+}
+
+// Set sets key-value to the hash map.
+func (gm *StringInterfaceMap) Set(key string, val interface{}) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
+}
+
+// BatchSet batch sets key-values to the hash map.
+func (gm *StringInterfaceMap) BatchSet(m map[string]interface{}) {
+	gm.mu.Lock()
+	for k, v := range m {
+		gm.m[k] = v
+	}
+	gm.mu.Unlock()
+}
+
+// Get returns the value by given <key>.
+func (gm *StringInterfaceMap) Get(key string) interface{} {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 返回键列表
-func (this *StringInterfaceMap) Keys() []string {
-	this.mu.RLock()
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// When setting value, if <value> is type of <func() interface {}>,
+// it will be executed with mutex.Lock of the hash map,
+// and its return value will be set to the map with <key>.
+//
+// It returns value with given <key>.
+func (gm *StringInterfaceMap) doSetWithLockCheck(key string, value interface{}) interface{} {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if v, ok := gm.m[key]; ok {
+		return v
+	}
+	if f, ok := value.(func() interface{}); ok {
+		value = f()
+	}
+	if value != nil {
+		gm.m[key] = value
+	}
+	return value
+}
+
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *StringInterfaceMap) GetOrSet(key string, value interface{}) interface{} {
+	if v := gm.Get(key); v == nil {
+		return gm.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 (gm *StringInterfaceMap) GetOrSetFunc(key string, f func() interface{}) interface{} {
+	if v := gm.Get(key); v == nil {
+		return gm.doSetWithLockCheck(key, f())
+	} else {
+		return v
+	}
+}
+
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{}) interface{} {
+	if v := gm.Get(key); v == nil {
+		return gm.doSetWithLockCheck(key, f)
+	} 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 (gm *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, value)
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringInterfaceMap) SetIfNotExistFunc(key string, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
+}
+
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringInterfaceMap) SetIfNotExistFuncLock(key string, f func() interface{}) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f)
+		return true
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *StringInterfaceMap) BatchRemove(keys []string) {
+	gm.mu.Lock()
+	for _, key := range keys {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *StringInterfaceMap) Remove(key string) interface{} {
+	gm.mu.Lock()
+	val, exists := gm.m[key]
+	if exists {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
+	return val
+}
+
+// Keys returns all keys of the map as a slice.
+func (gm *StringInterfaceMap) Keys() []string {
+	gm.mu.RLock()
 	keys := make([]string, 0)
-	for key, _ := range this.m {
+	for key, _ := range gm.m {
 		keys = append(keys, key)
 	}
-    this.mu.RUnlock()
+	gm.mu.RUnlock()
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
-func (this *StringInterfaceMap) Values() []interface{} {
-	this.mu.RLock()
+// Values returns all values of the map as a slice.
+func (gm *StringInterfaceMap) Values() []interface{} {
+	gm.mu.RLock()
 	vals := make([]interface{}, 0)
-	for _, val := range this.m {
+	for _, val := range gm.m {
 		vals = append(vals, val)
 	}
-	this.mu.RUnlock()
+	gm.mu.RUnlock()
 	return vals
 }
 
-// 是否存在某个键
-func (this *StringInterfaceMap) Contains(key string) bool {
-	this.mu.RLock()
-	_, exists := this.m[key]
-	this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *StringInterfaceMap) Contains(key string) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
 	return exists
 }
 
-// 哈希表大小
-func (this *StringInterfaceMap) Size() int {
-	this.mu.RLock()
-	length := len(this.m)
-	this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *StringInterfaceMap) Size() int {
+	gm.mu.RLock()
+	length := len(gm.m)
+	gm.mu.RUnlock()
 	return length
 }
 
-// 哈希表是否为空
-func (this *StringInterfaceMap) IsEmpty() bool {
-	this.mu.RLock()
-	empty := len(this.m) == 0
-	this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *StringInterfaceMap) IsEmpty() bool {
+	gm.mu.RLock()
+	empty := len(gm.m) == 0
+	gm.mu.RUnlock()
 	return empty
 }
 
-// 清空哈希表
-func (this *StringInterfaceMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[string]interface{})
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *StringInterfaceMap) Clear() {
+	gm.mu.Lock()
+	gm.m = make(map[string]interface{})
+	gm.mu.Unlock()
 }
 
-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
-func (this *StringInterfaceMap) LockFunc(f func(m map[string]interface{})) {
-	this.mu.Lock(true)
-	defer this.mu.Unlock(true)
-	f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *StringInterfaceMap) LockFunc(f func(m map[string]interface{})) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	f(gm.m)
 }
 
-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
-func (this *StringInterfaceMap) RLockFunc(f func(m map[string]interface{})) {
-	this.mu.RLock(true)
-	defer this.mu.RUnlock(true)
-	f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *StringInterfaceMap) RLockFunc(f func(m map[string]interface{})) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *StringInterfaceMap) Flip() {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	n := make(map[string]interface{}, len(gm.m))
+	for k, v := range gm.m {
+		n[gconv.String(v)] = k
+	}
+	gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringInterfaceMap) Merge(other *StringInterfaceMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.m {
+		gm.m[k] = v
+	}
 }

g/container/gmap/gmap_string_string_map.go

@@ -1,19 +1,24 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gmap
 
-import "gitee.com/johng/gf/g/internal/rwmutex"
+import (
+    "github.com/gogf/gf/g/internal/rwmutex"
+)
 
 type StringStringMap struct {
 	mu *rwmutex.RWMutex
 	m  map[string]string
 }
 
+// NewStringStringMap returns an empty StringStringMap object.
+// The param <unsafe> used to specify whether using map with un-concurrent-safety,
+// which is false in default, means concurrent-safe.
 func NewStringStringMap(unsafe...bool) *StringStringMap {
 	return &StringStringMap{
 		m  : make(map[string]string),
@@ -21,201 +26,304 @@ func NewStringStringMap(unsafe...bool) *StringStringMap {
 	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (this *StringStringMap) Iterator(f func (k string, v string) bool) {
-	this.mu.RLock()
-	defer this.mu.RUnlock()
-	for k, v := range this.m {
+// NewStringStringMapFrom returns an StringStringMap object from given map <m>.
+// Notice that, the param map is a type of pointer,
+// there might be some concurrent-safe issues when changing the map outside.
+func NewStringStringMapFrom(m map[string]string, unsafe...bool) *StringStringMap {
+    return &StringStringMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// NewStringStringMapFromArray returns an StringStringMap object from given array.
+// The param <keys> given as the keys of the map,
+// and <values> as its corresponding values.
+//
+// If length of <keys> is greater than that of <values>,
+// the corresponding overflow map values will be the default value of its type.
+func NewStringStringMapFromArray(keys []string, values []string, unsafe...bool) *StringStringMap {
+    m := make(map[string]string)
+    l := len(values)
+    for i, k := range keys {
+        if i < l {
+            m[k] = values[i]
+        } else {
+            m[k] = ""
+        }
+    }
+    return &StringStringMap{
+        m  : m,
+        mu : rwmutex.New(unsafe...),
+    }
+}
+
+// Iterator iterates the hash map with custom callback function <f>.
+// If f returns true, then continue iterating; or false to stop.
+func (gm *StringStringMap) Iterator(f func (k string, v string) bool) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	for k, v := range gm.m {
 		if !f(k, v) {
 			break
 		}
 	}
 }
 
-// 哈希表克隆
-func (this *StringStringMap) Clone() map[string]string {
+// Clone returns a new hash map with copy of current map data.
+func (gm *StringStringMap) Clone() *StringStringMap {
+    return NewStringStringMapFrom(gm.Map(), !gm.mu.IsSafe())
+}
+
+// Map returns a copy of the data of the hash map.
+func (gm *StringStringMap) Map() map[string]string {
     m := make(map[string]string)
-    this.mu.RLock()
-    for k, v := range this.m {
+    gm.mu.RLock()
+    for k, v := range gm.m {
         m[k] = v
     }
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
     return m
 }
 
-// 设置键值对
-func (this *StringStringMap) Set(key string, val string) {
-	this.mu.Lock()
-	this.m[key] = val
-	this.mu.Unlock()
+// Set sets key-value to the hash map.
+func (gm *StringStringMap) Set(key string, val string) {
+	gm.mu.Lock()
+	gm.m[key] = val
+	gm.mu.Unlock()
 }
 
-// 批量设置键值对
-func (this *StringStringMap) BatchSet(m map[string]string) {
-    this.mu.Lock()
+// BatchSet batch sets key-values to the hash map.
+func (gm *StringStringMap) BatchSet(m map[string]string) {
+    gm.mu.Lock()
     for k, v := range m {
-        this.m[k] = v
+        gm.m[k] = v
     }
-    this.mu.Unlock()
+    gm.mu.Unlock()
 }
 
-// 获取键值
-func (this *StringStringMap) Get(key string) string {
-	this.mu.RLock()
-	val, _ := this.m[key]
-	this.mu.RUnlock()
+// Get returns the value by given <key>.
+func (gm *StringStringMap) Get(key string) string {
+	gm.mu.RLock()
+	val, _ := gm.m[key]
+	gm.mu.RUnlock()
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
-func (this *StringStringMap) doSetWithLockCheck(key string, value string) string {
-	this.mu.Lock()
-	if v, ok := this.m[key]; ok {
-		this.mu.Unlock()
+// doSetWithLockCheck checks whether value of the key exists with mutex.Lock,
+// if not exists, set value to the map with given <key>,
+// or else just return the existing value.
+//
+// It returns value with given <key>.
+func (gm *StringStringMap) doSetWithLockCheck(key string, value string) string {
+	gm.mu.Lock()
+	if v, ok := gm.m[key]; ok {
+		gm.mu.Unlock()
 		return v
 	}
-	this.m[key] = value
-	this.mu.Unlock()
+	gm.m[key] = value
+	gm.mu.Unlock()
 	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
-func (this *StringStringMap) GetOrSet(key string, value string) string {
-	this.mu.RLock()
-	v, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSet returns the value by key,
+// or set value with given <value> if not exist and returns this value.
+func (gm *StringStringMap) GetOrSet(key string, value string) string {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		return this.doSetWithLockCheck(key, value)
+		return gm.doSetWithLockCheck(key, value)
 	} else {
 		return v
 	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
-func (this *StringStringMap) GetOrSetFunc(key string, f func() string) string {
-	this.mu.RLock()
-	v, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSetFunc returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+func (gm *StringStringMap) GetOrSetFunc(key string, f func() string) string {
+	gm.mu.RLock()
+	v, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		return this.doSetWithLockCheck(key, f())
+		return gm.doSetWithLockCheck(key, f())
 	} else {
 		return v
 	}
 }
 
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
-func (this *StringStringMap) GetOrSetFuncLock(key string, f func() string) string {
-	this.mu.RLock()
-	val, ok := this.m[key]
-	this.mu.RUnlock()
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
+//
+// GetOrSetFuncLock differs with GetOrSetFunc function is that it executes function <f>
+// with mutex.Lock of the hash map.
+func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string {
+	gm.mu.RLock()
+	val, ok := gm.m[key]
+	gm.mu.RUnlock()
 	if !ok {
-		this.mu.Lock()
-		defer this.mu.Unlock()
-		if v, ok := this.m[key]; ok {
-			this.mu.Unlock()
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if v, ok := gm.m[key]; ok {
 			return v
 		}
-		val         = f()
-		this.m[key] = val
+		val       = f()
+		gm.m[key] = val
 		return val
 	} else {
 		return val
 	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回false。
-func (this *StringStringMap) SetIfNotExist(key string, value string) bool {
-	if !this.Contains(key) {
-		this.doSetWithLockCheck(key, value)
+// 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 (gm *StringStringMap) SetIfNotExist(key string, value string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, value)
 		return true
 	}
 	return false
 }
 
-// 批量删除键值对
-func (this *StringStringMap) BatchRemove(keys []string) {
-    this.mu.Lock()
-    for _, key := range keys {
-        delete(this.m, key)
-    }
-    this.mu.Unlock()
+// SetIfNotExistFunc sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+func (gm *StringStringMap) SetIfNotExistFunc(key string, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.doSetWithLockCheck(key, f())
+		return true
+	}
+	return false
 }
 
-// 返回对应的键值，并删除该键值
-func (this *StringStringMap) Remove(key string) string {
-	this.mu.Lock()
-	val, exists := this.m[key]
-	if exists {
-		delete(this.m, key)
+// SetIfNotExistFuncLock sets value with return value of callback function <f>, then return true.
+// It returns false if <key> exists, and <value> would be ignored.
+//
+// SetIfNotExistFuncLock differs with SetIfNotExistFunc function is that
+// it executes function <f> with mutex.Lock of the hash map.
+func (gm *StringStringMap) SetIfNotExistFuncLock(key string, f func() string) bool {
+	if !gm.Contains(key) {
+		gm.mu.Lock()
+		defer gm.mu.Unlock()
+		if _, ok := gm.m[key]; !ok {
+			gm.m[key] = f()
+		}
+		return true
 	}
-	this.mu.Unlock()
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
+func (gm *StringStringMap) BatchRemove(keys []string) {
+    gm.mu.Lock()
+    for _, key := range keys {
+        delete(gm.m, key)
+    }
+    gm.mu.Unlock()
+}
+
+// Remove deletes value from map by given <key>, and return this deleted value.
+func (gm *StringStringMap) Remove(key string) string {
+	gm.mu.Lock()
+	val, exists := gm.m[key]
+	if exists {
+		delete(gm.m, key)
+	}
+	gm.mu.Unlock()
 	return val
 }
 
-// 返回键列表
-func (this *StringStringMap) Keys() []string {
-	this.mu.RLock()
+// Keys returns all keys of the map as a slice.
+func (gm *StringStringMap) Keys() []string {
+	gm.mu.RLock()
 	keys := make([]string, 0)
-	for key, _ := range this.m {
+	for key, _ := range gm.m {
 		keys = append(keys, key)
 	}
-    this.mu.RUnlock()
+    gm.mu.RUnlock()
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
-func (this *StringStringMap) Values() []string {
-	this.mu.RLock()
+// Values returns all values of the map as a slice.
+func (gm *StringStringMap) Values() []string {
+	gm.mu.RLock()
 	vals := make([]string, 0)
-	for _, val := range this.m {
+	for _, val := range gm.m {
 		vals = append(vals, val)
 	}
-	this.mu.RUnlock()
+	gm.mu.RUnlock()
 	return vals
 }
 
-// 是否存在某个键
-func (this *StringStringMap) Contains(key string) bool {
-	this.mu.RLock()
-	_, exists := this.m[key]
-	this.mu.RUnlock()
+// Contains checks whether a key exists.
+// It returns true if the <key> exists, or else false.
+func (gm *StringStringMap) Contains(key string) bool {
+	gm.mu.RLock()
+	_, exists := gm.m[key]
+	gm.mu.RUnlock()
 	return exists
 }
 
-// 哈希表大小
-func (this *StringStringMap) Size() int {
-	this.mu.RLock()
-	length := len(this.m)
-	this.mu.RUnlock()
+// Size returns the size of the map.
+func (gm *StringStringMap) Size() int {
+	gm.mu.RLock()
+	length := len(gm.m)
+	gm.mu.RUnlock()
 	return length
 }
 
-// 哈希表是否为空
-func (this *StringStringMap) IsEmpty() bool {
-	this.mu.RLock()
-	empty := len(this.m) == 0
-	this.mu.RUnlock()
+// IsEmpty checks whether the map is empty.
+// It returns true if map is empty, or else false.
+func (gm *StringStringMap) IsEmpty() bool {
+	gm.mu.RLock()
+	empty := len(gm.m) == 0
+	gm.mu.RUnlock()
 	return empty
 }
 
-// 清空哈希表
-func (this *StringStringMap) Clear() {
-    this.mu.Lock()
-    this.m = make(map[string]string)
-    this.mu.Unlock()
+// Clear deletes all data of the map, it will remake a new underlying map data map.
+func (gm *StringStringMap) Clear() {
+    gm.mu.Lock()
+    gm.m = make(map[string]string)
+    gm.mu.Unlock()
 }
 
-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
-func (this *StringStringMap) LockFunc(f func(m map[string]string)) {
-	this.mu.Lock(true)
-	defer this.mu.Unlock(true)
-	f(this.m)
+// LockFunc locks writing with given callback function <f> and mutex.Lock.
+func (gm *StringStringMap) LockFunc(f func(m map[string]string)) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	f(gm.m)
 }
 
-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
-func (this *StringStringMap) RLockFunc(f func(m map[string]string)) {
-	this.mu.RLock(true)
-	defer this.mu.RUnlock(true)
-	f(this.m)
+// RLockFunc locks reading with given callback function <f> and mutex.RLock.
+func (gm *StringStringMap) RLockFunc(f func(m map[string]string)) {
+	gm.mu.RLock()
+	defer gm.mu.RUnlock()
+	f(gm.m)
+}
+
+// Flip exchanges key-value of the map, it will change key-value to value-key.
+func (gm *StringStringMap) Flip() {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	n := make(map[string]string, len(gm.m))
+	for k, v := range gm.m {
+		n[v] = k
+	}
+	gm.m = n
+}
+
+// Merge merges two hash maps.
+// The <other> map will be merged into the map <gm>.
+func (gm *StringStringMap) Merge(other *StringStringMap) {
+	gm.mu.Lock()
+	defer gm.mu.Unlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
+	}
+	for k, v := range other.m {
+		gm.m[k] = v
+	}
 }

g/container/gmap/gmap_z_bench_safe_test.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
@@ -18,7 +18,7 @@ var ibm   = NewIntBoolMap()
 var iim   = NewIntIntMap()
 var iifm  = NewIntInterfaceMap()
 var ism   = NewIntStringMap()
-var ififm = NewInterfaceInterfaceMap()
+var ififm = NewMap()
 var sbm   = NewStringBoolMap()
 var sim   = NewStringIntMap()
 var sifm  = NewStringInterfaceMap()

g/container/gmap/gmap_z_bench_syncmap_test.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
@@ -10,7 +10,7 @@ package gmap_test
 
 import (
     "testing"
-    "gitee.com/johng/gf/g/container/gmap"
+    "github.com/gogf/gf/g/container/gmap"
     "sync"
 )
 

g/container/gmap/gmap_z_bench_unsafe_test.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
@@ -14,15 +14,15 @@ import (
 )
 
 
-var ibmUnsafe   = NewIntBoolMap(false)
-var iimUnsafe   = NewIntIntMap(false)
-var iifmUnsafe  = NewIntInterfaceMap(false)
-var ismUnsafe   = NewIntStringMap(false)
-var ififmUnsafe = NewInterfaceInterfaceMap(false)
-var sbmUnsafe   = NewStringBoolMap(false)
-var simUnsafe   = NewStringIntMap(false)
-var sifmUnsafe  = NewStringInterfaceMap(false)
-var ssmUnsafe   = NewStringStringMap(false)
+var ibmUnsafe   = NewIntBoolMap(true)
+var iimUnsafe   = NewIntIntMap(true)
+var iifmUnsafe  = NewIntInterfaceMap(true)
+var ismUnsafe   = NewIntStringMap(true)
+var ififmUnsafe = NewMap(true)
+var sbmUnsafe   = NewStringBoolMap(true)
+var simUnsafe   = NewStringIntMap(true)
+var sifmUnsafe  = NewStringInterfaceMap(true)
+var ssmUnsafe   = NewStringStringMap(true)
 
 // 写入性能测试
 

g/container/gmap/gmap_z_int_bool_test.go

@@ -0,0 +1,123 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func getBool() bool {
+	return true
+}
+func intBoolCallBack(int, bool) bool {
+	return true
+}
+func Test_IntBoolMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewIntBoolMap()
+		m.Set(1, true)
+
+		gtest.Assert(m.Get(1), true)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet(2, false), false)
+		gtest.Assert(m.SetIfNotExist(2, false), false)
+
+		gtest.Assert(m.SetIfNotExist(3, false), true)
+
+		gtest.Assert(m.Remove(2), false)
+		gtest.Assert(m.Contains(2), false)
+
+		gtest.AssertIN(3, m.Keys())
+		gtest.AssertIN(1, m.Keys())
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewIntBoolMapFrom(map[int]bool{1: true, 2: false})
+		gtest.Assert(m2.Map(), map[int]bool{1: true, 2: false})
+		m3 := gmap.NewIntBoolMapFromArray([]int{1, 2}, []bool{true, false})
+		gtest.Assert(m3.Map(), map[int]bool{1: true, 2: false})
+
+	})
+}
+func Test_IntBoolMap_Set_Fun(t *testing.T) {
+	m := gmap.NewIntBoolMap()
+
+	m.GetOrSetFunc(1, getBool)
+	m.GetOrSetFuncLock(2, getBool)
+	gtest.Assert(m.Get(1), true)
+	gtest.Assert(m.Get(2), true)
+	gtest.Assert(m.SetIfNotExistFunc(1, getBool), false)
+	gtest.Assert(m.SetIfNotExistFunc(4, getBool), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock(2, getBool), false)
+	gtest.Assert(m.SetIfNotExistFuncLock(3, getBool), true)
+
+}
+
+func Test_IntBoolMap_Batch(t *testing.T) {
+	m := gmap.NewIntBoolMap()
+
+	m.BatchSet(map[int]bool{1: true, 2: false, 3: true})
+	gtest.Assert(m.Map(), map[int]bool{1: true, 2: false, 3: true})
+	m.BatchRemove([]int{1, 2})
+	gtest.Assert(m.Map(), map[int]bool{3: true})
+}
+func Test_IntBoolMap_Iterator(t *testing.T){
+	expect := map[int]bool{1: true, 2: false}
+	m      := gmap.NewIntBoolMapFrom(expect)
+	m.Iterator(func(k int, v bool) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k int, v bool) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k int, v bool) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+}
+
+func Test_IntBoolMap_Lock(t *testing.T){
+	expect := map[int]bool{1: true, 2: false}
+	m      := gmap.NewIntBoolMapFrom(expect)
+	m.LockFunc(func(m map[int]bool) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[int]bool) {
+		gtest.Assert(m, expect)
+	})
+
+}
+
+func Test_IntBoolMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewIntBoolMapFrom(map[int]bool{1: true, 2: false})
+
+	m_clone := m.Clone()
+	m.Remove(1)
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN(1, m_clone.Keys())
+
+	m_clone.Remove(2)
+	//修改clone map,原 map 不影响
+	gtest.AssertIN(2, m.Keys())
+}
+func Test_IntBoolMap_Merge(t *testing.T) {
+	m1 := gmap.NewIntBoolMap()
+	m2 := gmap.NewIntBoolMap()
+	m1.Set(1, true)
+	m2.Set(2, false)
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[int]bool{1: true, 2: false})
+}

g/container/gmap/gmap_z_int_int_test.go

@@ -0,0 +1,128 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func getInt() int {
+	return 123
+}
+func intIntCallBack(int, int) bool {
+	return true
+}
+func Test_IntIntMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewIntIntMap()
+		m.Set(1, 1)
+
+		gtest.Assert(m.Get(1), 1)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet(2, 2), 2)
+		gtest.Assert(m.SetIfNotExist(2, 2), false)
+
+		gtest.Assert(m.SetIfNotExist(3, 3), true)
+
+		gtest.Assert(m.Remove(2), 2)
+		gtest.Assert(m.Contains(2), false)
+
+		gtest.AssertIN(3, m.Keys())
+		gtest.AssertIN(1, m.Keys())
+		gtest.AssertIN(3, m.Values())
+		gtest.AssertIN(1, m.Values())
+		m.Flip()
+		gtest.Assert(m.Map(), map[int]int{1: 1, 3: 3})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
+		gtest.Assert(m2.Map(), map[int]int{1: 1, 2: 2})
+		m3 := gmap.NewIntIntMapFromArray([]int{1, 2}, []int{1, 2})
+		gtest.Assert(m3.Map(), map[int]int{1: 1, 2: 2})
+
+	})
+}
+func Test_IntIntMap_Set_Fun(t *testing.T) {
+	m := gmap.NewIntIntMap()
+
+	m.GetOrSetFunc(1, getInt)
+	m.GetOrSetFuncLock(2, getInt)
+	gtest.Assert(m.Get(1), 123)
+	gtest.Assert(m.Get(2), 123)
+	gtest.Assert(m.SetIfNotExistFunc(1, getInt), false)
+	gtest.Assert(m.SetIfNotExistFunc(3, getInt), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock(2, getInt), false)
+	gtest.Assert(m.SetIfNotExistFuncLock(4, getInt), true)
+
+}
+
+func Test_IntIntMap_Batch(t *testing.T) {
+	m := gmap.NewIntIntMap()
+
+	m.BatchSet(map[int]int{1: 1, 2: 2, 3: 3})
+	m.Iterator(intIntCallBack)
+	gtest.Assert(m.Map(), map[int]int{1: 1, 2: 2, 3: 3})
+	m.BatchRemove([]int{1, 2})
+	gtest.Assert(m.Map(), map[int]int{3: 3})
+}
+
+func Test_IntIntMap_Iterator(t *testing.T){
+	expect := map[int]int{1: 1, 2: 2}
+	m      := gmap.NewIntIntMapFrom(expect)
+	m.Iterator(func(k int, v int) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k int, v int) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k int, v int) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+}
+
+func Test_IntIntMap_Lock(t *testing.T){
+	expect := map[int]int{1: 1, 2: 2}
+	m      := gmap.NewIntIntMapFrom(expect)
+	m.LockFunc(func(m map[int]int) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[int]int) {
+		gtest.Assert(m, expect)
+	})
+
+}
+func Test_IntIntMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
+
+	m_clone := m.Clone()
+	m.Remove(1)
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN(1, m_clone.Keys())
+
+	m_clone.Remove(2)
+	//修改clone map,原 map 不影响
+	gtest.AssertIN(2, m.Keys())
+}
+func Test_IntIntMap_Merge(t *testing.T) {
+	m1 := gmap.NewIntIntMap()
+	m2 := gmap.NewIntIntMap()
+	m1.Set(1, 1)
+	m2.Set(2, 2)
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[int]int{1: 1, 2: 2})
+}

g/container/gmap/gmap_z_int_interface_test.go

@@ -0,0 +1,128 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func getInterface() interface{} {
+	return 123
+}
+func intInterfaceCallBack(int, interface{}) bool {
+	return true
+}
+func Test_IntInterfaceMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewIntInterfaceMap()
+		m.Set(1, 1)
+
+		gtest.Assert(m.Get(1), 1)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet(2, "2"), "2")
+		gtest.Assert(m.SetIfNotExist(2, "2"), false)
+
+		gtest.Assert(m.SetIfNotExist(3, 3), true)
+
+		gtest.Assert(m.Remove(2), "2")
+		gtest.Assert(m.Contains(2), false)
+
+		gtest.AssertIN(3, m.Keys())
+		gtest.AssertIN(1, m.Keys())
+		gtest.AssertIN(3, m.Values())
+		gtest.AssertIN(1, m.Values())
+		m.Flip()
+		gtest.Assert(m.Map(), map[interface{}]int{1: 1, 3: 3})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewIntInterfaceMapFrom(map[int]interface{}{1: 1, 2: "2"})
+		gtest.Assert(m2.Map(), map[int]interface{}{1: 1, 2: "2"})
+		m3 := gmap.NewIntInterfaceMapFromArray([]int{1, 2}, []interface{}{1, "2"})
+		gtest.Assert(m3.Map(), map[int]interface{}{1: 1, 2: "2"})
+
+	})
+}
+func Test_IntInterfaceMap_Set_Fun(t *testing.T) {
+	m := gmap.NewIntInterfaceMap()
+
+	m.GetOrSetFunc(1, getInterface)
+	m.GetOrSetFuncLock(2, getInterface)
+	gtest.Assert(m.Get(1), 123)
+	gtest.Assert(m.Get(2), 123)
+
+	gtest.Assert(m.SetIfNotExistFunc(1, getInterface), false)
+	gtest.Assert(m.SetIfNotExistFunc(3, getInterface), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock(2, getInterface), false)
+	gtest.Assert(m.SetIfNotExistFuncLock(4, getInterface), true)
+
+}
+
+func Test_IntInterfaceMap_Batch(t *testing.T) {
+	m := gmap.NewIntInterfaceMap()
+
+	m.BatchSet(map[int]interface{}{1: 1, 2: "2", 3: 3})
+	gtest.Assert(m.Map(), map[int]interface{}{1: 1, 2: "2", 3: 3})
+	m.BatchRemove([]int{1, 2})
+	gtest.Assert(m.Map(), map[int]interface{}{3: 3})
+}
+func Test_IntInterfaceMap_Iterator(t *testing.T){
+	expect := map[int]interface{}{1: 1, 2: "2"}
+	m      := gmap.NewIntInterfaceMapFrom(expect)
+	m.Iterator(func(k int, v interface{}) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k int, v interface{}) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k int, v interface{}) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, "2")
+	gtest.Assert(j, 1)
+
+
+}
+
+func Test_IntInterfaceMap_Lock(t *testing.T){
+	expect := map[int]interface{}{1: 1, 2: "2"}
+	m := gmap.NewIntInterfaceMapFrom(expect)
+	m.LockFunc(func(m map[int]interface{}) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[int]interface{}) {
+		gtest.Assert(m, expect)
+	})
+}
+func Test_IntInterfaceMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewIntInterfaceMapFrom(map[int]interface{}{1: 1, 2: "2"})
+
+	m_clone := m.Clone()
+	m.Remove(1)
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN(1, m_clone.Keys())
+
+	m_clone.Remove(2)
+	//修改clone map,原 map 不影响
+	gtest.AssertIN(2, m.Keys())
+}
+func Test_IntInterfaceMap_Merge(t *testing.T) {
+	m1 := gmap.NewIntInterfaceMap()
+	m2 := gmap.NewIntInterfaceMap()
+	m1.Set(1, 1)
+	m2.Set(2, "2")
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[int]interface{}{1: 1, 2: "2"})
+}

g/container/gmap/gmap_z_int_string_test.go

@@ -0,0 +1,132 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func getString() string {
+	return "z"
+}
+func intStringCallBack(int, string) bool {
+	return true
+}
+func Test_IntStringMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewIntStringMap()
+		m.Set(1, "a")
+
+		gtest.Assert(m.Get(1), "a")
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet(2, "b"), "b")
+		gtest.Assert(m.SetIfNotExist(2, "b"), false)
+
+		gtest.Assert(m.SetIfNotExist(3, "c"), true)
+
+		gtest.Assert(m.Remove(2), "b")
+		gtest.Assert(m.Contains(2), false)
+
+		gtest.AssertIN(3, m.Keys())
+		gtest.AssertIN(1, m.Keys())
+		gtest.AssertIN("a", m.Values())
+		gtest.AssertIN("c", m.Values())
+
+		//反转之后不成为以下 map,flip 操作只是翻转原 map
+		//gtest.Assert(m.Map(), map[string]int{"a": 1, "c": 3})
+		m_f := gmap.NewIntStringMap()
+		m_f.Set(1, "2")
+		m_f.Flip()
+		gtest.Assert(m_f.Map(), map[int]string{2: "1"})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewIntStringMapFrom(map[int]string{1: "a", 2: "b"})
+		gtest.Assert(m2.Map(), map[int]string{1: "a", 2: "b"})
+		m3 := gmap.NewIntStringMapFromArray([]int{1, 2}, []string{"a", "b"})
+		gtest.Assert(m3.Map(), map[int]string{1: "a", 2: "b"})
+
+	})
+}
+func Test_IntStringMap_Set_Fun(t *testing.T) {
+	m := gmap.NewIntStringMap()
+
+	m.GetOrSetFunc(1, getString)
+	m.GetOrSetFuncLock(2, getString)
+	gtest.Assert(m.Get(1), "z")
+	gtest.Assert(m.Get(2), "z")
+	gtest.Assert(m.SetIfNotExistFunc(1, getString), false)
+	gtest.Assert(m.SetIfNotExistFunc(3, getString), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock(2, getString), false)
+	gtest.Assert(m.SetIfNotExistFuncLock(4, getString), true)
+
+}
+
+func Test_IntStringMap_Batch(t *testing.T) {
+	m := gmap.NewIntStringMap()
+
+	m.BatchSet(map[int]string{1: "a", 2: "b", 3: "c"})
+	gtest.Assert(m.Map(), map[int]string{1: "a", 2: "b",3: "c"})
+	m.BatchRemove([]int{1, 2})
+	gtest.Assert(m.Map(), map[int]interface{}{3: "c"})
+}
+func Test_IntStringMap_Iterator(t *testing.T){
+	expect := map[int]string{1: "a", 2: "b"}
+	m      := gmap.NewIntStringMapFrom(expect)
+	m.Iterator(func(k int, v string) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k int, v string) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k int, v string) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+}
+
+func Test_IntStringMap_Lock(t *testing.T){
+
+	expect := map[int]string{1: "a", 2: "b", 3: "c"}
+	m      := gmap.NewIntStringMapFrom(expect)
+	m.LockFunc(func(m map[int]string) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[int]string) {
+		gtest.Assert(m, expect)
+	})
+
+}
+func Test_IntStringMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewIntStringMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
+
+	m_clone := m.Clone()
+	m.Remove(1)
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN(1, m_clone.Keys())
+
+	m_clone.Remove(2)
+	//修改clone map,原 map 不影响
+	gtest.AssertIN(2, m.Keys())
+}
+func Test_IntStringMap_Merge(t *testing.T) {
+	m1 := gmap.NewIntStringMap()
+	m2 := gmap.NewIntStringMap()
+	m1.Set(1, "a")
+	m2.Set(2, "b")
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[int]string{1: "a", 2: "b"})
+}

g/container/gmap/gmap_z_interface_interface_basic_test.go

@@ -0,0 +1,125 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func getValue() interface{} {
+	return 3
+}
+func callBack(k interface{}, v interface{}) bool {
+	return true
+}
+
+func Test_Map_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.New()
+		m.Set("key1", "val1")
+		gtest.Assert(m.Keys(), []interface{}{"key1"})
+
+		gtest.Assert(m.Get("key1"), "val1")
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet("key2", "val2"), "val2")
+		gtest.Assert(m.SetIfNotExist("key2", "val2"), false)
+
+		gtest.Assert(m.SetIfNotExist("key3", "val3"), true)
+
+		gtest.Assert(m.Remove("key2"), "val2")
+		gtest.Assert(m.Contains("key2"), false)
+
+		gtest.AssertIN("key3", m.Keys())
+		gtest.AssertIN("key1", m.Keys())
+		gtest.AssertIN("val3", m.Values())
+		gtest.AssertIN("val1", m.Values())
+
+		m.Flip()
+		gtest.Assert(m.Map(), map[interface{}]interface{}{"val3": "key3", "val1": "key1"})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
+		gtest.Assert(m2.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
+		m3 := gmap.NewFromArray([]interface{}{1, "key1"}, []interface{}{1, "val1"})
+		gtest.Assert(m3.Map(), map[interface{}]interface{}{1: 1, "key1": "val1"})
+
+	})
+}
+func Test_Map_Set_Fun(t *testing.T) {
+	m := gmap.New()
+	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)
+}
+
+func Test_Map_Batch(t *testing.T) {
+	m := gmap.New()
+	m.BatchSet(map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+	gtest.Assert(m.Map(), map[interface{}]interface{}{1: 1, "key1": "val1", "key2": "val2", "key3": "val3"})
+	m.BatchRemove([]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"}
+
+	m := gmap.NewFrom(expect)
+	m.Iterator(func(k interface{}, v interface{}) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	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, 2)
+	gtest.Assert(j, 1)
+}
+
+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{}) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[interface{}]interface{}) {
+		gtest.Assert(m, expect)
+	})
+}
+
+func Test_Map_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
+	m_clone := m.Clone()
+	m.Remove(1)
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN(1, m_clone.Keys())
+
+	m_clone.Remove("key1")
+	//修改clone map,原 map 不影响
+	gtest.AssertIN("key1", m.Keys())
+}
+func Test_Map_Basic_Merge(t *testing.T) {
+	m1 := gmap.New()
+	m2 := gmap.New()
+	m1.Set("key1", "val1")
+	m2.Set("key2", "val2")
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[interface{}]interface{}{"key1": "val1", "key2": "val2"})
+}

g/container/gmap/gmap_z_normal_example_test.go

@@ -0,0 +1,71 @@
+package gmap_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/g/container/gmap"
+)
+
+func Example_Normal_Basic() {
+	m := gmap.New()
+
+	//Add data
+	m.Set("key1", "val1")
+
+	//Print size
+	fmt.Println(m.Size())
+	//output 1
+
+	add_map := make(map[interface{}]interface{})
+	add_map["key2"] = "val2"
+	add_map["key3"] = "val3"
+	add_map[1] = 1
+
+	fmt.Println(m.Values())
+
+	//Batch add data
+	m.BatchSet(add_map)
+
+	//Gets the value of the corresponding key
+	key3_val := m.Get("key3")
+	fmt.Println(key3_val)
+
+	//Get the value by key, or set it with given key-value if not exist.
+	get_or_set_val := m.GetOrSet("key4", "val4")
+	fmt.Println(get_or_set_val)
+
+	// Set key-value if the key does not exist, then return true; or else return false.
+	is_set := m.SetIfNotExist("key3", "val3")
+	fmt.Println(is_set)
+
+	//Remove key
+	m.Remove("key2")
+	fmt.Println(m.Keys())
+
+	//Batch remove keys
+	remove_keys := []interface{}{"key1", 1}
+	m.BatchRemove(remove_keys)
+	fmt.Println(m.Keys())
+
+	//Contains checks whether a key exists.
+	is_contain := m.Contains("key3")
+	fmt.Println(is_contain)
+
+	//Flip exchanges key-value of the map, it will change key-value to value-key.
+	m.Flip()
+	fmt.Println(m.Map())
+
+	// Clear deletes all data of the map,
+	m.Clear()
+
+	fmt.Println(m.Size())
+
+}
+func Example_Normal_Merge(){
+	m1 := gmap.New()
+	m2 := gmap.New()
+	m1.Set("key1","val1")
+	m2.Set("key2","val2")
+	m1.Merge(m2)
+	fmt.Println(m1.Map())
+}
+

g/container/gmap/gmap_z_string_bool_test.go

@@ -0,0 +1,122 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func StringBoolCallBack(string, bool) bool {
+	return true
+}
+func Test_StringBoolMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewStringBoolMap()
+		m.Set("a", true)
+
+		gtest.Assert(m.Get("a"), true)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet("b", false), false)
+		gtest.Assert(m.SetIfNotExist("b", false), false)
+
+		gtest.Assert(m.SetIfNotExist("c", false), true)
+
+		gtest.Assert(m.Remove("b"), false)
+		gtest.Assert(m.Contains("b"), false)
+
+		gtest.AssertIN("c", m.Keys())
+		gtest.AssertIN("a", m.Keys())
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewStringBoolMapFrom(map[string]bool{"a": true, "b": false})
+		gtest.Assert(m2.Map(), map[string]bool{"a": true, "b": false})
+		m3 := gmap.NewStringBoolMapFromArray([]string{"a", "b"}, []bool{true, false})
+		gtest.Assert(m3.Map(), map[string]bool{"a": true, "b": false})
+
+	})
+}
+func Test_StringBoolMap_Set_Fun(t *testing.T) {
+	m := gmap.NewStringBoolMap()
+
+	m.GetOrSetFunc("a", getBool)
+	m.GetOrSetFuncLock("b", getBool)
+	gtest.Assert(m.Get("a"), true)
+	gtest.Assert(m.Get("b"), true)
+	gtest.Assert(m.SetIfNotExistFunc("a", getBool), false)
+	gtest.Assert(m.SetIfNotExistFunc("c", getBool), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock("b", getBool), false)
+	gtest.Assert(m.SetIfNotExistFuncLock("d", getBool), true)
+
+}
+
+func Test_StringBoolMap_Batch(t *testing.T) {
+	m := gmap.NewStringBoolMap()
+
+	m.BatchSet(map[string]bool{"a": true, "b": false, "c": true})
+	gtest.Assert(m.Map(), map[string]bool{"a": true, "b": false, "c": true})
+	m.BatchRemove([]string{"a", "b"})
+	gtest.Assert(m.Map(), map[string]bool{"c": true})
+}
+
+func Test_StringBoolMap_Iterator(t *testing.T) {
+	expect := map[string]bool{"a": true, "b": false}
+	m := gmap.NewStringBoolMapFrom(expect)
+	m.Iterator(func(k string, v bool) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k string, v bool) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k string, v bool) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+
+}
+
+func Test_StringBoolMap_Lock(t *testing.T) {
+	expect := map[string]bool{"a": true, "b": false}
+
+	m      := gmap.NewStringBoolMapFrom(expect)
+	m.LockFunc(func(m map[string]bool) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[string]bool) {
+		gtest.Assert(m, expect)
+	})
+}
+
+func Test_StringBoolMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewStringBoolMapFrom(map[string]bool{"a": true, "b": false})
+
+	m_clone := m.Clone()
+	m.Remove("a")
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN("a", m_clone.Keys())
+
+	m_clone.Remove("b")
+	//修改clone map,原 map 不影响
+	gtest.AssertIN("b", m.Keys())
+}
+func Test_StringBoolMap_Merge(t *testing.T) {
+	m1 := gmap.NewStringBoolMap()
+	m2 := gmap.NewStringBoolMap()
+	m1.Set("a", true)
+	m2.Set("b", false)
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[string]bool{"a": true, "b": false})
+}

g/container/gmap/gmap_z_string_int_test.go

@@ -0,0 +1,128 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func stringIntCallBack(string, int) bool {
+	return true
+}
+func Test_StringIntMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewStringIntMap()
+		m.Set("a", 1)
+
+		gtest.Assert(m.Get("a"), 1)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet("b", 2), 2)
+		gtest.Assert(m.SetIfNotExist("b", 2), false)
+
+		gtest.Assert(m.SetIfNotExist("c", 3), true)
+
+		gtest.Assert(m.Remove("b"), 2)
+		gtest.Assert(m.Contains("b"), false)
+
+		gtest.AssertIN("c", m.Keys())
+		gtest.AssertIN("a", m.Keys())
+		gtest.AssertIN(3, m.Values())
+		gtest.AssertIN(1, m.Values())
+
+		m_f := gmap.NewStringIntMap()
+		m_f.Set("1", 2)
+		m_f.Flip()
+		gtest.Assert(m_f.Map(), map[string]int{"2": 1})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewStringIntMapFrom(map[string]int{"a": 1, "b": 2})
+		gtest.Assert(m2.Map(), map[string]int{"a": 1, "b": 2})
+		m3 := gmap.NewStringIntMapFromArray([]string{"a", "b"}, []int{1, 2})
+		gtest.Assert(m3.Map(), map[string]int{"a": 1, "b": 2})
+
+	})
+}
+func Test_StringIntMap_Set_Fun(t *testing.T) {
+	m := gmap.NewStringIntMap()
+
+	m.GetOrSetFunc("a", getInt)
+	m.GetOrSetFuncLock("b", getInt)
+	gtest.Assert(m.Get("a"), 123)
+	gtest.Assert(m.Get("b"), 123)
+	gtest.Assert(m.SetIfNotExistFunc("a", getInt), false)
+	gtest.Assert(m.SetIfNotExistFunc("c", getInt), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock("b", getInt), false)
+	gtest.Assert(m.SetIfNotExistFuncLock("d", getInt), true)
+
+}
+
+func Test_StringIntMap_Batch(t *testing.T) {
+	m := gmap.NewStringIntMap()
+
+	m.BatchSet(map[string]int{"a": 1, "b": 2, "c": 3})
+	gtest.Assert(m.Map(), map[string]int{"a": 1, "b": 2, "c": 3})
+	m.BatchRemove([]string{"a", "b"})
+	gtest.Assert(m.Map(), map[string]int{"c": 3})
+}
+func Test_StringIntMap_Iterator(t *testing.T) {
+	expect := map[string]int{"a": 1, "b": 2}
+	m := gmap.NewStringIntMapFrom(expect)
+	m.Iterator(func(k string, v int) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k string, v int) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k string, v int) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+
+}
+
+func Test_StringIntMap_Lock(t *testing.T) {
+	expect := map[string]int{"a": 1, "b": 2}
+
+	m      := gmap.NewStringIntMapFrom(expect)
+	m.LockFunc(func(m map[string]int) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[string]int) {
+		gtest.Assert(m, expect)
+	})
+}
+
+func Test_StringIntMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewStringIntMapFrom(map[string]int{"a": 1, "b": 2, "c": 3})
+
+	m_clone := m.Clone()
+	m.Remove("a")
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN("a", m_clone.Keys())
+
+	m_clone.Remove("b")
+	//修改clone map,原 map 不影响
+	gtest.AssertIN("b", m.Keys())
+}
+func Test_StringIntMap_Merge(t *testing.T) {
+	m1 := gmap.NewStringIntMap()
+	m2 := gmap.NewStringIntMap()
+	m1.Set("a", 1)
+	m2.Set("b", 2)
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[string]int{"a": 1, "b": 2})
+}

g/container/gmap/gmap_z_string_interface_test.go

@@ -0,0 +1,125 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func stringInterfaceCallBack(string, interface{}) bool {
+	return true
+}
+func Test_StringInterfaceMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewStringInterfaceMap()
+		m.Set("a", 1)
+
+		gtest.Assert(m.Get("a"), 1)
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet("b", "2"), "2")
+		gtest.Assert(m.SetIfNotExist("b", "2"), false)
+
+		gtest.Assert(m.SetIfNotExist("c", 3), true)
+
+		gtest.Assert(m.Remove("b"), "2")
+		gtest.Assert(m.Contains("b"), false)
+
+		gtest.AssertIN("c", m.Keys())
+		gtest.AssertIN("a", m.Keys())
+		gtest.AssertIN(3, m.Values())
+		gtest.AssertIN(1, m.Values())
+
+		m.Flip()
+		gtest.Assert(m.Map(), map[string]interface{}{"1": "a", "3": "c"})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewStringInterfaceMapFrom(map[string]interface{}{"a": 1, "b": "2"})
+		gtest.Assert(m2.Map(), map[string]interface{}{"a": 1, "b": "2"})
+		m3 := gmap.NewStringInterfaceMapFromArray([]string{"a", "b"}, []interface{}{1, "2"})
+		gtest.Assert(m3.Map(), map[string]interface{}{"a": 1, "b": "2"})
+
+	})
+}
+func Test_StringInterfaceMap_Set_Fun(t *testing.T) {
+	m := gmap.NewStringInterfaceMap()
+
+	m.GetOrSetFunc("a", getInterface)
+	m.GetOrSetFuncLock("b", getInterface)
+	gtest.Assert(m.Get("a"), 123)
+	gtest.Assert(m.Get("b"), 123)
+	gtest.Assert(m.SetIfNotExistFunc("a", getInterface), false)
+	gtest.Assert(m.SetIfNotExistFunc("c", getInterface), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock("b", getInterface), false)
+	gtest.Assert(m.SetIfNotExistFuncLock("d", getInterface), true)
+
+}
+
+func Test_StringInterfaceMap_Batch(t *testing.T) {
+	m := gmap.NewStringInterfaceMap()
+
+	m.BatchSet(map[string]interface{}{"a": 1, "b": "2", "c": 3})
+	gtest.Assert(m.Map(), map[string]interface{}{"a": 1, "b": "2", "c": 3})
+	m.BatchRemove([]string{"a", "b"})
+	gtest.Assert(m.Map(), map[string]interface{}{"c": 3})
+}
+
+func Test_StringInterfaceMap_Iterator(t *testing.T) {
+	expect := map[string]interface{}{"a": true, "b": false}
+	m := gmap.NewStringInterfaceMapFrom(expect)
+	m.Iterator(func(k string, v interface{}) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k string, v interface{}) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k string, v interface{}) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+}
+
+func Test_StringInterfaceMap_Lock(t *testing.T) {
+	expect := map[string]interface{}{"a": true, "b": false}
+
+	m      := gmap.NewStringInterfaceMapFrom(expect)
+	m.LockFunc(func(m map[string]interface{}) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[string]interface{}) {
+		gtest.Assert(m, expect)
+	})
+}
+func Test_StringInterfaceMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewStringInterfaceMapFrom(map[string]interface{}{"a": 1, "b": "2"})
+
+	m_clone := m.Clone()
+	m.Remove("a")
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN("a", m_clone.Keys())
+
+	m_clone.Remove("b")
+	//修改clone map,原 map 不影响
+	gtest.AssertIN("b", m.Keys())
+}
+func Test_StringInterfaceMap_Merge(t *testing.T) {
+	m1 := gmap.NewStringInterfaceMap()
+	m2 := gmap.NewStringInterfaceMap()
+	m1.Set("a", 1)
+	m2.Set("b", "2")
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[string]interface{}{"a": 1, "b": "2"})
+}

g/container/gmap/gmap_z_string_string_test.go

@@ -0,0 +1,125 @@
+package gmap_test
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+
+func stringStringCallBack(string, string) bool {
+	return true
+}
+func Test_StringStringMap_Basic(t *testing.T) {
+	gtest.Case(t, func() {
+		m := gmap.NewStringStringMap()
+		m.Set("a", "a")
+
+		gtest.Assert(m.Get("a"), "a")
+		gtest.Assert(m.Size(), 1)
+		gtest.Assert(m.IsEmpty(), false)
+
+		gtest.Assert(m.GetOrSet("b", "b"), "b")
+		gtest.Assert(m.SetIfNotExist("b", "b"), false)
+
+		gtest.Assert(m.SetIfNotExist("c", "c"), true)
+
+		gtest.Assert(m.Remove("b"), "b")
+		gtest.Assert(m.Contains("b"), false)
+
+		gtest.AssertIN("c", m.Keys())
+		gtest.AssertIN("a", m.Keys())
+		gtest.AssertIN("a", m.Values())
+		gtest.AssertIN("c", m.Values())
+
+		m.Flip()
+
+		gtest.Assert(m.Map(), map[string]string{"a": "a", "c": "c"})
+
+		m.Clear()
+		gtest.Assert(m.Size(), 0)
+		gtest.Assert(m.IsEmpty(), true)
+
+		m2 := gmap.NewStringStringMapFrom(map[string]string{"a": "a", "b": "b"})
+		gtest.Assert(m2.Map(), map[string]string{"a": "a", "b": "b"})
+		m3 := gmap.NewStringStringMapFromArray([]string{"a", "b"}, []string{"a", "b"})
+		gtest.Assert(m3.Map(), map[string]string{"a": "a", "b": "b"})
+
+	})
+}
+func Test_StringStringMap_Set_Fun(t *testing.T) {
+	m := gmap.NewStringStringMap()
+
+	m.GetOrSetFunc("a", getString)
+	m.GetOrSetFuncLock("b", getString)
+	gtest.Assert(m.Get("a"), "z")
+	gtest.Assert(m.Get("b"), "z")
+	gtest.Assert(m.SetIfNotExistFunc("a", getString), false)
+	gtest.Assert(m.SetIfNotExistFunc("c", getString), true)
+
+	gtest.Assert(m.SetIfNotExistFuncLock("b", getString), false)
+	gtest.Assert(m.SetIfNotExistFuncLock("d", getString), true)
+
+}
+
+func Test_StringStringMap_Batch(t *testing.T) {
+	m := gmap.NewStringStringMap()
+
+	m.BatchSet(map[string]string{"a": "a", "b": "b", "c": "c"})
+	gtest.Assert(m.Map(), map[string]string{"a": "a", "b": "b", "c": "c"})
+	m.BatchRemove([]string{"a", "b"})
+	gtest.Assert(m.Map(), map[string]string{"c": "c"})
+}
+func Test_StringStringMap_Iterator(t *testing.T) {
+	expect := map[string]string{"a": "a", "b": "b"}
+	m := gmap.NewStringStringMapFrom(expect)
+	m.Iterator(func(k string, v string) bool {
+		gtest.Assert(expect[k], v)
+		return true
+	})
+	// 断言返回值对遍历控制
+	i := 0
+	j := 0
+	m.Iterator(func(k string, v string) bool {
+		i++
+		return true
+	})
+	m.Iterator(func(k string, v string) bool {
+		j++
+		return false
+	})
+	gtest.Assert(i, 2)
+	gtest.Assert(j, 1)
+}
+
+func Test_StringStringMap_Lock(t *testing.T) {
+	expect := map[string]string{"a": "a", "b": "b"}
+
+	m      := gmap.NewStringStringMapFrom(expect)
+	m.LockFunc(func(m map[string]string) {
+		gtest.Assert(m, expect)
+	})
+	m.RLockFunc(func(m map[string]string) {
+		gtest.Assert(m, expect)
+	})
+}
+func Test_StringStringMap_Clone(t *testing.T) {
+	//clone 方法是深克隆
+	m := gmap.NewStringStringMapFrom(map[string]string{"a": "a", "b": "b", "c": "c"})
+
+	m_clone := m.Clone()
+	m.Remove("a")
+	//修改原 map,clone 后的 map 不影响
+	gtest.AssertIN("a", m_clone.Keys())
+
+	m_clone.Remove("b")
+	//修改clone map,原 map 不影响
+	gtest.AssertIN("b", m.Keys())
+}
+func Test_StringStringMap_Merge(t *testing.T) {
+	m1 := gmap.NewStringStringMap()
+	m2 := gmap.NewStringStringMap()
+	m1.Set("a", "a")
+	m2.Set("b", "b")
+	m1.Merge(m2)
+	gtest.Assert(m1.Map(), map[string]string{"a": "a", "b": "b"})
+}

g/container/gpool/gpool.go

@@ -1,20 +1,18 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gpool provides a object-reusable concurrent-safe pool.
-//
-// 对象复用池.
 package gpool
 
 import (
     "errors"
-    "gitee.com/johng/gf/g/container/glist"
-    "gitee.com/johng/gf/g/container/gtype"
-    "gitee.com/johng/gf/g/os/gtime"
-    "gitee.com/johng/gf/g/os/gtimer"
+    "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"
 )
 

g/container/gpool/gpool_test.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*"
 

g/container/gqueue/gqueue.go

@@ -1,12 +1,12 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gqueue provides a dynamic/static concurrent-safe(alternative) queue.
 //
-// 并发安全的动态队列.
+// 并发安全动态队列.
 //
 //   特点：
 //   1. 动态队列初始化速度快；
@@ -15,9 +15,8 @@
 package gqueue
 
 import (
-    "container/list"
+    "github.com/gogf/gf/g/container/glist"
     "math"
-    "sync"
 )
 
 // 1、这是一个先进先出的队列(chan <-- list)；
@@ -28,9 +27,8 @@ import (
 //
 // 4、由于功能主体是chan，那么操作仍然像chan那样具有阻塞效果；
 type Queue struct {
-    mu        sync.Mutex       // 底层链表写锁
     limit     int              // 队列限制大小
-    list      *list.List       // 底层数据链表
+    list      *glist.List       // 底层数据链表
     events    chan struct{}    // 写入事件通知
     closed    chan struct{}    // 队列关闭通知
     C         chan interface{} // 队列数据读取
@@ -50,7 +48,7 @@ func New(limit...int) *Queue {
         q.limit  = limit[0]
         q.C      = make(chan interface{}, limit[0])
     } else {
-        q.list   = list.New()
+        q.list   = glist.New()
         q.events = make(chan struct{}, math.MaxInt32)
         q.C      = make(chan interface{}, gDEFAULT_QUEUE_SIZE)
         go q.startAsyncLoop()
@@ -68,7 +66,6 @@ func (q *Queue) startAsyncLoop() {
                 for {
                     if length := q.list.Len(); length > 0 {
                         array := make([]interface{}, length)
-                        q.mu.Lock()
                         for i := 0; i < length; i++ {
                             if e := q.list.Front(); e != nil {
                                 array[i] = q.list.Remove(e)
@@ -76,7 +73,6 @@ func (q *Queue) startAsyncLoop() {
                                 break
                             }
                         }
-                        q.mu.Unlock()
                         for _, v := range array {
                            q.C <- v
                         }
@@ -93,9 +89,7 @@ func (q *Queue) Push(v interface{}) {
     if q.limit > 0 {
         q.C <- v
     } else {
-        q.mu.Lock()
         q.list.PushBack(v)
-        q.mu.Unlock()
         q.events <- struct{}{}
     }
 }

g/container/gqueue/gqueue_bench_test.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
@@ -10,7 +10,7 @@ package gqueue_test
 
 import (
     "testing"
-    "gitee.com/johng/gf/g/container/gqueue"
+    "github.com/gogf/gf/g/container/gqueue"
 )
 
 var bn        = 20000000

g/container/gring/gring.go

@@ -1,18 +1,16 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package gring provides a concurrent-safe(alternative) ring(circular lists).
-//
-// 并发安全环.
+// Package gring provides a concurrent-safe/unsafe ring(circular lists).
 package gring
 
 import (
     "container/ring"
-    "gitee.com/johng/gf/g/container/gtype"
-    "gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/container/gtype"
+    "github.com/gogf/gf/g/internal/rwmutex"
 )
 
 type Ring struct {
@@ -149,8 +147,8 @@ func (r *Ring) Unlink(n int) *Ring {
 
 // 读锁遍历，往后只读遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
     if !f(r.ring.Value) {
         return
     }
@@ -163,8 +161,8 @@ func (r *Ring) RLockIteratorNext(f func(value interface{}) bool) {
 
 // 读锁遍历，往前只读遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
     if !f(r.ring.Value) {
         return
     }
@@ -177,8 +175,8 @@ func (r *Ring) RLockIteratorPrev(f func(value interface{}) bool) {
 
 // 写锁遍历，往后写遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
     if !f(r.ring) {
         return
     }
@@ -191,8 +189,8 @@ func (r *Ring) LockIteratorNext(f func(item *ring.Ring) bool) {
 
 // 写锁遍历，往前写遍历，回调函数返回true表示继续遍历，否则退出遍历
 func (r *Ring) LockIteratorPrev(f func(item *ring.Ring) bool) {
-    r.mu.RLock(true)
-    defer r.mu.RUnlock(true)
+    r.mu.RLock()
+    defer r.mu.RUnlock()
     if !f(r.ring) {
         return
     }

g/container/gring/gring_test.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*"
 

g/container/gring/gring_unit_test.go

@@ -0,0 +1,229 @@
+package gring_test
+
+import (
+	"container/ring"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/gring"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+)
+type Student struct {
+	position int
+	name    string
+	upgrade bool
+}
+
+func TestRing_Val(t *testing.T) {
+	gtest.Case(t, func() {
+		//定义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})
+
+		//元素取值并判断和预设值是否相等
+		gtest.Assert(r.Val().(*Student).name,"jimmy")
+		//从当前位置往后移两个元素
+		r.Move(2)
+		gtest.Assert(r.Val().(*Student).name,"alon")
+		//更新元素值
+		//测试 value == nil
+		r.Set(nil)
+		gtest.Assert(r.Val(),nil)
+		//测试value != nil
+		r.Set(&Student{3, "jack", true})
+	})
+}
+func TestRing_CapLen(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(10)
+		r.Put("goframe")
+		//cap长度 10
+		gtest.Assert(r.Cap(), 10)
+		//已有数据项 1
+		gtest.Assert(r.Len(), 1)
+	})
+}
+
+func TestRing_Position(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(2)
+		r.Put(1)
+		r.Put(2)
+		//往后移动1个元素
+		r.Next()
+		gtest.Assert(r.Val(),2)
+		//往前移动1个元素
+		r.Prev()
+		gtest.Assert(r.Val(),1)
+
+	})
+}
+
+func TestRing_Link(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(3)
+		r.Put(1)
+		r.Put(2)
+		r.Put(3)
+		s := gring.New(2)
+		s.Put("a")
+		s.Put("b")
+
+		rs := r.Link(s)
+		gtest.Assert(rs.Move(2).Val(), "b")
+
+	})
+}
+
+func TestRing_Unlink(t *testing.T) {
+	gtest.Case(t, func() {
+		r := gring.New(5)
+		for i := 0; i< 5; i++  {
+			r.Put(i+1)
+		}
+		// 1 2 3 4
+		// 删除当前位置往后的2个数据，返回被删除的数据
+		// 重新计算s len
+		s := r.Unlink(2)		// 2 3
+		gtest.Assert(s.Val(), 2)
+		gtest.Assert(s.Len(), 1)
+	})
+}
+
+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)
+		}
+		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}
+		gtest.Assert(ra, array)
+
+		//第3个元素设为nil
+		r.Set(nil)
+		array2 := r.SliceNext() 	//[4 5 1 2]
+		//返回当前位置往后不为空的元素数组，长度为4
+		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})
+
+		s := gring.New(ringLen)
+		for i := 0; i< ringLen; i++  {
+			s.Put(i+1)
+		}
+		array4 := s.SlicePrev()	// []
+		gtest.Assert(array4, g.Slice{1,5,4,3,2})
+
+	})
+}
+
+func TestRing_RLockIterator(t *testing.T) {
+	gtest.Case(t, func() {
+		ringLen := 5
+		r := gring.New(ringLen)
+
+		//ring不存在有值元素
+		r.RLockIteratorNext(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return false
+		})
+		r.RLockIteratorNext(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return true
+		})
+
+		r.RLockIteratorPrev(func(v interface{}) bool {
+			gtest.Assert(v, nil)
+			return true
+		})
+
+		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++;
+			return true
+		})
+
+		//RLockIteratorPrev遍历1次返回 false,退出遍历
+		r.RLockIteratorPrev(func(v interface{}) bool {
+			gtest.Assert(v, 1)
+			return false
+		})
+
+	})
+}
+
+func TestRing_LockIterator(t *testing.T) {
+	gtest.Case(t, func() {
+		ringLen := 5
+		r := gring.New(ringLen)
+
+		//不存在有值元素
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorNext(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return true
+		})
+
+		r.LockIteratorPrev(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return false
+		})
+		r.LockIteratorPrev(func(item *ring.Ring) bool {
+			gtest.Assert(item.Value, nil)
+			return true
+		})
+
+		//ring初始化元素值
+		for i := 0; i< ringLen; i++  {
+			r.Put(i+1)
+		}
+
+		//往后遍历组成数据 [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++;
+			return true
+		})
+
+		//往后取3个元素组成数组
+		//获得 [1,5,4]
+		i := 0
+		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++;
+			return true
+		})
+
+
+	})
+}

g/container/gset/gset.go

@@ -1,17 +1,298 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package gset provides kinds of concurrent-safe(alternative) sets.
-//
-// 并发安全集合.
+// Package gset provides kinds of concurrent-safe/unsafe sets.
 package gset
 
-type Set = InterfaceSet
+import (
+    "github.com/gogf/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/util/gconv"
+    "strings"
+)
 
-// 默认Set类型
+type Set 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,
+// which is false in default.
 func New(unsafe...bool) *Set {
-    return NewInterfaceSet(unsafe...)
+    return NewSet(unsafe...)
+}
+
+// See New.
+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 {
+	m := make(map[interface{}]struct{})
+	for _, v := range gconv.Interfaces(items) {
+		m[v] = struct{}{}
+	}
+	return &Set{
+		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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Remove deletes <item> from set.
+func (set *Set) Remove(item interface{}) *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
+}
+
+// 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
+}
+
+// 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
+}
+
+// Join joins items with a string <glue>.
+func (set *Set) Join(glue string) string {
+    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(",")
+}
+
+// LockFunc locks writing with callback function <f>.
+func (set *Set) LockFunc(f func(m map[interface{}]struct{})) *Set {
+    set.mu.Lock()
+    defer set.mu.Unlock()
+    f(set.m)
+    return set
+}
+
+// RLockFunc locks reading with callback function <f>.
+func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) *Set {
+    set.mu.RLock()
+    defer set.mu.RUnlock()
+    f(set.m)
+    return set
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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()
+        }
+    }
+
+    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
+}
+
+// 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
+}
+
+// Complement returns a new set which is the complement from <set> to <full>.
+// Which means, all the items in <newSet> are in <full> and not in <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
+}
+
+// Merge adds items from <others> sets into <set>.
+func (set *Set) Merge(others ... *Set) *Set {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range other.m {
+			set.m[k] = v
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return set
+}
+
+// Sum sums items.
+// Note: The items should be converted to int type,
+// or you'd get a result that you unexpected.
+func (set *Set) Sum() (sum int) {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for k, _ := range set.m {
+		sum += gconv.Int(k)
+	}
+	return
 }

g/container/gset/gset_int_set.go

@@ -1,16 +1,16 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
-//
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gset
 
 import (
-	"fmt"
-	"gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/util/gconv"
+    "strings"
 )
 
 type IntSet struct {
@@ -18,6 +18,9 @@ type IntSet struct {
 	m  map[int]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,
+// which is false in default.
 func NewIntSet(unsafe...bool) *IntSet {
 	return &IntSet{
 		m  : make(map[int]struct{}),
@@ -25,8 +28,21 @@ func NewIntSet(unsafe...bool) *IntSet {
 	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (set *IntSet) Iterator(f func (v int) bool) {
+// NewIntSetFrom returns a new set from <items>.
+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...),
+	}
+}
+
+// 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()
 	for k, _ := range set.m {
@@ -34,27 +50,20 @@ func (set *IntSet) Iterator(f func (v int) bool) {
 			break
 		}
 	}
+    return set
 }
 
-// 设置键
-func (set *IntSet) Add(item int) *IntSet {
+// Add adds one or multiple items to the set.
+func (set *IntSet) Add(item...int) *IntSet {
 	set.mu.Lock()
-	set.m[item] = struct{}{}
+    for _, v := range item {
+        set.m[v] = struct{}{}
+    }
 	set.mu.Unlock()
 	return set
 }
 
-// 批量添加设置键
-func (set *IntSet) BatchAdd(items []int) *IntSet {
-	set.mu.Lock()
-	for _, item := range items {
-		set.m[item] = struct{}{}
-	}
-	set.mu.Unlock()
-    return set
-}
-
-// 键是否存在
+// Contains checks whether the set contains <item>.
 func (set *IntSet) Contains(item int) bool {
 	set.mu.RLock()
 	_, exists := set.m[item]
@@ -62,14 +71,15 @@ func (set *IntSet) Contains(item int) bool {
 	return exists
 }
 
-// 删除键值对
-func (set *IntSet) Remove(key int) {
+// Remove deletes <item> from set.
+func (set *IntSet) Remove(item int) *IntSet {
 	set.mu.Lock()
-	delete(set.m, key)
+	delete(set.m, item)
 	set.mu.Unlock()
+	return set
 }
 
-// 大小
+// Size returns the size of the set.
 func (set *IntSet) Size() int {
 	set.mu.RLock()
 	l := len(set.m)
@@ -77,40 +87,206 @@ func (set *IntSet) Size() int {
 	return l
 }
 
-// 清空set
-func (set *IntSet) Clear() {
+// Clear deletes all items of the set.
+func (set *IntSet) Clear() *IntSet {
 	set.mu.Lock()
 	set.m = make(map[int]struct{})
 	set.mu.Unlock()
+    return set
 }
 
-// 转换为数组
+// Slice returns the a of items of the set as slice.
 func (set *IntSet) Slice() []int {
 	set.mu.RLock()
 	ret := make([]int, len(set.m))
 	i := 0
-	for item := range set.m {
-		ret[i] = item
+	for k, _ := range set.m {
+		ret[i] = k
 		i++
 	}
-
 	set.mu.RUnlock()
 	return ret
 }
 
-// 转换为字符串
+// Join joins items with a string <glue>.
+func (set *IntSet) Join(glue string) string {
+    return strings.Join(gconv.Strings(set.Slice()), ",")
+}
+
+// String returns items as a string, which are joined by char ','.
 func (set *IntSet) String() string {
-	return fmt.Sprint(set.Slice())
+    return set.Join(",")
 }
 
-func (set *IntSet) LockFunc(f func(m map[int]struct{})) {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+// LockFunc locks writing with callback function <f>.
+func (set *IntSet) LockFunc(f func(m map[int]struct{})) *IntSet {
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
+    return set
 }
 
-func (set *IntSet) RLockFunc(f func(m map[int]struct{})) {
-    set.mu.RLock(true)
-    defer set.mu.RUnlock(true)
+// RLockFunc locks reading with callback function <f>.
+func (set *IntSet) RLockFunc(f func(m map[int]struct{})) *IntSet {
+    set.mu.RLock()
+    defer set.mu.RUnlock()
     f(set.m)
+    return set
+}
+
+// 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 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 *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
+}
+
+// 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()
+        }
+    }
+
+    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
+}
+
+// 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
+}
+
+// Complement returns a new set which is the complement from <set> to <full>.
+// Which means, all the items in <newSet> are in <full> and not in <set>.
+//
+// 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
+}
+
+// Merge adds items from <others> sets into <set>.
+func (set *IntSet) Merge(others ... *IntSet) *IntSet {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range other.m {
+			set.m[k] = v
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return set
+}
+
+// Sum sums items.
+// Note: The items should be converted to int type,
+// or you'd get a result that you unexpected.
+func (set *IntSet) Sum() (sum int) {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for k, _ := range set.m {
+		sum += k
+	}
+	return
 }

g/container/gset/gset_interface_set.go

@@ -1,114 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-//
-
-package gset
-
-import (
-	"fmt"
-	"gitee.com/johng/gf/g/internal/rwmutex"
-)
-
-type InterfaceSet struct {
-	mu *rwmutex.RWMutex
-	m  map[interface{}]struct{}
-}
-
-func NewInterfaceSet(unsafe...bool) *InterfaceSet {
-	return &InterfaceSet{
-		m  : make(map[interface{}]struct{}),
-		mu : rwmutex.New(unsafe...),
-    }
-}
-
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (set *InterfaceSet) Iterator(f func (v interface{}) bool) {
-    set.mu.RLock()
-    defer set.mu.RUnlock()
-    for k, _ := range set.m {
-		if !f(k) {
-			break
-		}
-    }
-}
-
-// 添加
-func (set *InterfaceSet) Add(item interface{}) *InterfaceSet {
-	set.mu.Lock()
-	set.m[item] = struct{}{}
-	set.mu.Unlock()
-	return set
-}
-
-// 批量添加
-func (set *InterfaceSet) BatchAdd(items []interface{}) *InterfaceSet {
-	set.mu.Lock()
-	for _, item := range items {
-		set.m[item] = struct{}{}
-	}
-	set.mu.Unlock()
-    return set
-}
-
-// 键是否存在
-func (set *InterfaceSet) Contains(item interface{}) bool {
-	set.mu.RLock()
-	_, exists := set.m[item]
-	set.mu.RUnlock()
-	return exists
-}
-
-// 删除键值对
-func (set *InterfaceSet) Remove(key interface{}) {
-	set.mu.Lock()
-	delete(set.m, key)
-	set.mu.Unlock()
-}
-
-// 大小
-func (set *InterfaceSet) Size() int {
-	set.mu.RLock()
-	l := len(set.m)
-	set.mu.RUnlock()
-	return l
-}
-
-// 清空set
-func (set *InterfaceSet) Clear() {
-	set.mu.Lock()
-	set.m = make(map[interface{}]struct{})
-	set.mu.Unlock()
-}
-
-// 转换为数组
-func (set *InterfaceSet) 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
-}
-
-// 转换为字符串
-func (set *InterfaceSet) String() string {
-	return fmt.Sprint(set.Slice())
-}
-
-func (set *InterfaceSet) LockFunc(f func(m map[interface{}]struct{})) {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
-	f(set.m)
-}
-
-func (set *InterfaceSet) RLockFunc(f func(m map[interface{}]struct{})) {
-	set.mu.RLock(true)
-	defer set.mu.RUnlock(true)
-	f(set.m)
-}

g/container/gset/gset_string_set.go

@@ -1,15 +1,16 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 //
 
 package gset
 
 import (
-	"fmt"
-	"gitee.com/johng/gf/g/internal/rwmutex"
+    "github.com/gogf/gf/g/internal/rwmutex"
+	"github.com/gogf/gf/g/util/gconv"
+	"strings"
 )
 
 type StringSet struct {
@@ -17,6 +18,9 @@ type StringSet struct {
 	m  map[string]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,
+// which is false in default.
 func NewStringSet(unsafe...bool) *StringSet {
 	return &StringSet {
 		m  : make(map[string]struct{}),
@@ -24,8 +28,21 @@ func NewStringSet(unsafe...bool) *StringSet {
 	}
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
-func (set *StringSet) Iterator(f func (v string) bool) {
+// NewStringSetFrom returns a new set from <items>.
+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...),
+	}
+}
+
+// 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()
 	for k, _ := range set.m {
@@ -33,27 +50,20 @@ func (set *StringSet) Iterator(f func (v string) bool) {
 			break
 		}
 	}
+	return set
 }
 
-// 设置键
-func (set *StringSet) Add(item string) *StringSet {
+// Add adds one or multiple items to the set.
+func (set *StringSet) Add(item...string) *StringSet {
 	set.mu.Lock()
-	set.m[item] = struct{}{}
+	for _, v := range item {
+		set.m[v] = struct{}{}
+	}
 	set.mu.Unlock()
 	return set
 }
 
-// 批量添加设置键
-func (set *StringSet) BatchAdd(items []string) *StringSet {
-	set.mu.Lock()
-	for _, item := range items {
-        set.m[item] = struct{}{}
-    }
-	set.mu.Unlock()
-    return set
-}
-
-// 键是否存在
+// Contains checks whether the set contains <item>.
 func (set *StringSet) Contains(item string) bool {
 	set.mu.RLock()
 	_, exists := set.m[item]
@@ -61,14 +71,15 @@ func (set *StringSet) Contains(item string) bool {
 	return exists
 }
 
-// 删除键值对
-func (set *StringSet) Remove(key string) {
+// Remove deletes <item> from set.
+func (set *StringSet) Remove(item string) *StringSet {
 	set.mu.Lock()
-	delete(set.m, key)
+	delete(set.m, item)
 	set.mu.Unlock()
+    return set
 }
 
-// 大小
+// Size returns the size of the set.
 func (set *StringSet) Size() int {
 	set.mu.RLock()
 	l := len(set.m)
@@ -76,14 +87,15 @@ func (set *StringSet) Size() int {
 	return l
 }
 
-// 清空set
-func (set *StringSet) Clear() {
+// Clear deletes all items of the set.
+func (set *StringSet) Clear() *StringSet {
 	set.mu.Lock()
 	set.m = make(map[string]struct{})
 	set.mu.Unlock()
+    return set
 }
 
-// 转换为数组
+// Slice returns the a of items of the set as slice.
 func (set *StringSet) Slice() []string {
 	set.mu.RLock()
 	ret := make([]string, len(set.m))
@@ -97,19 +109,185 @@ func (set *StringSet) Slice() []string {
 	return ret
 }
 
-// 转换为字符串
+// Join joins items with a string <glue>.
+func (set *StringSet) Join(glue string) string {
+    return strings.Join(set.Slice(), ",")
+}
+
+// String returns items as a string, which are joined by char ','.
 func (set *StringSet) String() string {
-	return fmt.Sprint(set.Slice())
+    return set.Join(",")
 }
 
-func (set *StringSet) LockFunc(f func(m map[string]struct{})) {
-	set.mu.Lock(true)
-	defer set.mu.Unlock(true)
+// LockFunc locks writing with callback function <f>.
+func (set *StringSet) LockFunc(f func(m map[string]struct{})) *StringSet {
+	set.mu.Lock()
+	defer set.mu.Unlock()
 	f(set.m)
+    return set
 }
 
-func (set *StringSet) RLockFunc(f func(m map[string]struct{})) {
-	set.mu.RLock(true)
-	defer set.mu.RUnlock(true)
+// RLockFunc locks reading with callback function <f>.
+func (set *StringSet) RLockFunc(f func(m map[string]struct{})) *StringSet {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
 	f(set.m)
+    return set
 }
+
+// Equal checks whether the two sets equal.
+func (set *StringSet) Equal(other *StringSet) 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
+}
+
+// IsSubsetOf checks whether the current set is a sub-set of <other>.
+func (set *StringSet) IsSubsetOf(other *StringSet) 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
+}
+
+// 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()
+        }
+    }
+
+    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
+}
+
+// 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
+}
+
+// Complement returns a new set which is the complement from <set> to <full>.
+// Which means, all the items in <newSet> are in <full> and not in <set>.
+//
+// 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
+}
+
+// Merge adds items from <others> sets into <set>.
+func (set *StringSet) Merge(others ... *StringSet) *StringSet {
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	for _, other := range others {
+		if set != other {
+			other.mu.RLock()
+		}
+		for k, v := range other.m {
+			set.m[k] = v
+		}
+		if set != other {
+			other.mu.RUnlock()
+		}
+	}
+	return set
+}
+
+// Sum sums items.
+// Note: The items should be converted to int type,
+// or you'd get a result that you unexpected.
+func (set *StringSet) Sum() (sum int) {
+	set.mu.RLock()
+	defer set.mu.RUnlock()
+	for k, _ := range set.m {
+		sum += gconv.Int(k)
+	}
+	return
+}

g/container/gset/gset_test.go

@@ -1,73 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-// go test *.go -bench=".*"
-
-package gset_test
-
-import (
-    "testing"
-    "strconv"
-    "gitee.com/johng/gf/g/container/gset"
-)
-
-var ints  = gset.NewIntSet()
-var itfs  = gset.NewInterfaceSet()
-var strs  = gset.NewStringSet()
-
-func Benchmark_IntSet_Add(b *testing.B) {
-    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)
-    }
-}
-
-func Benchmark_IntSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ints.Remove(i)
-    }
-}
-
-func Benchmark_InterfaceSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Add(i)
-    }
-}
-
-func Benchmark_InterfaceSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfs.Contains(i)
-    }
-}
-
-func Benchmark_InterfaceSet_Remove(b *testing.B) {
-    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))
-    }
-}
-
-func Benchmark_StringSet_Contains(b *testing.B) {
-    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))
-    }
-}

g/container/gset/gset_unsafe_test.go

@@ -1,73 +0,0 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-// go test *.go -bench=".*"
-
-package gset_test
-
-import (
-    "testing"
-    "strconv"
-    "gitee.com/johng/gf/g/container/gset"
-)
-
-var intsUnsafe  = gset.NewIntSet(true)
-var itfsUnsafe  = gset.NewInterfaceSet(true)
-var strsUnsafe  = gset.NewStringSet(true)
-
-func Benchmark_Unsafe_IntSet_Add(b *testing.B) {
-    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)
-    }
-}
-
-func Benchmark_Unsafe_IntSet_Remove(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        intsUnsafe.Remove(i)
-    }
-}
-
-func Benchmark_Unsafe_InterfaceSet_Add(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Add(i)
-    }
-}
-
-func Benchmark_Unsafe_InterfaceSet_Contains(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        itfsUnsafe.Contains(i)
-    }
-}
-
-func Benchmark_Unsafe_InterfaceSet_Remove(b *testing.B) {
-    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))
-    }
-}
-
-func Benchmark_Unsafe_StringSet_Contains(b *testing.B) {
-    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))
-    }
-}

g/container/gset/gset_z_bench_test.go

@@ -0,0 +1,130 @@
+// 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 gset_test
+
+import (
+    "testing"
+    "strconv"
+    "github.com/gogf/gf/g/container/gset"
+)
+
+var ints       = gset.NewIntSet()
+var itfs       = gset.NewSet()
+var strs       = gset.NewStringSet()
+var intsUnsafe = gset.NewIntSet(true)
+var itfsUnsafe = gset.NewSet(true)
+var strsUnsafe = gset.NewStringSet(true)
+
+func Benchmark_IntSet_Add(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_IntSet_Remove(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_Set_Contains(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_StringSet_Add(b *testing.B) {
+    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))
+    }
+}
+
+func Benchmark_StringSet_Remove(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_Unsafe_IntSet_Contains(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_Unsafe_Set_Add(b *testing.B) {
+    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)
+    }
+}
+
+func Benchmark_Unsafe_Set_Remove(b *testing.B) {
+    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))
+    }
+}
+
+func Benchmark_Unsafe_StringSet_Contains(b *testing.B) {
+    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))
+    }
+}

g/container/gset/gset_z_unit_int_test.go

@@ -0,0 +1,160 @@
+// 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.
+
+// go test *.go
+
+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"
+)
+
+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)
+    })
+}
+
+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)
+
+        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{}{},
+            })
+        })
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}

g/container/gset/gset_z_unit_string_test.go

@@ -0,0 +1,160 @@
+// 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.
+
+// go test *.go
+
+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"
+)
+
+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)
+    })
+}
+
+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)
+
+        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{}{},
+            })
+        })
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}

g/container/gset/gset_z_unit_test.go

@@ -0,0 +1,160 @@
+// 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.
+
+// go test *.go
+
+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"
+)
+
+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)
+    })
+}
+
+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)
+
+        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{}{},
+            })
+        })
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}
+
+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)
+    })
+}

g/container/gtype/bool.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,35 +11,39 @@ import (
 )
 
 type Bool struct {
-    val 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.val = 1
+            t.value = 1
         } else {
-            t.val = 0
+            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())
 }
 
-// 并发安全设置变量值，返回之前的旧值
+// Set atomically stores value into t.valueue and returns the previous t.value value.
 func (t *Bool) Set(value bool) (old bool) {
     if value {
-        old = atomic.SwapInt32(&t.val, 1) == 1
+        old = atomic.SwapInt32(&t.value, 1) == 1
     } else {
-        old = atomic.SwapInt32(&t.val, 0) == 1
+        old = atomic.SwapInt32(&t.value, 0) == 1
     }
     return
 }
 
+// Val atomically loads t.valueue.
 func (t *Bool) Val() bool {
-    return atomic.LoadInt32(&t.val) > 0
+    return atomic.LoadInt32(&t.value) > 0
 }

g/container/gtype/byte.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,29 +11,36 @@ import (
 )
 
 type Byte struct {
-    val int32
+	value int32
 }
 
+// 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{val : int32(value[0])}
+        return &Byte{
+	        value : int32(value[0]),
+		}
     }
     return &Byte{}
 }
 
+// Clone clones and returns a new concurrent-safe object for byte type.
 func (t *Byte) Clone() *Byte {
     return NewByte(t.Val())
 }
 
-// 并发安全设置变量值，返回之前的旧值
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Byte) Set(value byte) (old byte) {
-    return byte(atomic.SwapInt32(&t.val, int32(value)))
+    return byte(atomic.SwapInt32(&t.value, int32(value)))
 }
 
+// Val atomically loads t.value.
 func (t *Byte) Val() byte {
-    return byte(atomic.LoadInt32(&t.val))
+    return byte(atomic.LoadInt32(&t.value))
 }
 
-func (t *Byte) Add(delta int) byte {
-    return byte(atomic.AddInt32(&t.val, int32(delta)))
+// 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)))
 }

g/container/gtype/bytes.go

@@ -1,37 +1,43 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
 import "sync/atomic"
 
 type Bytes struct {
-    val atomic.Value
+	value atomic.Value
 }
 
+// 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.val.Store(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())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
+// Note: The parameter <value> cannot be nil.
 func (t *Bytes) Set(value []byte) (old []byte) {
     old = t.Val()
-    t.val.Store(value)
+    t.value.Store(value)
     return
 }
 
+// Val atomically loads t.value.
 func (t *Bytes) Val() []byte {
-    if s := t.val.Load(); s != nil {
+    if s := t.value.Load(); s != nil {
         return s.([]byte)
     }
     return nil

g/container/gtype/float32.go

@@ -1,53 +1,59 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
 import (
-    "sync/atomic"
-    "gitee.com/johng/gf/g/encoding/gbinary"
+	"math"
+	"sync/atomic"
+	"unsafe"
 )
 
 type Float32 struct {
-    val uint32
+	value uint32
 }
 
+// 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{ val : float32ToUint32InBits(value[0]) }
+        return &Float32{
+	        value : math.Float32bits(value[0]),
+		}
     }
     return &Float32{}
 }
 
+// Clone clones and returns a new concurrent-safe object for float32 type.
 func (t *Float32) Clone() *Float32 {
     return NewFloat32(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Float32) Set(value float32) (old float32) {
-    return uint32ToFloat32InBits(atomic.SwapUint32(&t.val, float32ToUint32InBits(value)))
+    return math.Float32frombits(atomic.SwapUint32(&t.value, math.Float32bits(value)))
 }
 
+// Val atomically loads t.value.
 func (t *Float32) Val() float32 {
-    return uint32ToFloat32InBits(atomic.LoadUint32(&t.val))
+    return math.Float32frombits(atomic.LoadUint32(&t.value))
 }
 
-func (t *Float32) Add(delta float32) float32 {
-    return uint32ToFloat32InBits(atomic.AddUint32(&t.val, float32ToUint32InBits(delta)))
-}
-
-// 通过二进制的方式将float32转换为uint32(都是32bits)
-func float32ToUint32InBits(value float32) uint32 {
-    b := gbinary.Encode(value)
-    i := gbinary.DecodeToUint32(b)
-    return i
-}
-
-// 通过二进制的方式将uint32转换为float32(都是32bits)
-func uint32ToFloat32InBits(value uint32) float32 {
-    b := gbinary.Encode(value)
-    f := gbinary.DecodeToFloat32(b)
-    return f
+// Add atomically adds delta to t.value and returns the new value.
+func (t *Float32) Add(delta float32) (new float32) {
+	for {
+		old := math.Float32frombits(t.value)
+		new  = old + delta
+		if atomic.CompareAndSwapUint32(
+			(*uint32)(unsafe.Pointer(&t.value)),
+			math.Float32bits(old),
+			math.Float32bits(new),
+		) {
+			break
+		}
+	}
+	return
 }

g/container/gtype/float64.go

@@ -1,53 +1,59 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
 import (
-    "sync/atomic"
-    "gitee.com/johng/gf/g/encoding/gbinary"
+	"math"
+	"sync/atomic"
+	"unsafe"
 )
 
 type Float64 struct {
-    val uint64
+	value uint64
 }
 
+// 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{ val : float64ToUint64InBits(value[0]) }
+        return &Float64{
+	        value : math.Float64bits(value[0]),
+		}
     }
     return &Float64{}
 }
 
+// Clone clones and returns a new concurrent-safe object for float64 type.
 func (t *Float64) Clone() *Float64 {
     return NewFloat64(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Float64) Set(value float64) (old float64) {
-    return uint64ToFloat64InBits(atomic.SwapUint64(&t.val, float64ToUint64InBits(value)))
+    return math.Float64frombits(atomic.SwapUint64(&t.value, math.Float64bits(value)))
 }
 
+// Val atomically loads t.value.
 func (t *Float64) Val() float64 {
-    return uint64ToFloat64InBits(atomic.LoadUint64(&t.val))
+    return math.Float64frombits(atomic.LoadUint64(&t.value))
 }
 
-func (t *Float64) Add(delta float64) float64 {
-    return uint64ToFloat64InBits(atomic.AddUint64(&t.val, float64ToUint64InBits(delta)))
+// Add atomically adds delta to t.value and returns the new value.
+func (t *Float64) Add(delta float64) (new float64) {
+	for {
+		old := math.Float64frombits(t.value)
+		new  = old + delta
+		if atomic.CompareAndSwapUint64(
+			(*uint64)(unsafe.Pointer(&t.value)),
+			math.Float64bits(old),
+			math.Float64bits(new),
+		) {
+			break
+		}
+	}
+	return
 }
-
-// 通过二进制的方式将float64转换为uint64(都是64bits)
-func float64ToUint64InBits(value float64) uint64 {
-    b := gbinary.Encode(value)
-    i := gbinary.DecodeToUint64(b)
-    return i
-}
-
-// 通过二进制的方式将uint64转换为float64(都是64bits)
-func uint64ToFloat64InBits(value uint64) float64 {
-    b := gbinary.Encode(value)
-    f := gbinary.DecodeToFloat64(b)
-    return f
-}

g/container/gtype/gtype.go

@@ -1,16 +1,15 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
-// Package gtype provides kinds of high performance, concurrent-safe basic variable types.
-//
-// 并发安全基本类型.
+// Package gtype provides kinds of high performance and concurrent-safe basic variable types.
 package gtype
 
 type Type = Interface
 
+// See NewInterface.
 func New(value ... interface{}) *Type {
     return NewInterface(value...)
 }

g/container/gtype/gtype_test.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 
@@ -11,7 +11,7 @@ package gtype
 import (
     "testing"
     "strconv"
-    "gitee.com/johng/gf/g/encoding/gbinary"
+    "github.com/gogf/gf/g/encoding/gbinary"
     "sync/atomic"
 )
 

g/container/gtype/int.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,30 +11,36 @@ import (
 )
 
 type Int struct {
-    val int64
+	value int64
 }
 
+// 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{val:int64(value[0])}
+        return &Int{
+	        value : int64(value[0]),
+		}
     }
     return &Int{}
 }
 
+// Clone clones and returns a new concurrent-safe object for int type.
 func (t *Int) Clone() *Int {
     return NewInt(t.Val())
 }
 
-// 并发安全设置变量值，返回之前的旧值
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Int) Set(value int) (old int) {
-    return int(atomic.SwapInt64(&t.val, int64(value)))
+    return int(atomic.SwapInt64(&t.value, int64(value)))
 }
 
+// Val atomically loads t.value.
 func (t *Int) Val() int {
-    return int(atomic.LoadInt64(&t.val))
+    return int(atomic.LoadInt64(&t.value))
 }
 
-// 数值增加delta，并返回**新**的数值
-func (t *Int) Add(delta int) int {
-    return int(atomic.AddInt64(&t.val, int64(delta)))
+// 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)))
 }

g/container/gtype/int32.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,28 +11,36 @@ import (
 )
 
 type Int32 struct {
-    val int32
+	value int32
 }
 
+// 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{val: value[0]}
+        return &Int32{
+	        value : value[0],
+		}
     }
     return &Int32{}
 }
 
+// Clone clones and returns a new concurrent-safe object for int32 type.
 func (t *Int32) Clone() *Int32 {
     return NewInt32(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Int32) Set(value int32) (old int32) {
-    return atomic.SwapInt32(&t.val, value)
+    return atomic.SwapInt32(&t.value, value)
 }
 
+// Val atomically loads t.value.
 func (t *Int32) Val() int32 {
-    return atomic.LoadInt32(&t.val)
+    return atomic.LoadInt32(&t.value)
 }
 
-func (t *Int32) Add(delta int32) int32 {
-    return atomic.AddInt32(&t.val, delta)
+// 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)
 }

g/container/gtype/int64.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,28 +11,36 @@ import (
 )
 
 type Int64 struct {
-    val int64
+	value int64
 }
 
+// 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{val:value[0]}
+        return &Int64{
+	        value : value[0],
+		}
     }
     return &Int64{}
 }
 
+// Clone clones and returns a new concurrent-safe object for int64 type.
 func (t *Int64) Clone() *Int64 {
     return NewInt64(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Int64) Set(value int64) (old int64) {
-    return atomic.SwapInt64(&t.val, value)
+    return atomic.SwapInt64(&t.value, value)
 }
 
+// Val atomically loads t.value.
 func (t *Int64) Val() int64 {
-    return atomic.LoadInt64(&t.val)
+    return atomic.LoadInt64(&t.value)
 }
 
+// Add atomically adds delta to t.value and returns the new value.
 func (t *Int64) Add(delta int64) int64 {
-    return atomic.AddInt64(&t.val, delta)
+    return atomic.AddInt64(&t.value, delta)
 }

g/container/gtype/interface.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -10,32 +10,34 @@ import (
     "sync/atomic"
 )
 
-// 比较通用的并发安全数据类型
 type Interface struct {
-    val atomic.Value
+	value atomic.Value
 }
 
+// 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.val.Store(value[0])
+        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())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
+// Note: The parameter <value> cannot be nil.
 func (t *Interface) Set(value interface{}) (old interface{}) {
-    if value == nil {
-        return
-    }
     old = t.Val()
-    t.val.Store(value)
+    t.value.Store(value)
     return
 }
 
+// Val atomically loads t.value.
 func (t *Interface) Val() interface{} {
-    return t.val.Load()
+    return t.value.Load()
 }

g/container/gtype/string.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,29 +11,34 @@ import (
 )
 
 type String struct {
-    val atomic.Value
+	value atomic.Value
 }
 
+// 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.val.Store(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())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *String) Set(value string) (old string) {
     old = t.Val()
-    t.val.Store(value)
+    t.value.Store(value)
     return
 }
 
+// Val atomically loads t.value.
 func (t *String) Val() string {
-    s := t.val.Load()
+    s := t.value.Load()
     if s != nil {
         return s.(string)
     }

g/container/gtype/uint.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,28 +11,36 @@ import (
 )
 
 type Uint struct {
-    val uint64
+	value uint64
 }
 
+// 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{val:uint64(value[0])}
+        return &Uint{
+	        value : uint64(value[0]),
+		}
     }
     return &Uint{}
 }
 
+// Clone clones and returns a new concurrent-safe object for uint type.
 func (t *Uint) Clone() *Uint {
     return NewUint(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Uint) Set(value uint) (old uint) {
-    return uint(atomic.SwapUint64(&t.val, uint64(value)))
+    return uint(atomic.SwapUint64(&t.value, uint64(value)))
 }
 
+// Val atomically loads t.value.
 func (t *Uint) Val() uint {
-    return uint(atomic.LoadUint64(&t.val))
+    return uint(atomic.LoadUint64(&t.value))
 }
 
-func (t *Uint) Add(delta uint) int {
-    return int(atomic.AddUint64(&t.val, uint64(delta)))
+// 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)))
 }

g/container/gtype/uint32.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,28 +11,36 @@ import (
 )
 
 type Uint32 struct {
-    val uint32
+	value uint32
 }
 
+// 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{val:value[0]}
+        return &Uint32{
+        	value : value[0],
+		}
     }
     return &Uint32{}
 }
 
+// Clone clones and returns a new concurrent-safe object for uint32 type.
 func (t *Uint32) Clone() *Uint32 {
     return NewUint32(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Uint32) Set(value uint32) (old uint32) {
-    return atomic.SwapUint32(&t.val, value)
+    return atomic.SwapUint32(&t.value, value)
 }
 
+// Val atomically loads t.value.
 func (t *Uint32) Val() uint32 {
-    return atomic.LoadUint32(&t.val)
+    return atomic.LoadUint32(&t.value)
 }
 
-func (t *Uint32) Add(delta uint32) uint32 {
-    return atomic.AddUint32(&t.val, delta)
+// 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)
 }

g/container/gtype/uint64.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gtype
 
@@ -11,28 +11,36 @@ import (
 )
 
 type Uint64 struct {
-    val uint64
+	value uint64
 }
 
+// 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{val:value[0]}
+        return &Uint64{
+	        value : value[0],
+		}
     }
     return &Uint64{}
 }
 
+// Clone clones and returns a new concurrent-safe object for uint64 type.
 func (t *Uint64) Clone() *Uint64 {
     return NewUint64(t.Val())
 }
 
+// Set atomically stores value into t.value and returns the previous t.value value.
 func (t *Uint64) Set(value uint64) (old uint64) {
-    return atomic.SwapUint64(&t.val, value)
+    return atomic.SwapUint64(&t.value, value)
 }
 
+// Val atomically loads t.value.
 func (t *Uint64) Val() uint64 {
-    return atomic.LoadUint64(&t.val)
+    return atomic.LoadUint64(&t.value)
 }
 
-func (t *Uint64) Add(delta uint64) uint64 {
-    return atomic.AddUint64(&t.val, delta)
+// 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)
 }

g/container/gvar/gvar.go

@@ -1,24 +1,22 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gvar provides an universal variable type, like generics.
-//
-// 通用动态变量.
 package gvar
 
 import (
-    "gitee.com/johng/gf/g/container/gtype"
-    "gitee.com/johng/gf/g/os/gtime"
-    "gitee.com/johng/gf/g/util/gconv"
+    "github.com/gogf/gf/g/container/gtype"
+    "github.com/gogf/gf/g/os/gtime"
+    "github.com/gogf/gf/g/util/gconv"
     "time"
 )
 
 type Var struct {
     value interface{} // 变量值
-    safe  bool        // 当为true时,value为 *gtype.Interface 类型
+    safe  bool        // 当为true时, value为 *gtype.Interface 类型
 }
 
 // 创建一个动态变量，value参数可以为nil

g/container/gvar/gvar_read.go

@@ -1,13 +1,13 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 package gvar
 
 import (
-    "gitee.com/johng/gf/g/os/gtime"
+    "github.com/gogf/gf/g/os/gtime"
     "time"
 )
 

g/container/gvar/gvar_z_bench_test.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // go test *.go -bench=".*" -benchmem
 

g/crypto/crypto.go

@@ -1,7 +0,0 @@
-// Copyright 2019 gf Author(https://gitee.com/johng/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://gitee.com/johng/gf.
-
-package crypto

g/crypto/gaes/gaes.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gaes provides useful API for AES encryption/decryption algorithms.
 package gaes
@@ -61,7 +61,10 @@ func Decrypt(cipherText []byte, key []byte, iv...[]byte) ([]byte, error) {
     blockModel := cipher.NewCBCDecrypter(block, ivValue)
     plainText  := make([]byte, len(cipherText))
     blockModel.CryptBlocks(plainText, cipherText)
-    plainText = PKCS5UnPadding(plainText)
+    plainText, e := PKCS5UnPadding(plainText, blockSize)
+	if e != nil {
+		return nil, e
+	}
 
     return plainText, nil
 }
@@ -72,8 +75,27 @@ func PKCS5Padding(src []byte, blockSize int) []byte {
     return append(src, padtext...)
 }
 
-func PKCS5UnPadding(src []byte) []byte {
+func PKCS5UnPadding(src []byte, blockSize int) ([]byte, error) {
     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])
-    return src[:(length - unpadding)]
-}
+	if unpadding > blockSize || unpadding == 0 {
+		return nil, errors.New("invalid padding")
+	}
+
+    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
+}

g/crypto/gaes/gaes_test.go

@@ -0,0 +1,67 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// go test *.go -bench=".*"
+
+package gaes_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/crypto/gaes"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+var (
+	content = []byte("pibigstar")
+	// iv 长度必须等于blockSize，只能为16
+	iv     = []byte("Hello My GoFrame")
+	key_16 = []byte("1234567891234567")
+	key_24 = []byte("123456789123456789123456")
+	key_32 = []byte("12345678912345678912345678912345")
+	keys   = []byte("12345678912345678912345678912346")
+)
+
+func TestEncrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		_, err := gaes.Encrypt(content, key_16)
+		gtest.Assert(err, nil)
+		_, err = gaes.Encrypt(content, key_24)
+		gtest.Assert(err, nil)
+		_, err = gaes.Encrypt(content, key_32)
+		gtest.Assert(err, nil)
+		_, err = gaes.Encrypt(content, key_16, iv)
+		gtest.Assert(err, nil)
+	})
+}
+
+func TestDecrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		encrypt, err := gaes.Encrypt(content, key_16)
+		decrypt, err := gaes.Decrypt(encrypt, key_16)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		encrypt, err = gaes.Encrypt(content, key_24)
+		decrypt, err = gaes.Decrypt(encrypt, key_24)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		encrypt, err = gaes.Encrypt(content, key_32)
+		decrypt, err = gaes.Decrypt(encrypt, key_32)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		encrypt, err = gaes.Encrypt(content, key_32, iv)
+		decrypt, err = gaes.Decrypt(encrypt, key_32, iv)
+		gtest.Assert(err, nil)
+		gtest.Assert(string(decrypt), string(content))
+
+		encrypt, err = gaes.Encrypt(content, key_32, iv)
+		decrypt, err = gaes.Decrypt(encrypt, keys, iv)
+		gtest.Assert(err, "invalid padding")
+	})
+}

g/crypto/gcrc32/gcrc32.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gcrc32 provides useful API for CRC32 encryption/decryption algorithms.
 package gcrc32

g/crypto/gcrc32/gcrc32_test.go

@@ -0,0 +1,27 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// go test *.go -bench=".*"
+
+package gcrc32_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/crypto/gcrc32"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func TestEncrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		s := "pibigstar"
+		result := 693191136
+		encrypt1 := gcrc32.EncryptString(s)
+		encrypt2 := gcrc32.EncryptBytes([]byte(s))
+		gtest.AssertEQ(int(encrypt1), result)
+		gtest.AssertEQ(int(encrypt2), result)
+	})
+}

g/crypto/gdes/gdes.go

@@ -1,8 +1,8 @@
-// Copyright 2018 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// 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.
@@ -262,14 +262,14 @@ func PKCS5Unpadding(text []byte) []byte{
 //补位方法
 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
@@ -278,14 +278,14 @@ func Padding(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,185 +1,239 @@
 package gdes_test
 
 import (
-	"testing"
-	"bytes"
 	"encoding/hex"
-	"fmt"
-	"gitee.com/johng/gf/g/crypto/gdes"
+	"testing"
+
+	"github.com/gogf/gf/g/crypto/gdes"
+	"github.com/gogf/gf/g/test/gtest"
 )
 
-func TestDesECB(t *testing.T){
-	{
+var (
+	errKey     = []byte("1111111111111234123456789")
+	errIv      = []byte("123456789")
+	errPadding = 5
+)
+
+func TestDesECB(t *testing.T) {
+	gtest.Case(t, func() {
 		key := []byte("11111111")
 		text := []byte("12345678")
 		padding := gdes.NOPADDING
+		result := "858b176da8b12503"
+		// encrypt test
 		cipherText, err := gdes.DesECBEncrypt(key, text, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-  
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		gtest.AssertEQ(err, nil)
+		gtest.AssertEQ(string(clearText), "12345678")
 
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
+		// encrypt err test. when throw exception,the err is not equal nil and the string is nil
+		errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		errEncrypt, err = gdes.DesECBEncrypt(errKey, text, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// err decrypt test.
+		errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+		errDecrypt, err = gdes.DesECBDecrypt(key, cipherText, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+	})
 
-	}
-
-	{
+	gtest.Case(t, func() {
 		key := []byte("11111111")
 		text := []byte("12345678")
 		padding := gdes.PKCS5PADDING
+		errPadding := 5
+		result := "858b176da8b12503ad6a88b4fa37833d"
 		cipherText, err := gdes.DesECBEncrypt(key, text, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.DesECBDecrypt(key, cipherText, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(string(clearText),"12345678")
 
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-	}
+		// err test
+		errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		errDecrypt, err := gdes.DesECBDecrypt(errKey, cipherText, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+	})
 }
 
-func Test3DesECB(t *testing.T){
-	{
+func Test3DesECB(t *testing.T) {
+	gtest.Case(t, func() {
 		key := []byte("1111111111111234")
 		text := []byte("1234567812345678")
 		padding := gdes.NOPADDING
+		result := "a23ee24b98c26263a23ee24b98c26263"
+		// encrypt test
 		cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(string(clearText),"1234567812345678")
+		// err test
+		errEncrypt, err := gdes.DesECBEncrypt(key, text, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+	})
 
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-
-	}
-
-	{
+	gtest.Case(t, func() {
 		key := []byte("111111111111123412345678")
 		text := []byte("123456789")
 		padding := gdes.PKCS5PADDING
+		errPadding := 5
+		result := "37989b1effc07a6d00ff89a7d052e79f"
+		// encrypt test
 		cipherText, err := gdes.TripleDesECBEncrypt(key, text, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.TripleDesECBDecrypt(key, cipherText, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-	}
+		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)
+		gtest.AssertEQ(errEncrypt, nil)
+		// when padding is err,but key and text is right
+		errEncrypt, err = gdes.TripleDesECBEncrypt(key, text, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// decrypt err test,when key is err
+		errEncrypt, err = gdes.TripleDesECBDecrypt(errKey, text, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+	})
 }
 
-func TestDesCBC(t *testing.T){
-	{
+func TestDesCBC(t *testing.T) {
+	gtest.Case(t, func() {
 		key := []byte("11111111")
 		text := []byte("1234567812345678")
 		padding := gdes.NOPADDING
 		iv := []byte("12345678")
-		cipherText, err := gdes.DesCBCEncrypt(key, text, iv,padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		result := "40826a5800608c87585ca7c9efabee47"
+		// encrypt test
+		cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		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.AssertEQ(errEncrypt, nil)
+		// the padding is err
+		errEncrypt, err = gdes.DesCBCEncrypt(key, text, iv, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// decrypt err test. the key is err
+		errDecrypt, err := gdes.DesCBCDecrypt(errKey, cipherText, iv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+		// the iv is err
+		errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, errIv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+		// the padding is err
+		errDecrypt, err = gdes.DesCBCDecrypt(key, cipherText, iv, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+	})
 
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-
-	}
-
-	{
+	gtest.Case(t, func() {
 		key := []byte("11111111")
 		text := []byte("12345678")
 		padding := gdes.PKCS5PADDING
 		iv := []byte("12345678")
+		result := "40826a5800608c87100a25d86ac7c52c"
+		// encrypt test
 		cipherText, err := gdes.DesCBCEncrypt(key, text, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.DesCBCDecrypt(key, cipherText, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-	}
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(string(clearText),"12345678")
+		// err test
+		errEncrypt, err := gdes.DesCBCEncrypt(key, text, errIv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+	})
 }
 
-func Test3DesCBC(t *testing.T){
-	{
+func Test3DesCBC(t *testing.T) {
+	gtest.Case(t, func() {
 		key := []byte("1111111112345678")
 		text := []byte("1234567812345678")
 		padding := gdes.NOPADDING
 		iv := []byte("12345678")
-		cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv,padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		result := "bfde1394e265d5f738d5cab170c77c88"
+		// encrypt test
+		cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-
-	}
-
-	{
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(string(clearText),"1234567812345678")
+		// encrypt err test
+		errEncrypt, err := gdes.TripleDesCBCEncrypt(errKey, text, iv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// the iv is err
+		errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, errIv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// the padding is err
+		errEncrypt, err = gdes.TripleDesCBCEncrypt(key, text, iv, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errEncrypt, nil)
+		// decrypt err test
+		errDecrypt, err := gdes.TripleDesCBCDecrypt(errKey, cipherText, iv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+		// the iv is err
+		errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, errIv, padding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+		// the padding is err
+		errDecrypt, err = gdes.TripleDesCBCDecrypt(key, cipherText, iv, errPadding)
+		gtest.AssertNE(err, nil)
+		gtest.AssertEQ(errDecrypt, nil)
+	})
+	gtest.Case(t, func() {
 		key := []byte("111111111234567812345678")
 		text := []byte("12345678")
 		padding := gdes.PKCS5PADDING
 		iv := []byte("12345678")
+		result := "40826a5800608c87100a25d86ac7c52c"
+		// encrypt test
 		cipherText, err := gdes.TripleDesCBCEncrypt(key, text, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
-
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(hex.EncodeToString(cipherText),result)
+		// decrypt test
 		clearText, err := gdes.TripleDesCBCDecrypt(key, cipherText, iv, padding)
-		if err != nil {
-			t.Errorf("%v", err)
-		}
+		gtest.AssertEQ(err,nil)
+		gtest.AssertEQ(string(clearText),"12345678")
+	})
 
-		if bytes.Equal(clearText, text) == false {
-			t.Errorf("text:%v, clearText:%v", hex.EncodeToString(text), hex.EncodeToString(clearText))
-		}
-		fmt.Println("key:", hex.EncodeToString(key),"clearText:", hex.EncodeToString(clearText), "cipherText:", hex.EncodeToString(cipherText))
-	}
-}
+}

g/crypto/gmd5/gmd5.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gmd5 provides useful API for MD5 encryption/decryption algorithms.
 package gmd5
@@ -12,7 +12,7 @@ import (
     "fmt"
     "os"
     "io"
-    "gitee.com/johng/gf/g/util/gconv"
+    "github.com/gogf/gf/g/util/gconv"
 )
 
 // 将任意类型的变量进行md5摘要(注意map等非排序变量造成的不同结果)

g/crypto/gmd5/gmd5_test.go

@@ -0,0 +1,78 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+// go test *.go -bench=".*"
+
+package gmd5_test
+
+import (
+	"os"
+	"testing"
+
+	"github.com/gogf/gf/g/crypto/gmd5"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+var (
+	s = "pibigstar"
+	// online generated MD5 value
+	result = "d175a1ff66aedde64344785f7f7a3df8"
+)
+
+type user struct {
+	name     string
+	password string
+	age      int
+}
+
+func TestEncrypt(t *testing.T) {
+	gtest.Case(t, func() {
+		encryptString := gmd5.Encrypt(s)
+		gtest.Assert(encryptString, result)
+
+		result := "1427562bb29f88a1161590b76398ab72"
+		encrypt := gmd5.Encrypt(123456)
+		gtest.AssertEQ(encrypt,result)
+	})
+
+	gtest.Case(t, func() {
+		user := &user{
+			name:     "派大星",
+			password: "123456",
+			age:      23,
+		}
+		result := "70917ebce8bd2f78c736cda63870fb39"
+		encrypt := gmd5.Encrypt(user)
+		gtest.AssertEQ(encrypt,result)
+	})
+}
+
+func TestEncryptString(t *testing.T) {
+	gtest.Case(t, func() {
+		encryptString := gmd5.EncryptString(s)
+		gtest.Assert(encryptString, result)
+	})
+}
+
+func TestEncryptFile(t *testing.T) {
+	path := "test.text"
+	errorPath := "err.txt"
+	result := "e6e6e1cd41895beebff16d5452dfce12"
+	gtest.Case(t, func() {
+		file, err := os.Create(path)
+		defer os.Remove(path)
+		defer file.Close()
+		gtest.Assert(err, nil)
+		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)
+		gtest.AssertEQ(errEncrypt, "")
+	})
+
+
+}

g/crypto/gsha1/gsha1.go

@@ -1,8 +1,8 @@
-// Copyright 2017 gf Author(https://gitee.com/johng/gf). All Rights Reserved.
+// 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://gitee.com/johng/gf.
+// You can obtain one at https://github.com/gogf/gf.
 
 // Package gsha1 provides useful API for SHA1 encryption/decryption algorithms.
 package gsha1
@@ -12,7 +12,7 @@ import (
     "encoding/hex"
     "os"
     "io"
-    "gitee.com/johng/gf/g/util/gconv"
+    "github.com/gogf/gf/g/util/gconv"
 )
 
 // 将任意类型的变量进行SHA摘要(注意map等非排序变量造成的不同结果)
@@ -34,6 +34,7 @@ func EncryptFile(path string) string {
     if e != nil {
         return ""
     }
+    defer f.Close()
     h := sha1.New()
     _, e = io.Copy(h, f)
     if e != nil {