Merge branch 'master' of https://github.com/gogf/gf

update unit test for gring

README.MD

@@ -5,9 +5,8 @@
 [![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) 
 [![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)
 
 <!--
 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. 
@@ -31,7 +30,7 @@ golang version >= 1.9.2
 
 # Documentation
 
-* [GoDoc](https://godoc.org/github.com/gogf/gf)
+* [APIDoc](https://godoc.org/github.com/gogf/gf)
 * [中文文档](https://goframe.org)
 
 # Architecture
@@ -67,28 +66,33 @@ func main() {
 
 # Contributors
 
-- [johng](https://gitee.com/johng)
-- [zhaopengme](https://github.com/zhaopengme)
-- [wenzi1](https://gitee.com/wenzi1)
-- [zseeker](https://gitee.com/zseeker)
-- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [aloncn](https://github.com/aloncn)
 - [chenyang351](https://github.com/chenyang351)
-- [wxkj](https://gitee.com/wxkj)
-- [wxkj001](https://github.com/wxkj001)
-- [zhangjinfu](https://gitee.com/zhangjinfu)
 - [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://gitee.com/johng)
+- [pibigstar](https://github.com/pibigstar)
 - [qq1054000800](https://gitee.com/qq1054000800)
+- [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
 
-- [tiangenglan](https://gitee.com/tiangenglan)
-- [zhuhuan12](https://gitee.com/zhuhuan12)
-- [zfan_codes](https://gitee.com/zfan_codes)
+- [flyke-xu](https://gitee.com/flyke-xu)
 - [hailaz](https://gitee.com/hailaz)
 - [mg91](https://gitee.com/mg91)
-- [wxkj](https://gitee.com/wxkj)
 - [pibigstar](https://github.com/pibigstar)
-- [flyke-xu](https://gitee.com/flyke-xu)
+- [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

@@ -5,9 +5,8 @@
 [![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) 
 [![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)
 
 `GF(Go Frame)`是一款模块化、松耦合、生产级Go应用开发框架。提供了常用的核心开发组件，如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、数据校验、数据编码、文件监控、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、
 并发安全容器等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、服务注册、配置管理、模板引擎等等，支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
@@ -87,25 +86,29 @@ func main() {
 
 # 贡献者
 
-- [johng](https://gitee.com/johng)
-- [zhaopengme](https://github.com/zhaopengme)
-- [wenzi1](https://gitee.com/wenzi1)
-- [zseeker](https://gitee.com/zseeker)
-- [ymrjqyy](https://gitee.com/ymrjqyy)
+- [aloncn](https://github.com/aloncn)
 - [chenyang351](https://github.com/chenyang351)
-- [wxkj](https://gitee.com/wxkj)
-- [wxkj001](https://github.com/wxkj001)
-- [zhangjinfu](https://gitee.com/zhangjinfu)
 - [garfieldkwong](https://gitee.com/garfieldkwong)
+- [hailaz](https://gitee.com/hailaz)
+- [johng](https://gitee.com/johng)
+- [pibigstar](https://github.com/pibigstar)
 - [qq1054000800](https://gitee.com/qq1054000800)
+- [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)
 
 # 捐赠者
 
-- [tiangenglan](https://gitee.com/tiangenglan)
-- [zhuhuan12](https://gitee.com/zhuhuan12)
-- [zfan_codes](https://gitee.com/zfan_codes)
+- [flyke-xu](https://gitee.com/flyke-xu)
 - [hailaz](https://gitee.com/hailaz)
 - [mg91](https://gitee.com/mg91)
-- [wxkj](https://gitee.com/wxkj)
 - [pibigstar](https://github.com/pibigstar)
-- [flyke-xu](https://gitee.com/flyke-xu)
+- [tiangenglan](https://gitee.com/tiangenglan)
+- [wxkj](https://gitee.com/wxkj)
+- [zhuhuan12](https://gitee.com/zhuhuan12)
+- [zfan_codes](https://gitee.com/zfan_codes)
+

RELEASE.MD

@@ -1,3 +1,51 @@
+# `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)
 
 ## 新特性

TODO.MD

@@ -40,8 +40,9 @@
 1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
 1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
 1. gtcp增加对TLS加密通信的支持；
-
-
+1. 添加Save/Replace/BatchSave/BatchReplace方法对sqlite数据库的支持；
+1. 添加sqlite数据库的单元测试用例；
+1. gredis增加cluster支持；
 
 # DONE
 1.  gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；

g/container/container.go

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

g/container/garray/garray.go

@@ -4,8 +4,6 @@
 // If a copy of the MIT was not distributed with this file,
 // 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
 

g/container/gchan/gchan.go

@@ -4,9 +4,9 @@
 // If a copy of the MIT was not distributed with this file,
 // 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 (
@@ -15,39 +15,48 @@ import (
 )
 
 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/glist/glist.go

@@ -5,9 +5,7 @@
 // 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 (
@@ -15,14 +13,14 @@ import (
     "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/gmap/gmap.go

@@ -4,46 +4,34 @@
 // 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
 
 import "github.com/gogf/gf/g/internal/rwmutex"
 
-// 注意:
-// 1、这个Map是所有并发安全Map中效率最低的，如果对效率要求比较高的场合，请合理选择对应数据类型的Map；
-// 2、这个Map的优点是使用简便，由于键值都是interface{}类型，因此对键值的数据类型要求不高；
-// 3、底层实现比较类似于sync.Map；
 type Map struct {
     mu *rwmutex.RWMutex
     m  map[interface{}]interface{}
 }
 
-// Create an empty hash map.
+// 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 in default.
-//
-// 创建一个空的哈希表，参数unsafe用于指定是否用于非并发安全场景，默认为false，表示并发安全。
-func New(unsafe...bool) *Map {
+// which is false in default, means concurrent-safe.
+func New(unsafe ...bool) *Map {
     return NewMap(unsafe...)
 }
 
-// See New.
-//
-// 同New方法。
-func NewMap(unsafe...bool) *Map {
+// Alias of New. See New.
+func NewMap(unsafe ...bool) *Map {
     return &Map{
         m  : make(map[interface{}]interface{}),
         mu : rwmutex.New(unsafe...),
     }
 }
 
-// Create a hash map from given map.
-// Be aware that, the param map is a type of pointer,
+// 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.
-//
-// 基于给定的map变量创建哈希表对象，注意由于map是指针类型，外部对map有操作时会有并发安全问题。
 func NewFrom(m map[interface{}]interface{}, unsafe...bool) *Map {
     return &Map{
         m  : m,
@@ -51,12 +39,12 @@ func NewFrom(m map[interface{}]interface{}, unsafe...bool) *Map {
     }
 }
 
-// Create a hash map from given arrays.
+// NewFromArray returns a hash map from given array.
 // The param <keys> given as the keys of the map,
-// and <values> as the corresponding values.
+// and <values> as its corresponding values.
 //
-// 基于给定的数组变量创建哈希表对象，keys作为键名, values作为键值。
-// 当keys数组大小比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)
@@ -73,10 +61,8 @@ func NewFromArray(keys []interface{}, values []interface{}, unsafe...bool) *Map
     }
 }
 
-// Iterate the hash map with custom callback function <f>.
+// Iterator iterates the hash map with custom callback function <f>.
 // If f returns true, then continue iterating; or false to stop.
-//
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
 func (gm *Map) Iterator(f func (k interface{}, v interface{}) bool) {
     gm.mu.RLock()
     defer gm.mu.RUnlock()
@@ -87,17 +73,12 @@ func (gm *Map) Iterator(f func (k interface{}, v interface{}) bool) {
     }
 }
 
-// Clone current hash map with copy of underlying data,
-// return a new hash map.
-//
-// 哈希表克隆.
-func (gm *Map) Clone() *Map {
-    return NewFrom(gm.Map(), !gm.mu.IsSafe())
+// Clone returns a new hash map with copy of current map data.
+func (gm *Map) Clone(unsafe ...bool) *Map {
+    return NewFrom(gm.Map(), unsafe ...)
 }
 
-// Returns copy of the data of the hash map.
-//
-// 返回当前哈希表的数据Map.
+// 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()
@@ -108,18 +89,14 @@ func (gm *Map) Map() map[interface{}]interface{} {
     return m
 }
 
-// Set key-value to the hash map.
-//
-// 设置键值对
+// 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()
 }
 
-// Batch set key-values to the hash map.
-//
-// 批量设置键值对
+// 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 {
@@ -128,9 +105,7 @@ func (gm *Map) BatchSet(m map[interface{}]interface{}) {
     gm.mu.Unlock()
 }
 
-// Get value by key.
-//
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *Map) Get(key interface{}) interface{} {
     gm.mu.RLock()
     val, _ := gm.m[key]
@@ -138,8 +113,15 @@ func (gm *Map) Get(key interface{}) interface{} {
     return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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()
@@ -153,9 +135,8 @@ func (gm *Map) doSetWithLockCheck(key interface{}, value interface{}) interface{
     return value
 }
 
-// Get the value by key, or set it with given key-value if not exist.
-//
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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)
@@ -164,9 +145,9 @@ func (gm *Map) GetOrSet(key interface{}, value interface{}) interface{} {
     }
 }
 
-// Get the value by key, or set the it with return of callback function <f> if not exist.
-//
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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())
@@ -175,10 +156,12 @@ func (gm *Map) GetOrSetFunc(key interface{}, f func() interface{}) interface{} {
     }
 }
 
-// Get the value by key, or set the it with return of callback function <f> if not exist.
-// The difference with GetOrSetFunc is, it locks in executing callback function <f>.
+// GetOrSetFuncLock returns the value by key,
+// or sets value with return value of callback function <f> if not exist
+// and returns this value.
 //
-// 与GetOrSetFunc不同的是，f是在写锁机制内执行
+// 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)
@@ -187,9 +170,8 @@ func (gm *Map) GetOrSetFuncLock(key interface{}, f func() interface{}) interface
     }
 }
 
-// Set key-value if the key does not exist, then return true; or else return false.
-//
-// 当键名不存在时写入，并返回true；否则返回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 *Map) SetIfNotExist(key interface{}, value interface{}) bool {
     if !gm.Contains(key) {
         gm.doSetWithLockCheck(key, value)
@@ -198,9 +180,30 @@ func (gm *Map) SetIfNotExist(key interface{}, value interface{}) bool {
     return false
 }
 
-// Batch remove by keys.
+// 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 {
@@ -209,9 +212,7 @@ func (gm *Map) BatchRemove(keys []interface{}) {
     gm.mu.Unlock()
 }
 
-// Remove by given key.
-//
-// 返回对应的键值，并删除该键值
+// 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]
@@ -222,9 +223,7 @@ func (gm *Map) Remove(key interface{}) interface{} {
     return val
 }
 
-// Return all the keys of hash map as a slice.
-//
-// 返回键列表.
+// Keys returns all keys of the map as a slice.
 func (gm *Map) Keys() []interface{} {
     gm.mu.RLock()
     keys := make([]interface{}, 0)
@@ -235,9 +234,7 @@ func (gm *Map) Keys() []interface{} {
     return keys
 }
 
-// Return all the values of hash map as a slice.
-//
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *Map) Values() []interface{} {
     gm.mu.RLock()
     vals := make([]interface{}, 0)
@@ -248,9 +245,8 @@ func (gm *Map) Values() []interface{} {
     return vals
 }
 
-// Check whether a key exist.
-//
-// 是否存在某个键
+// 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]
@@ -258,9 +254,7 @@ func (gm *Map) Contains(key interface{}) bool {
     return exists
 }
 
-// Get the size of hash map.
-//
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *Map) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -268,9 +262,8 @@ func (gm *Map) Size() int {
     return length
 }
 
-// Check whether the hash map is empty.
-//
-// 哈希表是否为空
+// 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
@@ -278,36 +271,28 @@ func (gm *Map) IsEmpty() bool {
     return empty
 }
 
-// Clear the hash map, it will remake a new underlying map data map.
-//
-// 清空哈希表
+// 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()
 }
 
-// Lock writing with given callback <f>.
-//
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// Lock reading with given callback <f>.
-//
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// Exchange key-value in the hash map, it will change key-value to value-key.
-//
-// 交换Map中的键和值.
+// 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()
@@ -318,17 +303,16 @@ func (gm *Map) Flip() {
     gm.m = n
 }
 
-// Merge two hash maps.
-//
-// 合并两个Map.
-func (gm *Map) Merge(m *Map) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_int_bool_map.go

@@ -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,6 +26,9 @@ func NewIntBoolMap(unsafe...bool) *IntBoolMap {
     }
 }
 
+// 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,
@@ -30,6 +36,12 @@ func NewIntBoolMapFrom(m map[int]bool, unsafe...bool) *IntBoolMap {
     }
 }
 
+// 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)
@@ -46,12 +58,12 @@ func NewIntBoolMapFromArray(keys []int, values []bool, unsafe...bool) *IntBoolMa
     }
 }
 
-// 哈希表克隆.
+// 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.
+// Map returns a copy of the data of the hash map.
 func (gm *IntBoolMap) Map() map[int]bool {
 	m := make(map[int]bool)
 	gm.mu.RLock()
@@ -62,7 +74,8 @@ func (gm *IntBoolMap) Map() map[int]bool {
 	return m
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -73,14 +86,14 @@ func (gm *IntBoolMap) Iterator(f func (k int, v bool) bool) {
     }
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -89,7 +102,7 @@ func (gm *IntBoolMap) BatchSet(m map[int]bool) {
 	gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntBoolMap) Get(key int) bool {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -97,8 +110,11 @@ func (gm *IntBoolMap) Get(key int) bool {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -110,7 +126,8 @@ func (gm *IntBoolMap) doSetWithLockCheck(key int, value bool) bool {
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -122,7 +139,8 @@ func (gm *IntBoolMap) GetOrSet(key int, value bool) bool {
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -134,7 +152,11 @@ func (gm *IntBoolMap) GetOrSetFunc(key int, f func() bool) bool {
     }
 }
 
-// 与GetOrSetFunc不同的是，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 *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
     gm.mu.RLock()
     val, ok := gm.m[key]
@@ -143,10 +165,9 @@ func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
         gm.mu.Lock()
         defer gm.mu.Unlock()
         if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
             return v
         }
-        val         = f()
+        val       = f()
         gm.m[key] = val
         return val
     } else {
@@ -154,7 +175,8 @@ func (gm *IntBoolMap) GetOrSetFuncLock(key int, f func() bool) bool {
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *IntBoolMap) SetIfNotExist(key int, value bool) bool {
     if !gm.Contains(key) {
         gm.doSetWithLockCheck(key, value)
@@ -163,7 +185,34 @@ func (gm *IntBoolMap) SetIfNotExist(key int, value bool) bool {
     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 *IntBoolMap) SetIfNotExistFunc(key int, f func() bool) 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 *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 {
@@ -172,7 +221,7 @@ func (gm *IntBoolMap) BatchRemove(keys []int) {
     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]
@@ -183,7 +232,7 @@ func (gm *IntBoolMap) Remove(key int) bool {
     return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntBoolMap) Keys() []int {
     gm.mu.RLock()
     keys := make([]int, 0)
@@ -194,18 +243,8 @@ func (gm *IntBoolMap) Keys() []int {
     return keys
 }
 
-// 返回值列表(注意是随机排序)
-//func (gm *IntBoolMap) Values() []bool {
-//    gm.mu.RLock()
-//    vals := make([]bool, 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 *IntBoolMap) Contains(key int) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@@ -213,7 +252,7 @@ func (gm *IntBoolMap) Contains(key int) bool {
 	return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntBoolMap) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -221,7 +260,8 @@ func (gm *IntBoolMap) Size() int {
     return length
 }
 
-// 哈希表是否为空
+// 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
@@ -229,36 +269,37 @@ func (gm *IntBoolMap) IsEmpty() bool {
     return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 合并两个Map.
-func (gm *IntBoolMap) Merge(m *IntBoolMap) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_int_int_map.go

@@ -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,6 +26,9 @@ func NewIntIntMap(unsafe...bool) *IntIntMap {
     }
 }
 
+// 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,
@@ -30,6 +36,12 @@ func NewIntIntMapFrom(m map[int]int, unsafe...bool) *IntIntMap {
     }
 }
 
+// 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)
@@ -46,7 +58,8 @@ func NewIntIntMapFromArray(keys []int, values []int, unsafe...bool) *IntIntMap {
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -57,12 +70,12 @@ func (gm *IntIntMap) Iterator(f func (k int, v int) bool) {
     }
 }
 
-// 哈希表克隆.
+// 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.
+// Map returns a copy of the data of the hash map.
 func (gm *IntIntMap) Map() map[int]int {
 	m := make(map[int]int)
 	gm.mu.RLock()
@@ -73,14 +86,14 @@ func (gm *IntIntMap) Map() map[int]int {
 	return m
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -89,7 +102,7 @@ func (gm *IntIntMap) BatchSet(m map[int]int) {
 	gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntIntMap) Get(key int) (int) {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -97,8 +110,11 @@ func (gm *IntIntMap) Get(key int) (int) {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -110,7 +126,8 @@ func (gm *IntIntMap) doSetWithLockCheck(key int, value int) int {
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -122,7 +139,8 @@ func (gm *IntIntMap) GetOrSet(key int, value int) int {
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -134,7 +152,11 @@ func (gm *IntIntMap) GetOrSetFunc(key int, f func() int) int {
     }
 }
 
-// 与GetOrSetFunc不同的是，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 *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
     gm.mu.RLock()
     val, ok := gm.m[key]
@@ -143,7 +165,6 @@ func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
         gm.mu.Lock()
         defer gm.mu.Unlock()
         if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
             return v
         }
         val         = f()
@@ -154,7 +175,8 @@ func (gm *IntIntMap) GetOrSetFuncLock(key int, f func() int) int {
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *IntIntMap) SetIfNotExist(key int, value int) bool {
     if !gm.Contains(key) {
         gm.doSetWithLockCheck(key, value)
@@ -163,7 +185,34 @@ func (gm *IntIntMap) SetIfNotExist(key int, value int) bool {
     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 *IntIntMap) SetIfNotExistFunc(key int, f func() int) 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 *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 {
@@ -172,7 +221,7 @@ func (gm *IntIntMap) BatchRemove(keys []int) {
     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]
@@ -183,7 +232,7 @@ func (gm *IntIntMap) Remove(key int) int {
     return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntIntMap) Keys() []int {
     gm.mu.RLock()
     keys := make([]int, 0)
@@ -194,7 +243,7 @@ func (gm *IntIntMap) Keys() []int {
     return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntIntMap) Values() []int {
     gm.mu.RLock()
     vals := make([]int, 0)
@@ -205,7 +254,8 @@ func (gm *IntIntMap) Values() []int {
     return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -213,7 +263,7 @@ func (gm *IntIntMap) Contains(key int) bool {
     return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntIntMap) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -221,7 +271,8 @@ func (gm *IntIntMap) Size() int {
     return length
 }
 
-// 哈希表是否为空
+// 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
@@ -229,28 +280,28 @@ func (gm *IntIntMap) IsEmpty() bool {
     return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -261,15 +312,16 @@ func (gm *IntIntMap) Flip() {
     gm.m = n
 }
 
-// 合并两个Map.
-func (gm *IntIntMap) Merge(m *IntIntMap) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_int_interface_map.go

@@ -17,6 +17,9 @@ type IntInterfaceMap struct {
 	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{}),
@@ -24,6 +27,9 @@ func NewIntInterfaceMap(unsafe...bool) *IntInterfaceMap {
     }
 }
 
+// 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,
@@ -31,6 +37,12 @@ func NewIntInterfaceMapFrom(m map[int]interface{}, unsafe...bool) *IntInterfaceM
     }
 }
 
+// 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)
@@ -47,7 +59,8 @@ func NewIntInterfaceMapFromArray(keys []int, values []interface{}, unsafe...bool
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -58,12 +71,12 @@ func (gm *IntInterfaceMap) Iterator(f func (k int, v interface{}) bool) {
     }
 }
 
-// 哈希表克隆.
+// 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.
+// Map returns a copy of the data of the hash map.
 func (gm *IntInterfaceMap) Map() map[int]interface{} {
 	m := make(map[int]interface{})
 	gm.mu.RLock()
@@ -74,14 +87,14 @@ func (gm *IntInterfaceMap) Map() map[int]interface{} {
 	return m
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -90,7 +103,7 @@ func (gm *IntInterfaceMap) BatchSet(m map[int]interface{}) {
 	gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntInterfaceMap) Get(key int) (interface{}) {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -98,8 +111,16 @@ func (gm *IntInterfaceMap) Get(key int) (interface{}) {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+
+// 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()
@@ -115,7 +136,8 @@ func (gm *IntInterfaceMap) doSetWithLockCheck(key int, value interface{}) interf
     return 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)
@@ -124,7 +146,8 @@ func (gm *IntInterfaceMap) GetOrSet(key int, value interface{}) interface{} {
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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())
@@ -133,7 +156,11 @@ func (gm *IntInterfaceMap) GetOrSetFunc(key int, f func() interface{}) interface
     }
 }
 
-// 与GetOrSetFunc不同的是，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)
@@ -142,7 +169,8 @@ func (gm *IntInterfaceMap) GetOrSetFuncLock(key int, f func() interface{}) inter
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
     if !gm.Contains(key) {
         gm.doSetWithLockCheck(key, value)
@@ -151,7 +179,31 @@ func (gm *IntInterfaceMap) SetIfNotExist(key int, value interface{}) bool {
     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 *IntInterfaceMap) SetIfNotExistFunc(key int, 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 *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 {
@@ -160,7 +212,7 @@ func (gm *IntInterfaceMap) BatchRemove(keys []int) {
     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]
@@ -171,7 +223,7 @@ func (gm *IntInterfaceMap) Remove(key int) interface{} {
     return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntInterfaceMap) Keys() []int {
     gm.mu.RLock()
     keys := make([]int, 0)
@@ -182,7 +234,7 @@ func (gm *IntInterfaceMap) Keys() []int {
     return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntInterfaceMap) Values() []interface{} {
     gm.mu.RLock()
     vals := make([]interface{}, 0)
@@ -193,7 +245,8 @@ func (gm *IntInterfaceMap) Values() []interface{} {
     return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -201,7 +254,7 @@ func (gm *IntInterfaceMap) Contains(key int) bool {
     return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntInterfaceMap) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -209,7 +262,8 @@ func (gm *IntInterfaceMap) Size() int {
     return length
 }
 
-// 哈希表是否为空
+// 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
@@ -217,28 +271,28 @@ func (gm *IntInterfaceMap) IsEmpty() bool {
     return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -249,15 +303,16 @@ func (gm *IntInterfaceMap) Flip() {
     gm.m = n
 }
 
-// 合并两个Map.
-func (gm *IntInterfaceMap) Merge(m *IntInterfaceMap) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_int_string_map.go

@@ -17,6 +17,9 @@ type IntStringMap struct {
 	m  map[int]string
 }
 
+// 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),
@@ -24,6 +27,9 @@ func NewIntStringMap(unsafe...bool) *IntStringMap {
     }
 }
 
+// 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,
@@ -31,6 +37,12 @@ func NewIntStringMapFrom(m map[int]string, unsafe...bool) *IntStringMap {
     }
 }
 
+// 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)
     l := len(values)
@@ -47,7 +59,8 @@ func NewIntStringMapFromArray(keys []int, values []string, unsafe...bool) *IntSt
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -58,12 +71,12 @@ func (gm *IntStringMap) Iterator(f func (k int, v string) bool) {
     }
 }
 
-// 哈希表克隆.
+// 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.
+// 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()
@@ -74,14 +87,14 @@ func (gm *IntStringMap) Map() map[int]string {
 	return m
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -90,7 +103,7 @@ func (gm *IntStringMap) BatchSet(m map[int]string) {
 	gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *IntStringMap) Get(key int) string {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -98,8 +111,11 @@ func (gm *IntStringMap) Get(key int) string {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -111,7 +127,8 @@ func (gm *IntStringMap) doSetWithLockCheck(key int, value string) string {
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -123,7 +140,8 @@ func (gm *IntStringMap) GetOrSet(key int, value string) string {
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -135,7 +153,11 @@ func (gm *IntStringMap) GetOrSetFunc(key int, f func() string) string {
     }
 }
 
-// 与GetOrSetFunc不同的是，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 *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
     gm.mu.RLock()
     val, ok := gm.m[key]
@@ -144,10 +166,9 @@ func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
         gm.mu.Lock()
         defer gm.mu.Unlock()
         if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
             return v
         }
-        val         = f()
+        val       = f()
         gm.m[key] = val
         return val
     } else {
@@ -155,7 +176,8 @@ func (gm *IntStringMap) GetOrSetFuncLock(key int, f func() string) string {
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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)
@@ -164,7 +186,35 @@ func (gm *IntStringMap) SetIfNotExist(key int, value string) bool {
     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 *IntStringMap) SetIfNotExistFunc(key int, f func() string) 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 *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
+}
+
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *IntStringMap) BatchRemove(keys []int) {
     gm.mu.Lock()
     for _, key := range keys {
@@ -173,7 +223,7 @@ func (gm *IntStringMap) BatchRemove(keys []int) {
     gm.mu.Unlock()
 }
 
-// 返回对应的键值，并删除该键值
+// 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]
@@ -184,7 +234,7 @@ func (gm *IntStringMap) Remove(key int) string {
     return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *IntStringMap) Keys() []int {
     gm.mu.RLock()
     keys := make([]int, 0)
@@ -195,7 +245,7 @@ func (gm *IntStringMap) Keys() []int {
     return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *IntStringMap) Values() []string {
     gm.mu.RLock()
     vals := make([]string, 0)
@@ -206,7 +256,8 @@ func (gm *IntStringMap) Values() []string {
     return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -214,7 +265,7 @@ func (gm *IntStringMap) Contains(key int) bool {
     return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *IntStringMap) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -222,7 +273,8 @@ func (gm *IntStringMap) Size() int {
     return length
 }
 
-// 哈希表是否为空
+// 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
@@ -230,28 +282,28 @@ func (gm *IntStringMap) IsEmpty() bool {
     return empty
 }
 
-// 清空哈希表
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -262,15 +314,16 @@ func (gm *IntStringMap) Flip() {
     gm.m = n
 }
 
-// 合并两个Map.
-func (gm *IntStringMap) Merge(m *IntStringMap) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_string_bool_map.go

@@ -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,6 +26,9 @@ func NewStringBoolMap(unsafe...bool) *StringBoolMap {
 	}
 }
 
+// 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,
@@ -30,6 +36,12 @@ func NewStringBoolMapFrom(m map[string]bool, unsafe...bool) *StringBoolMap {
     }
 }
 
+// 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)
@@ -46,7 +58,8 @@ func NewStringBoolMapFromArray(keys []string, values []bool, unsafe...bool) *Str
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -57,12 +70,12 @@ func (gm *StringBoolMap) Iterator(f func (k string, v bool) 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.
+// Map returns a copy of the data of the hash map.
 func (gm *StringBoolMap) Map() map[string]bool {
     m := make(map[string]bool)
     gm.mu.RLock()
@@ -73,14 +86,14 @@ func (gm *StringBoolMap) Map() map[string]bool {
     return m
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -89,7 +102,7 @@ func (gm *StringBoolMap) BatchSet(m map[string]bool) {
     gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringBoolMap) Get(key string) bool {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -97,8 +110,11 @@ func (gm *StringBoolMap) Get(key string) bool {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -110,7 +126,8 @@ func (gm *StringBoolMap) doSetWithLockCheck(key string, value bool) bool {
 	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -122,7 +139,9 @@ func (gm *StringBoolMap) GetOrSet(key string, value bool) bool {
 	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -134,7 +153,12 @@ func (gm *StringBoolMap) GetOrSetFunc(key string, f func() bool) bool {
 	}
 }
 
-// 与GetOrSetFunc不同的是，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 *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 	gm.mu.RLock()
 	val, ok := gm.m[key]
@@ -143,7 +167,6 @@ func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 		gm.mu.Lock()
 		defer gm.mu.Unlock()
 		if v, ok := gm.m[key]; ok {
-			gm.mu.Unlock()
 			return v
 		}
 		val         = f()
@@ -154,7 +177,9 @@ func (gm *StringBoolMap) GetOrSetFuncLock(key string, f func() bool) bool {
 	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *StringBoolMap) SetIfNotExist(key string, value bool) bool {
 	if !gm.Contains(key) {
 		gm.doSetWithLockCheck(key, value)
@@ -163,7 +188,34 @@ func (gm *StringBoolMap) SetIfNotExist(key string, value bool) bool {
 	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 *StringBoolMap) SetIfNotExistFunc(key string, f func() bool) 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 *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
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringBoolMap) BatchRemove(keys []string) {
     gm.mu.Lock()
     for _, key := range keys {
@@ -172,7 +224,7 @@ func (gm *StringBoolMap) BatchRemove(keys []string) {
     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]
@@ -183,7 +235,7 @@ func (gm *StringBoolMap) Remove(key string) bool {
 	return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringBoolMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@@ -194,18 +246,8 @@ func (gm *StringBoolMap) Keys() []string {
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
-//func (gm *StringBoolMap) Values() []bool {
-//	gm.mu.RLock()
-//	vals := make([]bool, 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 *StringBoolMap) Contains(key string) bool {
 	gm.mu.RLock()
 	_, exists := gm.m[key]
@@ -213,7 +255,7 @@ func (gm *StringBoolMap) Contains(key string) bool {
 	return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringBoolMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@@ -221,7 +263,8 @@ func (gm *StringBoolMap) Size() int {
 	return length
 }
 
-// 哈希表是否为空
+// 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
@@ -229,36 +272,37 @@ func (gm *StringBoolMap) IsEmpty() bool {
 	return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 合并两个Map.
-func (gm *StringBoolMap) Merge(m *StringBoolMap) {
+// 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 m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }

g/container/gmap/gmap_string_int_map.go

@@ -17,6 +17,9 @@ type StringIntMap struct {
 	m  map[string]int
 }
 
+// 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),
@@ -24,6 +27,9 @@ func NewStringIntMap(unsafe...bool) *StringIntMap {
     }
 }
 
+// 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,
@@ -31,6 +37,12 @@ func NewStringIntMapFrom(m map[string]int, unsafe...bool) *StringIntMap {
     }
 }
 
+// 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)
@@ -47,7 +59,8 @@ func NewStringIntMapFromArray(keys []string, values []int, unsafe...bool) *Strin
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -58,12 +71,12 @@ func (gm *StringIntMap) Iterator(f func (k string, v int) bool) {
     }
 }
 
-// 哈希表克隆.
+// 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.
+// 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()
@@ -74,14 +87,14 @@ func (gm *StringIntMap) Map() map[string]int {
     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 {
@@ -90,7 +103,7 @@ func (gm *StringIntMap) BatchSet(m map[string]int) {
 	gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringIntMap) Get(key string) int {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -98,8 +111,11 @@ func (gm *StringIntMap) Get(key string) int {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -111,7 +127,8 @@ func (gm *StringIntMap) doSetWithLockCheck(key string, value int) int {
     return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -123,7 +140,9 @@ func (gm *StringIntMap) GetOrSet(key string, value int) int {
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -135,7 +154,12 @@ func (gm *StringIntMap) GetOrSetFunc(key string, f func() int) int {
     }
 }
 
-// 与GetOrSetFunc不同的是，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 *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
     gm.mu.RLock()
     val, ok := gm.m[key]
@@ -144,10 +168,9 @@ func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
         gm.mu.Lock()
         defer gm.mu.Unlock()
         if v, ok := gm.m[key]; ok {
-            gm.mu.Unlock()
             return v
         }
-        val         = f()
+        val       = f()
         gm.m[key] = val
         return val
     } else {
@@ -155,7 +178,8 @@ func (gm *StringIntMap) GetOrSetFuncLock(key string, f func() int) int {
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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)
@@ -164,7 +188,34 @@ func (gm *StringIntMap) SetIfNotExist(key string, value int) bool {
     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 *StringIntMap) SetIfNotExistFunc(key string, f func() int) 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 *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
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringIntMap) BatchRemove(keys []string) {
     gm.mu.Lock()
     for _, key := range keys {
@@ -173,7 +224,7 @@ func (gm *StringIntMap) BatchRemove(keys []string) {
     gm.mu.Unlock()
 }
 
-// 返回对应的键值，并删除该键值
+// 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]
@@ -184,7 +235,7 @@ func (gm *StringIntMap) Remove(key string) int {
     return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringIntMap) Keys() []string {
     gm.mu.RLock()
     keys := make([]string, 0)
@@ -195,7 +246,7 @@ func (gm *StringIntMap) Keys() []string {
     return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringIntMap) Values() []int {
     gm.mu.RLock()
     vals := make([]int, 0)
@@ -206,7 +257,8 @@ func (gm *StringIntMap) Values() []int {
     return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -214,7 +266,7 @@ func (gm *StringIntMap) Contains(key string) bool {
     return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringIntMap) Size() int {
     gm.mu.RLock()
     length := len(gm.m)
@@ -222,7 +274,8 @@ func (gm *StringIntMap) Size() int {
     return length
 }
 
-// 哈希表是否为空
+// 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
@@ -230,28 +283,28 @@ func (gm *StringIntMap) IsEmpty() bool {
     return empty
 }
 
-// 清空哈希表
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -262,15 +315,16 @@ func (gm *StringIntMap) Flip() {
     gm.m = n
 }
 
-// 合并两个Map.
-func (gm *StringIntMap) Merge(m *StringIntMap) {
+// 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 m != gm {
-        m.mu.RLock()
-        defer m.mu.RUnlock()
+    if other != gm {
+	    other.mu.RLock()
+        defer other.mu.RUnlock()
     }
-    for k, v := range m.m {
+    for k, v := range other.m {
         gm.m[k] = v
     }
 }

g/container/gmap/gmap_string_interface_map.go

@@ -17,6 +17,9 @@ type StringInterfaceMap struct {
 	m  map[string]interface{}
 }
 
+// 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{}),
@@ -24,6 +27,9 @@ func NewStringInterfaceMap(unsafe...bool) *StringInterfaceMap {
 	}
 }
 
+// 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,
@@ -31,6 +37,12 @@ func NewStringInterfaceMapFrom(m map[string]interface{}, unsafe...bool) *StringI
     }
 }
 
+// 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)
@@ -47,7 +59,8 @@ func NewStringInterfaceMapFromArray(keys []string, values []interface{}, unsafe.
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -58,12 +71,12 @@ func (gm *StringInterfaceMap) Iterator(f func (k string, v interface{}) bool) {
 	}
 }
 
-// 哈希表克隆.
+// Clone returns a new hash map with copy of current map data.
 func (gm *StringInterfaceMap) Clone() *StringInterfaceMap {
     return NewStringInterfaceMapFrom(gm.Map(), !gm.mu.IsSafe())
 }
 
-// 返回当前哈希表的数据Map.
+// 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()
@@ -74,14 +87,14 @@ func (gm *StringInterfaceMap) Map() map[string]interface{} {
     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 {
@@ -90,7 +103,7 @@ func (gm *StringInterfaceMap) BatchSet(m map[string]interface{}) {
     gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringInterfaceMap) Get(key string) interface{} {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -98,8 +111,15 @@ func (gm *StringInterfaceMap) Get(key string) interface{} {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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()
@@ -115,7 +135,8 @@ func (gm *StringInterfaceMap) doSetWithLockCheck(key string, value interface{})
     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)
@@ -124,7 +145,9 @@ func (gm *StringInterfaceMap) GetOrSet(key string, value interface{}) interface{
     }
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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())
@@ -133,7 +156,12 @@ func (gm *StringInterfaceMap) GetOrSetFunc(key string, f func() interface{}) int
     }
 }
 
-// 与GetOrSetFunc不同的是，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 *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{}) interface{} {
     if v := gm.Get(key); v == nil {
         return gm.doSetWithLockCheck(key, f)
@@ -142,7 +170,8 @@ func (gm *StringInterfaceMap) GetOrSetFuncLock(key string, f func() interface{})
     }
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool {
     if !gm.Contains(key) {
         gm.doSetWithLockCheck(key, value)
@@ -151,7 +180,30 @@ func (gm *StringInterfaceMap) SetIfNotExist(key string, value interface{}) bool
     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 {
@@ -160,7 +212,7 @@ func (gm *StringInterfaceMap) BatchRemove(keys []string) {
     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]
@@ -171,7 +223,7 @@ func (gm *StringInterfaceMap) Remove(key string) interface{} {
 	return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringInterfaceMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@@ -182,7 +234,7 @@ func (gm *StringInterfaceMap) Keys() []string {
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringInterfaceMap) Values() []interface{} {
 	gm.mu.RLock()
 	vals := make([]interface{}, 0)
@@ -193,7 +245,8 @@ func (gm *StringInterfaceMap) Values() []interface{} {
 	return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -201,7 +254,7 @@ func (gm *StringInterfaceMap) Contains(key string) bool {
 	return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringInterfaceMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@@ -209,7 +262,8 @@ func (gm *StringInterfaceMap) Size() int {
 	return length
 }
 
-// 哈希表是否为空
+// 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
@@ -217,28 +271,28 @@ func (gm *StringInterfaceMap) IsEmpty() bool {
 	return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -249,15 +303,16 @@ func (gm *StringInterfaceMap) Flip() {
 	gm.m = n
 }
 
-// 合并两个Map.
-func (gm *StringInterfaceMap) Merge(m *StringInterfaceMap) {
+// 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 m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }

g/container/gmap/gmap_string_string_map.go

@@ -16,6 +16,9 @@ type StringStringMap struct {
 	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),
@@ -23,6 +26,9 @@ func NewStringStringMap(unsafe...bool) *StringStringMap {
 	}
 }
 
+// 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,
@@ -30,6 +36,12 @@ func NewStringStringMapFrom(m map[string]string, unsafe...bool) *StringStringMap
     }
 }
 
+// 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)
@@ -46,7 +58,8 @@ func NewStringStringMapFromArray(keys []string, values []string, unsafe...bool)
     }
 }
 
-// 给定回调函数对原始内容进行遍历，回调函数返回true表示继续遍历，否则停止遍历
+// 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()
@@ -57,12 +70,12 @@ func (gm *StringStringMap) Iterator(f func (k string, v string) bool) {
 	}
 }
 
-// 哈希表克隆.
+// 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.
+// Map returns a copy of the data of the hash map.
 func (gm *StringStringMap) Map() map[string]string {
     m := make(map[string]string)
     gm.mu.RLock()
@@ -73,14 +86,14 @@ func (gm *StringStringMap) Map() map[string]string {
     return m
 }
 
-// 设置键值对
+// 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()
 }
 
-// 批量设置键值对
+// 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 {
@@ -89,7 +102,7 @@ func (gm *StringStringMap) BatchSet(m map[string]string) {
     gm.mu.Unlock()
 }
 
-// 获取键值
+// Get returns the value by given <key>.
 func (gm *StringStringMap) Get(key string) string {
 	gm.mu.RLock()
 	val, _ := gm.m[key]
@@ -97,8 +110,11 @@ func (gm *StringStringMap) Get(key string) string {
 	return val
 }
 
-// 设置kv缓存键值对，内部会对键名的存在性使用写锁进行二次检索确认，如果存在则不再写入；返回键名对应的键值。
-// 在高并发下有用，防止数据写入的并发逻辑错误。
+// 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 {
@@ -110,7 +126,8 @@ func (gm *StringStringMap) doSetWithLockCheck(key string, value string) string {
 	return value
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值
+// 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]
@@ -122,7 +139,9 @@ func (gm *StringStringMap) GetOrSet(key string, value string) string {
 	}
 }
 
-// 当键名存在时返回其键值，否则写入指定的键值，键值由指定的函数生成
+// 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]
@@ -134,7 +153,12 @@ func (gm *StringStringMap) GetOrSetFunc(key string, f func() string) string {
 	}
 }
 
-// 与GetOrSetFunc不同的是，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 *StringStringMap) GetOrSetFuncLock(key string, f func() string) string {
 	gm.mu.RLock()
 	val, ok := gm.m[key]
@@ -143,10 +167,9 @@ func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string
 		gm.mu.Lock()
 		defer gm.mu.Unlock()
 		if v, ok := gm.m[key]; ok {
-			gm.mu.Unlock()
 			return v
 		}
-		val         = f()
+		val       = f()
 		gm.m[key] = val
 		return val
 	} else {
@@ -154,7 +177,8 @@ func (gm *StringStringMap) GetOrSetFuncLock(key string, f func() string) string
 	}
 }
 
-// 当键名不存在时写入，并返回true；否则返回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 *StringStringMap) SetIfNotExist(key string, value string) bool {
 	if !gm.Contains(key) {
 		gm.doSetWithLockCheck(key, value)
@@ -163,7 +187,34 @@ func (gm *StringStringMap) SetIfNotExist(key string, value string) bool {
 	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 *StringStringMap) SetIfNotExistFunc(key string, f func() string) 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 *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
+	}
+	return false
+}
+
+// BatchRemove batch deletes values of the map by keys.
 func (gm *StringStringMap) BatchRemove(keys []string) {
     gm.mu.Lock()
     for _, key := range keys {
@@ -172,7 +223,7 @@ func (gm *StringStringMap) BatchRemove(keys []string) {
     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]
@@ -183,7 +234,7 @@ func (gm *StringStringMap) Remove(key string) string {
 	return val
 }
 
-// 返回键列表
+// Keys returns all keys of the map as a slice.
 func (gm *StringStringMap) Keys() []string {
 	gm.mu.RLock()
 	keys := make([]string, 0)
@@ -194,7 +245,7 @@ func (gm *StringStringMap) Keys() []string {
 	return keys
 }
 
-// 返回值列表(注意是随机排序)
+// Values returns all values of the map as a slice.
 func (gm *StringStringMap) Values() []string {
 	gm.mu.RLock()
 	vals := make([]string, 0)
@@ -205,7 +256,8 @@ func (gm *StringStringMap) Values() []string {
 	return vals
 }
 
-// 是否存在某个键
+// 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]
@@ -213,7 +265,7 @@ func (gm *StringStringMap) Contains(key string) bool {
 	return exists
 }
 
-// 哈希表大小
+// Size returns the size of the map.
 func (gm *StringStringMap) Size() int {
 	gm.mu.RLock()
 	length := len(gm.m)
@@ -221,7 +273,8 @@ func (gm *StringStringMap) Size() int {
 	return length
 }
 
-// 哈希表是否为空
+// 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
@@ -229,28 +282,28 @@ func (gm *StringStringMap) IsEmpty() bool {
 	return empty
 }
 
-// 清空哈希表
+// 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()
 }
 
-// 并发安全写锁操作，使用自定义方法执行加锁修改操作
+// 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)
 }
 
-// 并发安全读锁操作，使用自定义方法执行加锁读取操作
+// 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)
 }
 
-// 交换Map中的键和值.
+// 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()
@@ -261,15 +314,16 @@ func (gm *StringStringMap) Flip() {
 	gm.m = n
 }
 
-// 合并两个Map.
-func (gm *StringStringMap) Merge(m *StringStringMap) {
+// 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 m != gm {
-		m.mu.RLock()
-		defer m.mu.RUnlock()
+	if other != gm {
+		other.mu.RLock()
+		defer other.mu.RUnlock()
 	}
-	for k, v := range m.m {
+	for k, v := range other.m {
 		gm.m[k] = v
 	}
 }

g/container/gpool/gpool.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gpool provides a object-reusable concurrent-safe pool.
-//
-// 对象复用池.
 package gpool
 
 import (

g/container/gring/gring.go

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // 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 (

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

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // 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
 
 import (

g/container/gtype/gtype.go

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // 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, concurrent-safe/unsafe basic variable types.
 package gtype
 
 type Type = Interface

g/container/gvar/gvar.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gvar provides an universal variable type, like generics.
-//
-// 通用动态变量.
 package gvar
 
 import (

g/crypto/crypto.go

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

g/database/database.go

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

g/database/gdb/gdb.go

@@ -14,6 +14,7 @@ import (
     "database/sql"
     "errors"
     "fmt"
+    "github.com/gogf/gf/g/container/gmap"
     "github.com/gogf/gf/g/container/gring"
     "github.com/gogf/gf/g/container/gtype"
     "github.com/gogf/gf/g/container/gvar"
@@ -147,30 +148,34 @@ type Map  = map[string]interface{}
 type List = []Map
 
 const (
-    OPTION_INSERT  = 0
-    OPTION_REPLACE = 1
-    OPTION_SAVE    = 2
-    OPTION_IGNORE  = 3
-    // 默认批量操作的数量值(Batch*操作)
-    gDEFAULT_BATCH_NUM          = 10
-    // 默认的连接池连接存活时间(秒)
-    gDEFAULT_CONN_MAX_LIFE_TIME = 30
-
+    OPTION_INSERT               = 0
+    OPTION_REPLACE              = 1
+    OPTION_SAVE                 = 2
+    OPTION_IGNORE               = 3
+    gDEFAULT_BATCH_NUM          = 10 // Per count for batch insert/replace/save
+    gDEFAULT_CONN_MAX_LIFE_TIME = 30 // Max life time for per connection in pool.
 )
 
-// 使用默认/指定分组配置进行连接，数据库集群配置项：default
-func New(groupName ...string) (db DB, err error) {
-	group := config.d
-	if len(groupName) > 0 {
-        group = groupName[0]
-	}
-	config.RLock()
-	defer config.RUnlock()
+var (
+    // Instance map.
+    instances = gmap.NewStringInterfaceMap()
+)
 
-	if len(config.c) < 1 {
+// New creates ORM DB object with global configurations.
+// The param <name> specifies the configuration group name,
+// which is DEFAULT_GROUP_NAME in default.
+func New(name ...string) (db DB, err error) {
+	group := configs.defaultGroup
+	if len(name) > 0 {
+        group = name[0]
+	}
+	configs.RLock()
+	defer configs.RUnlock()
+
+	if len(configs.config) < 1 {
 		return nil, errors.New("empty database configuration")
 	}
-	if _, ok := config.c[group]; ok {
+	if _, ok := configs.config[group]; ok {
 	    if node, err := getConfigNodeByGroup(group, true); err == nil {
 	        base := &dbBase {
                 group            : group,
@@ -204,9 +209,27 @@ func New(groupName ...string) (db DB, err error) {
 	}
 }
 
+// Instance returns an instance for DB operations.
+// The param <name> specifies the configuration group name,
+// which is DEFAULT_GROUP_NAME in default.
+func Instance(name ...string) (db DB, err error) {
+    group := configs.defaultGroup
+    if len(name) > 0 {
+        group = name[0]
+    }
+    v := instances.GetOrSetFuncLock(group, func() interface{} {
+        db, err = New(group)
+        return db
+    })
+    if v != nil {
+        return v.(DB), nil
+    }
+    return
+}
+
 // 获取指定数据库角色的一个配置项，内部根据权重计算负载均衡
 func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
-    if list, ok := config.c[group]; ok {
+    if list, ok := configs.config[group]; ok {
         // 将master, slave集群列表拆分出来
         masterList := make(ConfigGroup, 0)
         slaveList  := make(ConfigGroup, 0)
@@ -319,17 +342,17 @@ func (bs *dbBase) getSqlDb(master bool) (sqlDb *sql.DB, err error) {
     return
 }
 
-// 切换操作的数据库(注意该切换是全局的)
+// 切换当前数据库对象操作的数据库。
 func (bs *dbBase) SetSchema(schema string) {
     bs.schema.Set(schema)
 }
 
-// 创建底层数据库master链接对象
+// 创建底层数据库master链接对象。
 func (bs *dbBase) Master() (*sql.DB, error) {
 	return bs.getSqlDb(true)
 }
 
-// 创建底层数据库slave链接对象
+// 创建底层数据库slave链接对象。
 func (bs *dbBase) Slave() (*sql.DB, error) {
     return bs.getSqlDb(false)
 }

g/database/gdb/gdb_config.go

@@ -17,14 +17,7 @@ const (
     DEFAULT_GROUP_NAME = "default" // 默认配置名称
 )
 
-// 数据库配置包内对象
-var config struct {
-    sync.RWMutex
-    c  Config // 数据库配置
-    d  string // 默认数据库分组名称
-}
-
-// 数据库配置
+// 数据库分组配置
 type Config      map[string]ConfigGroup
 
 // 数据库集群配置
@@ -41,12 +34,19 @@ type ConfigNode  struct {
     Role             string   // (可选，默认为master)数据库的角色，用于主从操作分离，至少需要有一个master，参数值：master, slave
     Charset          string   // (可选，默认为 utf8)编码，默认为 utf8
     Priority         int      // (可选)用于负载均衡的权重计算，当集群中只有一个节点时，权重没有任何意义
-    Linkinfo         string   // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
+    LinkInfo         string   // (可选)自定义链接信息，当该字段被设置值时，以上链接字段(Host,Port,User,Pass,Name)将失效(该字段是一个扩展功能)
     MaxIdleConnCount int      // (可选)连接池最大限制的连接数
     MaxOpenConnCount int      // (可选)连接池最大打开的连接数
     MaxConnLifetime  int      // (可选，单位秒)连接对象可重复使用的时间长度
 }
 
+// 数据库配置包内对象
+var configs struct {
+    sync.RWMutex        // 并发安全互斥锁
+    config       Config // 数据库分组配置
+    defaultGroup string // 默认数据库分组名称
+}
+
 // 数据库集群配置示例，支持主从处理，多数据库集群支持
 /*
 var DatabaseConfiguration = Config {
@@ -80,29 +80,32 @@ var DatabaseConfiguration = Config {
 
 // 包初始化
 func init() {
-    config.c = make(Config)
-    config.d = DEFAULT_GROUP_NAME
+    configs.config       = make(Config)
+    configs.defaultGroup = DEFAULT_GROUP_NAME
 }
 
 // 设置当前应用的数据库配置信息，进行全局数据库配置覆盖操作
-func SetConfig (c Config) {
-    config.Lock()
-    defer config.Unlock()
-    config.c = c
+func SetConfig (config Config) {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config = config
 }
 
 // 添加数据库服务器集群配置
 func AddConfigGroup (group string, nodes ConfigGroup) {
-    config.Lock()
-    config.c[group] = nodes
-    config.Unlock()
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config[group] = nodes
 }
 
 // 添加一台数据库服务器配置
 func AddConfigNode (group string, node ConfigNode) {
-    config.Lock()
-    config.c[group] = append(config.c[group], node)
-    config.Unlock()
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.config[group] = append(configs.config[group], node)
 }
 
 // 添加默认链接的一台数据库服务器配置
@@ -117,16 +120,25 @@ func AddDefaultConfigGroup (nodes ConfigGroup) {
 
 // 添加一台数据库服务器配置
 func GetConfig (group string) ConfigGroup {
-    config.RLock()
-    defer config.RUnlock()
-    return config.c[group]
+    configs.RLock()
+    defer configs.RUnlock()
+    return configs.config[group]
 }
 
 // 设置默认链接的数据库链接配置项(默认是 default)
-func SetDefaultGroup (groupName string) {
-    config.Lock()
-    config.d = groupName
-    config.Unlock()
+func SetDefaultGroup (name string) {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    configs.defaultGroup = name
+}
+
+// 获取默认链接的数据库链接配置项(默认是 default)
+func GetDefaultGroup() string {
+    defer instances.Clear()
+    configs.Lock()
+    defer configs.Unlock()
+    return configs.defaultGroup
 }
 
 // 设置数据库连接池中空闲链接的大小
@@ -147,8 +159,8 @@ func (bs *dbBase) SetConnMaxLifetime(n int) {
 
 // 节点配置转换为字符串
 func (node *ConfigNode) String() string {
-    if node.Linkinfo != "" {
-        return node.Linkinfo
+    if node.LinkInfo != "" {
+        return node.LinkInfo
     }
     return fmt.Sprintf(`%s@%s:%s,%s,%s,%s,%s,%d-%d-%d`, node.User, node.Host, node.Port,
         node.Name, node.Type, node.Role, node.Charset,

g/database/gdb/gdb_mssql.go

@@ -30,8 +30,8 @@ type dbMssql struct {
 // 创建SQL操作对象
 func (db *dbMssql) Open(config *ConfigNode) (*sql.DB, error) {
 	source := ""
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = fmt.Sprintf("user id=%s;password=%s;server=%s;port=%s;database=%s;encrypt=disable",
 			config.User, config.Pass, config.Host, config.Port, config.Name)

g/database/gdb/gdb_mysql.go

@@ -20,8 +20,8 @@ type dbMysql struct {
 // 创建SQL操作对象，内部采用了lazy link处理
 func (db *dbMysql) Open (config *ConfigNode) (*sql.DB, error) {
     var source string
-    if config.Linkinfo != "" {
-        source = config.Linkinfo
+    if config.LinkInfo != "" {
+        source = config.LinkInfo
     } else {
         source = fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s&multiStatements=true",
             config.User, config.Pass, config.Host, config.Port, config.Name, config.Charset)

g/database/gdb/gdb_oracle.go

@@ -30,8 +30,8 @@ type dbOracle struct {
 // 创建SQL操作对象
 func (db *dbOracle) Open(config *ConfigNode) (*sql.DB, error) {
 	var source string
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = fmt.Sprintf("%s/%s@%s", config.User, config.Pass, config.Name)
 	}

g/database/gdb/gdb_pgsql.go

@@ -26,8 +26,8 @@ type dbPgsql struct {
 // 创建SQL操作对象，内部采用了lazy link处理
 func (db *dbPgsql) Open (config *ConfigNode) (*sql.DB, error) {
     var source string
-    if config.Linkinfo != "" {
-        source = config.Linkinfo
+    if config.LinkInfo != "" {
+        source = config.LinkInfo
     } else {
         source = fmt.Sprintf("user=%s password=%s host=%s port=%s dbname=%s", config.User, config.Pass, config.Host, config.Port, config.Name)
     }

g/database/gdb/gdb_sqlite.go

@@ -24,8 +24,8 @@ type dbSqlite struct {
 
 func (db *dbSqlite) Open(config *ConfigNode) (*sql.DB, error) {
 	var source string
-	if config.Linkinfo != "" {
-		source = config.Linkinfo
+	if config.LinkInfo != "" {
+		source = config.LinkInfo
 	} else {
 		source = config.Name
 	}

g/database/gdb/gdb_unit_basic_test.go

@@ -0,0 +1,28 @@
+// 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 gdb_test
+
+import (
+    "github.com/gogf/gf/g/database/gdb"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_Instance(t *testing.T) {
+    gtest.Case(t, func() {
+        _, err := gdb.Instance("none")
+        gtest.AssertNE(err, nil)
+
+        db, err := gdb.Instance()
+        gtest.Assert(err, nil)
+
+        err1 := db.PingMaster()
+        err2 := db.PingSlave()
+        gtest.Assert(err1, nil)
+        gtest.Assert(err2, nil)
+    })
+}

g/database/gredis/gredis.go

@@ -4,10 +4,11 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gredis provides client for redis server.
+// Package gredis provides convenient client for redis server.
 //
 // Redis客户端.
-// Redis中文手册文档请参考：http://redisdoc.com/ , Redis官方命令请参考：https://redis.io/commands
+// Redis中文手册请参考：http://redisdoc.com/
+// Redis官方命令请参考：https://redis.io/commands
 package gredis
 
 import (
@@ -24,8 +25,9 @@ const (
 
 // Redis客户端(管理连接池)
 type Redis struct {
-    pool   *redis.Pool
-    config Config
+    pool   *redis.Pool // 底层连接池
+    group  string      // 配置分组
+    config Config      // 配置对象
 }
 
 // Redis连接对象(连接池中的单个连接)
@@ -48,13 +50,17 @@ type PoolStats struct {
     redis.PoolStats
 }
 
-// 连接池map
-var pools = gmap.NewStringInterfaceMap()
+var (
+    // 单例对象Map
+    instances = gmap.NewStringInterfaceMap()
+    // 连接池Map
+    pools     = gmap.NewStringInterfaceMap()
+)
 
 // New creates a redis client object with given configuration.
 // Redis client maintains a connection pool automatically.
 //
-// 创建redis操作对象.
+// 创建redis操作对象，底层根据配置信息公用的连接池（连接池单例）。
 func New(config Config) *Redis {
     if config.IdleTimeout == 0 {
         config.IdleTimeout = gDEFAULT_POOL_IDLE_TIMEOUT
@@ -96,11 +102,41 @@ func New(config Config) *Redis {
     }
 }
 
+// Instance returns an instance of redis client with specified group.
+// The <group> param is unnecessary, if <group> is not passed,
+// return redis instance with default group.
+//
+// 获取指定分组名称的Redis单例对象，底层根据配置信息公用的连接池（连接池单例）。
+func Instance(name ...string) *Redis {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    v := instances.GetOrSetFuncLock(group, func() interface{} {
+        if config, ok := GetConfig(group); ok {
+            r      := New(config)
+            r.group = group
+            return r
+        }
+        return nil
+    })
+    if v != nil {
+        return v.(*Redis)
+    }
+    return nil
+}
+
 // Close closes the redis connection pool,
 // it will release all connections reserved by this pool.
+// It always not necessary to call Close manually.
 //
 // 关闭redis管理对象，将会关闭底层的连接池。
+// 往往没必要手动调用，跟随进程销毁即可。
 func (r *Redis) Close() error {
+    if r.group != "" {
+        // 如果是单例对象，那么需要从单例对象Map中删除
+        instances.Remove(r.group)
+    }
     pools.Remove(fmt.Sprintf("%v", r.config))
     return r.pool.Close()
 }

g/database/gredis/gredis_config.go

@@ -0,0 +1,61 @@
+// 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 gredis
+
+import "github.com/gogf/gf/g/container/gmap"
+
+const (
+    // Default configuration group name.
+    DEFAULT_GROUP_NAME = "default"
+)
+var (
+    // Configuration groups.
+    configs = gmap.NewStringInterfaceMap()
+)
+
+// SetConfig sets the global configuration for specified group.
+// If <name> is not passed, it sets configuration for the default group name.
+func SetConfig(config Config, name...string) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    configs.Set(group, config)
+    instances.Remove(group)
+}
+
+// GetConfig returns the global configuration with specified group name.
+// If <name> is not passed, it returns configuration of the default group name.
+func GetConfig(name...string) (config Config, ok bool) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    if v := configs.Get(group); v != nil {
+        return v.(Config), true
+    }
+    return Config{}, false
+}
+
+// RemoveConfig removes the global configuration with specified group.
+// If <name> is not passed, it removes configuration of the default group name.
+func RemoveConfig(name...string) {
+    group := DEFAULT_GROUP_NAME
+    if len(name) > 0 {
+        group = name[0]
+    }
+    configs.Remove(group)
+    instances.Remove(group)
+}
+
+// ClearConfig removes all configurations and instances of redis.
+func ClearConfig() {
+    configs.Clear()
+    instances.Clear()
+}
+
+

g/database/gredis/gredis_unit_test.go

@@ -99,6 +99,33 @@ func Test_Conn(t *testing.T) {
         conn := redis.Conn()
         defer conn.Close()
 
+
+        r, err := conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r,   []byte("v"))
+
+        _, err  = conn.Do("DEL", "k")
+        gtest.Assert(err, nil)
+        r, err  = conn.Do("GET", "k")
+        gtest.Assert(err, nil)
+        gtest.Assert(r, nil)
+    })
+}
+
+func Test_Instance(t *testing.T) {
+    gtest.Case(t, func() {
+        group := "my-test"
+        gredis.SetConfig(config, group)
+        defer gredis.RemoveConfig(group)
+        redis := gredis.Instance(group)
+        defer redis.Close()
+
+        conn := redis.Conn()
+        defer conn.Close()
+
+        _, err := conn.Do("SET", "k", "v")
+        gtest.Assert(err, nil)
+
         r, err := conn.Do("GET", "k")
         gtest.Assert(err, nil)
         gtest.Assert(r,   []byte("v"))

g/encoding/encoding.go

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

g/encoding/gjson/gjson.go

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gjson provides flexible and useful API for JSON/XML/YAML/TOML content handling.
-//
-// JSON/XML/YAML/TOML数据格式处理。
+// Package gjson provides convenient API for JSON/XML/YAML/TOML data handling.
 package gjson
 
 import (
@@ -19,7 +17,6 @@ import (
     "github.com/gogf/gf/g/encoding/gyaml"
     "github.com/gogf/gf/g/internal/rwmutex"
     "github.com/gogf/gf/g/os/gfcache"
-    "github.com/gogf/gf/g/os/gfile"
     "github.com/gogf/gf/g/text/gregex"
     "github.com/gogf/gf/g/text/gstr"
     "github.com/gogf/gf/g/util/gconv"
@@ -30,18 +27,24 @@ import (
 )
 
 const (
-    gDEFAULT_SPLIT_CHAR = '.' // 默认层级分隔符号
+    // Separator char for hierarchical data access.
+    gDEFAULT_SPLIT_CHAR = '.'
 )
 
-// json解析结果存放数组
+// The customized JSON struct.
 type Json struct {
     mu *rwmutex.RWMutex
-    p  *interface{} // 注意这是一个指针
-    c  byte         // 层级分隔符，默认为"."
-    vc bool         // 层级检索是否执行分隔符冲突检测(默认为false，检测会比较影响检索效率)
+    p  *interface{} // Pointer for hierarchical data access, it's the root of data in default.
+    c  byte         // Char separator('.' in default).
+    vc bool         // Violence Check(false in default), which is used to access data
+                    // when the hierarchical data key contains separator char.
 }
 
-// 将变量转换为Json对象进行处理，该变量至少应当是一个map或者slice，否者转换没有意义
+// New creates a Json object with any variable type of <data>,
+// but <data> should be a map or slice for data access reason,
+// or it will make no sense.
+// The <unsafe> param specifies whether using this Json object
+// in un-concurrent-safe context, which is false in default.
 func New(data interface{}, unsafe...bool) *Json {
     j := (*Json)(nil)
     switch data.(type) {
@@ -75,7 +78,7 @@ func New(data interface{}, unsafe...bool) *Json {
     return j
 }
 
-// 创建一个非并发安全的Json对象
+// NewUnsafe creates a un-concurrent-safe Json object.
 func NewUnsafe(data...interface{}) *Json {
     if len(data) > 0 {
         return New(data[0], true)
@@ -83,17 +86,17 @@ func NewUnsafe(data...interface{}) *Json {
     return New(nil, true)
 }
 
-// 识别当前给定内容是否为JSON格式
+// Valid checks whether <data> is a valid JSON data type.
 func Valid(data interface{}) bool {
     return json.Valid(gconv.Bytes(data))
 }
 
-// 编码go变量为json字符串，并返回json字符串指针
+// Encode encodes <value> to JSON data type of bytes.
 func Encode(value interface{}) ([]byte, error) {
     return json.Marshal(value)
 }
 
-// 解码字符串/[]byte为interface{}变量
+// Decode decodes <data>(string/[]byte) to golang variable.
 func Decode(data interface{}) (interface{}, error) {
     var value interface{}
     if err := DecodeTo(gconv.Bytes(data), &value); err != nil {
@@ -103,58 +106,63 @@ func Decode(data interface{}) (interface{}, error) {
     }
 }
 
-// 解析json字符串/[]byte为go变量，注意第二个参数为指针(任意结构的变量)
+// Decode decodes <data>(string/[]byte) to specified golang variable <v>.
+// The <v> should be a pointer type.
 func DecodeTo(data interface{}, v interface{}) error {
     decoder := json.NewDecoder(bytes.NewReader(gconv.Bytes(data)))
     decoder.UseNumber()
     return decoder.Decode(v)
 }
 
-// 解析json字符串为gjson.Json对象，并返回操作对象指针
-func DecodeToJson(data interface{}) (*Json, error) {
+// DecodeToJson codes <data>(string/[]byte) to a Json object.
+func DecodeToJson(data interface{}, unsafe...bool) (*Json, error) {
     if v, err := Decode(gconv.Bytes(data)); err != nil {
         return nil, err
     } else {
-        return New(v), nil
+        return New(v, unsafe...), nil
     }
 }
 
-// 支持多种配置文件类型转换为json格式内容并解析为gjson.Json对象
-func Load(path string) (*Json, error) {
-    return LoadContent(gfcache.GetBinContents(path), gfile.Ext(path))
+// Load loads content from specified file <path>,
+// and creates a Json object from its content.
+func Load(path string, unsafe...bool) (*Json, error) {
+    return LoadContent(gfcache.GetBinContents(path), unsafe...)
 }
 
-// 支持的配置文件格式：xml, json, yaml/yml, toml,
-// 默认为自动识别，当无法检测成功时使用json解析。
-func LoadContent(data interface{}, dataType...string) (*Json, error) {
+// LoadContent creates a Json object from given content,
+// it checks the data type of <content> automatically,
+// supporting JSON, XML, YAML and TOML types of data.
+func LoadContent(data interface{}, unsafe...bool) (*Json, error) {
     var err    error
     var result interface{}
     b := gconv.Bytes(data)
     t := "json"
-    if len(dataType) > 0 {
-        t = dataType[0]
+    // auto check data type
+    if json.Valid(b) {
+        t = "json"
+    } else if gregex.IsMatch(`^<.+>.*</.+>$`, b) {
+        t = "xml"
+    } else if gregex.IsMatch(`^[\s\t]*\w+\s*:\s*.+`, b) || gregex.IsMatch(`\n[\s\t]*\w+\s*:\s*.+`, b) {
+        t = "yml"
+    } else if gregex.IsMatch(`^[\s\t]*\w+\s*=\s*.+`, b) || gregex.IsMatch(`\n[\s\t]*\w+\s*=\s*.+`, b) {
+        t = "toml"
     } else {
-        if json.Valid(b) {
-            t = "json"
-        } else if gregex.IsMatch(`<.+>.*</.+>`, b) {
-            t = "xml"
-        } else if gregex.IsMatch(`\w+\s*:\s*.+`, b) {
-            t = "yml"
-        } else if gregex.IsMatch(`\w+\s*=\s*.+`, b) {
-            t = "toml"
-        }
+        return nil, errors.New("unsupported data type")
     }
-    // 其他数据格式解析
+    // convert to json type data
     switch t {
         case "json", ".json":
             // ok
         case "xml", ".xml":
+            // TODO UseNumber
             b, err = gxml.ToJson(b)
 
         case "yml", "yaml", ".yml", ".yaml":
+            // TODO UseNumber
             b, err = gyaml.ToJson(b)
 
         case "toml", ".toml":
+            // TODO UseNumber
             b, err = gtoml.ToJson(b)
 
         default:
@@ -169,27 +177,31 @@ func LoadContent(data interface{}, dataType...string) (*Json, error) {
         if err := decoder.Decode(&result); err != nil {
             return nil, err
         }
+        switch result.(type) {
+            case string, []byte:
+                return nil, fmt.Errorf(`json decoding failed for content: %s`, string(b))
+        }
     }
-    return New(result), nil
+    return New(result, unsafe...), nil
 }
 
-// 设置自定义的层级分隔符号
+// SetSplitChar sets the separator char for hierarchical data access.
 func (j *Json) SetSplitChar(char byte) {
     j.mu.Lock()
     j.c = char
     j.mu.Unlock()
 }
 
-// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
-// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
-func (j *Json) SetViolenceCheck(check bool) {
+// SetViolenceCheck enables/disables violence check for hierarchical data access.
+func (j *Json) SetViolenceCheck(enabled bool) {
     j.mu.Lock()
-    j.vc = check
+    j.vc = enabled
     j.mu.Unlock()
 }
 
-// 将指定的json内容转换为指定结构返回，查找失败或者转换失败，目标对象转换为nil
-// 注意第二个参数需要给的是**变量地址**
+// GetToVar gets the value by specified <pattern>,
+// and converts it to specified golang variable <v>.
+// The <v> should be a pointer type.
 func (j *Json) GetToVar(pattern string, v interface{}) error {
     r := j.Get(pattern)
     if r != nil {
@@ -204,19 +216,18 @@ func (j *Json) GetToVar(pattern string, v interface{}) error {
     return nil
 }
 
-// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetMap gets the value by specified <pattern>,
+// and converts it to map[string]interface{}.
 func (j *Json) GetMap(pattern string) map[string]interface{} {
     result := j.Get(pattern)
     if result != nil {
-        if r, ok := result.(map[string]interface{}); ok {
-            return r
-        }
+        return gconv.Map(result)
     }
     return nil
 }
 
-// 将检索值转换为Json对象指针返回。
+// GetJson gets the value by specified <pattern>,
+// and converts it to a Json object.
 func (j *Json) GetJson(pattern string) *Json {
     result := j.Get(pattern)
     if result != nil {
@@ -225,7 +236,8 @@ func (j *Json) GetJson(pattern string) *Json {
     return nil
 }
 
-// 将检索值转换为Json对象指针数组返回。
+// GetJsons gets the value by specified <pattern>,
+// and converts it to a slice of Json object.
 func (j *Json) GetJsons(pattern string) []*Json {
     array := j.GetArray(pattern)
     if len(array) > 0 {
@@ -238,21 +250,25 @@ func (j *Json) GetJsons(pattern string) []*Json {
     return nil
 }
 
-// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换。
+// GetArray gets the value by specified <pattern>,
+// and converts it to a slice of []interface{}.
 func (j *Json) GetArray(pattern string) []interface{} {
     return gconv.Interfaces(j.Get(pattern))
 }
 
-// 返回指定json中的string
+// GetString gets the value by specified <pattern>,
+// and converts it to string.
 func (j *Json) GetString(pattern string) string {
     return gconv.String(j.Get(pattern))
 }
 
-// 返回指定json中的strings(转换为[]string数组)
+// GetStrings gets the value by specified <pattern>,
+// and converts it to a slice of []string.
 func (j *Json) GetStrings(pattern string) []string {
     return gconv.Strings(j.Get(pattern))
 }
 
+// See GetArray.
 func (j *Json) GetInterfaces(pattern string) []interface{} {
     return gconv.Interfaces(j.Get(pattern))
 }
@@ -265,7 +281,10 @@ func (j *Json) GetTimeDuration(pattern string) time.Duration {
     return gconv.TimeDuration(j.Get(pattern))
 }
 
-// 返回指定json中的bool(false:"", 0, false, off)
+// GetBool gets the value by specified <pattern>,
+// and converts it to bool.
+// It returns false when value is: "", 0, false, off, nil;
+// or returns true instead.
 func (j *Json) GetBool(pattern string) bool {
     return gconv.Bool(j.Get(pattern))
 }
@@ -326,25 +345,29 @@ func (j *Json) GetFloats(pattern string) []float64 {
     return gconv.Floats(j.Get(pattern))
 }
 
-// 将指定变量转换为struct对象(对象属性赋值)
+// GetToStruct gets the value by specified <pattern>,
+// and converts it to specified object <objPointer>.
+// The <objPointer> should be the pointer to an object.
 func (j *Json) GetToStruct(pattern string, objPointer interface{}) error {
     return gconv.Struct(j.Get(pattern), objPointer)
 }
 
-// 动态设置层级变量
+// Set sets value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (j *Json) Set(pattern string, value interface{}) error {
     return j.setValue(pattern, value, false)
 }
 
-// 动态删除层级变量
+// Remove deletes value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (j *Json) Remove(pattern string) error {
     return j.setValue(pattern, nil, true)
 }
 
-// 根据pattern查找并设置数据
-// 注意：
-// 1、写入的value为nil且removed为true时，表示删除;
-// 2、里面的层级处理比较复杂，逻辑较复杂的地方在于层级检索及节点创建，叶子赋值;
+// Set <value> by <pattern>.
+// Notice:
+// 1. If value is nil and removed is true, means deleting this value;
+// 2. It's quite complicated in hierarchical data search, node creating and data assignment;
 func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
     array   := strings.Split(pattern, string(j.c))
     length  := len(array)
@@ -363,144 +386,144 @@ func (j *Json) setValue(pattern string, value interface{}, removed bool) error {
     defer j.mu.Unlock()
     for i:= 0; i < length; i++ {
         switch (*pointer).(type) {
-        case map[string]interface{}:
-            if i == length - 1 {
-                if removed && value == nil {
-                    // 删除map元素
-                    delete((*pointer).(map[string]interface{}), array[i])
-                } else {
-                    (*pointer).(map[string]interface{})[array[i]] = value
-                }
-            } else {
-                // 当键名不存在的情况这里会进行处理
-                if v, ok := (*pointer).(map[string]interface{})[array[i]]; !ok {
-                    if removed && value == nil {
-                        goto done
-                    }
-                    // 创建新节点
-                    if gstr.IsNumeric(array[i + 1]) {
-                        // 创建array节点
-                        n, _ := strconv.Atoi(array[i + 1])
-                        var v interface{} = make([]interface{}, n + 1)
-                        pparent = j.setPointerWithValue(pointer, array[i], v)
-                        pointer = &v
-                    } else {
-                        // 创建map节点
-                        var v interface{} = make(map[string]interface{})
-                        pparent = j.setPointerWithValue(pointer, array[i], v)
-                        pointer = &v
-                    }
-                } else {
-                    pparent = pointer
-                    pointer = &v
-                }
-            }
-
-        case []interface{}:
-            // 键名与当前指针类型不符合，需要执行**覆盖操作**
-            if !gstr.IsNumeric(array[i]) {
+            case map[string]interface{}:
                 if i == length - 1 {
-                    *pointer = map[string]interface{}{ array[i] : value }
+                    if removed && value == nil {
+                        // 删除map元素
+                        delete((*pointer).(map[string]interface{}), array[i])
+                    } else {
+                        (*pointer).(map[string]interface{})[array[i]] = value
+                    }
                 } else {
-                    var v interface{} = make(map[string]interface{})
-                    *pointer = v
-                    pparent  = pointer
-                    pointer  = &v
+                    // 当键名不存在的情况这里会进行处理
+                    if v, ok := (*pointer).(map[string]interface{})[array[i]]; !ok {
+                        if removed && value == nil {
+                            goto done
+                        }
+                        // 创建新节点
+                        if gstr.IsNumeric(array[i + 1]) {
+                            // 创建array节点
+                            n, _ := strconv.Atoi(array[i + 1])
+                            var v interface{} = make([]interface{}, n + 1)
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        } else {
+                            // 创建map节点
+                            var v interface{} = make(map[string]interface{})
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        }
+                    } else {
+                        pparent = pointer
+                        pointer = &v
+                    }
                 }
-                continue
-            }
 
-            valn, err := strconv.Atoi(array[i])
-            if err != nil {
-                return err
-            }
-            // 叶子节点
-            if i == length - 1 {
-                if len((*pointer).([]interface{})) > valn {
-                    if removed && value == nil {
-                        // 删除数据元素
-                        j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+            case []interface{}:
+                // 键名与当前指针类型不符合，需要执行**覆盖操作**
+                if !gstr.IsNumeric(array[i]) {
+                    if i == length - 1 {
+                        *pointer = map[string]interface{}{ array[i] : value }
                     } else {
-                        (*pointer).([]interface{})[valn] = value
-                    }
-                } else {
-                    if removed && value == nil {
-                        goto done
-                    }
-                    if pparent == nil {
-                        // 表示根节点
-                        j.setPointerWithValue(pointer, array[i], value)
-                    } else {
-                        // 非根节点
-                        s := make([]interface{}, valn + 1)
-                        copy(s, (*pointer).([]interface{}))
-                        s[valn] = value
-                        j.setPointerWithValue(pparent, array[i - 1], s)
+                        var v interface{} = make(map[string]interface{})
+                        *pointer = v
+                        pparent  = pointer
+                        pointer  = &v
                     }
+                    continue
                 }
-            } else {
-                if gstr.IsNumeric(array[i + 1]) {
-                    n, _ := strconv.Atoi(array[i + 1])
+
+                valn, err := strconv.Atoi(array[i])
+                if err != nil {
+                    return err
+                }
+                // 叶子节点
+                if i == length - 1 {
                     if len((*pointer).([]interface{})) > valn {
-                        (*pointer).([]interface{})[valn] = make([]interface{}, n + 1)
-                        pparent                          = pointer
-                        pointer                          = &(*pointer).([]interface{})[valn]
+                        if removed && value == nil {
+                            // 删除数据元素
+                            j.setPointerWithValue(pparent, array[i - 1], append((*pointer).([]interface{})[ : valn], (*pointer).([]interface{})[valn + 1 : ]...))
+                        } else {
+                            (*pointer).([]interface{})[valn] = value
+                        }
                     } else {
                         if removed && value == nil {
                             goto done
                         }
-                        var v interface{} = make([]interface{}, n + 1)
+                        if pparent == nil {
+                            // 表示根节点
+                            j.setPointerWithValue(pointer, array[i], value)
+                        } else {
+                            // 非根节点
+                            s := make([]interface{}, valn + 1)
+                            copy(s, (*pointer).([]interface{}))
+                            s[valn] = value
+                            j.setPointerWithValue(pparent, array[i - 1], s)
+                        }
+                    }
+                } else {
+                    if gstr.IsNumeric(array[i + 1]) {
+                        n, _ := strconv.Atoi(array[i + 1])
+                        if len((*pointer).([]interface{})) > valn {
+                            (*pointer).([]interface{})[valn] = make([]interface{}, n + 1)
+                            pparent                          = pointer
+                            pointer                          = &(*pointer).([]interface{})[valn]
+                        } else {
+                            if removed && value == nil {
+                                goto done
+                            }
+                            var v interface{} = make([]interface{}, n + 1)
+                            pparent = j.setPointerWithValue(pointer, array[i], v)
+                            pointer = &v
+                        }
+                    } else {
+                        var v interface{} = make(map[string]interface{})
                         pparent = j.setPointerWithValue(pointer, array[i], v)
                         pointer = &v
                     }
-                } else {
-                    var v interface{} = make(map[string]interface{})
-                    pparent = j.setPointerWithValue(pointer, array[i], v)
-                    pointer = &v
                 }
-            }
 
             // 如果当前指针指向的变量不是引用类型的，
             // 那么修改变量必须通过父级进行修改，即 pparent
-        default:
-            if removed && value == nil {
-                goto done
-            }
-            if gstr.IsNumeric(array[i]) {
-                n, _    := strconv.Atoi(array[i])
-                s       := make([]interface{}, n + 1)
-                if i == length - 1 {
-                    s[n] = value
+            default:
+                if removed && value == nil {
+                    goto done
                 }
-                if pparent != nil {
-                    pparent = j.setPointerWithValue(pparent, array[i - 1], s)
-                } else {
-                    *pointer = s
-                    pparent  = pointer
-                }
-            } else {
-                var v interface{} = make(map[string]interface{})
-                if i == length - 1 {
-                    v = map[string]interface{}{
-                        array[i] : value,
+                if gstr.IsNumeric(array[i]) {
+                    n, _    := strconv.Atoi(array[i])
+                    s       := make([]interface{}, n + 1)
+                    if i == length - 1 {
+                        s[n] = value
+                    }
+                    if pparent != nil {
+                        pparent = j.setPointerWithValue(pparent, array[i - 1], s)
+                    } else {
+                        *pointer = s
+                        pparent  = pointer
                     }
-                }
-                if pparent != nil {
-                    pparent = j.setPointerWithValue(pparent, array[i - 1], v)
                 } else {
-                    *pointer = v
-                    pparent  = pointer
+                    var v interface{} = make(map[string]interface{})
+                    if i == length - 1 {
+                        v = map[string]interface{}{
+                            array[i] : value,
+                        }
+                    }
+                    if pparent != nil {
+                        pparent = j.setPointerWithValue(pparent, array[i - 1], v)
+                    } else {
+                        *pointer = v
+                        pparent  = pointer
+                    }
+                    pointer = &v
                 }
-                pointer = &v
-            }
-
         }
     }
 done:
     return nil
 }
 
-// 数据结构转换，map参数必须转换为map[string]interface{}，数组参数必须转换为[]interface{}
+// Convert <value> to map[string]interface{} or []interface{},
+// which can be supported for hierarchical data access.
 func (j *Json) convertValue(value interface{}) interface{} {
     switch value.(type) {
         case map[string]interface{}:
@@ -520,7 +543,7 @@ func (j *Json) convertValue(value interface{}) interface{} {
                 case reflect.Map:    return gconv.Map(value)
                 case reflect.Struct: return gconv.Map(value)
                 default:
-                    // 最后使用JSON编解码
+                    // Use json decode/encode at last.
                     b, _ := Encode(value)
                     v, _ := Decode(b)
                     return v
@@ -528,8 +551,8 @@ func (j *Json) convertValue(value interface{}) interface{} {
     }
 }
 
-// 用于Set方法中，对指针指向的内存地址进行赋值
-// 返回修改后的父级指针
+// Set <key>:<value> to <pointer>, the <key> may be a map key or slice index.
+// It returns the pointer to the new value set.
 func (j *Json) setPointerWithValue(pointer *interface{}, key string, value interface{}) *interface{} {
     switch (*pointer).(type) {
         case map[string]interface{}:
@@ -553,9 +576,12 @@ func (j *Json) setPointerWithValue(pointer *interface{}, key string, value inter
     return pointer
 }
 
-// 根据约定字符串方式访问json解析数据，参数形如： "items.name.first", "list.0"; 当pattern为空时，表示获取所有数据;
-// 返回的结果类型的interface{}，因此需要自己做类型转换;
-// 如果找不到对应节点的数据，返回nil;
+// Get returns value by specified <pattern>.
+// It returns all values of current Json object, if <pattern> is empty or not specified.
+// It returns nil if no value found by <pattern>.
+//
+// We can also access slice item by its index number in <pattern>,
+// eg: "items.name.first", "list.10".
 func (j *Json) Get(pattern...string) interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
@@ -576,13 +602,14 @@ func (j *Json) Get(pattern...string) interface{} {
     return nil
 }
 
-// 判断锁给定pattern是否数据存在
+// Contains checks whether the value by specified <pattern> exist.
 func (j *Json) Contains(pattern...string) bool {
     return j.Get(pattern...) != nil
 }
 
-// 计算指定pattern的元素长度(pattern对应数据类型为map/slice时有效)。
-// 当pattern对应的数据类型非map/slice时，返回-1。
+// Len returns the length/size of the value by specified <pattern>.
+// The target value by <pattern> should be type of slice or map.
+// It returns -1 if the target value is not found, or its type is invalid.
 func (j *Json) Len(pattern string) int {
     p := j.getPointerByPattern(pattern)
     if p != nil {
@@ -598,7 +625,8 @@ func (j *Json) Len(pattern string) int {
     return -1
 }
 
-// 指定pattern追加元素
+// Append appends value to the value by specified <pattern>.
+// The target value by <pattern> should be type of slice.
 func (j *Json) Append(pattern string, value interface{}) error {
     p := j.getPointerByPattern(pattern)
     if p == nil {
@@ -611,7 +639,7 @@ func (j *Json) Append(pattern string, value interface{}) error {
     return fmt.Errorf("invalid variable type of %s", pattern)
 }
 
-// 根据pattern获取对应元素项的指针
+// Get a pointer to the value by specified <pattern>.
 func (j *Json) getPointerByPattern(pattern string) *interface{} {
     if j.vc {
         return j.getPointerByPatternWithViolenceCheck(pattern)
@@ -620,18 +648,7 @@ func (j *Json) getPointerByPattern(pattern string) *interface{} {
     }
 }
 
-// 根据pattern层级查找**变量指针**, 执行冲突检测。
-// 检索方式：例如检索 a.a.a ，值为1
-// 1. 检索 a.a.a.a 是否存在对应map的键名；
-// 2. 检索 a.a.a   是否存在对应map的键名；
-// 3. 检索 a.a     是否存在对应map的键名；
-// 4. 检索 a       是否存在对应map的键名，如果检索出这是一个map，假如为变量m1；
-// 5. 在m1中检索 a.a.a 否存在对应map的键名；
-// 6. 在m1中检索 a.a   否存在对应map的键名；
-// 7. 在m1中检索 a     否存在对应map的键名，如果检索出这是一个map，假如为变量m2；
-// 8. 在m2中检索 a.a   否存在对应map的键名；
-// 9. 在m2中检索 a     否存在对应map的键名，检索到有值，值为1；
-// 这样检索的复杂度很高，主要是为了避免键名中存在分隔符号(默认为".")的情况，避免歧义。
+// Get a pointer to the value of specified <pattern> with violence check.
 func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{} {
     if !j.vc {
         return j.getPointerByPatternWithoutViolenceCheck(pattern)
@@ -657,7 +674,7 @@ func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{}
                 pointer = r
             }
         } else {
-            // 查找下一个分割符号的索引位置
+            // Get the position for next separator char.
             index = strings.LastIndexByte(pattern[start:index], j.c)
             if index != -1 && length > 0 {
                 index += length + 1
@@ -670,7 +687,7 @@ func (j *Json) getPointerByPatternWithViolenceCheck(pattern string) *interface{}
     return nil
 }
 
-// 层级检索，内部不执行分隔符冲突检查，检索效率会有所提高，但是冲突需要开发者自己根据自定义的分隔符来进行解决
+// Get a pointer to the value of specified <pattern>, with no violence check.
 func (j *Json) getPointerByPatternWithoutViolenceCheck(pattern string) *interface{} {
     if j.vc {
         return j.getPointerByPatternWithViolenceCheck(pattern)
@@ -694,8 +711,8 @@ func (j *Json) getPointerByPatternWithoutViolenceCheck(pattern string) *interfac
     return nil
 }
 
-// 判断给定的key在当前的pointer下是否有值，并返回对应的pointer,
-// 注意这里返回的指针都是临时变量的内存地址
+// Check whether there's value by <key> in specified <pointer>.
+// It returns a pointer to the value.
 func (j *Json) checkPatternByPointer(key string, pointer *interface{}) *interface{} {
     switch (*pointer).(type) {
         case map[string]interface{}:
@@ -713,7 +730,8 @@ func (j *Json) checkPatternByPointer(key string, pointer *interface{}) *interfac
     return nil
 }
 
-// 转换为map[string]interface{}类型,如果转换失败，返回nil
+// ToMap converts current Json object to map[string]interface{}.
+// It returns nil if fails.
 func (j *Json) ToMap() map[string]interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
@@ -725,15 +743,16 @@ func (j *Json) ToMap() map[string]interface{} {
     }
 }
 
-// 转换为[]interface{}类型,如果转换失败，返回nil
+// ToArray converts current Json object to []interface{}.
+// It returns nil if fails.
 func (j *Json) ToArray() []interface{} {
     j.mu.RLock()
     defer j.mu.RUnlock()
     switch (*(j.p)).(type) {
-    case []interface{}:
-        return (*(j.p)).([]interface{})
-    default:
-        return nil
+        case []interface{}:
+            return (*(j.p)).([]interface{})
+        default:
+            return nil
     }
 }
 
@@ -799,14 +818,15 @@ func (j *Json) ToTomlString() (string, error) {
     return string(b), e
 }
 
-// 转换为指定的struct对象
-func (j *Json) ToStruct(o interface{}) error {
+// ToStruct converts current Json object to specified object.
+// The <objPointer> should be a pointer type.
+func (j *Json) ToStruct(objPointer interface{}) error {
     j.mu.RLock()
     defer j.mu.RUnlock()
-    return gconv.Struct(*(j.p), o)
+    return gconv.Struct(*(j.p), objPointer)
 }
 
-// 打印Json对象
+// Dump prints current Json object with more manually readable.
 func (j *Json) Dump() error {
     j.mu.RLock()
     defer j.mu.RUnlock()

g/encoding/gjson/gjson_unit_basic_test.go

@@ -139,9 +139,9 @@ func Test_GetMap(t *testing.T) {
     gtest.Case(t, func() {
         j, err := gjson.DecodeToJson(data)
         gtest.Assert(err, nil)
-        gtest.Assert(j.GetMap("n"), g.Map{})
+        gtest.Assert(j.GetMap("n"), nil)
         gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
-        gtest.Assert(j.GetMap("a"), g.Map{})
+        gtest.Assert(j.GetMap("a"), nil)
     })
 }
 
@@ -189,7 +189,7 @@ func Test_GetStrings(t *testing.T) {
         gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
         gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
         gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
-        gtest.AssertEQ(j.GetStrings("i"), g.SliceStr{})
+        gtest.AssertEQ(j.GetStrings("i"), nil)
     })
 }
 

g/encoding/gjson/gjson_unit_load_test.go

@@ -69,7 +69,7 @@ func Test_Load_XML(t *testing.T) {
     })
 }
 
-func Test_Load_YAML(t *testing.T) {
+func Test_Load_YAML1(t *testing.T) {
     data := []byte(`
 a:
 - 1
@@ -104,7 +104,16 @@ m:
     })
 }
 
-func Test_Load_TOML(t *testing.T) {
+func Test_Load_YAML2(t *testing.T) {
+    data := []byte("i : 123456789")
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
+
+func Test_Load_TOML1(t *testing.T) {
     data := []byte(`
 a = ["1", "2", "3"]
 n = "123456789"
@@ -136,3 +145,12 @@ n = "123456789"
         gtest.Assert(j.Get("a.1"), 2)
     })
 }
+
+func Test_Load_TOML2(t *testing.T) {
+    data := []byte("i=123456789")
+    gtest.Case(t, func() {
+        j, err := gjson.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}

g/encoding/gjson/gjson_unit_set_test.go

@@ -172,7 +172,7 @@ func Test_Set10(t *testing.T) {
 
 func Test_Set11(t *testing.T) {
     e    := []byte(`{"a":{"b":{}}}`)
-    p, _ := gjson.LoadContent([]byte(`{"a":{"b":{"c":1}}}`), "json")
+    p, _ := gjson.LoadContent([]byte(`{"a":{"b":{"c":1}}}`))
     p.Remove("a.b.c")
     if c, err := p.ToJson(); err == nil {
         

g/encoding/gparser/gparser.go

@@ -4,7 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://gitee.com/johng/gp.
 
-// Package gparser provides a flexible and easy way for accessing/converting variable and JSON/XML/YAML/TOML contents.
+// Package gparser provides convenient API for accessing/converting variable and JSON/XML/YAML/TOML.
 package gparser
 
 import (
@@ -16,13 +16,16 @@ type Parser struct {
     json *gjson.Json
 }
 
-// 将变量转换为Parser对象进行处理，该变量至少应当是一个map或者array，否者转换没有意义
-// value可以传递nil, 表示创建一个空的Parser对象
-func New (value interface{}, unsafe...bool) *Parser {
+// New creates a Parser object with any variable type of <data>,
+// but <data> should be a map or slice for data access reason,
+// or it will make no sense.
+// The <unsafe> param specifies whether using this Parser object
+// in un-concurrent-safe context, which is false in default.
+func New(value interface{}, unsafe...bool) *Parser {
     return &Parser{gjson.New(value, unsafe...)}
 }
 
-// 非并发安全Parser对象
+// NewUnsafe creates a un-concurrent-safe Parser object.
 func NewUnsafe (value...interface{}) *Parser {
     if len(value) > 0 {
         return &Parser{gjson.New(value[0], false)}
@@ -30,57 +33,64 @@ func NewUnsafe (value...interface{}) *Parser {
     return &Parser{gjson.New(nil, false)}
 }
 
-func Load (path string) (*Parser, error) {
-    if j, e := gjson.Load(path); e == nil {
+// Load loads content from specified file <path>,
+// and creates a Parser object from its content.
+func Load (path string, unsafe...bool) (*Parser, error) {
+    if j, e := gjson.Load(path, unsafe...); e == nil {
         return &Parser{j}, nil
     } else {
         return nil, e
     }
 }
 
-// 支持的数据内容格式：json(默认), xml, yaml/yml, toml
-func LoadContent (data []byte, dataType...string) (*Parser, error) {
-    if j, e := gjson.LoadContent(data, dataType...); e == nil {
+// LoadContent creates a Parser object from given content,
+// it checks the data type of <content> automatically,
+// supporting JSON, XML, YAML and TOML types of data.
+func LoadContent (data []byte, unsafe...bool) (*Parser, error) {
+    if j, e := gjson.LoadContent(data, unsafe...); e == nil {
         return &Parser{j}, nil
     } else {
         return nil, e
     }
 }
 
-// 设置自定义的层级分隔符号
+// SetSplitChar sets the separator char for hierarchical data access.
 func (p *Parser) SetSplitChar(char byte) {
     p.json.SetSplitChar(char)
 }
 
-// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
-// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
+// SetViolenceCheck enables/disables violence check for hierarchical data access.
 func (p *Parser) SetViolenceCheck(check bool) {
     p.json.SetViolenceCheck(check)
 }
 
-// 将指定的json内容转换为指定结构返回，查找失败或者转换失败，目标对象转换为nil
-// 注意第二个参数需要给的是变量地址
+// GetToVar gets the value by specified <pattern>,
+// and converts it to specified golang variable <v>.
+// The <v> should be a pointer type.
 func (p *Parser) GetToVar(pattern string, v interface{}) error {
     return p.json.GetToVar(pattern, v)
 }
 
-// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetMap gets the value by specified <pattern>,
+// and converts it to map[string]interface{}.
 func (p *Parser) GetMap(pattern string) map[string]interface{} {
     return p.json.GetMap(pattern)
 }
 
-// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
+// GetArray gets the value by specified <pattern>,
+// and converts it to a slice of []interface{}.
 func (p *Parser) GetArray(pattern string) []interface{} {
     return p.json.GetArray(pattern)
 }
 
-// 返回指定json中的string
+// GetString gets the value by specified <pattern>,
+// and converts it to string.
 func (p *Parser) GetString(pattern string) string {
     return p.json.GetString(pattern)
 }
 
+// GetStrings gets the value by specified <pattern>,
+// and converts it to a slice of []string.
 func (p *Parser) GetStrings(pattern string) []string {
     return p.json.GetStrings(pattern)
 }
@@ -97,7 +107,10 @@ func (p *Parser) GetTimeDuration(pattern string) time.Duration {
     return p.json.GetTimeDuration(pattern)
 }
 
-// 返回指定json中的bool(false:"", 0, false, off)
+// GetBool gets the value by specified <pattern>,
+// and converts it to bool.
+// It returns false when value is: "", 0, false, off, nil;
+// or returns true instead.
 func (p *Parser) GetBool(pattern string) bool {
     return p.json.GetBool(pattern)
 }
@@ -158,51 +171,60 @@ func (p *Parser) GetFloats(pattern string) []float64 {
     return p.json.GetFloats(pattern)
 }
 
-// 将指定变量转换为struct对象(对象属性赋值)
+// GetToStruct gets the value by specified <pattern>,
+// and converts it to specified object <objPointer>.
+// The <objPointer> should be the pointer to an object.
 func (p *Parser) GetToStruct(pattern string, objPointer interface{}) error {
     return p.json.GetToStruct(pattern, objPointer)
 }
 
-// 根据pattern查找并设置数据
-// 注意：写入的时候"."符号只能表示层级，不能使用带"."符号的键名
+// Set sets value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (p *Parser) Set(pattern string, value interface{}) error {
     return p.json.Set(pattern, value)
 }
 
-// 计算指定pattern的元素长度(pattern对应数据类型为map[string]interface{}/[]interface{}时有效)
+// Len returns the length/size of the value by specified <pattern>.
+// The target value by <pattern> should be type of slice or map.
+// It returns -1 if the target value is not found, or its type is invalid.
 func (p *Parser) Len(pattern string) int {
     return p.json.Len(pattern)
 }
 
-// 指定pattern追加元素
+// Append appends value to the value by specified <pattern>.
+// The target value by <pattern> should be type of slice.
 func (p *Parser) Append(pattern string, value interface{}) error {
     return p.json.Append(pattern, value)
 }
 
-// 动态删除变量节点
+// Remove deletes value with specified <pattern>.
+// It supports hierarchical data access by char separator, which is '.' in default.
 func (p *Parser) Remove(pattern string) error {
     return p.json.Remove(pattern)
 }
 
-// 根据约定字符串方式访问json解析数据，参数形如： "items.name.first", "list.0"; 当pattern为空时，表示获取所有数据
-// 返回的结果类型的interface{}，因此需要自己做类型转换;
-// 如果找不到对应节点的数据，返回nil;
+// Get returns value by specified <pattern>.
+// It returns all values of current Json object, if <pattern> is empty or not specified.
+// It returns nil if no value found by <pattern>.
+//
+// We can also access slice item by its index number in <pattern>,
+// eg: "items.name.first", "list.10".
 func (p *Parser) Get(pattern...string) interface{} {
     return p.json.Get(pattern...)
 }
 
-// 转换为map[string]interface{}类型,如果转换失败，返回nil
+// ToMap converts current object values to map[string]interface{}.
+// It returns nil if fails.
 func (p *Parser) ToMap() map[string]interface{} {
     return p.json.ToMap()
 }
 
-// 转换为[]interface{}类型,如果转换失败，返回nil
+// ToArray converts current object values to []interface{}.
+// It returns nil if fails.
 func (p *Parser) ToArray() []interface{} {
     return p.json.ToArray()
 }
 
-/* 以下为数据文件格式转换，支持类型：xml, json, yaml/yml, toml */
-
 func (p *Parser) ToXml(rootTag...string) ([]byte, error) {
     return p.json.ToXml(rootTag...)
 }
@@ -227,12 +249,13 @@ func (p *Parser) ToToml() ([]byte, error) {
     return p.json.ToToml()
 }
 
-// 打印Json对象
+// Dump prints current Json object with more manually readable.
 func (p *Parser) Dump() error {
     return p.json.Dump()
 }
 
-// 将变量解析为对应的struct对象，注意传递的参数为struct对象指针
+// ToStruct converts current Json object to specified object.
+// The <objPointer> should be a pointer type.
 func (p *Parser) ToStruct(o interface{}) error {
     return p.json.ToStruct(o)
 }
@@ -261,7 +284,6 @@ func VarToToml(value interface{}) ([]byte, error) {
     return New(value).ToToml()
 }
 
-// 将变量解析为对应的struct对象，注意传递的参数为struct对象指针
 func VarToStruct(value interface{}, obj interface{}) error {
     return New(value).ToStruct(obj)
 }

g/encoding/gparser/gparser_unit_basic_test.go

@@ -0,0 +1,208 @@
+// 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.
+
+package gparser_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gparser"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+func Test_New(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.Assert(j.Get("n"), "123456789")
+        gtest.Assert(j.Get("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.Get("a"), g.Slice{1, 2, 3})
+    })
+}
+
+func Test_NewUnsafe(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.NewUnsafe(data)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Encode(t *testing.T) {
+    value := g.Slice{1, 2, 3}
+    gtest.Case(t, func() {
+        b, err := gparser.VarToJson(value)
+        gtest.Assert(err, nil)
+        gtest.Assert(b,   []byte(`[1,2,3]`))
+    })
+}
+
+func Test_Decode(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_SplitChar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        j.SetSplitChar(byte('#'))
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m#k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a#1"), 2)
+    })
+}
+
+func Test_ViolenceCheck(t *testing.T) {
+    data := []byte(`{"m":{"a":[1,2,3], "v1.v2":"4"}}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.Get("m.a.2"),   3)
+        gtest.Assert(j.Get("m.v1.v2"), nil)
+        j.SetViolenceCheck(true)
+        gtest.Assert(j.Get("m.v1.v2"), 4)
+    })
+}
+
+func Test_GetToVar(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        var m map[string]string
+        var n int
+        var a []int
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+
+        j.GetToVar("n", &n)
+        j.GetToVar("m", &m)
+        j.GetToVar("a", &a)
+
+        gtest.Assert(n, "123456789")
+        gtest.Assert(m, g.Map{"k" : "v"})
+        gtest.Assert(a, g.Slice{1, 2, 3})
+    })
+}
+
+func Test_GetMap(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.GetMap("n"), nil)
+        gtest.Assert(j.GetMap("m"), g.Map{"k" : "v"})
+        gtest.Assert(j.GetMap("a"), nil)
+    })
+}
+
+func Test_GetArray(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.Assert(j.GetArray("n"), g.Array{123456789})
+        gtest.Assert(j.GetArray("m"), g.Array{g.Map{"k":"v"}})
+        gtest.Assert(j.GetArray("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_GetString(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetString("n"), "123456789")
+        gtest.AssertEQ(j.GetString("m"), `{"k":"v"}`)
+        gtest.AssertEQ(j.GetString("a"), `[1,2,3]`)
+        gtest.AssertEQ(j.GetString("i"), "")
+    })
+}
+
+func Test_GetStrings(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetStrings("n"), g.SliceStr{"123456789"})
+        gtest.AssertEQ(j.GetStrings("m"), g.SliceStr{`{"k":"v"}`})
+        gtest.AssertEQ(j.GetStrings("a"), g.SliceStr{"1", "2", "3"})
+        gtest.AssertEQ(j.GetStrings("i"), nil)
+    })
+}
+
+func Test_GetInterfaces(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    gtest.Case(t, func() {
+        j := gparser.New(data)
+        gtest.AssertNE(j, nil)
+        gtest.AssertEQ(j.GetInterfaces("n"), g.Array{123456789})
+        gtest.AssertEQ(j.GetInterfaces("m"), g.Array{g.Map{"k":"v"}})
+        gtest.AssertEQ(j.GetInterfaces("a"), g.Array{1,2,3})
+    })
+}
+
+func Test_Len(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Len("a"), 2)
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Set("a", 1)
+        gtest.Assert(p.Len("a"), -1)
+    })
+}
+
+func Test_Append(t *testing.T) {
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a", 1)
+        p.Append("a", 2)
+        gtest.Assert(p.Get("a"), g.Slice{1, 2})
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Append("a.b", 1)
+        p.Append("a.c", 2)
+        gtest.Assert(p.Get("a"), g.Map{
+            "b" : g.Slice{1},
+            "c" : g.Slice{2},
+        })
+    })
+    gtest.Case(t, func() {
+        p := gparser.New(nil)
+        p.Set("a", 1)
+        err := p.Append("a", 2)
+        gtest.AssertNE(err, nil)
+        gtest.Assert(p.Get("a"), 1)
+    })
+}
+
+
+

g/encoding/gparser/gparser_unit_load_test.go

@@ -0,0 +1,156 @@
+// 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.
+
+package gparser_test
+
+import (
+    "github.com/gogf/gf/g"
+    "github.com/gogf/gf/g/encoding/gparser"
+    "github.com/gogf/gf/g/os/gfile"
+    "github.com/gogf/gf/g/test/gtest"
+    "testing"
+)
+
+
+func Test_Load_JSON(t *testing.T) {
+    data := []byte(`{"n":123456789, "m":{"k":"v"}, "a":[1,2,3]}`)
+    // JSON
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,        nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // JSON
+    gtest.Case(t, func() {
+        path := "test.json"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_XML(t *testing.T) {
+    data := []byte(`<doc><a>1</a><a>2</a><a>3</a><m><k>v</k></m><n>123456789</n></doc>`)
+    // XML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+    // XML
+    gtest.Case(t, func() {
+        path := "test.xml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err, nil)
+        gtest.Assert(j.Get("doc.n"),   "123456789")
+        gtest.Assert(j.Get("doc.m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("doc.m.k"), "v")
+        gtest.Assert(j.Get("doc.a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("doc.a.1"), 2)
+    })
+}
+
+func Test_Load_YAML1(t *testing.T) {
+    data := []byte(`
+a:
+- 1
+- 2
+- 3
+m:
+ k: v
+"n": 123456789
+    `)
+    // YAML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // YAML
+    gtest.Case(t, func() {
+        path := "test.yaml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_YAML2(t *testing.T) {
+    data := []byte("i : 123456789")
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}
+
+func Test_Load_TOML1(t *testing.T) {
+    data := []byte(`
+a = ["1", "2", "3"]
+n = "123456789"
+
+[m]
+  k = "v"
+`)
+    // TOML
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+    // TOML
+    gtest.Case(t, func() {
+        path := "test.toml"
+        gfile.PutBinContents(path, data)
+        defer gfile.Remove(path)
+        j, err := gparser.Load(path)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("n"),   "123456789")
+        gtest.Assert(j.Get("m"),   g.Map{"k" : "v"})
+        gtest.Assert(j.Get("m.k"), "v")
+        gtest.Assert(j.Get("a"),   g.Slice{1, 2, 3})
+        gtest.Assert(j.Get("a.1"), 2)
+    })
+}
+
+func Test_Load_TOML2(t *testing.T) {
+    data := []byte("i=123456789")
+    gtest.Case(t, func() {
+        j, err := gparser.LoadContent(data)
+        gtest.Assert(err,          nil)
+        gtest.Assert(j.Get("i"),   "123456789")
+    })
+}

g/encoding/gparser/gparser_unit_set_test.go

@@ -4,8 +4,6 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// 单元测试
-
 package gparser_test
 
 import (
@@ -22,7 +20,6 @@ func Test_Set1(t *testing.T) {
     })
     p.Set("k1.k11", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, []byte(`{"k1":{"k11":[1,2,3]},"k2":"v2"}`)) != 0 {
             t.Error("expect:", string(e))
         }
@@ -36,7 +33,6 @@ func Test_Set2(t *testing.T) {
     p := gparser.New([]string{"a"})
     p.Set("0.1", 1)
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -48,11 +44,10 @@ func Test_Set2(t *testing.T) {
 func Test_Set3(t *testing.T) {
     e := []byte(`{"kv":{"k1":"v1"}}`)
     p := gparser.New([]string{"a"})
-    p.Set("kv", map[string]string{
+    p.Set("kv", map[string]string {
         "k1" : "v1",
     })
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -68,7 +63,6 @@ func Test_Set4(t *testing.T) {
         "k1" : "v1",
     })
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -82,7 +76,6 @@ func Test_Set5(t *testing.T) {
     p := gparser.New([]string{"a"})
     p.Set("0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -96,7 +89,6 @@ func Test_Set6(t *testing.T) {
     p := gparser.New([]string{"a"})
     p.Set("1", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -113,7 +105,6 @@ func Test_Set7(t *testing.T) {
     })
     p.Set("0.1", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -130,7 +121,6 @@ func Test_Set8(t *testing.T) {
     })
     p.Set("0.0.0.0.0.0.1", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -147,7 +137,6 @@ func Test_Set9(t *testing.T) {
     })
     p.Set("k1.1", []int{1,2,3})
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -162,7 +151,6 @@ func Test_Set10(t *testing.T) {
     p := gparser.New(nil)
     p.Set("a.b.c", 1)
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -174,10 +162,9 @@ func Test_Set10(t *testing.T) {
 
 func Test_Set11(t *testing.T) {
     e    := []byte(`{"a":{"b":{}}}`)
-    p, _ := gparser.LoadContent([]byte(`{"a":{"b":{"c":1}}}`), "json")
+    p, _ := gparser.LoadContent([]byte(`{"a":{"b":{"c":1}}}`))
     p.Remove("a.b.c")
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -192,7 +179,6 @@ func Test_Set12(t *testing.T) {
     p.Set("0", 0)
     p.Set("1", 1)
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -207,7 +193,6 @@ func Test_Set13(t *testing.T) {
     p.Set("array.0", 0)
     p.Set("array.1", 1)
     if c, err := p.ToJson(); err == nil {
-        
         if bytes.Compare(c, e) != 0 {
             t.Error("expect:", string(e))
         }
@@ -216,7 +201,16 @@ func Test_Set13(t *testing.T) {
     }
 }
 
-
-
-
-
+func Test_Set14(t *testing.T) {
+    e := []byte(`{"f":{"a":1}}`)
+    p := gparser.New(nil)
+    p.Set("f",   "m")
+    p.Set("f.a", 1)
+    if c, err := p.ToJson(); err == nil {
+        if bytes.Compare(c, e) != 0 {
+            t.Error("expect:", string(e))
+        }
+    } else {
+        t.Error(err)
+    }
+}

g/encoding/gxml/gxml.go

@@ -10,58 +10,55 @@
 package gxml
 
 import (
-    "github.com/gogf/gf/third/github.com/clbanning/mxj"
-    "encoding/xml"
-    "io"
+	"fmt"
 	"github.com/gogf/gf/g/text/gregex"
 	"github.com/gogf/gf/third/github.com/axgle/mahonia"
-	"errors"
-	"fmt"
+	"github.com/gogf/gf/third/github.com/clbanning/mxj"
 	"strings"
 )
 
 // 将XML内容解析为map变量
 func Decode(content []byte) (map[string]interface{}, error) {
-    prepare(content)
-    return mxj.NewMapXml(content)
+	res, err := convert(content)
+	if err != nil {
+		return nil, err
+	}
+	return mxj.NewMapXml(res)
 }
 
 // 将map变量解析为XML格式内容
-func Encode(v map[string]interface{}, rootTag...string) ([]byte, error) {
-    return mxj.Map(v).Xml(rootTag...)
+func Encode(v map[string]interface{}, rootTag ...string) ([]byte, error) {
+	return mxj.Map(v).Xml(rootTag...)
 }
 
-func EncodeWithIndent(v map[string]interface{}, rootTag...string) ([]byte, error) {
-    return mxj.Map(v).XmlIndent("", "\t", rootTag...)
+func EncodeWithIndent(v map[string]interface{}, rootTag ...string) ([]byte, error) {
+	return mxj.Map(v).XmlIndent("", "\t", rootTag...)
 }
 
 // XML格式内容直接转换为JSON格式内容
 func ToJson(content []byte) ([]byte, error) {
-    prepare(content)
-	mv, err := mxj.NewMapXml(content)
+	res, err := convert(content)
+	if err != nil {
+		fmt.Println("convert error. ", err)
+		return nil, err
+	}
+
+	mv, err := mxj.NewMapXml(res)
 	if err == nil {
-        return mv.Json()
-    } else {
-        return nil, err
-    }
+		return mv.Json()
+	} else {
+		return nil, err
+	}
 }
 
 // XML字符集预处理
 // @author wenzi1
-// @date 20180604
-func prepare(xmlbyte []byte) error {
+// @date 20180604  修复并发安全问题,改为如果非UTF8字符集则先做字符集转换
+func convert(xmlbyte []byte) (res []byte, err error) {
 	patten := `<\?xml.*encoding\s*=\s*['|"](.*?)['|"].*\?>`
-	charsetReader := func(charset string, input io.Reader) (io.Reader, error) {
-		reader := mahonia.GetCharset(charset)
-		if reader == nil {
-			return nil, errors.New(fmt.Sprintf("not support charset:%s", charset))
-		}
-		return reader.NewDecoder().NewReader(input), nil
-	}
-
 	matchStr, err := gregex.MatchString(patten, string(xmlbyte))
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	xmlEncode := "UTF-8"
@@ -69,13 +66,19 @@ func prepare(xmlbyte []byte) error {
 		xmlEncode = matchStr[1]
 	}
 
-	charset := mahonia.GetCharset(xmlEncode)
-	if charset == nil {
-		return errors.New(fmt.Sprintf("not support charset:%s", xmlEncode))
+	s := mahonia.GetCharset(xmlEncode)
+	if s == nil {
+		return nil, fmt.Errorf("not support charset:%s\n", xmlEncode)
 	}
 
-	if !strings.EqualFold(charset.Name, "UTF-8") {
-		mxj.CustomDecoder = &xml.Decoder{Strict : false, CharsetReader : charsetReader}
+	res, err = gregex.Replace(patten, []byte(""), []byte(xmlbyte))
+	if err != nil {
+		return nil, err
 	}
-	return nil
-}
+
+	if !strings.EqualFold(s.Name, "UTF-8") {
+		res = []byte(s.NewDecoder().ConvertString(string(res)))
+	}
+
+	return res, nil
+}

g/encoding/gxml/gxml_test.go

@@ -0,0 +1,140 @@
+// 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.
+
+package gxml_test
+
+import (
+	"bytes"
+	"github.com/gogf/gf/g/encoding/gcharset"
+	"github.com/gogf/gf/g/encoding/gparser"
+	"github.com/gogf/gf/g/encoding/gxml"
+	"strings"
+	"testing"
+)
+
+var testData = []struct {
+	utf8, other, otherEncoding string
+}{
+	{"Hello 常用國字標準字體表", "Hello \xb1`\xa5\u03b0\xea\xa6r\xbc\u0437\u01e6r\xc5\xe9\xaa\xed", "big5"},
+	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gbk"},
+	{"Hello 常用國字標準字體表", "Hello \xb3\xa3\xd3\xc3\x87\xf8\xd7\xd6\x98\xcb\x9c\xca\xd7\xd6\xf3\x77\xb1\xed", "gb18030"},
+}
+
+func buildXml(charset string, str string) (string, string) {
+	head := `<?xml version="1.0" encoding="UTF-8"?>`
+	srcXml := strings.Replace(head, "UTF-8", charset, -1)
+
+	srcParser := gparser.New(nil)
+	srcParser.Set("name", str)
+	srcParser.Set("age", "12")
+
+	s, err := srcParser.ToXml()
+	if err != nil {
+		return "", ""
+	}
+
+	srcXml = srcXml + string(s)
+	srcXml, err = gcharset.UTF8To(charset, srcXml)
+	if err != nil {
+		return "", ""
+	}
+
+	dstXml := head + string(s)
+
+	return srcXml, dstXml
+}
+
+//测试XML中字符集的转换
+func Test_XmlToJson(t *testing.T) {
+	for _, v := range testData {
+		srcXml, dstXml := buildXml(v.otherEncoding, v.utf8)
+		if len(srcXml) == 0 && len(dstXml) == 0 {
+			t.Errorf("build xml string error. srcEncoding:%s, src:%s, utf8:%s", v.otherEncoding, v.other, v.utf8)
+		}
+
+		srcJson, err := gxml.ToJson([]byte(srcXml))
+		if err != nil {
+			t.Errorf("gxml.ToJson error. %s", srcXml)
+		}
+
+		dstJson, err := gxml.ToJson([]byte(dstXml))
+		if err != nil {
+			t.Errorf("dstXml to json error. %s", dstXml)
+		}
+
+		if bytes.Compare(srcJson, dstJson) != 0 {
+			t.Errorf("convert to json error. srcJson:%s, dstJson:%s", string(srcJson), string(dstJson))
+		}
+
+	}
+}
+
+func Test_Decode(t *testing.T) {
+	for _, v := range testData {
+		srcXml, dstXml := buildXml(v.otherEncoding, v.utf8)
+		if len(srcXml) == 0 && len(dstXml) == 0 {
+			t.Errorf("build xml string error. srcEncoding:%s, src:%s, utf8:%s", v.otherEncoding, v.other, v.utf8)
+		}
+
+		srcMap, err := gxml.Decode([]byte(srcXml))
+		if err != nil {
+			t.Errorf("gxml.Decode error. %s", srcXml)
+		}
+
+		dstMap, err := gxml.Decode([]byte(dstXml))
+		if err != nil {
+			t.Errorf("gxml decode error. %s", dstXml)
+		}
+		s := srcMap["doc"].(map[string]interface{})
+		d := dstMap["doc"].(map[string]interface{})
+		for kk, vv := range s {
+			if vv.(string) != d[kk].(string) {
+				t.Errorf("convert to map error. src:%v, dst:%v", vv, d[kk])
+			}
+		}
+	}
+}
+
+func Test_Encode(t *testing.T) {
+	m := make(map[string]interface{})
+	v := map[string]interface{}{
+		"string": "hello world",
+		"int":    123,
+		"float":  100.92,
+		"bool":   true,
+	}
+	m["root"] = interface{}(v)
+
+	xmlStr, err := gxml.Encode(m)
+	if err != nil {
+		t.Errorf("encode error.")
+	}
+	t.Logf("%s\n", string(xmlStr))
+
+	res := `<root><bool>true</bool><float>100.92</float><int>123</int><string>hello world</string></root>`
+	if string(xmlStr) != res {
+		t.Errorf("encode error. result: [%s], expect:[%s]", string(xmlStr), res)
+	}
+}
+
+func Test_EncodeIndent(t *testing.T) {
+	m := make(map[string]interface{})
+	v := map[string]interface{}{
+		"string": "hello world",
+		"int":    123,
+		"float":  100.92,
+		"bool":   true,
+	}
+	m["root"] = interface{}(v)
+
+	xmlStr, err := gxml.EncodeWithIndent(m, "xml")
+	if err != nil {
+		t.Errorf("encodeWithIndent error.")
+	}
+
+	t.Logf("%s\n", string(xmlStr))
+
+}

g/frame/frame.go

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

g/frame/gins/gins.go

@@ -4,32 +4,25 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gins provides instances management and some core components.
-// 
-// 单例对象管理.
-// 框架内置了一些核心对象获取方法，并且可以通过Set和Get方法实现IoC以及对内置核心对象的自定义替换
+// Package gins provides instances management and core components management.
 package gins
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/database/gdb"
-    "github.com/gogf/gf/g/database/gredis"
-    "github.com/gogf/gf/g/internal/cmdenv"
-    "github.com/gogf/gf/g/os/gcfg"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gfsnotify"
-    "github.com/gogf/gf/g/os/glog"
-    "github.com/gogf/gf/g/os/gview"
-    "github.com/gogf/gf/g/text/gstr"
-    "github.com/gogf/gf/g/util/gconv"
-    "github.com/gogf/gf/g/text/gregex"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/database/gdb"
+	"github.com/gogf/gf/g/database/gredis"
+	"github.com/gogf/gf/g/os/gcfg"
+	"github.com/gogf/gf/g/os/gfsnotify"
+	"github.com/gogf/gf/g/os/glog"
+	"github.com/gogf/gf/g/os/gview"
+	"github.com/gogf/gf/g/text/gregex"
+	"github.com/gogf/gf/g/text/gstr"
+	"github.com/gogf/gf/g/util/gconv"
+	"time"
 )
 
 const (
-    gFRAME_CORE_COMPONENT_NAME_VIEW       = "gf.core.component.view"
-    gFRAME_CORE_COMPONENT_NAME_CONFIG     = "gf.core.component.config"
     gFRAME_CORE_COMPONENT_NAME_REDIS      = "gf.core.component.redis"
     gFRAME_CORE_COMPONENT_NAME_DATABASE   = "gf.core.component.database"
 )
@@ -67,62 +60,20 @@ func SetIfNotExist(key string, value interface{}) bool {
     return instances.SetIfNotExist(key, value)
 }
 
-// 核心对象：View
-func View(name...string) *gview.View {
-    group := "default"
-    if len(name) > 0 {
-        group = name[0]
-    }
-    key := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_VIEW, group)
-    return instances.GetOrSetFuncLock(key, func() interface{} {
-        view := gview.New(gfile.Pwd())
-        // 自定义的环境变量/启动参数路径，优先级最高，覆盖默认的工作目录
-        if envPath := cmdenv.Get("gf.gview.path").String(); envPath != "" && gfile.Exists(envPath) {
-            view.SetPath(envPath)
-        }
-        // 二进制文件执行目录
-        if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
-            view.AddPath(selfPath)
-        }
-        // 开发环境源码main包目录
-        if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
-            view.AddPath(mainPath)
-        }
-        // 框架内置函数
-        view.BindFunc("config", funcConfig)
-        return view
-    }).(*gview.View)
+// View returns an instance of View with default settings.
+// The param <name> is the name for the instance.
+func View(name ...string) *gview.View {
+	return gview.Instance(name ...)
 }
 
-// 核心对象：Config
-// 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
-func Config(file...string) *gcfg.Config {
-    configFile := gcfg.DEFAULT_CONFIG_FILE
-    if len(file) > 0 {
-        configFile = file[0]
-    }
-    return instances.GetOrSetFuncLock(fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile),
-        func() interface{} {
-            // 默认当前工作目录
-            config := gcfg.New(gfile.Pwd(), configFile)
-            // 自定义的环境变量/启动参数路径，优先级最高，覆盖默认的工作目录
-            if envPath := cmdenv.Get("gf.gcfg.path").String(); envPath != "" && gfile.Exists(envPath) {
-                config.SetPath(envPath)
-            }
-            // 二进制文件执行目录
-            if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
-                config.AddPath(selfPath)
-            }
-            // 开发环境源码main包目录
-            if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
-                config.AddPath(mainPath)
-            }
-            return config
-    }).(*gcfg.Config)
+// Config returns an instance of View with default settings.
+// The param <name> is the name for the instance.
+func Config(name ...string) *gcfg.Config {
+    return gcfg.Instance(name ...)
 }
 
 // 数据库操作对象，使用了连接池
-func Database(name...string) gdb.DB {
+func Database(name ...string) gdb.DB {
     config := Config()
     group  := gdb.DEFAULT_GROUP_NAME
     if len(name) > 0 {
@@ -139,62 +90,66 @@ func Database(name...string) gdb.DB {
             for group, v := range m {
                 cg := gdb.ConfigGroup{}
                 if list, ok := v.([]interface{}); ok {
-                    for _, nodev := range list {
-                        node  := gdb.ConfigNode{}
-                        nodem := nodev.(map[string]interface{})
-                        if value, ok := nodem["host"]; ok {
+                    for _, nodeValue := range list {
+                        node    := gdb.ConfigNode{}
+                        nodeMap := nodeValue.(map[string]interface{})
+                        if value, ok := nodeMap["host"]; ok {
                             node.Host = gconv.String(value)
                         }
-                        if value, ok := nodem["port"]; ok {
+                        if value, ok := nodeMap["port"]; ok {
                             node.Port = gconv.String(value)
                         }
-                        if value, ok := nodem["user"]; ok {
+                        if value, ok := nodeMap["user"]; ok {
                             node.User = gconv.String(value)
                         }
-                        if value, ok := nodem["pass"]; ok {
+                        if value, ok := nodeMap["pass"]; ok {
                             node.Pass = gconv.String(value)
                         }
-                        if value, ok := nodem["name"]; ok {
+                        if value, ok := nodeMap["name"]; ok {
                             node.Name = gconv.String(value)
                         }
-                        if value, ok := nodem["type"]; ok {
+                        if value, ok := nodeMap["type"]; ok {
                             node.Type = gconv.String(value)
                         }
-                        if value, ok := nodem["role"]; ok {
+                        if value, ok := nodeMap["role"]; ok {
                             node.Role = gconv.String(value)
                         }
-                        if value, ok := nodem["charset"]; ok {
+                        if value, ok := nodeMap["charset"]; ok {
                             node.Charset = gconv.String(value)
                         }
-                        if value, ok := nodem["priority"]; ok {
+                        if value, ok := nodeMap["priority"]; ok {
                             node.Priority = gconv.Int(value)
                         }
                         // Deprecated
-                        if value, ok := nodem["linkinfo"]; ok {
-                            node.Linkinfo = gconv.String(value)
-                        }
-                        if value, ok := nodem["linkInfo"]; ok {
-                            node.Linkinfo = gconv.String(value)
+                        if value, ok := nodeMap["linkinfo"]; ok {
+                            node.LinkInfo = gconv.String(value)
                         }
                         // Deprecated
-                        if value, ok := nodem["max-idle"]; ok {
+                        if value, ok := nodeMap["link-info"]; ok {
+                            node.LinkInfo = gconv.String(value)
+                        }
+                        if value, ok := nodeMap["linkInfo"]; ok {
+                            node.LinkInfo = gconv.String(value)
+                        }
+                        // Deprecated
+                        if value, ok := nodeMap["max-idle"]; ok {
                             node.MaxIdleConnCount = gconv.Int(value)
                         }
-                        if value, ok := nodem["maxIdle"]; ok {
+                        if value, ok := nodeMap["maxIdle"]; ok {
                             node.MaxIdleConnCount = gconv.Int(value)
                         }
                         // Deprecated
-                        if value, ok := nodem["max-open"]; ok {
+                        if value, ok := nodeMap["max-open"]; ok {
                             node.MaxOpenConnCount = gconv.Int(value)
                         }
-                        if value, ok := nodem["maxOpen"]; ok {
+                        if value, ok := nodeMap["maxOpen"]; ok {
                             node.MaxOpenConnCount = gconv.Int(value)
                         }
                         // Deprecated
-                        if value, ok := nodem["max-lifetime"]; ok {
+                        if value, ok := nodeMap["max-lifetime"]; ok {
                             node.MaxConnLifetime = gconv.Int(value)
                         }
-                        if value, ok := nodem["maxLifetime"]; ok {
+                        if value, ok := nodeMap["maxLifetime"]; ok {
                             node.MaxConnLifetime = gconv.Int(value)
                         }
                         cg = append(cg, node)
@@ -202,10 +157,7 @@ func Database(name...string) gdb.DB {
                 }
                 gdb.AddConfigGroup(group, cg)
             }
-            // 使用gfsnotify进行文件监控，当配置文件有任何变化时，清空数据库配置缓存
-            gfsnotify.Add(config.GetFilePath(), func(event *gfsnotify.Event) {
-                instances.Remove(key)
-            })
+            addConfigMonitor(key, config)
         }
         if db, err := gdb.New(name...); err == nil {
             return db
@@ -235,29 +187,31 @@ func Redis(name...string) *gredis.Redis {
                 line := gconv.String(v)
                 array, _ := gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)\?(.+)`, line)
                 if len(array) == 6 {
-                    parse, _ := gstr.Parse(array[5])
-                    config   := gredis.Config{
+                    parse, _    := gstr.Parse(array[5])
+                    redisConfig := gredis.Config{
                         Host : array[1],
                         Port : gconv.Int(array[2]),
                         Db   : gconv.Int(array[3]),
                         Pass : array[4],
                     }
                     if v, ok := parse["maxIdle"]; ok {
-                        config.MaxIdle = gconv.Int(v)
+                        redisConfig.MaxIdle = gconv.Int(v)
                     }
                     if v, ok := parse["maxActive"]; ok {
-                        config.MaxActive = gconv.Int(v)
+                        redisConfig.MaxActive = gconv.Int(v)
                     }
                     if v, ok := parse["idleTimeout"]; ok {
-                        config.IdleTimeout = gconv.TimeDuration(v)*time.Second
+                        redisConfig.IdleTimeout = gconv.TimeDuration(v)*time.Second
                     }
                     if v, ok := parse["maxConnLifetime"]; ok {
-                        config.MaxConnLifetime = gconv.TimeDuration(v)*time.Second
+                        redisConfig.MaxConnLifetime = gconv.TimeDuration(v)*time.Second
                     }
-                    return gredis.New(config)
+                    addConfigMonitor(key, config)
+                    return gredis.New(redisConfig)
                 }
                 array, _ = gregex.MatchString(`(.+):(\d+),{0,1}(\d*),{0,1}(.*)`, line)
                 if len(array) == 5 {
+                    addConfigMonitor(key, config)
                     return gredis.New(gredis.Config{
                         Host : array[1],
                         Port : gconv.Int(array[2]),
@@ -281,6 +235,16 @@ func Redis(name...string) *gredis.Redis {
     return nil
 }
 
+// 添加对单例对象的配置文件inotify监控
+func addConfigMonitor(key string, config *gcfg.Config) {
+    // 使用gfsnotify进行文件监控，当配置文件有任何变化时，清空对象单例缓存
+    if path := config.GetFilePath(); path != "" {
+        gfsnotify.Add(path, func(event *gfsnotify.Event) {
+            instances.Remove(key)
+        })
+    }
+}
+
 // 模板内置方法：config
 func funcConfig(pattern string, file...string) string {
     return Config().GetString(pattern, file...)

g/frame/gins/gins_config_test.go

@@ -7,13 +7,13 @@
 package gins_test
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/frame/gins"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/test/gtest"
-    "testing"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/frame/gins"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+	"testing"
+	"time"
 )
 
 func Test_Config(t *testing.T) {
@@ -51,13 +51,14 @@ test = "v=1"
     gtest.Case(t, func() {
         gtest.AssertNE(gins.Config(), nil)
     })
+
     // relative path
     gtest.Case(t, func() {
         path := "config.toml"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config().Get("test"), "v=1")
         gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
         gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
@@ -71,7 +72,7 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config().Get("test"), "v=1")
         gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
         gtest.Assert(gins.Config().Get("redis.disk"), "127.0.0.1:6379,0")
@@ -84,10 +85,11 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
-        gtest.Assert(gins.Config("test.toml").Get("test"), "v=1")
-        gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
-        gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").Get("test"), "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
     })
     // for gfsnotify callbacks to refresh cache of config file
     time.Sleep(500*time.Millisecond)
@@ -97,10 +99,11 @@ test = "v=1"
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
-        defer gins.Config().Reload()
-        gtest.Assert(gins.Config("test.toml").Get("test"), "v=1")
-        gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
-        gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").Get("test"), "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
     })
     // for gfsnotify callbacks to refresh cache of config file
     time.Sleep(500*time.Millisecond)
@@ -113,7 +116,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config().AddPath(path), nil)
         gtest.Assert(gins.Config().Get("test"),   "v=1")
         gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
@@ -127,7 +130,7 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config().Reload()
+        defer gins.Config().Clear()
         gtest.Assert(gins.Config().AddPath(path), nil)
         gtest.Assert(gins.Config().Get("test"),   "v=1")
         gtest.Assert(gins.Config().Get("database.default.1.host"), "127.0.0.1")
@@ -141,12 +144,12 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config("test.toml").Reload()
-
-        gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
-        gtest.Assert(gins.Config("test.toml").Get("test"),   "v=1")
-        gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
-        gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
+        defer gins.Config("test").Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").AddPath(path), nil)
+        gtest.Assert(gins.Config("test").Get("test"),   "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
     })
     time.Sleep(500*time.Millisecond)
 
@@ -156,11 +159,11 @@ test = "v=1"
         err  := gfile.PutContents(file, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(file)
-        defer gins.Config("test.toml").Reload()
-
-        gtest.Assert(gins.Config("test.toml").AddPath(path), nil)
-        gtest.Assert(gins.Config("test.toml").Get("test"),   "v=1")
-        gtest.Assert(gins.Config("test.toml").Get("database.default.1.host"), "127.0.0.1")
-        gtest.Assert(gins.Config("test.toml").Get("redis.disk"), "127.0.0.1:6379,0")
+        defer gins.Config().Clear()
+	    gins.Config("test").SetFileName("test.toml")
+        gtest.Assert(gins.Config("test").AddPath(path), nil)
+        gtest.Assert(gins.Config("test").Get("test"),   "v=1")
+        gtest.Assert(gins.Config("test").Get("database.default.1.host"), "127.0.0.1")
+        gtest.Assert(gins.Config("test").Get("redis.disk"), "127.0.0.1:6379,0")
     })
 }

g/frame/gins/gins_database_test.go

@@ -53,7 +53,7 @@ test = "v=2"
     err  := gfile.PutContents(path, config)
     gtest.Assert(err, nil)
     defer gfile.Remove(path)
-    defer gins.Config().Reload()
+    defer gins.Config().Clear()
 
     // for gfsnotify callbacks to refresh cache of config file
     time.Sleep(500*time.Millisecond)

g/frame/gins/gins_redis_test.go

@@ -53,7 +53,7 @@ test = "v=3"
     err  := gfile.PutContents(path, config)
     gtest.Assert(err, nil)
     defer gfile.Remove(path)
-    defer gins.Config().Reload()
+    defer gins.Config().Clear()
 
     // for gfsnotify callbacks to refresh cache of config file
     time.Sleep(500*time.Millisecond)

g/g.go

@@ -9,13 +9,9 @@ package g
 import "github.com/gogf/gf/g/container/gvar"
 
 // Universal variable type, like generics.
-//
-// 动态变量类型，可以用该类型替代interface{}类型
 type Var        = gvar.Var
 
 // Frequently-used map type alias.
-//
-// 常用map数据结构(使用别名)
 type Map        = map[string]interface{}
 type MapAnyAny  = map[interface{}]interface{}
 type MapAnyStr  = map[interface{}]string
@@ -28,8 +24,6 @@ type MapIntStr  = map[int]string
 type MapIntInt  = map[int]int
 
 // Frequently-used slice type alias.
-//
-// 常用list数据结构(使用别名)
 type List       = []Map
 type ListAnyStr = []map[interface{}]string
 type ListAnyInt = []map[interface{}]int
@@ -41,8 +35,6 @@ type ListIntStr = []map[int]string
 type ListIntInt = []map[int]int
 
 // Frequently-used slice type alias.
-//
-// 常用slice数据结构(使用别名)
 type Slice      = []interface{}
 type SliceAny   = []interface{}
 type SliceStr   = []string

g/g_func.go

@@ -13,38 +13,28 @@ import (
     "github.com/gogf/gf/g/util/gutil"
 )
 
-// NewVar creates a *Var.
-//
-// 动态变量
+// NewVar returns a *gvar.Var.
 func NewVar(i interface{}, unsafe...bool) *Var {
     return gvar.New(i, unsafe...)
 }
 
 // Wait blocks until all the web servers shutdown.
-//
-// 阻塞等待HTTPServer执行完成(同一进程多HTTPServer情况下)
 func Wait() {
     ghttp.Wait()
 }
 
 // Dump dumps a variable to stdout with more manually readable.
-//
-// 格式化打印变量.
 func Dump(i...interface{}) {
     gutil.Dump(i...)
 }
 
 // Export exports a variable to string with more manually readable.
-//
-// 格式化导出变量.
 func Export(i...interface{}) string {
     return gutil.Export(i...)
 }
 
-// Throw throws a exception, which can be caught by Catch function.
+// Throw throws a exception, which can be caught by TryCatch function.
 // It always be used in TryCatch function.
-//
-// 抛出一个异常
 func Throw(exception interface{}) {
     gutil.Throw(exception)
 }
@@ -55,12 +45,8 @@ func TryCatch(try func(), catch ... func(exception interface{})) {
 }
 
 // IsEmpty checks given value empty or not.
-// false: integer(0), bool(false), slice/map(len=0), nil;
-// true : other.
-//
-// 判断给定的变量是否为空。
-// 整型为0, 布尔为false, slice/map长度为0, 其他为nil的情况，都为空。
-// 为空时返回true，否则返回false。
+// It returns false if value is: integer(0), bool(false), slice/map(len=0), nil;
+// or else true.
 func IsEmpty(value interface{}) bool {
     return empty.IsEmpty(value)
 }

g/g_logger.go

@@ -10,23 +10,17 @@ import (
     "github.com/gogf/gf/g/os/glog"
 )
 
-// Disable/Enabled debug of logging globally.
-//
-// 是否显示调试信息
+// SetDebug disables/enables debug level for logging globally.
 func SetDebug(debug bool) {
     glog.SetDebug(debug)
 }
 
-// Set the logging level globally.
-//
-// 设置日志的显示等级
+// SetLogLevel sets the logging level globally.
 func SetLogLevel(level int) {
     glog.SetLevel(level)
 }
 
-// Get the global logging level.
-//
-// 获取设置的日志显示等级
+// GetLogLevel returns the global logging level.
 func GetLogLevel() int {
     return glog.GetLevel()
 }

g/g_object.go

@@ -17,59 +17,42 @@ import (
     "github.com/gogf/gf/g/os/gcfg"
 )
 
-// Get an instance of http server with specified name.
-//
-// HTTPServer单例对象
+// Server returns an instance of http server with specified name.
 func Server(name...interface{}) *ghttp.Server {
     return ghttp.GetServer(name...)
 }
 
-// Get an instance of tcp server with specified name.
-//
-// TCPServer单例对象
+// TCPServer returns an instance of tcp server with specified name.
 func TCPServer(name...interface{}) *gtcp.Server {
     return gtcp.GetServer(name...)
 }
 
-// Get an instance of udp server with specified name.
-//
-// UDPServer单例对象
+// UDPServer returns an instance of udp server with specified name.
 func UDPServer(name...interface{}) *gudp.Server {
     return gudp.GetServer(name...)
 }
 
-// Get an instance of template engine object with specified name.
-//
-// 核心对象：View
+// View returns an instance of template engine object with specified name.
 func View(name...string) *gview.View {
     return gins.View(name...)
 }
 
-// Get an instance of config object with specified default config file name.
-//
-// Config配置管理对象,
-// 配置文件目录查找依次为：启动参数cfgpath、当前程序运行目录
+// Config returns an instance of config object with specified name.
 func Config(file...string) *gcfg.Config {
     return gins.Config(file...)
 }
 
-// Get an instance of database ORM object with specified configuration group name.
-//
-// 数据库操作对象，使用了连接池
+// Database returns an instance of database ORM object with specified configuration group name.
 func Database(name...string) gdb.DB {
     return gins.Database(name...)
 }
 
-// Alias of Database.
-//
-// (别名)Database
+// Alias of Database. See Database.
 func DB(name...string) gdb.DB {
     return gins.Database(name...)
 }
 
-// Get an instance of redis client with specified configuration group name.
-//
-// Redis操作对象，使用了连接池
+// Redis returns an instance of redis client with specified configuration group name.
 func Redis(name...string) *gredis.Redis {
     return gins.Redis(name...)
 }

g/g_setting.go

@@ -8,9 +8,8 @@ package g
 
 import "github.com/gogf/gf/g/net/ghttp"
 
-// SetServerGraceful enables/disables graceful reload feature of ghttp Web Server.
-//
-// 是否开启WebServer的平滑重启特性。
+// SetServerGraceful enables/disables graceful/hot reload feature of http Web Server.
+// This feature is disabled in default.
 func SetServerGraceful(enabled bool) {
     ghttp.SetGraceful(enabled)
 }

g/net/ghttp/ghttp_server_admin_process.go

@@ -168,7 +168,7 @@ func getServerFdMap() map[string]listenerFdMap {
 func bufferToServerFdMap(buffer []byte) map[string]listenerFdMap {
     sfm := make(map[string]listenerFdMap)
     if len(buffer) > 0 {
-        j, _ := gjson.LoadContent(buffer, "json")
+        j, _ := gjson.LoadContent(buffer)
         for k, _ := range j.ToMap() {
             m := make(map[string]string)
             for k, v := range j.GetMap(k) {

g/net/gtcp/gtcp_server.go

@@ -30,7 +30,7 @@ var serverMapping = gmap.NewStringInterfaceMap()
 
 // 获取/创建一个空配置的TCP Server
 // 单例模式，请保证name的唯一性
-func GetServer(name...interface{}) (*Server) {
+func GetServer(name...interface{}) *Server {
     serverName := gDEFAULT_SERVER
     if len(name) > 0 {
         serverName = gconv.String(name[0])

g/net/net.go

@@ -1 +0,0 @@
-package net

g/os/gcfg/gcfg.go

@@ -4,44 +4,42 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gcfg provides reading, caching and managing for configuration files.
-// 
-// 配置管理,
-// 配置文件格式支持：json, xml, toml, yaml/yml
+// Package gcfg provides reading, caching and managing for configuration files/contents.
 package gcfg
 
 import (
-    "bytes"
-    "errors"
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g/container/gtype"
-    "github.com/gogf/gf/g/container/gvar"
-    "github.com/gogf/gf/g/encoding/gjson"
-    "github.com/gogf/gf/g/os/gfile"
-    "github.com/gogf/gf/g/os/gfsnotify"
-    "github.com/gogf/gf/g/os/glog"
-    "github.com/gogf/gf/g/os/gspath"
+	"bytes"
+	"errors"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g/container/gmap"
+	"github.com/gogf/gf/g/container/gtype"
+	"github.com/gogf/gf/g/container/gvar"
+	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/internal/cmdenv"
+	"github.com/gogf/gf/g/os/gfile"
+	"github.com/gogf/gf/g/os/gfsnotify"
+	"github.com/gogf/gf/g/os/glog"
+	"github.com/gogf/gf/g/os/gspath"
 )
 
 const (
-    // 默认的配置管理文件名称
+    // Default configuration file name.
     DEFAULT_CONFIG_FILE = "config.toml"
 )
 
-// 配置管理对象
+// Configuration struct.
 type Config struct {
-    name   *gtype.String            // 默认配置文件名称
-    paths  *garray.StringArray      // 搜索目录路径
-    jsons  *gmap.StringInterfaceMap // 配置文件对象
-    vc     *gtype.Bool              // 层级检索是否执行分隔符冲突检测(默认为false，检测会比较影响检索效率)
+    name   *gtype.String            // Default configuration file name.
+    paths  *garray.StringArray      // Searching path array.
+    jsons  *gmap.StringInterfaceMap // The pared JSON objects for configuration files.
+    vc     *gtype.Bool              // Whether do violence check in value index searching.
+                                    // It affects the performance when set true(false in default).
 }
 
 // New returns a new configuration management object.
-//
-// 生成一个配置管理对象
-func New(path string, file...string) *Config {
+// The param <file> specifies the default configuration file name for reading.
+func New(file ...string) *Config {
     name := DEFAULT_CONFIG_FILE
     if len(file) > 0 {
         name = file[0]
@@ -52,15 +50,29 @@ func New(path string, file...string) *Config {
         jsons  : gmap.NewStringInterfaceMap(),
         vc     : gtype.NewBool(),
     }
-    if len(path) > 0 {
-        c.SetPath(path)
-    }
+	// Customized dir path from env/cmd.
+	if envPath := cmdenv.Get("gf.gcfg.path").String(); envPath != "" {
+		if gfile.Exists(envPath) {
+			c.SetPath(envPath)
+		} else {
+			glog.Errorfln("Configuration directory path does not exist: %s", envPath)
+		}
+	} else {
+		// Dir path of working dir.
+		c.SetPath(gfile.Pwd())
+		// Dir path of binary.
+		if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
+			c.AddPath(selfPath)
+		}
+		// Dir path of main package.
+		if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
+			c.AddPath(mainPath)
+		}
+	}
     return c
 }
 
 // filePath returns the absolute configuration file path for the given filename by <file>.
-//
-// 判断从哪个配置文件中获取内容，返回配置文件的绝对路径
 func (c *Config) filePath(file...string) (path string) {
     name := c.name.Val()
     if len(file) > 0 {
@@ -72,8 +84,12 @@ func (c *Config) filePath(file...string) (path string) {
         if c.paths.Len() > 0 {
             buffer.WriteString(fmt.Sprintf("[gcfg] cannot find config file \"%s\" in following paths:", name))
             c.paths.RLockFunc(func(array []string) {
-                for k, v := range array {
-                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+            	index := 1
+                for _, v := range array {
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s", index,  v))
+                    index++
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s%s%s", index,  v, gfile.Separator, "config"))
+	                index++
                 }
             })
         } else {
@@ -84,12 +100,13 @@ func (c *Config) filePath(file...string) (path string) {
     return path
 }
 
-// 设置配置管理器的配置文件存放目录绝对路径
+// SetPath sets the configuration directory path for file search.
+// The param <path> can be absolute or relative path, but absolute path is suggested.
 func (c *Config) SetPath(path string) error {
-    // 判断绝对路径(或者工作目录下目录)
+    // Absolute path.
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        // 判断相对路径
+        // Relative path.
         c.paths.RLockFunc(func(array []string) {
             for _, v := range array {
                 if path, _ := gspath.Search(v, path); path != "" {
@@ -99,7 +116,7 @@ func (c *Config) SetPath(path string) error {
             }
         })
     }
-    // 目录不存在错误处理
+    // Path not exist.
     if realPath == "" {
         buffer := bytes.NewBuffer(nil)
         if c.paths.Len() > 0 {
@@ -116,13 +133,13 @@ func (c *Config) SetPath(path string) error {
         glog.Error(err)
         return err
     }
-    // 路径必须为目录类型
+    // Should be a directory.
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gcfg] SetPath failed: path "%s" should be directory type`, path))
         glog.Error(err)
         return err
     }
-    // 重复判断
+    // Repeated path check.
     if c.paths.Search(realPath) != -1 {
         return nil
     }
@@ -133,19 +150,23 @@ func (c *Config) SetPath(path string) error {
     return nil
 }
 
-// 设置是否执行层级冲突检查，当键名中存在层级符号时需要开启该特性，默认为关闭。
-// 开启比较耗性能，也不建议允许键名中存在分隔符，最好在应用端避免这种情况。
+// SetViolenceCheck sets whether to perform level conflict check.
+// This feature needs to be enabled when there is a level symbol in the key name.
+// The default is off.
+// Turning on this feature is quite expensive,
+// and it is not recommended to allow separators in the key names.
+// It is best to avoid this on the application side.
 func (c *Config) SetViolenceCheck(check bool) {
     c.vc.Set(check)
-    c.Reload()
+    c.Clear()
 }
 
-// 添加配置管理器的配置文件搜索路径
+// AddPath adds a absolute or relative path to the search paths.
 func (c *Config) AddPath(path string) error {
-    // 判断绝对路径(或者工作目录下目录)
+    // Absolute path.
     realPath := gfile.RealPath(path)
     if realPath == "" {
-        // 判断相对路径
+	    // Relative path.
         c.paths.RLockFunc(func(array []string) {
             for _, v := range array {
                 if path, _ := gspath.Search(v, path); path != "" {
@@ -155,14 +176,13 @@ func (c *Config) AddPath(path string) error {
             }
         })
     }
-    // 目录不存在错误处理
     if realPath == "" {
         buffer := bytes.NewBuffer(nil)
         if c.paths.Len() > 0 {
             buffer.WriteString(fmt.Sprintf("[gcfg] AddPath failed: cannot find directory \"%s\" in following paths:", path))
             c.paths.RLockFunc(func(array []string) {
                 for k, v := range array {
-                    buffer.WriteString(fmt.Sprintf("\n%d. %s",k + 1,  v))
+                    buffer.WriteString(fmt.Sprintf("\n%d. %s", k + 1,  v))
                 }
             })
         } else {
@@ -172,13 +192,12 @@ func (c *Config) AddPath(path string) error {
         glog.Error(err)
         return err
     }
-    // 路径必须为目录类型
     if !gfile.IsDir(realPath) {
         err := errors.New(fmt.Sprintf(`[gcfg] AddPath failed: path "%s" should be directory type`, path))
         glog.Error(err)
         return err
     }
-    // 重复判断
+    // Repeated path check.
     if c.paths.Search(realPath) != -1 {
         return nil
     }
@@ -187,8 +206,10 @@ func (c *Config) AddPath(path string) error {
     return nil
 }
 
-// 查找配置文件，获取指定配置文件的绝对路径，默认获取默认的配置文件路径；
-// 当指定的配置文件不存在时，返回空字符串，并且不会报错。
+// GetFilePath returns the absolute path of the specified configuration file.
+// If <file> is not passed, it returns the configuration file path of the default name.
+// If the specified configuration file does not exist,
+// an empty string is returned.
 func (c *Config) GetFilePath(file...string) (path string) {
     name := c.name.Val()
     if len(file) > 0 {
@@ -209,38 +230,51 @@ func (c *Config) GetFilePath(file...string) (path string) {
     return
 }
 
-// 设置配置管理对象的默认文件名称
+// SetFileName sets the default configuration file name.
 func (c *Config) SetFileName(name string) {
     //glog.Debug("[gcfg] SetFileName:", name)
     c.name.Set(name)
 }
 
-// 获取配置管理对象的默认文件名称
+// GetFileName returns the default configuration file name.
 func (c *Config) GetFileName() string {
     return c.name.Val()
 }
 
-// 添加配置文件到配置管理器中，第二个参数为非必须，如果不输入表示添加进入默认的配置名称中
-// 内部带缓存控制功能。
+// getJson returns a gjson.Json object for the specified <file> content.
+// It would print error if file reading fails.
+// If any error occurs, it return nil.
 func (c *Config) getJson(file...string) *gjson.Json {
     name := c.name.Val()
     if len(file) > 0 {
         name = file[0]
     }
     r := c.jsons.GetOrSetFuncLock(name, func() interface{} {
-        filePath := c.filePath(file...)
-        if filePath == "" {
-            return nil
+        content  := ""
+        filePath := ""
+        if content = GetContent(name); content == "" {
+            filePath = c.filePath(name)
+            if filePath == "" {
+                return nil
+            }
+            content = gfile.GetContents(filePath)
         }
-        if j, err := gjson.Load(filePath); err == nil {
+        if j, err := gjson.LoadContent(content); err == nil {
             j.SetViolenceCheck(c.vc.Val())
-            // 添加配置文件监听，如果有任何变化，删除文件内容缓存，下一次查询会自动更新
-            gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
-                c.jsons.Remove(name)
-            })
+            // Add monitor for this configuration file,
+            // any changes of this file will refresh its cache in Config object.
+            if filePath != "" {
+                gfsnotify.Add(filePath, func(event *gfsnotify.Event) {
+                    c.jsons.Remove(name)
+                })
+            }
             return j
         } else {
-            glog.Criticalfln(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
+            if filePath != "" {
+                glog.Criticalfln(`[gcfg] Load config file "%s" failed: %s`, filePath, err.Error())
+            } else {
+                glog.Criticalfln(`[gcfg] Load configuration failed: %s`, err.Error())
+            }
         }
         return nil
     })
@@ -250,7 +284,6 @@ func (c *Config) getJson(file...string) *gjson.Json {
     return nil
 }
 
-// 获取配置项，当不存在时返回nil
 func (c *Config) Get(pattern string, file...string) interface{} {
     if j := c.getJson(file...); j != nil {
         return j.Get(pattern)
@@ -258,7 +291,6 @@ func (c *Config) Get(pattern string, file...string) interface{} {
     return nil
 }
 
-// 获得配置项，返回动态变量
 func (c *Config) GetVar(pattern string, file...string) gvar.VarRead {
     if j := c.getJson(file...); j != nil {
         return gvar.New(j.Get(pattern), true)
@@ -266,7 +298,6 @@ func (c *Config) GetVar(pattern string, file...string) gvar.VarRead {
     return gvar.New(nil, true)
 }
 
-// 判断指定的配置项是否存在
 func (c *Config) Contains(pattern string, file...string) bool {
     if j := c.getJson(file...); j != nil {
         return j.Contains(pattern)
@@ -274,8 +305,6 @@ func (c *Config) Contains(pattern string, file...string) bool {
     return false
 }
 
-// 获得一个键值对关联数组/哈希表，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
 func (c *Config) GetMap(pattern string, file...string)  map[string]interface{} {
     if j := c.getJson(file...); j != nil {
         return j.GetMap(pattern)
@@ -283,8 +312,6 @@ func (c *Config) GetMap(pattern string, file...string)  map[string]interface{} {
     return nil
 }
 
-// 获得一个数组[]interface{}，方便操作，不需要自己做类型转换
-// 注意，如果获取的值不存在，或者类型与json类型不匹配，那么将会返回nil
 func (c *Config) GetArray(pattern string, file...string)  []interface{} {
     if j := c.getJson(file...); j != nil {
         return j.GetArray(pattern)
@@ -292,7 +319,6 @@ func (c *Config) GetArray(pattern string, file...string)  []interface{} {
     return nil
 }
 
-// 返回指定json中的string
 func (c *Config) GetString(pattern string, file...string) string {
     if j := c.getJson(file...); j != nil {
         return j.GetString(pattern)
@@ -314,7 +340,6 @@ func (c *Config) GetInterfaces(pattern string, file...string) []interface{} {
     return nil
 }
 
-// 返回指定json中的bool
 func (c *Config) GetBool(pattern string, file...string) bool {
     if j := c.getJson(file...); j != nil {
         return j.GetBool(pattern)
@@ -322,7 +347,6 @@ func (c *Config) GetBool(pattern string, file...string) bool {
     return false
 }
 
-// 返回指定json中的float32
 func (c *Config) GetFloat32(pattern string, file...string) float32 {
     if j := c.getJson(file...); j != nil {
         return j.GetFloat32(pattern)
@@ -330,7 +354,6 @@ func (c *Config) GetFloat32(pattern string, file...string) float32 {
     return 0
 }
 
-// 返回指定json中的float64
 func (c *Config) GetFloat64(pattern string, file...string) float64 {
     if j := c.getJson(file...); j != nil {
         return j.GetFloat64(pattern)
@@ -345,7 +368,6 @@ func (c *Config) GetFloats(pattern string, file...string) []float64 {
     return nil
 }
 
-// 返回指定json中的float64->int
 func (c *Config) GetInt(pattern string, file...string)  int {
     if j := c.getJson(file...); j != nil {
         return j.GetInt(pattern)
@@ -389,7 +411,6 @@ func (c *Config) GetInts(pattern string, file...string) []int {
     return nil
 }
 
-// 返回指定json中的float64->uint
 func (c *Config) GetUint(pattern string, file...string)  uint {
     if j := c.getJson(file...); j != nil {
         return j.GetUint(pattern)
@@ -432,8 +453,14 @@ func (c *Config) GetToStruct(pattern string, objPointer interface{}, file...stri
     return errors.New("config file not found")
 }
 
-// 清空当前配置文件缓存，强制重新从磁盘文件读取配置文件内容
+// Deprecated. See Clear.
 func (c *Config) Reload() {
     c.jsons.Clear()
 }
 
+// Clear removes all parsed configuration files content cache,
+// which will force reload configuration content from file.
+func (c *Config) Clear() {
+    c.jsons.Clear()
+}
+

g/os/gcfg/gcfg_config.go

@@ -0,0 +1,71 @@
+// 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 gcfg
+
+import "github.com/gogf/gf/g/container/gmap"
+
+var (
+    // Customized configuration content.
+    configs = gmap.NewStringStringMap()
+)
+
+// SetContent sets customized configuration content for specified <file>.
+// The <file> is unnecessary param, default is DEFAULT_CONFIG_FILE.
+func SetContent(content string, file ...string) {
+    name := DEFAULT_CONFIG_FILE
+    if len(file) > 0 {
+        name = file[0]
+    }
+    // Clear file cache for instances which cached <name>.
+    instances.LockFunc(func(m map[string]interface{}) {
+    	if configs.Contains(name) {
+		    for _, v := range m {
+			    v.(*Config).jsons.Remove(name)
+		    }
+	    }
+	    configs.Set(name, content)
+    })
+}
+
+// GetContent returns customized configuration content for specified <file>.
+// The <file> is unnecessary param, default is DEFAULT_CONFIG_FILE.
+func GetContent(file ...string) string {
+    name := DEFAULT_CONFIG_FILE
+    if len(file) > 0 {
+        name = file[0]
+    }
+    return configs.Get(name)
+}
+
+// RemoveConfig removes the global configuration with specified group.
+// If <name> is not passed, it removes configuration of the default group name.
+func RemoveConfig(file ...string) {
+	name := DEFAULT_CONFIG_FILE
+	if len(file) > 0 {
+		name = file[0]
+	}
+	// Clear file cache for instances which cached <name>.
+	instances.LockFunc(func(m map[string]interface{}) {
+		if configs.Contains(name) {
+			for _, v := range m {
+				v.(*Config).jsons.Remove(name)
+			}
+			configs.Remove(name)
+		}
+	})
+}
+
+// ClearContent removes all global configuration contents.
+func ClearContent() {
+    configs.Clear()
+	// Clear cache for all instances.
+	instances.LockFunc(func(m map[string]interface{}) {
+		for _, v := range m {
+			v.(*Config).jsons.Clear()
+		}
+	})
+}

g/os/gcfg/gcfg_instance.go

@@ -0,0 +1,32 @@
+// 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 gcfg
+
+import (
+	"github.com/gogf/gf/g/container/gmap"
+)
+
+const (
+	// Default group name for instance usage.
+	DEFAULT_GROUP_NAME = "default"
+)
+var (
+    // Instances map.
+    instances = gmap.NewStringInterfaceMap()
+)
+
+// Instance returns an instance of Config with default settings.
+// The param <name> is the name for the instance.
+func Instance(name ...string) *Config {
+	key := DEFAULT_GROUP_NAME
+	if len(name) > 0 {
+		key = name[0]
+	}
+	return instances.GetOrSetFuncLock(key, func() interface{} {
+		return New()
+	}).(*Config)
+}

g/os/gcfg/gcfg_z_unit_test.go

@@ -27,12 +27,12 @@ array = [1,2,3]
     cache = "127.0.0.1:6379,1"
 `
     gtest.Case(t, func() {
-        path := "config.toml"
+        path := gcfg.DEFAULT_CONFIG_FILE
         err  := gfile.PutContents(path, config)
         gtest.Assert(err, nil)
         defer gfile.Remove(path)
 
-        c := gcfg.New(".")
+        c := gcfg.New()
         gtest.Assert(c.Get("v1"),           1)
         gtest.AssertEQ(c.GetInt("v1"),      1)
         gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
@@ -71,7 +71,201 @@ array = [1,2,3]
             "disk"  : "127.0.0.1:6379,0",
             "cache" : "127.0.0.1:6379,1",
         })
-        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + "config.toml")
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
 
     })
 }
+
+func Test_Content(t *testing.T) {
+    content := `
+v1    = 1
+v2    = "true"
+v3    = "off"
+v4    = "1.23"
+array = [1,2,3]
+[redis]
+    disk  = "127.0.0.1:6379,0"
+    cache = "127.0.0.1:6379,1"
+`
+    gcfg.SetContent(content)
+    defer gcfg.ClearContent()
+
+    gtest.Case(t, func() {
+        c := gcfg.New()
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.23))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.23))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+    })
+}
+
+func Test_SetFileName(t *testing.T) {
+    config := `
+{
+	"array": [
+		1,
+		2,
+		3
+	],
+	"redis": {
+		"cache": "127.0.0.1:6379,1",
+		"disk": "127.0.0.1:6379,0"
+	},
+	"v1": 1,
+	"v2": "true",
+	"v3": "off",
+	"v4": "1.234"
+}
+`
+    gtest.Case(t, func() {
+        path := "config.json"
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+
+        c := gcfg.New()
+        c.SetFileName(path)
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
+
+    })
+}
+
+func Test_Instance(t *testing.T) {
+    config := `
+{
+	"array": [
+		1,
+		2,
+		3
+	],
+	"redis": {
+		"cache": "127.0.0.1:6379,1",
+		"disk": "127.0.0.1:6379,0"
+	},
+	"v1": 1,
+	"v2": "true",
+	"v3": "off",
+	"v4": "1.234"
+}
+`
+    gtest.Case(t, func() {
+        path := gcfg.DEFAULT_CONFIG_FILE
+        err  := gfile.PutContents(path, config)
+        gtest.Assert(err, nil)
+        defer gfile.Remove(path)
+
+        c := gcfg.Instance()
+        gtest.Assert(c.Get("v1"),           1)
+        gtest.AssertEQ(c.GetInt("v1"),      1)
+        gtest.AssertEQ(c.GetInt8("v1"),     int8(1))
+        gtest.AssertEQ(c.GetInt16("v1"),    int16(1))
+        gtest.AssertEQ(c.GetInt32("v1"),    int32(1))
+        gtest.AssertEQ(c.GetInt64("v1"),    int64(1))
+        gtest.AssertEQ(c.GetUint("v1"),     uint(1))
+        gtest.AssertEQ(c.GetUint8("v1"),    uint8(1))
+        gtest.AssertEQ(c.GetUint16("v1"),   uint16(1))
+        gtest.AssertEQ(c.GetUint32("v1"),   uint32(1))
+        gtest.AssertEQ(c.GetUint64("v1"),   uint64(1))
+
+        gtest.AssertEQ(c.GetVar("v1").String(), "1")
+        gtest.AssertEQ(c.GetVar("v1").Bool(),   true)
+        gtest.AssertEQ(c.GetVar("v2").String(), "true")
+        gtest.AssertEQ(c.GetVar("v2").Bool(),   true)
+
+        gtest.AssertEQ(c.GetString("v1"),  "1")
+        gtest.AssertEQ(c.GetFloat32("v4"), float32(1.234))
+        gtest.AssertEQ(c.GetFloat64("v4"), float64(1.234))
+        gtest.AssertEQ(c.GetString("v2"),  "true")
+        gtest.AssertEQ(c.GetBool("v2"),    true)
+        gtest.AssertEQ(c.GetBool("v3"),    false)
+
+        gtest.AssertEQ(c.Contains("v1"),    true)
+        gtest.AssertEQ(c.Contains("v2"),    true)
+        gtest.AssertEQ(c.Contains("v3"),    true)
+        gtest.AssertEQ(c.Contains("v4"),    true)
+        gtest.AssertEQ(c.Contains("v5"),    false)
+
+        gtest.AssertEQ(c.GetInts("array"),        []int{1,2,3})
+        gtest.AssertEQ(c.GetStrings("array"),     []string{"1","2","3"})
+        gtest.AssertEQ(c.GetArray("array"),       []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetInterfaces("array"),  []interface{}{"1","2","3"})
+        gtest.AssertEQ(c.GetMap("redis"),         map[string]interface{}{
+            "disk"  : "127.0.0.1:6379,0",
+            "cache" : "127.0.0.1:6379,1",
+        })
+        gtest.AssertEQ(c.GetFilePath(),    gfile.Pwd() + gfile.Separator + path)
+
+    })
+}

g/os/gcron/gcron_cron.go

@@ -141,11 +141,6 @@ func (c *Cron) Search(name string) *Entry {
     return nil
 }
 
-// 根据指定名称删除定时任务
-func (c *Cron) Remove(name string) {
-    c.entries.Remove(name)
-}
-
 // 开启定时任务执行(可以指定特定名称的一个或若干个定时任务)
 func (c *Cron) Start(name...string) {
     if len(name) > 0 {
@@ -172,6 +167,13 @@ func (c *Cron) Stop(name...string) {
     }
 }
 
+// 根据指定名称删除定时任务。
+func (c *Cron) Remove(name string) {
+    if v := c.entries.Get(name); v != nil {
+        v.(*Entry).Close()
+    }
+}
+
 // 关闭定时任务
 func (c *Cron) Close() {
     c.status.Set(STATUS_CLOSED)

g/os/gcron/gcron_entry.go

@@ -87,7 +87,7 @@ func (entry *Entry) Stop() {
 
 // 关闭定时任务
 func (entry *Entry) Close() {
-    entry.cron.Remove(entry.Name)
+    entry.cron.entries.Remove(entry.Name)
     entry.entry.Close()
 }
 
@@ -96,6 +96,7 @@ func (entry *Entry) check() {
     if entry.schedule.meet(time.Now()) {
         path  := entry.cron.GetLogPath()
         level := entry.cron.GetLogLevel()
+        // 检查定时任务对象状态(非任务状态)
         switch entry.cron.status.Val() {
             case STATUS_STOPPED:
                 return

g/os/gcron/gcron_unit_1_test.go

@@ -71,6 +71,24 @@ func TestCron_Basic(t *testing.T) {
     })
 }
 
+func TestCron_Remove(t *testing.T) {
+    gtest.Case(t, func() {
+        cron  := gcron.New()
+        array := garray.New()
+        cron.Add("* * * * * *", func() {
+            array.Append(1)
+        }, "add")
+        gtest.Assert(array.Len(), 0)
+        time.Sleep(1200*time.Millisecond)
+        gtest.Assert(array.Len(), 1)
+
+        cron.Remove("add")
+        gtest.Assert(array.Len(), 1)
+        time.Sleep(1200*time.Millisecond)
+        gtest.Assert(array.Len(), 1)
+    })
+}
+
 func TestCron_AddSingleton(t *testing.T) {
     // un used, can be removed
     gtest.Case(t, func() {

g/os/gtime/gtime.go

@@ -147,11 +147,7 @@ func parseDateStr(s string) (year, month, day int) {
             return
         }
         year, _  = strconv.Atoi(array[2])
-        day, _   = strconv.Atoi(array[1])
-    }
-    // 年是否为缩写，如果是，那么需要补上前缀
-    if year < 100 {
-        year = int(time.Now().Year()/100)*100 + year
+        day, _   = strconv.Atoi(array[0])
     }
     return
 }
@@ -308,7 +304,7 @@ func FuncCost(f func()) int64 {
     return Nanosecond() - t
 }
 
-// 判断锁给字符串是否为数字
+// 判断所给字符串是否为数字
 func isNumeric(s string) bool {
     length := len(s)
     if length == 0 {

g/os/gtime/gtime_format.go

@@ -9,7 +9,8 @@ package gtime
 import (
     "bytes"
     "github.com/gogf/gf/g/text/gregex"
-    "strings"
+	"github.com/gogf/gf/g/text/gstr"
+	"strings"
 )
 
 var (
@@ -126,8 +127,8 @@ func (t *Time) Format(format string) string {
                     result := t.Time.Format(f)
                     // 有几个转换的符号需要特殊处理
                     switch runes[i] {
-                        case 'j': buffer.WriteString(strings.Replace(result, "=j=0", "", -1))
-                        case 'G': buffer.WriteString(strings.Replace(result, "=G=0", "", -1))
+                        case 'j': buffer.WriteString(gstr.ReplaceByArray(result, []string{"=j=0", "", "=j=", ""}))
+                        case 'G': buffer.WriteString(gstr.ReplaceByArray(result, []string{"=G=0", "", "=G=", ""}))
                         case 'u': buffer.WriteString(strings.Replace(result, "=u=.", "", -1))
                         default:
                             buffer.WriteString(result)

g/os/gtime/gtime_z_bench_test.go

@@ -4,50 +4,70 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-package gtime
+package gtime_test
 
 import (
-    "testing"
+	"testing"
+
+	"github.com/gogf/gf/g/os/gtime"
 )
 
 func Benchmark_Second(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Second()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Second()
+	}
 }
 
 func Benchmark_Millisecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Millisecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Millisecond()
+	}
 }
 
 func Benchmark_Microsecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Microsecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Microsecond()
+	}
 }
 
 func Benchmark_Nanosecond(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        Nanosecond()
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.Nanosecond()
+	}
 }
 
 func Benchmark_StrToTime(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        StrToTime("2018-02-09T20:46:17.897Z")
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.StrToTime("2018-02-09T20:46:17.897Z")
+	}
 }
 
 func Benchmark_ParseTimeFromContent(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        ParseTimeFromContent("2018-02-09T20:46:17.897Z")
-    }
+	for i := 0; i < b.N; i++ {
+		gtime.ParseTimeFromContent("2018-02-09T20:46:17.897Z")
+	}
 }
 
 func Benchmark_NewFromTimeStamp(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        NewFromTimeStamp(1542674930)
-    }
-}
+	for i := 0; i < b.N; i++ {
+		gtime.NewFromTimeStamp(1542674930)
+	}
+}
+
+func Benchmark_Date(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.Date()
+	}
+}
+
+func Benchmark_Datetime(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.Datetime()
+	}
+}
+
+func Benchmark_SetTimeZone(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		gtime.SetTimeZone("Asia/Shanghai")
+	}
+}

g/os/gtime/gtime_z_unit_basic_test.go

@@ -0,0 +1,234 @@
+package gtime_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_SetTimeZone(t *testing.T) {
+	gtest.Case(t, func() {
+		gtime.SetTimeZone("Asia/Shanghai")
+		gtest.Assert(time.Local.String(), "Asia/Shanghai")
+	})
+}
+
+func Test_Nanosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		nanos := gtime.Nanosecond()
+		timeTemp := time.Unix(0, nanos)
+		gtest.Assert(nanos, timeTemp.UnixNano())
+	})
+}
+
+func Test_Microsecond(t *testing.T) {
+	gtest.Case(t, func() {
+		micros := gtime.Microsecond()
+		timeTemp := time.Unix(0, micros*1e3)
+		gtest.Assert(micros, timeTemp.UnixNano()/1e3)
+	})
+}
+
+func Test_Millisecond(t *testing.T) {
+	gtest.Case(t, func() {
+		millis := gtime.Millisecond()
+		timeTemp := time.Unix(0, millis*1e6)
+		gtest.Assert(millis, timeTemp.UnixNano()/1e6)
+	})
+}
+
+func Test_Second(t *testing.T) {
+	gtest.Case(t, func() {
+		s := gtime.Second()
+		timeTemp := time.Unix(s, 0)
+		gtest.Assert(s, timeTemp.Unix())
+	})
+}
+
+func Test_Date(t *testing.T) {
+	gtest.Case(t, func() {
+		gtest.Assert(gtime.Date(), time.Now().Format("2006-01-02"))
+	})
+}
+
+func Test_Datetime(t *testing.T) {
+	gtest.Case(t, func() {
+		datetime := gtime.Datetime()
+		timeTemp, err := gtime.StrToTime(datetime, "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(datetime, timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}
+
+func Test_StrToTime(t *testing.T) {
+	gtest.Case(t, func() {
+		//正常日期列表
+		//正则的原因，日期"06.01.02"，"2006.01"，"2006..01"无法覆盖gtime.go的百分百
+		var testDatetimes = []string{
+			"2006-01-02 15:04:05",
+			"2006/01/02 15:04:05",
+			"2006.01.02 15:04:05.000",
+			"2006.01.02 - 15:04:05",
+			"2006.01.02 15:04:05 +0800 CST",
+			"2006-01-02T20:05:06+05:01:01",
+			"2006-01-02T14:03:04Z01:01:01",
+			"2006-01-02T15:04:05Z",
+			"02-jan-2006 15:04:05",
+			"02/jan/2006 15:04:05",
+			"02.jan.2006 15:04:05",
+			"02.jan.2006:15:04:05",
+		}
+
+		for _, item := range testDatetimes {
+			timeTemp, err := gtime.StrToTime(item)
+			if err != nil {
+				t.Error("test fail")
+			}
+			gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+		}
+
+		//正常日期列表，时间00:00:00
+		var testDates = []string{
+			"2006.01.02",
+			"2006.01.02 00:00",
+			"2006.01.02 00:00:00.000",
+		}
+
+		for _, item := range testDates {
+			timeTemp, err := gtime.StrToTime(item)
+			if err != nil {
+				t.Error("test fail")
+			}
+			gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 00:00:00")
+		}
+
+		//测试格式化formatToStdLayout
+		var testDateFormats = []string{
+			"Y-m-d H:i:s",
+			"\\T\\i\\m\\e Y-m-d H:i:s",
+			"Y-m-d H:i:s\\",
+			"Y-m-j G:i:s.u",
+			"Y-m-j G:i:su",
+		}
+
+		var testDateFormatsResult = []string{
+			"2007-01-02 15:04:05",
+			"Time 2007-01-02 15:04:05",
+			"2007-01-02 15:04:05",
+			"2007-01-02 15:04:05.000",
+			"2007-01-02 15:04:05.000",
+		}
+
+		for index, item := range testDateFormats {
+			timeTemp, err := gtime.StrToTime(testDateFormatsResult[index], item)
+			if err != nil {
+				t.Error("test fail")
+			}
+			gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05.000"), "2007-01-02 15:04:05.000")
+		}
+
+		//异常日期列表
+		var testDatesFail = []string{
+			"2006.01",
+			"06..02",
+			"20060102",
+		}
+
+		for _, item := range testDatesFail {
+			_, err := gtime.StrToTime(item)
+			if err == nil {
+				t.Error("test fail")
+			}
+		}
+
+		//test err
+		_, err := gtime.StrToTime("2006-01-02 15:04:05", "aabbccdd")
+		if err == nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_ConvertZone(t *testing.T) {
+	gtest.Case(t, func() {
+		//现行时间
+		nowUTC := time.Now().UTC()
+		testZone := "America/Los_Angeles"
+
+		//转换为洛杉矶时间
+		t1, err := gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
+		if err != nil {
+			t.Error("test fail")
+		}
+
+		//使用洛杉矶时区解析上面转换后的时间
+		laStr := t1.Time.Format("2006-01-02 15:04:05")
+		loc, err := time.LoadLocation(testZone)
+		t2, err := time.ParseInLocation("2006-01-02 15:04:05", laStr, loc)
+
+		//判断是否与现行时间匹配
+		gtest.Assert(t2.UTC().Unix(), nowUTC.Unix())
+
+	})
+
+	//test err
+	gtest.Case(t, func() {
+		//现行时间
+		nowUTC := time.Now().UTC()
+		//t.Log(nowUTC.Unix())
+		testZone := "errZone"
+
+		//错误时间输入
+		_, err := gtime.ConvertZone(nowUTC.Format("06..02 15:04:05"), testZone, "")
+		if err == nil {
+			t.Error("test fail")
+		}
+		//错误时区输入
+		_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, "")
+		if err == nil {
+			t.Error("test fail")
+		}
+		//错误时区输入
+		_, err = gtime.ConvertZone(nowUTC.Format("2006-01-02 15:04:05"), testZone, testZone)
+		if err == nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_StrToTimeFormat(t *testing.T) {
+	gtest.Case(t, func() {
+
+	})
+}
+
+func Test_ParseTimeFromContent(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文", "Y-m-d H:i:s")
+		gtest.Assert(timeTemp.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.ParseTimeFromContent("我是中文2006-01-02 15:04:05我也是中文")
+		gtest.Assert(timeTemp1.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		timeTemp2 := gtime.ParseTimeFromContent("我是中文02.jan.2006 15:04:05我也是中文")
+		gtest.Assert(timeTemp2.Time.Format("2006-01-02 15:04:05"), "2006-01-02 15:04:05")
+
+		//test err
+		timeTempErr := gtime.ParseTimeFromContent("我是中文", "Y-m-d H:i:s")
+		if timeTempErr != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_FuncCost(t *testing.T) {
+	gtest.Case(t, func() {
+		gtime.FuncCost(func() {
+
+		})
+	})
+}

g/os/gtime/gtime_z_unit_format_test.go

@@ -0,0 +1,54 @@
+package gtime_test
+
+import (
+	"testing"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_Format(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp, err := gtime.StrToTime("2006-01-11 15:04:05", "Y-m-d H:i:s")
+		timeTemp.ToZone("Asia/Shanghai")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp.Format("\\T\\i\\m\\e中文Y-m-j G:i:s.u\\"), "Time中文2006-01-11 15:04:05.000")
+
+		gtest.Assert(timeTemp.Format("d D j l"), "11 Wed 11 Wednesday")
+
+		gtest.Assert(timeTemp.Format("F m M n"), "January 01 Jan 1")
+
+		gtest.Assert(timeTemp.Format("Y y"), "2006 06")
+
+		gtest.Assert(timeTemp.Format("a A g G h H i s u .u"), "pm PM 3 15 03 15 04 05 000 .000")
+
+		gtest.Assert(timeTemp.Format("O P T"), "+0800 +08:00 CST")
+
+		gtest.Assert(timeTemp.Format("r"), "Wed, 11 Jan 06 15:04 CST")
+
+		gtest.Assert(timeTemp.Format("c"), "2006-01-11T15:04:05+08:00")
+
+		//补零
+		timeTemp1, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp1.Format("Y-m-d h:i:s"), "2006-01-02 03:04:05")
+		//不补零
+		timeTemp2, err := gtime.StrToTime("2006-01-02 03:04:05", "Y-m-d H:i:s")
+		if err != nil {
+			t.Error("test fail")
+		}
+		gtest.Assert(timeTemp2.Format("Y-n-j G:i:s"), "2006-1-2 3:04:05")
+
+	})
+}
+
+func Test_Layout(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Layout("2006-01-02 15:04:05"), timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}

g/os/gtime/gtime_z_unit_time_test.go

@@ -0,0 +1,189 @@
+package gtime_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/test/gtest"
+)
+
+func Test_New(t *testing.T) {
+	gtest.Case(t, func() {
+		timeNow := time.Now()
+		timeTemp := gtime.New(timeNow)
+		gtest.Assert(timeTemp.Time.UnixNano(), timeNow.UnixNano())
+
+		timeTemp1 := gtime.New()
+		gtest.Assert(timeTemp1.Time, time.Time{})
+	})
+}
+
+func Test_NewFromStr(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStr("20060102")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromStrFormat(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStrFormat("2006-01-02 15:04:05", "Y-m-d H:i:s")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStrFormat("2006-01-02 15:04:05", "aabbcc")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromStrLayout(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStrLayout("2006-01-02 15:04:05", "2006-01-02 15:04:05")
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:05")
+
+		timeTemp1 := gtime.NewFromStrLayout("2006-01-02 15:04:05", "aabbcc")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_NewFromTimeStamp(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromTimeStamp(1554459846000)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2019-04-05 18:24:06")
+		timeTemp1 := gtime.NewFromTimeStamp(0)
+		gtest.Assert(timeTemp1.Format("Y-m-d H:i:s"), "0001-01-01 00:00:00")
+	})
+}
+
+func Test_tSecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Second(), timeTemp.Time.Unix())
+	})
+}
+
+func Test_tNanosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Nanosecond(), timeTemp.Time.UnixNano())
+	})
+}
+
+func Test_tMicrosecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Microsecond(), timeTemp.Time.UnixNano()/1e3)
+	})
+}
+
+func Test_tMillisecond(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.Millisecond(), timeTemp.Time.UnixNano()/1e6)
+	})
+}
+
+func Test_String(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		gtest.Assert(timeTemp.String(), timeTemp.Time.Format("2006-01-02 15:04:05"))
+	})
+}
+
+func Test_Clone(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Clone()
+		gtest.Assert(timeTemp.Time.Unix(), timeTemp1.Time.Unix())
+	})
+}
+
+func Test_ToTime(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		gtest.Assert(timeTemp.ToTime().UnixNano(), timeTemp1.UnixNano())
+	})
+}
+
+func Test_Add(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		timeTemp.Add(time.Second)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2006-01-02 15:04:06")
+	})
+}
+
+func Test_ToZone(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		//
+		timeTemp.ToZone("America/Los_Angeles")
+		gtest.Assert(timeTemp.Time.Location().String(), "America/Los_Angeles")
+
+		loc, err := time.LoadLocation("Asia/Shanghai")
+		if err != nil {
+			t.Error("test fail")
+		}
+		timeTemp.ToLocation(loc)
+		gtest.Assert(timeTemp.Time.Location().String(), "Asia/Shanghai")
+
+		timeTemp1 := timeTemp.ToZone("errZone")
+		if timeTemp1 != nil {
+			t.Error("test fail")
+		}
+	})
+}
+
+func Test_AddDate(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.NewFromStr("2006-01-02 15:04:05")
+		timeTemp.AddDate(1, 2, 3)
+		gtest.Assert(timeTemp.Format("Y-m-d H:i:s"), "2007-03-05 15:04:05")
+	})
+}
+
+func Test_UTC(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.UTC()
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.UTC().UnixNano())
+	})
+}
+
+func Test_Local(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Local()
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Local().UnixNano())
+	})
+}
+
+func Test_Round(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Round(time.Hour)
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Round(time.Hour).UnixNano())
+	})
+}
+
+func Test_Truncate(t *testing.T) {
+	gtest.Case(t, func() {
+		timeTemp := gtime.Now()
+		timeTemp1 := timeTemp.Time
+		timeTemp.Truncate(time.Hour)
+		gtest.Assert(timeTemp.UnixNano(), timeTemp1.Truncate(time.Hour).UnixNano())
+	})
+}

g/os/gview/gview.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gview implements a template engine based on text/template.
-// 
-// 模板引擎.
 package gview
 
 import (
@@ -18,6 +16,7 @@ import (
     "github.com/gogf/gf/g/encoding/ghash"
     "github.com/gogf/gf/g/encoding/ghtml"
     "github.com/gogf/gf/g/encoding/gurl"
+    "github.com/gogf/gf/g/internal/cmdenv"
     "github.com/gogf/gf/g/os/gfcache"
     "github.com/gogf/gf/g/os/gfile"
     "github.com/gogf/gf/g/os/glog"
@@ -46,19 +45,19 @@ type Params  = map[string]interface{}
 type FuncMap = map[string]interface{}
 
 // 默认的视图对象
-var viewObj *View
+var defaultViewObj *View
 
 // 初始化默认的视图对象, 默认加载包不会初始化，使用包方法才会初始化模板引擎对象。
 func checkAndInitDefaultView() {
-    if viewObj == nil {
-        viewObj = New(gfile.Pwd())
+    if defaultViewObj == nil {
+        defaultViewObj = New(gfile.Pwd())
     }
 }
 
 // 直接解析模板内容，返回解析后的内容
 func ParseContent(content string, params Params) ([]byte, error) {
     checkAndInitDefaultView()
-    return viewObj.ParseContent(content, params)
+    return defaultViewObj.ParseContent(content, params)
 }
 
 // 生成一个视图对象
@@ -71,6 +70,26 @@ func New(path...string) *View {
     }
     if len(path) > 0 && len(path[0]) > 0 {
         view.SetPath(path[0])
+    } else {
+        // Customized dir path from env/cmd.
+        if envPath := cmdenv.Get("gf.gview.path").String(); envPath != "" {
+            if gfile.Exists(envPath) {
+	            view.SetPath(envPath)
+            } else {
+                glog.Errorfln("Template directory path does not exist: %s", envPath)
+            }
+        } else {
+            // Dir path of working dir.
+	        view.SetPath(gfile.Pwd())
+            // Dir path of binary.
+            if selfPath := gfile.SelfDir(); selfPath != "" && gfile.Exists(selfPath) {
+	            view.AddPath(selfPath)
+            }
+            // Dir path of main package.
+            if mainPath := gfile.MainPkgPath(); mainPath != "" && gfile.Exists(mainPath) {
+	            view.AddPath(mainPath)
+            }
+        }
     }
     view.SetDelimiters("{{", "}}")
     // 内置变量

g/os/gview/gview_instance.go

@@ -0,0 +1,30 @@
+// 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.
+
+package gview
+
+import "github.com/gogf/gf/g/container/gmap"
+
+const (
+	// Default group name for instance usage.
+	DEFAULT_INSTANCE_NAME = "default"
+)
+var (
+	// Instances map.
+	instances = gmap.NewStringInterfaceMap()
+)
+
+// Instance returns an instance of View with default settings.
+// The param <name> is the name for the instance.
+func Instance(name ...string) *View {
+	key := DEFAULT_INSTANCE_NAME
+	if len(name) > 0 {
+		key = name[0]
+	}
+	return instances.GetOrSetFuncLock(key, func() interface{} {
+		return New()
+	}).(*View)
+}

g/os/os.go

@@ -1 +0,0 @@
-package os

g/test/gtest/gtest.go

@@ -4,9 +4,7 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gtest provides simple and useful test utils.
-// 
-// 测试模块.
+// Package gtest provides convenient test utils for unit testing.
 package gtest
 
 import (
@@ -19,7 +17,9 @@ import (
     "testing"
 )
 
-// 封装一个测试用例
+// Case creates an unit test case.
+// The param <t> is the pointer to testing.T of stdlib (*testing.T).
+// The param <f> is the callback function for unit test case.
 func Case(t *testing.T, f func()) {
     defer func() {
         if err := recover(); err != nil {
@@ -30,14 +30,11 @@ func Case(t *testing.T, f func()) {
     f()
 }
 
-// 断言判断, 相等
+// Assert checks <value> and <expect> EQUAL.
 func Assert(value, expect interface{}) {
-    rvValue  := reflect.ValueOf(value)
     rvExpect := reflect.ValueOf(expect)
-    if rvValue.Kind() == reflect.Ptr {
-        if rvValue.IsNil() {
-            value = nil
-        }
+    if isNil(value) {
+        value = nil
     }
     if rvExpect.Kind() == reflect.Map {
         if err := compareMap(value, expect); err != nil {
@@ -50,21 +47,13 @@ func Assert(value, expect interface{}) {
     }
 }
 
-// 断言判断, 相等, 包括数据类型
+// AssertEQ checks <value> and <expect> EQUAL, including their TYPES.
 func AssertEQ(value, expect interface{}) {
-    // 类型判断
-    t1 := reflect.TypeOf(value)
-    t2 := reflect.TypeOf(expect)
-    if t1 != t2 {
-        panic(fmt.Sprintf(`[ASSERT] EXPECT TYPE %v == %v`, t1, t2))
-    }
-    rvValue  := reflect.ValueOf(value)
+	// Value assert.
     rvExpect := reflect.ValueOf(expect)
-    if rvValue.Kind() == reflect.Ptr {
-        if rvValue.IsNil() {
-            value = nil
-        }
-    }
+	if isNil(value) {
+		value = nil
+	}
     if rvExpect.Kind() == reflect.Map {
         if err := compareMap(value, expect); err != nil {
             panic(err)
@@ -74,17 +63,20 @@ func AssertEQ(value, expect interface{}) {
     if fmt.Sprintf("%v", value) != fmt.Sprintf("%v", expect) {
         panic(fmt.Sprintf(`[ASSERT] EXPECT %v == %v`, value, expect))
     }
+	// Type assert.
+	t1 := reflect.TypeOf(value)
+	t2 := reflect.TypeOf(expect)
+	if t1 != t2 {
+		panic(fmt.Sprintf(`[ASSERT] EXPECT TYPE %v[%v] == %v[%v]`, value, t1, expect, t2))
+	}
 }
 
-// 断言判断, 不相等
+// AssertNE checks <value> and <expect> NOT EQUAL.
 func AssertNE(value, expect interface{}) {
-    rvValue  := reflect.ValueOf(value)
     rvExpect := reflect.ValueOf(expect)
-    if rvValue.Kind() == reflect.Ptr {
-        if rvValue.IsNil() {
-            value = nil
-        }
-    }
+	if isNil(value) {
+		value = nil
+	}
     if rvExpect.Kind() == reflect.Map {
         if err := compareMap(value, expect); err == nil {
             panic(fmt.Sprintf(`[ASSERT] EXPECT %v != %v`, value, expect))
@@ -96,7 +88,9 @@ func AssertNE(value, expect interface{}) {
     }
 }
 
-// 断言判断, value > expect; 注意: 仅有字符串、整形、浮点型才可以比较
+// AssertGT checks <value> is GREATER THAN <expect>.
+// Notice that, only string, integer and float types can be compared by AssertGT,
+// others are invalid.
 func AssertGT(value, expect interface{}) {
     passed := false
     switch reflect.ValueOf(expect).Kind() {
@@ -117,7 +111,9 @@ func AssertGT(value, expect interface{}) {
     }
 }
 
-// 断言判断, value >= expect; 注意: 仅有字符串、整形、浮点型才可以比较
+// AssertGTE checks <value> is GREATER OR EQUAL THAN <expect>.
+// Notice that, only string, integer and float types can be compared by AssertGTE,
+// others are invalid.
 func AssertGTE(value, expect interface{}) {
     passed := false
     switch reflect.ValueOf(expect).Kind() {
@@ -138,7 +134,9 @@ func AssertGTE(value, expect interface{}) {
     }
 }
 
-// 断言判断, value < expect; 注意: 仅有字符串、整形、浮点型才可以比较
+// AssertLT checks <value> is LESS EQUAL THAN <expect>.
+// Notice that, only string, integer and float types can be compared by AssertLT,
+// others are invalid.
 func AssertLT(value, expect interface{}) {
     passed := false
     switch reflect.ValueOf(expect).Kind() {
@@ -159,7 +157,9 @@ func AssertLT(value, expect interface{}) {
     }
 }
 
-// 断言判断, value <= expect; 注意: 仅有字符串、整形、浮点型才可以比较
+// AssertLTE checks <value> is LESS OR EQUAL THAN <expect>.
+// Notice that, only string, integer and float types can be compared by AssertLTE,
+// others are invalid.
 func AssertLTE(value, expect interface{}) {
     passed := false
     switch reflect.ValueOf(expect).Kind() {
@@ -180,16 +180,18 @@ func AssertLTE(value, expect interface{}) {
     }
 }
 
-
-// 断言判断, value IN expect; 注意: expect必须为slice类型。
-// 注意：value参数可以为普通变量，也可以为slice类型。
+// AssertIN checks <value> is IN <expect>.
+// The <expect> should be a slice,
+// but the <value> can be a slice or a basic type variable.
+// TODO map support.
 func AssertIN(value, expect interface{}) {
     passed := true
     switch reflect.ValueOf(expect).Kind() {
         case reflect.Slice, reflect.Array:
+        	expectSlice := gconv.Interfaces(expect)
             for _, v1 := range gconv.Interfaces(value) {
                 result := false
-                for _, v2 := range gconv.Interfaces(expect) {
+                for _, v2 := range expectSlice {
                     if v1 == v2 {
                         result = true
                         break
@@ -206,7 +208,10 @@ func AssertIN(value, expect interface{}) {
     }
 }
 
-// 断言判断, value NOT IN expect; 注意: expect必须为slice类型
+// AssertNI checks <value> is NOT IN <expect>.
+// The <expect> should be a slice,
+// but the <value> can be a slice or a basic type variable.
+// TODO map support.
 func AssertNI(value, expect interface{}) {
     passed := true
     switch reflect.ValueOf(expect).Kind() {
@@ -230,31 +235,30 @@ func AssertNI(value, expect interface{}) {
     }
 }
 
-// 提示错误不退出进程执行
+// Error panics with given <message>.
 func Error(message...interface{}) {
     panic(fmt.Sprintf("[ERROR] %s", fmt.Sprint(message...)))
 }
 
-// 提示错误并退出进程执行
+// Fatal prints <message> to stderr and exit the process.
 func Fatal(message...interface{}) {
     fmt.Fprintf(os.Stderr, "[FATAL] %s\n%s", fmt.Sprint(message...), getBacktrace())
     os.Exit(1)
 }
 
-// Map比较，如果相等返回nil，否则返回错误信息.
+// compareMap compares two maps, returns nil if they are equal, or else returns error.
 func compareMap(value, expect interface{}) error {
     rvValue  := reflect.ValueOf(value)
     rvExpect := reflect.ValueOf(expect)
-    if rvValue.Kind() == reflect.Ptr {
-        if rvValue.IsNil() {
-            value = nil
-        }
-    }
+	if isNil(value) {
+		value = nil
+	}
     if rvExpect.Kind() == reflect.Map {
         if rvValue.Kind() == reflect.Map {
             if rvExpect.Len() == rvValue.Len() {
-                // 将两个map类型转换为同一个map类型, 才能执行比较,
-                // 直接使用 rvValue.MapIndex(key).Interface() 当key类型不一致时会报错。
+                // Turn two interface maps to the same type for comparison.
+                // Direct use of rvValue.MapIndex(key).Interface() will panic
+                // when the key types are inconsistent.
                 mValue   := make(map[string]string)
                 mExpect  := make(map[string]string)
                 ksValue  := rvValue.MapKeys()
@@ -280,7 +284,8 @@ func compareMap(value, expect interface{}) error {
     return nil
 }
 
-// 获取文件调用回溯字符串，参数skip表示调用端往上多少级开始回溯
+// getBacktrace returns the caller backtrace content from getBacktrace.
+// The param <skip> indicates the skip count of the caller backtrace from getBacktrace.
 func getBacktrace(skip...int) string {
     customSkip := 0
     if len(skip) > 0 {
@@ -289,7 +294,7 @@ func getBacktrace(skip...int) string {
     backtrace := ""
     index     := 1
     from      := 0
-    // 首先定位业务文件开始位置
+    // Ignore current gtest lines and find the beginning index of caller file.
     for i := 0; i < 10; i++ {
         if _, file, _, ok := runtime.Caller(i); ok {
             if reg, _  := regexp.Compile(`gtest\.go$`); !reg.MatchString(file) {
@@ -298,7 +303,7 @@ func getBacktrace(skip...int) string {
             }
         }
     }
-    // 从业务文件开始位置根据自定义的skip开始backtrace
+    // Get the caller backtrace from business caller file.
     goRoot := runtime.GOROOT()
     for i := from + customSkip; i < 10000; i++ {
         if _, file, cline, ok := runtime.Caller(i); ok && file != "" {
@@ -320,4 +325,15 @@ func getBacktrace(skip...int) string {
         }
     }
     return backtrace
+}
+
+// isNil checks whether <value> is nil.
+func isNil(value interface{}) bool {
+	rv := reflect.ValueOf(value)
+	switch rv.Kind() {
+	case reflect.Slice, reflect.Array, reflect.Map, reflect.Ptr, reflect.Func:
+		return rv.IsNil()
+	default:
+		return value == nil
+	}
 }

g/text/gregex/gregex_z_unit_test.go

@@ -0,0 +1,239 @@
+// 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 gregex_test
+
+import (
+	"github.com/gogf/gf/g/test/gtest"
+	"github.com/gogf/gf/g/text/gregex"
+	"strings"
+	"testing"
+)
+
+func Test_Quote(t *testing.T) {
+	gtest.Case(t, func() {
+		s1 := `[foo]` //`\[foo\]`
+		gtest.Assert(gregex.Quote(s1), `\[foo\]`)
+	})
+}
+
+func Test_Validate(t *testing.T) {
+	gtest.Case(t, func() {
+		var s1 = `(.+):(\d+)`
+		gtest.Assert(gregex.Validate(s1), nil)
+		s1 = `((.+):(\d+)`
+		gtest.Assert(gregex.Validate(s1) == nil, false)
+	})
+}
+
+func Test_IsMatch(t *testing.T) {
+	gtest.Case(t, func() {
+		var pattern = `(.+):(\d+)`
+		s1 := []byte(`sfs:2323`)
+		gtest.Assert(gregex.IsMatch(pattern, s1), true)
+		s1 = []byte(`sfs2323`)
+		gtest.Assert(gregex.IsMatch(pattern, s1), false)
+		s1 = []byte(`sfs:`)
+		gtest.Assert(gregex.IsMatch(pattern, s1), false)
+	})
+}
+
+func Test_IsMatchString(t *testing.T) {
+	gtest.Case(t, func() {
+		var pattern = `(.+):(\d+)`
+		s1 := `sfs:2323`
+		gtest.Assert(gregex.IsMatchString(pattern, s1), true)
+		s1 = `sfs2323`
+		gtest.Assert(gregex.IsMatchString(pattern, s1), false)
+		s1 = `sfs:`
+		gtest.Assert(gregex.IsMatchString(pattern, s1), false)
+	})
+}
+
+func Test_Match(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		s := "acbb" + wantSubs + "dd"
+		subs, err := gregex.Match(re, []byte(s))
+		gtest.Assert(err, nil)
+		if string(subs[0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs)
+		}
+		if string(subs[1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
+		}
+	})
+}
+
+func Test_MatchString(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		s := "acbb" + wantSubs + "dd"
+		subs, err := gregex.MatchString(re, s)
+		gtest.Assert(err, nil)
+		if string(subs[0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0], wantSubs)
+		}
+		if string(subs[1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1], "aab")
+		}
+	})
+}
+
+func Test_MatchAll(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		s := "acbb" + wantSubs + "dd"
+		s = s + `其他的` + s
+		subs, err := gregex.MatchAll(re, []byte(s))
+		gtest.Assert(err, nil)
+		if string(subs[0][0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs)
+		}
+		if string(subs[0][1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[0][1], "aab")
+		}
+
+		if string(subs[1][0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[1][0], wantSubs)
+		}
+		if string(subs[1][1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
+		}
+	})
+}
+
+func Test_MatchAllString(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		s := "acbb" + wantSubs + "dd"
+		subs, err := gregex.MatchAllString(re, s+`其他的`+s)
+		gtest.Assert(err, nil)
+		if string(subs[0][0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[0][0], wantSubs)
+		}
+		if string(subs[0][1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[0][1], "aab")
+		}
+
+		if string(subs[1][0]) != wantSubs {
+			t.Fatalf("regex:%s,Match(%q)[0] = %q; want %q", re, s, subs[1][0], wantSubs)
+		}
+		if string(subs[1][1]) != "aab" {
+			t.Fatalf("Match(%q)[1] = %q; want %q", s, subs[1][1], "aab")
+		}
+	})
+}
+
+func Test_Replace(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		replace := "12345"
+		s := "acbb" + wantSubs + "dd"
+		wanted := "acbb" + replace + "dd"
+		replacedStr, err := gregex.Replace(re, []byte(replace), []byte(s))
+		gtest.Assert(err, nil)
+		if string(replacedStr) != wanted {
+			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
+		}
+	})
+}
+
+func Test_ReplaceString(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		replace := "12345"
+		s := "acbb" + wantSubs + "dd"
+		wanted := "acbb" + replace + "dd"
+		replacedStr, err := gregex.ReplaceString(re, replace, s)
+		gtest.Assert(err, nil)
+		if replacedStr != wanted {
+			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
+		}
+	})
+}
+
+func Test_ReplaceFun(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		//replace :="12345"
+		s := "acbb" + wantSubs + "dd"
+		wanted := "acbb[x" + wantSubs + "y]dd"
+		wanted = "acbb" + "3个a" + "dd"
+		replacedStr, err := gregex.ReplaceFunc(re, []byte(s), func(s []byte) []byte {
+			if strings.Index(string(s), "aaa") >= 0 {
+				return []byte("3个a")
+			}
+			return []byte("[x" + string(s) + "y]")
+		})
+		gtest.Assert(err, nil)
+		if string(replacedStr) != wanted {
+			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
+		}
+	})
+}
+
+func Test_ReplaceStringFunc(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		wantSubs := "aaabb"
+		//replace :="12345"
+		s := "acbb" + wantSubs + "dd"
+		wanted := "acbb[x" + wantSubs + "y]dd"
+		wanted = "acbb" + "3个a" + "dd"
+		replacedStr, err := gregex.ReplaceStringFunc(re, s, func(s string) string {
+			if strings.Index(s, "aaa") >= 0 {
+				return "3个a"
+			}
+			return "[x" + s + "y]"
+		})
+		gtest.Assert(err, nil)
+		if replacedStr != wanted {
+			t.Fatalf("regex:%s,old:%s; want %q", re, s, wanted)
+		}
+	})
+}
+
+func Test_Split(t *testing.T) {
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		matched := "aaabb"
+		item0 := "acbb"
+		item1 := "dd"
+		s := item0 + matched + item1
+		gtest.Assert(gregex.IsMatchString(re, matched), true)
+		items := gregex.Split(re, s) //split string with matched
+		if items[0] != item0 {
+			t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
+		}
+		if items[1] != item1 {
+			t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
+		}
+	})
+
+	gtest.Case(t, func() {
+		re := "a(a+b+)b"
+		notmatched := "aaxbb"
+		item0 := "acbb"
+		item1 := "dd"
+		s := item0 + notmatched + item1
+		gtest.Assert(gregex.IsMatchString(re, notmatched), false)
+		items := gregex.Split(re, s) //split string with notmatched then nosplitting
+		if items[0] != s {
+			t.Fatalf("regex:%s,Split(%q) want %q", re, s, item0)
+		}
+
+	})
+}

g/text/gstr/gstr.go

@@ -5,8 +5,6 @@
 // You can obtain one at https://github.com/gogf/gf.
 
 // Package gstr provides functions for string handling.
-// 
-// 字符串处理.
 package gstr
 
 import (
@@ -20,9 +18,8 @@ import (
     "unicode/utf8"
 )
 
-// Replace returns a copy of the string <origin> with string <search> replaced by <replace>.
-//
-// 字符串替换(大小写敏感)
+// Replace returns a copy of the string <origin>
+// in which string <search> replaced by <replace> case-sensitively.
 func Replace(origin, search, replace string, count...int) string {
     n := -1
     if len(count) > 0 {
@@ -31,10 +28,8 @@ func Replace(origin, search, replace string, count...int) string {
     return strings.Replace(origin, search, replace, n)
 }
 
-// Replace returns a copy of the string <origin> with string <search> replaced by <replace>
-// with case-insensitive.
-//
-// 字符串替换(大小写不敏感)
+// Replace returns a copy of the string <origin>
+// in which string <search> replaced by <replace> case-insensitively.
 func ReplaceI(origin, search, replace string, count...int) string {
     n := -1
     if len(count) > 0 {
@@ -59,23 +54,20 @@ func ReplaceI(origin, search, replace string, count...int) string {
     return origin
 }
 
-// Count counts the number of <substr> appears in <s>. It returns 0 if no <substr> found in <s>.
-//
-// 计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
+// Count counts the number of <substr> appears in <s>.
+// It returns 0 if no <substr> found in <s>.
 func Count(s, substr string) int {
     return strings.Count(s, substr)
 }
 
-// Count counts the number of <substr> appears in <s>, case-insensitive. It returns 0 if no <substr> found in <s>.
-//
-// (非大小写敏感)计算字符串substr在字符串s中出现的次数，如果没有在s中找到substr，那么返回0。
+// Count counts the number of <substr> appears in <s>, case-insensitively.
+// It returns 0 if no <substr> found in <s>.
 func CountI(s, substr string) int {
     return strings.Count(ToLower(s), ToLower(substr))
 }
 
-// Replace string by array/slice.
-//
-// 使用map进行字符串替换(大小写敏感)
+// ReplaceByArray returns a copy of <origin>,
+// which is replaced by a slice in order, case-sensitively.
 func ReplaceByArray(origin string, array []string) string {
     for i := 0; i < len(array); i += 2 {
         if i + 1 >= len(array) {
@@ -86,9 +78,8 @@ func ReplaceByArray(origin string, array []string) string {
     return origin
 }
 
-// Replace string by array/slice with case-insensitive.
-//
-// 使用map进行字符串替换(大小写不敏感)
+// ReplaceIByArray returns a copy of <origin>,
+// which is replaced by a slice in order, case-insensitively.
 func ReplaceIByArray(origin string, array []string) string {
     for i := 0; i < len(array); i += 2 {
         if i + 1 >= len(array) {
@@ -99,9 +90,8 @@ func ReplaceIByArray(origin string, array []string) string {
     return origin
 }
 
-// Replace string by map.
-//
-// 使用map进行字符串替换(大小写敏感)
+// ReplaceByMap returns a copy of <origin>,
+// which is replaced by a map in unordered way, case-sensitively.
 func ReplaceByMap(origin string, replaces map[string]string) string {
     for k, v := range replaces {
         origin = Replace(origin, k, v)
@@ -109,9 +99,8 @@ func ReplaceByMap(origin string, replaces map[string]string) string {
     return origin
 }
 
-// Replace string by map with case-insensitive.
-//
-// 使用map进行字符串替换(大小写不敏感)
+// ReplaceIByMap returns a copy of <origin>,
+// which is replaced by a map in unordered way, case-insensitively.
 func ReplaceIByMap(origin string, replaces map[string]string) string {
     for k, v := range replaces {
         origin = ReplaceI(origin, k, v)
@@ -120,21 +109,16 @@ func ReplaceIByMap(origin string, replaces map[string]string) string {
 }
 
 // ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.
-// 字符串转换为小写
 func ToLower(s string) string {
     return strings.ToLower(s)
 }
 
 // ToUpper returns a copy of the string s with all Unicode letters mapped to their upper case.
-//
-// 字符串转换为大写
 func ToUpper(s string) string {
     return strings.ToUpper(s)
 }
 
 // UcFirst returns a copy of the string s with the first letter mapped to its upper case.
-//
-// 字符串首字母转换为大写
 func UcFirst(s string) string {
     if len(s) == 0 {
         return s
@@ -146,8 +130,6 @@ func UcFirst(s string) string {
 }
 
 // LcFirst returns a copy of the string s with the first letter mapped to its lower case.
-//
-// 字符串首字母转换为小写
 func LcFirst(s string) string {
     if len(s) == 0 {
         return s
@@ -158,16 +140,12 @@ func LcFirst(s string) string {
     return s
 }
 
-// Uppercase the first character of each word in a string.
-//
-// 大写字符串中每个单词的第一个字符。
+// UcWords uppercase the first character of each word in a string.
 func UcWords(str string) string {
     return strings.Title(str)
 }
 
 // IsLetterLower tests whether the given byte b is in lower case.
-//
-// 判断给定字符是否小写
 func IsLetterLower(b byte) bool {
     if b >= byte('a') && b <= byte('z') {
         return true
@@ -176,8 +154,6 @@ func IsLetterLower(b byte) bool {
 }
 
 // IsLetterUpper tests whether the given byte b is in upper case.
-//
-// 判断给定字符是否大写
 func IsLetterUpper(b byte) bool {
     if b >= byte('A') && b <= byte('Z') {
         return true
@@ -186,8 +162,6 @@ func IsLetterUpper(b byte) bool {
 }
 
 // IsNumeric tests whether the given string s is numeric.
-//
-// 判断锁给字符串是否为数字.
 func IsNumeric(s string) bool {
     length := len(s)
     if length == 0 {
@@ -201,9 +175,7 @@ func IsNumeric(s string) bool {
     return true
 }
 
-// Returns the portion of string specified by the start and length parameters.
-//
-// 字符串截取，支持中文
+// SubStr returns a portion of string <str> specified by the <start> and <length> parameters.
 func SubStr(str string, start int, length...int) (substr string) {
     // 将字符串的转换成[]rune
     rs  := []rune(str)
@@ -229,12 +201,10 @@ func SubStr(str string, start int, length...int) (substr string) {
     return string(rs[start : end])
 }
 
-// Returns the portion of string specified by the <length> parameters,
-// if the length of str is greater than <length>,
-// then the <suffix> will be appended to the result.
-//
-// 字符串长度截取限制，超过长度限制被截取并在字符串末尾追加指定的内容，支持中文
-func StrLimit(str string, length int, suffix...string) (string) {
+// StrLimit returns a portion of string <str> specified by <length> parameters,
+// if the length of <str> is greater than <length>,
+// then the <suffix> will be appended to the result string.
+func StrLimit(str string, length int, suffix...string) string {
     rs := []rune(str)
     if len(str) < length {
         return str
@@ -246,9 +216,7 @@ func StrLimit(str string, length int, suffix...string) (string) {
     return string(rs[0 : length]) + addStr
 }
 
-// Reverse a string.
-//
-// 字符串反转.
+// Reverse returns a string which is the reverse of <str>.
 func Reverse(str string) string {
     runes := []rune(str)
     for i, j := 0, len(runes) - 1; i < j; i, j = i + 1, j - 1 {
@@ -257,13 +225,11 @@ func Reverse(str string) string {
     return string(runes)
 }
 
-// Format a number with grouped thousands.
-// decimals: Sets the number of decimal points.
-// decPoint: Sets the separator for the decimal point.
-// thousandsSep: Sets the thousands separator.
+// NumberFormat formats a number with grouped thousands.
+// <decimals>: Sets the number of decimal points.
+// <decPoint>: Sets the separator for the decimal point.
+// <thousandsSep>: Sets the thousands separator.
 // See http://php.net/manual/en/function.number-format.php.
-//
-// 以千位分隔符方式格式化一个数字.
 func NumberFormat(number float64, decimals int, decPoint, thousandsSep string) string {
     neg := false
     if number < 0 {
@@ -305,14 +271,10 @@ func NumberFormat(number float64, decimals int, decPoint, thousandsSep string) s
     return s
 }
 
-// Split a string into smaller chunks.
+// ChunkSplit splits a string into smaller chunks.
 // Can be used to split a string into smaller chunks which is useful for
 // e.g. converting BASE64 string output to match RFC 2045 semantics.
 // It inserts end every chunkLen characters.
-//
-// 将字符串分割成小块。使用此函数将字符串分割成小块非常有用。
-// 例如将BASE64的输出转换成符合RFC2045语义的字符串。
-// 它会在每 chunkLen 个字符后边插入 end。
 func ChunkSplit(body string, chunkLen int, end string) string {
     if end == "" {
         end = "\r\n"
@@ -336,51 +298,37 @@ func ChunkSplit(body string, chunkLen int, end string) string {
 
 // Compare returns an integer comparing two strings lexicographically.
 // The result will be 0 if a==b, -1 if a < b, and +1 if a > b.
-//
-// 比较两个字符串。
 func Compare(a, b string) int {
     return strings.Compare(a, b)
 }
 
-// Equal reports whether s and t, interpreted as UTF-8 strings,
-// are equal under Unicode case-folding, case-insensitive.
-//
-// 比较两个字符串是否相等（不区分大小写）。
+// Equal reports whether <a> and <b>, interpreted as UTF-8 strings,
+// are equal under Unicode case-folding, case-insensitively.
 func Equal(a, b string) bool {
     return strings.EqualFold(a, b)
 }
 
-// Return the words used in a string.
-//
-// 分割字符串中的单词。
+// Fields returns the words used in a string as slice.
 func Fields(str string) []string {
     return strings.Fields(str)
 }
 
-// Contains reports whether substr is within str.
-//
-// 判断是否substr存在于str中。
+// Contains reports whether <substr> is within <str>, case-sensitively.
 func Contains(str, substr string) bool {
     return strings.Contains(str, substr)
 }
 
-// Contains reports whether substr is within str, case-insensitive.
-//
-// 判断是否substr存在于str中(不区分大小写)。
+// ContainsI reports whether substr is within str, case-insensitively.
 func ContainsI(str, substr string) bool {
     return PosI(str, substr) != -1
 }
 
-// ContainsAny reports whether any Unicode code points in chars are within s.
-//
-// 判断是否s中是否包含chars指定的任意字符。
+// ContainsAny reports whether any Unicode code points in <chars> are within <s>.
 func ContainsAny(s, chars string) bool {
     return strings.ContainsAny(s, chars)
 }
 
-// Return information about words used in a string.
-//
-// 返回字符串中单词的使用情况。
+// CountWords returns information about words' count used in a string.
 func CountWords(str string) map[string]int {
     m      := make(map[string]int)
     buffer := bytes.NewBuffer(nil)
@@ -400,7 +348,7 @@ func CountWords(str string) map[string]int {
     return m
 }
 
-// Return information about words used in a string.
+// CountChars returns information about chars' count used in a string.
 //
 // 返回字符串中字符的使用情况。
 func CountChars(str string, noSpace...bool) map[string]int {
@@ -418,10 +366,8 @@ func CountChars(str string, noSpace...bool) map[string]int {
     return m
 }
 
-// Wraps a string to a given number of characters.
+// WordWrap wraps a string to a given number of characters.
 // TODO: Enable cut param, see http://php.net/manual/en/function.wordwrap.php.
-//
-// 使用字符串断点将字符串打断为指定数量的字串。
 func WordWrap(str string, width int, br string) string {
     if br == "" {
         br = "\n"
@@ -479,24 +425,19 @@ func WordWrap(str string, width int, br string) string {
     return buf.String()
 }
 
-// Get string length of unicode.
-//
-// UTF-8字符串长度。
+// RuneLen returns string length of unicode.
 func RuneLen(str string) int {
     return utf8.RuneCountInString(str)
 }
 
 // Repeat returns a new string consisting of multiplier copies of the string input.
-//
-// 按照指定大小创建重复的字符串。
 func Repeat(input string, multiplier int) string {
     return strings.Repeat(input, multiplier)
 }
 
-// Returns part of haystack string starting from and including the first occurrence of needle to the end of haystack.
+// Str returns part of <haystack> string starting from and including
+// the first occurrence of <needle> to the end of <haystack>.
 // See http://php.net/manual/en/function.strstr.php.
-//
-// 查找字符串的首次出现。返回 haystack 字符串从 needle 第一次出现的位置开始到 haystack 结尾的字符串。
 func Str(haystack string, needle string) string {
     if needle == "" {
         return ""
@@ -508,9 +449,7 @@ func Str(haystack string, needle string) string {
     return haystack[idx + len([]byte(needle)) - 1 : ]
 }
 
-// Randomly shuffles a string.
-//
-// 将字符串打乱。
+// Shuffle randomly shuffles a string.
 func Shuffle(str string) string {
     runes := []rune(str)
     s     := make([]rune, len(runes))
@@ -520,54 +459,40 @@ func Shuffle(str string) string {
     return string(s)
 }
 
-// Split a string by a string, to an array.
-//
-// 此函数返回由字符串组成的数组，每个元素都是 str 的一个子串，它们被字符串 delimiter 作为边界点分割出来。
+// Split splits string <str> by a string <delimiter>, to an array.
 func Split(str, delimiter string) []string {
     return strings.Split(str, delimiter)
 }
 
 // Join concatenates the elements of a to create a single string. The separator string
 // sep is placed between elements in the resulting string.
-//
-// 用sep将字符串数组array连接为一个字符串。
 func Join(array []string, sep string) string {
     return strings.Join(array, sep)
 }
 
-// Split a string by a string, to an array.
+// Explode splits string <str> by a string <delimiter>, to an array.
 // See http://php.net/manual/en/function.explode.php.
-//
-// 此函数返回由字符串组成的数组，每个元素都是 str 的一个子串，它们被字符串 delimiter 作为边界点分割出来。
 func Explode(delimiter, str string) []string {
     return Split(str, delimiter)
 }
 
-// Join array elements with a string.
+// Implode joins array elements <pieces> with a string <glue>.
 // http://php.net/manual/en/function.implode.php
-//
-// 用glue将字符串数组pieces连接为一个字符串。
 func Implode(glue string, pieces []string) string {
     return strings.Join(pieces, glue)
 }
 
-// Generate a single-byte string from a number.
-//
-// 返回相对应于 ascii 所指定的单个字符。
+// Chr return the ascii string of a number(0-255).
 func Chr(ascii int) string {
     return string(ascii)
 }
 
-// Convert the first byte of a string to a value between 0 and 255.
-//
-// 解析 char 二进制值第一个字节为 0 到 255 范围的无符号整型类型。
+// Ord converts the first byte of a string to a value between 0 and 255.
 func Ord(char string) int {
     return int(char[0])
 }
 
-// HideStr replaces part of the the string by percentage from the middle.
-//
-// 按照百分比从字符串中间向两边隐藏字符(主要用于姓名、手机号、邮箱地址、身份证号等的隐藏)，支持utf-8中文，支持email格式。
+// HideStr replaces part of the the string <str> to <hide> by <percentage> from the <middle>.
 func HideStr(str string, percent int, hide string) string {
     array := strings.Split(str, "@")
     if len(array) > 1 {
@@ -593,10 +518,8 @@ func HideStr(str string, percent int, hide string) string {
     return buffer.String()
 }
 
-// Inserts HTML line breaks before all newlines in a string.
-// \n\r, \r\n, \r, \n
-//
-// 在字符串 string 所有新行之前插入 '<br />' 或 '<br>'，并返回。
+// Nl2Br inserts HTML line breaks(<br>|<br />) before all newlines in a string:
+// \n\r, \r\n, \r, \n.
 func Nl2Br(str string, isXhtml...bool) string {
     r, n, runes := '\r', '\n', []rune(str)
     var br []byte
@@ -628,9 +551,7 @@ func Nl2Br(str string, isXhtml...bool) string {
     return buf.String()
 }
 
-// Quote string with slashes.
-//
-// 转义字符串中的单引号（'）、双引号（"）、反斜线（\）与 NUL（NULL 字符）。
+// AddSlashes quotes chars('"\) with slashes.
 func AddSlashes(str string) string {
     var buf bytes.Buffer
     for _, char := range str {
@@ -643,9 +564,7 @@ func AddSlashes(str string) string {
     return buf.String()
 }
 
-// Un-quotes a quoted string.
-//
-// 反转义字符串。
+// StripSlashes un-quotes a quoted string by AddSlashes.
 func StripSlashes(str string) string {
     var buf bytes.Buffer
     l, skip := len(str), false
@@ -665,8 +584,6 @@ func StripSlashes(str string) string {
 
 // Returns a version of str with a backslash character (\) before every character that is among:
 // .\+*?[^]($)
-//
-// 转义字符串，转义的特殊字符包括：.\+*?[^]($)。
 func QuoteMeta(str string) string {
     var buf bytes.Buffer
     for _, char := range str {

g/text/gstr/gstr_levenshtein.go

@@ -6,13 +6,11 @@
 
 package gstr
 
-// Calculate Levenshtein distance between two strings.
+// Levenshtein calculates Levenshtein distance between two strings.
 // costIns: Defines the cost of insertion.
 // costRep: Defines the cost of replacement.
 // costDel: Defines the cost of deletion.
 // See http://php.net/manual/en/function.levenshtein.php.
-//
-// 计算两个字符串之间的编辑距离(Levenshtein distance)。
 func Levenshtein(str1, str2 string, costIns, costRep, costDel int) int {
     var maxLen = 255
     l1 := len(str1)

g/text/gstr/gstr_parse.go

@@ -12,7 +12,7 @@ import (
     "strings"
 )
 
-// Parses the string into map[string]interface{}.
+// Parse parses the string into map[string]interface{}.
 //
 // f1=m&f2=n           -> map[f1:m f2:n]
 // f[a]=m&f[b]=n       -> map[f:map[a:m b:n]]
@@ -23,7 +23,6 @@ import (
 // f=m&f[a]=n          -> error
 // a .[[b=c            -> map[a___[b:c]
 //
-// 将字符串解析成Map。
 func Parse(s string) (result map[string]interface{}, err error) {
     result = make(map[string]interface{})
     parts := strings.Split(s, "&")

g/text/gstr/gstr_pos.go

@@ -8,10 +8,9 @@ package gstr
 
 import "strings"
 
-// Find the position of the first occurrence of a substring in a string.
-// It returns -1, if none found.
-//
-// 返回 needle 在 haystack 中首次出现的数字位置，找不到返回-1。
+// Pos returns the position of the first occurrence of <needle>
+// in <haystack> from <startOffset>, case-sensitively.
+// It returns -1, if not found.
 func Pos(haystack, needle string, startOffset...int) int {
     length := len(haystack)
     offset := 0
@@ -32,10 +31,9 @@ func Pos(haystack, needle string, startOffset...int) int {
     return pos + offset
 }
 
-// Find the position of the first occurrence of a case-insensitive substring in a string.
-// It returns -1, if none found.
-//
-// 返回在字符串 haystack 中 needle 首次出现的数字位置（不区分大小写），找不到返回-1。
+// PosI returns the position of the first occurrence of <needle>
+// in <haystack> from <startOffset>, case-insensitively.
+// It returns -1, if not found.
 func PosI(haystack, needle string, startOffset...int) int {
     length := len(haystack)
     offset := 0
@@ -56,10 +54,9 @@ func PosI(haystack, needle string, startOffset...int) int {
     return pos + offset
 }
 
-// Find the position of the last occurrence of a substring in a string.
-// It returns -1, if none found.
-//
-// 查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
+// PosR returns the position of the last occurrence of <needle>
+// in <haystack> from <startOffset>, case-sensitively.
+// It returns -1, if not found.
 func PosR(haystack, needle string, startOffset...int) int {
     offset := 0
     if len(startOffset) > 0 {
@@ -82,10 +79,9 @@ func PosR(haystack, needle string, startOffset...int) int {
     return pos
 }
 
-// Find the position of the last occurrence of a case-insensitive substring in a string.
-// It returns -1, if none found.
-//
-// 以不区分大小写的方式查找指定字符串在目标字符串中最后一次出现的位置，找不到返回-1。
+// PosR returns the position of the last occurrence of <needle>
+// in <haystack> from <startOffset>, case-insensitively.
+// It returns -1, if not found.
 func PosRI(haystack, needle string, startOffset...int) int {
     offset := 0
     if len(startOffset) > 0 {

g/text/gstr/gstr_similartext.go

@@ -6,10 +6,8 @@
 
 package gstr
 
-// Calculate the similarity between two strings.
+// SimilarText calculates the similarity between two strings.
 // See http://php.net/manual/en/function.similar-text.php.
-//
-// 计算两个字符串的相似度。
 func SimilarText(first, second string, percent *float64) int {
     var similarText func(string, string, int, int) int
     similarText = func(str1, str2 string, len1, len2 int) int {

g/text/gstr/gstr_soundex.go

@@ -6,10 +6,8 @@
 
 package gstr
 
-// Calculate the soundex key of a string.
+// Soundex calculates the soundex key of a string.
 // See http://php.net/manual/en/function.soundex.php.
-//
-// 计算字符串的SOUNDEX值，SOUNDEX为由四个字符组成的代码以评估两个字符串的相似性。
 func Soundex(str string) string {
     if str == "" {
         panic("str: cannot be an empty string")

g/text/gstr/gstr_trim.go

@@ -8,9 +8,7 @@ package gstr
 
 import "strings"
 
-// Strip whitespace (or other characters) from the beginning and end of a string.
-//
-// 去除字符串首尾处的空白字符（或者其他字符）。
+// Trim strips whitespace (or other characters) from the beginning and end of a string.
 func Trim(str string, characterMask ...string) string {
     if len(characterMask) > 0 {
         return strings.Trim(str, characterMask[0])
@@ -19,9 +17,7 @@ func Trim(str string, characterMask ...string) string {
     }
 }
 
-// Strip whitespace (or other characters) from the beginning of a string.
-//
-// 去除字符串首的空白字符（或者其他字符）。
+// TrimLeft strips whitespace (or other characters) from the beginning of a string.
 func TrimLeft(str string, characterMask ...string) string {
     mask := ""
     if len(characterMask) == 0 {
@@ -32,9 +28,7 @@ func TrimLeft(str string, characterMask ...string) string {
     return strings.TrimLeft(str, mask)
 }
 
-// Strip all of the given <cut> string from the beginning of a string.
-//
-// 去除字符串首的给定字符串。
+// TrimLeftStr strips all of the given <cut> string from the beginning of a string.
 func TrimLeftStr(str string, cut string) string {
     for str[0 : len(cut)] == cut {
         str = str[len(cut) : ]
@@ -42,9 +36,7 @@ func TrimLeftStr(str string, cut string) string {
     return str
 }
 
-// Strip whitespace (or other characters) from the end of a string.
-//
-// 去除字符串尾的空白字符（或者其他字符）。
+// TrimRight strips whitespace (or other characters) from the end of a string.
 func TrimRight(str string, characterMask ...string) string {
     mask := ""
     if len(characterMask) == 0 {
@@ -55,9 +47,7 @@ func TrimRight(str string, characterMask ...string) string {
     return strings.TrimRight(str, mask)
 }
 
-// Strip all of the given <cut> string from the end of a string.
-//
-// 去除字符串尾的给定字符串。
+// TrimRightStr strips all of the given <cut> string from the end of a string.
 func TrimRightStr(str string, cut string) string {
     for {
         length := len(str)

g/text/gstr/gstr_z_bench_test.go

@@ -1,53 +0,0 @@
-// 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 -bench=".*"
-
-package gstr_test
-
-import (
-    "github.com/gogf/gf/g/text/gstr"
-    "testing"
-)
-
-var (
-    str   = "This is the test string for gstr."
-    bytes = []byte(str)
-)
-
-func Benchmark_StringToBytes(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        if []byte(str) != nil {
-
-        }
-    }
-}
-
-func Benchmark_BytesToString(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        if string(bytes) != "" {
-
-        }
-    }
-}
-
-func Benchmark_Parse1(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        gstr.Parse("a=1&b=2")
-    }
-}
-
-func Benchmark_Parse2(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        gstr.Parse("m[]=1&m[]=2")
-    }
-}
-
-func Benchmark_Parse3(b *testing.B) {
-    for i := 0; i < b.N; i++ {
-        gstr.Parse("m[a1][b1][c1][d1]=1&m[a2][b2]=2&m[a3][b3][c3]=3")
-    }
-}

g/util/grand/grand_intn.go

@@ -7,8 +7,9 @@
 package grand
 
 import (
-    "crypto/rand"
-    "encoding/binary"
+	"crypto/rand"
+	"encoding/binary"
+	"os"
 )
 
 const (
@@ -27,6 +28,7 @@ func init() {
         for {
             if n, err := rand.Read(buffer); err != nil {
                 panic(err)
+                os.Exit(1)
             } else {
                 // 使用缓冲区数据进行一次完整的随机数生成
                 for i := 0; i < n - 4; {
@@ -34,10 +36,18 @@ func init() {
                     i ++
                 }
                 // 充分利用缓冲区数据，随机索引递增
-                step = int(buffer[0])%10
+                for i := 0; i < n; i++ {
+	                step = int(buffer[0])%10
+	                if step != 0 {
+	                	break
+	                }
+                }
+	            if step == 0 {
+		            step = 2
+	            }
                 for i := 0; i < n - 4; {
-                    bufferChan <- binary.BigEndian.Uint32(buffer[i : i + 4])
-                    i += step
+                   bufferChan <- binary.BigEndian.Uint32(buffer[i : i + 4])
+                   i += step
                 }
             }
         }

g/util/util.go

@@ -1 +0,0 @@
-package util

geg/container/garray/array_unique.go

@@ -3,15 +3,14 @@ package main
 import "fmt"
 
 func main() {
-    array := []uint{1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6}
-    for i := 0; i < len(array) - 1; i++ {
-        for j := i + 1; j < len(array); j++ {
-            if array[i] == array[j] {
-                array = append(array[ : j], array[j + 1 : ]...)
-            }
-        }
-    }
-    fmt.Println(array)
+	array := []uint{1, 1, 2, 3, 3, 4, 4, 5, 5, 6, 6}
+	for i := 0; i < len(array)-1; i++ {
+		for j := i + 1; j < len(array); j++ {
+			if array[i] == array[j] {
+				array = append(array[:j], array[j+1:]...)
+			}
+		}
+	}
+	fmt.Println(array)
 
-
-}
+}

geg/container/garray/garray1.go

@@ -1,59 +1,58 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	// 创建普通的int类型数组，并关闭默认的并发安全特性
+	a := garray.NewIntArray(true)
 
-func main () {
-    // 创建普通的int类型数组，并关闭默认的并发安全特性
-    a := garray.NewIntArray(true)
+	// 添加数据项
+	for i := 0; i < 10; i++ {
+		a.Append(i)
+	}
 
-    // 添加数据项
-    for i := 0; i < 10; i++ {
-        a.Append(i)
-    }
+	// 获取当前数组长度
+	fmt.Println(a.Len())
 
-    // 获取当前数组长度
-    fmt.Println(a.Len())
+	// 获取当前数据项列表
+	fmt.Println(a.Slice())
 
-    // 获取当前数据项列表
-    fmt.Println(a.Slice())
+	// 获取指定索引项
+	fmt.Println(a.Get(6))
 
-    // 获取指定索引项
-    fmt.Println(a.Get(6))
+	// 在指定索引前插入数据项
+	a.InsertAfter(9, 11)
+	// 在指定索引后插入数据项
+	a.InsertBefore(10, 10)
+	fmt.Println(a.Slice())
 
-    // 在指定索引前插入数据项
-    a.InsertAfter(9, 11)
-    // 在指定索引后插入数据项
-    a.InsertBefore(10, 10)
-    fmt.Println(a.Slice())
+	// 修改指定索引的数据项
+	a.Set(0, 100)
+	fmt.Println(a.Slice())
 
-    // 修改指定索引的数据项
-    a.Set(0, 100)
-    fmt.Println(a.Slice())
+	// 搜索数据项，返回搜索到的索引位置
+	fmt.Println(a.Search(5))
 
-    // 搜索数据项，返回搜索到的索引位置
-    fmt.Println(a.Search(5))
+	// 删除指定索引的数据项
+	a.Remove(0)
+	fmt.Println(a.Slice())
 
-    // 删除指定索引的数据项
-    a.Remove(0)
-    fmt.Println(a.Slice())
+	// 并发安全，写锁操作
+	a.LockFunc(func(array []int) {
+		// 将末尾项改为100
+		array[len(array)-1] = 100
+	})
 
-    // 并发安全，写锁操作
-    a.LockFunc(func(array []int) {
-        // 将末尾项改为100
-        array[len(array) - 1] = 100
-    })
+	// 并发安全，读锁操作
+	a.RLockFunc(func(array []int) {
+		fmt.Println(array[len(array)-1])
+	})
 
-    // 并发安全，读锁操作
-    a.RLockFunc(func(array []int) {
-        fmt.Println(array[len(array) - 1])
-    })
-
-    // 清空数组
-    fmt.Println(a.Slice())
-    a.Clear()
-    fmt.Println(a.Slice())
+	// 清空数组
+	fmt.Println(a.Slice())
+	a.Clear()
+	fmt.Println(a.Slice())
 }

geg/container/garray/garray2.go

@@ -1,40 +1,39 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/garray"
+	"fmt"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	// 自定义排序数组，降序排序(SortedIntArray管理的数据是升序)
+	a := garray.NewSortedArray(func(v1, v2 interface{}) int {
+		if v1.(int) < v2.(int) {
+			return 1
+		}
+		if v1.(int) > v2.(int) {
+			return -1
+		}
+		return 0
+	})
 
-func main () {
-    // 自定义排序数组，降序排序(SortedIntArray管理的数据是升序)
-    a := garray.NewSortedArray(func(v1, v2 interface{}) int {
-        if v1.(int) < v2.(int) {
-            return 1
-        }
-        if v1.(int) > v2.(int) {
-            return -1
-        }
-        return 0
-    })
+	// 添加数据
+	a.Add(2)
+	a.Add(3)
+	a.Add(1)
+	fmt.Println(a.Slice())
 
-    // 添加数据
-    a.Add(2)
-    a.Add(3)
-    a.Add(1)
-    fmt.Println(a.Slice())
+	// 添加重复数据
+	a.Add(3)
+	fmt.Println(a.Slice())
 
-    // 添加重复数据
-    a.Add(3)
-    fmt.Println(a.Slice())
+	// 检索数据，返回最后对比的索引位置，检索结果
+	// 检索结果：0: 匹配; <0:参数小于对比值; >0:参数大于对比值
+	fmt.Println(a.Search(1))
 
-    // 检索数据，返回最后对比的索引位置，检索结果
-    // 检索结果：0: 匹配; <0:参数小于对比值; >0:参数大于对比值
-    fmt.Println(a.Search(1))
-
-    // 设置不可重复
-    a.SetUnique(true)
-    fmt.Println(a.Slice())
-    a.Add(1)
-    fmt.Println(a.Slice())
+	// 设置不可重复
+	a.SetUnique(true)
+	fmt.Println(a.Slice())
+	a.Add(1)
+	fmt.Println(a.Slice())
 }

geg/container/garray/garray_slice_safe.go

@@ -1,18 +1,17 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/garray"
-    "github.com/gogf/gf/g"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
 )
 
+func main() {
+	a := garray.NewIntArray()
+	a.Append(1, 2, 3)
 
-func main () {
-    a := garray.NewIntArray()
-    a.Append(1, 2, 3)
+	v := a.Slice()
+	v[0] = 4
 
-    v   := a.Slice()
-    v[0] = 4
-
-    g.Dump(a.Slice())
-    g.Dump(v)
+	g.Dump(a.Slice())
+	g.Dump(v)
 }

geg/container/garray/sorted_string_array1.go

@@ -1,20 +1,20 @@
 package main
 
 import (
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/container/garray"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
 )
 
-func main()  {
-    array := garray.NewSortedStringArray()
-    array.Add("1")
-    array.Add("2")
-    array.Add("3")
-    array.Add("4")
-    array.Add("5")
-    array.Add("6")
-    array.Add("7")
-    array.Add("8")
-    array.Add("9")
-    g.Dump(array.Slice())
-}
+func main() {
+	array := garray.NewSortedStringArray()
+	array.Add("1")
+	array.Add("2")
+	array.Add("3")
+	array.Add("4")
+	array.Add("5")
+	array.Add("6")
+	array.Add("7")
+	array.Add("8")
+	array.Add("9")
+	g.Dump(array.Slice())
+}

geg/container/garray/sorted_string_array2.go

@@ -1,26 +1,26 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g"
-    "github.com/gogf/gf/g/container/garray"
-    "strings"
+	"fmt"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/garray"
+	"strings"
 )
 
-func main()  {
-    array := garray.NewSortedStringArray()
-    array.Add("/api/ctl/show")
-    array.Add("/api/ctl/post")
-    array.Add("/api/obj/rest")
-    array.Add("/api/handler")
-    array.Add("/api/obj/delete")
-    array.Add("/api/obj/show")
-    array.Add("/api/obj/my-show")
-    array.Add("/api/*")
-    array.Add("/api/ctl/rest")
-    array.Add("/api/ctl/my-show")
-    g.Dump(array.Slice())
+func main() {
+	array := garray.NewSortedStringArray()
+	array.Add("/api/ctl/show")
+	array.Add("/api/ctl/post")
+	array.Add("/api/obj/rest")
+	array.Add("/api/handler")
+	array.Add("/api/obj/delete")
+	array.Add("/api/obj/show")
+	array.Add("/api/obj/my-show")
+	array.Add("/api/*")
+	array.Add("/api/ctl/rest")
+	array.Add("/api/ctl/my-show")
+	g.Dump(array.Slice())
 
-    fmt.Println(strings.Compare("/api/ctl/post", "/api/*"))
-    fmt.Println(strings.Compare("/api/*", "/api/ctl/my-show"))
-}
+	fmt.Println(strings.Compare("/api/ctl/post", "/api/*"))
+	fmt.Println(strings.Compare("/api/*", "/api/ctl/my-show"))
+}

geg/container/gmap/gmap.go

@@ -1,73 +1,73 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gmap"
+	"fmt"
+	"github.com/gogf/gf/g/container/gmap"
 )
 
 func main() {
-    // 创建一个默认的gmap对象，
-    // 默认情况下该gmap对象支持并发安全特性，
-    // 初始化时可以给定false参数关闭并发安全特性，当做一个普通的map使用。
-    m := gmap.New()
+	// 创建一个默认的gmap对象，
+	// 默认情况下该gmap对象支持并发安全特性，
+	// 初始化时可以给定false参数关闭并发安全特性，当做一个普通的map使用。
+	m := gmap.New()
 
-    // 设置键值对
-    for i := 0; i < 10; i++ {
-        m.Set(i, i)
-    }
-    // 查询大小
-    fmt.Println(m.Size())
-    // 批量设置键值对(不同的数据类型对象参数不同)
-    m.BatchSet(map[interface{}]interface{}{
-        10 : 10,
-        11 : 11,
-    })
-    fmt.Println(m.Size())
+	// 设置键值对
+	for i := 0; i < 10; i++ {
+		m.Set(i, i)
+	}
+	// 查询大小
+	fmt.Println(m.Size())
+	// 批量设置键值对(不同的数据类型对象参数不同)
+	m.BatchSet(map[interface{}]interface{}{
+		10: 10,
+		11: 11,
+	})
+	fmt.Println(m.Size())
 
-    // 查询是否存在
-    fmt.Println(m.Contains(1))
+	// 查询是否存在
+	fmt.Println(m.Contains(1))
 
-    // 查询键值
-    fmt.Println(m.Get(1))
+	// 查询键值
+	fmt.Println(m.Get(1))
 
-    // 删除数据项
-    m.Remove(9)
-    fmt.Println(m.Size())
+	// 删除数据项
+	m.Remove(9)
+	fmt.Println(m.Size())
 
-    // 批量删除
-    m.BatchRemove([]interface{}{10, 11})
-    fmt.Println(m.Size())
+	// 批量删除
+	m.BatchRemove([]interface{}{10, 11})
+	fmt.Println(m.Size())
 
-    // 当前键名列表(随机排序)
-    fmt.Println(m.Keys())
-    // 当前键值列表(随机排序)
-    fmt.Println(m.Values())
+	// 当前键名列表(随机排序)
+	fmt.Println(m.Keys())
+	// 当前键值列表(随机排序)
+	fmt.Println(m.Values())
 
-    // 查询键名，当键值不存在时，写入给定的默认值
-    fmt.Println(m.GetWithDefault(100, 100))
+	// 查询键名，当键值不存在时，写入给定的默认值
+	fmt.Println(m.GetWithDefault(100, 100))
 
-    // 删除键值对，并返回对应的键值
-    fmt.Println(m.GetAndRemove(100))
+	// 删除键值对，并返回对应的键值
+	fmt.Println(m.GetAndRemove(100))
 
-    // 遍历map
-    m.Iterator(func(k interface{}, v interface{}) bool {
-        fmt.Printf("%v:%v ", k, v)
-        return true
-    })
+	// 遍历map
+	m.Iterator(func(k interface{}, v interface{}) bool {
+		fmt.Printf("%v:%v ", k, v)
+		return true
+	})
 
-    // 自定义写锁操作
-    m.LockFunc(func(m map[interface{}]interface{}) {
-        m[99] = 99
-    })
+	// 自定义写锁操作
+	m.LockFunc(func(m map[interface{}]interface{}) {
+		m[99] = 99
+	})
 
-    // 自定义读锁操作
-    m.RLockFunc(func(m map[interface{}]interface{}) {
-        fmt.Println(m[99])
-    })
+	// 自定义读锁操作
+	m.RLockFunc(func(m map[interface{}]interface{}) {
+		fmt.Println(m[99])
+	})
 
-    // 清空map
-    m.Clear()
+	// 清空map
+	m.Clear()
 
-    // 判断map是否为空
-    fmt.Println(m.IsEmpty())
+	// 判断map是否为空
+	fmt.Println(m.IsEmpty())
 }

geg/container/gmap/gmap_map_safe.go

@@ -1,17 +1,17 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gmap"
-    "github.com/gogf/gf/g"
+	"github.com/gogf/gf/g"
+	"github.com/gogf/gf/g/container/gmap"
 )
 
 func main() {
-    m := gmap.New()
-    m.Set("1", "1")
+	m := gmap.New()
+	m.Set("1", "1")
 
-    m1 := m.Clone()
-    m1["2"] = "2"
+	m1 := m.Clone()
+	m1["2"] = "2"
 
-    g.Dump(m.Clone())
-    g.Dump(m1)
+	g.Dump(m.Clone())
+	g.Dump(m1)
 }

geg/container/gmap/safe_map_delete.go

@@ -1,39 +1,39 @@
 package main
 
 import (
-    "sync"
-    "time"
-    "fmt"
+	"fmt"
+	"sync"
+	"time"
 )
 
 // 验证 map 的delete方法是否并发安全
 func main() {
-    // 创建一个初始化的map
-    m := make(map[int]int)
-    for i := 0; i < 10000; i++ {
-        m[i] = i
-    }
+	// 创建一个初始化的map
+	m := make(map[int]int)
+	for i := 0; i < 10000; i++ {
+		m[i] = i
+	}
 
-    fmt.Println("map size:", len(m))
+	fmt.Println("map size:", len(m))
 
-    wg := sync.WaitGroup{}
-    ev := make(chan struct{}, 0)
+	wg := sync.WaitGroup{}
+	ev := make(chan struct{}, 0)
 
-    // 创建10个并发的goroutine，使用ev控制并发开始事件，更容易模拟data race
-    for i := 0; i < 10; i++ {
-        wg.Add(1)
-        go func() {
-            <- ev
-            fmt.Println("start")
-            for i := 0; i < 10000; i++ {
-                delete(m, i)
-            }
-            wg.Done()
-        }()
-    }
+	// 创建10个并发的goroutine，使用ev控制并发开始事件，更容易模拟data race
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			<-ev
+			fmt.Println("start")
+			for i := 0; i < 10000; i++ {
+				delete(m, i)
+			}
+			wg.Done()
+		}()
+	}
 
-    time.Sleep(time.Second)
+	time.Sleep(time.Second)
 
-    close(ev)
-    wg.Wait()
+	close(ev)
+	wg.Wait()
 }

geg/container/gpool/gpool.go

@@ -1,25 +1,25 @@
 package main
 
 import (
-    "github.com/gogf/gf/g/container/gpool"
-    "fmt"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gpool"
+	"time"
 )
 
-func main () {
-    // 创建一个对象池，过期时间为1000毫秒
-    p := gpool.New(1000, nil)
+func main() {
+	// 创建一个对象池，过期时间为1000毫秒
+	p := gpool.New(1000, nil)
 
-    // 从池中取一个对象，返回nil及错误信息
-    fmt.Println(p.Get())
+	// 从池中取一个对象，返回nil及错误信息
+	fmt.Println(p.Get())
 
-    // 丢一个对象到池中
-    p.Put(1)
+	// 丢一个对象到池中
+	p.Put(1)
 
-    // 重新从池中取一个对象，返回1
-    fmt.Println(p.Get())
+	// 重新从池中取一个对象，返回1
+	fmt.Println(p.Get())
 
-    // 等待1秒后重试，发现对象已过期，返回nil及错误信息
-    time.Sleep(time.Second)
-    fmt.Println(p.Get())
+	// 等待1秒后重试，发现对象已过期，返回nil及错误信息
+	time.Sleep(time.Second)
+	fmt.Println(p.Get())
 }

geg/container/gqueue/gqueue.go

@@ -1,33 +1,33 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
-    "github.com/gogf/gf/g/os/gtime"
-    "github.com/gogf/gf/g/container/gqueue"
+	"fmt"
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/os/gtime"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
 func main() {
-    q := gqueue.New()
-    // 数据生产者，每隔1秒往队列写数据
-    gtimer.SetInterval(time.Second, func() {
-        v := gtime.Now().String()
-        q.Push(v)
-        fmt.Println("Push:", v)
-    })
+	q := gqueue.New()
+	// 数据生产者，每隔1秒往队列写数据
+	gtimer.SetInterval(time.Second, func() {
+		v := gtime.Now().String()
+		q.Push(v)
+		fmt.Println("Push:", v)
+	})
 
-    // 3秒后关闭队列
-    gtimer.SetTimeout(3*time.Second, func() {
-        q.Close()
-    })
+	// 3秒后关闭队列
+	gtimer.SetTimeout(3*time.Second, func() {
+		q.Close()
+	})
 
-    // 消费者，不停读取队列数据并输出到终端
-    for {
-        if v := q.Pop(); v != nil {
-            fmt.Println(" Pop:", v)
-        } else {
-            break
-        }
-    }
+	// 消费者，不停读取队列数据并输出到终端
+	for {
+		if v := q.Pop(); v != nil {
+			fmt.Println(" Pop:", v)
+		} else {
+			break
+		}
+	}
 }

geg/container/gqueue/gqueue2.go

@@ -1,27 +1,27 @@
 package main
 
 import (
-    "fmt"
-    "github.com/gogf/gf/g/container/gqueue"
-    "github.com/gogf/gf/g/os/gtimer"
-    "time"
+	"fmt"
+	"github.com/gogf/gf/g/container/gqueue"
+	"github.com/gogf/gf/g/os/gtimer"
+	"time"
 )
 
 func main() {
-    q := gqueue.New()
-    // 数据生产者，每隔1秒往队列写数据
-    gtimer.SetInterval(time.Second, func() {
-        for i := 0; i < 10; i++ {
-            q.Push(i)
-        }
-    })
+	q := gqueue.New()
+	// 数据生产者，每隔1秒往队列写数据
+	gtimer.SetInterval(time.Second, func() {
+		for i := 0; i < 10; i++ {
+			q.Push(i)
+		}
+	})
 
-    // 消费者，不停读取队列数据并输出到终端
-    for {
-        if v := q.Pop(); v != nil {
-            fmt.Println(" Pop:", v)
-        } else {
-            break
-        }
-    }
+	// 消费者，不停读取队列数据并输出到终端
+	for {
+		if v := q.Pop(); v != nil {
+			fmt.Println(" Pop:", v)
+		} else {
+			break
+		}
+	}
 }