version updates

feat: 🐛 fix GetWhereConditionOfStruct where AND

.example/database/gdb/driver/driver/driver.go

@@ -9,7 +9,6 @@ package driver
 import (
 	"database/sql"
 	"github.com/gogf/gf/database/gdb"
-	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/gtime"
 )
 
@@ -51,14 +50,13 @@ func (d *MyDriver) New(core *gdb.Core, node *gdb.ConfigNode) (gdb.DB, error) {
 func (d *MyDriver) DoQuery(link gdb.Link, sql string, args ...interface{}) (rows *sql.Rows, err error) {
 	tsMilli := gtime.TimestampMilli()
 	rows, err = d.DriverMysql.DoQuery(link, sql, args...)
-	if _, err := d.DriverMysql.InsertIgnore("monitor", g.Map{
-		"sql":   gdb.FormatSqlWithArgs(sql, args),
-		"cost":  gtime.TimestampMilli() - tsMilli,
-		"time":  gtime.Now(),
-		"error": err.Error(),
-	}); err != nil {
-		panic(err)
-	}
+	link.Exec(
+		"INSERT INTO `monitor`(`sql`,`cost`,`time`,`error`) VALUES(?,?,?,?)",
+		gdb.FormatSqlWithArgs(sql, args),
+		gtime.TimestampMilli()-tsMilli,
+		gtime.Now(),
+		err,
+	)
 	return
 }
 
@@ -67,13 +65,12 @@ func (d *MyDriver) DoQuery(link gdb.Link, sql string, args ...interface{}) (rows
 func (d *MyDriver) DoExec(link gdb.Link, sql string, args ...interface{}) (result sql.Result, err error) {
 	tsMilli := gtime.TimestampMilli()
 	result, err = d.DriverMysql.DoExec(link, sql, args...)
-	if _, err := d.DriverMysql.InsertIgnore("monitor", g.Map{
-		"sql":   gdb.FormatSqlWithArgs(sql, args),
-		"cost":  gtime.TimestampMilli() - tsMilli,
-		"time":  gtime.Now(),
-		"error": err.Error(),
-	}); err != nil {
-		panic(err)
-	}
+	link.Exec(
+		"INSERT INTO `monitor`(`sql`,`cost`,`time`,`error`) VALUES(?,?,?,?)",
+		gdb.FormatSqlWithArgs(sql, args),
+		gtime.TimestampMilli()-tsMilli,
+		gtime.Now(),
+		err,
+	)
 	return
 }

.example/database/gdb/mssql/gdb_sqlserver.go

@@ -512,16 +512,6 @@ func mapToStruct() {
 	}
 }
 
-// getQueriedSqls
-func getQueriedSqls() {
-	for k, v := range db.GetQueriedSqls() {
-		fmt.Println(k, ":")
-		fmt.Println("Sql  :", v.Sql)
-		fmt.Println("Args :", v.Args)
-		fmt.Println("Error:", v.Error)
-	}
-}
-
 func main() {
 
 	db.PingMaster()

.example/database/gdb/mysql/config.toml

@@ -1,8 +1,18 @@
 
-# MySQL数据库配置
+# MySQL.
 [database]
-#	debug = true
-    link  = "mysql:root:12345678@tcp(127.0.0.1:3306)/test?parseTime=true&loc=Local"
+    [database.logger]
+        Level   = "all"
+        Stdout  = true
+        CtxKeys = ["Trace-Id"]
+    [database.default]
+        link   = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
+        debug  = true
+
+# Redis.
+[redis]
+    default = "127.0.0.1:6379,0"
+    cache   = "127.0.0.1:6379,1"
 
 #[database]
 #   [[database.default]]

.example/database/gdb/mysql/gdb_all.go

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-
 	"github.com/gogf/gf/frame/g"
 )
 
@@ -11,11 +10,19 @@ func main() {
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
 
-	r, e := db.Table("test").Order("id asc").All()
+	r, e := db.GetAll("SELECT * from `user` where id in(?)", g.Slice{})
 	if e != nil {
 		fmt.Println(e)
 	}
 	if r != nil {
-		fmt.Println(r.List())
+		fmt.Println(r)
 	}
+	return
+	//r, e := db.Table("user").Where("id in(?)", g.Slice{}).All()
+	//if e != nil {
+	//	fmt.Println(e)
+	//}
+	//if r != nil {
+	//	fmt.Println(r.List())
+	//}
 }

.example/database/gdb/mysql/gdb_cache.go

@@ -3,6 +3,7 @@ package main
 import (
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/util/gutil"
+	"time"
 )
 
 func main() {
@@ -10,7 +11,7 @@ func main() {
 		Host:    "127.0.0.1",
 		Port:    "3306",
 		User:    "root",
-		Pass:    "123456",
+		Pass:    "12345678",
 		Name:    "test",
 		Type:    "mysql",
 		Role:    "master",
@@ -20,19 +21,20 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
+	//db.GetCache().SetAdapter(adapter.NewRedis(g.Redis()))
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
 
 	// 执行2次查询并将查询结果缓存3秒，并可执行缓存名称(可选)
-	for i := 0; i < 2; i++ {
-		r, _ := db.Table("user").Cache(3, "vip-user").Where("uid=?", 1).One()
-		gutil.Dump(r.ToMap())
+	for i := 0; i < 3; i++ {
+		r, _ := db.Table("user").Cache(3000*time.Second).Where("id=?", 1).One()
+		gutil.Dump(r.Map())
 	}
 
 	// 执行更新操作，并清理指定名称的查询缓存
-	db.Table("user").Cache(-1, "vip-user").Data(gdb.Map{"name": "smith"}).Where("uid=?", 1).Update()
+	//db.Table("user").Cache(-1, "vip-user").Data(gdb.Map{"name": "smith"}).Where("id=?", 1).Update()
 
 	// 再次执行查询，启用查询缓存特性
-	r, _ := db.Table("user").Cache(3, "vip-user").Where("uid=?", 1).One()
-	gutil.Dump(r.ToMap())
+	//r, _ := db.Table("user").Cache(300000*time.Second, "vip-user").Where("id=?", 1).One()
+	//gutil.Dump(r.Map())
 }

.example/database/gdb/mysql/gdb_ctx.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"context"
+	"github.com/gogf/gf/frame/g"
+)
+
+func main() {
+	ctx := context.WithValue(context.Background(), "Trace-Id", "123456789")
+	_, err := g.DB().Ctx(ctx).Query("SELECT 1")
+	if err != nil {
+		panic(err)
+	}
+}

.example/database/gdb/mysql/gdb_ctx_model.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"context"
+	"github.com/gogf/gf/frame/g"
+)
+
+func main() {
+	ctx := context.WithValue(context.Background(), "Trace-Id", "123456789")
+	_, err := g.DB().Model("user").Ctx(ctx).All()
+	if err != nil {
+		panic(err)
+	}
+}

.example/database/gdb/mysql/gdb_insert.go

@@ -3,7 +3,7 @@ package main
 import (
 	"fmt"
 	"github.com/gogf/gf/database/gdb"
-	"time"
+	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
@@ -18,10 +18,9 @@ func main() {
 
 	db.SetDebug(true)
 
-	type User struct {
-		CreateTime time.Time `orm:"create_time"`
-	}
-	r, e := db.Table("user").Data(User{CreateTime: time.Now()}).Insert()
+	r, e := db.Table("user").Data(g.Map{
+		"create_at": "now()",
+	}).Unscoped().Insert()
 	if e != nil {
 		panic(e)
 	}

.example/database/gdb/mysql/gdb_pool.go

@@ -8,9 +8,6 @@ import (
 
 func main() {
 	db := g.DB()
-	db.SetMaxIdleConnCount(10)
-	db.SetMaxOpenConnCount(10)
-	db.SetMaxConnLifetime(time.Minute)
 
 	// 开启调试模式，以便于记录所有执行的SQL
 	db.SetDebug(true)
@@ -19,7 +16,7 @@ func main() {
 		for i := 0; i < 10; i++ {
 			go db.Table("user").All()
 		}
-		time.Sleep(time.Second)
+		time.Sleep(time.Millisecond * 100)
 	}
 
 }

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

@@ -1,12 +1,15 @@
 package main
 
 import (
+	"fmt"
 	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	db := g.DB()
-	db.SetDebug(true)
-
-	db.Table("user").Fields("DISTINCT id,nickname").Filter().All()
+	one, err := g.DB().Table("carlist c").
+		LeftJoin("cardetail d", "c.postid=d.carid").
+		Where("c.postid", "142039140032006").
+		Fields("c.*,d.*").One()
+	fmt.Println(err)
+	g.Dump(one)
 }

.example/database/gdb/oracle/gdb.go

@@ -513,16 +513,6 @@ func mapToStruct() {
 	}
 }
 
-// getQueriedSqls
-func getQueriedSqls() {
-	for k, v := range db.GetQueriedSqls() {
-		fmt.Println(k, ":")
-		fmt.Println("Sql  :", v.Sql)
-		fmt.Println("Args :", v.Args)
-		fmt.Println("Error:", v.Error)
-	}
-}
-
 func main() {
 
 	db.PingMaster()

.example/encoding/gcompress/zip.go

@@ -1,16 +1,68 @@
 package main
 
 import (
+	"archive/zip"
 	"fmt"
-
 	"github.com/gogf/gf/encoding/gcompress"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
 )
 
-func main() {
-	err := gcompress.ZipPath(
-		`D:\Workspace\Go\GOPATH\src\github.com\gogf\gf\geg`,
-		`D:\Workspace\Go\GOPATH\src\github.com\gogf\gf\geg\encoding\gcompress\data.zip`,
-		"my-dir",
-	)
-	fmt.Println(err)
+// srcFile could be a single file or a directory
+func Zip(srcFile string, destZip string) error {
+	zipfile, err := os.Create(destZip)
+	if err != nil {
+		return err
+	}
+	defer zipfile.Close()
+
+	archive := zip.NewWriter(zipfile)
+	defer archive.Close()
+
+	filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		header, err := zip.FileInfoHeader(info)
+		if err != nil {
+			return err
+		}
+
+		header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile)+"/")
+		// header.Name = path
+		if info.IsDir() {
+			header.Name += "/"
+		} else {
+			header.Method = zip.Deflate
+		}
+
+		writer, err := archive.CreateHeader(header)
+		if err != nil {
+			return err
+		}
+
+		if !info.IsDir() {
+			file, err := os.Open(path)
+			if err != nil {
+				return err
+			}
+			defer file.Close()
+			_, err = io.Copy(writer, file)
+		}
+		return err
+	})
+
+	return err
+}
+
+func main() {
+	src := `/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/test`
+	dst := `/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/test.zip`
+	//src := `/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/README.MD`
+	//dst := `/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/README.MD.zip`
+	fmt.Println(gcompress.ZipPath(src, dst))
+	//fmt.Println(Zip(src, dst))
 }

.example/i18n/gi18n/gi18n.go

@@ -2,25 +2,14 @@ package main
 
 import (
 	"fmt"
-
-	"github.com/gogf/gf/i18n/gi18n"
+	"github.com/gogf/gf/frame/g"
 )
 
 func main() {
-	t := gi18n.New()
-	t.SetPath("/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/.example/i18n/gi18n/i18n")
-	t.SetLanguage("en")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	t.SetLanguage("ja")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	t.SetLanguage("ru")
-	fmt.Println(t.Translate(`hello`))
-	fmt.Println(t.Translate(`{#hello}{#world}!`))
-
-	fmt.Println(t.Translate(`hello`, "zh-CN"))
-	fmt.Println(t.Translate(`{#hello}{#world}!`, "zh-CN"))
+	var (
+		orderId     = 865271654
+		orderAmount = 99.8
+	)
+	fmt.Println(g.I18n().Tfl(`en`, `{#OrderPaid}`, orderId, orderAmount))
+	fmt.Println(g.I18n().Tfl(`zh-CN`, `{#OrderPaid}`, orderId, orderAmount))
 }

.example/i18n/gi18n/i18n/en.toml

@@ -1,3 +1 @@
-
-hello = "Hello"
-world = "World"
+OrderPaid = "You have successfully complete order #%d payment, paid amount: ￥%0.2f."

.example/i18n/gi18n/i18n/zh-CN.toml

@@ -1,2 +1 @@
-hello = "你好"
-world = "世界"
+OrderPaid = "您已成功完成订单号 #%d 支付，支付金额￥%.2f。"

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

@@ -9,7 +9,7 @@ import (
 func Upload(r *ghttp.Request) {
 	saveDirPath := "/tmp/"
 	files := r.GetUploadFiles("upload-file")
-	if err := files.Save(saveDirPath); err != nil {
+	if _, err := files.Save(saveDirPath); err != nil {
 		r.Response.WriteExit(err)
 	}
 	r.Response.WriteExit("upload successfully")

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

@@ -2,12 +2,34 @@ package main
 
 import (
 	"fmt"
+	"github.com/gogf/gf/frame/g"
+	"path/filepath"
 
 	"github.com/gogf/gf/net/ghttp"
 	"github.com/gogf/gf/os/glog"
 )
 
+func SendXmlFile(gameId int, areaName string, filePath string) error {
+	path := filepath.FromSlash(filePath)
+	fmt.Println(path)
+	data := g.Map{
+		"gameName":    gameId,
+		"area":        areaName,
+		"file":        "@file:" + path,
+		"contentType": "json",
+	}
+	if r, err := ghttp.Post("http://127.0.0.1:8199/upload", data); err != nil {
+		panic(err)
+	} else {
+		defer r.Close()
+		fmt.Println("ok")
+	}
+	return nil
+}
+
 func main() {
+	SendXmlFile(1, "xxx", "/Users/john/Workspace/Go/GOPATH/src/github.com/gogf/gf/.example/net/ghttp/server/session.go")
+	return
 	path := "/home/john/Workspace/Go/github.com/gogf/gf/version.go"
 	r, e := ghttp.Post("http://127.0.0.1:8199/upload", "upload-file=@file:"+path)
 	if e != nil {

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

@@ -8,8 +8,8 @@ import (
 // Upload uploads files to /tmp .
 func Upload(r *ghttp.Request) {
 	saveDirPath := "/tmp/"
-	files := r.GetUploadFiles("upload-file")
-	if err := files.Save(saveDirPath); err != nil {
+	files := r.GetUploadFiles("file")
+	if _, err := files.Save(saveDirPath); err != nil {
 		r.Response.WriteExit(err)
 	}
 	r.Response.WriteExit("upload successfully")

.example/net/ghttp/server/exit.go

@@ -15,10 +15,10 @@ func main() {
 		r.Response.Writeln("end")
 	})
 	s.BindHookHandlerByMap(p, map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			glog.To(r.Response.Writer).Println("BeforeServe")
 		},
-		ghttp.HOOK_AFTER_SERVE: func(r *ghttp.Request) {
+		ghttp.HookAfterServe: func(r *ghttp.Request) {
 			glog.To(r.Response.Writer).Println("AfterServe")
 		},
 	})

.example/net/ghttp/server/hello.go

@@ -3,15 +3,12 @@ package main
 import (
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
-	"github.com/gogf/gf/os/glog"
 )
 
 func main() {
 	s := g.Server()
-	s.SetIndexFolder(true)
 	s.BindHandler("/", func(r *ghttp.Request) {
-		glog.Println(r.Header)
-		r.Response.Write("hello world")
+		r.Response.Write("Hello World")
 	})
 	s.SetPort(8999)
 	s.Run()

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

@@ -12,7 +12,7 @@ func Order(r *ghttp.Request) {
 func main() {
 	s := g.Server()
 	s.Group("/api.v1", func(group *ghttp.RouterGroup) {
-		group.Hook("/*any", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+		group.Hook("/*any", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 			r.Response.CORSDefault()
 		})
 		g.GET("/order", Order)

.example/net/ghttp/server/hooks/hooks1.go

@@ -11,10 +11,10 @@ func main() {
 	p := "/:name/info/{uid}"
 	s := g.Server()
 	s.BindHookHandlerByMap(p, map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE:  func(r *ghttp.Request) { glog.Println(ghttp.HOOK_BEFORE_SERVE) },
-		ghttp.HOOK_AFTER_SERVE:   func(r *ghttp.Request) { glog.Println(ghttp.HOOK_AFTER_SERVE) },
-		ghttp.HOOK_BEFORE_OUTPUT: func(r *ghttp.Request) { glog.Println(ghttp.HOOK_BEFORE_OUTPUT) },
-		ghttp.HOOK_AFTER_OUTPUT:  func(r *ghttp.Request) { glog.Println(ghttp.HOOK_AFTER_OUTPUT) },
+		ghttp.HookBeforeServe:  func(r *ghttp.Request) { glog.Println(ghttp.HookBeforeServe) },
+		ghttp.HookAfterServe:   func(r *ghttp.Request) { glog.Println(ghttp.HookAfterServe) },
+		ghttp.HookBeforeOutput: func(r *ghttp.Request) { glog.Println(ghttp.HookBeforeOutput) },
+		ghttp.HookAfterOutput:  func(r *ghttp.Request) { glog.Println(ghttp.HookAfterOutput) },
 	})
 	s.BindHandler(p, func(r *ghttp.Request) {
 		r.Response.Write("用户:", r.Get("name"), ", uid:", r.Get("uid"))

.example/net/ghttp/server/hooks/hooks4.go

@@ -11,7 +11,7 @@ func main() {
 	// 多事件回调示例，事件1
 	pattern1 := "/:name/info"
 	s.BindHookHandlerByMap(pattern1, map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			r.SetParam("uid", 1000)
 		},
 	})
@@ -22,7 +22,7 @@ func main() {
 	// 多事件回调示例，事件2
 	pattern2 := "/{object}/list/{page}.java"
 	s.BindHookHandlerByMap(pattern2, map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_OUTPUT: func(r *ghttp.Request) {
+		ghttp.HookBeforeOutput: func(r *ghttp.Request) {
 			r.Response.SetBuffer([]byte(
 				fmt.Sprintf("通过事件修改输出内容, object:%s, page:%s", r.Get("object"), r.GetRouterString("page"))),
 			)

.example/net/ghttp/server/hooks/hooks5.go

@@ -7,10 +7,10 @@ import (
 
 func main() {
 	s := g.Server()
-	s.BindHookHandler("/*any", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+	s.BindHookHandler("/*any", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 		r.Response.Writeln("/*any")
 	})
-	s.BindHookHandler("/v1/*", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+	s.BindHookHandler("/v1/*", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 		r.Response.Writeln("/v1/*")
 		r.ExitHook()
 	})

.example/net/ghttp/server/hooks/hooks_param.go

@@ -11,7 +11,7 @@ func main() {
 		r.Response.Writeln(r.Get("name"))
 	})
 	s.BindHookHandlerByMap("/", map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			r.SetParam("name", "john")
 		},
 	})

.example/net/ghttp/server/hooks/same_route_multi_hook.go

@@ -12,17 +12,17 @@ func main() {
 	})
 
 	s.BindHookHandlerByMap("/priority/:name", map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			r.Response.Writeln("/priority/:name")
 		},
 	})
 	s.BindHookHandlerByMap("/priority/*any", map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			r.Response.Writeln("/priority/*any")
 		},
 	})
 	s.BindHookHandlerByMap("/priority/show", map[string]ghttp.HandlerFunc{
-		ghttp.HOOK_BEFORE_SERVE: func(r *ghttp.Request) {
+		ghttp.HookBeforeServe: func(r *ghttp.Request) {
 			r.Response.Writeln("/priority/show")
 		},
 	})

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

@@ -27,10 +27,10 @@ func main() {
 			})
 		})
 		group.Group("/hook", func(group *ghttp.RouterGroup) {
-			group.Hook("/*", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+			group.Hook("/*", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 				r.Response.Write("hook any")
 			})
-			group.Hook("/:name", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+			group.Hook("/:name", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 				r.Response.Write("hook name")
 			})
 		})

.example/net/ghttp/server/object/user.go

@@ -5,21 +5,18 @@ import (
 	"github.com/gogf/gf/net/ghttp"
 )
 
-type User struct {
-}
+type User struct{}
 
-func (c *User) Index(r *ghttp.Request) {
-	r.Response.Write("Index")
-}
-
-// 不符合规范，不会被注册
-func (c *User) Test(r *ghttp.Request, value interface{}) {
+func (c *User) Test(r *ghttp.Request) {
 	r.Response.Write("Test")
 }
 
 func main() {
 	s := g.Server()
-	s.BindObject("/user", new(User))
+	u := new(User)
+	s.Group("/", func(group *ghttp.RouterGroup) {
+		group.GET("/db-{table}/{id}", u, "Test")
+	})
 	s.SetPort(8199)
 	s.Run()
 }

.example/net/ghttp/server/pprof.go

@@ -1,12 +1,13 @@
 package main
 
 import (
+	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/net/ghttp"
 )
 
 func main() {
-	s := ghttp.GetServer()
-	s.EnablePProf()
+	s := g.Server()
+	s.Domain("localhost").EnablePProf()
 	s.BindHandler("/", func(r *ghttp.Request) {
 		r.Response.Writeln("哈喽世界！")
 	})

.example/net/ghttp/server/reload/admin.go

@@ -6,12 +6,8 @@ import (
 
 func main() {
 	s := g.Server()
+	s.SetConfigWithMap(g.Map{"Graceful": true})
 	s.EnableAdmin()
-	//s.BindHookHandler("/admin/*any", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
-	//    if !r.BasicAuth("admin", "123", "") {
-	//        r.Exit()
-	//    }
-	//})
 	s.SetPort(8199)
 	s.Run()
 }

.example/net/ghttp/server/resource/resource.go

@@ -18,7 +18,7 @@ func main() {
 	s := g.Server()
 	s.SetIndexFolder(true)
 	s.SetServerRoot("root")
-	s.BindHookHandler("/*", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+	s.BindHookHandler("/*", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 		fmt.Println(r.URL.Path, r.IsFileRequest())
 	})
 	s.BindHandler("/template", func(r *ghttp.Request) {

.example/net/ghttp/server/router/group/batch.go

@@ -27,7 +27,7 @@ func main() {
 	s := g.Server()
 	obj := new(Object)
 	s.Group("/api").Bind([]ghttp.GroupItem{
-		{"ALL", "*", HookHandler, ghttp.HOOK_BEFORE_SERVE},
+		{"ALL", "*", HookHandler, ghttp.HookBeforeServe},
 		{"ALL", "/handler", Handler},
 		{"ALL", "/obj", obj},
 		{"GET", "/obj/show", obj, "Show"},

.example/net/ghttp/server/router/group/level.go

@@ -54,10 +54,10 @@ func main() {
 			})
 		})
 		group.Group("/hook", func(group *ghttp.RouterGroup) {
-			group.Hook("/*", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+			group.Hook("/*", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 				r.Response.Write("hook any")
 			})
-			group.Hook("/:name", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+			group.Hook("/:name", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 				r.Response.Write("hook name")
 			})
 		})

.example/net/ghttp/server/router/router5.go

@@ -9,7 +9,7 @@ import (
 
 func main() {
 	s := g.Server()
-	s.BindHookHandler("/*any", ghttp.HOOK_BEFORE_SERVE, func(r *ghttp.Request) {
+	s.BindHookHandler("/*any", ghttp.HookBeforeServe, func(r *ghttp.Request) {
 		fmt.Println(r.Router)
 		fmt.Println(r.Get("customer_id"))
 	})

.example/os/gfcache/gfcache.go

@@ -1,29 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"time"
-
-	"github.com/gogf/gf/os/gfcache"
-	"github.com/gogf/gf/os/gfile"
-)
-
-func main() {
-	s := 0
-	r := ""
-	path := gfile.TempDir() + gfile.Separator + "temp"
-	gfile.PutContents(path, "hello")
-
-	s = gfcache.GetSize()
-	r = gfcache.GetContents(path)
-	fmt.Println(s, r)
-
-	gfile.PutContentsAppend(path, " john")
-
-	// 等待1秒以便gfsnotify回调能处理完成
-	time.Sleep(time.Second)
-
-	s = gfcache.GetSize()
-	r = gfcache.GetContents(path)
-	fmt.Println(s, r)
-}

.example/os/glog/glog_ctx.go

@@ -0,0 +1,14 @@
+package main
+
+import (
+	"context"
+	"github.com/gogf/gf/os/glog"
+)
+
+func main() {
+	glog.SetCtxKeys("Trace-Id", "Span-Id", "Test")
+	ctx := context.WithValue(context.Background(), "Trace-Id", "1234567890")
+	ctx = context.WithValue(ctx, "Span-Id", "abcdefg")
+
+	glog.Ctx(ctx).Print(1, 2, 3)
+}

.example/os/gmlock/locker4.go

@@ -13,7 +13,7 @@ func main() {
 	key := "key"
 
 	// 第一次锁带时间
-	gmlock.Lock(key, 1000)
+	gmlock.Lock(key)
 	glog.Println("lock1")
 	// 这个时候上一次的计时解锁已失效
 	gmlock.Unlock(key)

.example/os/gview/layout/layout1/main.go

@@ -2,19 +2,18 @@ package main
 
 import (
 	"github.com/gogf/gf/frame/g"
-	"github.com/gogf/gf/frame/gmvc"
+	"github.com/gogf/gf/net/ghttp"
 )
 
-type Controller struct {
-	gmvc.Controller
-}
-
-func (c *Controller) Test() {
-	c.View.Display("layout.html")
-}
 func main() {
 	s := g.Server()
-	s.BindControllerMethod("/", new(Controller), "Test")
+	s.BindHandler("/", func(r *ghttp.Request) {
+		r.Response.WriteTpl("layout.html", g.Map{
+			"header":    "This is header",
+			"container": "This is container",
+			"footer":    "This is footer",
+		})
+	})
 	s.SetPort(8199)
 	s.Run()
 }

.example/os/gview/layout/layout1/template/container.html

@@ -1,3 +1,3 @@
 {{define "container"}}
-<h1>CONTAINER</h1>
+<h1>{{.container}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/footer.html

@@ -1,3 +1,3 @@
 {{define "footer"}}
-<h1>FOOTER</h1>
+<h1>{{.footer}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/header.html

@@ -1,3 +1,3 @@
 {{define "header"}}
-    <h1>HEADER</h1>
+    <h1>{{.header}}</h1>
 {{end}}

.example/os/gview/layout/layout1/template/layout.html

@@ -2,14 +2,14 @@
 <html>
 <head>
     <title>GoFrame Layout</title>
-    {{template "header"}}
+    {{template "header" .}}
 </head>
 <body>
     <div class="container">
-    {{template "container"}}
+    {{template "container" .}}
     </div>
     <div class="footer">
-    {{template "footer"}}
+    {{template "footer" .}}
     </div>
 </body>
 </html>

.example/os/gview/layout/layout2/main.go

@@ -9,11 +9,13 @@ func main() {
 	s := g.Server()
 	s.BindHandler("/main1", func(r *ghttp.Request) {
 		r.Response.WriteTpl("layout.html", g.Map{
+			"name":    "smith",
 			"mainTpl": "main/main1.html",
 		})
 	})
 	s.BindHandler("/main2", func(r *ghttp.Request) {
 		r.Response.WriteTpl("layout.html", g.Map{
+			"name":    "john",
 			"mainTpl": "main/main2.html",
 		})
 	})

.example/other/config.toml

@@ -1,18 +0,0 @@
-
-[database]
-	debug = true
-    link  = "mysql:root:12345678@tcp(127.0.0.1:3306)/test"
-
-[redis]
-    default  = "127.0.0.1:6379,0"
-    cache = "127.0.0.1:6379,1"
-
-# Logger.
-[logger]
-    Path        = "/tmp/log/gf-app"
-    Level       = "all"
-    Stdout      = true
-
-[viewer]
-    delimiters  =  ["${", "}"]
-    autoencode  =  true

.example/other/test.go

@@ -1,5 +0,0 @@
-package main
-
-func main() {
-
-}

.example/other/test2.go

@@ -1,11 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"github.com/gogf/gf/net/ghttp"
-)
-
-func main() {
-	r := ghttp.PostContent("http://127.0.0.1:8199/test", `<doc><id>1</id><name>john</name><password1>123Abc!@#</password1><password2>123Abc!@#</password2></doc>`)
-	fmt.Println(r)
-}

.example/util/grand/grand.go

@@ -8,6 +8,9 @@ import (
 
 func main() {
 	for i := 0; i < 100; i++ {
-		fmt.Println(grand.Rand(0, 99999))
+		fmt.Println(grand.S(16))
+	}
+	for i := 0; i < 100; i++ {
+		fmt.Println(grand.N(0, 99999999))
 	}
 }

.example/util/guid/guid.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"github.com/gogf/gf/util/guid"
+)
+
+func main() {
+	for i := 0; i < 100; i++ {
+		s := guid.S()
+		fmt.Println(s, len(s))
+	}
+}

.example/util/guid/guid_length.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+)
+
+func main() {
+	// 36*36^2+36*36+36
+	var s string
+	fmt.Println(strconv.ParseUint("zzz", 36, 3))
+	fmt.Println(1 << 1)
+	// MaxInt64
+	s = strconv.FormatUint(math.MaxUint64, 16)
+	fmt.Println(s, len(s))
+	// PID
+	s = strconv.FormatInt(1000000, 36)
+	fmt.Println(s, len(s))
+}

.example/util/guid/guid_unique.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"github.com/gogf/gf/util/guid"
+)
+
+func main() {
+	for i := 0; i < 100; i++ {
+		s := guid.S([]byte("123"))
+		fmt.Println(s, len(s))
+	}
+	fmt.Println()
+	for i := 0; i < 100; i++ {
+		s := guid.S([]byte("123"), []byte("456"))
+		fmt.Println(s, len(s))
+	}
+	fmt.Println()
+	for i := 0; i < 100; i++ {
+		s := guid.S([]byte("123"), []byte("456"), []byte("789"))
+		fmt.Println(s, len(s))
+	}
+}

.example/util/gutil/try_catch.go

@@ -11,7 +11,7 @@ func main() {
 		fmt.Println(1)
 		gutil.Throw("error")
 		fmt.Println(2)
-	}, func(err interface{}) {
+	}, func(err error) {
 		fmt.Println(err)
 	})
 }

.example/util/gvalid/gvalid_custom_message.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"fmt"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/util/gvalid"
+)
+
+func main() {
+	g.I18n().SetLanguage("cn")
+	err := gvalid.Check("", "required", nil)
+	fmt.Println(err.String())
+}

.example/util/gvalid/i18n/cn.toml

@@ -0,0 +1,14 @@
+
+
+"gf.gvalid.required" = "字段不能为空"
+
+
+
+
+
+
+
+
+
+
+

.gitignore

@@ -6,7 +6,7 @@
 .idea/
 .settings/
 .vscode/
-vender/
+vendor/
 composer.lock
 gitpush.sh
 pkg/
@@ -15,3 +15,4 @@ cbuild
 **/.DS_Store
 .vscode/
 go.sum
+.example/other/

.travis.yml

@@ -1,8 +1,11 @@
 language: go
 
 go:
+  - "1.11.x"
+  - "1.12.x"
   - "1.13.x"
   - "1.14.x"
+  - "1.15.x"
 
 branches:
   only:

DONATOR.MD

@@ -1,78 +0,0 @@
-# Donators
-
-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 
-|---|---|--- | ---
-|[hailaz](https://gitee.com/hailaz)|gitee|￥20.00 | 
-|[ireadx](https://github.com/ireadx)|alipay|￥301.00 |
-|[mg91](https://gitee.com/mg91)|gitee|￥10.00 |
-|[pibigstar](https://github.com/pibigstar)|alipay|￥10.00 |
-|[tiangenglan](https://gitee.com/tiangenglan)|gitee|￥30.00 |
-|[wxkj](https://gitee.com/wxkj)|wechat|￥10.00 |
-|[zhuhuan12](https://gitee.com/zhuhuan12)|gitee|￥50.00 |
-|[zfan_codes](https://gitee.com/zfan_codes)|gitee|￥10.00 |
-|[arden](https://github.com/arden)|alipay|￥10.00 |
-|[macnie](https://www.macnie.com)|wechat|￥110.00 |
-|lah|wechat|￥100.00 |
-|x*z|wechat|￥20.00 |
-|潘兄|wechat|￥100.00 |
-|Fly的狐狸|wechat|￥100.00 |
-|全|alipay|￥100.00 |
-|东东|wechat|￥100.00 |
-|严宇轩|alipay|￥99.99 |
-|土豆相公|alipay|￥66.60 |
-|Hades|alipay|￥66.66 |
-|蔡蔡|wechat|￥666.00 | gf越来越强
-|上海金保证网络科技|bank|￥2000.00 |
-|[foxhack](https://github.com/foxhack)|wechat|￥20.00 |
-|*栈|wechat|￥5.00 |
-|*络|wechat|￥10.00|
-|M*e|wechat|￥20.00|
-|*G|wechat|￥10.00|
-|E*_|wechat|￥10.00|
-|A*y|wechat|￥1.00| 感谢大佬goframe
-|K*e|wechat|￥168.00| 感谢老大
-|*雨|wechat|￥100.00|
-|*洁|wechat|￥10.00|赞助你肥宅快乐水
-|R*s|wechat|￥18.88| 谢谢GF！辛苦了！
-|粟*e|wechat|￥50.00|
-|[李超](https://github.com/effortlee)|wechat|￥124.00| 
-|soidea666|wechat+qq|￥800.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越来越好，框架很牛逼！
-|陆昱天|alipay|￥100.00|
-|[Dockercore](https://github.com/dockercore)|wechat|￥200.00| 非常喜欢！简洁好用！文档超级全！
-|🚶|wechat|￥6.88| 喝杯冰阔落
-|a*l|wechat|￥10.00| gf
-|[wxkj](https://gitee.com/wxkj)|wechat|￥10.00| 
-|*包|wechat|￥9.99| 
-|重庆宝尔威科技|wechat|￥6.66| 
-|琦玉-QPT|wechat|￥6.66| 
-|sailsea|wechat|￥11.00| 
-|[seny0929](https://gitee.com/seny0929)|wechat|￥99.90| 
-|*华|wechat|￥6.66| 感谢郭强的热心
-|[Playhi](https://github.com/Playhi)|alipay|￥10.00| 
-|北京京纬互动科技|alipay|￥200.00| 
-|米司特包|wechat|￥99.99| 
-|金毛|alipay|￥100.00| 
-|1*1x|wechat|￥100.00| 
-|[ywanbing](https://github.com/ywanbing)|wechat|￥66.66| 
-|[侯哥](http://www.macnie.com)|wechat|￥10.00| 
-|如果🍋|alipay|￥100.00| 错过的奶茶^_^
-|蔡蔡|wechat|￥666.00| gf真强大，让项目省心
-|jack|wechat|￥100.00| 
-|sbilly|wechat|￥100.00| 祝好！
-
-
-<img src="https://goframe.org/images/donate.png"/>

README.MD

@@ -9,12 +9,13 @@
 
 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, such as: 
+`GF(GoFrame)` is a modular, powerful, high-performance and enterprise-class application development framework 
+of Golang. Providing a series of core components and dozens of practical modules, such as: 
 cache, logging, containers, timer, resource, validator, database orm, etc. 
 Supporting web server integrated with router, cookie, session, middleware, logger, configure, 
 template, https, hooks, rewrites and many more features. 
 
+> If you're a newbie to `Go`, you may consider `GoFrame` easy and great as `Laravel` in `PHP`, `SpringBoot` in `Java` or `Django` in `Python`.
 
 # Installation
 ```
@@ -27,9 +28,29 @@ require github.com/gogf/gf latest
 
 # Limitation
 ```
-golang version >= 1.13
+golang version >= 1.11
 ```
 
+# Architecture
+<div align=center>
+<img src="https://itician.org/download/attachments/1114119/arch.png?version=1&modificationDate=1608537397031&api=v2"/>
+</div>
+
+# Packages
+1. **Primary Package**
+
+    The `gf` repository maintains some basic and most commonly used packages, keeping it as lightweight and simple as possible. 
+
+1. **Community Package**
+
+    The community packages are contributed and maintained by community members, which are hosted in `gogf` organization. Some of the community packages are separated from the `gf` repository, which are not of common usage or are with heavy dependencies. 
+
+# Performance
+
+The `Web` component performance of `GoFrame`, please refer to third-party project: https://github.com/the-benchmarker/web-frameworks
+
+
+
 # Documentation
 
 * 中文官网: https://goframe.org
@@ -43,30 +64,45 @@ golang version >= 1.13
 
 > 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=11"/>
-</div>
-
-
 # License
 
 `GF` is licensed under the [MIT License](LICENSE), 100% free and open-source, forever.
 
+# Part Of Users
+
+- [Tencent](https://www.tencent.com/)
+- [ZTE](https://www.zte.com.cn/china/)
+- [Ant Financial Services](https://www.antfin.com/)
+- [MedLinker](https://www.medlinker.com/)
+- [KuCoin](https://www.kucoin.io/)
+- [LeYouJia](https://www.leyoujia.com/)
+- [IGG](https://igg.com)
+- [XiMaLaYa](https://www.ximalaya.com)
+- [ZYBang](https://www.zybang.com/)
+
+> We list part of the users here, if your company or products are using `GoFrame`, please let us know [here](https://github.com/gogf/gf/issues/168).
+
+
 # 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)?
+If you love `GF`, why not [buy developer a cup of coffee](https://itician.org/pages/viewpage.action?pageId=1115633)?
 
 # 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>
+<a href="https://www.jetbrains.com/?from=GoFrame"><img src="https://itician.org/download/thumbnails/1114119/jetbrains.png?version=1&modificationDate=1608649325806&api=v2" height="120" alt="JetBrains"/></a>
+<a href="https://www.atlassian.com/?from=GoFrame"><img src="https://itician.org/download/thumbnails/1114119/u%3D605052180%2C3099422872%26fm%3D11%26gp%3D0.jpg?version=1&modificationDate=1608649343601&api=v2" height="120" alt="Atlassian"/></a>
+
+
+
 
 
 

README_ZH.MD

@@ -8,23 +8,24 @@
 
 [English](README.MD) | 简体中文
 
-`GF(Go Frame)`是一款模块化、高性能、生产级的Go基础开发框架。
+`GF(Go Frame)`是一款模块化、高性能、企业级的Go基础开发框架。
 实现了比较完善的基础设施建设以及开发工具链，提供了常用的基础开发模块，
 如：缓存、日志、队列、数组、集合、容器、定时器、命令行、内存锁、对象池、
 配置管理、资源管理、数据校验、数据编码、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信等等。
 并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、Middleware、服务注册、模板引擎等等，
 支持热重启、热更新、域名绑定、TLS/HTTPS、Rewrite等特性。
 
+> 如果您初识`Go`语言，您可以将`GoFrame`类似于`PHP`中的`Laravel`, `Java`中的`SpringBoot`或者`Python`中的`Django`。
 
 # 特点
 * 模块化、松耦合设计；
-* 模块丰富，开箱即用；
-* 简便易用，易于维护；
-* 社区活跃，大牛谦逊低调脾气好；
+* 模块丰富、开箱即用；
+* 简便易用、易于维护；
 * 高代码质量、高单元测试覆盖率；
+* 社区活跃，大牛谦逊低调脾气好；
 * 详尽的开发文档及示例；
 * 完善的本地中文化支持；
-* 更适合企业及团队使用；
+* 设计为团队及企业使用；
 
 # 地址
 - **主库**：https://github.com/gogf/gf 
@@ -41,15 +42,29 @@ require github.com/gogf/gf latest
 
 # 限制
 ```shell
-golang版本 >= 1.13
+golang版本 >= 1.11
 ```
 
+
+
 # 架构
 <div align=center>
-<img src="https://goframe.org/images/arch.png?v=11"/>
+<img src="https://itician.org/download/attachments/1114119/arch.png?version=1&modificationDate=1608537397031&api=v2"/>
 </div>
 
+# 模块
 
+1. **核心模块**
+
+    `GoFrame`提供了一些基础的、常用的模块，简单、易用和轻量级，并保持极少的外部依赖，这些模块由`gf`主仓库细致维护。
+
+1. **社区模块**
+
+    社区模块主要由社区贡献并维护，大部分也是由`gf`主仓库的贡献者提供及维护，存放于`gogf`空间下，与`gf`主仓库处于同一级别。有的社区模块是从`gf`主仓库中剥离出来单独维护的模块，这些模块并不是特别常用，或者对外部依赖较重。
+
+
+# 性能
+大家较为感兴趣的`Web`组件性能测试，请参考第三方性能测试评估：https://github.com/the-benchmarker/web-frameworks
 
 # 文档
 
@@ -62,12 +77,26 @@ golang版本 >= 1.13
 - WX交流群：微信添加`389961817`备注`GF`
 - 主库ISSUE：https://github.com/gogf/gf/issues
 
-> 建议通过阅读`Gorame`的源码以及API文档深度学习`GoFrame`，了解更多的精妙设计。
+> 建议通过阅读`GoFrame`的源码以及API文档深度学习`GoFrame`，了解更多的精妙设计。
 
 # 协议
 
 `GF` 使用非常友好的 [MIT](LICENSE) 开源协议进行发布，永久`100%`开源免费。
 
+# 用户
+
+- [腾讯科技](https://www.tencent.com/)
+- [中兴科技](https://www.zte.com.cn/china/)
+- [蚂蚁金服](https://www.antfin.com/)
+- [医联科技](https://www.medlinker.com/)
+- [库币科技](https://www.kucoin.io/)
+- [乐有家](https://www.leyoujia.com/)
+- [IGG](https://igg.com)
+- [喜马拉雅](https://www.ximalaya.com)
+- [作业帮](https://www.zybang.com/)
+
+> 在这里只列举了部分知名的用户，如果您的企业或者产品正在使用`GoFrame`，欢迎到 [这里](https://github.com/gogf/gf/issues/168) 留言。
+
 # 贡献
 
 感谢所有参与`GoFrame`开发的贡献者。 [[贡献者列表](https://github.com/gogf/gf/graphs/contributors)].
@@ -76,7 +105,7 @@ golang版本 >= 1.13
 
 # 捐赠
 
-如果您喜欢`GF`，要不[给开发者来杯咖啡吧](DONATOR.MD)！
+如果您喜欢`GF`，要不给开发者 [来杯咖啡](https://itician.org/pages/viewpage.action?pageId=1115633) 吧！
 请在捐赠时备注您的`github`/`gitee`账号名称。
 
 # 赞助
@@ -84,4 +113,5 @@ golang版本 >= 1.13
 赞助支持`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>
+<a href="https://www.jetbrains.com/?from=GoFrame"><img src="https://itician.org/download/thumbnails/1114119/jetbrains.png?version=1&modificationDate=1608649325806&api=v2" height="120" alt="JetBrains"/></a>
+<a href="https://www.atlassian.com/?from=GoFrame"><img src="https://itician.org/download/thumbnails/1114119/u%3D605052180%2C3099422872%26fm%3D11%26gp%3D0.jpg?version=1&modificationDate=1608649343601&api=v2" height="120" alt="Atlassian"/></a>

RELEASE.1.MD

@@ -1,566 +0,0 @@
-# `v1.8.0` (2019-07-15)
-
-## 新功能改进
-1. 框架目前 `69` 个开发模块（不包括内部模块），原生代码 `65302` 行（不包含第三包依赖包），单元测试覆盖率达到`77%`；
-1. 新增`gerror`错误处理模块：https://goframe.org/errors/gerror/index
-1. 改进`gcharset`字符编码转换模块，支持更多的字符集：https://goframe.org/encoding/gcharset/index
-1. 新增`gmutex`模块，基于`channel`实现的高级互斥锁模块，支持更丰富的互斥锁特性：https://goframe.org/os/gmutex/index
-1. 改进`glog`日志模块：
-    - 新增日志异步输出特性：https://goframe.org/os/glog/async
-    - 新增`Flags`额外功能特性：https://goframe.org/os/glog/flags
-    - 新增`Json`数据格式输出：https://goframe.org/os/glog/json
-    - 新增自定义`Writer`接口特性：https://goframe.org/os/glog/writer
-    - **修改`Backtrace`名称为`Stack`，并改进调用堆栈输出格式；**
-    - 新增`Expose`方法暴露内部默认`Logger`对象；
-1. 改进`gdb`数据库ORM模块：
-    - **改进错误处理，当数据库操作没有查询到数据时，`error`返回`sql.ErrNoRows`**：https://goframe.org/database/gdb/error
-    - 改进`Update`/`Delete`方法支持`Order BY`及`LIMIT`特性；
-    - 数据库链式操作及方法操作中，预处理变量参数支持`slice`参数：https://goframe.org/database/gdb/chaining/model
-    - **修改`Priority`权重配置名称为`Weight`；**
-    - 新增`Debug`配置，可配置开启/关闭调试特性：https://goframe.org/database/gdb/config
-    - 新增`Offset`方法，该方法为可选链式操作方法，`pgsql`数据库可直接通过`Limit`方法第二个参数自动识别为`Offset`语法；
-    - 改进数据库动态切换特性，支持不同数据库类型的当前操作数据库切换；
-    - 改进简化配置文件结构：https://goframe.org/database/gdb/config
-1. 改进`gconv`数据转换模块：
-    - 对结构体对象转换时支持更多的标签：`gconv/c/json`；
-    - 支持`*struct/[]struct/[]*struct`自动初始化创建对象/数组：https://goframe.org/util/gconv/struct
-    - 新增`Strusts/StrctsDeep`方法，用于结构体数组的递归转换；
-    - 新增`StructDeep`方法，用于对结构体对象的递归转换；
-    - 新增`MapDeep`方法，用于对结构体属性的递归转换；
-1. 改进`ghttp`模块：
-    - 改进`ghttp`模块的分组路由功能，完善逻辑处理细节，程序更加稳健；
-    - 改进`ghttp.Request.Get*ToStruct`方法，支持`params/param/p`标签，支持结构体递归转换，并且支持`**struct`参数的对象自动初始化；
-    - 改进`ghttp.CORSDefault`的跨域设置参数，`AllowOrigin`参数调整为`*`；
-1. 改进`gvalid`数据校验模块：
-    - 增加对校验标签`gvalid/valid/v`的支持；
-    - 改进`CheckStruct`支持对结构体对象的递归校验：https://goframe.org/util/gvalid/checkstruct
-1. 改进`gtcp`TCP通信模块：
-    - 改进通信包协议设计，更加轻量级高效：https://goframe.org/net/gtcp/conn/pkg
-    - 改进`TCP Server`增加对`TLS`的支持：https://goframe.org/net/gtcp/tls
-    - 增加`Server.Cloce`服务端关闭方法；
-1. 改进`gproc`模块的通信数据结构，并使用`gtcp`的轻量级包协议重构消息发送逻辑；
-1. 改进`gqueue`模块增加数据同步缓冲机制，解决大数据量下的内存占用及延迟问题；
-1. 改进`gmlock`模块，使用`gmutex`模块替换内部的互斥锁，增加更多的操作方法；
-1. 改进`gaes`加密模块，增加`CBC`模式的加密/解密方法：
-1. 改进`garray.Range/SubSlice`方法，改进设计，提高性能；
-1. 改进`gjson`/`gparser`模块实现`MarshalJSON`接口以实现自定义的`JSON`数据格式转换；
-1. **改进`crypto`分类下模块的方法返回值，增加`error`错误变量返回，以保证更严谨的接口设计风格；**
-1. **改进`gbase64`模块，输入输出类型发生改变，并增加多个相关方法；**
-1. 改进`gflock`修改方法名`UnLock`为`Unlock`，新增`IsRLocked`方法；
-1. 新增`gfile.CopyFile/CopyDir`方法，用于文件及目录的复制；
-1. 改进`gjson/gparser/gvar/gcfg`模块增加更多的类型转换方法；
-1. 改进`gcache`模块，过期时间参数支持`time.Duration`类型；
-1. 新增`internal/structs`包，强大且便捷的结构体解析，并改进框架中所有涉及到结构体反射处理的模块；
-1. 改进`gbinary`增加封装方法对`BigEndian`的支持；
-
-## Bug Fix
-1. 修复`garray.Search`返回值问题；
-1. 修复`garray.Contains`, `garray.New*ArrayFromCopy`方法逻辑问题；
-1. 修复`gjson.Remove`删除`slice`参数问题；
-1. 修复`gtree.AVLTree.Remove`方法返回值问题；
-1. 修复`gqueue.Size`不准确的大小问题；
-1. 修复`queue.Close`问题；
-1. 修复`gcache.GetOrSetLockFunc`当回调函数返回`nil`结果时的死锁问题；
-1. 修复`gfsnotify.Add`方法默认递归监控添加失效问题；
-1. 修复`gdb.Model.Scan`在某些参数类型下的失效问题；
-
-## 注意事项
-
-请注意以上粗体文字部分，如有使用，在您升级时可能会出现不兼容性。
-
-
-
-# `v1.7.0` (2019-06-10)
-## 新功能/改进
-1. 重构改进`glog`模块：
-    - 去掉日志模块所有的锁机制，改为无锁设计，执行性能更加高效
-    - 增加日志内容的异步输出特性：https://goframe.org/os/glog/async
-    - 增加日志输出内容的`Json`格式支持：https://goframe.org/os/glog/json
-    - 增加`Flags`额外特性支持，包括文件行号打印、自定义时间格式、异步输出等特性控制：https://goframe.org/os/glog/flags
-    - 增加`Writer`接口支持，便于开发者进行自定义的日志功能扩展，或者与第三方服务/模块对接集成：https://goframe.org/os/glog/writer
-    - 修改`SetStdPrint`方法名为`SetStdoutPrint`
-    - 修改链式方法`StdPrint`方法名为`Stdout`
-    - 标记淘汰`*fln`日志输出方法，`*f`方法支持自动的换行输出
-    - 新增更多的链式方法支持：https://goframe.org/os/glog/chain
-1. 重构改进`gmap`模块：
-    - 增加更多数据格式支持：`HashMap`/`ListMap`/`TreeMap`
-    - 简化类型名称，如`gmap.StringInterfaceMap`简化为`gmap.StrAnyMap`
-    - 改进`Map/Keys/Values`方法以提高性能
-    - 修改`BatchSet`/`BatchRemove`方法名为`Sets`/`Removes`
-    - 新增更多功能方法支持：https://goframe.org/container/gmap/index
-1. 改进`gtime`时间模块：
-    - 增加并完善更多的类`PHP`时间格式支持
-    - 新增更多功能方法，如`FormatTo`/`LayoutTo`等等
-    - 详见开发文档：https://goframe.org/os/gtime/index
-1. 改进`gdb`数据库模块：
-    - 增加对继承结构体的数据转换支持：https://goframe.org/database/gdb/senior
-    - 新增`GetLastSql`方法，用以在调试模式下获取最近一条执行的SQL语句
-    - 其他的细节处理改进
-1. 改进`gtcp`通信模块：
-    - 完善处理细节，提高通信性能；
-    - 增加`TLS`服务端/客户端通信支持：https://goframe.org/net/gtcp/tls
-    - 增加简单协议支持，便于开发者封包/解包，并解决粘包/半包问题：https://goframe.org/net/gtcp/conn/pkg
-    - TCP服务端增加`Close`方法
-    - 更多细节查看开发文档：https://goframe.org/net/gtcp/index
-1. 改进`gconv`类型转换模块
-    - 修改`gconv.TimeDuration`转换方法名称为`gconv.Duration`
-    - 新增`gconv.StructDeep`及`gconv.MapDeep`方法，支持递归转换
-    - 详见开发文档：https://goframe.org/util/gconv/struct
-1. 改进`ghttp`模块：
-    - 日志输出增加`http/https`字段：https://goframe.org/net/ghttp/logs
-    - 新增`ghttp.Server.SetKeepAlive`设置方法，用以开启/关闭`KeepAlive`特性
-    - 增加`ghttp.Request.GetUrl`方法，用以获取当前完整的URL请求地址
-    - `ghttp.Client`客户端支持开发者自定义`Transport`属性，`ghttp.Client.Post`方法支持`浏览器模式`：https://goframe.org/net/ghttp/client
-1. 新增`gtree`树形数据结构容器支持：https://goframe.org/container/gtree/index
-1. 改进`gudp`通信模块，具体请参考开发文档：https://goframe.org/net/gudp/index
-1. 改进`gcfg`配置管理模块，所有`Get*`方法增加默认值支持：https://goframe.org/os/gcfg/index
-1. `gredis`模块新增`DoVar`/`ReceiveVar`方法以便于开发者对执行结果进行灵活的数据格式转换：https://goframe.org/database/gredis/index
-1. `gcache`模块`BatchSet`/`BatchRemove`方法名修改为`Sets`/`Removes`
-1. 改进`gjson`/`gparser`模块，增加更多方法：https://goframe.org/encoding/gjson/index
-1. 改进`gfile.MainPkgPath`方法，以支持不同平台的开发环境；
-1. 改进`grpool`协程池模块，提高执行性能：https://goframe.org/os/grpool/index
-1. 改进`TryCatch`方法，当开发者不传递`Catch`参数时，默认抑制并忽略错误的处理
-1. 改进`gmlock`模块，增加`TryLockFunc`/`TryRLockFunc`方法，并且为`gmlock.Mutex`高级互斥锁对象增加`TryLockFunc`/`TryRLockFunc`方法
-1. 去除`gvar.VarRead`接口类型支持
-
-## Bug Fix
-1. 解决`gdb`模块与其他第三方`ORM`模块同时使用的冲突；
-1. 修复`gcron.AddOnce`方法的细节逻辑问题；
-1. 修复内部`empty`模块的`IsEmpty`方法对结构体属性的空校验错误；
-1. 修复`gview`模板引擎的并发安全问题；
-1. 修复`ghttp.Server`的SESSION初始化过期时间问题；
-
-# `v1.6.0` (2019-04-09)
-
-## 新功能/改进
-1. `gcron`定时任务模块增加运行日志记录功能：https://goframe.org/os/gcron/index
-1. `gredis`增加全局分组配置功能，并增加更多的配置选项`maxIdle/maxActive/idleTimeout/maxConnLifetime`：https://goframe.org/database/gredis/index
-1. `gcfg`模块增加更多的默认配置文件检索路径，并且增加全局分组配置特性，增加`Instance`单例方法：https://goframe.org/os/gcfg/index
-1. `gview`模块增加更多的默认配置文件检索路径，并且增加`Instance`单例方法：https://goframe.org/os/gview/index
-1. `ghttp`模块新功能及改进：
-    - 新增`CORS`HTTP(S)跨域请求特性: https://goframe.org/net/ghttp/cors
-    - 增加`TLSConfig`配置功能；
-    - 去掉路由注册方法的`error`返回值，当产生注册错误时直接终端打印错误/输出到日志文件；
-    - 增加在`HTTP Code 302`跳转时的`Set-Cookie`支持；
-    - 增加对`SESSION ID`的安全性检查；
-    - 增加对基于`HTTPS`的`WebSocket`支持（`WSS`）：https://goframe.org/net/ghttp/websocket/index
-    - `Request`对象增加`Error`方法，用于输出自定义错误信息到`WebServer`错误日志中；
-    - 其他一些改进；
-1. `gdb`模块新功能及改进：
-    - 新增`Instance`单例管理方法；
-    - 新增`Structs/Scan`链式操作方法，`gdb.DB/TX`新增`GetStructs/GetScan`方法，用于结果集`struct`/`slice`映射转换：https://goframe.org/database/gdb/chaining
-    - 新增`Safe`链式操作方法（默认非并发安全），用于链式安全控制：https://goframe.org/database/gdb/chaining
-    - `Where`链式操作方法改进：
-        - 方法支持任意的`string/map/slice/struct/*struct`类型；
-        - 逻辑调整，当链式操作中存在多个`Where`方法调用时，自动转换为`And`条件；
-        - 支持`slice`条件参数，常用在`SELECT IN`查询中，例如：`Where("uid IN(?)", g.Slice{1,2,3})`；
-        - 支持在`map`类型条件参数的`key`中传递条件，例如：`Where(g.Map{"uid>?", uid})`；
-1. `gconv`及`gvalid`模块改进并去掉对私有`struct`方法属性的转换/校验；
-1. `gconv.Map`转换方法新增对`json tag`: `-`, `omitempty`的支持: https://goframe.org/util/gconv/map
-1. `gstr`模块新增 `ReplaceI/ReplaceIByArray/ReplaceIByMap`大小写非敏感替换方法；
-1. `gutil`模块增加`IsEmpty`方法，用于判断给定变量是否为空（整型0, 布尔false, slice/map长度为0, 其他为nil的情况，判断为空），并增加快捷方法`g.IsEmpty`；
-1. `gutil`模块增加`Export`方法，用于导出返回格式化打印的变量内容字符串，并增加快捷方法`g.Export`；
-1. `gspath`增加缓存及非缓存检索检索方法`Search`/`SearchWithCache`；
-1. `gjson`模块增加默认的`UseNumber`功能支持；
-1. `gmap`增加`SetIfNotExistFunc/SetIfNotExistFuncLock`方法；
-1. 迁移`greuseport`模块到新的仓库：https://github.com/gogf/greuseport
-1. 大量的单元测试完善；
-
-## Bug Fix
-1. 修复`gqueue`模块的资源竞争问题；
-1. 修复`gconv.GTime`转换失败问题；
-1. 修复`gconv.String`在转换`int`参数时字节溢出问题；
-1. 修复`ghttp.Request`的`HTTP Basic Auth`校验问题；
-1. 修复`gxml`针对于非`UTF-8`编码内容转换的并发安全问题；
-1. 修复`gtime`部分`Format`（`G`&`j`）格式失效问题；
-1. 修复`gudp.Conn`对象的`RemoteAddr`获取客户端连接地址方法问题；
-1. 修复`gmap/gcache`模块的`GetOrSetFuncLock`方法，增加对回调方法返回值的`nil`判断，只有非nil返回值才会被保存；
-
-
-
-# `v1.5.8` (2019-02-28)
-
-## 新特性
-1. 主库从`gitee`迁移到了`github`( https://github.com/gogf/gf )，`gitee`作为镜像站，用于国内的代码贡献及ISSUE提交，迁移说明详见：https://goframe.org/upgradeto150
-1. 对常用的`container`数组模块: `garray`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/container/garray
-1. 对常用的`container`集合模块: `gset`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/container/gset
-1. 对常用的`container`MAP模块: `gmap`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/container/gmap
-1. 对常用的字符串模块: `gstr`做了大量改进/完善工作，新增大量常用方法，并完善单元测试用例及方法注释，详见API文档：https://godoc.org/github.com/gogf/gf/text/gstr
-1. 改进`gform`中对`struct`/`*struct`参数的支持，`*Insert/*Save/*Replace/*Update/Where/Data`方法的参数调整为`interface{}`类型，并支持任意类型的: `string/map/slice/struct/*struct`参数传递，具体请参考：https://goframe.org/database/orm/chaining
-1. 新增/完善若干模块的单元测试用例, 包括：`gvalid`/`gregex`/`garray`/`gset`/`gmap`/`gstr`/`gconv`/`ghttp`/`gdb`；
-1. 由于`gkafka`模块比较重，且不是框架核心模块，因此将该模块迁移到新的仓库中独立管理，并去掉相关依赖包：https://github.com/gogf/gkafka
-1. 新增`greuseport`模块，用以实现TCP的`REUSEPORT`特性：https://godoc.org/github.com/gogf/gf/net/greuseport
-
-## 新功能/改进
-1. 去掉模板引擎内置变量中自动初始化`session`对象带来的内存占用问题；
-1. `ghttp.Client`改进，增加若干方法，详见：https://goframe.org/net/ghttp/client 
-1. `ghttp`分组路由增加`COMMON`方法，用以注册常用的`HTTP METHOD`(`GET/PUT/POST/DELETE`)路由；
-1. 更新框架依赖的`golang.org/x/sys`模块；
-1. 改进`gform`的批量操作(`Batch*`操作)返回结果对象，可以通过该结果对象获得批量操作准确的受影响记录行数；
-1. 将`gstr`/`gregex`模块从`util`分类迁移到了`text`分类目录下；
-1. 将`gtest`模块从`util`分类迁移到了`test`分类目录下；
-1. 完善`glog`方法注释；
-
-## Bug Fix
-1. 修复带点的邮件格式,用`gvalid.Check`的"`email`"规则不能匹配成功;
-1. 修复`gvalid.Check`在`regex`规则下的检查失败问题；
-1. 修复`gcron`模块定时规则中天和周不允许`?`符号的问题；
-1. 修复`ghttp.Server`在部分异常情况下仍然返回`200`状态码的问题；
-1. 修复`gfpool`模块中由于原子操作问题造成的高并发"内存泄露"问题；
-1. 修复分组路由注册对象/控制时，方法`Index`的路由仅能通过`/xxx/index`访问的问题；
-1. 修复模板引擎使用中，当不存在`config.toml`(即使没使用)配置文件时的报错问题；
-1. 其他一些修复；
-
-
-
-# `v1.4.6` (2019-01-24)
-
-## 新特性
-1. 新增并发安全的高性能任务定时器模块`gtimer`, 类似于Java的`Timer`，但是比较于Java的`Timer`更加强大，内部实现采用灵活高效的`分层时间轮`设计，被设计为可管理维护百万级别以上数量的定时任务。`gtimer`为`GF`框架的核心模块之一，单元测试覆盖率达到`93.6%`：[https://goframe.org/os/gtimer/index](https://goframe.org/os/gtimer/index)
-1. 采用任务定时器`gtimer`重构`gcron`定时任务模块，去掉第三方`github.com/robfig/cron`包的使用。`gcron`增加单例模式的定时任务：[https://goframe.org/os/gcron/index#](https://goframe.org/os/gcron/index#)；
-1. `gconv`类型转换模块支持对`struct`结构体中的**指针属性**转换：[https://goframe.org/util/gconv/struct](https://goframe.org/util/gconv/struct)；
-1. `gform`增加对数据库类型的自动识别特性，这一特性在需要将查询结果`json`编码返回时非常有用: [https://goframe.org/database/orm/index](https://goframe.org/database/orm/index)
-1. `Travis CI`增加对`386`架构的自动化测试支持(目前已支持`386`和`amd64`)；
-
-## 新功能
-1. `ghttp`模块新增`Exit`、`ExitAll`、`ExitHook`方法，用于HTTP请求处理流程控制: [https://goframe.org/net/ghttp/service/object](https://goframe.org/net/ghttp/service/object)；
-1. `grand`模块增加`Meet/MeetProb`方法，用于给定概率的随机满足判断，增加别名方法`N/Str/Digits/Letters`；
-1. `gvalid`数据/表单校验模块增加`16X`及`19X`手机号的校验支持；
-
-## 功能改进
-1. `gform`设置默认的数据库连接池`CONN_MAX_LIFE`参数值为`30`秒；
-1. 改进`glist`模块，提高约`20%`左右性能，并增加若干链表操作方法；
-1. 改进`gqueue`模块，提高约`50`左右性能，并增加模块对`select`语法的支持(使用`Queue.C`): [https://goframe.org/container/gqueue/index](https://goframe.org/container/gqueue/index)；
-1. 改进`gmlock`内存锁模块，并完善单元测试用例：[https://goframe.org/os/gmlock/index](https://goframe.org/os/gmlock/index)；
-1. 改进并发安全容器所有的模块，调整并发安全控制非必需参数`safe...bool`为`unsafe...bool`；
-1. 改进`gpool`对象复用模块，支持并发安全；
-1. 更新`gkafka`模块的第三方依赖包；
-1. 完善`ghttp`模块的单元测试用例；
-
-
-## Bug Fix
-1. 修复`gmd5`模块操作文件时的文件指针未关闭问题；
-1. 修复`gcache`缓存项过期删除失效问题；
-1. 其他修复；
-
-# `v1.3.8` (2018-12-26)
-
-## 新特性
-1. 对`gform`完成重构，以提高扩展性，并修复部分细节问题、完善单元测试用例([https://goframe.org/database/orm/index](https://goframe.org/database/orm/index))；
-1. `WebServer`路由注册新增分组路由特性([https://goframe.org/net/ghttp/group](https://goframe.org/net/ghttp/group));
-1. `WebServer`新增`Rewrite`路由重写特性([https://goframe.org/net/ghttp/static](https://goframe.org/net/ghttp/static));
-1. 增加框架运行时对开发环境的自动识别；
-1. 增加了`Travis CI`自动化构建/测试；
-
-## 新功能
-1. 改进`WebServer`静态文件服务功能，增加`SetStaticPath`/`AddStaticPath`方法([https://goframe.org/net/ghttp/static](https://goframe.org/net/ghttp/static))；
-1. `gform`新增`Filter`链式操作方法，用于过滤参数中的非表字段键值对（[https://goframe.org/database/orm/linkop](https://goframe.org/database/orm/linkop)）；
-1. `gcache`新增`Data`方法，用以获取所有的缓存数据项；
-1. `gredis`增加`GetConn`方法获取原生redis连接对象；
-
-## 功能改进
-1. 改进`gform`的`Where`方法，支持`slice`类型的参数，并更方便地支持`in`操作查询（[https://goframe.org/database/orm/linkop](https://goframe.org/database/orm/linkop)）；
-1. 改进`gproc`进程间通信数据结构，将`pid`字段从`16bit`扩展为`24bit`；
-1. 改进`gconv`/`gmap`/`garray`，增加若干操作方法；
-1. 改进`gview`模板引擎中的`date`内置函数，当给定的时间戳为空时打印当前的系统时间；
-1. 改进`gview`模板引擎中，当打印的变量不存在时，显示为空（标准库默认显示为`<no value>`）；
-1. 改进`WebServer`，去掉`HANGUP`的信号监听，避免程序通过`nohup`运行时产生异常退出问题；
-1. 改进`gcache`性能，并完善基准测试；
-
-## Bug Fix
-1. 修复`gcache`在非LRU特性开启时的缓存关闭资源竞争问题，并修复`doSetWithLockCheck`内部方法的返回值问题；
-1. 修复`grand.intn`内部方法在`x86`架构下的随机数位溢出问题；
-1. 修复`gbinary`中`Int`方法针对`[]byte`参数长度自动匹配造成的字节长度溢出问题；
-1. 修复`gjson`由于官方标准库`json`不支持`map[interface{}]*`类型造成的Go变量编码问题；
-1. 修复`garray`中部分方法的数据竞争问题，修复二分查找排序问题；
-1. 修复`ghttp.Request.GetVar`方法获取参数问题；
-1. 修复`gform`的数据库连接池不起作用的问题；
-
-
-
-
-
-# `v1.2.11` (2018-11-26)
-## 新特性
-1. `ORM`新增对`SQLServer`及`Oracle`的支持([https://goframe.org/database/orm/database](https://goframe.org/database/orm/database))；
-1. 完成`gvalid`模块校验结果的顺序特性([https://goframe.org/util/gvalid/checkmap](https://goframe.org/util/gvalid/checkmap));
-1. 改进`ghttp.Request.Exit`，使得调用该方法时立即退出业务执行，开发者无需调用`Exit`方法时再使用`return`返回([https://goframe.org/net/ghttp/service/object](https://goframe.org/net/ghttp/service/object))；
-1. 模板引擎新增若干内置函数:`text/html/htmldecode/url/urldecode/date/compare/substr/strlimit/hidestr/highlight/toupper/tolower/nl2br` ([https://goframe.org/os/gview/funcs](https://goframe.org/os/gview/funcs));
-1. 模板引擎新增内置变量`Config` ([https://goframe.org/os/gview/vars](https://goframe.org/os/gview/vars));
-1. 改进`gconv.Struct`转换默认规则，支持不区分大小写的键名与属性名称匹配；
-1. `gform`配置文件支持`linkinfo`自定义数据库连接字段([https://goframe.org/database/orm/config](https://goframe.org/database/orm/config))；
-1. `gfsnotify`模块增加对特定回调的取消注册功能（[https://goframe.org/os/gfsnotify/index](https://goframe.org/os/gfsnotify/index)）；
-
-
-
-## 新功能
-1. 改进`ghttp.Request`，增加`SetParam/GetParam`请求流程自定义变量设置/获取方法，用于在请求流程中的回调函数共享变量（[https://goframe.org/net/ghttp/request](https://goframe.org/net/ghttp/request)）;
-1. 改进`ghttp.Response`，增加`ServeFileDownload`方法，用于WebServer引导客户端下载文件([https://goframe.org/net/ghttp/response](https://goframe.org/net/ghttp/response));
-1. `gvar`模块新增`gvar.VarRead`只读接口，用于控制对外只暴露数据读取功能；
-1. 增加`g.Throw`抛异常方法，`g.TryCatch`异常捕获方法封装;
-1. 改进`gcron`模块，增加自定义的Cron管理对象，增加`New/Start/Stop`方法;
-
-
-## 功能改进
-1. WebServer添加`RouterCacheExpire`配置参数，用于设置路由检索缓存过期时间；
-1. WebServer允许同一`HOOK`事件被多次绑定注册，先注册的回调函数优先级更高([https://goframe.org/net/ghttp/service/hook](https://goframe.org/net/ghttp/service/hook));
-1. 当前工作目录为系统临时目录时，`gcfg`/`gview`/`ghttp`模块默认不添加工作目录到搜索路径;
-1. 改进`WebSocket`默认支持跨域请求([https://goframe.org/net/ghttp/websocket](https://goframe.org/net/ghttp/websocket));
-1. 改进`gtime.Format`支持中文;
-1. 改进`gfsnotify`，支持编辑器对文件非执行标准编辑时(RENAME+CHMOD)的热更新问题;
-1. 改进`gtype.Set`方法，增加Set原子操作返回旧的变量值;
-1. `gfile.ScanDir`增加支持`pattern`多个文件模式匹配，使用'`,`'符号分隔多个匹配模式;
-1. `gcfg`模块增加获取配置变量为`*gvar.Var`;
-1. `gstr`模块增加对中文截取方法;
-1. 改进`gtime.StrToTime`对常用时间格式匹配模式，新增`gtime.ParseTimeFromContent`方法;
-1. 修改配置管理、模板引擎、调试模式的环境变量名称为大写下划线标准格式;
-1. 改进`grand`模块随机数生成设计，底层使用`crypto/rand`+缓冲区实现高速的随机数生成([https://goframe.org/util/grand/index](https://goframe.org/util/grand/index));
-
-## 问题修复
-1. 修复`gspath`模块在`windows`下搜索失效问题；
-1. 修复`gspath`模块Search时带有indexFiles的检索问题;
-1. bug fix INZS1([https://github.com/gogf/gf/issues/INZS1](https://github.com/gogf/gf/issues/INZS1));
-1. 修复`gproc.ShellRun`在windows下的执行问题;
-
-
-
-
-
-
-# `v1.0.898 stable` (2018-10-24)
-
-## 新特性
-1. `gf-orm`增加`sqlite`数据库类型支持([http://gf.johng.cn/database/orm/database](http://gf.johng.cn/database/orm/database))；
-1. 增加`gkafka`模块，对kafka的客户端程序封装，支持分组消费及指定起始位置等特性，并提供简便易用的API接口([http://gf.johng.cn/database/gkafka/index](http://gf.johng.cn/database/gkafka/index))；
-1. 增加go语言最新版本的`go modules`特性支持；
-1. 增加`gcron`定时任务模块([http://gf.johng.cn/os/gcron/index](http://gf.johng.cn/os/gcron/index))；
-1. `Web Server`增加路由注册项获取/打印特性，所有的路由注册/回调注册一览无余；
-1. 模板引擎增加全局变量管理，并增加多个常用的内置函数及内置变量（[http://gf.johng.cn/os/gview/funcs](http://gf.johng.cn/os/gview/funcs)）；
-1. `gredis`改进为单例操作方式(基于基层连接池特性)，每次操作`redis`服务器时开发者无需显示调用`Close`方法执行关闭（[http://gf.johng.cn/database/gredis/index](http://gf.johng.cn/database/gredis/index)）；
-1. `gf-orm`增加数据库操作自动`Close`特性(基于底层链接池特性)，开发者无需再`defer db.Close()`，并增加`g.DB`数据库对象单例别名（[http://gf.johng.cn/database/orm/linkop](http://gf.johng.cn/database/orm/linkop)）；
-1. 增加`gvar`通用动态变量模块（[http://gf.johng.cn/container/gvar/index](http://gf.johng.cn/container/gvar/index)）；
-1. 数据结构容器增加`并发安全特性开启/关闭功能`，当关闭后和普通的数据结构无异，且在非并发安全模式下性能会得到提高;
-1. 新增`gmlock`内存锁模块（[http://gf.johng.cn/os/gmlock/index](http://gf.johng.cn/os/gmlock/index)）；
-1. 增加`gaes`算法模块（[http://gf.johng.cn/crypto/gaes/index](http://gf.johng.cn/crypto/gaes/index)）；
-1. `gproc`模块增加执行`shell`命令方法（[http://gf.johng.cn/os/gproc/index](http://gf.johng.cn/os/gproc/index)）；
-1. 新增`gfcache`模块，用于带自动缓存更新的文件内容操作（文档待完善）；
-
-## 新功能
-1. `glog`增加链式操作方法，增加日志级别管理控制、分类管理、调试管理功能；
-1. `g.View`增加分组名称设置，支持通过`g.*`对象管理器获取多个命名的单例模板引擎对象；
-1. `glog`增加对文件名称格式的自定义设置，支持`gtime日期格式`；
-1. `gconv`增加`Ints/Uints/Floats/Interfaces`转换方法;
-1. `gjson`增加`Append`方法;
-1. `gparser`增加`NewUnsafe/Append`方法;
-1. `gcache`增加`GetOrSet/GetOrSetFunc/GetOrSetFuncLock`方法；
-1. `gset`增加`LockFunc/RLockFunc`方法;
-1. `ghttp.Response`方法完善，增加`ParseTpl/ParseTplContent/TplContent`方法，`Template`修改为`Tpl`方法;
-1. `ghttp.Request`增加获取用户真实IP判断;
-1. `Session`增加`Contains`方法;
-1. 完善`ghtml`模块，增加多个方法;
-1. `gcache`新增`Contains/SetIfNotExist`方法；
-1. `gvalid`增加`Error`对象，用以管理校验错误信息；
-1. `gvalid`模块增加`struct tag`的校验规则、自定义错误提示信息绑定的支持特性（[http://gf.johng.cn/util/gvalid/index](http://gf.johng.cn/util/gvalid/index)）；
-1. `ghttp`增加输入参数与`struct`的`绑定机制`，并增加对应`params`标签支持（[http://gf.johng.cn/net/ghttp/service/handler](http://gf.johng.cn/net/ghttp/service/handler)）；
-1. `ghttp.Request`增加服务端`BasicAuth`功能(文档待完善)；
-1. `gvalid`增加字段校验别名，用于自定义返回结果字段，并更新WebServer中相关使用的模块；
-1. `gf-orm`链式操作增加`ForPage`方法，调整`Chunks`方法;
-1. `ghttp`对象路由注册增加`Init&Shut`自动回调方法，增加重复路由注册检测功能；
-1. `gfsnotify`增加默认递归`Add/Remove`特性；
-1. `ghttp.Response`增加`ServiceFile`方法；
-1. 其他一些新功能；
-
-## 功能改进
-1. 改进`ghttp.Server`配置管理；
-1. 改进`gcache`底层对象继承关系，改进部分设计细节，提高性能；
-1. 改进`gfpool`文件指针池，修复部分错误，提升性能，并增加基准测试代码；
-1. 改进`gmap`系列并发安全map数据结构，增加多个易用性的方法；
-1. 改进`gconv.Struct`对象转换功能（[http://gf.johng.cn/util/gconv/index](http://gf.johng.cn/util/gconv/index)）；
-1. 改进`grand`随机数生成规则，提供了极高的随机数生成性能，并保证每一次调用随机方法时生成的都是不同的随机数值（[http://gf.johng.cn/util/grand/index](http://gf.johng.cn/util/grand/index)）；
-1. 改进`gfile`文件内容操作方法，增加若干常用的文件内容读取方法；
-1. 改进`gtime`模块，并增加时区转换方法；
-1. 改进`COOKIE`，去掉锁机制；
-1. 改进`SESSION`获取方法，新增多个类型获取方法；
-1. 改进`g.DB/g.Config`单例缓存键名；
-1. 改进`gtcp/gudp`超时错误判断机制;
-1. 改进`gtype`底层统一修改为原子操作;
-1. 改进`gvalid`对`struct`的`string`属性的默认值非必需校验;
-1. 改进`gvalid`在关联规则下的非必需校验；
-1. 改进`gf-orm`在调试模式下日志自动输出功能；
-1. `ghttp.Server/gspath`模块静态文件检索改进;
-1. 优化`ghttp.ServerConfig`配置，增加`struct/method``名称到uri`的转换规则，通过`SetNameToUri`方法进行灵活配置（[http://gf.johng.cn/net/ghttp/service/object](http://gf.johng.cn/net/ghttp/service/object)）；
-1. 改进`*any/:name`路由匹配规则，支持不带名字的`*/:`路由规则;
-1. 修改默认配置文件名称 `config.yml` -> `config.toml`（[http://gf.johng.cn/os/gcfg/index](http://gf.johng.cn/os/gcfg/index)）；
-1. 调整服务注册的`BindControllerMethod`及`BindObjectMethod`逻辑为绑定路由到指定的方法执行；
-1. 改进`garray`二分查找方法，增加安全操作处理；
-1. 改进`gdb.Result/Recorde` `ToXml`方法，增加可选的`rootTag`参数；
-1. 其他一些改进；
-
-## 问题修复
-1. 修复`ghttp.Server`在`windows`下的重启失效问题；
-1. 修复`ghttp.Server`服务注册与回调注册路由重复判断问题；
-1. 修复`garray`排序数组`Add`变参时的死锁问题；
-1. 修复`gfsnotify`默认递归监控整个`gspath.Add`添加的目录的问题;
-1. 修复`ghttp.BindParams`对`@file`文件上传标识符的转义问题；
-1. 修复`ghttp.Server`日志路径丢失问题;
-1. 修复`多WebServer`下的状态检测问题;
-1. 修复`gvalid`模块`min/max`校验问题；
-1. 修复控制器和执行对象服务注册时绑定'/'路由的问题；
-1. 修复`gvalid.CheckStruct`自定义错误提示失效问题；
-1. `ghttp.Server`修复`hook`与`serve`方法的路由影响，并新增跳转方法；
-1. 其他一些修复；
-
-## 其他改动
-1. 去掉`gfile.IsExecutable`方法；
-1. 目录调整，将`加密/解密`相关的包从`encoding`目录迁移到`crypto`目录下；
-1. 增加`gfsnotify/gfcache`调试信息；
-1. `gf-orm`允许写入的键值为`nil`时往数据库中写入`null`;
-1. 统一使用`gview.Params`类型作为模板变量类型；
-1. `gconv.MapToStruct`方法名称修改为`gconv.Struct`；
-1. `ghttp.Server`完善重启及停止的终端提示信息；
-1. 完善`gring`模块，增加`约瑟夫问题`代码作为`gring`示例程序；
-1. 其他一些改动；
-
-
-
-# `v0.99.682 beta` (2018-08-07)
-## 新特性
-    1、新增gdes包，用于DES加密/加密算法处理；
-    2、新增gkafka包，kafka的golang客户端；
-    3、新增gpool对象复用池，比较于标准库的sync.Pool更加灵活强大，可自定义对象的缓存时间、创建方法、销毁方法(http://gf.johng.cn/686654)；
-    4、完成网络通信gtcp/gudp包的重构，并进行了大量的改进工作，新增了详尽的开发文档及示例代码(http://gf.johng.cn/494382)；
-    5、增加gring并发安全环，标准库container/ring包的并发安全版本，并做了易用性的封装(http://gf.johng.cn/686655)；
-    6、gtime包新增了自定义日期格式话的支持，格式化语法类似PHP的date语法(http://gf.johng.cn/494387)；
-    7、gdb增加调试模式特性，使用SetDebug方法实现，在调试模式下可以获取详细的SQL执行记录，增加了详细的开发文档及示例代码(http://gf.johng.cn/702801)；
-    8、gdb增加查询缓存特性，使用Cache方法实现，增加了详细的开发文档及示例代码(http://gf.johng.cn/702801)；
-    9、ghttp.Server路由功能增加字段匹配规则特性，支持如：/order/list/{page}.html 动态路由规则特性(http://gf.johng.cn/702766)；
-    10、gpage分页包增加分页URL规则生成模板特性，内部可使用{.page}变量指定页码位置(http://gf.johng.cn/716438)；
-    11、增加gmap.Map对象，这是gmap.InterfaceInterfaceMap的别名；
-
-## 新功能
-    1、gdb增加MaxIdleConnCount/MaxOpenConnCount/MaxConnLifetime三项配置，并增加SetMaxConnLifetime方法；
-    2、ghttp.Client增加HTTP账号密码设置功能(SetBasicAuth)；
-    3、glog新增对系统换行符号的自适配调整(\n|\r\n)；
-    4、增加glog控制台调试模式打印开关(SetDebug)；
-    5、gcfg增加SetFileName方法设置默认读取的配置文件名称；
-    6、gcfg/gjson/gparser包新增Int8/16/32/64,Uint8/16/32/64方法；
-    7、增加gzip方法的封装(Zip/Unzip)；
-    8、gview增加模板变量分隔符设置方法SetDelimiters；
-    9、ghttp.Response增加Writef、Writefln方法；
-
-## 功能改进
-    1、改进gfilepool文件指针池设计；改进gfile文本内容写入，增加指针池使用
-    2、gdb包增加调试模式特性，并支持在调试模式下获得已执行的SQL列表结果
-    3、改进gproc进程间通信机制，增加进程消息分组特性，并限定队列大小
-    4、gdb结果方法处理增加ToXml/ToJson方法
-    5、gregx包名修改为gregex
-    6、改进gtime.StrToTime方法，新增对常见标准时间日期的自动转换，以及对时区的自动识别支持，并调整gconv,gvalid对该包的引用
-    7、增加对字符集转换的封装，gxml包中使用新增的字符集转换包来做处理
-    8、ghttp.Server.EnableAdmin页面Restart接口支持GET参数newExeFilePath支持
-    9、ghttp.Server平滑重启机制增加可自定义重启可执行文件路径，特别是针对windows系统特别有用(因为windows下不支持可执行文件覆盖更新)
-    10、改进ghttp.Server静态文件检索设计，增加开发环境时的main包源码目录查找机制；改进gcfg/gview的main包源码目录查找机制
-    11、优化gcache设计，LRU特性非默认开启；优化gtype/gcache基准测试脚本；新增gregx基准测试脚本，改进设计，提升性能
-    12、gfile包增加GoRootOfBuild方法，用于获取编译时的GOROOT数值；并改进glog包中backtrace的GOROOT路径过滤处理；
-    13、改进grpool代码质量，并改进对池化goroutine数量的限制设计
-    14、改进gdb.Map/List及g.Map/List的类型定义，改用别名特性以便支持原生类型输入(map/slice)，并修复gdb.Model.Update方法参数处理问题
-    15、调整ghttp包示例代码目录结构，增加ghttp.Client自定义Header方法，ghttp.Cookie增加Map方法用于获得客户端提交的所有cookie值，构造成map返回
-    16、删除gcharset中的getcharset方法
-    17、去掉gmap中常用的基本数据类型转换获取方法
-    18、改进gconv.String方法，当无法使用基本类型进行字符串转换时，使用json.Marshal进行转换
-    19、gvalid.CheckObject方法名称修改为gvalid.CheckStruct
-
-
-## 问题修复
-    1、修正gstr.IsNumeric错误
-    2、修复当xml中encoding字符集为非UTF-8字符集时报错的问题
-    3、修正gconv包float32->float64精度问题
-    4、修复gpage包分页计数问题
-    5、修复gdb批量数据Save错误
-    6、去掉gpool中math.MAXINT64常量的使用，以修复int64到int类型的转换错误，兼容32位系统
-    7、修正ghttp包没有使用Server仍然初始化相关异步goroutine的问题
-
-
-
-
-# `v0.98.503 beta` (2018-05-21)
-## 新特性
-    1、平滑重启特性( http://gf.johng.cn/625833 )；
-    2、gflock文件锁模块( http://gf.johng.cn/626062 )；
-    3、gproc进程管理及通信模块( http://gf.johng.cn/626063 )；
-    4、gpage分页管理模块，强大的动态分页及静态分页功能，并为开发者自定义分页样式提供了极高的灵活度( http://gf.johng.cn/597431 )；
-    5、ghttp.Server增加多端口监听特性，并支持HTTP/HTTPS( http://gf.johng.cn/494366 , http://gf.johng.cn/598802 )；
-    6、增加gspath目录检索包管理工具，支持对多目录下的文件检索特性；
-    7、ghttp包控制器及执行对象注册增加更灵活的动态路由特性，路由规则增加{method}变量支持；
-
-## 新功能
-    1、gutil包增加MapToStruct方法，支持将map数据类型映射为struct对象；
-    2、gconv
-        1)、gconv包增加按照类型名称字符串进行类型转换；
-        2)、gconv包新增Time/TimeDuration类型转换方法；
-    3、ghttp
-        1)、增加Web Server目录安全访问控制机制；
-        2)、ghttp.Server增加自定义状态码回调函数注册处理；
-    4、gdb
-        1)、gdb包增加gdb.GetStruct/gdb.Model.Struct方法，获取查询结果记录自动转换为指定对象；
-        2)、gdb增加Value/Record/Result类型，增加对Value类型的系列类型转换方法；
-        3)、gdb包增加db.GetCount,tx.GetCount,model.Count数量查询方法；
-
-## 功能改进
-    1、改进gredis客户端功能封装；
-    2、改进grand包随机数生成性能；
-    3、grand/gdb/gredis包增加benchmark性能测试脚本；
-    4、改进gjson/gparser包的ToStruct方法实现；
-    5、gdb  ：改进gdb.New获取ORM操作对象性能；
-    6、gcfg ：改进配置文件检索功能；
-    7、gview：模板引擎增加多目录检索功能；
-    8、gfile：增加源码main包目录获取方法MainPkgPath；
-    9、ghttp
-        1)、ghttp.Request增加请求进入和完成时间记录，并增加到默认日志内容中；
-        2)、ghttp.Server事件回调之间支持通过ghttp.Request.Param自定义参数进行流程传参；
-    10、gdb
-        1)、改进gdb.Result与gdb.List, gdb.Record与gdb.Map之间的类型转换，便于业务层数据编码处理(如json/xml)；
-        2)、改进gdb.Tx.GetValue返回值类型；
-        3)、gdb.Model.Data参数支持更加灵活的map参数；
-
-## 问题修复
-    1、ghttp
-        1)、修复ghttp包路由缓存问题；
-        2)、修复服务注册时的控制器及执行对象方法丢失问题；
-    2、gconv
-        1)、修正gconv.Float64方法位大小设置问题；
-        2)、修复gconv.Int64(float64(xxx))问题；
-    2、gdb
-        1)、修复gdb.GetAll针对返回数据列表的for..range...的返回结果slice相同指针问题；
-        2)、修复gdb.Delete方法错误；
-        3)、修复gdb.Model.And/Or方法；
-        4)、修复gdb.Model.Where方法参数处理问题；
-    3、garray：修复garray包Remove方法锁机制问题；
-    4、gtype ：修复gtype.Float32/gtype.Float64对象类型的方法逻辑错误；
-    5、gfsnotify：修复在windows下文件参数中不同文件分隔符引起的热更新机制失效问题；
-    6、修复gvalid包验证问题：如果值为nil，并且不需要require*验证时，其他验证失效。并增加单元测试项，测试通过。
-
-
-
-
-
-# `v0.97.399 beta` (2018-04-23)
-    1、 增加gfsnotify文件监控模块；
-    2、 配置管理模块增加配置文件自动检测更新机制；
-    3、 模板引擎增加对模板文件的自动检测更新机制；
-    4、 改进gconv包基本类型转换功能，提高转换性能；
-    5、 增加gpage分页管理包，支持动态分页、静态分页以及自定义分页样式特性；
-    6、 ghttp.Request增加Exit方法，用以标记服务退出，当在服务执行前调用后，服务将不再执行；
-    7、 ghttp.Response去掉WriteString方法，统一使用Write方法返回数据流，是使用灵活的参数形式；
-    8、 模板引擎增加模板变量暴露接口LockFunc/RLockFunc，以便支持开发者灵活处理模板变量；
-    9、 ghttp.Server增加access & error log功能，并支持开发者自定义日志处理回调函数注册；
-    10、增加gredis包，支持对redis的客户端操作封装，并将gredis.Redis对象加入到gins单例管理器中进行统一配置管理维护；
-    11、gins单例管理器增加对单例对象配置文件的自动检测更新机制，当配置文件在外部发生变更时，自动刷新单例管理器中的单例对象；
-    12、gdb数据库ORM包增加And/Or条件链式方法，并改进Where/Data方法参数灵活性；
-    13、对于新增加的模块，同时也增加了对应的开发文档，并梳理完善了现有的其他模块开发文档；
-    14、修复ISSUE:
-        #IISWI github.com/gogf/gf/issues/IISWI,
-        #IISMY github.com/gogf/gf/issues/IISMY,
-        反馈并跟踪完成第三方依赖mxj包的ISSUE修复(github.com/clbanning/mxj/issues/48)；
-
-
-

RELEASE.2.MD

@@ -1,614 +0,0 @@
-# `v1.12.1` (2020-03-31)
-
-大家好啊！久等啦！
-
-由于自从上次版本的发布以来，越来越多小伙伴加入了`GF`的大家庭，并提供了许多不错的建议和反馈，这次版本对其中大部分反馈进行了处理，包括大部分的改进建议和部分新特性，因此这次的版本发布时隔了两个多月。`GF`非常注重代码质量以及可持续维护性，这次版本也进一步对框架大部分模块的示例、注释和单元测试用例进行了完善，目前单元测试用例数量约为`1991`例，代码覆盖率为`71%`，覆盖了所有模块的绝大部分主要功能。
-
-`GF`框架提供了比较常用、高质量的基础开发模块，轻量级、模块化、高性能，推荐大家阅读框架源码了解更多细节。本次发布有个别的不兼容升级，往往批量替换即可，以下`change log`比较完善，建议升级前仔细阅读。
-
-本次发布即意味下一版本开发计划的开启，欢迎更多小伙伴参与开源贡献：https://github.com/gogf/gf/projects/8
-
-感谢大家支持！Enjoy your `GF`！
-
-
-# GoFrame
-
-`GF(Go Frame)`是一款模块化、高性能、生产级的Go基础开发框架。实现了比较完善的基础设施建设以及开发工具链，提供了常用的基础开发模块，如：缓存、日志、队列、数组、集合、容器、定时器、命令行、内存锁、对象池、配置管理、资源管理、数据校验、数据编码、定时任务、数据库ORM、TCP/UDP组件、进程管理/通信等等。并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、Middleware、服务注册、模板引擎等等，支持热重启、热更新、域名绑定、TLS/HTTPS、Rewrite等特性。
-
-## 特点
-* 模块化、松耦合设计；
-* 模块丰富，开箱即用；
-* 简便易用，易于维护；
-* 社区活跃，大牛谦逊低调脾气好；
-* 高代码质量、高单元测试覆盖率；
-* 详尽的开发文档及示例；
-* 完善的本地中文化支持；
-* 更适合企业及团队使用；
-
-## 地址
-- 官网：https://goframe.org
-- 主库：https://github.com/gogf/gf 
-- 码云：https://gitee.com/johng/gf 
-
-# Change Log
-
-从`GF v1.12`版本开始，框架要求的最低`Golang`运行版本为`v1.13`，由于`Golang`新版本都是向后兼容的，因此推荐大家更新使用`Golang`新版本：https://golang.google.cn/dl/
-
-> 本次版本也新增了`Swagger`的工具及插件支持，另行独立发布。
-
-## `tool chain`
-1. `gen model`命令新增对`pgsql/mssql/sqlite/oracle`的模型生成支持。
-1. `gen model`命令生成模型新增公开包变量`Columns`用于获得表的字段名称。
-
-## `net`
-1. `ghttp`
-    - 注意：从该版本开始，`Server`默认关闭了平滑重启特性。开发者可以通过相应的配置选项打开。
-    - 改进`Client.Get`方法，增加可选的请求参数。
-    - 新增`Client`链式操作方法：`Header`, `HeaderRaw`, `Cookie`, `ContentType`, `ContentJson`, `ContentXml`, `Timeout`, `BasicAuth`, `Ctx`：https://goframe.org/net/ghttp/client/chain
-    - 新增`Request.GetCtx/GetCtxVar/SetCtxVar/Context`上下文变量管理方法，用于请求内部的上下文变量特性：
-        - 自定义变量：https://goframe.org/net/ghttp/request/custom
-        - 上下文变量：https://goframe.org/net/ghttp/request/context
-    - 新增`Request.GetUploadFile/GetUploadFiles`方法，以及`UploadFile`类型，极大简化文件上传处理逻辑：https://goframe.org/net/ghttp/client/demo/upload
-    - 新增`Request.GetPage`方法，用于便捷地获得分页对象：
-        - 基本介绍：https://goframe.org/util/gpage/index
-        - 动态分页：https://goframe.org/util/gpage/dynamic
-        - 静态分页：https://goframe.org/util/gpage/static
-        - Ajax分页：https://goframe.org/util/gpage/ajax
-        - URL模板：https://goframe.org/util/gpage/template
-        - 自定义分页：https://goframe.org/util/gpage/custom
-    - 改进`Response.Redirect*`方法，增加自定义的跳转HTTP状态码参数。
-    - 改进`CORS`特性，完善跨域功能处理，并完全遵守`W3C`关于`OPTIONS`请求方法的规范约定：https://goframe.org/net/ghttp/cors
-    - 模板视图对象增加`Request`内置变量，用于模板获得请求参数。由于`GF`框架的模板引擎采用两级缓存设计，减少`IO`开销的同时提升了执行效率，即使增加了大量的内置变量以及内置方法，经过大规模的性能测试，性能比其他`WebServer`库相同逻辑下高出`50% - 200%`的效率。
-    - 新增`Server`实验性的`Plugin`特性。
-    - 改进`Server`底层路由存储、检索逻辑，优化代码，提升效率。
-    - 改进分组路由注册的源码位置记录功能，当路由注册冲突时能够精准定位及提示重复路由源码位置。
-    - 改进`Server`日志处理。
-    - 完善单元测试。
-
-
-## `database`
-1. `gdb`
-    - 代码重构改进，增加`Driver`驱动接口设计，方便开发者自定义驱动实现。新增`Register`包方法，用于开发者注册自定义的数据库类型驱动：https://goframe.org/database/gdb/driver
-    - 新增`GetArray`接口及实现，用于获取指定字段列的数据，构造成数组返回：https://goframe.org/database/gdb/chaining/select
-    - 新增`InsertIgnore`接口及实现，用于写入时忽略写入冲突，仅对`mysql`数据库类型有效：https://goframe.org/database/gdb/chaining/insert-save
-    - 新增`Schema`接口及实现，用于动态切换并获取指定名称的数据库对象：https://goframe.org/database/gdb/chaining/schema
-    - 新增`FieldsStr/FieldsExStr`模型方法，用于获取表字段，并构造成字符串返回：hhttps://goframe.org/database/gdb/chaining/fields-retrieve
-    - 新增`LockUpdate/LockShared`模型链式操作方法，用于实现悲观锁操作：https://goframe.org/database/gdb/chaining/lock
-    - 改进`Where/Data`方法对更新参数输入方式的支持，提高灵活性：
-        - https://goframe.org/database/gdb/chaining/select
-        - https://goframe.org/database/gdb/chaining/update-delete
-    - 查询结果对象`Result`新增`Array`方法，用于获得指定字段的数值，构造成数组返回：https://goframe.org/database/gdb/result
-    - 改进`OmitEmpty`方法对`Data`输入参数的过滤，当给定的`Data`参数为空时间对象时，将会被过滤。
-    - 增加默认的数据库连接池参数：`MaxIdleConns=10`。
-    - 其他一些改进。
-    - 完善单元测试。
-
-1. `gredis`
-    - 增加/修改默认的数据库连接池参数：`MaxIdle=10`, `IdleTimeout=10s`, `MaxConnLifetime=30s`, `Wait=true`。
-    - 完善单元测试。
-
-## `container`
-1. 所有容器对象新增`UnmarshalValue(interface{}) error`接口方法实现，用于`gconv`转换时根据任意类型变量创建/设置对象内容，`GF`框架的所有容器对象均实现了该接口。
-
-1. `garray`
-    - 新增`RemoveValue`方法，用于根据数值检索并删除元素项。
-    - 新增`FilterNil`方法，用于遍历并删除数组中的`nil`元素项。
-    - 新增`FilterEmpty`方法，用于遍历并删除数组中的空值元素项，空值包括：`0, nil, false, "", len(slice/map/chan) == 0`。
-    - 改进`Set/Fill/InsertBefore/InsertAfter`方法严谨性，将原有的链式操作返回值对象修改为`error`返回值。
-    - 改进`Get/Remove/PopRand/PopLeft/PopRight/Rand`方法严谨性，增加`found`的`bool`返回值，标识当前方法是否有数据返回，当空数组或者操作越界时`found`返回值为`false`。
-    - 改变`Rands`方法原有逻辑，保证按照给定大小返回随机数组。
-    - 完善单元测试。
-
-1. `gpool`
-    - 调整缓存池过期时间参数类型，旧版本为`int`类型表示毫秒，新版本为`time.Duration`类型使得时间控制更灵活。
-    - 内部代码优化，性能改进。
-    - 完善单元测试。
-    - 完善注释。
-
-## `os`
-1. `glog`
-    - 增加`Rotation`日志滚动切分特性，新增按照文件大小或过期时间进行日志切分，并支持切分文件数量限制、对日志文件进行自动压缩、可自定义压缩级别（`1-9`）、支持对切分文件过期时间清理：https://goframe.org/os/glog/rotate
-    - 新增`LevelPrefixes`特性，支持对日志级别的前缀名称进行自定义：https://goframe.org/os/glog/level
-    - 新增`SetLevelStr`方法，并增加按照字符串进行日志级别配置的特性：
-        - https://goframe.org/os/glog/level
-        - https://goframe.org/os/glog/config
-    - 新增`SetDefaultLogger`包方法，用于设置全局默认的`Logger`对象。
-
-1. `gres`
-    1. 改进资源内容编码设计，采用新的压缩算法，减少资源文件大小，例如原本`15MB`的网站静态资源文件（`css/js/html`等），资源文件打包后约为`4MB`左右：https://goframe.org/os/gres/index
-    1. 注意：该改进与旧版本无法兼容，需要重新打包原有的资源文件。
-    1. 完善单元测试。
-
-1. `gcfg`
-    - 去掉配置对象属性的原子并发安全控制，改为普通变量类型。由于配置管理是最常用模块之一，因此确保高效的设计及方法实现。
-    - 单例对象做较大调整：为方便多文件场景下的配置文件调用，简便使用并提高开发效率，因此当给定的单例名称对应的`toml`配置文件在配置目录中存在时，将自动设置该单例对象的默认配置文件为该文件。例如：`g.Cfg("redis")`获取到的单例对象将会默认去检索并设置默认的配置文件为`redis.toml`，当该文件不存在时，则使用默认的配置文件（`config.toml`）：https://goframe.org/net/ghttp/config
-    - 完善单元测试。
-
-1. `gview`
-    - 新增`concat`内置字符串拼接方法：https://goframe.org/os/gview/function/buildin
-    - 完善单元测试。
-
-1. `gfile`
-    - 改进`SelfPath`获取当前执行文件路径方法，提高执行效率。
-    - 改进`Join`文件路径连接方法，防止多余的路径连接符号。
-    - 改建`GetContents`文件内容获取方法执行效率，降低内存占用。
-    - 新增`StrToSize`方法，用于将大小字符串转换为字节数字，大小字符串例如`10m`, `5KB`, `1.25Gib`等。
-    - 新增`ReadLines/ReadByteLines`方法，用于按行读取指定文件内容，并给定读取回调函数。
-    - 完善单元测试。
-
-1. `gtime`
-    - 改进`gtime.Time`对象实现，统一字符串打印时间格式为`Y-m-d H:i:s`，如：`2020-01-01 12:00:00`。
-
-1. `gcmd`
-    - 命令行解析方法增加`strict`参数，用于设置当前解析是否严格解析，严格解析下如果给定了非法的选项，将会停止解析并返回错误。默认情况下为非严格解析。
-
-1. `genv`
-    - 改进`Remove`删除环境变量键值对方法，增加对多个键值对环境变量的删除。
-
-1. `gfpool`
-    - 改进代码实现，提高效率。
-    - 完善单元测试。
-
-1. `gfsnotify`
-    - 改进包初始化方法，当系统原因引起默认`Watcher`对象创建失败时，直接`panic`。
-
-1. `gproc`
-    - 改进`SearchBinaryPath`方法。
-    - 改进`Process.Kill`方法在`windows`及`*niux`平台下不同表现的处理。
-
-## `encoding`
-1. `gjson`
-    - 代码改进、完善注释、新增大量代码示例。
-    - 文档更新：
-        - 基本介绍：https://goframe.org/encoding/gjson/index
-        - 对象创建：https://goframe.org/encoding/gjson/object
-        - 层级访问：https://goframe.org/encoding/gjson/pattern
-        - Struct转换：https://goframe.org/encoding/gjson/conversion-struct
-        - 动态创建修改：https://goframe.org/encoding/gjson/dataset
-        - 数据格式转换：https://goframe.org/encoding/gjson/conversion-format
-
-## `frame`
-1. `g`
-    - 新增`IsNil`方法，用于判断当前给定的变量是否为`nil`，该方法有可能会使用到反射来实现判断。
-    - 新增`IsEmpty`方法，用于判断当前给定的变量是否为`空`，该方法优先使用断言判断但有可能会使用到反射来实现判断。空值包括：`0, nil, false, "", len(slice/map/chan) == 0`。
-    - 标记废弃`SetServerGraceful`方法，转而统一交给`Server`的配置来管理。
-1. `gins`
-    - 改进代码结构，方便维护。
-    - 改进、完善单元测试。
-1. `gmvc`
-    - 新增`M`类型，为`*gdb.Model`的别名简称，用于工具链自动生成模型中的`M`属性。
-
-## `text`
-1. `gstr`
-    - 新增`HasPrefix/HasSuffix`方法。
-    - 新增`OctStr`方法，用于将八进制字符串转换为其对应的`unicode`字符串，例如转换为中文。常用于`gRPC`底层通信编码中。
-    - 完善单元测试。
-
-## `debug`
-1. `gdebug`
-    - 改进代码结构，方便维护。
-    - 新增`TestDataPath`方法，用于当前包单元测试中获得当前包中`testdata`目录的绝对路径。
-
-## `util`
-1. `gconv`
-    - 改进`String`字符串转换方法，增加对`time.Time/*time.Time/gtime.Time`类型的内置支持。
-    - 改进`Map/Struct`转换方法，增加对一些特殊场景的细节处理。经过大规模的使用，大量的反馈改进，不断完善了细节。
-    - 改进`Struct`转换方法，增加对`UnmarshalValue(interface{}) error`接口的支持。
-    - 完善单元测试。
-
-1. `grand`
-    - 注意：不兼容调整，原有的`Str`方法更名为`S`方法，用以获取指定长度的随机字符串、数字，并增加`symbol`参数，指定是否可以随机返回特殊可见字符。
-    - 新增`Str`方法，用于从指定的字符串字符中随机获取指定长度的字符串。该方法同时支持`unicode`字符串，例如：中文：https://goframe.org/util/grand/index
-    - 新增`Symbols`方法，用于随机返回指定场孤独的特殊可见字符：https://goframe.org/util/grand/index
-    - 完善单元测试。
-
-1. `gvalid`
-    - 长度校验规则增加对`unicode`字符串的支持，例如：中文。
-
-# Bug Fix
-1. 修复`Server`的视图对象配置失效问题。
-1. 修复`Server`中间件在中间件`panic`情况下，忽略`Middleware.Next`方法控制，导致鉴权中间件失效的问题。
-1. 修复`gudp.Server`在请求包大小超过`64bytes`时的断包问题，并调整默认缓冲区大小为`1024byte`，开发者可自定义缓冲区大小。
-1. 修复`gfile.MTimeMillisecond`方法返回错误的文件修改毫秒时间戳。
-1. 修复`gconv.Int64`对负数转换的支持。
-1. 其他一些修复。
-1. 详见：https://github.com/gogf/gf/issues?q=label%3Abug
-
-
-
-# `v1.11.2` (2020-01-14)
-
-`GF(Go Frame)` https://goframe.org 是一款模块化、高性能、生产级的Go基础开发框架。实现了比较完善的基础设施建设，包括常用的核心开发组件， 如：缓存、日志、文件、时间、队列、数组、集合、字符串、定时器、命令行、文件锁、内存锁、对象池、连接池、资源管理、数据校验、数据编码、文件监控、 定时任务、数据库ORM、TCP/UDP组件、进程管理/通信、并发安全容器等等。 并提供了Web服务开发的系列核心组件，如：Router、Cookie、Session、Middleware、服务注册、配置管理、模板引擎等等， 支持热重启、热更新、多域名、多端口、多服务、HTTPS、Rewrite等特性。
-
-`GF`有着丰富的基础模块、完善的工具链、详尽的开发文档。开源近两年以来，`GF`得到越来越多小伙伴的肯定和支持，从寂寂无名到现在被广泛应用于微服务、物联网、区块链、电商系统、银行系统等企业级的生产项目中，经历了百万级、千万级项目的考验，2019年度被码云`gitee`评选为`GVP`最有价值开源项目。`GF`正在快速地成长中，目前保持着1-2个月迭代版本的发布规律，社区活跃，欢迎加入`GF`大家庭。
-
-最后，祝大家2020新年快乐，鼠年大吉！
-
-
-
-## 新特性
-
-1. 新年新气象，官网文档大量更新：https://goframe.org/index
-1. `GF`工具链更新：https://goframe.org/toolchain/cli
-    - 新增`gf run`热编译运行命令；
-    - 新增`gf docker` Docker镜像编译命令；
-    - 新增`gf gen model` 强大的模型自动生成命令；
-    - `gf build`命令增加对配置文件配置支持；
-    - 大量命令行工具改进工作；
-    - 新增自动代理设置特性；
-1. 数据库`ORM`新特性：
-    - 增加`prefix`数据表前缀支持：https://goframe.org/database/gdb/config
-    - 新增`Schema`数据库对象并改进数据库切换特性：https://goframe.org/database/gdb/chaining/schema
-    - 新增`WherePri`方法，用于自动识别主键的条件方法：https://goframe.org/database/gdb/chaining/select
-    - 文档及示例大量更新，覆盖95%以上的功能特性；
-
-
-
-## 功能改进
-
-### `container`
-1. `garray`
-    - 新增`New*ArrayRange`方法，用于初始化创建指定数值范围的数组。
-    - 新增`Iterator*`方法，用于数组项元素回调遍历。
-    - 完善单元测试。
-1. `gvar`
-    - 改进`MapStrStr`、`MapStrStrDeep`方法实现。
-
-### `net`
-1. `ghttp`
-    - 改进HTTP客户端，增加对提交参数的自动`Content-Type`识别功能。
-    - `Request`对象增加`Parse`方法，用于快捷的对象转换即参数校验。
-    - `Request.GetPost*`方法全部标记为`deprecated`，统一客户端参数提交方式为`QueryString`, `Form`, `Body`。
-    - 去掉`Response`模板解析时的`Get`/`Post`内置变量，新增`Query`, `Form`, `Request`内置变量：https://goframe.org/net/ghttp/response/template
-    - 改进`Response.WriteJson*`及`Response.WriteXml*`方法，增加对`string`, `[]byte`类型参数的支持。
-    - `Server`新增`GetRouterArray`方法，用于向应用层暴露并获取`Server`的路由列表。
-    - `Server`新增`Use`方法，该方法为`BindMiddlewareDefault`的别名，用以全局中间件的注册。
-    - `Server`新增`RouteOverWrite`配置项，用于控制是否在注册路由冲突时自动覆盖，默认关闭并提示。
-    - `Server`新增`Graceful`配置项，用于在单服务场景下控制平滑重启特性的开启/关闭，默认开启。
-    - 完善单元测试。
-1. `gtcp`
-    - 改进简单协议下的数据包发送接收功能。
-    - 将连接池默认的缓存过期时间`30`秒修改为`10`秒。
-    - 完善单元测试。
-
-### `database`
-1. `gdb`
-    - 新增`As`数据表别名方法。
-    - 改进数据表、字段的安全字符自动识别添加功能。
-    - 新增`DB`数据库对象切换方法。
-    - 新增`TX`链式操作事务支持方法。
-    - 完善单元测试。
-### `os`
-1. `gcfg`
-    - 新增`GetMapStrStr`方法。
-1. `gcmd`
-    - 增加参数解析的`strict`严格参数，默认严格解析，不存在指定参数/选项名称时则报错返回。
-1. `genv`
-    - 改进`Remove`方法支持多个环境变量的删除。
-1. `gfile`
-    - 改进`TempDir`临时目录获取方法，在`*nix`系统下默认为`/tmp`目录。
-    - 新增`ReadLines`, `ReadByteLines`方法，用以按行回调读取文件内容。
-    - 新增`Copy*`方法，用以文件/目录的拷贝，支持递归。
-    - 新增`Replace*`方法，用以目录下的文件内容替换，支持递归。
-    - 改进`Scan*`方法，用以检索并返回指定目录下的所有文件/目录，支持文件模式指定，支持递归。
-    - 完善单元测试。
-1. `gproc`
-    - 改进命令行运行方法。
-    - 改进`Shell`命令文件检索逻辑。
-    - 改进实验性的进程间通信设计。
-1. `gtime`
-    - 将包方法以及`Time`对象的时间戳方法`Second`, `Millisecond`, `Microsecond`, `Nanosecond`标记为废除，
-    并新增`Timestamp`, `TimestampMilli`, `TimestampMicro`, `TimestampNano`替换。
-    - 需要注意的是以上修改可能和老版本存在兼容性问题。
-
-1. `gview`
-    - 解析功能、缓存设计改进。
-    - 新增`encode`, `decode`HTML编码/解码模板函数。
-    - 新增`concat`字符串拼接模板函数。
-    - 新增`dump`模板函数，功能类似于`g.Dump`方法。
-    - 新增`AutoEncode`配置项，用于自动转码输出的`HTML`内容，常用于防止`XSS`，默认关闭。需要注意的是该特性并不会影响`include`内置函数: https://goframe.org/os/gview/xss
-    - 单元测试完善。
-
-### `crypto`
-1. `gmd5`
-    - 增加`MustEncrypt`, `MustEncryptBytes`, `MustEncryptString`, `MustEncryptFile`方法。
-1. `gsha1`
-    - 增加`MustEncryptFile`方法
-
-### `encoding`
-1. `gbase64`
-    - 新增`MustEncodeFile`, `MustEncodeFileToString`, `MustDecode`, `MustDecodeToString`方法。
-1. `gjson`/`gparser`
-    - 新增`GetMapStrStr`方法。
-    - 新增`Must*`方法，用于指定数据格式的转换失败时产生`panic`错误，而不会返回`error`参数。
-
-### `util`
-1. `gconv`
-    - 改进`Convert`方法增加对`[]int32`, `[]int64`, `[]uint`, `[]uint32`, `[]uint64`, `[]float32`, `[]float64`数据类型的转换支持。
-    - 改进`String`字符串转换方法对指针参数的支持。
-    - 改进`Map*` Map转换方法的代码结构及性能。
-    - 新增`Floats`, `Float32s`, `Float64s`对`[]float32`, `[]float64`类型转换方法。
-    - 新增`Ints`, `Int32s`, `Int64s`对`[]int`, `[]int32`, `[]int64`类型转换方法。
-    - 新增`Uints`, `Uint32s`, `Uint64s`对`[]uint`, `[]uint32`, `[]uint64`类型转换方法。
-    - 完善单元测试。
-
-
-### `frame`
-1. `gins`
-    - 所有的单例对象在获取失败时产生`panic`错误。
-
-## Bug Fix
-1. 增加对常见错误路由格式例如`/user//index`的兼容支持。
-1. 修复`gtcp`/`gudp`在数据接收时的间隔时间单位问题。
-1. 修复`gfile`/`gspath`/`gfsnotify`包对文件的存在性判断不严谨问题。
-1. 修复`gproc.Kill`方法在`windows`系统下的运行阻塞问题。
-1. 修复`gstr.TrimLeftStr`/`gstr.TrimRightStr`在被替换字符串长度小于替换字符串长度时的数组溢出问题。
-
-
-
-# `v1.10.0` (2019-12-05)
-
-各位`gfer`久等了，较上一次发布时间过去已有两个多月了，这段时间`GF`也在不断地迭代改进，细节比较多，拟了个大概，以下是`release log`。
-
-另外，`GoFrame`也参加了2019最受欢迎中国开源软件评选投票，明天就结束了，欢迎为`GF`投票啊：https://www.oschina.net/project/top_cn_2019 网页可以投一票，微信也可以投一票。
-
-## 新特性
-
-1. `Web Server`新特性：
-    - 改进中间件及分组路由实现：https://goframe.org/net/ghttp/router/middleware
-    - 增加文件配置管理特性：https://goframe.org/net/ghttp/config
-    - 改进参数获取：https://goframe.org/net/ghttp/request
-    - 改进文件上传：https://goframe.org/net/ghttp/client/demo/upload
-1. `Session`增加内置的多种`Storage`实现：
-    - 基本介绍：https://goframe.org/os/gsession/index
-    - 文件存储：https://goframe.org/os/gsession/file
-    - 内存存储：https://goframe.org/os/gsession/memory
-    - `Redis`存储：https://goframe.org/os/gsession/redis
-1. 增加日志组件单例对象，并优化配置管理：
-    - https://goframe.org/frame/g/index
-    - https://goframe.org/os/glog/config
-1. 常用的`container`容器增加`JSON`数据格式的`Marshal`/`UnMarshal`接口实现：
-    - https://goframe.org/container/gmap/index
-    - https://goframe.org/container/garray/index
-    - https://goframe.org/container/gset/index
-    - https://goframe.org/container/gvar/index
-    - https://goframe.org/container/gtype/index
-    - https://goframe.org/container/glist/index
-    - https://goframe.org/container/gvar/index
-1. 新增`guuid`模块，用于通用的`UUID`生成：https://goframe.org/util/guuid/index
-
-## 功能改进
-
-### `net`
-1. `ghttp`
-    - 改进请求流程处理性能；
-    - `Server`增加对`Logger`日志对象的配置；
-    - `Server`开放了`GetRouterMap`方法，用于获得当前服务的路由列表信息，使得开发者可以更方便地实现自定义权限管理；
-    - `Server`配置管理优化；
-    - `Client`客户端对象进行了大量的改进工作；
-    - `Client`客户端对象增加多文件上传功能；
-    - `Request`对象增加`GetError`方法，用于获取当前处理错误；
-    - `Request`对象增加独立的视图对象及视图变量绑定功能，使得每个请求可以独立视图管理，也可以通过中间件切换请求对象的视图对象。默认情况下该功能关闭，视图解析时使用的是`Server`对象的视图对象；
-    - 改建`Response`对象的`CORS`功能；
-    - 增加`Response.WriteTplDefault`方法，用于解析并返回默认的模板内容；
-    - 增加更多的单元测试用例；
-    - 其他改进；
-1. `gipv4`/`gipv6`
-    - 一些改进工作；
-1. `gtcp`/`gudp`
-    - 一些改进工作；
-
-### `database`
-1. `gdb`
-    - 大量细节改进工作；
-    - 去掉查询数据为空时的`sql.ErrNoRows`错误返回，保留`Struct`/`Structs`/`Scan`方法在操作数据为空的该错误返回；
-    - 调试模式开启时，输出的SQL语句改进为完整的带参数的SQL，仅作参考；
-    - `Where`方法增加对`gmap`数据类型支持，包括顺序性的`ListMap`/`TreeMap`等等；
-    - 查询缓存方法`Cache`的缓存时间参数类型修改为`time.Duration`；
-    - 修改`Record`/`Result`的数据类型转换方法名称，原有的转换方法标记为`deprecated`；
-    - `Record`/`Result`查询结果类型增加`IsEmpty`方法，用于判断结果集是否为空；
-    - `Record`类型增加`GMap`方法，用于将查询记录转换为`gmap`类型；
-    - 增加`Option`/`OptionOmitEmpty`方法，用于输入参数过滤，包括`Data`参数及`Where`参数：https://goframe.org/database/gdb/empty
-    - 增加字段排除方法`FieldsEx`：https://goframe.org/database/gdb/senior
-    - 增加日志功能特性：https://goframe.org/database/gdb/senior
-    - 改进数据库配置管理：https://goframe.org/database/gdb/config
-    - 增加大量单元测试；
-1. `gredis`
-    - 返回数据类型转换改进：https://github.com/gogf/gf/issues/415
-    - 完善单元测试；
-    - 其他改进；
-
-### `os`
-1. `gcache`
-    - 需要注意了：缓存的有效时间参数从`interface{}`类型调整为了`time.Duration`类型，因此不再兼容之前的`int`参数类型，以保证更好的性能；
-1. `gfcache`
-    - 由于`gcache`组件的缓存时间参数类型的变更，因此该组件的时间参数也变更为了`time.Duration`类型；
-1. `gcfg`
-    - 增加`Available`方法，用以判断配置是否有效；
-1. `gfile`
-    - 增加`Chdir`方法，用于工作目录切换；
-1. `gtime`
-    - 增加`JSON`数据格式的`Marshal`/`UnMarshal`接口实现；
-
-### `container`
-1. `gmap`
-    - 增加`MapStrAny`方法，用于常见`map`类型的转换；
-    - 增加`MapCopy`方法，用于底层`map`数据复制；
-    - 增加`FilterEmpty`方法，用于`map`空值过滤；
-    - 增加`Pop`/`Pops`方法，用于随机返回`map`中的数据项（并删除）；
-    - 增加`Replace`方法，用于给定的`map`数据覆盖底层`map`数据项；
-    - 完善单元测试；
-    - 其他改进；
-1. `garray`
-    - 增加`Interfaces`转换方法，返回`[]interface{}`类型；
-    - 对排序数组增加`SetComparator`方法用户自定义修改比较器；
-    - 完善单元测试；
-    - 其他改进；
-1. `glist`
-    - 增加`NewFrom`方法，基于给定的`[]interface{}`变量创建链表；
-    - 增加`Join`方法，用于将链表项使用给定字符串连接为字符串返回；
-    - 完善单元测试；
-    - 其他改进；
-1. `gset`
-    - 增加`AddIfNotExistFunc`/`AddIfNotExistFuncLock`方法；
-    - 完善单元测试；
-    - 其他改进；
-1. `gtree`
-    - 增加`Replace`方法，用于更新现有树的数据项；
-    - 其他改进；
-1. `gtype`
-    - 一些细节改进工作，不一一列出；
-    - 完善基准测试、单元测试；
-1. `gvar`
-    - 增加`Ints`/`Uints`类型转换方法；
-    - 其他改进；
-
-### `crypto`
-1. `gmd5`
-    - 小细节改进；
-1. `gsha1`
-    - 小细节改进；
-
-### `text`
-1. `gstr`
-    - 改进`SplitAndTrim`方法，将`SplitAndTrimSpace`标记为`deprecated`；
-    - 增加`TrimStr`方法；
-    - 完善单元测试；
-    - 其他改进；
-
-### `debug`
-
-1. `gdebug`
-    - 增加`CallerFileLineShort`/`FuncPath`/`FuncName`方法；
-    - 其他改进；
-
-### `encoding`
-
-1. `gbase64`
-    - 增加`EncodeToString`/`EncodeFile`/`EncodeFileToString`/`DecodeToString`方法；
-    - 完善单元测试；
-1. `gjson`
-    - 完善单元测试；
-
-### `frame`
-
-1. `g`/`gins`
-    - https://goframe.org/frame/g/index
-    - 增加`CreateVar`方法；
-    - 完善单元测试；
-    - 其他改进；
-
-### `util`
-
-1. `gconv`
-    - 改进优化部分类型转换方法性能；
-    - 增加`Uints`/`SliceUint`类型转换方法；
-    - 增加`UnsafeStrToBytes`/`UnsafeBytesToStr`高性能的类型转换方法；
-    - 增加对`MapStrAny`接口方法的支持，用于常见`map`类型的转换；
-    - 其他改进；
-1. `gvalid`
-    - 改进对中国身份证号的识别校验功能；
-    - 增加`luhn`银行卡号的校验功能；
-1. `grand`
-    - 一些性能改进工作；
-
-
-## Bug Fix
-1. 解决`WebSocket`关闭时的`hijacked`报错问题：https://github.com/gogf/gf/issues/381
-1. 解决静态文件服务时大文件的内存占用问题；
-1. 修复前置`Nginx`后默认情况下的`Cookie`域名设置问题；
-1. 修复`gconv.Struct`在属性为`[]struct`并且输入属性参数为空时的转换失败问题：https://github.com/gogf/gf/issues/405
-1. 其他一些修复；
-
-
-
-# `v1.9.3` (2019-09-24)
-
-该版本实际为`v2.0`的大版本发布，为避免`go module`机制严格要求`v2`版本以上需要修改`import`并加上`v2`后缀，因此使用了`v1.9`版本进行发布。
-
-## 新特性
-
-1. 新增`gf`命令行开发辅助工具：https://goframe.org/toolchain/cli
-1. 新增`gres`资源管理器模块：https://goframe.org/os/gres/index
-1. 重构`Session`功能，新增`gsession`模块，`WebServer`默认使用文件存储`Session`：https://goframe.org/net/ghttp/session
-1. `WebServer`新增中间件特性，并保留原有的HOOK设计，两者都可实现请求拦截、预处理等等特性：https://goframe.org/net/ghttp/router/middleware
-1. 新增`gi18n`国际化管理模块：https://goframe.org/i18n/gi18n/index
-1. 新增`gini`模块：https://goframe.org/encoding/gini/index
-1. `WebServer`新增更便捷的层级路由注册方式：https://goframe.org/net/ghttp/group/level
-1. `gcmd`命令行参数解析模块重构，增加`Parser`解析对象：https://goframe.org/os/gcmd/index
-1. 新增`gdebug`模块，用于堆栈信息获取/打印：https://goframe.org/debug/gdebug/index
-
-
-## 重大调整
-1. 去掉`1.x`版本中已经被标记为`deprecated`的方法；
-1. 调整`container`分类的容器模块，将默认并发安全参数调整为默认非并发安全；
-1. 目录调整:
-    - 去掉`third`目录，统一使用`go module`管理包依赖；
-    - 将原有`g`目录中的模块移出到框架主目录，原有的`g`模块移动到`frame/g`目录；
-    - 将原有`geg`示例代码目录名称修改为`.example`；
-
-
-
-## 功能改进
-
-1. `ghttp`
-    - 改进`Request`参数解析方式：https://goframe.org/net/ghttp/request
-    - 改进跨域请求功能，新增`Origin`设置及校验功能：https://goframe.org/net/ghttp/cors
-    - `Cookie`及`Session`的`TTL`配置数据类型修改为`time.Duration`;
-    - 新增允许同时通过`Header/Cookie`传递`SessionId`；
-    - 新增`ConfigFromMap/SetConfigWithMap`方法，支持通过`map`参数设置WebServer；
-    - 改进默认的`CORS`配置，增加对常见`Header`参数的默认支持；
-    - 新增`IsExitError`方法，用于开发者自定义处理`recover`错误处理时，过滤框架本身自定义的非异常错误；
-    - 新增`SetSessionStorage`配置方法，用于开发者自定义`Session`存储；
-    - `ghttp.Request`新增更多的参数获取方法；
-1. `gdb`
-    - 增加对SQL中部分字段的自动转义(`Quote`)功能；
-    - 增加对方法操作以及链式操作中的`slice`参数的支持；
-    - 增加`SetLogger`方法用于开发者自定义数据库的日志打印；
-    - 增加`Master/Slave`方法，开发者可自主选择数据库操作执行的主从节点；
-    - 增加对`mssql/pgsql/oracle`的单元测试；
-    - 在`debug`模式支持完整带参数整合的SQL语句调试打印；
-    - 增加了更多的功能方法；
-1. `glog`
-    - 新增`Default`方法用于获取默认的`Logger`对象；
-    - 新增`StackWithFilter`方法用于自定义堆栈打印过滤；
-    - 增加了更多的功能方法；
-1. `gfile`
-    - 部分方法名称调整：`Get/PutBinContents`修改为`Get/PutBytes`；
-    - 增加`ScanDirFile`方法，用于仅检索文件目录，支持递归检索；
-    - 增加了更多的功能方法；
-1. `gview`
-    - 新增`SetI18n`方法用于设置视图对象自定义的`gi18n`国际化对象；
-    - 新增对`gres`资源管理器的内置支持；
-1. `gcompress`
-    - 增加`zip`算法的文件/目录的压缩/解压方法；
-    - 文件/目录压缩参数支持多路径；
-1. `gconv`
-    - 改进对`[]byte`数据类型参数的支持；
-    - 新增`Unsafe`转换方法，开发者可在特定场景下使用，提高转换效率；
-    - 新增`MapDeep/StructDeep/StructsDeep`方法，支持递归`struct`转换；
-1. `gjson/gparser`
-    - 改进类型自动识别功能；
-    - 新增`LoadJson/LoadXml/LoadToml/LoadYaml/LoadIni`方法用于自定义的数据类型内容加载；
-    - 增加了更多的功能方法；
-1. `gerror`
-    - 改进错误堆栈获取逻辑；
-    - 增加了更多的功能方法；
-1. `gmap/garray/gset/glist/gvar`
-    - 改进并发安全基准测试脚本；
-    - 修改`garray.StringArray`为`garray.StrArray`；
-    - 增加了更多的功能方法；
-1. `gdes`
-    - 规范化修改方法名称；
-1. `gstr`
-    - 增加`Camel/Snake`相关命名转换方法；
-    - 增加了更多的功能方法；
-1. `genv`
-    - 增加了更多的功能方法；
-
-
-## Bug Fix
-1. 修复`gvalid`校验`struct`时的`tag`自定义错误失效的问题；
-1. 修复`gcfg`配置管理模块在特定情况下的内容类型自动识别失败问题；
-1. 修复`gqueue`在用户主动关闭队列时的并发安全问题；
-1. 修复`session`在开发者设置的`TTL`过大时的整型变量溢出问题；

TODO.Deprecated.MD

@@ -1,135 +0,0 @@
-> This markdown is deprecated and will be removed in future. All TODO features are staged in the issue: https://github.com/gogf/gf/issues
-
-# ON THE WAY
-1. 增加图形验证码支持，至少支持数字和英文字母；
-1. Cookie&Session数据池化处理；
-1. ghttp.Client增加proxy特性；
-1. gtime增加对时区转换的封装，并简化失去转换时对类似+80500时区的支持；
-1. orm增加sqlite对Save方法的支持(去掉触发器语句);
-1. ghttp.Server增加Ip访问控制功能(DenyIps&AllowIps)；
-1. ghttp增加返回数据压缩机制；
-1. ghttp.Server增加proxy功能特性，本地proxy和远程proxy，本地即将路由规则映射；远程即反向代理；
-1. gjson对大json数据的解析效率问题；
-1. ghttp增加route name特性，并同时支持backend和template(提供内置函数)引用，可以通过RedirectRoute方法给定route name和路由参数跳转到指定的路由地址上；
-1. gvalid校验支持当第一个规则失败后便不再校验后续的规则，最好做成链式操作；
-1. ghttp.Request增加对输入参数的自动HtmlEncode机制；
-1. 常量命名风格根据golint进行修改；
-1. 开放rwmutex包，并将gjson的互斥锁使用自定义的mutex替换；
-1. 文档完善：
-    - gconv struct tag、
-    - 控制器及执行对象注册的Init&Shut方法、
-    - ghttp.Response&ServeFile、gfcache、gproc shell执行、
-    - ghttp Server&Client basic auth、
-    - glog分类&日志等级&链式操作、gdb debug自动输出调试信息、gmlock内存锁、
-1. 服务注册域名增加对泛域名的支持；
-1. 项目参考：
-    - https://github.com/namreg/godown
-    - https://github.com/Masterminds/sprig
-1. gform参考 https://gohouse.github.io/gorose/dist/index.html 进行改进
-1. gtcp提供简便的包发送/接收方法(SendPkg/RecvPkg)以解决常见的TCP通信粘包问题，并完善文档（参考：https://www.cnblogs.com/kex1n/p/6502002.html）；
-1. 路由增加不区分大小写得匹配方式；
-1. 改进WebServer获取POST参数处理逻辑，当提交非form数据时，例如json数据，针对某些方法可以直接解析；
-1. WebServer增加可选择的路由覆盖配置，默认情况下不覆盖；
-1. 增加jumplist的数据结构容器；
-1. DelayQueue/PriorityQueue；
-1. 权限管理模块；
-1. 从ghttp中剥离SESSION功能构成单独的模块gsession；
-1. 改进gproc进程间通信处理逻辑，提高稳定性，以应对进程间大批量的数据发送/接收；
-1. 添加Save/Replace/BatchSave/BatchReplace方法对sqlite数据库的支持；
-1. 添加sqlite数据库的单元测试用例；
-1. gredis增加cluster支持；
-1. gset.Add/Remove/Contains方法增加批量操作支持；
-1. gmlock增加手动清理机制：当内存锁不再使用时，由调用端决定是否清理内存锁；
-1. gtimer增加DelayAdd*方法返回Entry对象，以便DelayAdd*的定时任务也能进行状态控制；gcron同理需要改进；
-1. grpool增加支持阻塞添加任务接口；
-1. gdb.Model在链式安全的对象创建中增加sync.Pool的使用；
-1. 增加g.Table快捷方法以方便操作数据表，但是得考虑后续模型操作设计，特别是脚手架的模型管理；
-
-
-
-
-
-
-# DONE
-1. Cookie设置中文失效问题；
-1. gvalid增加支持对[]rune的长度校验(一个中文占3个字节)；
-1. grpool性能压测结果变慢的问题；
-1. ghttp的热重启的本地进程端口监听，在不使用该特性时默认关闭掉；
-1. gtcp增加对TLS加密通信的支持；
-1. 改进gdb对pgsql/mssql/oracle的支持，使用方法覆盖的方式改进操作，而不是完全依靠正则替换的方式；
-1. gdb的Cache缓存功能增加可自定义缓存接口，以便支持外部缓存功能，缓存接口可以通过io.ReadWriter接口实现；
-1. 改进ghttp分组路由中对hook的支持方式，以便格式与BindHookHandler统一；
-1. 使用gconv将slice映射到struct属性上，例如redis hscan的结果集；
-1.  gconv完善针对不同类型的判断，例如：尽量减少sprintf("%v", xxx)来执行string类型的转换；
-2.  ghttp.Server请求执行中增加服务退出的方法，不再执行后续操作；
-3.  ghttp.Response对象完善并改进数据返回方法(Write/WriteString)；
-4.  ghttp.Server请求执行中增加服务退出的方法，不再执行后续操作；
-5.  增加fsnotify包支持；
-6.  改进gcfg和gview的文件自动更新机制；
-7.  将模板变量进行暴露，以便应用端可以进行灵活控制；
-8.  跟踪第三方mxj包的issue问题：https://github.com/clbanning/mxj/issues/48；
-9.  gdb Where方法参数的改进，研究是否可以将string参数类型修改为interface{}；
-10. gpage分页控制功能；
-11. https支持；
-12. ghttp.Server日志中增加请求时间和返回时间，以便计算执行时间差；
-13. 由于去掉了gdb的单例模式，并且将gins的部分对象封装迁移到了g包中，需要同时梳理文档，完善修改；
-14. 在代码中增加https与http同时开启使用的示例代码，这块大家问得比较多；
-15. ghttp.Server多个事件之间通过ghttp.Request.Param自定义参数传参；
-16. 研究是否增加配置文件目录检索功能，特别是如何友好改进开发环境的配置文件默认目录问题；
-17. 增加ghttp.Server不同状态码的自定义处理方法；
-18. ghttp.Server平滑重启方案；
-19. 完善gconv类型转换功能，增加time.Time/time.Duration类型转换，并增加benchmark测试脚本
-20. 当二进制参数为nil时，gjson.LoadContent并将gjson.Json对象ToMap时会报错；
-21. 改进控制器及执行对象注册，更友好地支持动态路由注册，例如：注册规则为 /channel/:name，现有的控制器及执行对象注册很难友好支持这种动态形式；
-22. 当前gpage分页包的输出标签不支持li，大多数CSS框架都是li+a标签模式，需要提供可更加灵活的定制化功能实现；
-23. 平滑重启机制改进，以便于开发阶段调试；
-24. 对grpool进行优化改进，包括属性原子操作封装采用gtype实现，修正设计BUG：https://github.com/gogf/gf/issues/6；
-25. gredis增加redis密码支持；
-26. 改进ghttp.Server平滑重启机制，当新进程接管服务后，再使用进程间通信方式通知父进程销毁；
-27. gproc进程间通信增加分组特性，不同的进程间可以通过进程ID以及分组名称发送/获取进程消息；
-28. ORM增加获取被执行的sql语句的方法；
-29. gdb增加查询缓存特性；
-30. gpage分页增加对自定义后缀的支持，如:2.html, 2.php等等；
-31. gvalid包增加struct tag的校验规则、自定义错误提示信息绑定的支持特性；
-32. 增加文件缓存包，可根据fsnotify机制进行缓存更新；
-33. *any/:name路由匹配路由改进支持不带名字的*/:路由规则；
-34. ghttp静态文件服务改进(特别是403返回状态的修改)；
-35. map转struct增加对tag的支持；
-36. gcache检查在i386下的int64->int转换问题；
-37. ghttp获取参数支持直接转struct功能；
-38. gfsnotify增加对于目录的监控；
-39. 检查windows下的平滑重启失效问题；
-40. ghttp.Server的Cookie及Session锁机制优化(去掉map锁机制);
-41. 解决glog串日志情况；
-42. glog增加对日志文件名称的生成规则设定，支持时间格式规则；
-43. ghttp日志增加客户端IP信息；
-44. 完善gform配置管理说明，g.DB/Database和gdb.New的区别；
-1. 完善配置管理章节，说明默认的配置文件更改方式；
-1. 服务注册时判断方法定义满足规范时才执行绑定，否则提示WARN信息；
-1. `gfsnotify`增加添加监听文件时的监听ID返回，以便调用端删除监听时只删除自己添加的监听，而不影响其他对该同一文件的监听回调；
-1. `gfsnotify`针对添加目录监听时无法使用多个`Watcher`，考虑改进，并考虑动态扩容全局`Watcher`方案；
-1. 由于系统对inotify实例数量(`fs.inotify.max_user_instances`)以及队列大小(`fs.inotify.max_user_watches`)有限制，需要改进`gfsnotify`；
-1. WebServer事件回调允许对同一个路由规则绑定多个事件回调；
-1. gcfg/gview/ghttp等模块加上对临时文件目录的自动添加监听判断（基本是开发环境下，特别是windows环境），去掉临时文件的监听，避免临时文件过大引起的运行缓慢占用内存问题；
-1. 改进gfpool在文件指针变化时的更新；
-1. ghttp hook回调使用方式在注册路由比较多的时候，优先级可能使得开发者混乱，考虑方式便于管理；
-1. gform对于MySQL字段类型为datetime类型的时区问题分析；
-1. 改进证书打开失败时的WebServer错误提示，前置HOOK校验后关闭后续的HOOK逻辑执行；
-1. 目前WebServer的HOOK是按照优先级执行的，需要增加覆盖特性；
-1. 更新跨域请求CORS相关功能文档；
-1. ghttp.Response增加输出内容后自动退出当前请求机制，不需要用户手动return，参考beego如何实现；
-1. gcfg包目前允许添加重复的目录路径，需要在SetPath/AddPath时判断重复性，不能添加重复的路径；
-1. gdb执行数据写入时，如果参数为struct/[]struct，自动映射与表字段对应关系，不再使用gconv标签标识；
-1. gdb的Data方法支持struct参数传入；
-1. gfcache依旧使用gcache作为缓存控制对象，不要使用gmap；
-1. 增加对ghttp路由注册的{.struct}/{.method}单元测试；
-1. gconv针对struct的转换增加json tag支持，gconv.Map默认也支持json tag, 完善开发文档；
-1. 增加SO_REUSEPORT的支持；
-1. gkafka这个包比较重，未来从框架中剥离出来；
-1. str_ireplace: http://php.net/manual/en/function.str-ireplace.php
-1. strpos/stripos/strrpos/strripos: http://php.net/manual/en/function.stripos.php
-1. gfile对于文件的读写强行使用了gfpool，在某些场景下不合适，需要考虑剥离开，并为开发者提供单独的指针池文件操作特性；
-1. ghttp.Client自动Close机制；
-1. ghttp路由功能增加分组路由特性；
-1. 增加可选择性的orm tag特性，用以数据表记录与struct对象转换的键名属性映射；
-1. gview中的template标签失效问题；

container/garray/garray.go

@@ -4,5 +4,5 @@
 // If a copy of the MIT was not distributed with this file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package garray provides concurrent-safe/unsafe arrays.
+// Package garray provides most commonly used array containers which also support concurrent-safe/unsafe switch feature.
 package garray

container/garray/garray_normal_any.go

@@ -8,10 +8,10 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"github.com/gogf/gf/internal/empty"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/text/gstr"
 	"math"
 	"sort"
@@ -22,6 +22,8 @@ import (
 )
 
 // Array is a golang array with rich features.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type Array struct {
 	mu    rwmutex.RWMutex
 	array []interface{}
@@ -288,7 +290,7 @@ func (a *Array) PopRight() (value interface{}, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return nil, false
 	}
 	value = a.array[index]
@@ -451,7 +453,7 @@ func (a *Array) Clone() (newArray *Array) {
 	array := make([]interface{}, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewArrayFrom(array, !a.mu.IsSafe())
+	return NewArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -473,18 +475,7 @@ func (a *Array) Contains(value interface{}) bool {
 // or returns -1 if not exists.
 func (a *Array) Search(value interface{}) int {
 	a.mu.RLock()
-	result := -1
-	for index, v := range a.array {
-		if v == value {
-			result = index
-			break
-		}
-	}
-	a.mu.RUnlock()
-	return result
-}
-
-func (a *Array) doSearch(value interface{}) int {
+	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
 		return -1
 	}
@@ -499,12 +490,15 @@ func (a *Array) doSearch(value interface{}) int {
 }
 
 // Unique uniques the array, clear repeated items.
+// Example: [1,1,2,3,2] -> [1,2,3]
 func (a *Array) Unique() *Array {
 	a.mu.Lock()
 	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); j++ {
+		for j := i + 1; j < len(a.array); {
 			if a.array[i] == a.array[j] {
 				a.array = append(a.array[:j], a.array[j+1:]...)
+			} else {
+				j++
 			}
 		}
 	}
@@ -728,7 +722,8 @@ func (a *Array) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *Array) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a Array) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_normal_int.go

@@ -8,9 +8,9 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/gogf/gf/internal/json"
 	"math"
 	"sort"
 
@@ -20,6 +20,8 @@ import (
 )
 
 // IntArray is a golang int array with rich features.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type IntArray struct {
 	mu    rwmutex.RWMutex
 	array []int
@@ -264,7 +266,7 @@ func (a *IntArray) PopRight() (value int, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return 0, false
 	}
 	value = a.array[index]
@@ -467,7 +469,7 @@ func (a *IntArray) Clone() (newArray *IntArray) {
 	array := make([]int, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewIntArrayFrom(array, !a.mu.IsSafe())
+	return NewIntArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -489,6 +491,10 @@ func (a *IntArray) Contains(value int) bool {
 // or returns -1 if not exists.
 func (a *IntArray) Search(value int) int {
 	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return -1
+	}
 	result := -1
 	for index, v := range a.array {
 		if v == value {
@@ -496,17 +502,19 @@ func (a *IntArray) Search(value int) int {
 			break
 		}
 	}
-	a.mu.RUnlock()
 	return result
 }
 
 // Unique uniques the array, clear repeated items.
+// Example: [1,1,2,3,2] -> [1,2,3]
 func (a *IntArray) Unique() *IntArray {
 	a.mu.Lock()
 	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); j++ {
+		for j := i + 1; j < len(a.array); {
 			if a.array[i] == a.array[j] {
 				a.array = append(a.array[:j], a.array[j+1:]...)
+			} else {
+				j++
 			}
 		}
 	}
@@ -713,7 +721,8 @@ func (a *IntArray) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *IntArray) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a IntArray) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_normal_str.go

@@ -8,9 +8,9 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
 	"errors"
 	"fmt"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/text/gstr"
 	"math"
 	"sort"
@@ -22,6 +22,8 @@ import (
 )
 
 // StrArray is a golang string array with rich features.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type StrArray struct {
 	mu    rwmutex.RWMutex
 	array []string
@@ -252,7 +254,7 @@ func (a *StrArray) PopRight() (value string, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return "", false
 	}
 	value = a.array[index]
@@ -455,7 +457,7 @@ func (a *StrArray) Clone() (newArray *StrArray) {
 	array := make([]string, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewStrArrayFrom(array, !a.mu.IsSafe())
+	return NewStrArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -473,13 +475,30 @@ func (a *StrArray) Contains(value string) bool {
 	return a.Search(value) != -1
 }
 
+// ContainsI checks whether a value exists in the array with case-insensitively.
+// Note that it internally iterates the whole array to do the comparison with case-insensitively.
+func (a *StrArray) ContainsI(value string) bool {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return false
+	}
+	for _, v := range a.array {
+		if strings.EqualFold(v, value) {
+			return true
+		}
+	}
+	return false
+}
+
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *StrArray) Search(value string) int {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
 	if len(a.array) == 0 {
 		return -1
 	}
-	a.mu.RLock()
 	result := -1
 	for index, v := range a.array {
 		if strings.Compare(v, value) == 0 {
@@ -487,17 +506,19 @@ func (a *StrArray) Search(value string) int {
 			break
 		}
 	}
-	a.mu.RUnlock()
 	return result
 }
 
 // Unique uniques the array, clear repeated items.
+// Example: [1,1,2,3,2] -> [1,2,3]
 func (a *StrArray) Unique() *StrArray {
 	a.mu.Lock()
 	for i := 0; i < len(a.array)-1; i++ {
-		for j := i + 1; j < len(a.array); j++ {
+		for j := i + 1; j < len(a.array); {
 			if a.array[i] == a.array[j] {
 				a.array = append(a.array[:j], a.array[j+1:]...)
+			} else {
+				j++
 			}
 		}
 	}
@@ -715,7 +736,8 @@ func (a *StrArray) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *StrArray) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a StrArray) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_sorted_any.go

@@ -8,9 +8,9 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
 	"github.com/gogf/gf/internal/empty"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/text/gstr"
 	"github.com/gogf/gf/util/gutil"
 	"math"
@@ -22,7 +22,10 @@ import (
 )
 
 // SortedArray is a golang sorted array with rich features.
-// It's using increasing order in default.
+// It is using increasing order in default, which can be changed by
+// setting it a custom comparator.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type SortedArray struct {
 	mu         rwmutex.RWMutex
 	array      []interface{}
@@ -122,7 +125,13 @@ func (a *SortedArray) Sort() *SortedArray {
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
+// It's alias of function Append, see Append.
 func (a *SortedArray) Add(values ...interface{}) *SortedArray {
+	return a.Append(values...)
+}
+
+// Append adds one or multiple values to sorted array, the array always keeps sorted.
+func (a *SortedArray) Append(values ...interface{}) *SortedArray {
 	if len(values) == 0 {
 		return a
 	}
@@ -218,7 +227,7 @@ func (a *SortedArray) PopRight() (value interface{}, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return nil, false
 	}
 	value = a.array[index]
@@ -425,19 +434,19 @@ func (a *SortedArray) Search(value interface{}) (index int) {
 // If <result> lesser than 0, it means the value at <index> is lesser than <value>.
 // If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedArray) binSearch(value interface{}, lock bool) (index int, result int) {
-	if len(a.array) == 0 {
-		return -1, -2
-	}
 	if lock {
 		a.mu.RLock()
 		defer a.mu.RUnlock()
 	}
+	if len(a.array) == 0 {
+		return -1, -2
+	}
 	min := 0
 	max := len(a.array) - 1
 	mid := 0
 	cmp := -2
 	for min <= max {
-		mid = (min + max) / 2
+		mid = min + int((max-min)/2)
 		cmp = a.getComparator()(value, a.array[mid])
 		switch {
 		case cmp < 0:
@@ -490,7 +499,7 @@ func (a *SortedArray) Clone() (newArray *SortedArray) {
 	array := make([]interface{}, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewSortedArrayFrom(array, a.comparator, !a.mu.IsSafe())
+	return NewSortedArrayFrom(array, a.comparator, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -660,7 +669,8 @@ func (a *SortedArray) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *SortedArray) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a SortedArray) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_sorted_int.go

@@ -8,8 +8,8 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
 	"fmt"
+	"github.com/gogf/gf/internal/json"
 	"math"
 	"sort"
 
@@ -19,7 +19,10 @@ import (
 )
 
 // SortedIntArray is a golang sorted int array with rich features.
-// It's using increasing order in default.
+// It is using increasing order in default, which can be changed by
+// setting it a custom comparator.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type SortedIntArray struct {
 	mu         rwmutex.RWMutex
 	array      []int
@@ -107,7 +110,13 @@ func (a *SortedIntArray) Sort() *SortedIntArray {
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
+// It's alias of function Append, see Append.
 func (a *SortedIntArray) Add(values ...int) *SortedIntArray {
+	return a.Append(values...)
+}
+
+// Append adds one or multiple values to sorted array, the array always keeps sorted.
+func (a *SortedIntArray) Append(values ...int) *SortedIntArray {
 	if len(values) == 0 {
 		return a
 	}
@@ -203,7 +212,7 @@ func (a *SortedIntArray) PopRight() (value int, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return 0, false
 	}
 	value = a.array[index]
@@ -422,19 +431,19 @@ func (a *SortedIntArray) Search(value int) (index int) {
 // If <result> lesser than 0, it means the value at <index> is lesser than <value>.
 // If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedIntArray) binSearch(value int, lock bool) (index int, result int) {
-	if len(a.array) == 0 {
-		return -1, -2
-	}
 	if lock {
 		a.mu.RLock()
 		defer a.mu.RUnlock()
 	}
+	if len(a.array) == 0 {
+		return -1, -2
+	}
 	min := 0
 	max := len(a.array) - 1
 	mid := 0
 	cmp := -2
 	for min <= max {
-		mid = (min + max) / 2
+		mid = min + int((max-min)/2)
 		cmp = a.getComparator()(value, a.array[mid])
 		switch {
 		case cmp < 0:
@@ -487,7 +496,7 @@ func (a *SortedIntArray) Clone() (newArray *SortedIntArray) {
 	array := make([]int, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewSortedIntArrayFrom(array, !a.mu.IsSafe())
+	return NewSortedIntArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -634,7 +643,8 @@ func (a *SortedIntArray) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *SortedIntArray) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a SortedIntArray) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_sorted_str.go

@@ -8,10 +8,11 @@ package garray
 
 import (
 	"bytes"
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/text/gstr"
 	"math"
 	"sort"
+	"strings"
 
 	"github.com/gogf/gf/internal/rwmutex"
 	"github.com/gogf/gf/util/gconv"
@@ -19,7 +20,10 @@ import (
 )
 
 // SortedStrArray is a golang sorted string array with rich features.
-// It's using increasing order in default.
+// It is using increasing order in default, which can be changed by
+// setting it a custom comparator.
+// It contains a concurrent-safe/unsafe switch, which should be set
+// when its initialization and cannot be changed then.
 type SortedStrArray struct {
 	mu         rwmutex.RWMutex
 	array      []string
@@ -92,7 +96,13 @@ func (a *SortedStrArray) Sort() *SortedStrArray {
 }
 
 // Add adds one or multiple values to sorted array, the array always keeps sorted.
+// It's alias of function Append, see Append.
 func (a *SortedStrArray) Add(values ...string) *SortedStrArray {
+	return a.Append(values...)
+}
+
+// Append adds one or multiple values to sorted array, the array always keeps sorted.
+func (a *SortedStrArray) Append(values ...string) *SortedStrArray {
 	if len(values) == 0 {
 		return a
 	}
@@ -188,7 +198,7 @@ func (a *SortedStrArray) PopRight() (value string, found bool) {
 	a.mu.Lock()
 	defer a.mu.Unlock()
 	index := len(a.array) - 1
-	if index <= 0 {
+	if index < 0 {
 		return "", false
 	}
 	value = a.array[index]
@@ -392,6 +402,22 @@ func (a *SortedStrArray) Contains(value string) bool {
 	return a.Search(value) != -1
 }
 
+// ContainsI checks whether a value exists in the array with case-insensitively.
+// Note that it internally iterates the whole array to do the comparison with case-insensitively.
+func (a *SortedStrArray) ContainsI(value string) bool {
+	a.mu.RLock()
+	defer a.mu.RUnlock()
+	if len(a.array) == 0 {
+		return false
+	}
+	for _, v := range a.array {
+		if strings.EqualFold(v, value) {
+			return true
+		}
+	}
+	return false
+}
+
 // Search searches array by <value>, returns the index of <value>,
 // or returns -1 if not exists.
 func (a *SortedStrArray) Search(value string) (index int) {
@@ -407,19 +433,19 @@ func (a *SortedStrArray) Search(value string) (index int) {
 // If <result> lesser than 0, it means the value at <index> is lesser than <value>.
 // If <result> greater than 0, it means the value at <index> is greater than <value>.
 func (a *SortedStrArray) binSearch(value string, lock bool) (index int, result int) {
-	if len(a.array) == 0 {
-		return -1, -2
-	}
 	if lock {
 		a.mu.RLock()
 		defer a.mu.RUnlock()
 	}
+	if len(a.array) == 0 {
+		return -1, -2
+	}
 	min := 0
 	max := len(a.array) - 1
 	mid := 0
 	cmp := -2
 	for min <= max {
-		mid = (min + max) / 2
+		mid = min + int((max-min)/2)
 		cmp = a.getComparator()(value, a.array[mid])
 		switch {
 		case cmp < 0:
@@ -472,7 +498,7 @@ func (a *SortedStrArray) Clone() (newArray *SortedStrArray) {
 	array := make([]string, len(a.array))
 	copy(array, a.array)
 	a.mu.RUnlock()
-	return NewSortedStrArrayFrom(array, !a.mu.IsSafe())
+	return NewSortedStrArrayFrom(array, a.mu.IsSafe())
 }
 
 // Clear deletes all items of current array.
@@ -630,7 +656,8 @@ func (a *SortedStrArray) String() string {
 }
 
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
-func (a *SortedStrArray) MarshalJSON() ([]byte, error) {
+// Note that do not use pointer as its receiver here.
+func (a SortedStrArray) MarshalJSON() ([]byte, error) {
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	return json.Marshal(a.array)

container/garray/garray_z_example_any_test.go

@@ -0,0 +1,281 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package garray_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/frame/g"
+
+	"github.com/gogf/gf/container/garray"
+)
+
+func ExampleNew() {
+	// A normal array.
+	a := garray.New()
+
+	// Adding items.
+	for i := 0; i < 10; i++ {
+		a.Append(i)
+	}
+
+	// Print the array length.
+	fmt.Println(a.Len())
+
+	// Print the array items.
+	fmt.Println(a.Slice())
+
+	// Retrieve item by index.
+	fmt.Println(a.Get(6))
+
+	// Check item existence.
+	fmt.Println(a.Contains(6))
+	fmt.Println(a.Contains(100))
+
+	// Insert item before specified index.
+	a.InsertAfter(9, 11)
+	// Insert item after specified index.
+	a.InsertBefore(10, 10)
+
+	fmt.Println(a.Slice())
+
+	// Modify item by index.
+	a.Set(0, 100)
+	fmt.Println(a.Slice())
+
+	// Search item and return its index.
+	fmt.Println(a.Search(5))
+
+	// Remove item by index.
+	a.Remove(0)
+	fmt.Println(a.Slice())
+
+	// Empty the array, removes all items of it.
+	fmt.Println(a.Slice())
+	a.Clear()
+	fmt.Println(a.Slice())
+
+	// Output:
+	// 10
+	// [0 1 2 3 4 5 6 7 8 9]
+	// 6 true
+	// true
+	// false
+	// [0 1 2 3 4 5 6 7 8 9 10 11]
+	// [100 1 2 3 4 5 6 7 8 9 10 11]
+	// 5
+	// [1 2 3 4 5 6 7 8 9 10 11]
+	// [1 2 3 4 5 6 7 8 9 10 11]
+	// []
+}
+
+func ExampleArray_Iterator() {
+	array := garray.NewArrayFrom(g.Slice{"a", "b", "c"})
+	// Iterator is alias of IteratorAsc, which iterates the array readonly in ascending order
+	//  with given callback function <f>.
+	// If <f> returns true, then it continues iterating; or false to stop.
+	array.Iterator(func(k int, v interface{}) bool {
+		fmt.Println(k, v)
+		return true
+	})
+	// IteratorDesc iterates the array readonly in descending order with given callback function <f>.
+	// If <f> returns true, then it continues iterating; or false to stop.
+	array.IteratorDesc(func(k int, v interface{}) bool {
+		fmt.Println(k, v)
+		return true
+	})
+
+	// Output:
+	// 0 a
+	// 1 b
+	// 2 c
+	// 2 c
+	// 1 b
+	// 0 a
+}
+
+func ExampleArray_Reverse() {
+	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Reverse makes array with elements in reverse order.
+	fmt.Println(array.Reverse().Slice())
+
+	// Output:
+	// [9 8 7 6 5 4 3 2 1]
+}
+
+func ExampleArray_Shuffle() {
+	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Shuffle randomly shuffles the array.
+	fmt.Println(array.Shuffle().Slice())
+}
+
+func ExampleArray_Rands() {
+	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Randomly retrieve and return 2 items from the array.
+	// It does not delete the items from array.
+	fmt.Println(array.Rands(2))
+
+	// Randomly pick and return one item from the array.
+	// It deletes the picked up item from array.
+	fmt.Println(array.PopRand())
+}
+
+func ExampleArray_PopRand() {
+	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Randomly retrieve and return 2 items from the array.
+	// It does not delete the items from array.
+	fmt.Println(array.Rands(2))
+
+	// Randomly pick and return one item from the array.
+	// It deletes the picked up item from array.
+	fmt.Println(array.PopRand())
+}
+
+func ExampleArray_Join() {
+	array := garray.NewFrom(g.Slice{"a", "b", "c", "d"})
+	fmt.Println(array.Join(","))
+
+	// Output:
+	// a,b,c,d
+}
+
+func ExampleArray_Chunk() {
+	array := garray.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Chunk splits an array into multiple arrays,
+	// the size of each array is determined by <size>.
+	// The last chunk may contain less than size elements.
+	fmt.Println(array.Chunk(2))
+
+	// Output:
+	// [[1 2] [3 4] [5 6] [7 8] [9]]
+}
+
+func ExampleArray_PopLeft() {
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Any Pop* functions pick, delete and return the item from array.
+
+	fmt.Println(array.PopLeft())
+	fmt.Println(array.PopLefts(2))
+	fmt.Println(array.PopRight())
+	fmt.Println(array.PopRights(2))
+
+	// Output:
+	// 1 true
+	// [2 3]
+	// 9 true
+	// [7 8]
+}
+
+func ExampleArray_PopLefts() {
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Any Pop* functions pick, delete and return the item from array.
+
+	fmt.Println(array.PopLeft())
+	fmt.Println(array.PopLefts(2))
+	fmt.Println(array.PopRight())
+	fmt.Println(array.PopRights(2))
+
+	// Output:
+	// 1 true
+	// [2 3]
+	// 9 true
+	// [7 8]
+}
+
+func ExampleArray_PopRight() {
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Any Pop* functions pick, delete and return the item from array.
+
+	fmt.Println(array.PopLeft())
+	fmt.Println(array.PopLefts(2))
+	fmt.Println(array.PopRight())
+	fmt.Println(array.PopRights(2))
+
+	// Output:
+	// 1 true
+	// [2 3]
+	// 9 true
+	// [7 8]
+}
+
+func ExampleArray_PopRights() {
+	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	// Any Pop* functions pick, delete and return the item from array.
+
+	fmt.Println(array.PopLeft())
+	fmt.Println(array.PopLefts(2))
+	fmt.Println(array.PopRight())
+	fmt.Println(array.PopRights(2))
+
+	// Output:
+	// 1 true
+	// [2 3]
+	// 9 true
+	// [7 8]
+}
+
+func ExampleArray_Contains() {
+	var array garray.StrArray
+	array.Append("a")
+	fmt.Println(array.Contains("a"))
+	fmt.Println(array.Contains("A"))
+	fmt.Println(array.ContainsI("A"))
+
+	// Output:
+	// true
+	// false
+	// true
+}
+
+func ExampleArray_Merge() {
+	array1 := garray.NewFrom(g.Slice{1, 2})
+	array2 := garray.NewFrom(g.Slice{3, 4})
+	slice1 := g.Slice{5, 6}
+	slice2 := []int{7, 8}
+	slice3 := []string{"9", "0"}
+	fmt.Println(array1.Slice())
+	array1.Merge(array1)
+	array1.Merge(array2)
+	array1.Merge(slice1)
+	array1.Merge(slice2)
+	array1.Merge(slice3)
+	fmt.Println(array1.Slice())
+
+	// Output:
+	// [1 2]
+	// [1 2 1 2 3 4 5 6 7 8 9 0]
+}
+
+func ExampleArray_FilterEmpty() {
+	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	fmt.Printf("%#v\n", array1.FilterNil().Slice())
+	fmt.Printf("%#v\n", array2.FilterEmpty().Slice())
+
+	// Output:
+	// []interface {}{0, 1, 2, "", []interface {}{}, "john"}
+	// []interface {}{1, 2, "john"}
+}
+
+func ExampleArray_FilterNil() {
+	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
+	fmt.Printf("%#v\n", array1.FilterNil().Slice())
+	fmt.Printf("%#v\n", array2.FilterEmpty().Slice())
+
+	// Output:
+	// []interface {}{0, 1, 2, "", []interface {}{}, "john"}
+	// []interface {}{1, 2, "john"}
+}

container/garray/garray_z_example_str_test.go

@@ -0,0 +1,28 @@
+// Copyright 2018 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package garray_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/frame/g"
+)
+
+func ExampleStrArray_Walk() {
+	var array garray.StrArray
+	tables := g.SliceStr{"user", "user_detail"}
+	prefix := "gf_"
+	array.Append(tables...)
+	// Add prefix for given table names.
+	array.Walk(func(value string) string {
+		return prefix + value
+	})
+	fmt.Println(array.Slice())
+
+	// Output:
+	// [gf_user gf_user_detail]
+}

container/garray/garray_z_example_test.go

@@ -1,132 +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 garray_test
-
-import (
-	"fmt"
-	"github.com/gogf/gf/frame/g"
-
-	"github.com/gogf/gf/container/garray"
-)
-
-func Example_basic() {
-	// A normal array.
-	a := garray.New()
-
-	// Adding items.
-	for i := 0; i < 10; i++ {
-		a.Append(i)
-	}
-
-	// Print the array length.
-	fmt.Println(a.Len())
-
-	// Print the array items.
-	fmt.Println(a.Slice())
-
-	// Retrieve item by index.
-	fmt.Println(a.Get(6))
-
-	// Check item existence.
-	fmt.Println(a.Contains(6))
-	fmt.Println(a.Contains(100))
-
-	// Insert item before specified index.
-	a.InsertAfter(9, 11)
-	// Insert item after specified index.
-	a.InsertBefore(10, 10)
-
-	fmt.Println(a.Slice())
-
-	// Modify item by index.
-	a.Set(0, 100)
-	fmt.Println(a.Slice())
-
-	// Search item and return its index.
-	fmt.Println(a.Search(5))
-
-	// Remove item by index.
-	a.Remove(0)
-	fmt.Println(a.Slice())
-
-	// Empty the array, removes all items of it.
-	fmt.Println(a.Slice())
-	a.Clear()
-	fmt.Println(a.Slice())
-
-	// Output:
-	// 10
-	// [0 1 2 3 4 5 6 7 8 9]
-	// 6 true
-	// true
-	// false
-	// [0 1 2 3 4 5 6 7 8 9 10 11]
-	// [100 1 2 3 4 5 6 7 8 9 10 11]
-	// 5
-	// [1 2 3 4 5 6 7 8 9 10 11]
-	// [1 2 3 4 5 6 7 8 9 10 11]
-	// []
-}
-
-func Example_rand() {
-	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
-
-	// Randomly retrieve and return 2 items from the array.
-	// It does not delete the items from array.
-	fmt.Println(array.Rands(2))
-
-	// Randomly pick and return one item from the array.
-	// It deletes the picked up item from array.
-	fmt.Println(array.PopRand())
-}
-
-func Example_popItem() {
-	array := garray.NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
-
-	// Any Pop* functions pick, delete and return the item from array.
-
-	fmt.Println(array.PopLeft())
-	fmt.Println(array.PopLefts(2))
-	fmt.Println(array.PopRight())
-	fmt.Println(array.PopRights(2))
-
-	// Output:
-	// 1 true
-	// [2 3]
-	// 9 true
-	// [7 8]
-}
-
-func Example_mergeArray() {
-	array1 := garray.NewFrom([]interface{}{1, 2})
-	array2 := garray.NewFrom([]interface{}{3, 4})
-	slice1 := []interface{}{5, 6}
-	slice2 := []int{7, 8}
-	slice3 := []string{"9", "0"}
-	fmt.Println(array1.Slice())
-	array1.Merge(array1)
-	array1.Merge(array2)
-	array1.Merge(slice1)
-	array1.Merge(slice2)
-	array1.Merge(slice3)
-	fmt.Println(array1.Slice())
-
-	// Output:
-	// [1 2]
-	// [1 2 1 2 3 4 5 6 7 8 9 0]
-}
-
-func Example_filter() {
-	array1 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
-	array2 := garray.NewFrom(g.Slice{0, 1, 2, nil, "", g.Slice{}, "john"})
-	fmt.Printf("%#v\n", array1.FilterNil().Slice())
-	fmt.Printf("%#v\n", array2.FilterEmpty().Slice())
-
-	// Output:
-	// []interface {}{0, 1, 2, "", []interface {}{}, "john"}
-	// []interface {}{1, 2, "john"}
-}

container/garray/garray_z_unit_normal_any_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"testing"
 	"time"
 
@@ -95,9 +95,9 @@ func TestArray_Sort(t *testing.T) {
 
 func TestArray_Unique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []interface{}{1, 1, 2, 3}
+		expect := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array := garray.NewArrayFrom(expect)
-		t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3})
+		t.Assert(array.Unique().Slice(), []interface{}{1, 2, 3, 4, 5})
 	})
 }
 
@@ -137,6 +137,65 @@ func TestArray_PopRands(t *testing.T) {
 	})
 }
 
+func TestArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopLefts(2), g.Slice{1, 2})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{3})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewFrom(g.Slice{1, 2, 3})
+		t.Assert(array.PopRights(2), g.Slice{2, 3})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{1})
+		t.Assert(array.Len(), 0)
+	})
+}
+
 func TestArray_PopLeftsAndPopRights(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.New()
@@ -501,6 +560,7 @@ func TestArray_RLockFunc(t *testing.T) {
 }
 
 func TestArray_Json(t *testing.T) {
+	// pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []interface{}{"a", "b", "d", "c"}
 		a1 := garray.NewArrayFrom(s1)
@@ -519,7 +579,26 @@ func TestArray_Json(t *testing.T) {
 		t.Assert(err, nil)
 		t.Assert(a3.Slice(), s1)
 	})
+	// value.
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []interface{}{"a", "b", "d", "c"}
+		a1 := *garray.NewArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.New()
+		err2 = json.Unmarshal(b2, &a2)
+		t.Assert(err2, nil)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.Array
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+	})
+	// pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -532,6 +611,25 @@ func TestArray_Json(t *testing.T) {
 		b, err := json.Marshal(data)
 		t.Assert(err, nil)
 
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+	// value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.Array
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
 		user := new(User)
 		err = json.Unmarshal(b, user)
 		t.Assert(err, nil)

container/garray/garray_z_unit_normal_int_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"testing"
 	"time"
 
@@ -87,9 +87,9 @@ func TestIntArray_Sort(t *testing.T) {
 
 func TestIntArray_Unique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []int{1, 1, 2, 3}
+		expect := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array := garray.NewIntArrayFrom(expect)
-		t.Assert(array.Unique().Slice(), []int{1, 2, 3})
+		t.Assert(array.Unique().Slice(), []int{1, 2, 3, 4, 5})
 	})
 }
 
@@ -230,6 +230,65 @@ func TestIntArray_Fill(t *testing.T) {
 	})
 }
 
+func TestIntArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestIntArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3})
+
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestIntArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3})
+		t.Assert(array.PopLefts(2), g.Slice{1, 2})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{3})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestIntArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewIntArrayFrom(g.SliceInt{1, 2, 3})
+		t.Assert(array.PopRights(2), g.Slice{2, 3})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{1})
+		t.Assert(array.Len(), 0)
+	})
+}
+
 func TestIntArray_Chunk(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{1, 2, 3, 4, 5}
@@ -546,6 +605,7 @@ func TestIntArray_RLockFunc(t *testing.T) {
 }
 
 func TestIntArray_Json(t *testing.T) {
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []int{1, 4, 3, 2}
 		a1 := garray.NewIntArrayFrom(s1)
@@ -563,7 +623,25 @@ func TestIntArray_Json(t *testing.T) {
 		t.Assert(err, nil)
 		t.Assert(a3.Slice(), s1)
 	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []int{1, 4, 3, 2}
+		a1 := *garray.NewIntArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.NewIntArray()
+		err1 = json.Unmarshal(b2, &a2)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.IntArray
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+	})
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -576,6 +654,25 @@ func TestIntArray_Json(t *testing.T) {
 		b, err := json.Marshal(data)
 		t.Assert(err, nil)
 
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.IntArray
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
 		user := new(User)
 		err = json.Unmarshal(b, user)
 		t.Assert(err, nil)

container/garray/garray_z_unit_normal_str_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"strings"
 	"testing"
 	"time"
@@ -64,6 +64,16 @@ func Test_StrArray_Basic(t *testing.T) {
 	})
 }
 
+func TestStrArray_ContainsI(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := garray.NewStrArray()
+		s.Append("a", "b", "C")
+		t.Assert(s.Contains("A"), false)
+		t.Assert(s.Contains("a"), true)
+		t.Assert(s.ContainsI("A"), true)
+	})
+}
+
 func TestStrArray_Sort(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		expect1 := []string{"0", "1", "2", "3"}
@@ -81,7 +91,7 @@ func TestStrArray_Sort(t *testing.T) {
 
 func TestStrArray_Unique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		expect := []string{"1", "1", "2", "3"}
+		expect := []string{"1", "1", "2", "2", "3", "3", "2", "2"}
 		array := garray.NewStrArrayFrom(expect)
 		t.Assert(array.Unique().Slice(), []string{"1", "2", "3"})
 	})
@@ -119,6 +129,65 @@ func TestStrArray_PushAndPop(t *testing.T) {
 	})
 }
 
+func TestStrArray_PopLeft(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2", "3"})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestStrArray_PopRight(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2", "3"})
+
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestStrArray_PopLefts(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2", "3"})
+		t.Assert(array.PopLefts(2), g.Slice{"1", "2"})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{"3"})
+		t.Assert(array.Len(), 0)
+	})
+}
+
+func TestStrArray_PopRights(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewStrArrayFrom(g.SliceStr{"1", "2", "3"})
+		t.Assert(array.PopRights(2), g.Slice{"2", "3"})
+		t.Assert(array.Len(), 1)
+		t.Assert(array.PopLefts(2), g.Slice{"1"})
+		t.Assert(array.Len(), 0)
+	})
+}
+
 func TestStrArray_PopLeftsAndPopRights(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		array := garray.NewStrArray()
@@ -535,6 +604,7 @@ func TestStrArray_LockFunc(t *testing.T) {
 }
 
 func TestStrArray_Json(t *testing.T) {
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []string{"a", "b", "d", "c"}
 		a1 := garray.NewStrArrayFrom(s1)
@@ -552,7 +622,25 @@ func TestStrArray_Json(t *testing.T) {
 		t.Assert(err, nil)
 		t.Assert(a3.Slice(), s1)
 	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		a1 := *garray.NewStrArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.NewStrArray()
+		err1 = json.Unmarshal(b2, &a2)
+		t.Assert(a2.Slice(), s1)
+
+		var a3 garray.StrArray
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+	})
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -565,6 +653,25 @@ func TestStrArray_Json(t *testing.T) {
 		b, err := json.Marshal(data)
 		t.Assert(err, nil)
 
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, data["Scores"])
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.StrArray
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []string{"A+", "A", "A"},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
 		user := new(User)
 		err = json.Unmarshal(b, user)
 		t.Assert(err, nil)

container/garray/garray_z_unit_sorted_any_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gutil"
 	"strings"
 	"testing"
@@ -148,34 +148,62 @@ func TestSortedArray_Remove(t *testing.T) {
 
 func TestSortedArray_PopLeft(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []interface{}{"a", "d", "c", "b"}
-		func1 := func(v1, v2 interface{}) int {
-			return strings.Compare(gconv.String(v1), gconv.String(v2))
-		}
-		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1 := garray.NewSortedArrayFrom(
+			[]interface{}{"a", "d", "c", "b"},
+			gutil.ComparatorString,
+		)
 		i1, ok := array1.PopLeft()
 		t.Assert(ok, true)
 		t.Assert(gconv.String(i1), "a")
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1, []interface{}{"b", "c", "d"})
 	})
-
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedArray_PopRight(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []interface{}{"a", "d", "c", "b"}
-		func1 := func(v1, v2 interface{}) int {
-			return strings.Compare(gconv.String(v1), gconv.String(v2))
-		}
-		array1 := garray.NewSortedArrayFrom(a1, func1)
+		array1 := garray.NewSortedArrayFrom(
+			[]interface{}{"a", "d", "c", "b"},
+			gutil.ComparatorString,
+		)
 		i1, ok := array1.PopRight()
 		t.Assert(ok, true)
 		t.Assert(gconv.String(i1), "d")
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1, []interface{}{"a", "b", "c"})
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedArrayFrom(g.Slice{1, 2, 3}, gutil.ComparatorInt)
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
 
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedArray_PopRand(t *testing.T) {
@@ -249,7 +277,6 @@ func TestSortedArray_PopLefts(t *testing.T) {
 		t.Assert(len(i2), 4)
 		t.AssertIN(i1, []interface{}{"a", "d", "c", "b", "e", "f"})
 		t.Assert(array1.Len(), 0)
-
 	})
 }
 
@@ -267,7 +294,7 @@ func TestSortedArray_PopRights(t *testing.T) {
 
 		i2 := array1.PopRights(10)
 		t.Assert(len(i2), 4)
-
+		t.Assert(array1.Len(), 0)
 	})
 }
 
@@ -499,15 +526,21 @@ func TestSortedArray_CountValues(t *testing.T) {
 
 func TestSortedArray_SetUnique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []interface{}{"a", "d", "c", "c"}
-
-		func1 := func(v1, v2 interface{}) int {
-			return strings.Compare(gconv.String(v1), gconv.String(v2))
-		}
-		array1 := garray.NewSortedArrayFrom(a1, func1)
+		a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
 		array1.SetUnique(true)
-		t.Assert(array1.Len(), 3)
-		t.Assert(array1, []interface{}{"a", "c", "d"})
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
+	})
+}
+
+func TestSortedArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []interface{}{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedArrayFrom(a1, gutil.ComparatorInt)
+		array1.Unique()
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []interface{}{1, 2, 3, 4, 5})
 	})
 }
 
@@ -612,6 +645,7 @@ func TestSortedArray_Merge(t *testing.T) {
 }
 
 func TestSortedArray_Json(t *testing.T) {
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []interface{}{"a", "b", "d", "c"}
 		s2 := []interface{}{"a", "b", "c", "d"}
@@ -631,7 +665,27 @@ func TestSortedArray_Json(t *testing.T) {
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []interface{}{"a", "b", "d", "c"}
+		s2 := []interface{}{"a", "b", "c", "d"}
+		a1 := *garray.NewSortedArrayFrom(s1, gutil.ComparatorString)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.NewSortedArray(gutil.ComparatorString)
+		err1 = json.Unmarshal(b2, &a2)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedArray
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -663,6 +717,42 @@ func TestSortedArray_Json(t *testing.T) {
 		t.AssertIN(v, data["Scores"])
 		t.Assert(ok, true)
 
+		v, ok = user.Scores.PopLeft()
+		t.Assert(v, nil)
+		t.Assert(ok, false)
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.SortedArray
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.AssertNE(user.Scores, nil)
+		t.Assert(user.Scores.Len(), 3)
+
+		v, ok := user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
+		v, ok = user.Scores.PopLeft()
+		t.AssertIN(v, data["Scores"])
+		t.Assert(ok, true)
+
 		v, ok = user.Scores.PopLeft()
 		t.Assert(v, nil)
 		t.Assert(ok, false)

container/garray/garray_z_unit_sorted_int_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"testing"
 	"time"
 
@@ -133,6 +133,21 @@ func TestSortedIntArray_PopLeft(t *testing.T) {
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1.Search(1), -1)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedIntArray_PopRight(t *testing.T) {
@@ -145,6 +160,23 @@ func TestSortedIntArray_PopRight(t *testing.T) {
 		t.Assert(array1.Len(), 3)
 		t.Assert(array1.Search(5), -1)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedIntArrayFrom(g.SliceInt{1, 2, 3})
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedIntArray_PopRand(t *testing.T) {
@@ -404,7 +436,7 @@ func TestSortedIntArray_CountValues(t *testing.T) {
 
 func TestSortedIntArray_SetUnique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []int{1, 2, 3, 4, 5, 3}
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
 		array1.SetUnique(true)
 		t.Assert(array1.Len(), 5)
@@ -412,6 +444,16 @@ func TestSortedIntArray_SetUnique(t *testing.T) {
 	})
 }
 
+func TestSortedIntArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []int{1, 2, 3, 4, 5, 3, 2, 2, 3, 5, 5}
+		array1 := garray.NewSortedIntArrayFrom(a1)
+		array1.Unique()
+		t.Assert(array1.Len(), 5)
+		t.Assert(array1, []int{1, 2, 3, 4, 5})
+	})
+}
+
 func TestSortedIntArray_LockFunc(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []int{1, 2, 3, 4}
@@ -504,6 +546,7 @@ func TestSortedIntArray_Merge(t *testing.T) {
 }
 
 func TestSortedIntArray_Json(t *testing.T) {
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []int{1, 4, 3, 2}
 		s2 := []int{1, 2, 3, 4}
@@ -522,7 +565,26 @@ func TestSortedIntArray_Json(t *testing.T) {
 		t.Assert(err, nil)
 		t.Assert(a3.Slice(), s1)
 	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []int{1, 4, 3, 2}
+		s2 := []int{1, 2, 3, 4}
+		a1 := *garray.NewSortedIntArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.NewSortedIntArray()
+		err1 = json.Unmarshal(b2, &a2)
+		t.Assert(a2.Slice(), s2)
+
+		var a3 garray.SortedIntArray
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+	})
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -535,6 +597,25 @@ func TestSortedIntArray_Json(t *testing.T) {
 		b, err := json.Marshal(data)
 		t.Assert(err, nil)
 
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, []int{98, 99, 100})
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.SortedIntArray
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []int{99, 100, 98},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
 		user := new(User)
 		err = json.Unmarshal(b, user)
 		t.Assert(err, nil)

container/garray/garray_z_unit_sorted_str_array_test.go

@@ -9,8 +9,8 @@
 package garray_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"testing"
 	"time"
 
@@ -51,6 +51,16 @@ func TestSortedStrArray_SetArray(t *testing.T) {
 	})
 }
 
+func TestSortedStrArray_ContainsI(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		s := garray.NewSortedStrArray()
+		s.Append("a", "b", "C")
+		t.Assert(s.Contains("A"), false)
+		t.Assert(s.Contains("a"), true)
+		t.Assert(s.ContainsI("A"), true)
+	})
+}
+
 func TestSortedStrArray_Sort(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []string{"a", "d", "c", "b"}
@@ -127,6 +137,21 @@ func TestSortedStrArray_PopLeft(t *testing.T) {
 		t.Assert(array1.Len(), 4)
 		t.Assert(array1.Contains("a"), false)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2", "3"})
+		v, ok := array.PopLeft()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+		v, ok = array.PopLeft()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+		v, ok = array.PopLeft()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedStrArray_PopRight(t *testing.T) {
@@ -139,6 +164,23 @@ func TestSortedStrArray_PopRight(t *testing.T) {
 		t.Assert(array1.Len(), 4)
 		t.Assert(array1.Contains("e"), false)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		array := garray.NewSortedStrArrayFrom(g.SliceStr{"1", "2", "3"})
+		v, ok := array.PopRight()
+		t.Assert(v, 3)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 2)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 2)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 1)
+
+		v, ok = array.PopRight()
+		t.Assert(v, 1)
+		t.Assert(ok, true)
+		t.Assert(array.Len(), 0)
+	})
 }
 
 func TestSortedStrArray_PopRand(t *testing.T) {
@@ -200,6 +242,7 @@ func TestSortedStrArray_PopLefts(t *testing.T) {
 		s1 = array1.PopLefts(4)
 		t.Assert(len(s1), 3)
 		t.Assert(s1, []string{"c", "d", "e"})
+		t.Assert(array1.Len(), 0)
 	})
 }
 
@@ -411,11 +454,21 @@ func TestSortedStrArray_Chunk(t *testing.T) {
 
 func TestSortedStrArray_SetUnique(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		a1 := []string{"e", "a", "d", "a", "c"}
+		a1 := []string{"1", "1", "2", "2", "3", "3", "2", "2"}
 		array1 := garray.NewSortedStrArrayFrom(a1)
 		array2 := array1.SetUnique(true)
-		t.Assert(array2.Len(), 4)
-		t.Assert(array2, []string{"a", "c", "d", "e"})
+		t.Assert(array2.Len(), 3)
+		t.Assert(array2, []string{"1", "2", "3"})
+	})
+}
+
+func TestSortedStrArray_Unique(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		a1 := []string{"1", "1", "2", "2", "3", "3", "2", "2"}
+		array1 := garray.NewSortedStrArrayFrom(a1)
+		array1.Unique()
+		t.Assert(array1.Len(), 3)
+		t.Assert(array1, []string{"1", "2", "3"})
 	})
 }
 
@@ -513,6 +566,7 @@ func TestSortedStrArray_Merge(t *testing.T) {
 }
 
 func TestSortedStrArray_Json(t *testing.T) {
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		s1 := []string{"a", "b", "d", "c"}
 		s2 := []string{"a", "b", "c", "d"}
@@ -533,7 +587,28 @@ func TestSortedStrArray_Json(t *testing.T) {
 		t.Assert(a3.Slice(), s1)
 		t.Assert(a3.Interfaces(), s1)
 	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		s1 := []string{"a", "b", "d", "c"}
+		s2 := []string{"a", "b", "c", "d"}
+		a1 := *garray.NewSortedStrArrayFrom(s1)
+		b1, err1 := json.Marshal(a1)
+		b2, err2 := json.Marshal(s1)
+		t.Assert(b1, b2)
+		t.Assert(err1, err2)
 
+		a2 := garray.NewSortedStrArray()
+		err1 = json.Unmarshal(b2, &a2)
+		t.Assert(a2.Slice(), s2)
+		t.Assert(a2.Interfaces(), s2)
+
+		var a3 garray.SortedStrArray
+		err := json.Unmarshal(b2, &a3)
+		t.Assert(err, nil)
+		t.Assert(a3.Slice(), s1)
+		t.Assert(a3.Interfaces(), s1)
+	})
+	// array pointer
 	gtest.C(t, func(t *gtest.T) {
 		type User struct {
 			Name   string
@@ -546,6 +621,25 @@ func TestSortedStrArray_Json(t *testing.T) {
 		b, err := json.Marshal(data)
 		t.Assert(err, nil)
 
+		user := new(User)
+		err = json.Unmarshal(b, user)
+		t.Assert(err, nil)
+		t.Assert(user.Name, data["Name"])
+		t.Assert(user.Scores, []string{"A", "A", "A+"})
+	})
+	// array value
+	gtest.C(t, func(t *gtest.T) {
+		type User struct {
+			Name   string
+			Scores garray.SortedStrArray
+		}
+		data := g.Map{
+			"Name":   "john",
+			"Scores": []string{"A+", "A", "A"},
+		}
+		b, err := json.Marshal(data)
+		t.Assert(err, nil)
+
 		user := new(User)
 		err = json.Unmarshal(b, user)
 		t.Assert(err, nil)

container/gchan/gchan.go

@@ -1,70 +0,0 @@
-// Copyright 2017 gf Author(https://github.com/gogf/gf). All Rights Reserved.
-//
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file,
-// You can obtain one at https://github.com/gogf/gf.
-
-// Package gchan provides graceful channel for no panic operations.
-//
-// It's safe to call Chan.Push/Close functions repeatedly.
-package gchan
-
-import (
-	"errors"
-
-	"github.com/gogf/gf/container/gtype"
-)
-
-// Graceful channel.
-type Chan struct {
-	channel chan interface{}
-	closed  *gtype.Bool
-}
-
-// New creates a graceful channel with given <limit>.
-func New(limit int) *Chan {
-	return &Chan{
-		channel: make(chan interface{}, limit),
-		closed:  gtype.NewBool(),
-	}
-}
-
-// Push pushes <value> to channel.
-// It is safe to be called repeatedly.
-func (c *Chan) Push(value interface{}) error {
-	if c.closed.Val() {
-		return errors.New("channel is closed")
-	}
-	c.channel <- value
-	return nil
-}
-
-// Pop pops value from channel.
-// If there's no value in channel, it would block to wait.
-// If the channel is closed, it will return a nil value immediately.
-func (c *Chan) Pop() interface{} {
-	return <-c.channel
-}
-
-// Close closes the channel.
-// It is safe to be called repeatedly.
-func (c *Chan) Close() {
-	if !c.closed.Set(true) {
-		close(c.channel)
-	}
-}
-
-// See Len.
-func (c *Chan) Size() int {
-	return c.Len()
-}
-
-// Len returns the length of the channel.
-func (c *Chan) Len() int {
-	return len(c.channel)
-}
-
-// Cap returns the capacity of the channel.
-func (c *Chan) Cap() int {
-	return cap(c.channel)
-}

container/gchan/gchan_example_test.go

@@ -1,30 +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 gchan_test
-
-import (
-	"fmt"
-
-	"github.com/gogf/gf/container/gchan"
-)
-
-func Example_basic() {
-	n := 10
-	c := gchan.New(n)
-	for i := 0; i < n; i++ {
-		c.Push(i)
-	}
-	fmt.Println(c.Len(), c.Cap())
-	for i := 0; i < n; i++ {
-		fmt.Print(c.Pop())
-	}
-	c.Close()
-
-	// Output:
-	//10 10
-	//0123456789
-}

container/gchan/gchan_z_unit_test.go

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

container/glist/glist.go

@@ -5,25 +5,26 @@
 // You can obtain one at https://github.com/gogf/gf.
 //
 
-// Package glist provides a concurrent-safe/unsafe doubly linked list.
+// Package glist provides most commonly used doubly linked list container which also supports concurrent-safe/unsafe switch feature.
 package glist
 
 import (
 	"bytes"
 	"container/list"
-	"encoding/json"
-	"github.com/gogf/gf/text/gstr"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 
 	"github.com/gogf/gf/internal/rwmutex"
 )
 
 type (
+	// List is a doubly linked list containing a concurrent-safe/unsafe switch.
+	// The switch should be set when its initialization and cannot be changed then.
 	List struct {
 		mu   rwmutex.RWMutex
-		list list.List
+		list *list.List
 	}
-
+	// Element the item type of the list.
 	Element = list.Element
 )
 
@@ -31,7 +32,7 @@ type (
 func New(safe ...bool) *List {
 	return &List{
 		mu:   rwmutex.Create(safe...),
-		list: list.List{},
+		list: list.New(),
 	}
 }
 
@@ -39,7 +40,7 @@ func New(safe ...bool) *List {
 // The parameter <safe> is used to specify whether using list in concurrent-safety,
 // which is false in default.
 func NewFrom(array []interface{}, safe ...bool) *List {
-	l := list.List{}
+	l := list.New()
 	for _, v := range array {
 		l.PushBack(v)
 	}
@@ -52,6 +53,9 @@ func NewFrom(array []interface{}, safe ...bool) *List {
 // PushFront inserts a new element <e> with value <v> at the front of list <l> and returns <e>.
 func (l *List) PushFront(v interface{}) (e *Element) {
 	l.mu.Lock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	e = l.list.PushFront(v)
 	l.mu.Unlock()
 	return
@@ -60,6 +64,9 @@ func (l *List) PushFront(v interface{}) (e *Element) {
 // PushBack inserts a new element <e> with value <v> at the back of list <l> and returns <e>.
 func (l *List) PushBack(v interface{}) (e *Element) {
 	l.mu.Lock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	e = l.list.PushBack(v)
 	l.mu.Unlock()
 	return
@@ -68,6 +75,9 @@ func (l *List) PushBack(v interface{}) (e *Element) {
 // PushFronts inserts multiple new elements with values <values> at the front of list <l>.
 func (l *List) PushFronts(values []interface{}) {
 	l.mu.Lock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	for _, v := range values {
 		l.list.PushFront(v)
 	}
@@ -77,6 +87,9 @@ func (l *List) PushFronts(values []interface{}) {
 // PushBacks inserts multiple new elements with values <values> at the back of list <l>.
 func (l *List) PushBacks(values []interface{}) {
 	l.mu.Lock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	for _, v := range values {
 		l.list.PushBack(v)
 	}
@@ -86,20 +99,28 @@ func (l *List) PushBacks(values []interface{}) {
 // PopBack removes the element from back of <l> and returns the value of the element.
 func (l *List) PopBack() (value interface{}) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+		return
+	}
 	if e := l.list.Back(); e != nil {
 		value = l.list.Remove(e)
 	}
-	l.mu.Unlock()
 	return
 }
 
 // PopFront removes the element from front of <l> and returns the value of the element.
 func (l *List) PopFront() (value interface{}) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+		return
+	}
 	if e := l.list.Front(); e != nil {
 		value = l.list.Remove(e)
 	}
-	l.mu.Unlock()
 	return
 }
 
@@ -107,6 +128,11 @@ func (l *List) PopFront() (value interface{}) {
 // and returns values of the removed elements as slice.
 func (l *List) PopBacks(max int) (values []interface{}) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		if max > 0 && max < length {
@@ -117,7 +143,6 @@ func (l *List) PopBacks(max int) (values []interface{}) {
 			values[i] = l.list.Remove(l.list.Back())
 		}
 	}
-	l.mu.Unlock()
 	return
 }
 
@@ -125,6 +150,11 @@ func (l *List) PopBacks(max int) (values []interface{}) {
 // and returns values of the removed elements as slice.
 func (l *List) PopFronts(max int) (values []interface{}) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		if max > 0 && max < length {
@@ -135,7 +165,6 @@ func (l *List) PopFronts(max int) (values []interface{}) {
 			values[i] = l.list.Remove(l.list.Front())
 		}
 	}
-	l.mu.Unlock()
 	return
 }
 
@@ -154,6 +183,10 @@ func (l *List) PopFrontAll() []interface{} {
 // FrontAll copies and returns values of all elements from front of <l> as slice.
 func (l *List) FrontAll() (values []interface{}) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		values = make([]interface{}, length)
@@ -161,13 +194,16 @@ func (l *List) FrontAll() (values []interface{}) {
 			values[i] = e.Value
 		}
 	}
-	l.mu.RUnlock()
 	return
 }
 
 // BackAll copies and returns values of all elements from back of <l> as slice.
 func (l *List) BackAll() (values []interface{}) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		values = make([]interface{}, length)
@@ -175,43 +211,54 @@ func (l *List) BackAll() (values []interface{}) {
 			values[i] = e.Value
 		}
 	}
-	l.mu.RUnlock()
 	return
 }
 
 // FrontValue returns value of the first element of <l> or nil if the list is empty.
 func (l *List) FrontValue() (value interface{}) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	if e := l.list.Front(); e != nil {
 		value = e.Value
 	}
-	l.mu.RUnlock()
 	return
 }
 
 // BackValue returns value of the last element of <l> or nil if the list is empty.
 func (l *List) BackValue() (value interface{}) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	if e := l.list.Back(); e != nil {
 		value = e.Value
 	}
-	l.mu.RUnlock()
 	return
 }
 
 // Front returns the first element of list <l> or nil if the list is empty.
 func (l *List) Front() (e *Element) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	e = l.list.Front()
-	l.mu.RUnlock()
 	return
 }
 
 // Back returns the last element of list <l> or nil if the list is empty.
 func (l *List) Back() (e *Element) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	e = l.list.Back()
-	l.mu.RUnlock()
 	return
 }
 
@@ -219,8 +266,11 @@ func (l *List) Back() (e *Element) {
 // The complexity is O(1).
 func (l *List) Len() (length int) {
 	l.mu.RLock()
+	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	length = l.list.Len()
-	l.mu.RUnlock()
 	return
 }
 
@@ -234,8 +284,11 @@ func (l *List) Size() int {
 // The element and <p> must not be nil.
 func (l *List) MoveBefore(e, p *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	l.list.MoveBefore(e, p)
-	l.mu.Unlock()
 }
 
 // MoveAfter moves element <e> to its new position after <p>.
@@ -243,8 +296,11 @@ func (l *List) MoveBefore(e, p *Element) {
 // The element and <p> must not be nil.
 func (l *List) MoveAfter(e, p *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	l.list.MoveAfter(e, p)
-	l.mu.Unlock()
 }
 
 // MoveToFront moves element <e> to the front of list <l>.
@@ -252,8 +308,11 @@ func (l *List) MoveAfter(e, p *Element) {
 // The element must not be nil.
 func (l *List) MoveToFront(e *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	l.list.MoveToFront(e)
-	l.mu.Unlock()
 }
 
 // MoveToBack moves element <e> to the back of list <l>.
@@ -261,8 +320,11 @@ func (l *List) MoveToFront(e *Element) {
 // The element must not be nil.
 func (l *List) MoveToBack(e *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	l.list.MoveToBack(e)
-	l.mu.Unlock()
 }
 
 // PushBackList inserts a copy of an other list at the back of list <l>.
@@ -273,8 +335,11 @@ func (l *List) PushBackList(other *List) {
 		defer other.mu.RUnlock()
 	}
 	l.mu.Lock()
-	l.list.PushBackList(&other.list)
-	l.mu.Unlock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
+	l.list.PushBackList(other.list)
 }
 
 // PushFrontList inserts a copy of an other list at the front of list <l>.
@@ -285,8 +350,11 @@ func (l *List) PushFrontList(other *List) {
 		defer other.mu.RUnlock()
 	}
 	l.mu.Lock()
-	l.list.PushFrontList(&other.list)
-	l.mu.Unlock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
+	l.list.PushFrontList(other.list)
 }
 
 // InsertAfter inserts a new element <e> with value <v> immediately after <p> and returns <e>.
@@ -294,8 +362,11 @@ func (l *List) PushFrontList(other *List) {
 // The <p> must not be nil.
 func (l *List) InsertAfter(p *Element, v interface{}) (e *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	e = l.list.InsertAfter(v, p)
-	l.mu.Unlock()
 	return
 }
 
@@ -304,8 +375,11 @@ func (l *List) InsertAfter(p *Element, v interface{}) (e *Element) {
 // The <p> must not be nil.
 func (l *List) InsertBefore(p *Element, v interface{}) (e *Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	e = l.list.InsertBefore(v, p)
-	l.mu.Unlock()
 	return
 }
 
@@ -314,25 +388,31 @@ func (l *List) InsertBefore(p *Element, v interface{}) (e *Element) {
 // The element must not be nil.
 func (l *List) Remove(e *Element) (value interface{}) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	value = l.list.Remove(e)
-	l.mu.Unlock()
 	return
 }
 
 // Removes removes multiple elements <es> from <l> if <es> are elements of list <l>.
 func (l *List) Removes(es []*Element) {
 	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	for _, e := range es {
 		l.list.Remove(e)
 	}
-	l.mu.Unlock()
 	return
 }
 
 // RemoveAll removes all elements from list <l>.
 func (l *List) RemoveAll() {
 	l.mu.Lock()
-	l.list = list.List{}
+	l.list = list.New()
 	l.mu.Unlock()
 }
 
@@ -345,14 +425,19 @@ func (l *List) Clear() {
 func (l *List) RLockFunc(f func(list *list.List)) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
-	f(&l.list)
+	if l.list != nil {
+		f(l.list)
+	}
 }
 
 // LockFunc locks writing with given callback function <f> within RWMutex.Lock.
 func (l *List) LockFunc(f func(list *list.List)) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
-	f(&l.list)
+	if l.list == nil {
+		l.list = list.New()
+	}
+	f(l.list)
 }
 
 // Iterator is alias of IteratorAsc.
@@ -365,6 +450,9 @@ func (l *List) Iterator(f func(e *Element) bool) {
 func (l *List) IteratorAsc(f func(e *Element) bool) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
@@ -380,6 +468,9 @@ func (l *List) IteratorAsc(f func(e *Element) bool) {
 func (l *List) IteratorDesc(f func(e *Element) bool) {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
+	if l.list == nil {
+		return
+	}
 	length := l.list.Len()
 	if length > 0 {
 		for i, e := 0, l.list.Back(); i < length; i, e = i+1, e.Prev() {
@@ -394,17 +485,14 @@ func (l *List) IteratorDesc(f func(e *Element) bool) {
 func (l *List) Join(glue string) string {
 	l.mu.RLock()
 	defer l.mu.RUnlock()
+	if l.list == nil {
+		return ""
+	}
 	buffer := bytes.NewBuffer(nil)
 	length := l.list.Len()
 	if length > 0 {
-		s := ""
 		for i, e := 0, l.list.Front(); i < length; i, e = i+1, e.Next() {
-			s = gconv.String(e.Value)
-			if gstr.IsNumeric(s) {
-				buffer.WriteString(s)
-			} else {
-				buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
-			}
+			buffer.WriteString(gconv.String(e.Value))
 			if i != length-1 {
 				buffer.WriteString(glue)
 			}
@@ -427,6 +515,9 @@ func (l *List) MarshalJSON() ([]byte, error) {
 func (l *List) UnmarshalJSON(b []byte) error {
 	l.mu.Lock()
 	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	var array []interface{}
 	if err := json.Unmarshal(b, &array); err != nil {
 		return err
@@ -439,6 +530,9 @@ func (l *List) UnmarshalJSON(b []byte) error {
 func (l *List) UnmarshalValue(value interface{}) (err error) {
 	l.mu.Lock()
 	defer l.mu.Unlock()
+	if l.list == nil {
+		l.list = list.New()
+	}
 	var array []interface{}
 	switch value.(type) {
 	case string, []byte:

container/glist/glist_example_test.go

@@ -10,11 +10,12 @@ import (
 	"container/list"
 	"fmt"
 	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/frame/g"
 
 	"github.com/gogf/gf/container/glist"
 )
 
-func Example_basic() {
+func ExampleNew() {
 	n := 10
 	l := glist.New()
 	for i := 0; i < n; i++ {
@@ -31,14 +32,14 @@ func Example_basic() {
 	fmt.Println(l.Len())
 
 	// Output:
-	//10
-	//[0 1 2 3 4 5 6 7 8 9]
-	//[9 8 7 6 5 4 3 2 1 0]
-	//0123456789
-	//0
+	// 10
+	// [0 1 2 3 4 5 6 7 8 9]
+	// [9 8 7 6 5 4 3 2 1 0]
+	// 0123456789
+	// 0
 }
 
-func Example_iterate() {
+func ExampleList_RLockFunc() {
 	// concurrent-safe list.
 	l := glist.NewFrom(garray.NewArrayRange(1, 10, 1).Slice(), true)
 	// iterate reading from head.
@@ -62,21 +63,39 @@ func Example_iterate() {
 	})
 
 	fmt.Println()
+	// Output:
+	// 12345678910
+	// 10987654321
+}
 
+func ExampleList_IteratorAsc() {
+	// concurrent-safe list.
+	l := glist.NewFrom(garray.NewArrayRange(1, 10, 1).Slice(), true)
 	// iterate reading from head using IteratorAsc.
 	l.IteratorAsc(func(e *glist.Element) bool {
 		fmt.Print(e.Value)
 		return true
 	})
-	fmt.Println()
+
+	// Output:
+	// 12345678910
+}
+
+func ExampleList_IteratorDesc() {
+	// concurrent-safe list.
+	l := glist.NewFrom(garray.NewArrayRange(1, 10, 1).Slice(), true)
 	// iterate reading from tail using IteratorDesc.
 	l.IteratorDesc(func(e *glist.Element) bool {
 		fmt.Print(e.Value)
 		return true
 	})
+	// Output:
+	// 10987654321
+}
 
-	fmt.Println()
-
+func ExampleList_LockFunc() {
+	// concurrent-safe list.
+	l := glist.NewFrom(garray.NewArrayRange(1, 10, 1).Slice(), true)
 	// iterate writing from head.
 	l.LockFunc(func(list *list.List) {
 		length := list.Len()
@@ -91,10 +110,51 @@ func Example_iterate() {
 	})
 	fmt.Println(l)
 
-	//output:
-	//12345678910
-	//10987654321
-	//12345678910
-	//10987654321
-	//[1,2,3,4,5,"M",7,8,9,10]
+	// Output:
+	// [1,2,3,4,5,M,7,8,9,10]
+}
+
+func ExampleList_PopBack() {
+	l := glist.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	fmt.Println(l.PopBack())
+
+	// Output:
+	// 9
+}
+func ExampleList_PopBacks() {
+	l := glist.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	fmt.Println(l.PopBacks(2))
+
+	// Output:
+	// [9 8]
+}
+
+func ExampleList_PopFront() {
+	l := glist.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	fmt.Println(l.PopFront())
+
+	// Output:
+	// 1
+}
+
+func ExampleList_PopFronts() {
+	l := glist.NewFrom(g.Slice{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+	fmt.Println(l.PopFronts(2))
+
+	// Output:
+	// [1 2]
+}
+
+func ExampleList_Join() {
+	var l glist.List
+	l.PushBacks(g.Slice{"a", "b", "c", "d"})
+
+	fmt.Println(l.Join(","))
+
+	// Output:
+	// a,b,c,d
 }

container/glist/glist_z_unit_test.go

@@ -8,14 +8,13 @@ package glist
 
 import (
 	"container/list"
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/test/gtest"
 	"github.com/gogf/gf/util/gconv"
 
 	"testing"
 )
 
-// 检查链表长度
 func checkListLen(t *gtest.T, l *List, len int) bool {
 	if n := l.Len(); n != len {
 		t.Errorf("l.Len() = %d, want %d", n, len)
@@ -24,7 +23,6 @@ func checkListLen(t *gtest.T, l *List, len int) bool {
 	return true
 }
 
-// 检查指针地址
 func checkListPointers(t *gtest.T, l *List, es []*Element) {
 	if !checkListLen(t, l, len(es)) {
 		return
@@ -605,6 +603,17 @@ func TestList_Removes(t *testing.T) {
 	})
 }
 
+func TestList_Pop(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		l := NewFrom([]interface{}{1, 2, 3, 4, 5, 6, 7, 8, 9})
+
+		t.Assert(l.PopBack(), 9)
+		t.Assert(l.PopBacks(2), []interface{}{8, 7})
+		t.Assert(l.PopFront(), 1)
+		t.Assert(l.PopFronts(2), []interface{}{2, 3})
+	})
+}
+
 func TestList_Clear(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := New()
@@ -672,15 +681,15 @@ func TestList_Iterator(t *testing.T) {
 func TestList_Join(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
-		t.Assert(l.Join(","), `1,2,"a","\"b\"","\\c"`)
-		t.Assert(l.Join("."), `1.2."a"."\"b\""."\\c"`)
+		t.Assert(l.Join(","), `1,2,a,"b",\c`)
+		t.Assert(l.Join("."), `1.2.a."b".\c`)
 	})
 }
 
 func TestList_String(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		l := NewFrom([]interface{}{1, 2, "a", `"b"`, `\c`})
-		t.Assert(l.String(), `[1,2,"a","\"b\"","\\c"]`)
+		t.Assert(l.String(), `[1,2,a,"b",\c]`)
 	})
 }
 

container/gmap/gmap.go

@@ -4,7 +4,7 @@
 // If a copy of the MIT was not distributed with gm file,
 // You can obtain one at https://github.com/gogf/gf.
 
-// Package gmap provides concurrent-safe/unsafe map containers.
+// Package gmap provides most commonly used map container which also support concurrent-safe/unsafe switch feature.
 package gmap
 
 type (

container/gmap/gmap_hash_any_any_map.go

@@ -7,7 +7,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -98,6 +98,7 @@ func (m *AnyAnyMap) MapStrAny() map[string]interface{} {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *AnyAnyMap) FilterEmpty() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
@@ -108,6 +109,17 @@ func (m *AnyAnyMap) FilterEmpty() {
 	}
 }
 
+// FilterNil deletes all key-value pair of which the value is nil.
+func (m *AnyAnyMap) FilterNil() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
+}
+
 // Set sets key-value to the hash map.
 func (m *AnyAnyMap) Set(key interface{}, value interface{}) {
 	m.mu.Lock()
@@ -445,6 +457,12 @@ func (m *AnyAnyMap) Merge(other *AnyAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *AnyAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *AnyAnyMap) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))

container/gmap/gmap_hash_int_any_map.go

@@ -8,7 +8,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -56,7 +56,7 @@ func (m *IntAnyMap) Iterator(f func(k int, v interface{}) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *IntAnyMap) Clone() *IntAnyMap {
-	return NewIntAnyMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewIntAnyMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -98,6 +98,7 @@ func (m *IntAnyMap) MapCopy() map[int]interface{} {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntAnyMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -108,6 +109,17 @@ func (m *IntAnyMap) FilterEmpty() {
 	m.mu.Unlock()
 }
 
+// FilterNil deletes all key-value pair of which the value is nil.
+func (m *IntAnyMap) FilterNil() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
+}
+
 // Set sets key-value to the hash map.
 func (m *IntAnyMap) Set(key int, val interface{}) {
 	m.mu.Lock()
@@ -443,6 +455,12 @@ func (m *IntAnyMap) Merge(other *IntAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_int_int_map.go

@@ -7,7 +7,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 
 	"github.com/gogf/gf/internal/empty"
@@ -54,7 +54,7 @@ func (m *IntIntMap) Iterator(f func(k int, v int) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *IntIntMap) Clone() *IntIntMap {
-	return NewIntIntMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewIntIntMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -96,6 +96,7 @@ func (m *IntIntMap) MapCopy() map[int]int {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntIntMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -425,6 +426,12 @@ func (m *IntIntMap) Merge(other *IntIntMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntIntMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_int_str_map.go

@@ -7,7 +7,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -54,7 +54,7 @@ func (m *IntStrMap) Iterator(f func(k int, v string) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *IntStrMap) Clone() *IntStrMap {
-	return NewIntStrMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewIntStrMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -96,6 +96,7 @@ func (m *IntStrMap) MapCopy() map[int]string {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *IntStrMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -425,6 +426,12 @@ func (m *IntStrMap) Merge(other *IntStrMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *IntStrMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *IntStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_any_map.go

@@ -8,7 +8,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -56,7 +56,7 @@ func (m *StrAnyMap) Iterator(f func(k string, v interface{}) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *StrAnyMap) Clone() *StrAnyMap {
-	return NewStrAnyMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewStrAnyMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -92,6 +92,7 @@ func (m *StrAnyMap) MapCopy() map[string]interface{} {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrAnyMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -102,6 +103,17 @@ func (m *StrAnyMap) FilterEmpty() {
 	m.mu.Unlock()
 }
 
+// FilterNil deletes all key-value pair of which the value is nil.
+func (m *StrAnyMap) FilterNil() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	for k, v := range m.data {
+		if empty.IsNil(v) {
+			delete(m.data, k)
+		}
+	}
+}
+
 // Set sets key-value to the hash map.
 func (m *StrAnyMap) Set(key string, val interface{}) {
 	m.mu.Lock()
@@ -439,6 +451,12 @@ func (m *StrAnyMap) Merge(other *StrAnyMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrAnyMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrAnyMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_int_map.go

@@ -8,7 +8,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 	"github.com/gogf/gf/internal/rwmutex"
@@ -54,7 +54,7 @@ func (m *StrIntMap) Iterator(f func(k string, v int) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *StrIntMap) Clone() *StrIntMap {
-	return NewStrIntMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewStrIntMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -96,6 +96,7 @@ func (m *StrIntMap) MapCopy() map[string]int {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrIntMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -428,6 +429,12 @@ func (m *StrIntMap) Merge(other *StrIntMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrIntMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrIntMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_hash_str_str_map.go

@@ -8,7 +8,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 
 	"github.com/gogf/gf/internal/empty"
@@ -55,7 +55,7 @@ func (m *StrStrMap) Iterator(f func(k string, v string) bool) {
 
 // Clone returns a new hash map with copy of current map data.
 func (m *StrStrMap) Clone() *StrStrMap {
-	return NewStrStrMapFrom(m.MapCopy(), !m.mu.IsSafe())
+	return NewStrStrMapFrom(m.MapCopy(), m.mu.IsSafe())
 }
 
 // Map returns the underlying data map.
@@ -97,6 +97,7 @@ func (m *StrStrMap) MapCopy() map[string]string {
 }
 
 // FilterEmpty deletes all key-value pair of which the value is empty.
+// Values like: 0, nil, false, "", len(slice/map/chan) == 0 are considered empty.
 func (m *StrStrMap) FilterEmpty() {
 	m.mu.Lock()
 	for k, v := range m.data {
@@ -428,6 +429,12 @@ func (m *StrStrMap) Merge(other *StrStrMap) {
 	}
 }
 
+// String returns the map as a string.
+func (m *StrStrMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *StrStrMap) MarshalJSON() ([]byte, error) {
 	m.mu.RLock()

container/gmap/gmap_list_map.go

@@ -7,7 +7,7 @@
 package gmap
 
 import (
-	"encoding/json"
+	"github.com/gogf/gf/internal/json"
 
 	"github.com/gogf/gf/internal/empty"
 
@@ -510,6 +510,12 @@ func (m *ListMap) Merge(other *ListMap) {
 	})
 }
 
+// String returns the map as a string.
+func (m *ListMap) String() string {
+	b, _ := m.MarshalJSON()
+	return gconv.UnsafeBytesToStr(b)
+}
+
 // MarshalJSON implements the interface MarshalJSON for json.Marshal.
 func (m *ListMap) MarshalJSON() ([]byte, error) {
 	return json.Marshal(gconv.Map(m.Map()))

container/gmap/gmap_z_example_any_any_test.go

@@ -0,0 +1,207 @@
+// Copyright 2019 gf Author(https://github.com/gogf/gf). All Rights Reserved.
+//
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with gm file,
+// You can obtain one at https://github.com/gogf/gf.
+
+package gmap_test
+
+import (
+	"fmt"
+	"github.com/gogf/gf/frame/g"
+
+	"github.com/gogf/gf/container/gmap"
+)
+
+func ExampleNew() {
+	m := gmap.New()
+
+	// Add data.
+	m.Set("key1", "val1")
+
+	// Print size.
+	fmt.Println(m.Size())
+
+	addMap := make(map[interface{}]interface{})
+	addMap["key2"] = "val2"
+	addMap["key3"] = "val3"
+	addMap[1] = 1
+
+	fmt.Println(m.Values())
+
+	// Batch add data.
+	m.Sets(addMap)
+
+	// Gets the value of the corresponding key.
+	fmt.Println(m.Get("key3"))
+
+	// Get the value by key, or set it with given key-value if not exist.
+	fmt.Println(m.GetOrSet("key4", "val4"))
+
+	// Set key-value if the key does not exist, then return true; or else return false.
+	fmt.Println(m.SetIfNotExist("key3", "val3"))
+
+	// Remove key
+	m.Remove("key2")
+	fmt.Println(m.Keys())
+
+	// Batch remove keys.
+	m.Removes([]interface{}{"key1", 1})
+	fmt.Println(m.Keys())
+
+	// Contains checks whether a key exists.
+	fmt.Println(m.Contains("key3"))
+
+	// Flip exchanges key-value of the map, it will change key-value to value-key.
+	m.Flip()
+	fmt.Println(m.Map())
+
+	// Clear deletes all data of the map.
+	m.Clear()
+
+	fmt.Println(m.Size())
+
+	// May Output:
+	// 1
+	// [val1]
+	// val3
+	// val4
+	// false
+	// [key4 key1 key3 1]
+	// [key4 key3]
+	// true
+	// map[val3:key3 val4:key4]
+	// 0
+}
+
+func ExampleAnyAnyMap_Keys() {
+	var m gmap.Map
+	m.Sets(g.MapAnyAny{
+		"k1": "v1",
+		"k2": "v2",
+		"k3": "v3",
+		"k4": "v4",
+	})
+	fmt.Println(m.Keys())
+	fmt.Println(m.Values())
+
+	// May Output:
+	// [k1 k2 k3 k4]
+	// [v2 v3 v4 v1]
+}
+
+func ExampleAnyAnyMap_Values() {
+	var m gmap.Map
+	m.Sets(g.MapAnyAny{
+		"k1": "v1",
+		"k2": "v2",
+		"k3": "v3",
+		"k4": "v4",
+	})
+	fmt.Println(m.Keys())
+	fmt.Println(m.Values())
+
+	// May Output:
+	// [k1 k2 k3 k4]
+	// [v2 v3 v4 v1]
+}
+
+func ExampleAnyAnyMap_Flip() {
+	var m gmap.Map
+	m.Sets(g.MapAnyAny{
+		"k1": "v1",
+		"k2": "v2",
+	})
+	m.Flip()
+	fmt.Println(m.Map())
+
+	// May Output:
+	// map[v1:k1 v2:k2]
+}
+
+func ExampleAnyAnyMap_Pop() {
+	var m gmap.Map
+	m.Sets(g.MapAnyAny{
+		"k1": "v1",
+		"k2": "v2",
+		"k3": "v3",
+		"k4": "v4",
+	})
+	fmt.Println(m.Pop())
+	fmt.Println(m.Pops(2))
+	fmt.Println(m.Size())
+
+	// May Output:
+	// k1 v1
+	// map[k2:v2 k4:v4]
+	// 1
+}
+
+func ExampleAnyAnyMap_Pops() {
+	var m gmap.Map
+	m.Sets(g.MapAnyAny{
+		"k1": "v1",
+		"k2": "v2",
+		"k3": "v3",
+		"k4": "v4",
+	})
+	fmt.Println(m.Pop())
+	fmt.Println(m.Pops(2))
+	fmt.Println(m.Size())
+
+	// May Output:
+	// k1 v1
+	// map[k2:v2 k4:v4]
+	// 1
+}
+
+func ExampleAnyAnyMap_FilterEmpty() {
+	m := gmap.NewFrom(g.MapAnyAny{
+		"k1": "",
+		"k2": nil,
+		"k3": 0,
+		"k4": 1,
+	})
+	m.FilterEmpty()
+	fmt.Println(m.Map())
+
+	// May Output:
+	// map[k4:1]
+}
+
+func ExampleAnyAnyMap_FilterNil() {
+	m := gmap.NewFrom(g.MapAnyAny{
+		"k1": "",
+		"k2": nil,
+		"k3": 0,
+		"k4": 1,
+	})
+	m.FilterNil()
+	fmt.Println(m.Map())
+
+	// May Output:
+	// map[k1: k3:0 k4:1]
+}
+
+func ExampleAnyAnyMap_SetIfNotExist() {
+	var m gmap.Map
+	fmt.Println(m.SetIfNotExist("k1", "v1"))
+	fmt.Println(m.SetIfNotExist("k1", "v1"))
+	fmt.Println(m.Map())
+
+	// Output:
+	// true
+	// false
+	// map[k1:v1]
+}
+
+func ExampleAnyAnyMap_Merge() {
+	var m1, m2 gmap.Map
+	m1.Set("key1", "val1")
+	m2.Set("key2", "val2")
+	m1.Merge(&m2)
+	fmt.Println(m1.Map())
+
+	// May Output:
+	// map[key1:val1 key2:val2]
+}

container/gmap/gmap_z_example_test.go

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

container/gmap/gmap_z_unit_any_any_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/container/gmap"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
+	"github.com/gogf/gf/test/gtest"
 	"github.com/gogf/gf/util/gconv"
 	"testing"
-
-	"github.com/gogf/gf/container/gmap"
-	"github.com/gogf/gf/test/gtest"
+	"time"
 )
 
 func Test_AnyAnyMap_Var(t *testing.T) {
@@ -218,6 +218,18 @@ func Test_AnyAnyMap_FilterEmpty(t *testing.T) {
 		t.Assert(m.Get(1), nil)
 		t.Assert(m.Get(2), 2)
 	})
+	gtest.C(t, func(t *gtest.T) {
+		m := gmap.NewAnyAnyMap()
+		m.Set(1, 0)
+		m.Set("time1", time.Time{})
+		m.Set("time2", time.Now())
+		t.Assert(m.Get(1), 0)
+		t.Assert(m.Get("time1"), time.Time{})
+		m.FilterEmpty()
+		t.Assert(m.Get(1), nil)
+		t.Assert(m.Get("time1"), nil)
+		t.AssertNE(m.Get("time2"), nil)
+	})
 }
 
 func Test_AnyAnyMap_Json(t *testing.T) {

container/gmap/gmap_z_unit_int_any_test.go

@@ -7,9 +7,9 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 	"testing"
 

container/gmap/gmap_z_unit_int_int_test.go

@@ -7,9 +7,9 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 	"testing"
 

container/gmap/gmap_z_unit_int_str_test.go

@@ -7,9 +7,9 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 	"testing"
 

container/gmap/gmap_z_unit_list_map_test.go

@@ -7,8 +7,8 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 	"testing"
 

container/gmap/gmap_z_unit_str_any_test.go

@@ -7,9 +7,9 @@
 package gmap_test
 
 import (
-	"encoding/json"
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/internal/json"
 	"github.com/gogf/gf/util/gconv"
 	"testing"