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

improve grand.Intn; README updates
Merge pull request #96 from aloncn/master
2026-06-09 11:03:59 +08:00 · 2019-04-10 23:09:59 +08:00 · 2019-04-10 23:09:38 +08:00 · 2019-04-10 21:42:25 +08:00 · 2019-04-10 18:33:51 +08:00 · 2019-04-10 18:33:12 +08:00
68 changed files with 2311 additions and 1060 deletions
--- a/README.MD
+++ b/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)
+
+



--- a/README_ZH.MD
+++ b/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)
+
--- a/RELEASE.MD
+++ b/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)

 ## 新特性
--- a/TODO.MD
+++ b/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类型的转换；
--- a/g/container/container.go
+++ b/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
--- a/g/container/garray/garray.go
+++ b/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

--- a/g/container/gchan/gchan.go
+++ b/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)
 }
--- a/g/container/glist/glist.go
+++ b/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 {
--- a/g/container/gmap/gmap.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_int_bool_map.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_int_int_map.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_int_interface_map.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_int_string_map.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_string_bool_map.go
+++ b/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
 	}
 }
--- a/g/container/gmap/gmap_string_int_map.go
+++ b/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
    }
 }
--- a/g/container/gmap/gmap_string_interface_map.go
+++ b/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
 	}
 }
--- a/g/container/gmap/gmap_string_string_map.go
+++ b/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
 	}
 }
--- a/g/container/gpool/gpool.go
+++ b/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 (
--- a/g/container/gring/gring.go
+++ b/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 (
--- a/g/container/gring/gring_unit_test.go
+++ b/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
+		})
+
+
+	})
+}
--- a/g/container/gset/gset.go
+++ b/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 (
--- a/g/container/gtype/gtype.go
+++ b/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
--- a/g/container/gvar/gvar.go
+++ b/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 (
--- a/g/crypto/crypto.go
+++ b/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
--- a/g/database/database.go
+++ b/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
--- a/g/database/gdb/gdb.go
+++ b/g/database/gdb/gdb.go
@ -148,23 +148,23 @@ 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.
 )

 var (
-    // 单例对象Map
+    // Instance map.
    instances = gmap.NewStringInterfaceMap()
 )

-// 使用默认/指定分组配置进行连接，数据库集群配置项：default
-func New(name...string) (db DB, err error) {
+// 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]
@ -209,8 +209,10 @@ func New(name...string) (db DB, err error) {
 	}
 }

-// 获得数据库操作对象单例
-func Instance(name...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]
--- a/g/database/gredis/gredis.go
+++ b/g/database/gredis/gredis.go
@ -107,7 +107,7 @@ func New(config Config) *Redis {
 // return redis instance with default group.
 //
 // 获取指定分组名称的Redis单例对象，底层根据配置信息公用的连接池（连接池单例）。
-func Instance(name...string) *Redis {
+func Instance(name ...string) *Redis {
    group := DEFAULT_GROUP_NAME
    if len(name) > 0 {
        group = name[0]
--- a/g/database/gredis/gredis_config.go
+++ b/g/database/gredis/gredis_config.go
@ -9,18 +9,16 @@ 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.
-//
-// 设置全局分组配置，name为非必需参数，默认为默认分组名称。
 func SetConfig(config Config, name...string) {
    group := DEFAULT_GROUP_NAME
    if len(name) > 0 {
@ -30,10 +28,8 @@ func SetConfig(config Config, name...string) {
    instances.Remove(group)
 }

-// GetConfig returns the global configuration with specified group.
-// If <group> is not passed, it returns configuration of the default group name.
-//
-// 获取指定全局分组配置，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 {
@ -47,8 +43,6 @@ func GetConfig(name...string) (config Config, ok bool) {

 // RemoveConfig removes the global configuration with specified group.
 // If <name> is not passed, it removes configuration of the default group name.
-//
-// 删除指定全局分组配置，name为非必需参数，默认为默认分组名称。
 func RemoveConfig(name...string) {
    group := DEFAULT_GROUP_NAME
    if len(name) > 0 {
@ -59,8 +53,6 @@ func RemoveConfig(name...string) {
 }

 // ClearConfig removes all configurations and instances of redis.
-//
-// 清除所有的配置内容。
 func ClearConfig() {
    configs.Clear()
    instances.Clear()
--- a/g/encoding/encoding.go
+++ b/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
--- a/g/encoding/gjson/gjson_unit_basic_test.go
+++ b/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)
    })
 }

--- a/g/encoding/gparser/gparser_unit_basic_test.go
+++ b/g/encoding/gparser/gparser_unit_basic_test.go
@ -107,9 +107,9 @@ func Test_GetMap(t *testing.T) {
    gtest.Case(t, func() {
        j := gparser.New(data)
        gtest.AssertNE(j, 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)
    })
 }

@ -144,7 +144,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)
    })
 }

--- a/g/frame/frame.go
+++ b/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
--- a/g/frame/gins/gins.go
+++ b/g/frame/gins/gins.go
@ -8,25 +8,21 @@
 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/gregex"
-    "github.com/gogf/gf/g/text/gstr"
-    "github.com/gogf/gf/g/util/gconv"
-    "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"
 )
@ -64,48 +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]
-    }
-    key := fmt.Sprintf("%s.%s", gFRAME_CORE_COMPONENT_NAME_CONFIG, configFile)
-    return instances.GetOrSetFuncLock(key, func() interface{} {
-        return gcfg.New(configFile)
-    }).(*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 {
--- a/g/frame/gins/gins_config_test.go
+++ b/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,6 +51,7 @@ test = "v=1"
    gtest.Case(t, func() {
        gtest.AssertNE(gins.Config(), nil)
    })
+
    // relative path
    gtest.Case(t, func() {
        path := "config.toml"
@ -84,10 +85,11 @@ test = "v=1"
        err  := gfile.PutContents(path, config)
        gtest.Assert(err, nil)
        defer gfile.Remove(path)
-        defer gins.Config().Clear()
-        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().Clear()
-        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)
@ -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").Clear()
-
-        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").Clear()
-
-        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")
    })
 }
--- a/g/g.go
+++ b/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
--- a/g/g_func.go
+++ b/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)
 }
--- a/g/g_logger.go
+++ b/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()
 }
--- a/g/g_object.go
+++ b/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...)
 }
--- a/g/g_setting.go
+++ b/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)
 }
--- a/g/net/net.go
+++ b/g/net/net.go
@ -1 +0,0 @@
-package net
--- a/g/os/gcfg/gcfg.go
+++ b/g/os/gcfg/gcfg.go
@ -38,7 +38,8 @@ type Config struct {
 }

 // New returns a new configuration management object.
-func New(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]
@ -49,19 +50,24 @@ func New(file...string) *Config {
        jsons  : gmap.NewStringInterfaceMap(),
        vc     : gtype.NewBool(),
    }
-    // Dir path of working dir.
-    c.SetPath(gfile.Pwd())
-	// Dir path from env/cmd, most high priority, will overwrite previous dir path setting.
-	if envPath := cmdenv.Get("gf.gcfg.path").String(); envPath != "" && gfile.Exists(envPath) {
-		c.SetPath(envPath)
-	}
-	// 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)
+	// 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
 }
@ -78,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 {
@ -90,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 != "" {
@ -105,7 +116,7 @@ func (c *Config) SetPath(path string) error {
            }
        })
    }
-    // 目录不存在错误处理
+    // Path not exist.
    if realPath == "" {
        buffer := bytes.NewBuffer(nil)
        if c.paths.Len() > 0 {
@ -122,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
    }
@ -139,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.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 != "" {
@ -161,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 {
@ -178,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
    }
@ -193,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 {
@ -215,19 +230,20 @@ 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 {
@ -245,7 +261,8 @@ func (c *Config) getJson(file...string) *gjson.Json {
        }
        if j, err := gjson.LoadContent(content); err == nil {
            j.SetViolenceCheck(c.vc.Val())
-            // 添加配置文件监听，如果有任何变化，删除文件内容缓存，下一次查询会自动更新
+            // 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)
@ -267,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)
@ -275,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)
@ -283,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)
@ -291,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)
@ -300,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)
@ -309,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)
@ -331,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)
@ -339,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)
@ -347,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)
@ -362,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)
@ -406,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)
--- a/g/os/gcfg/gcfg_config.go
+++ b/g/os/gcfg/gcfg_config.go
@ -15,17 +15,25 @@ var (

 // SetContent sets customized configuration content for specified <file>.
 // The <file> is unnecessary param, default is DEFAULT_CONFIG_FILE.
-func SetContent(content string, file...string) {
+func SetContent(content string, file ...string) {
    name := DEFAULT_CONFIG_FILE
    if len(file) > 0 {
        name = file[0]
    }
-    configs.Set(name, content)
+    // 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 {
+func GetContent(file ...string) string {
    name := DEFAULT_CONFIG_FILE
    if len(file) > 0 {
        name = file[0]
@ -33,7 +41,31 @@ func GetContent(file...string) string {
    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()
+		}
+	})
 }
--- a/g/os/gcfg/gcfg_instance.go
+++ b/g/os/gcfg/gcfg_instance.go
@ -10,18 +10,23 @@ 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.
-func Instance(file...string) *Config {
-	configFile := DEFAULT_CONFIG_FILE
-	if len(file) > 0 {
-		configFile = file[0]
+// 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(configFile, func() interface{} {
-		return New(configFile)
+	return instances.GetOrSetFuncLock(key, func() interface{} {
+		return New()
 	}).(*Config)
 }
--- a/g/os/gtime/gtime.go
+++ b/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 {
--- a/g/os/gtime/gtime_format.go
+++ b/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)
--- a/g/os/gtime/gtime_z_bench_test.go
+++ b/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")
+	}
+}
--- a/g/os/gtime/gtime_z_unit_basic_test.go
+++ b/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() {
+
+		})
+	})
+}
--- a/g/os/gtime/gtime_z_unit_format_test.go
+++ b/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"))
+	})
+}
--- a/g/os/gtime/gtime_z_unit_time_test.go
+++ b/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())
+	})
+}
--- a/g/os/gview/gview.go
+++ b/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("{{", "}}")
    // 内置变量
--- a/g/os/gview/gview_instance.go
+++ b/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)
+}
--- a/g/os/os.go
+++ b/g/os/os.go
@ -1 +0,0 @@
-package os
--- a/g/test/gtest/gtest.go
+++ b/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
+	}
 }
--- a/g/text/gregex/gregex_z_unit_test.go
+++ b/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)
+		}
+
+	})
+}
--- a/g/text/gstr/gstr.go
+++ b/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 {
--- a/g/text/gstr/gstr_levenshtein.go
+++ b/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)
--- a/g/text/gstr/gstr_parse.go
+++ b/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, "&")
--- a/g/text/gstr/gstr_pos.go
+++ b/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 {
--- a/g/text/gstr/gstr_similartext.go
+++ b/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 {
--- a/g/text/gstr/gstr_soundex.go
+++ b/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")
--- a/g/text/gstr/gstr_trim.go
+++ b/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)
--- a/g/text/gstr/gstr_z_bench_test.go
+++ b/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")
-    }
-}
--- a/g/util/grand/grand_intn.go
+++ b/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
                }
            }
        }
--- a/g/util/util.go
+++ b/g/util/util.go
@ -1 +0,0 @@
-package util
--- a/geg/os/gcron/gcron-log.go
+++ b/geg/os/gcron/gcron-log.go
@ -0,0 +1,16 @@
+package main
+
+import (
+	"github.com/gogf/gf/g/os/gcron"
+	"github.com/gogf/gf/g/os/glog"
+	"time"
+)
+
+
+func main() {
+	gcron.SetLogLevel(glog.LEVEL_ALL)
+	gcron.Add("* * * * * ?", func() {
+		glog.Println("test")
+	})
+	time.Sleep(3 * time.Second)
+}
--- a/geg/os/gtime/gtime_strtotime.go
+++ b/geg/os/gtime/gtime_strtotime.go
@ -2,6 +2,7 @@ package main

 import (
 	"fmt"
+	"github.com/gogf/gf/g/os/glog"
 	"github.com/gogf/gf/g/os/gtime"
 	"time"
 )
@ -19,15 +20,11 @@ func main() {
 		"2018-02-09",
 		"2017/12/14 04:51:34 +0805 LMT",
 		"2018/02/09 12:00:15",
-		"18/02/09 12:16",
-		"18/02/09 12",
-		"18/02/09 +0805 LMT",
 		"01/Nov/2018:13:28:13 +0800",
 		"01-Nov-2018 11:50:28 +0805 LMT",
 		"01-Nov-2018T15:04:05Z07:00",
 		"01-Nov-2018T01:19:15+08:00",
 		"01-Nov-2018 11:50:28 +0805 LMT",
-		"01/Nov/18 11:50:28",
 		"01/Nov/2018 11:50:28",
 		"01/Nov/2018:11:50:28",
 		"01.Nov.2018:11:50:28",
@ -35,12 +32,12 @@ func main() {
 	}
 	cstLocal, _ := time.LoadLocation("Asia/Shanghai")
 	for _, s := range array {
-		fmt.Println(s)
 		if t, err := gtime.StrToTime(s); err == nil {
-			fmt.Println(t.String())
+			fmt.Println(s)
+			fmt.Println(t.UTC().String())
 			fmt.Println(t.In(cstLocal).String())
 		} else {
-			panic(err)
+			glog.Error(s, err)
 		}
 		fmt.Println()
 	}
--- a/geg/other/test.go
+++ b/geg/other/test.go
@ -2,21 +2,14 @@ package main

 import (
 	"fmt"
-	"github.com/gogf/gf/g/encoding/gjson"
+	"github.com/gogf/gf/g/util/grand"
 )

+
+
 func main() {
-	config := `
-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"
-`
-	j, err := gjson.LoadContent(config)
-	fmt.Println(err)
-	fmt.Println(j.ToJsonIndentString())
-}
+	for {
+		fmt.Println(grand.Intn(100))
+	}
+
+}
--- a/version.go
+++ b/version.go
@ -1,4 +1,4 @@
 package gf

-const VERSION = "v1.5.23"
+const VERSION = "v1.6.1"
 const AUTHORS = "john<john@goframe.org>"
Author	SHA1	Message	Date
John	872536c035	Merge branch 'master' of https://github.com/gogf/gf	2019-04-10 23:09:59 +08:00
John	c7a6a6fff0	improve grand.Intn; README updates	2019-04-10 23:09:38 +08:00
John Guo	0cb82d70fd	Merge pull request #96 from aloncn/master update unit test for gring	2019-04-10 21:42:25 +08:00
John	acac5a2ad6	version updates	2019-04-10 18:33:51 +08:00
John	9ec15ad2ca	fix issue in repeated rand value of grand.Intn	2019-04-10 18:33:12 +08:00
aloncn	ad50ca6e60	update unit test for gring	2019-04-10 14:26:21 +08:00
aloncn	8285c31bf1	Update unit test for gring	2019-04-10 10:44:40 +08:00
aloncn	230be66fa9	update unit test for gring	2019-04-10 10:13:56 +08:00
aloncn	2c53f934c9	Merge branch 'master' of https://github.com/gogf/gf	2019-04-10 09:50:29 +08:00
John	08785cb272	update unit test cases of gjson	2019-04-10 08:54:49 +08:00
aloncn	bd0207c938	update unit test for gring	2019-04-10 01:16:45 +08:00
John	6fad737617	update unit test cases of gjson/gparser	2019-04-10 01:00:51 +08:00
aloncn	af4148d985	Merge branch 'master' of github.com:aloncn/gf	2019-04-10 00:37:22 +08:00
aloncn	922eaf4d42	Update unit test for gring	2019-04-10 00:37:06 +08:00
farmer chen	4b5153950f	Add unit test for gring	2019-04-10 00:37:06 +08:00
aloncn	78010d2bd7	Update unit test for gring	2019-04-10 00:22:10 +08:00
John	85c2ed1bf2	improve nil checks for gtest.Assert*	2019-04-09 23:12:22 +08:00
farmer chen	429aa90e0d	Merge branch 'master' of github.com:aloncn/gf	2019-04-09 18:42:16 +08:00
farmer chen	4f792b347d	Add unit test for gring	2019-04-09 18:40:48 +08:00
farmer chen	6d8ced21b9	Add unit test for gring	2019-04-09 17:27:58 +08:00
John	8b3eb5b02d	version&release updates	2019-04-09 00:15:48 +08:00
John	b90d61b27c	README updates	2019-04-07 22:03:04 +08:00
John	85606e3e7e	README updates	2019-04-07 21:59:28 +08:00
John	1fc85d49bd	gtime updates; README updates	2019-04-07 21:49:24 +08:00
John Guo	a5cfb4e638	Merge pull request #82 from hailaz/master Add gtime unit test	2019-04-07 21:27:29 +08:00
John Guo	38754bf062	Merge pull request #78 from youyixiao/youyixiao_gogf gregex_unit_test	2019-04-07 21:23:03 +08:00
hailaz	f1818ed2ff	补充gtime_format的覆盖测试。	2019-04-06 23:53:06 +08:00
hailaz	352ad17715	避免pr时造成gtime文件的更改。	2019-04-06 22:56:47 +08:00
hailaz	e50b8d9632	移除gtime unit test中注释掉的函数。	2019-04-06 22:50:37 +08:00
hailaz	2107061a46	Add gtime unit test	2019-04-06 22:48:47 +08:00
John	61f57b4895	update comments of gstr	2019-04-06 21:31:01 +08:00
hailaz	d34273abff	同步master	2019-04-05 23:53:43 +08:00
hailaz	0aff0f0362	同步master	2019-04-05 23:49:20 +08:00
John	68949b69bc	update example of gtime	2019-04-05 23:31:14 +08:00
John	c56c77d3a1	fix issue in G&j char format	2019-04-05 23:13:47 +08:00
John	dc82ce395a	comment updates for gcfg	2019-04-05 00:23:59 +08:00
John	2a29483456	comment fix	2019-04-04 23:24:27 +08:00
John	4f10562980	remove limit for gdb.Model.One	2019-04-04 23:22:09 +08:00
一墨染尽青衣颜	6863928b06	!18 限制下查询单条记录查询条数 Merge pull request !18 from 一墨染尽青衣颜/master	2019-04-04 22:55:13 +08:00
John	aa4dca11f0	fix issue in gtime; update comment for g/gtest	2019-04-04 22:52:56 +08:00
hailaz	dc6ab820ce	修复解析日期函数（parseDateStr）对"02.jan.2006"格式日期解析异常的问题。更正函数（isNumeric）的注释。	2019-04-04 17:57:17 +08:00
肖有益	be0fa4d60b	gregex_unit_test	2019-04-04 17:45:04 +08:00
肖有益	a86d2272af	gregex_unit_test	2019-04-04 16:15:50 +08:00
John	08550d413e	update unit test cases for gcfg	2019-04-04 09:18:43 +08:00
John	b89294561b	add gmap.SetIfNotExistFunc/SetIfNotExistFuncLock for gmap; update comment of gmap; update instance feature of gcfg	2019-04-03 23:39:31 +08:00