version updates

fix typo in gpool_bench_test.go

.example/database/gdb/mssql/config.toml

@@ -1,8 +1,3 @@
 
 [database]
-    type = "mssql"
-    host = "127.0.0.1"
-    port = "1451"
-    user = "sa"
-    pass = "eno@123"
-    name = "frpc"
+    linkinfo = "mssql:user id=test;password=test1;server=122.152.202.91;port=1433;database=test;encrypt=disable"

.example/database/gdb/mssql/gdb_all.go

@@ -2,13 +2,22 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/os/gtime"
 
 	_ "github.com/denisenkom/go-mssqldb"
 	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	r, err := g.DB().GetAll(`SELECT TOP 10  * FROM KF_PatInfo_Emergency`)
-	fmt.Println(err)
-	g.Dump(r.ToList())
+	type Table2 struct {
+		Id         string     `orm:"id;pr" json:"id"`              //ID
+		Createtime gtime.Time `orm:"createtime" json:"createtime"` //创建时间
+		Updatetime gtime.Time `orm:"updatetime" json:"updatetime"` //更新时间
+	}
+	var table2 Table2
+	err := g.DB().Table("table2").Where("id=?", 1).Struct(&table2)
+	if err != nil {
+		panic(err)
+	}
+	fmt.Println(table2.Createtime)
 }

.example/database/gdb/mysql/gdb_reconnect.go

@@ -0,0 +1,18 @@
+package main
+
+import (
+	"fmt"
+	"github.com/gogf/gf/frame/g"
+	"time"
+)
+
+func main() {
+	db := g.DB()
+	db.SetDebug(true)
+	for {
+		r, err := db.Table("user").All()
+		fmt.Println(err)
+		fmt.Println(r)
+		time.Sleep(time.Second * 10)
+	}
+}

.example/database/gdb/mysql/gdb_value.go

@@ -8,10 +8,6 @@ func main() {
 	db := g.DB()
 	db.SetDebug(true)
 
-	one, e := db.Table("order.order o").LeftJoin("user.user u", "o.uid=u.id").Where("u.id", 1).One()
-	if e != nil {
-		panic(e)
-	}
-	g.Dump(one)
+	db.Table("user").Fields("DISTINCT id,nickname").Filter().All()
 
 }

.example/encoding/gjson/gjson.go

@@ -100,53 +100,53 @@ func testConvert() {
 func testSplitChar() {
 	var v interface{}
 	j := gjson.New(nil)
-	t1 := gtime.Nanosecond()
+	t1 := gtime.TimestampNano()
 	j.Set("a.b.c.d.e.f.g.h.i.j.k", 1)
-	t2 := gtime.Nanosecond()
+	t2 := gtime.TimestampNano()
 	fmt.Println(t2 - t1)
 
-	t5 := gtime.Nanosecond()
+	t5 := gtime.TimestampNano()
 	v = j.Get("a.b.c.d.e.f.g.h.i.j.k")
-	t6 := gtime.Nanosecond()
+	t6 := gtime.TimestampNano()
 	fmt.Println(v)
 	fmt.Println(t6 - t5)
 
 	j.SetSplitChar('#')
 
-	t7 := gtime.Nanosecond()
+	t7 := gtime.TimestampNano()
 	v = j.Get("a#b#c#d#e#f#g#h#i#j#k")
-	t8 := gtime.Nanosecond()
+	t8 := gtime.TimestampNano()
 	fmt.Println(v)
 	fmt.Println(t8 - t7)
 }
 
 func testViolenceCheck() {
 	j := gjson.New(nil)
-	t1 := gtime.Nanosecond()
+	t1 := gtime.TimestampNano()
 	j.Set("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a", 1)
-	t2 := gtime.Nanosecond()
+	t2 := gtime.TimestampNano()
 	fmt.Println(t2 - t1)
 
-	t3 := gtime.Nanosecond()
+	t3 := gtime.TimestampNano()
 	j.Set("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a", 1)
-	t4 := gtime.Nanosecond()
+	t4 := gtime.TimestampNano()
 	fmt.Println(t4 - t3)
 
-	t5 := gtime.Nanosecond()
+	t5 := gtime.TimestampNano()
 	j.Get("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a")
-	t6 := gtime.Nanosecond()
+	t6 := gtime.TimestampNano()
 	fmt.Println(t6 - t5)
 
 	j.SetViolenceCheck(false)
 
-	t7 := gtime.Nanosecond()
+	t7 := gtime.TimestampNano()
 	j.Set("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a", 1)
-	t8 := gtime.Nanosecond()
+	t8 := gtime.TimestampNano()
 	fmt.Println(t8 - t7)
 
-	t9 := gtime.Nanosecond()
+	t9 := gtime.TimestampNano()
 	j.Get("a.a.a.a.a.a.a.a.a.a.a.a.a.a.a.a")
-	t10 := gtime.Nanosecond()
+	t10 := gtime.TimestampNano()
 	fmt.Println(t10 - t9)
 }
 

.example/net/ghttp/client/upload-batch/server.go

@@ -3,34 +3,16 @@ package main
 import (
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/gfile"
-	"io"
 )
 
 // Upload uploads files to /tmp .
 func Upload(r *ghttp.Request) {
-	saveDir := "/tmp/"
-	for _, item := range r.GetMultipartFiles("upload-file") {
-		file, err := item.Open()
-		if err != nil {
-			r.Response.Write(err)
-			return
-		}
-		defer file.Close()
-
-		f, err := gfile.Create(saveDir + gfile.Basename(item.Filename))
-		if err != nil {
-			r.Response.Write(err)
-			return
-		}
-		defer f.Close()
-
-		if _, err := io.Copy(f, file); err != nil {
-			r.Response.Write(err)
-			return
-		}
+	saveDirPath := "/tmp/"
+	files := r.GetUploadFiles("upload-file")
+	if err := files.Save(saveDirPath); err != nil {
+		r.Response.WriteExit(err)
 	}
-	r.Response.Write("upload successfully")
+	r.Response.WriteExit("upload successfully")
 }
 
 // UploadShow shows uploading simgle file page.
@@ -71,7 +53,7 @@ func UploadShowBatch(r *ghttp.Request) {
 func main() {
 	s := g.Server()
 	s.Group("/upload", func(group *ghttp.RouterGroup) {
-		group.ALL("/", Upload)
+		group.POST("/", Upload)
 		group.ALL("/show", UploadShow)
 		group.ALL("/batch", UploadShowBatch)
 	})

.example/net/ghttp/client/upload/server.go

@@ -3,34 +3,16 @@ package main
 import (
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/gfile"
-	"io"
 )
 
 // Upload uploads files to /tmp .
 func Upload(r *ghttp.Request) {
-	saveDir := "/tmp/"
-	for _, item := range r.GetMultipartFiles("upload-file") {
-		file, err := item.Open()
-		if err != nil {
-			r.Response.Write(err)
-			return
-		}
-		defer file.Close()
-
-		f, err := gfile.Create(saveDir + gfile.Basename(item.Filename))
-		if err != nil {
-			r.Response.Write(err)
-			return
-		}
-		defer f.Close()
-
-		if _, err := io.Copy(f, file); err != nil {
-			r.Response.Write(err)
-			return
-		}
+	saveDirPath := "/tmp/"
+	files := r.GetUploadFiles("upload-file")
+	if err := files.Save(saveDirPath); err != nil {
+		r.Response.WriteExit(err)
 	}
-	r.Response.Write("upload successfully")
+	r.Response.WriteExit("upload successfully")
 }
 
 // UploadShow shows uploading simgle file page.
@@ -71,7 +53,7 @@ func UploadShowBatch(r *ghttp.Request) {
 func main() {
 	s := g.Server()
 	s.Group("/upload", func(group *ghttp.RouterGroup) {
-		group.ALL("/", Upload)
+		group.POST("/", Upload)
 		group.ALL("/show", UploadShow)
 		group.ALL("/batch", UploadShowBatch)
 	})

.example/net/ghttp/server/body.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"fmt"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/net/ghttp"
+	"io/ioutil"
+)
+
+func main() {
+	s := g.Server()
+	s.SetIndexFolder(true)
+	s.BindHandler("/", func(r *ghttp.Request) {
+		body1 := r.GetBody()
+		body2, _ := ioutil.ReadAll(r.Body)
+		fmt.Println(body1)
+		fmt.Println(body2)
+		r.Response.Write("hello world")
+	})
+	s.SetPort(8999)
+	s.Run()
+}

.example/net/ghttp/server/cors/cors1.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
+	"github.com/gogf/gf/os/glog"
 )
 
 func MiddlewareCORS(r *ghttp.Request) {
@@ -11,6 +12,7 @@ func MiddlewareCORS(r *ghttp.Request) {
 }
 
 func Order(r *ghttp.Request) {
+	glog.Println("order")
 	r.Response.Write("GET")
 }
 
@@ -18,7 +20,7 @@ func main() {
 	s := g.Server()
 	s.Group("/api.v1", func(group *ghttp.RouterGroup) {
 		group.Middleware(MiddlewareCORS)
-		g.GET("/order", Order)
+		group.GET("/order", Order)
 	})
 	s.SetPort(8199)
 	s.Run()

.example/net/ghttp/server/cors/cors2.go

@@ -20,7 +20,7 @@ func main() {
 	s := g.Server()
 	s.Group("/api.v1", func(group *ghttp.RouterGroup) {
 		group.Middleware(MiddlewareCORS)
-		g.GET("/order", Order)
+		group.GET("/order", Order)
 	})
 	s.SetPort(8199)
 	s.Run()

.example/net/ghttp/server/cors/cors3.go

@@ -26,7 +26,7 @@ func main() {
 	s := g.Server()
 	s.Group("/api.v1", func(group *ghttp.RouterGroup) {
 		group.Middleware(MiddlewareCORS)
-		g.GET("/order", Order)
+		group.GET("/order", Order)
 	})
 	s.SetPort(8199)
 	s.Run()

.example/net/ghttp/server/middleware/auth_exception.go

@@ -19,7 +19,7 @@ func MiddlewareAuth(r *ghttp.Request) {
 func main() {
 	s := g.Server()
 	s.Group("/admin", func(group *ghttp.RouterGroup) {
-		g.MiddlewarePattern("/*action", func(r *ghttp.Request) {
+		group.Middleware(func(r *ghttp.Request) {
 			if action := r.GetRouterString("action"); action != "" {
 				switch action {
 				case "login":

.example/net/ghttp/server/middleware/log.go

@@ -25,14 +25,12 @@ func MiddlewareCORS(r *ghttp.Request) {
 
 func MiddlewareLog(r *ghttp.Request) {
 	r.Middleware.Next()
-	glog.Println(r.Response.Status, r.URL.Path)
+	g.Log().Println(r.Response.Status, r.URL.Path)
 }
 
 func main() {
 	s := g.Server()
-	s.Group("/", func(group *ghttp.RouterGroup) {
-		group.Middleware(MiddlewareLog)
-	})
+	s.Use(MiddlewareLog)
 	s.Group("/api.v2", func(group *ghttp.RouterGroup) {
 		group.Middleware(MiddlewareAuth, MiddlewareCORS)
 		group.ALL("/user/list", func(r *ghttp.Request) {

.example/net/ghttp/server/middleware/middleware.go

@@ -13,20 +13,20 @@ func main() {
 			r.Middleware.Next()
 			r.Response.Write("end")
 		})
-		g.Group("/order", func(group *ghttp.RouterGroup) {
-			g.GET("/list", func(r *ghttp.Request) {
+		group.Group("/order", func(group *ghttp.RouterGroup) {
+			group.GET("/list", func(r *ghttp.Request) {
 				r.Response.Write("list")
 			})
 		})
-		g.Group("/user", func(group *ghttp.RouterGroup) {
-			g.GET("/info", func(r *ghttp.Request) {
+		group.Group("/user", func(group *ghttp.RouterGroup) {
+			group.GET("/info", func(r *ghttp.Request) {
 				r.Response.Write("info")
 			})
-			g.POST("/edit", func(r *ghttp.Request) {
+			group.POST("/edit", func(r *ghttp.Request) {
 				r.Response.Write("edit")
 			})
 		})
-		g.Group("/hook", func(group *ghttp.RouterGroup) {
+		group.Group("/hook", func(group *ghttp.RouterGroup) {
 			group.Hook("/*", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
 				r.Response.Write("hook any")
 			})

.example/net/ghttp/server/session/basic/session.go

@@ -9,14 +9,14 @@ import (
 func main() {
 	s := g.Server()
 	s.Group("/", func(group *ghttp.RouterGroup) {
-		g.GET("/set", func(r *ghttp.Request) {
-			r.Session.Set("time", gtime.Second())
+		group.GET("/set", func(r *ghttp.Request) {
+			r.Session.Set("time", gtime.Timestamp())
 			r.Response.Write("ok")
 		})
-		g.GET("/get", func(r *ghttp.Request) {
+		group.GET("/get", func(r *ghttp.Request) {
 			r.Response.WriteJson(r.Session.Map())
 		})
-		g.GET("/clear", func(r *ghttp.Request) {
+		group.GET("/clear", func(r *ghttp.Request) {
 			r.Session.Clear()
 		})
 	})

.example/net/ghttp/server/session/redis/redis.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/net/ghttp"
+	"github.com/gogf/gf/os/gsession"
+	"github.com/gogf/gf/os/gtime"
+	"time"
+)
+
+func main() {
+	s := g.Server()
+	s.SetSessionMaxAge(2 * time.Minute)
+	s.SetSessionStorage(gsession.NewStorageRedis(g.Redis()))
+	s.Group("/", func(group *ghttp.RouterGroup) {
+		group.GET("/set", func(r *ghttp.Request) {
+			r.Session.Set("time", gtime.Timestamp())
+			r.Response.Write("ok")
+		})
+		group.GET("/get", func(r *ghttp.Request) {
+			r.Response.WriteJson(r.Session.Map())
+		})
+		group.GET("/clear", func(r *ghttp.Request) {
+			r.Session.Clear()
+		})
+	})
+	s.SetPort(8199)
+	s.Run()
+}

.example/net/gtcp/pkg_operations/monitor/gtcp_monitor_client.go

@@ -27,7 +27,7 @@ func main() {
 		},
 		MemUsed:  15560320,
 		MemTotal: 16333788,
-		Time:     int(gtime.Second()),
+		Time:     int(gtime.Timestamp()),
 	})
 	if err != nil {
 		panic(err)

.example/os/grpool/goroutine.go

@@ -9,7 +9,7 @@ import (
 )
 
 func main() {
-	start := gtime.Millisecond()
+	start := gtime.TimestampMilli()
 	wg := sync.WaitGroup{}
 	for i := 0; i < 100000; i++ {
 		wg.Add(1)
@@ -19,5 +19,5 @@ func main() {
 		}()
 	}
 	wg.Wait()
-	fmt.Println("time spent:", gtime.Millisecond()-start)
+	fmt.Println("time spent:", gtime.TimestampMilli()-start)
 }

.example/os/grpool/grpool.go

@@ -10,7 +10,7 @@ import (
 )
 
 func main() {
-	start := gtime.Millisecond()
+	start := gtime.TimestampMilli()
 	wg := sync.WaitGroup{}
 	for i := 0; i < 100000; i++ {
 		wg.Add(1)
@@ -21,5 +21,5 @@ func main() {
 	}
 	wg.Wait()
 	fmt.Println(grpool.Size())
-	fmt.Println("time spent:", gtime.Millisecond()-start)
+	fmt.Println("time spent:", gtime.TimestampMilli()-start)
 }

.example/os/gtime/gtime_func.go

@@ -9,8 +9,8 @@ import (
 func main() {
 	fmt.Println("Date       :", gtime.Date())
 	fmt.Println("Datetime   :", gtime.Datetime())
-	fmt.Println("Second     :", gtime.Second())
-	fmt.Println("Millisecond:", gtime.Millisecond())
-	fmt.Println("Microsecond:", gtime.Microsecond())
-	fmt.Println("Nanosecond :", gtime.Nanosecond())
+	fmt.Println("Second     :", gtime.Timestamp())
+	fmt.Println("Millisecond:", gtime.TimestampMilli())
+	fmt.Println("Microsecond:", gtime.TimestampMicro())
+	fmt.Println("Nanosecond :", gtime.TimestampNano())
 }

.example/other/config.toml

@@ -5,4 +5,8 @@
 
 [redis]
     default  = "127.0.0.1:6379,0"
-    cache = "127.0.0.1:6379,1"
+    cache = "127.0.0.1:6379,1"
+
+[viewer]
+    delimiters  =  ["${", "}"]
+    autoencode  =  true

.example/other/test.go

@@ -1,14 +1,37 @@
 package main
 
 import (
+	"net/http"
+
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/os/gfile"
+	"github.com/gogf/gf/net/ghttp"
 )
 
-func main() {
-	g.Dump(gfile.ScanDirFile("/Users/john/Temp/test", "Dockerfile", true))
-	//if err := gfile.ReplaceDir("gf-empty", "app", "/Users/john/Temp/test", "*.*", true); err != nil {
-	//	glog.Fatal("content replacing failed,", err.Error())
-	//}
-
+func MiddlewareAuth(r *ghttp.Request) {
+	token := r.Get("token")
+	if token == "123456" {
+		r.Response.Writeln("auth")
+		r.Middleware.Next()
+	} else {
+		r.Response.WriteStatus(http.StatusForbidden)
+	}
+}
+
+func MiddlewareCORS(r *ghttp.Request) {
+	r.Response.Writeln("cors")
+	r.Response.CORSDefault()
+	r.Middleware.Next()
+}
+
+func main() {
+	s := g.Server()
+	s.Use(MiddlewareCORS)
+	s.Group("/api.v2", func(group *ghttp.RouterGroup) {
+		group.Middleware(MiddlewareAuth)
+		group.ALL("/user/list", func(r *ghttp.Request) {
+			r.Response.Writeln("list")
+		})
+	})
+	s.SetPort(8199)
+	s.Run()
 }

.travis.yml

@@ -4,6 +4,7 @@ go:
   - "1.11.x"
   - "1.12.x"
   - "1.13.x"
+  - "1.14.x"
 
 branches:
   only:
@@ -12,7 +13,7 @@ branches:
   - staging
 
 env:
-- GF_DEV=1 GO111MODULE=on
+- GF_DEBUG=1 GO111MODULE=on
 
 services:
 - mysql

DONATOR.MD

@@ -2,6 +2,7 @@
 
 We currently accept donation by Alipay/WechatPay, please note your github/gitee account in your payment bill.
 
+> If you cannot view the donation image, please click [here](https://goframe.org/images/donate.png).
 
 | Name | Channel | Amount | Comment 
 |---|---|--- | ---
@@ -42,6 +43,14 @@ We currently accept donation by Alipay/WechatPay, please note your github/gitee
 |张炳贤|wechat+qq|￥600.00| 
 |[王哈哈](https://gitee.com/develop1024)|wechat|￥6.66| 希望gf越来越好
 |夕景|alipay+qq|￥9.96+3.57| 
+|struggler|alipay|￥18.80| 
+|*铁|wechat|￥0.01| 
+|C*e|wechat|￥66.66| GF越来越好，棒👍！
+|(佚名)|wechat|￥6.66| (名字打不出来，也没备注，捐赠时间2020-02-21 14:24:34)
+|[王飞](https://gitee.com/wang_2018)|gitee|￥20.00| 感谢您的开源项目！
+|[Zeroing-ZY](https://gitee.com/yunjieg)|gitee|￥20.00| 感谢您的开源项目！
+|[katydid酱](https://gitee.com/katydid2005)|gitee|￥50.00| 感谢您的开源项目！框架给予了很大的帮助！谢谢大佬！
+|[李海峰](https://gitee.com/dlhf)|gitee|￥10.00| 希望GF越来越好，框架很牛逼！
 
 
 <img src="https://goframe.org/images/donate.png"/>

README.MD

@@ -1,6 +1,6 @@
 # GoFrame
 
-[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf/g#pkg-subdirectories)
+[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf)
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf)
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
@@ -9,11 +9,11 @@
 
 English | [简体中文](README_ZH.MD)
 
-`GF(GoFrame)` is a modular, full-featured and production-ready application development framework of golang. 
-Providing a series of core components and dozens of practical modules, 
+`GF(GoFrame)` is a modular, loose-coupled, full-featured and production-ready application development framework of golang,
+providing a series of core components and dozens of practical modules, 
 such as: memcache, configure, validator, logging, array/queue/set/map containers, 
-timer/timing tasks, file/memory lock, object pool, database ORM, etc. 
-Supporting web server integrated with router, cookie, session, middleware, logger, 
+timer/timing tasks, file/memory lock, object pool, database ORM, etc,
+supporting web server integrated with router, cookie, session, middleware, logger, 
 template, https, hooks, rewrites and many more features.
 
 
@@ -36,49 +36,41 @@ golang version >= 1.10
 * [APIDoc](https://godoc.org/github.com/gogf/gf)
 * [中文文档](https://goframe.org)
 
+# Discussion
+- QQ Group：[116707870](//shang.qq.com/wpa/qunwpa?idkey=195f91eceeb5d7fa76009b7cd5a4641f70bf4897b7f5a520635eb26ff17adfe7)
+- WX Group：Add friend`389961817` in WeChat, commenting `GF`
+- Issues：https://github.com/gogf/gf/issues
+
+> It's recommended learning `GoFrame` through its awesome source codes and API reference.
+
 # Architecture
 <div align=center>
-<img src="https://goframe.org/images/arch.png?v=10"/>
+<img src="https://goframe.org/images/arch.png?v=11"/>
 </div>
 
-# Quick Start
-
-```go
-package main
-
-import (
-    "github.com/gogf/gf/frame/g"
-    "github.com/gogf/gf/net/ghttp"
-)
-
-func main() {
-    s := g.Server()
-    s.BindHandler("/", func(r *ghttp.Request) {
-        r.Response.Write("Hello World")
-    })
-    s.Run()
-}
-```
-
-[More Features...](https://goframe.org/start/index)
-
 
 # License
 
 `GF` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.
 
+# Contributors
+This project exists thanks to all the people who contribute. [[Contributors](https://github.com/gogf/gf/graphs/contributors)].
+<a href="https://github.com/gogf/gf/graphs/contributors"><img src="https://opencollective.com/goframe/contributors.svg?width=890&button=false" /></a>
+
 # Donators
 
 We currently accept donation by Alipay/WechatPay, please note your github/gitee account in your payment bill. If you like `GF`, why not [buy developer a cup of coffee](DONATOR.MD)?
 
+# Sponsors
+We appreciate any kind of sponsorship for `GF` development. If you've got some interesting, please contact WeChat `389961817` / Email `john@goframe.org`.
+
+
 # Thanks
 <a href="https://www.jetbrains.com/?from=GoFrame"><img src="https://goframe.org/images/jetbrains.png" width="100" alt="JetBrains"/></a>
 
 
-<!--
-# Sponsor
-We appreciate any kind of sponsorship for `GF` development. If you've got some interested, please contact john@goframe.org.
--->
+
+
 
 
 

README_ZH.MD

@@ -1,5 +1,5 @@
 # GoFrame
-[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf/g#pkg-subdirectories) 
+[![Go Doc](https://godoc.org/github.com/gogf/gf?status.svg)](https://godoc.org/github.com/gogf/gf) 
 [![Build Status](https://travis-ci.org/gogf/gf.svg?branch=master)](https://travis-ci.org/gogf/gf) 
 [![Go Report](https://goreportcard.com/badge/github.com/gogf/gf?v=1)](https://goreportcard.com/report/github.com/gogf/gf)
 [![Code Coverage](https://codecov.io/gh/gogf/gf/branch/master/graph/badge.svg)](https://codecov.io/gh/gogf/gf/branch/master)
@@ -18,11 +18,16 @@
 # 特点
 * 模块化、松耦合设计；
 * 模块丰富，开箱即用；
-* 简便及可维护性为宗旨；
+* 简便易用，易于维护；
+* 社区活跃，大牛谦逊低调脾气好；
+* 高代码质量、高单元测试覆盖率；
 * 详尽的开发文档及示例；
 * 完善的本地中文化支持；
 * 更适合企业及团队使用；
-* 更多请查阅文档及源码；
+
+# 地址
+- **主库**：https://github.com/gogf/gf 
+- **码云**：https://gitee.com/johng/gf 
 
 # 安装
 ```html
@@ -40,7 +45,7 @@ golang版本 >= 1.11
 
 # 架构
 <div align=center>
-<img src="https://goframe.org/images/arch.png?v=10"/>
+<img src="https://goframe.org/images/arch.png?v=11"/>
 </div>
 
 
@@ -51,35 +56,31 @@ golang版本 >= 1.11
 
 接口文档：[https://godoc.org/github.com/gogf/gf](https://godoc.org/github.com/gogf/gf)
 
-# 使用
-```go
-package main
-
-import (
-    "github.com/gogf/gf/frame/g"
-    "github.com/gogf/gf/net/ghttp"
-)
-
-func main() {
-    s := g.Server()
-    s.BindHandler("/", func(r *ghttp.Request) {
-        r.Response.Write("Hello World")
-    })
-    s.Run()
-}
-```
-
-[更多..](https://goframe.org/start/index)
+# 帮助
+- QQ交流群：[116707870](//shang.qq.com/wpa/qunwpa?idkey=195f91eceeb5d7fa76009b7cd5a4641f70bf4897b7f5a520635eb26ff17adfe7)
+- WX交流群：微信添加`389961817`备注`GF`
+- 主库ISSUE：https://github.com/gogf/gf/issues
 
+> 建议通过阅读`Gorame`的源码以及API文档深度学习`GoFrame`，了解更多的精妙设计。
 
 # 协议
 
 `GF` 使用非常友好的 [MIT](LICENSE) 开源协议进行发布，永久`100%`开源免费。
 
+# 贡献
+
+感谢所有参与`GoFrame`开发的贡献者。 [[贡献者列表](https://github.com/gogf/gf/graphs/contributors)].
+<a href="https://github.com/gogf/gf/graphs/contributors"><img src="https://opencollective.com/goframe/contributors.svg?width=890&button=false" /></a>
+
+
 # 捐赠
 
 如果您喜欢`GF`，要不[给开发者来杯咖啡吧](DONATOR.MD)！
 请在捐赠时备注您的`github`/`gitee`账号名称。
 
+# 赞助
+
+赞助支持`GF`框架的快速研发，如果您感兴趣，请联系 微信 `389961817` / 邮件 `john@goframe.org`。
+
 # 感谢
 <a href="https://www.jetbrains.com/?from=GoFrame"><img src="https://goframe.org/images/jetbrains.png" width="100" alt="JetBrains"/></a>

container/garray/garray_normal_any.go

@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/gogf/gf/internal/empty"
 	"github.com/gogf/gf/text/gstr"
 	"math"
 	"sort"
@@ -176,6 +177,9 @@ func (a *Array) InsertAfter(index int, value interface{}) *Array {
 func (a *Array) Remove(index int) interface{} {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return nil
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency。
 	if index == 0 {
 		value := a.array[0]
@@ -194,6 +198,16 @@ func (a *Array) Remove(index int) interface{} {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *Array) RemoveValue(value interface{}) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *Array) PushLeft(value ...interface{}) *Array {
 	a.mu.Lock()
@@ -418,9 +432,6 @@ func (a *Array) Contains(value interface{}) bool {
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *Array) Search(value interface{}) int {
-	if len(a.array) == 0 {
-		return -1
-	}
 	a.mu.RLock()
 	result := -1
 	for index, v := range a.array {
@@ -430,7 +441,20 @@ func (a *Array) Search(value interface{}) int {
 		}
 	}
 	a.mu.RUnlock()
+	return result
+}
 
+func (a *Array) doSearch(value interface{}) int {
+	if len(a.array) == 0 {
+		return -1
+	}
+	result := -1
+	for index, v := range a.array {
+		if v == value {
+			result = index
+			break
+		}
+	}
 	return result
 }
 
@@ -696,3 +720,48 @@ func (a *Array) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *Array) UnmarshalValue(value interface{}) error {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceAny(value)
+	}
+	return nil
+}
+
+// FilterNil removes all nil value of the array.
+func (a *Array) FilterNil() *Array {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}
+
+// FilterEmpty removes all empty value of the array.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
+func (a *Array) FilterEmpty() *Array {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}

container/garray/garray_normal_int.go

@@ -179,6 +179,9 @@ func (a *IntArray) InsertAfter(index int, value int) *IntArray {
 func (a *IntArray) Remove(index int) int {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return 0
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency.
 	if index == 0 {
 		value := a.array[0]
@@ -197,6 +200,16 @@ func (a *IntArray) Remove(index int) int {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *IntArray) RemoveValue(value int) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *IntArray) PushLeft(value ...int) *IntArray {
 	a.mu.Lock()
@@ -430,9 +443,6 @@ func (a *IntArray) Contains(value int) bool {
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *IntArray) Search(value int) int {
-	if len(a.array) == 0 {
-		return -1
-	}
 	a.mu.RLock()
 	result := -1
 	for index, v := range a.array {
@@ -442,7 +452,6 @@ func (a *IntArray) Search(value int) int {
 		}
 	}
 	a.mu.RUnlock()
-
 	return result
 }
 
@@ -691,3 +700,33 @@ func (a *IntArray) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *IntArray) UnmarshalValue(value interface{}) error {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceInt(value)
+	}
+	return nil
+}
+
+// FilterEmpty removes all zero value of the array.
+func (a *IntArray) FilterEmpty() *IntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if a.array[i] == 0 {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}

container/garray/garray_normal_str.go

@@ -165,6 +165,9 @@ func (a *StrArray) InsertAfter(index int, value string) *StrArray {
 func (a *StrArray) Remove(index int) string {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return ""
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency。
 	if index == 0 {
 		value := a.array[0]
@@ -183,6 +186,16 @@ func (a *StrArray) Remove(index int) string {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *StrArray) RemoveValue(value string) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PushLeft pushes one or multiple items to the beginning of array.
 func (a *StrArray) PushLeft(value ...string) *StrArray {
 	a.mu.Lock()
@@ -687,3 +700,33 @@ func (a *StrArray) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *StrArray) UnmarshalValue(value interface{}) error {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceStr(value)
+	}
+	return nil
+}
+
+// FilterEmpty removes all empty string value of the array.
+func (a *StrArray) FilterEmpty() *StrArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if a.array[i] == "" {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			i++
+		}
+	}
+	return a
+}

container/garray/garray_sorted_any.go

@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"github.com/gogf/gf/internal/empty"
 	"github.com/gogf/gf/text/gstr"
 	"github.com/gogf/gf/util/gutil"
 	"math"
@@ -160,6 +161,9 @@ func (a *SortedArray) Get(index int) interface{} {
 func (a *SortedArray) Remove(index int) interface{} {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return nil
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency.
 	if index == 0 {
 		value := a.array[0]
@@ -178,6 +182,16 @@ func (a *SortedArray) Remove(index int) interface{} {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *SortedArray) RemoveValue(value interface{}) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedArray) PopLeft() interface{} {
 	a.mu.Lock()
@@ -642,10 +656,77 @@ func (a *SortedArray) UnmarshalJSON(b []byte) error {
 	if err := json.Unmarshal(b, &a.array); err != nil {
 		return err
 	}
-	if a.comparator != nil {
+	if a.comparator != nil && a.array != nil {
 		sort.Slice(a.array, func(i, j int) bool {
 			return a.comparator(a.array[i], a.array[j]) < 0
 		})
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *SortedArray) UnmarshalValue(value interface{}) (err error) {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+		a.unique = gtype.NewBool()
+		// Note that the comparator is string comparator in default.
+		a.comparator = gutil.ComparatorString
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceAny(value)
+	}
+	if a.comparator != nil && a.array != nil {
+		sort.Slice(a.array, func(i, j int) bool {
+			return a.comparator(a.array[i], a.array[j]) < 0
+		})
+	}
+	return err
+}
+
+// FilterNil removes all nil value of the array.
+func (a *SortedArray) FilterNil() *SortedArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	for i := len(a.array) - 1; i >= 0; {
+		if empty.IsNil(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	return a
+}
+
+// FilterEmpty removes all empty value of the array.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
+func (a *SortedArray) FilterEmpty() *SortedArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	for i := len(a.array) - 1; i >= 0; {
+		if empty.IsEmpty(a.array[i]) {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	return a
+}

container/garray/garray_sorted_int.go

@@ -146,6 +146,9 @@ func (a *SortedIntArray) Get(index int) int {
 func (a *SortedIntArray) Remove(index int) int {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return 0
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency.
 	if index == 0 {
 		value := a.array[0]
@@ -164,6 +167,16 @@ func (a *SortedIntArray) Remove(index int) int {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *SortedIntArray) RemoveValue(value int) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedIntArray) PopLeft() int {
 	a.mu.Lock()
@@ -616,6 +629,51 @@ func (a *SortedIntArray) UnmarshalJSON(b []byte) error {
 	if err := json.Unmarshal(b, &a.array); err != nil {
 		return err
 	}
-	sort.Ints(a.array)
+	if a.array != nil {
+		sort.Ints(a.array)
+	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *SortedIntArray) UnmarshalValue(value interface{}) (err error) {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+		a.unique = gtype.NewBool()
+		// Note that the comparator is string comparator in default.
+		a.comparator = defaultComparatorInt
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceInt(value)
+	}
+	if a.array != nil {
+		sort.Ints(a.array)
+	}
+	return err
+}
+
+// FilterEmpty removes all zero value of the array.
+func (a *SortedIntArray) FilterEmpty() *SortedIntArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if a.array[i] == 0 {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	for i := len(a.array) - 1; i >= 0; {
+		if a.array[i] == 0 {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	return a
+}

container/garray/garray_sorted_str.go

@@ -131,6 +131,9 @@ func (a *SortedStrArray) Get(index int) string {
 func (a *SortedStrArray) Remove(index int) string {
 	a.mu.Lock()
 	defer a.mu.Unlock()
+	if index < 0 || index >= len(a.array) {
+		return ""
+	}
 	// Determine array boundaries when deleting to improve deletion efficiency.
 	if index == 0 {
 		value := a.array[0]
@@ -149,6 +152,16 @@ func (a *SortedStrArray) Remove(index int) string {
 	return value
 }
 
+// RemoveValue removes an item by value.
+// It returns true if value is found in the array, or else false if not found.
+func (a *SortedStrArray) RemoveValue(value string) bool {
+	if i := a.Search(value); i != -1 {
+		a.Remove(i)
+		return true
+	}
+	return false
+}
+
 // PopLeft pops and returns an item from the beginning of array.
 func (a *SortedStrArray) PopLeft() string {
 	a.mu.Lock()
@@ -612,6 +625,51 @@ func (a *SortedStrArray) UnmarshalJSON(b []byte) error {
 	if err := json.Unmarshal(b, &a.array); err != nil {
 		return err
 	}
-	sort.Strings(a.array)
+	if a.array != nil {
+		sort.Strings(a.array)
+	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for array.
+func (a *SortedStrArray) UnmarshalValue(value interface{}) (err error) {
+	if a.mu == nil {
+		a.mu = rwmutex.New()
+		a.unique = gtype.NewBool()
+		// Note that the comparator is string comparator in default.
+		a.comparator = defaultComparatorStr
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &a.array)
+	default:
+		a.array = gconv.SliceStr(value)
+	}
+	if a.array != nil {
+		sort.Strings(a.array)
+	}
+	return err
+}
+
+// FilterEmpty removes all empty string value of the array.
+func (a *SortedStrArray) FilterEmpty() *SortedStrArray {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	for i := 0; i < len(a.array); {
+		if a.array[i] == "" {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	for i := len(a.array) - 1; i >= 0; {
+		if a.array[i] == "" {
+			a.array = append(a.array[:i], a.array[i+1:]...)
+		} else {
+			break
+		}
+	}
+	return a
+}

container/garray/garray_z_unit_normal_any_array_test.go

@@ -34,6 +34,8 @@ func Test_Array_Basic(t *testing.T) {
 		gtest.Assert(array3.Search(100), -1)
 		gtest.Assert(array.Contains(100), true)
 		gtest.Assert(array.Remove(0), 100)
+		gtest.Assert(array.Remove(-1), nil)
+		gtest.Assert(array.Remove(100000), nil)
 
 		gtest.Assert(array2.Remove(3), 3)
 		gtest.Assert(array2.Remove(1), 1)
@@ -190,6 +192,34 @@ func TestArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[2], []interface{}{5})
 		gtest.Assert(array1.Chunk(0), nil)
 	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5}
+		array1 := garray.NewArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []interface{}{1, 2, 3})
+		gtest.Assert(chunks[1], []interface{}{4, 5})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []interface{}{1, 2})
+		gtest.Assert(chunks[1], []interface{}{3, 4})
+		gtest.Assert(chunks[2], []interface{}{5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []interface{}{1, 2, 3})
+		gtest.Assert(chunks[1], []interface{}{4, 5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestArray_Pad(t *testing.T) {
@@ -497,3 +527,67 @@ func TestArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestArray_RemoveValue(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewArrayFrom(slice)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue("e"), false)
+		gtest.Assert(array.RemoveValue("b"), true)
+		gtest.Assert(array.RemoveValue("a"), true)
+		gtest.Assert(array.RemoveValue("c"), true)
+		gtest.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.Array
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[1,2,3]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{1, 2, 3},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestArray_FilterNil(t *testing.T) {
+	gtest.Case(t, func() {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewArrayFromCopy(values)
+		gtest.Assert(array.FilterNil().Slice(), values)
+	})
+	gtest.Case(t, func() {
+		array := garray.NewArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil})
+		gtest.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}})
+		gtest.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewArrayFrom(g.Slice{1, 2, 3, 4})
+		gtest.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+}

container/garray/garray_z_unit_normal_int_array_test.go

@@ -35,6 +35,8 @@ func Test_IntArray_Basic(t *testing.T) {
 		gtest.Assert(array2.Search(100), -1)
 		gtest.Assert(array.Contains(100), true)
 		gtest.Assert(array.Remove(0), 100)
+		gtest.Assert(array.Remove(-1), 0)
+		gtest.Assert(array.Remove(100000), 0)
 		gtest.Assert(array.Contains(100), false)
 		array.Append(4)
 		gtest.Assert(array.Len(), 4)
@@ -178,6 +180,34 @@ func TestIntArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[2], []int{5})
 		gtest.Assert(array1.Chunk(0), nil)
 	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewIntArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []int{1, 2, 3})
+		gtest.Assert(chunks[1], []int{4, 5})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []int{1, 2})
+		gtest.Assert(chunks[1], []int{3, 4})
+		gtest.Assert(chunks[2], []int{5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewIntArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []int{1, 2, 3})
+		gtest.Assert(chunks[1], []int{4, 5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestIntArray_Pad(t *testing.T) {
@@ -531,3 +561,56 @@ func TestIntArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestIntArray_RemoveValue(t *testing.T) {
+	slice := g.SliceInt{10, 20, 30, 40}
+	array := garray.NewIntArrayFrom(slice)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue(99), false)
+		gtest.Assert(array.RemoveValue(20), true)
+		gtest.Assert(array.RemoveValue(10), true)
+		gtest.Assert(array.RemoveValue(20), false)
+		gtest.Assert(array.RemoveValue(88), false)
+		gtest.Assert(array.Len(), 2)
+	})
+}
+
+func TestIntArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.IntArray
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[1,2,3]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{1, 2, 3},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestIntArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
+		gtest.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		gtest.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+	})
+}

container/garray/garray_z_unit_normal_str_array_test.go

@@ -34,6 +34,8 @@ func Test_StrArray_Basic(t *testing.T) {
 		gtest.Assert(array.Search("100"), 0)
 		gtest.Assert(array.Contains("100"), true)
 		gtest.Assert(array.Remove(0), 100)
+		gtest.Assert(array.Remove(-1), "")
+		gtest.Assert(array.Remove(100000), "")
 		gtest.Assert(array.Contains("100"), false)
 		array.Append("4")
 		gtest.Assert(array.Len(), 4)
@@ -177,6 +179,34 @@ func TestStrArray_Chunk(t *testing.T) {
 		gtest.Assert(chunks[2], []string{"5"})
 		gtest.Assert(len(array1.Chunk(0)), 0)
 	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5"}
+		array1 := garray.NewStrArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []string{"1", "2", "3"})
+		gtest.Assert(chunks[1], []string{"4", "5"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStrArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []string{"1", "2"})
+		gtest.Assert(chunks[1], []string{"3", "4"})
+		gtest.Assert(chunks[2], []string{"5", "6"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewStrArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []string{"1", "2", "3"})
+		gtest.Assert(chunks[1], []string{"4", "5", "6"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestStrArray_Pad(t *testing.T) {
@@ -535,3 +565,55 @@ func TestStrArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestStrArray_RemoveValue(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewStrArrayFrom(slice)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue("e"), false)
+		gtest.Assert(array.RemoveValue("b"), true)
+		gtest.Assert(array.RemoveValue("a"), true)
+		gtest.Assert(array.RemoveValue("c"), true)
+		gtest.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestStrArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.StrArray
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`["1","2","3"]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.SliceStr{"1", "2", "3"},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+	})
+}
+
+func TestStrArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		gtest.Assert(array.FilterEmpty(), g.SliceStr{"1", "2", "0"})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2"})
+		gtest.Assert(array.FilterEmpty(), g.SliceStr{"1", "2"})
+	})
+}

container/garray/garray_z_unit_sorted_any_array_test.go

@@ -117,6 +117,9 @@ func TestSortedArray_Remove(t *testing.T) {
 		gtest.Assert(array1.Len(), 3)
 		gtest.Assert(array1.Contains("b"), false)
 
+		gtest.Assert(array1.Remove(-1), nil)
+		gtest.Assert(array1.Remove(100000), nil)
+
 		i2 := array1.Remove(0)
 		gtest.Assert(gconv.String(i2), "a")
 		gtest.Assert(array1.Len(), 2)
@@ -323,6 +326,34 @@ func TestSortedArray_Chunk(t *testing.T) {
 		i1 = array1.Chunk(0)
 		gtest.Assert(len(i1), 0)
 	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []interface{}{1, 2, 3})
+		gtest.Assert(chunks[1], []interface{}{4, 5})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []interface{}{1, 2})
+		gtest.Assert(chunks[1], []interface{}{3, 4})
+		gtest.Assert(chunks[2], []interface{}{5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []interface{}{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []interface{}{1, 2, 3})
+		gtest.Assert(chunks[1], []interface{}{4, 5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestSortedArray_SubSlice(t *testing.T) {
@@ -634,3 +665,67 @@ func TestSortedArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestSortedArray_RemoveValue(t *testing.T) {
+	slice := g.Slice{"a", "b", "d", "c"}
+	array := garray.NewSortedArrayFrom(slice, gutil.ComparatorString)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue("e"), false)
+		gtest.Assert(array.RemoveValue("b"), true)
+		gtest.Assert(array.RemoveValue("a"), true)
+		gtest.Assert(array.RemoveValue("c"), true)
+		gtest.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestSortedArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.SortedArray
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[2,3,1]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{2, 3, 1},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestSortedArray_FilterNil(t *testing.T) {
+	gtest.Case(t, func() {
+		values := g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}
+		array := garray.NewSortedArrayFromCopy(values, gutil.ComparatorInt)
+		gtest.Assert(array.FilterNil().Slice(), g.Slice{0, "", g.Slice{}, 1, 2, 3, 4})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewSortedArrayFromCopy(g.Slice{nil, 1, 2, 3, 4, nil}, gutil.ComparatorInt)
+		gtest.Assert(array.FilterNil(), g.Slice{1, 2, 3, 4})
+	})
+}
+
+func TestSortedArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewSortedArrayFrom(g.Slice{0, 1, 2, 3, 4, "", g.Slice{}}, gutil.ComparatorInt)
+		gtest.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3, 4}, gutil.ComparatorInt)
+		gtest.Assert(array.FilterEmpty(), g.Slice{1, 2, 3, 4})
+	})
+}

container/garray/garray_z_unit_sorted_int_array_test.go

@@ -78,6 +78,10 @@ func TestSortedIntArray_Remove(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []int{1, 3, 5, 0}
 		array1 := garray.NewSortedIntArrayFrom(a1)
+
+		gtest.Assert(array1.Remove(-1), 0)
+		gtest.Assert(array1.Remove(100000), 0)
+
 		i1 := array1.Remove(2)
 		gtest.Assert(i1, 3)
 		gtest.Assert(array1.Search(5), 2)
@@ -264,6 +268,34 @@ func TestSortedIntArray_Chunk(t *testing.T) {
 		gtest.Assert(ns1[2], []int{5})
 		gtest.Assert(len(ns2), 0)
 	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []int{1, 2, 3})
+		gtest.Assert(chunks[1], []int{4, 5})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []int{1, 2})
+		gtest.Assert(chunks[1], []int{3, 4})
+		gtest.Assert(chunks[2], []int{5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []int{1, 2, 3, 4, 5, 6}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []int{1, 2, 3})
+		gtest.Assert(chunks[1], []int{4, 5, 6})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestSortedIntArray_SubSlice(t *testing.T) {
@@ -513,3 +545,56 @@ func TestSortedIntArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestSortedIntArray_RemoveValue(t *testing.T) {
+	slice := g.SliceInt{10, 20, 30, 40}
+	array := garray.NewSortedIntArrayFrom(slice)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue(99), false)
+		gtest.Assert(array.RemoveValue(20), true)
+		gtest.Assert(array.RemoveValue(10), true)
+		gtest.Assert(array.RemoveValue(20), false)
+		gtest.Assert(array.RemoveValue(88), false)
+		gtest.Assert(array.Len(), 2)
+	})
+}
+
+func TestSortedIntArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.SortedIntArray
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`[2,3,1]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.Slice{2, 3, 1},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.Slice{1, 2, 3})
+	})
+}
+
+func TestSortedIntArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{0, 1, 2, 3, 4, 0})
+		gtest.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3, 4})
+		gtest.Assert(array.FilterEmpty(), g.SliceInt{1, 2, 3, 4})
+	})
+}

container/garray/garray_z_unit_sorted_str_array_test.go

@@ -77,6 +77,10 @@ func TestSortedStrArray_Remove(t *testing.T) {
 	gtest.Case(t, func() {
 		a1 := []string{"a", "d", "c", "b"}
 		array1 := garray.NewSortedStrArrayFrom(a1)
+
+		gtest.Assert(array1.Remove(-1), "")
+		gtest.Assert(array1.Remove(100000), "")
+
 		gtest.Assert(array1.Remove(2), "c")
 		gtest.Assert(array1.Get(2), "d")
 		gtest.Assert(array1.Len(), 3)
@@ -330,6 +334,34 @@ func TestSortedStrArray_Chunk(t *testing.T) {
 		gtest.Assert(array2[1], []string{"c", "d"})
 		gtest.Assert(array1.Chunk(0), nil)
 	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5"}
+		array1 := garray.NewSortedStrArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []string{"1", "2", "3"})
+		gtest.Assert(chunks[1], []string{"4", "5"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewSortedStrArrayFrom(a1)
+		chunks := array1.Chunk(2)
+		gtest.Assert(len(chunks), 3)
+		gtest.Assert(chunks[0], []string{"1", "2"})
+		gtest.Assert(chunks[1], []string{"3", "4"})
+		gtest.Assert(chunks[2], []string{"5", "6"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
+	gtest.Case(t, func() {
+		a1 := []string{"1", "2", "3", "4", "5", "6"}
+		array1 := garray.NewSortedStrArrayFrom(a1)
+		chunks := array1.Chunk(3)
+		gtest.Assert(len(chunks), 2)
+		gtest.Assert(chunks[0], []string{"1", "2", "3"})
+		gtest.Assert(chunks[1], []string{"4", "5", "6"})
+		gtest.Assert(array1.Chunk(0), nil)
+	})
 }
 
 func TestSortedStrArray_SetUnique(t *testing.T) {
@@ -523,3 +555,55 @@ func TestSortedStrArray_Iterator(t *testing.T) {
 		gtest.Assert(index, 1)
 	})
 }
+
+func TestSortedStrArray_RemoveValue(t *testing.T) {
+	slice := g.SliceStr{"a", "b", "d", "c"}
+	array := garray.NewSortedStrArrayFrom(slice)
+	gtest.Case(t, func() {
+		gtest.Assert(array.RemoveValue("e"), false)
+		gtest.Assert(array.RemoveValue("b"), true)
+		gtest.Assert(array.RemoveValue("a"), true)
+		gtest.Assert(array.RemoveValue("c"), true)
+		gtest.Assert(array.RemoveValue("f"), false)
+	})
+}
+
+func TestSortedStrArray_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name  string
+		Array *garray.SortedStrArray
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": []byte(`["1","3","2"]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name":  "john",
+			"array": g.SliceStr{"1", "3", "2"},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Array.Slice(), g.SliceStr{"1", "2", "3"})
+	})
+}
+
+func TestSortedStrArray_FilterEmpty(t *testing.T) {
+	gtest.Case(t, func() {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"", "1", "2", "0"})
+		gtest.Assert(array.FilterEmpty(), g.SliceStr{"0", "1", "2"})
+	})
+	gtest.Case(t, func() {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2"})
+		gtest.Assert(array.FilterEmpty(), g.SliceStr{"1", "2"})
+	})
+}

container/glist/glist.go

@@ -438,3 +438,22 @@ func (l *List) UnmarshalJSON(b []byte) error {
 	l.PushBacks(array)
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for list.
+func (l *List) UnmarshalValue(value interface{}) (err error) {
+	if l.mu == nil {
+		l.mu = rwmutex.New()
+		l.list = list.New()
+	}
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	var array []interface{}
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &array)
+	default:
+		array = gconv.SliceAny(value)
+	}
+	l.PushBacks(array)
+	return err
+}

container/glist/glist_z_unit_test.go

@@ -632,3 +632,32 @@ func TestList_Json(t *testing.T) {
 		gtest.Assert(l.FrontAll(), a)
 	})
 }
+
+func TestList_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		List *List
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"list": []byte(`[1,2,3]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.List.FrontAll(), []interface{}{1, 2, 3})
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"list": []interface{}{1, 2, 3},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.List.FrontAll(), []interface{}{1, 2, 3})
+	})
+}

container/gmap/gmap_hash_any_any_map.go

@@ -436,3 +436,17 @@ func (m *AnyAnyMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[interface{}]interface{})
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range gconv.Map(value) {
+		m.data[k] = v
+	}
+	return
+}

container/gmap/gmap_hash_int_any_map.go

@@ -432,3 +432,22 @@ func (m *IntAnyMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[int]interface{})
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = v
+		}
+	}
+	return
+}

container/gmap/gmap_hash_int_int_map.go

@@ -409,3 +409,22 @@ func (m *IntIntMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[int]int)
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = gconv.Int(v)
+		}
+	}
+	return
+}

container/gmap/gmap_hash_int_str_map.go

@@ -410,3 +410,22 @@ func (m *IntStrMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[int]string)
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[gconv.Int(k)] = gconv.String(v)
+		}
+	}
+	return
+}

container/gmap/gmap_hash_str_any_map.go

@@ -428,3 +428,15 @@ func (m *StrAnyMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[string]interface{})
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.data = gconv.Map(value)
+	return
+}

container/gmap/gmap_hash_str_int_map.go

@@ -411,3 +411,22 @@ func (m *StrIntMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[string]int)
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	switch value.(type) {
+	case string, []byte:
+		return json.Unmarshal(gconv.Bytes(value), &m.data)
+	default:
+		for k, v := range gconv.Map(value) {
+			m.data[k] = gconv.Int(v)
+		}
+	}
+	return
+}

container/gmap/gmap_hash_str_str_map.go

@@ -9,6 +9,7 @@ package gmap
 
 import (
 	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -412,3 +413,14 @@ func (m *StrStrMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.data = gconv.MapStrStr(value)
+	return
+}

container/gmap/gmap_list_map.go

@@ -491,3 +491,22 @@ func (m *ListMap) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
+	if m.mu == nil {
+		m.mu = rwmutex.New()
+		m.data = make(map[interface{}]*glist.Element)
+		m.list = glist.New()
+	}
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range gconv.Map(value) {
+		if e, ok := m.data[k]; !ok {
+			m.data[k] = m.list.PushBack(&gListMapNode{k, v})
+		} else {
+			e.Value = &gListMapNode{k, v}
+		}
+	}
+	return
+}

container/gmap/gmap_z_unit_any_any_test.go

@@ -275,3 +275,39 @@ func Test_AnyAnyMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestAnyAnyMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.Map
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.Map{
+				"k1": "v1",
+				"k2": "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+}

container/gmap/gmap_z_unit_int_any_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -257,3 +258,39 @@ func Test_IntAnyMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestIntAnyMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.IntAnyMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"1":"v1","2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "v1")
+		gtest.Assert(t.Map.Get(2), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.MapIntAny{
+				1: "v1",
+				2: "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "v1")
+		gtest.Assert(t.Map.Get(2), "v2")
+	})
+}

container/gmap/gmap_z_unit_int_int_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -260,3 +261,39 @@ func Test_IntIntMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestIntIntMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.IntIntMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"1":1,"2":2}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "1")
+		gtest.Assert(t.Map.Get(2), "2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.MapIntAny{
+				1: 1,
+				2: 2,
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "1")
+		gtest.Assert(t.Map.Get(2), "2")
+	})
+}

container/gmap/gmap_z_unit_int_str_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -261,3 +262,39 @@ func Test_IntStrMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestIntStrMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.IntStrMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"1":"v1","2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "v1")
+		gtest.Assert(t.Map.Get(2), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.MapIntAny{
+				1: "v1",
+				2: "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get(1), "v1")
+		gtest.Assert(t.Map.Get(2), "v2")
+	})
+}

container/gmap/gmap_z_unit_list_map_test.go

@@ -231,3 +231,39 @@ func Test_ListMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestListMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.ListMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"1":"v1","2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("1"), "v1")
+		gtest.Assert(t.Map.Get("2"), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.MapIntAny{
+				1: "v1",
+				2: "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("1"), "v1")
+		gtest.Assert(t.Map.Get("2"), "v2")
+	})
+}

container/gmap/gmap_z_unit_str_any_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -269,3 +270,39 @@ func Test_StrAnyMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestStrAnyMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.StrAnyMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.Map{
+				"k1": "v1",
+				"k2": "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+}

container/gmap/gmap_z_unit_str_int_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -272,3 +273,39 @@ func Test_StrIntMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestStrIntMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.StrIntMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"k1":1,"k2":2}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), 1)
+		gtest.Assert(t.Map.Get("k2"), 2)
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.Map{
+				"k1": 1,
+				"k2": 2,
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), 1)
+		gtest.Assert(t.Map.Get("k2"), 2)
+	})
+}

container/gmap/gmap_z_unit_str_str_test.go

@@ -10,6 +10,7 @@ import (
 	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/container/gmap"
@@ -269,3 +270,39 @@ func Test_StrStrMap_Pops(t *testing.T) {
 		gtest.Assert(vArray.Unique().Len(), 3)
 	})
 }
+
+func TestStrStrMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.StrStrMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.Map{
+				"k1": "v1",
+				"k2": "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+}

container/gmap/gmap_z_unit_tree_map_test.go

@@ -148,3 +148,39 @@ func Test_TreeMap_Json(t *testing.T) {
 		gtest.Assert(m.Get("k2"), data["k2"])
 	})
 }
+
+func TestTreeMap_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Map  *gmap.TreeMap
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map":  []byte(`{"k1":"v1","k2":"v2"}`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"map": g.Map{
+				"k1": "v1",
+				"k2": "v2",
+			},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Map.Size(), 2)
+		gtest.Assert(t.Map.Get("k1"), "v1")
+		gtest.Assert(t.Map.Get("k2"), "v2")
+	})
+}

container/gpool/gpool.go

@@ -71,7 +71,7 @@ func (p *Pool) Put(value interface{}) {
 	if p.Expire == 0 {
 		item.expire = 0
 	} else {
-		item.expire = gtime.Millisecond() + p.Expire
+		item.expire = gtime.TimestampMilli() + p.Expire
 	}
 	p.list.PushBack(item)
 }
@@ -86,7 +86,7 @@ func (p *Pool) Get() (interface{}, error) {
 	for !p.closed.Val() {
 		if r := p.list.PopFront(); r != nil {
 			f := r.(*poolItem)
-			if f.expire == 0 || f.expire > gtime.Millisecond() {
+			if f.expire == 0 || f.expire > gtime.TimestampMilli() {
 				return f.value, nil
 			}
 		} else {
@@ -130,7 +130,7 @@ func (p *Pool) checkExpire() {
 		// TODO Do not use Pop and Push mechanism, which is not graceful.
 		if r := p.list.PopFront(); r != nil {
 			item := r.(*poolItem)
-			if item.expire == 0 || item.expire > gtime.Millisecond() {
+			if item.expire == 0 || item.expire > gtime.TimestampMilli() {
 				p.list.PushFront(item)
 				break
 			}

container/gpool/gpool_bench_test.go

@@ -36,7 +36,7 @@ func BenchmarkSyncPoolPut(b *testing.B) {
 	}
 }
 
-func BenchmarkGpoolGet(b *testing.B) {
+func BenchmarkSyncPoolGet(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		syncp.Get()
 	}

container/gset/gset_any_set.go

@@ -430,3 +430,24 @@ func (set *Set) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for set.
+func (set *Set) UnmarshalValue(value interface{}) (err error) {
+	if set.mu == nil {
+		set.mu = rwmutex.New()
+		set.data = make(map[interface{}]struct{})
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	var array []interface{}
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &array)
+	default:
+		array = gconv.SliceAny(value)
+	}
+	for _, v := range array {
+		set.data[v] = struct{}{}
+	}
+	return
+}

container/gset/gset_int_set.go

@@ -401,3 +401,24 @@ func (set *IntSet) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for set.
+func (set *IntSet) UnmarshalValue(value interface{}) (err error) {
+	if set.mu == nil {
+		set.mu = rwmutex.New()
+		set.data = make(map[int]struct{})
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	var array []int
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &array)
+	default:
+		array = gconv.SliceInt(value)
+	}
+	for _, v := range array {
+		set.data[v] = struct{}{}
+	}
+	return
+}

container/gset/gset_str_set.go

@@ -417,3 +417,24 @@ func (set *StrSet) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for set.
+func (set *StrSet) UnmarshalValue(value interface{}) (err error) {
+	if set.mu == nil {
+		set.mu = rwmutex.New()
+		set.data = make(map[string]struct{})
+	}
+	set.mu.Lock()
+	defer set.mu.Unlock()
+	var array []string
+	switch value.(type) {
+	case string, []byte:
+		err = json.Unmarshal(gconv.Bytes(value), &array)
+	default:
+		array = gconv.SliceStr(value)
+	}
+	for _, v := range array {
+		set.data[v] = struct{}{}
+	}
+	return
+}

container/gset/gset_z_unit_any_test.go

@@ -10,6 +10,8 @@ package gset_test
 
 import (
 	"encoding/json"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"strings"
 
 	"github.com/gogf/gf/container/garray"
@@ -361,3 +363,40 @@ func TestSet_AddIfNotExistFunc(t *testing.T) {
 		gtest.Assert(s.Contains(4), false)
 	})
 }
+
+func TestSet_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Set  *gset.Set
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  []byte(`["k1","k2","k3"]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains("k1"), true)
+		gtest.Assert(t.Set.Contains("k2"), true)
+		gtest.Assert(t.Set.Contains("k3"), true)
+		gtest.Assert(t.Set.Contains("k4"), false)
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  g.Slice{"k1", "k2", "k3"},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains("k1"), true)
+		gtest.Assert(t.Set.Contains("k2"), true)
+		gtest.Assert(t.Set.Contains("k3"), true)
+		gtest.Assert(t.Set.Contains("k4"), false)
+	})
+}

container/gset/gset_z_unit_int_test.go

@@ -10,6 +10,8 @@ package gset_test
 
 import (
 	"encoding/json"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"strings"
 	"testing"
 
@@ -324,3 +326,40 @@ func TestIntSet_AddIfNotExistFunc(t *testing.T) {
 		gtest.Assert(s.Contains(4), false)
 	})
 }
+
+func TestIntSet_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Set  *gset.IntSet
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  []byte(`[1,2,3]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains(1), true)
+		gtest.Assert(t.Set.Contains(2), true)
+		gtest.Assert(t.Set.Contains(3), true)
+		gtest.Assert(t.Set.Contains(4), false)
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  g.Slice{1, 2, 3},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains(1), true)
+		gtest.Assert(t.Set.Contains(2), true)
+		gtest.Assert(t.Set.Contains(3), true)
+		gtest.Assert(t.Set.Contains(4), false)
+	})
+}

container/gset/gset_z_unit_str_test.go

@@ -10,6 +10,8 @@ package gset_test
 
 import (
 	"encoding/json"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gconv"
 	"strings"
 	"testing"
 
@@ -360,3 +362,40 @@ func TestStrSet_AddIfNotExistFunc(t *testing.T) {
 		gtest.Assert(s.Contains("4"), false)
 	})
 }
+
+func TestStrSet_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Set  *gset.StrSet
+	}
+	// JSON
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  []byte(`["1","2","3"]`),
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains("1"), true)
+		gtest.Assert(t.Set.Contains("2"), true)
+		gtest.Assert(t.Set.Contains("3"), true)
+		gtest.Assert(t.Set.Contains("4"), false)
+	})
+	// Map
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(g.Map{
+			"name": "john",
+			"set":  g.SliceStr{"1", "2", "3"},
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Set.Size(), 3)
+		gtest.Assert(t.Set.Contains("1"), true)
+		gtest.Assert(t.Set.Contains("2"), true)
+		gtest.Assert(t.Set.Contains("3"), true)
+		gtest.Assert(t.Set.Contains("4"), false)
+	})
+}

container/gtree/gtree_redblacktree.go

@@ -942,3 +942,17 @@ func (tree *RedBlackTree) UnmarshalJSON(b []byte) error {
 	}
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for map.
+func (tree *RedBlackTree) UnmarshalValue(value interface{}) (err error) {
+	if tree.mu == nil {
+		tree.mu = rwmutex.New()
+		tree.comparator = gutil.ComparatorString
+	}
+	tree.mu.Lock()
+	defer tree.mu.Unlock()
+	for k, v := range gconv.Map(value) {
+		tree.doSet(k, v)
+	}
+	return
+}

container/gtype/bool.go

@@ -57,7 +57,7 @@ func (v *Bool) Val() bool {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Bool) Cas(old, new bool) bool {
+func (v *Bool) Cas(old, new bool) (swapped bool) {
 	var oldInt32, newInt32 int32
 	if old {
 		oldInt32 = 1
@@ -90,3 +90,9 @@ func (v *Bool) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Bool(bytes.Trim(b, `"`)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Bool) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Bool(value))
+	return nil
+}

container/gtype/byte.go

@@ -49,7 +49,7 @@ func (v *Byte) Add(delta byte) (new byte) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Byte) Cas(old, new byte) bool {
+func (v *Byte) Cas(old, new byte) (swapped bool) {
 	return atomic.CompareAndSwapInt32(&v.value, int32(old), int32(new))
 }
 
@@ -68,3 +68,9 @@ func (v *Byte) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Uint8(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Byte) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Byte(value))
+	return nil
+}

container/gtype/bytes.go

@@ -72,3 +72,9 @@ func (v *Bytes) UnmarshalJSON(b []byte) error {
 	v.Set(src[:n])
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Bytes) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Bytes(value))
+	return nil
+}

container/gtype/float32.go

@@ -62,7 +62,7 @@ func (v *Float32) Add(delta float32) (new float32) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Float32) Cas(old, new float32) bool {
+func (v *Float32) Cas(old, new float32) (swapped bool) {
 	return atomic.CompareAndSwapUint32(&v.value, math.Float32bits(old), math.Float32bits(new))
 }
 
@@ -81,3 +81,9 @@ func (v *Float32) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Float32(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Float32) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Float32(value))
+	return nil
+}

container/gtype/float64.go

@@ -62,7 +62,7 @@ func (v *Float64) Add(delta float64) (new float64) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Float64) Cas(old, new float64) bool {
+func (v *Float64) Cas(old, new float64) (swapped bool) {
 	return atomic.CompareAndSwapUint64(&v.value, math.Float64bits(old), math.Float64bits(new))
 }
 
@@ -81,3 +81,9 @@ func (v *Float64) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Float64(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Float64) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Float64(value))
+	return nil
+}

container/gtype/int.go

@@ -49,7 +49,7 @@ func (v *Int) Add(delta int) (new int) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Int) Cas(old, new int) bool {
+func (v *Int) Cas(old, new int) (swapped bool) {
 	return atomic.CompareAndSwapInt64(&v.value, int64(old), int64(new))
 }
 
@@ -68,3 +68,9 @@ func (v *Int) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Int(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Int) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Int(value))
+	return nil
+}

container/gtype/int32.go

@@ -49,7 +49,7 @@ func (v *Int32) Add(delta int32) (new int32) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Int32) Cas(old, new int32) bool {
+func (v *Int32) Cas(old, new int32) (swapped bool) {
 	return atomic.CompareAndSwapInt32(&v.value, old, new)
 }
 
@@ -68,3 +68,9 @@ func (v *Int32) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Int32(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Int32) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Int32(value))
+	return nil
+}

container/gtype/int64.go

@@ -49,7 +49,7 @@ func (v *Int64) Add(delta int64) (new int64) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Int64) Cas(old, new int64) bool {
+func (v *Int64) Cas(old, new int64) (swapped bool) {
 	return atomic.CompareAndSwapInt64(&v.value, old, new)
 }
 
@@ -68,3 +68,9 @@ func (v *Int64) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Int64(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Int64) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Int64(value))
+	return nil
+}

container/gtype/interface.go

@@ -65,3 +65,9 @@ func (v *Interface) UnmarshalJSON(b []byte) error {
 	v.Set(i)
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Interface) UnmarshalValue(value interface{}) error {
+	v.Set(value)
+	return nil
+}

container/gtype/string.go

@@ -63,3 +63,9 @@ func (v *String) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.UnsafeBytesToStr(bytes.Trim(b, `"`)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *String) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.String(value))
+	return nil
+}

container/gtype/uint.go

@@ -49,7 +49,7 @@ func (v *Uint) Add(delta uint) (new uint) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Uint) Cas(old, new uint) bool {
+func (v *Uint) Cas(old, new uint) (swapped bool) {
 	return atomic.CompareAndSwapUint64(&v.value, uint64(old), uint64(new))
 }
 
@@ -68,3 +68,9 @@ func (v *Uint) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Uint(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Uint) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Uint(value))
+	return nil
+}

container/gtype/uint32.go

@@ -49,7 +49,7 @@ func (v *Uint32) Add(delta uint32) (new uint32) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Uint32) Cas(old, new uint32) bool {
+func (v *Uint32) Cas(old, new uint32) (swapped bool) {
 	return atomic.CompareAndSwapUint32(&v.value, old, new)
 }
 
@@ -68,3 +68,9 @@ func (v *Uint32) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Uint32(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Uint32) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Uint32(value))
+	return nil
+}

container/gtype/uint64.go

@@ -49,7 +49,7 @@ func (v *Uint64) Add(delta uint64) (new uint64) {
 }
 
 // Cas executes the compare-and-swap operation for value.
-func (v *Uint64) Cas(old, new uint64) bool {
+func (v *Uint64) Cas(old, new uint64) (swapped bool) {
 	return atomic.CompareAndSwapUint64(&v.value, old, new)
 }
 
@@ -68,3 +68,9 @@ func (v *Uint64) UnmarshalJSON(b []byte) error {
 	v.Set(gconv.Uint64(gconv.UnsafeBytesToStr(b)))
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for <v>.
+func (v *Uint64) UnmarshalValue(value interface{}) error {
+	v.Set(gconv.Uint64(value))
+	return nil
+}

container/gtype/z_bench_basic_test.go

@@ -49,6 +49,12 @@ func BenchmarkInt_Add(b *testing.B) {
 	}
 }
 
+func BenchmarkInt_Cas(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		it.Cas(i, i)
+	}
+}
+
 func BenchmarkInt32_Set(b *testing.B) {
 	for i := int32(0); i < int32(b.N); i++ {
 		it32.Set(i)

container/gtype/z_unit_bool_test.go

@@ -0,0 +1,125 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
+	"testing"
+
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+)
+
+func Test_Bool(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBool(true)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(false), true)
+		gtest.AssertEQ(iClone.Val(), false)
+
+		i1 := gtype.NewBool(false)
+		iClone1 := i1.Clone()
+		gtest.AssertEQ(iClone1.Set(true), false)
+		gtest.AssertEQ(iClone1.Val(), true)
+
+		//空参测试
+		i2 := gtype.NewBool()
+		gtest.AssertEQ(i2.Val(), false)
+	})
+}
+
+func Test_Bool_JSON(t *testing.T) {
+	// Marshal
+	gtest.Case(t, func() {
+		i := gtype.NewBool(true)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+	})
+	gtest.Case(t, func() {
+		i := gtype.NewBool(false)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+	})
+	// Unmarshal
+	gtest.Case(t, func() {
+		var err error
+		i := gtype.NewBool()
+		err = json.Unmarshal([]byte("true"), &i)
+		gtest.Assert(err, nil)
+		gtest.Assert(i.Val(), true)
+		err = json.Unmarshal([]byte("false"), &i)
+		gtest.Assert(err, nil)
+		gtest.Assert(i.Val(), false)
+		err = json.Unmarshal([]byte("1"), &i)
+		gtest.Assert(err, nil)
+		gtest.Assert(i.Val(), true)
+		err = json.Unmarshal([]byte("0"), &i)
+		gtest.Assert(err, nil)
+		gtest.Assert(i.Val(), false)
+	})
+
+	gtest.Case(t, func() {
+		i := gtype.NewBool(true)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewBool()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i.Val())
+	})
+	gtest.Case(t, func() {
+		i := gtype.NewBool(false)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewBool()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i.Val())
+	})
+}
+
+func Test_Bool_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Bool
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "true",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), true)
+	})
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "false",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), false)
+	})
+}

container/gtype/z_unit_byte_test.go

@@ -0,0 +1,77 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+)
+
+func Test_Byte(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 127
+		i := gtype.NewByte(byte(0))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(byte(1)), byte(0))
+		gtest.AssertEQ(iClone.Val(), byte(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(byte(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewByte()
+		gtest.AssertEQ(i1.Val(), byte(0))
+	})
+}
+
+func Test_Byte_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewByte(49)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+	})
+	// Unmarshal
+	gtest.Case(t, func() {
+		var err error
+		i := gtype.NewByte()
+		err = json.Unmarshal([]byte("49"), &i)
+		gtest.Assert(err, nil)
+		gtest.Assert(i.Val(), "49")
+	})
+}
+
+func Test_Byte_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Byte
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "2",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "2")
+	})
+}

container/gtype/z_unit_bytes_test.go

@@ -0,0 +1,63 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
+	"testing"
+
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+)
+
+func Test_Bytes(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewBytes([]byte("abc"))
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set([]byte("123")), []byte("abc"))
+		gtest.AssertEQ(iClone.Val(), []byte("123"))
+
+		//空参测试
+		i1 := gtype.NewBytes()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_Bytes_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		b := []byte("i love gf")
+		i := gtype.NewBytes(b)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewBytes()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), b)
+	})
+}
+
+func Test_Bytes_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Bytes
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_float32_test.go

@@ -0,0 +1,64 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"testing"
+)
+
+func Test_Float32(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewFloat32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float32(0))
+		gtest.AssertEQ(iClone.Val(), float32(0.1))
+
+		//空参测试
+		i1 := gtype.NewFloat32()
+		gtest.AssertEQ(i1.Val(), float32(0))
+	})
+}
+
+func Test_Float32_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		v := float32(math.MaxFloat32)
+		i := gtype.NewFloat32(v)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewFloat32()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), v)
+	})
+}
+
+func Test_Float32_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Float32
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123.456",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123.456")
+	})
+}

container/gtype/z_unit_float64_test.go

@@ -0,0 +1,62 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"testing"
+)
+
+func Test_Float64(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewFloat64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(0.1), float64(0))
+		gtest.AssertEQ(iClone.Val(), float64(0.1))
+		//空参测试
+		i1 := gtype.NewFloat64()
+		gtest.AssertEQ(i1.Val(), float64(0))
+	})
+}
+
+func Test_Float64_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		v := math.MaxFloat64
+		i := gtype.NewFloat64(v)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewFloat64()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), v)
+	})
+}
+
+func Test_Float64_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Float64
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123.456",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123.456")
+	})
+}

container/gtype/z_unit_int32_test.go

@@ -0,0 +1,75 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"sync"
+	"testing"
+)
+
+func Test_Int32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int32(0))
+		gtest.AssertEQ(iClone.Val(), int32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt32()
+		gtest.AssertEQ(i1.Val(), int32(0))
+	})
+}
+
+func Test_Int32_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		v := int32(math.MaxInt32)
+		i := gtype.NewInt32(v)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewInt32()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), v)
+	})
+}
+
+func Test_Int32_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Int32
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_int64_test.go

@@ -0,0 +1,74 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"sync"
+	"testing"
+)
+
+func Test_Int64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), int64(0))
+		gtest.AssertEQ(iClone.Val(), int64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(int64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt64()
+		gtest.AssertEQ(i1.Val(), int64(0))
+	})
+}
+
+func Test_Int64_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewInt64(math.MaxInt64)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewInt64()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i)
+	})
+}
+
+func Test_Int64_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Int64
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_int_test.go

@@ -0,0 +1,74 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"sync"
+	"testing"
+)
+
+func Test_Int(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewInt(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), 0)
+		gtest.AssertEQ(iClone.Val(), 1)
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(addTimes, i.Val())
+
+		//空参测试
+		i1 := gtype.NewInt()
+		gtest.AssertEQ(i1.Val(), 0)
+	})
+}
+
+func Test_Int_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		v := 666
+		i := gtype.NewInt(v)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewInt()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), v)
+	})
+}
+
+func Test_Int_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Int
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_interface_test.go

@@ -0,0 +1,64 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"testing"
+)
+
+func Test_Interface(t *testing.T) {
+	gtest.Case(t, func() {
+		t := Temp{Name: "gf", Age: 18}
+		t1 := Temp{Name: "gf", Age: 19}
+		i := gtype.New(t)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(t1), t)
+		gtest.AssertEQ(iClone.Val().(Temp), t1)
+
+		//空参测试
+		i1 := gtype.New()
+		gtest.AssertEQ(i1.Val(), nil)
+	})
+}
+
+func Test_Interface_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		s := "i love gf"
+		i := gtype.New(s)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.New()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), s)
+	})
+}
+
+func Test_Interface_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Interface
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_string_test.go

@@ -0,0 +1,62 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"testing"
+)
+
+func Test_String(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewString("abc")
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set("123"), "abc")
+		gtest.AssertEQ(iClone.Val(), "123")
+
+		//空参测试
+		i1 := gtype.NewString()
+		gtest.AssertEQ(i1.Val(), "")
+	})
+}
+
+func Test_String_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		s := "i love gf"
+		i1 := gtype.NewString(s)
+		b1, err1 := json.Marshal(i1)
+		b2, err2 := json.Marshal(i1.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewString()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), s)
+	})
+}
+
+func Test_String_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.String
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_test.go

@@ -1,528 +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.
-
-package gtype_test
-
-import (
-	"encoding/json"
-	"math"
-	"sync"
-	"testing"
-
-	"github.com/gogf/gf/container/gtype"
-	"github.com/gogf/gf/test/gtest"
-)
-
-type Temp struct {
-	Name string
-	Age  int
-}
-
-func Test_Bool(t *testing.T) {
-	gtest.Case(t, func() {
-		i := gtype.NewBool(true)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(false), true)
-		gtest.AssertEQ(iClone.Val(), false)
-
-		i1 := gtype.NewBool(false)
-		iClone1 := i1.Clone()
-		gtest.AssertEQ(iClone1.Set(true), false)
-		gtest.AssertEQ(iClone1.Val(), true)
-
-		//空参测试
-		i2 := gtype.NewBool()
-		gtest.AssertEQ(i2.Val(), false)
-	})
-
-	// Marshal
-	gtest.Case(t, func() {
-		i := gtype.NewBool(true)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewBool(false)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-	})
-	// Unmarshal
-	gtest.Case(t, func() {
-		var err error
-		i := gtype.NewBool()
-		err = json.Unmarshal([]byte("true"), &i)
-		gtest.Assert(err, nil)
-		gtest.Assert(i.Val(), true)
-		err = json.Unmarshal([]byte("false"), &i)
-		gtest.Assert(err, nil)
-		gtest.Assert(i.Val(), false)
-		err = json.Unmarshal([]byte("1"), &i)
-		gtest.Assert(err, nil)
-		gtest.Assert(i.Val(), true)
-		err = json.Unmarshal([]byte("0"), &i)
-		gtest.Assert(err, nil)
-		gtest.Assert(i.Val(), false)
-	})
-
-	gtest.Case(t, func() {
-		i := gtype.NewBool(true)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewBool()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i.Val())
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewBool(false)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewBool()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i.Val())
-	})
-}
-
-func Test_Byte(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 127
-		i := gtype.NewByte(byte(0))
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(byte(1)), byte(0))
-		gtest.AssertEQ(iClone.Val(), byte(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(byte(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewByte()
-		gtest.AssertEQ(i1.Val(), byte(0))
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewByte(49)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-	})
-	// Unmarshal
-	gtest.Case(t, func() {
-		var err error
-		i := gtype.NewByte()
-		err = json.Unmarshal([]byte("49"), &i)
-		gtest.Assert(err, nil)
-		gtest.Assert(i.Val(), "49")
-	})
-}
-
-func Test_Bytes(t *testing.T) {
-	gtest.Case(t, func() {
-		i := gtype.NewBytes([]byte("abc"))
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set([]byte("123")), []byte("abc"))
-		gtest.AssertEQ(iClone.Val(), []byte("123"))
-
-		//空参测试
-		i1 := gtype.NewBytes()
-		gtest.AssertEQ(i1.Val(), nil)
-	})
-	gtest.Case(t, func() {
-		b := []byte("i love gf")
-		i := gtype.NewBytes(b)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewBytes()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), b)
-	})
-}
-
-func Test_String(t *testing.T) {
-	gtest.Case(t, func() {
-		i := gtype.NewString("abc")
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set("123"), "abc")
-		gtest.AssertEQ(iClone.Val(), "123")
-
-		//空参测试
-		i1 := gtype.NewString()
-		gtest.AssertEQ(i1.Val(), "")
-	})
-	gtest.Case(t, func() {
-		s := "i love gf"
-		i1 := gtype.NewString(s)
-		b1, err1 := json.Marshal(i1)
-		b2, err2 := json.Marshal(i1.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewString()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), s)
-	})
-}
-
-func Test_Interface(t *testing.T) {
-	gtest.Case(t, func() {
-		t := Temp{Name: "gf", Age: 18}
-		t1 := Temp{Name: "gf", Age: 19}
-		i := gtype.New(t)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(t1), t)
-		gtest.AssertEQ(iClone.Val().(Temp), t1)
-
-		//空参测试
-		i1 := gtype.New()
-		gtest.AssertEQ(i1.Val(), nil)
-	})
-	gtest.Case(t, func() {
-		s := "i love gf"
-		i := gtype.New(s)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.New()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), s)
-	})
-}
-
-func Test_Float32(t *testing.T) {
-	gtest.Case(t, func() {
-		//var wg sync.WaitGroup
-		//addTimes := 100
-		i := gtype.NewFloat32(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(0.1), float32(0))
-		gtest.AssertEQ(iClone.Val(), float32(0.1))
-		// for index := 0; index < addTimes; index++ {
-		// 	wg.Add(1)
-		// 	go func() {
-		// 	defer wg.Done()
-		// 	i.Add(0.2)
-		// 	fmt.Println(i.Val())
-		// 	}()
-		// }
-		// wg.Wait()
-		// gtest.AssertEQ(100.0, i.Val())
-
-		//空参测试
-		i1 := gtype.NewFloat32()
-		gtest.AssertEQ(i1.Val(), float32(0))
-	})
-	gtest.Case(t, func() {
-		v := float32(math.MaxFloat32)
-		i := gtype.NewFloat32(v)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewFloat32()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), v)
-	})
-}
-
-func Test_Float64(t *testing.T) {
-	gtest.Case(t, func() {
-		//var wg sync.WaitGroup
-		//addTimes := 100
-		i := gtype.NewFloat64(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(0.1), float64(0))
-		gtest.AssertEQ(iClone.Val(), float64(0.1))
-		// for index := 0; index < addTimes; index++ {
-		// 	wg.Add(1)
-		// 	go func() {
-		// 	defer wg.Done()
-		// 	i.Add(0.1)
-		// 	fmt.Println(i.Val())
-		// 	}()
-		// }
-		// wg.Wait()
-		// gtest.AssertEQ(100.0, i.Val())
-
-		//空参测试
-		i1 := gtype.NewFloat64()
-		gtest.AssertEQ(i1.Val(), float64(0))
-	})
-	gtest.Case(t, func() {
-		v := math.MaxFloat64
-		i := gtype.NewFloat64(v)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewFloat64()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), v)
-	})
-}
-
-func Test_Int(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewInt(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), 0)
-		gtest.AssertEQ(iClone.Val(), 1)
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(addTimes, i.Val())
-
-		//空参测试
-		i1 := gtype.NewInt()
-		gtest.AssertEQ(i1.Val(), 0)
-	})
-	gtest.Case(t, func() {
-		v := 666
-		i := gtype.NewInt(v)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewInt()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), v)
-	})
-}
-
-func Test_Int32(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewInt32(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), int32(0))
-		gtest.AssertEQ(iClone.Val(), int32(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(int32(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewInt32()
-		gtest.AssertEQ(i1.Val(), int32(0))
-	})
-	gtest.Case(t, func() {
-		v := int32(math.MaxInt32)
-		i := gtype.NewInt32(v)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewInt32()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), v)
-	})
-}
-
-func Test_Int64(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewInt64(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), int64(0))
-		gtest.AssertEQ(iClone.Val(), int64(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(int64(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewInt64()
-		gtest.AssertEQ(i1.Val(), int64(0))
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewInt64(math.MaxInt64)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewInt64()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i)
-	})
-}
-
-func Test_Uint(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewUint(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), uint(0))
-		gtest.AssertEQ(iClone.Val(), uint(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(uint(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewUint()
-		gtest.AssertEQ(i1.Val(), uint(0))
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewUint(666)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewUint()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i)
-	})
-}
-
-func Test_Uint32(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewUint32(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), uint32(0))
-		gtest.AssertEQ(iClone.Val(), uint32(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(uint32(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewUint32()
-		gtest.AssertEQ(i1.Val(), uint32(0))
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewUint32(math.MaxUint32)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewUint32()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i)
-	})
-}
-
-func Test_Uint64(t *testing.T) {
-	gtest.Case(t, func() {
-		var wg sync.WaitGroup
-		addTimes := 1000
-		i := gtype.NewUint64(0)
-		iClone := i.Clone()
-		gtest.AssertEQ(iClone.Set(1), uint64(0))
-		gtest.AssertEQ(iClone.Val(), uint64(1))
-		for index := 0; index < addTimes; index++ {
-			wg.Add(1)
-			go func() {
-				defer wg.Done()
-				i.Add(1)
-			}()
-		}
-		wg.Wait()
-		gtest.AssertEQ(uint64(addTimes), i.Val())
-
-		//空参测试
-		i1 := gtype.NewUint64()
-		gtest.AssertEQ(i1.Val(), uint64(0))
-	})
-	gtest.Case(t, func() {
-		i := gtype.NewUint64(math.MaxUint64)
-		b1, err1 := json.Marshal(i)
-		b2, err2 := json.Marshal(i.Val())
-		gtest.Assert(err1, nil)
-		gtest.Assert(err2, nil)
-		gtest.Assert(b1, b2)
-
-		i2 := gtype.NewUint64()
-		err := json.Unmarshal(b2, &i2)
-		gtest.Assert(err, nil)
-		gtest.Assert(i2.Val(), i)
-	})
-}

container/gtype/z_unit_uint32_test.go

@@ -0,0 +1,74 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"sync"
+	"testing"
+)
+
+func Test_Uint32(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint32(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint32(0))
+		gtest.AssertEQ(iClone.Val(), uint32(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint32(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint32()
+		gtest.AssertEQ(i1.Val(), uint32(0))
+	})
+}
+
+func Test_Uint32_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewUint32(math.MaxUint32)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewUint32()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i)
+	})
+}
+
+func Test_Uint32_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Uint32
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_uint64_test.go

@@ -0,0 +1,79 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
+	"math"
+	"sync"
+	"testing"
+
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+)
+
+type Temp struct {
+	Name string
+	Age  int
+}
+
+func Test_Uint64(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint64(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint64(0))
+		gtest.AssertEQ(iClone.Val(), uint64(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint64(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint64()
+		gtest.AssertEQ(i1.Val(), uint64(0))
+	})
+}
+func Test_Uint64_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewUint64(math.MaxUint64)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewUint64()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i)
+	})
+}
+
+func Test_Uint64_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Uint64
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gtype/z_unit_uint_test.go

@@ -0,0 +1,73 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gtype_test
+
+import (
+	"encoding/json"
+	"github.com/gogf/gf/container/gtype"
+	"github.com/gogf/gf/test/gtest"
+	"github.com/gogf/gf/util/gconv"
+	"sync"
+	"testing"
+)
+
+func Test_Uint(t *testing.T) {
+	gtest.Case(t, func() {
+		var wg sync.WaitGroup
+		addTimes := 1000
+		i := gtype.NewUint(0)
+		iClone := i.Clone()
+		gtest.AssertEQ(iClone.Set(1), uint(0))
+		gtest.AssertEQ(iClone.Val(), uint(1))
+		for index := 0; index < addTimes; index++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				i.Add(1)
+			}()
+		}
+		wg.Wait()
+		gtest.AssertEQ(uint(addTimes), i.Val())
+
+		//空参测试
+		i1 := gtype.NewUint()
+		gtest.AssertEQ(i1.Val(), uint(0))
+	})
+}
+
+func Test_Uint_JSON(t *testing.T) {
+	gtest.Case(t, func() {
+		i := gtype.NewUint(666)
+		b1, err1 := json.Marshal(i)
+		b2, err2 := json.Marshal(i.Val())
+		gtest.Assert(err1, nil)
+		gtest.Assert(err2, nil)
+		gtest.Assert(b1, b2)
+
+		i2 := gtype.NewUint()
+		err := json.Unmarshal(b2, &i2)
+		gtest.Assert(err, nil)
+		gtest.Assert(i2.Val(), i)
+	})
+}
+
+func Test_Uint_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gtype.Uint
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "123",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.Val(), "123")
+	})
+}

container/gvar/gvar.go

@@ -335,3 +335,9 @@ func (v *Var) UnmarshalJSON(b []byte) error {
 	v.Set(i)
 	return nil
 }
+
+// UnmarshalValue is an interface implement which sets any type of value for Var.
+func (v *Var) UnmarshalValue(value interface{}) error {
+	v.Set(value)
+	return nil
+}

container/gvar/gvar_z_unit_test.go

@@ -10,6 +10,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"encoding/json"
+	"github.com/gogf/gf/util/gconv"
 	"math"
 	"testing"
 	"time"
@@ -378,3 +379,20 @@ func Test_Json(t *testing.T) {
 		gtest.Assert(v.String(), s)
 	})
 }
+
+func Test_UnmarshalValue(t *testing.T) {
+	type T struct {
+		Name string
+		Var  *gvar.Var
+	}
+	gtest.Case(t, func() {
+		var t *T
+		err := gconv.Struct(map[string]interface{}{
+			"name": "john",
+			"var":  "v",
+		}, &t)
+		gtest.Assert(err, nil)
+		gtest.Assert(t.Name, "john")
+		gtest.Assert(t.Var.String(), "v")
+	})
+}

database/gdb/gdb.go

@@ -64,6 +64,7 @@ type DB interface {
 	Begin() (*TX, error)
 
 	Insert(table string, data interface{}, batch ...int) (sql.Result, error)
+	InsertIgnore(table string, data interface{}, batch ...int) (sql.Result, error)
 	Replace(table string, data interface{}, batch ...int) (sql.Result, error)
 	Save(table string, data interface{}, batch ...int) (sql.Result, error)
 
@@ -137,31 +138,32 @@ type Sql struct {
 	End    int64         // End execution timestamp in milliseconds.
 }
 
-// 表字段结构信息
+// TableField is the struct for table field.
 type TableField struct {
-	Index   int         // 用于字段排序(因为map类型是无序的)
-	Name    string      // 字段名称
-	Type    string      // 字段类型
-	Null    bool        // 是否可为null
-	Key     string      // 索引信息
-	Default interface{} // 默认值
-	Extra   string      // 其他信息
-	Comment string      // 字段描述
+	Index   int         // For ordering purpose as map is unordered.
+	Name    string      // Field name.
+	Type    string      // Field type.
+	Null    bool        // Field can be null or not.
+	Key     string      // The index information(empty if it's not a index).
+	Default interface{} // Default value for the field.
+	Extra   string      // Extra information.
+	Comment string      // Comment.
 }
 
-// 返回数据表记录值
+// Value is the field value type.
 type Value = *gvar.Var
 
-// 返回数据表记录Map
+// Record is the row record of the table.
 type Record map[string]Value
 
-// 返回数据表记录List
+// Result is the row record array.
 type Result []Record
 
-// 关联数组，绑定一条数据表记录(使用别名)
+// Map is alias of map[string]interface{},
+// which is the most common usage map type.
 type Map = map[string]interface{}
 
-// 关联数组列表(索引从0开始的数组)，绑定多条记录(使用别名)
+// List is type of map array.
 type List = []Map
 
 const (
@@ -170,7 +172,7 @@ const (
 	gINSERT_OPTION_SAVE         = 2
 	gINSERT_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.
+	gDEFAULT_CONN_MAX_LIFE_TIME = 30 // Max life time for per connection in pool in seconds.
 )
 
 var (
@@ -182,7 +184,7 @@ var (
 // The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
 func New(name ...string) (db DB, err error) {
-	group := configs.defaultGroup
+	group := configs.group
 	if len(name) > 0 && name[0] != "" {
 		group = name[0]
 	}
@@ -195,12 +197,13 @@ func New(name ...string) (db DB, err error) {
 	if _, ok := configs.config[group]; ok {
 		if node, err := getConfigNodeByGroup(group, true); err == nil {
 			base := &dbBase{
-				group:           group,
-				debug:           gtype.NewBool(),
-				cache:           gcache.New(),
-				schema:          gtype.NewString(),
-				logger:          glog.New(),
-				prefix:          node.Prefix,
+				group:  group,
+				debug:  gtype.NewBool(),
+				cache:  gcache.New(),
+				schema: gtype.NewString(),
+				logger: glog.New(),
+				prefix: node.Prefix,
+				// Default max connection life time if user does not configure.
 				maxConnLifetime: gDEFAULT_CONN_MAX_LIFE_TIME,
 			}
 			switch node.Type {
@@ -230,7 +233,7 @@ func New(name ...string) (db DB, err error) {
 // The parameter <name> specifies the configuration group name,
 // which is DEFAULT_GROUP_NAME in default.
 func Instance(name ...string) (db DB, err error) {
-	group := configs.defaultGroup
+	group := configs.group
 	if len(name) > 0 && name[0] != "" {
 		group = name[0]
 	}
@@ -244,10 +247,14 @@ func Instance(name ...string) (db DB, err error) {
 	return
 }
 
-// 获取指定数据库角色的一个配置项，内部根据权重计算负载均衡
+// getConfigNodeByGroup calculates and returns a configuration node of given group. It
+// calculates the value internally using weight algorithm for load balance.
+//
+// The parameter <master> specifies whether retrieving a master node, or else a slave node
+// if master-slave configured.
 func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
 	if list, ok := configs.config[group]; ok {
-		// 将master, slave集群列表拆分出来
+		// Separates master and slave configuration nodes array.
 		masterList := make(ConfigGroup, 0)
 		slaveList := make(ConfigGroup, 0)
 		for i := 0; i < len(list); i++ {
@@ -273,12 +280,12 @@ func getConfigNodeByGroup(group string, master bool) (*ConfigNode, error) {
 	}
 }
 
-// 按照负载均衡算法(优先级配置)从数据库集群中选择一个配置节点出来使用
-// 算法说明举例，
-// 1、假如2个节点的priority都是1，那么随机大小范围为[0, 199]；
-// 2、那么节点1的权重范围为[0, 99]，节点2的权重范围为[100, 199]，比例为1:1；
-// 3、假如计算出的随机数为99;
-// 4、那么选择的配置为节点1;
+// getConfigNodeByWeight calculates the configuration weights and randomly returns a node.
+//
+// Calculation algorithm brief:
+// 1. If we have 2 nodes, and their weights are both 1, then the weight range is [0, 199];
+// 2. Node1 weight range is [0, 99], and node2 weight range is [100, 199], ratio is 1:1;
+// 3. If the random number is 99, it then chooses and returns node1;
 func getConfigNodeByWeight(cg ConfigGroup) *ConfigNode {
 	if len(cg) < 2 {
 		return &cg[0]
@@ -287,18 +294,16 @@ func getConfigNodeByWeight(cg ConfigGroup) *ConfigNode {
 	for i := 0; i < len(cg); i++ {
 		total += cg[i].Weight * 100
 	}
-	// 如果total为0表示所有连接都没有配置priority属性，那么默认都是1
+	// If total is 0 means all of the nodes have no weight attribute configured.
+	// It then defaults each node's weight attribute to 1.
 	if total == 0 {
 		for i := 0; i < len(cg); i++ {
 			cg[i].Weight = 1
 			total += cg[i].Weight * 100
 		}
 	}
-	// 不能取到末尾的边界点
-	r := grand.N(0, total)
-	if r > 0 {
-		r -= 1
-	}
+	// Exclude the right border value.
+	r := grand.N(0, total-1)
 	min := 0
 	max := 0
 	for i := 0; i < len(cg); i++ {

database/gdb/gdb_base.go

@@ -27,11 +27,13 @@ const (
 )
 
 var (
-	// lastOperatorReg is the regular expression object for a string which has operator at its tail.
+	// lastOperatorReg is the regular expression object for a string
+	// which has operator at its tail.
 	lastOperatorReg = regexp.MustCompile(`[<>=]+\s*$`)
 )
 
-// 数据库sql查询操作，主要执行查询
+// Query commits one query SQL to underlying driver and returns the execution result.
+// It is most commonly used for data querying.
 func (bs *dbBase) Query(query string, args ...interface{}) (rows *sql.Rows, err error) {
 	link, err := bs.db.Slave()
 	if err != nil {
@@ -40,7 +42,8 @@ func (bs *dbBase) Query(query string, args ...interface{}) (rows *sql.Rows, err
 	return bs.db.doQuery(link, query, args...)
 }
 
-// 数据库sql查询操作，主要执行查询
+// doQuery commits the query string and its arguments to underlying driver
+// through given link object and returns the execution result.
 func (bs *dbBase) doQuery(link dbLink, query string, args ...interface{}) (rows *sql.Rows, err error) {
 	query, args = formatQuery(query, args)
 	query = bs.db.handleSqlBeforeExec(query)
@@ -68,7 +71,8 @@ func (bs *dbBase) doQuery(link dbLink, query string, args ...interface{}) (rows
 	return nil, err
 }
 
-// 执行一条sql，并返回执行情况，主要用于非查询操作
+// Exec commits one query SQL to underlying driver and returns the execution result.
+// It is most commonly used for data inserting and updating.
 func (bs *dbBase) Exec(query string, args ...interface{}) (result sql.Result, err error) {
 	link, err := bs.db.Master()
 	if err != nil {
@@ -77,7 +81,8 @@ func (bs *dbBase) Exec(query string, args ...interface{}) (result sql.Result, er
 	return bs.db.doExec(link, query, args...)
 }
 
-// 执行一条sql，并返回执行情况，主要用于非查询操作
+// doExec commits the query string and its arguments to underlying driver
+// through given link object and returns the execution result.
 func (bs *dbBase) doExec(link dbLink, query string, args ...interface{}) (result sql.Result, err error) {
 	query, args = formatQuery(query, args)
 	query = bs.db.handleSqlBeforeExec(query)
@@ -100,7 +105,14 @@ func (bs *dbBase) doExec(link dbLink, query string, args ...interface{}) (result
 	return result, formatError(err, query, args...)
 }
 
-// SQL预处理，执行完成后调用返回值sql.Stmt.Exec完成sql操作; 默认执行在Slave上, 通过第二个参数指定执行在Master上
+// Prepare creates a prepared statement for later queries or executions.
+// Multiple queries or executions may be run concurrently from the
+// returned statement.
+// The caller must call the statement's Close method
+// when the statement is no longer needed.
+//
+// The parameter <execOnMaster> specifies whether executing the sql on master node,
+// or else it executes the sql on slave node if master-slave configured.
 func (bs *dbBase) Prepare(query string, execOnMaster ...bool) (*sql.Stmt, error) {
 	err := (error)(nil)
 	link := (dbLink)(nil)
@@ -116,17 +128,17 @@ func (bs *dbBase) Prepare(query string, execOnMaster ...bool) (*sql.Stmt, error)
 	return bs.db.doPrepare(link, query)
 }
 
-// SQL预处理，执行完成后调用返回值sql.Stmt.Exec完成sql操作
+// doPrepare calls prepare function on given link object and returns the statement object.
 func (bs *dbBase) doPrepare(link dbLink, query string) (*sql.Stmt, error) {
 	return link.Prepare(query)
 }
 
-// 数据库查询，获取查询结果集，以列表结构返回
+// GetAll queries and returns data records from database.
 func (bs *dbBase) GetAll(query string, args ...interface{}) (Result, error) {
 	return bs.db.doGetAll(nil, query, args...)
 }
 
-// 数据库查询，获取查询结果集，以列表结构返回，给定连接对象
+// doGetAll queries and returns data records from database.
 func (bs *dbBase) doGetAll(link dbLink, query string, args ...interface{}) (result Result, err error) {
 	if link == nil {
 		link, err = bs.db.Slave()
@@ -142,7 +154,7 @@ func (bs *dbBase) doGetAll(link dbLink, query string, args ...interface{}) (resu
 	return bs.db.rowsToResult(rows)
 }
 
-// 数据库查询，获取查询结果记录，以关联数组结构返回
+// GetOne queries and returns one record from database.
 func (bs *dbBase) GetOne(query string, args ...interface{}) (Record, error) {
 	list, err := bs.GetAll(query, args...)
 	if err != nil {
@@ -154,7 +166,8 @@ func (bs *dbBase) GetOne(query string, args ...interface{}) (Record, error) {
 	return nil, nil
 }
 
-// 数据库查询，查询单条记录，自动映射数据到给定的struct对象中
+// GetStruct queries one record from database and converts it to given struct.
+// The parameter <pointer> should be a pointer to struct.
 func (bs *dbBase) GetStruct(pointer interface{}, query string, args ...interface{}) error {
 	one, err := bs.GetOne(query, args...)
 	if err != nil {
@@ -166,7 +179,8 @@ func (bs *dbBase) GetStruct(pointer interface{}, query string, args ...interface
 	return one.Struct(pointer)
 }
 
-// 数据库查询，查询多条记录，并自动转换为指定的slice对象, 如: []struct/[]*struct。
+// GetStructs queries records from database and converts them to given struct.
+// The parameter <pointer> should be type of struct slice: []struct/[]*struct.
 func (bs *dbBase) GetStructs(pointer interface{}, query string, args ...interface{}) error {
 	all, err := bs.GetAll(query, args...)
 	if err != nil {
@@ -178,9 +192,12 @@ func (bs *dbBase) GetStructs(pointer interface{}, query string, args ...interfac
 	return all.Structs(pointer)
 }
 
-// 将结果转换为指定的struct/*struct/[]struct/[]*struct,
-// 参数应该为指针类型，否则返回失败。
-// 该方法自动识别参数类型，调用Struct/Structs方法。
+// GetScan queries one or more records from database and converts them to given struct or
+// struct array.
+//
+// If parameter <pointer> is type of struct pointer, it calls GetStruct internally for
+// the conversion. If parameter <pointer> is type of slice, it calls GetStructs internally
+// for conversion.
 func (bs *dbBase) GetScan(pointer interface{}, query string, args ...interface{}) error {
 	t := reflect.TypeOf(pointer)
 	k := t.Kind()
@@ -197,7 +214,9 @@ func (bs *dbBase) GetScan(pointer interface{}, query string, args ...interface{}
 	return fmt.Errorf("element type should be type of struct/slice, unsupported: %v", k)
 }
 
-// 数据库查询，获取查询字段值
+// GetValue queries and returns the field value from database.
+// The sql should queries only one field from database, or else it returns only one
+// field of the result.
 func (bs *dbBase) GetValue(query string, args ...interface{}) (Value, error) {
 	one, err := bs.GetOne(query, args...)
 	if err != nil {
@@ -209,8 +228,10 @@ func (bs *dbBase) GetValue(query string, args ...interface{}) (Value, error) {
 	return nil, nil
 }
 
-// 数据库查询，获取查询数量
+// GetCount queries and returns the count from database.
 func (bs *dbBase) GetCount(query string, args ...interface{}) (int, error) {
+	// If the query fields do not contains function "COUNT",
+	// it replaces the query string and adds the "COUNT" function to the fields.
 	if !gregex.IsMatchString(`(?i)SELECT\s+COUNT\(.+\)\s+FROM`, query) {
 		query, _ = gregex.ReplaceString(`(?i)(SELECT)\s+(.+)\s+(FROM)`, `$1 COUNT($2) $3`, query)
 	}
@@ -221,7 +242,7 @@ func (bs *dbBase) GetCount(query string, args ...interface{}) (int, error) {
 	return value.Int(), nil
 }
 
-// ping一下，判断或保持数据库链接(master)
+// PingMaster pings the master node to check authentication or keeps the connection alive.
 func (bs *dbBase) PingMaster() error {
 	if master, err := bs.db.Master(); err != nil {
 		return err
@@ -230,7 +251,7 @@ func (bs *dbBase) PingMaster() error {
 	}
 }
 
-// ping一下，判断或保持数据库链接(slave)
+// PingSlave pings the slave node to check authentication or keeps the connection alive.
 func (bs *dbBase) PingSlave() error {
 	if slave, err := bs.db.Slave(); err != nil {
 		return err
@@ -239,8 +260,10 @@ func (bs *dbBase) PingSlave() error {
 	}
 }
 
-// 事务操作，开启，会返回一个底层的事务操作对象链接如需要嵌套事务，那么可以使用该对象，否则请忽略
-// 只有在tx.Commit/tx.Rollback时，链接会自动Close
+// Begin starts and returns the transaction object.
+// You should call Commit or Rollback functions of the transaction object
+// if you no longer use the transaction. Commit or Rollback functions will also
+// close the transaction automatically.
 func (bs *dbBase) Begin() (*TX, error) {
 	if master, err := bs.db.Master(); err != nil {
 		return nil, err
@@ -257,42 +280,76 @@ func (bs *dbBase) Begin() (*TX, error) {
 	}
 }
 
-// CURD操作:单条数据写入, 仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回。
-// 参数data支持map/struct/*struct/slice类型，
-// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+// Insert does "INSERT INTO ..." statement for the table.
+// If there's already one unique record of the data in the table, it returns error.
+//
+// The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
+// Eg:
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+//
+// The parameter <batch> specifies the batch operation count when given data is slice.
 func (bs *dbBase) Insert(table string, data interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doInsert(nil, table, data, gINSERT_OPTION_DEFAULT, batch...)
 }
 
-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条。
-// 参数data支持map/struct/*struct/slice类型，
-// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+// InsertIgnore does "INSERT IGNORE INTO ..." statement for the table.
+// If there's already one unique record of the data in the table, it ignores the inserting.
+//
+// The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
+// Eg:
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+//
+// The parameter <batch> specifies the batch operation count when given data is slice.
+func (bs *dbBase) InsertIgnore(table string, data interface{}, batch ...int) (sql.Result, error) {
+	return bs.db.doInsert(nil, table, data, gINSERT_OPTION_IGNORE, batch...)
+}
+
+// Replace does "REPLACE INTO ..." statement for the table.
+// If there's already one unique record of the data in the table, it deletes the record
+// and inserts a new one.
+//
+// The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
+// Eg:
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+//
+// The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
+// If given data is type of slice, it then does batch replacing, and the optional parameter
+// <batch> specifies the batch operation count.
 func (bs *dbBase) Replace(table string, data interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doInsert(nil, table, data, gINSERT_OPTION_REPLACE, batch...)
 }
 
-// CURD操作:单条数据写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据。
-// 参数data支持map/struct/*struct/slice类型，
-// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+// Save does "INSERT INTO ... ON DUPLICATE KEY UPDATE..." statement for the table.
+// It updates the record if there's primary or unique index in the saving data,
+// or else it inserts a new record into the table.
+//
+// The parameter <data> can be type of map/gmap/struct/*struct/[]map/[]struct, etc.
+// Eg:
+// Data(g.Map{"uid": 10000, "name":"john"})
+// Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})
+//
+// If given data is type of slice, it then does batch saving, and the optional parameter
+// <batch> specifies the batch operation count.
 func (bs *dbBase) Save(table string, data interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doInsert(nil, table, data, gINSERT_OPTION_SAVE, batch...)
 }
 
-// 支持insert、replace, save， ignore操作。
-// 0: insert:  仅仅执行写入操作，如果存在冲突的主键或者唯一索引，那么报错返回;
-// 1: replace: 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条;
-// 2: save:    如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据;
-// 3: ignore:  如果数据存在(主键或者唯一索引)，那么什么也不做;
+// doInsert inserts or updates data for given table.
 //
-// 参数data支持map/struct/*struct/slice类型，
-// 当为slice(例如[]map/[]struct/[]*struct)类型时，batch参数生效，并自动切换为批量操作。
+// The parameter <option> values are as follows:
+// 0: insert:  just insert, if there's unique/primary key in the data, it returns error;
+// 1: replace: if there's unique/primary key in the data, it deletes it from table and inserts a new one;
+// 2: save:    if there's unique/primary key in the data, it updates it or else inserts a new one;
+// 3: ignore:  if there's unique/primary key in the data, it ignores the inserting;
 func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option int, batch ...int) (result sql.Result, err error) {
 	var fields []string
 	var values []string
 	var params []interface{}
 	var dataMap Map
 	table = bs.db.handleTableName(table)
-	// 使用反射判断data数据类型，如果为slice类型，那么自动转为批量操作
 	rv := reflect.ValueOf(data)
 	kind := rv.Kind()
 	if kind == reflect.Ptr {
@@ -314,7 +371,7 @@ func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option i
 	for k, v := range dataMap {
 		fields = append(fields, charL+k+charR)
 		values = append(values, "?")
-		params = append(params, convertParam(v))
+		params = append(params, v)
 	}
 	operation := getInsertOperationByOption(option)
 	updateStr := ""
@@ -341,22 +398,31 @@ func (bs *dbBase) doInsert(link dbLink, table string, data interface{}, option i
 		params...)
 }
 
-// CURD操作:批量数据指定批次量写入
+// BatchInsert batch inserts data.
+// The parameter <list> must be type of slice of map or struct.
 func (bs *dbBase) BatchInsert(table string, list interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doBatchInsert(nil, table, list, gINSERT_OPTION_DEFAULT, batch...)
 }
 
-// CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么删除后重新写入一条
+// BatchInsert batch inserts data with ignore option.
+// The parameter <list> must be type of slice of map or struct.
+func (bs *dbBase) BatchInsertIgnore(table string, list interface{}, batch ...int) (sql.Result, error) {
+	return bs.db.doBatchInsert(nil, table, list, gINSERT_OPTION_IGNORE, batch...)
+}
+
+// BatchReplace batch replaces data.
+// The parameter <list> must be type of slice of map or struct.
 func (bs *dbBase) BatchReplace(table string, list interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doBatchInsert(nil, table, list, gINSERT_OPTION_REPLACE, batch...)
 }
 
-// CURD操作:批量数据指定批次量写入, 如果数据存在(主键或者唯一索引)，那么更新，否则写入一条新数据
+// BatchSave batch replaces data.
+// The parameter <list> must be type of slice of map or struct.
 func (bs *dbBase) BatchSave(table string, list interface{}, batch ...int) (sql.Result, error) {
 	return bs.db.doBatchInsert(nil, table, list, gINSERT_OPTION_SAVE, batch...)
 }
 
-// 批量写入数据, 参数list支持slice类型，例如: []map/[]struct/[]*struct。
+// doBatchInsert batch inserts/replaces/saves data.
 func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, option int, batch ...int) (result sql.Result, err error) {
 	var keys, values []string
 	var params []interface{}
@@ -425,7 +491,6 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
 		}
 		updateStr = fmt.Sprintf("ON DUPLICATE KEY UPDATE %s", updateStr)
 	}
-	// 构造批量写入数据格式(注意map的遍历是无序的)
 	batchNum := gDEFAULT_BATCH_NUM
 	if len(batch) > 0 && batch[0] > 0 {
 		batchNum = batch[0]
@@ -435,7 +500,7 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
 		// Note that the map type is unordered,
 		// so it should use slice+key to retrieve the value.
 		for _, k := range keys {
-			params = append(params, convertParam(listMap[i][k]))
+			params = append(params, listMap[i][k])
 		}
 		values = append(values, valueHolderStr)
 		if len(values) == batchNum || (i == listMapLen-1 && len(values) > 0) {
@@ -467,8 +532,20 @@ func (bs *dbBase) doBatchInsert(link dbLink, table string, list interface{}, opt
 	return batchResult, nil
 }
 
-// CURD操作:数据更新，统一采用sql预处理。
-// data参数支持string/map/struct/*struct类型。
+// Update does "UPDATE ... " statement for the table.
+//
+// The parameter <data> can be type of string/map/gmap/struct/*struct, etc.
+// Eg: "uid=10000", "uid", 10000, g.Map{"uid": 10000, "name":"john"}
+//
+// The parameter <condition> can be type of string/map/gmap/slice/struct/*struct, etc.
+// It is commonly used with parameter <args>.
+// Eg:
+// "uid=10000",
+// "uid", 10000
+// "money>? AND name like ?", 99999, "vip_%"
+// "status IN (?)", g.Slice{1,2,3}
+// "age IN(?,?)", 18, 50
+// User{ Id : 1, UserName : "john"}
 func (bs *dbBase) Update(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) {
 	newWhere, newArgs := formatWhere(bs.db, condition, args, false)
 	if newWhere != "" {
@@ -477,12 +554,11 @@ func (bs *dbBase) Update(table string, data interface{}, condition interface{},
 	return bs.db.doUpdate(nil, table, data, newWhere, newArgs...)
 }
 
-// CURD操作:数据更新，统一采用sql预处理。
-// data参数支持string/map/struct/*struct类型类型。
+// doUpdate does "UPDATE ... " statement for the table.
+// Also see Update.
 func (bs *dbBase) doUpdate(link dbLink, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error) {
 	table = bs.db.handleTableName(table)
 	updates := ""
-	// 使用反射进行类型判断
 	rv := reflect.ValueOf(data)
 	kind := rv.Kind()
 	if kind == reflect.Ptr {
@@ -495,7 +571,7 @@ func (bs *dbBase) doUpdate(link dbLink, table string, data interface{}, conditio
 		var fields []string
 		for k, v := range varToMapDeep(data) {
 			fields = append(fields, bs.db.quoteWord(k)+"=?")
-			params = append(params, convertParam(v))
+			params = append(params, v)
 		}
 		updates = strings.Join(fields, ",")
 	default:
@@ -516,7 +592,17 @@ func (bs *dbBase) doUpdate(link dbLink, table string, data interface{}, conditio
 	return bs.db.doExec(link, fmt.Sprintf("UPDATE %s SET %s%s", table, updates, condition), args...)
 }
 
-// CURD操作:删除数据
+// Delete does "DELETE FROM ... " statement for the table.
+//
+// The parameter <condition> can be type of string/map/gmap/slice/struct/*struct, etc.
+// It is commonly used with parameter <args>.
+// Eg:
+// "uid=10000",
+// "uid", 10000
+// "money>? AND name like ?", 99999, "vip_%"
+// "status IN (?)", g.Slice{1,2,3}
+// "age IN(?,?)", 18, 50
+// User{ Id : 1, UserName : "john"}
 func (bs *dbBase) Delete(table string, condition interface{}, args ...interface{}) (result sql.Result, err error) {
 	newWhere, newArgs := formatWhere(bs.db, condition, args, false)
 	if newWhere != "" {
@@ -525,7 +611,8 @@ func (bs *dbBase) Delete(table string, condition interface{}, args ...interface{
 	return bs.db.doDelete(nil, table, newWhere, newArgs...)
 }
 
-// CURD操作:删除数据
+// doDelete does "DELETE FROM ... " statement for the table.
+// Also see Delete.
 func (bs *dbBase) doDelete(link dbLink, table string, condition string, args ...interface{}) (result sql.Result, err error) {
 	if link == nil {
 		if link, err = bs.db.Master(); err != nil {
@@ -536,36 +623,35 @@ func (bs *dbBase) doDelete(link dbLink, table string, condition string, args ...
 	return bs.db.doExec(link, fmt.Sprintf("DELETE FROM %s%s", table, condition), args...)
 }
 
-// 获得缓存对象
+// getCache returns the internal cache object.
 func (bs *dbBase) getCache() *gcache.Cache {
 	return bs.cache
 }
 
-// 获得表名前缀
+// getPrefix returns the table prefix string configured.
 func (bs *dbBase) getPrefix() string {
 	return bs.prefix
 }
 
-// 将数据查询的列表数据*sql.Rows转换为Result类型
+// rowsToResult converts underlying data record type sql.Rows to Result type.
 func (bs *dbBase) rowsToResult(rows *sql.Rows) (Result, error) {
 	if !rows.Next() {
 		return nil, nil
 	}
-	// 列信息列表, 名称与类型
-	columnTypes, err := rows.ColumnTypes()
+	// Column names and types.
+	columns, err := rows.ColumnTypes()
 	if err != nil {
 		return nil, err
 	}
-	types := make([]string, len(columnTypes))
-	columns := make([]string, len(columnTypes))
-	for k, v := range columnTypes {
-		types[k] = v.DatabaseTypeName()
-		columns[k] = v.Name()
+	columnTypes := make([]string, len(columns))
+	columnNames := make([]string, len(columns))
+	for k, v := range columns {
+		columnTypes[k] = v.DatabaseTypeName()
+		columnNames[k] = v.Name()
 	}
-	// 返回结构组装
-	values := make([]sql.RawBytes, len(columns))
-	scanArgs := make([]interface{}, len(values))
+	values := make([]sql.RawBytes, len(columnNames))
 	records := make(Result, 0)
+	scanArgs := make([]interface{}, len(values))
 	for i := range values {
 		scanArgs[i] = &values[i]
 	}
@@ -573,17 +659,19 @@ func (bs *dbBase) rowsToResult(rows *sql.Rows) (Result, error) {
 		if err := rows.Scan(scanArgs...); err != nil {
 			return records, err
 		}
+		// Creates a new row object.
 		row := make(Record)
-		// 注意col字段是一个[]byte类型(slice类型本身是一个引用类型)，
-		// 多个记录循环时该变量指向的是同一个内存地址
-		for i, column := range values {
-			if column == nil {
-				row[columns[i]] = gvar.New(nil)
+		// Note that the internal looping variable <value> is type of []byte,
+		// which points to the same memory address. So it should do a copy.
+		for i, value := range values {
+			if value == nil {
+				row[columnNames[i]] = gvar.New(nil)
 			} else {
-				// 由于 sql.RawBytes 是slice类型, 这里必须使用值复制
-				v := make([]byte, len(column))
-				copy(v, column)
-				row[columns[i]] = gvar.New(bs.db.convertValue(v, types[i]))
+				// As sql.RawBytes is type of slice,
+				// it should do a copy of it.
+				v := make([]byte, len(value))
+				copy(v, value)
+				row[columnNames[i]] = gvar.New(bs.db.convertValue(v, columnTypes[i]))
 			}
 		}
 		records = append(records, row)
@@ -619,7 +707,8 @@ func (bs *dbBase) quoteString(s string) string {
 	return doQuoteString(s, charLeft, charRight)
 }
 
-// 打印SQL对象(仅在debug=true时有效)
+// printSql outputs the sql object to logger.
+// It is enabled when configuration "debug" is true.
 func (bs *dbBase) printSql(v *Sql) {
 	s := fmt.Sprintf("[%d ms] %s", v.End-v.Start, v.Format)
 	if v.Error != nil {

database/gdb/gdb_batch_result.go

@@ -8,7 +8,7 @@ package gdb
 
 import "database/sql"
 
-// 批量执行的结果对象
+// batchSqlResult is execution result for batch operations.
 type batchSqlResult struct {
 	rowsAffected int64
 	lastResult   sql.Result