Improved import, by group improt.

container/garray/garray_normal_any.go

@@ -9,15 +9,15 @@ package garray
 import (
 	"bytes"
 	"fmt"
+	"math"
+	"sort"
+
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/internal/empty"
 	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/text/gstr"
-	"math"
-	"sort"
-
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"
 )

container/garray/garray_normal_int.go

@@ -9,12 +9,12 @@ package garray
 import (
 	"bytes"
 	"fmt"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
 	"math"
 	"sort"
 
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"

container/garray/garray_normal_str.go

@@ -8,15 +8,15 @@ package garray
 
 import (
 	"bytes"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/text/gstr"
 	"math"
 	"sort"
 	"strings"
 
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"
 )

container/garray/garray_sorted_any.go

@@ -9,16 +9,16 @@ package garray
 import (
 	"bytes"
 	"fmt"
-	"github.com/gogf/gf/v2/internal/empty"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/text/gstr"
-	"github.com/gogf/gf/v2/util/gutil"
 	"math"
 	"sort"
 
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 // SortedArray is a golang sorted array with rich features.

container/garray/garray_sorted_int.go

@@ -9,10 +9,10 @@ package garray
 import (
 	"bytes"
 	"fmt"
-	"github.com/gogf/gf/v2/internal/json"
 	"math"
 	"sort"
 
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"

container/garray/garray_sorted_str.go

@@ -8,13 +8,13 @@ package garray
 
 import (
 	"bytes"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/text/gstr"
 	"math"
 	"sort"
 	"strings"
 
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/grand"
 )

container/garray/garray_z_bench_any_test.go

@@ -7,8 +7,9 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
 	"testing"
+
+	"github.com/gogf/gf/v2/container/garray"
 )
 
 type anySortedArrayItem struct {

container/garray/garray_z_example_any_test.go

@@ -8,9 +8,9 @@ package garray_test
 
 import (
 	"fmt"
-	"github.com/gogf/gf/v2/frame/g"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
 )
 
 func ExampleNew() {

container/garray/garray_z_example_int_test.go

@@ -8,6 +8,7 @@ package garray_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
@@ -144,7 +145,7 @@ func ExampleIntArray_SortFunc() {
 	s := garray.NewIntArrayFrom(g.SliceInt{10, 20, 15, 30})
 	fmt.Println(s)
 	s.SortFunc(func(v1, v2 int) bool {
-		//fmt.Println(v1,v2)
+		// fmt.Println(v1,v2)
 		return v1 > v2
 	})
 	fmt.Println(s)

container/garray/garray_z_example_sorted_str_test.go

@@ -8,6 +8,7 @@ package garray_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"

container/garray/garray_z_example_str_test.go

@@ -8,6 +8,7 @@ package garray_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"

container/garray/garray_z_unit_all_basic_test.go

@@ -9,13 +9,13 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/util/gutil"
 	"strings"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 func Test_Array_Var(t *testing.T) {

container/garray/garray_z_unit_normal_any_array_test.go

@@ -9,12 +9,12 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
 	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
 )
@@ -260,7 +260,7 @@ func TestArray_Merge(t *testing.T) {
 		array2 := garray.NewArrayFrom(i2)
 		t.Assert(array1.Merge(array2).Slice(), []interface{}{0, 1, 2, 3, 4, 5, 6, 7})
 
-		//s1 := []string{"a", "b", "c", "d"}
+		// s1 := []string{"a", "b", "c", "d"}
 		s2 := []string{"e", "f"}
 		i3 := garray.NewIntArrayFrom([]int{1, 2, 3})
 		i4 := garray.NewArrayFrom([]interface{}{3})
@@ -502,16 +502,16 @@ func TestArray_LockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []interface{}) { //读写锁
+		go a1.LockFunc(func(n1 []interface{}) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -519,10 +519,10 @@ func TestArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }
@@ -534,16 +534,16 @@ func TestArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []interface{}) { //读锁
+		go a1.RLockFunc(func(n1 []interface{}) { // 读锁
-			time.Sleep(2 * time.Second) //暂停1秒
+			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -551,10 +551,10 @@ func TestArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候，并没有阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }

container/garray/garray_z_unit_normal_int_array_test.go

@@ -9,15 +9,14 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
 	"testing"
 	"time"
 
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_IntArray_Basic(t *testing.T) {
@@ -534,16 +533,16 @@ func TestIntArray_LockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []int) { //读写锁
+		go a1.LockFunc(func(n1 []int) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = 6
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -551,10 +550,10 @@ func TestIntArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains(6), true)
 	})
 }
@@ -579,16 +578,16 @@ func TestIntArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []int) { //读锁
+		go a1.RLockFunc(func(n1 []int) { // 读锁
-			time.Sleep(2 * time.Second) //暂停1秒
+			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = 6
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -596,10 +595,10 @@ func TestIntArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候，并没有阻塞。
 		t.Assert(a1.Contains(6), true)
 	})
 }
@@ -758,7 +757,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) {
 		t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
 	})
 	// Map
-	//gtest.C(t, func(t *gtest.T) {
+	// gtest.C(t, func(t *gtest.T) {
 	//	var v *V
 	//	err := gconv.Struct(g.Map{
 	//		"name":  "john",
@@ -767,7 +766,7 @@ func TestIntArray_UnmarshalValue(t *testing.T) {
 	//	t.Assert(err, nil)
 	//	t.Assert(v.Name, "john")
 	//	t.Assert(v.Array.Slice(), g.Slice{1, 2, 3})
-	//})
+	// })
 }
 
 func TestIntArray_FilterEmpty(t *testing.T) {

container/garray/garray_z_unit_normal_str_array_test.go

@@ -9,13 +9,13 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
 )
@@ -534,16 +534,16 @@ func TestStrArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []string) { //读锁
+		go a1.RLockFunc(func(n1 []string) { // 读锁
-			time.Sleep(2 * time.Second) //暂停1秒
+			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -551,10 +551,10 @@ func TestStrArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候，并没有阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }
@@ -578,16 +578,16 @@ func TestStrArray_LockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []string) { //读写锁
+		go a1.LockFunc(func(n1 []string) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -595,10 +595,10 @@ func TestStrArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }

container/garray/garray_z_unit_sorted_any_array_test.go

@@ -9,16 +9,16 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gutil"
 	"strings"
 	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 func TestSortedArray_NewSortedArrayFrom(t *testing.T) {
@@ -554,16 +554,16 @@ func TestSortedArray_LockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []interface{}) { //读写锁
+		go a1.LockFunc(func(n1 []interface{}) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -571,10 +571,10 @@ func TestSortedArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }
@@ -589,16 +589,16 @@ func TestSortedArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []interface{}) { //读写锁
+		go a1.RLockFunc(func(n1 []interface{}) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -606,10 +606,10 @@ func TestSortedArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候不会被阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候不会被阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }

container/garray/garray_z_unit_sorted_int_array_test.go

@@ -9,15 +9,14 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
 	"testing"
 	"time"
 
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func TestNewSortedIntArrayFrom(t *testing.T) {
@@ -337,7 +336,7 @@ func TestSortedIntArray_Chunk(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{1, 2, 3, 4, 5}
 		array1 := garray.NewSortedIntArrayFrom(a1)
-		ns1 := array1.Chunk(2) //按每几个元素切成一个数组
+		ns1 := array1.Chunk(2) // 按每几个元素切成一个数组
 		ns2 := array1.Chunk(-1)
 		t.Assert(len(ns1), 3)
 		t.Assert(ns1[0], []int{1, 2})
@@ -427,7 +426,7 @@ func TestSortedIntArray_CountValues(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		a1 := []int{1, 2, 3, 4, 5, 3}
 		array1 := garray.NewSortedIntArrayFrom(a1)
-		ns1 := array1.CountValues() //按每几个元素切成一个数组
+		ns1 := array1.CountValues() // 按每几个元素切成一个数组
 		t.Assert(len(ns1), 5)
 		t.Assert(ns1[2], 1)
 		t.Assert(ns1[3], 2)
@@ -460,16 +459,16 @@ func TestSortedIntArray_LockFunc(t *testing.T) {
 		a1 := garray.NewSortedIntArrayFrom(s1, true)
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []int) { //读写锁
+		go a1.LockFunc(func(n1 []int) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = 6
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -477,10 +476,10 @@ func TestSortedIntArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains(6), true)
 	})
 }
@@ -492,16 +491,16 @@ func TestSortedIntArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []int) { //读锁
+		go a1.RLockFunc(func(n1 []int) { // 读锁
-			time.Sleep(2 * time.Second) //暂停1秒
+			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = 6
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -509,10 +508,10 @@ func TestSortedIntArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候，并没有阻塞。
 		t.Assert(a1.Contains(6), true)
 	})
 }

container/garray/garray_z_unit_sorted_str_array_test.go

@@ -9,12 +9,12 @@
 package garray_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
 	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
 )
@@ -479,16 +479,16 @@ func TestSortedStrArray_LockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 3)
-		//go1
+		// go1
-		go a1.LockFunc(func(n1 []string) { //读写锁
+		go a1.LockFunc(func(n1 []string) { // 读写锁
-			time.Sleep(2 * time.Second) //暂停2秒
+			time.Sleep(2 * time.Second) // 暂停2秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -496,10 +496,10 @@ func TestSortedStrArray_LockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertGT(t2-t1, 20) //go1加的读写互斥锁，所go2读的时候被阻塞。
+		t.AssertGT(t2-t1, 20) // go1加的读写互斥锁，所go2读的时候被阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }
@@ -511,16 +511,16 @@ func TestSortedStrArray_RLockFunc(t *testing.T) {
 
 		ch1 := make(chan int64, 3)
 		ch2 := make(chan int64, 1)
-		//go1
+		// go1
-		go a1.RLockFunc(func(n1 []string) { //读锁
+		go a1.RLockFunc(func(n1 []string) { // 读锁
-			time.Sleep(2 * time.Second) //暂停1秒
+			time.Sleep(2 * time.Second) // 暂停1秒
 			n1[2] = "g"
 			ch2 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 		})
 
-		//go2
+		// go2
 		go func() {
-			time.Sleep(100 * time.Millisecond) //故意暂停0.01秒,等go1执行锁后，再开始执行.
+			time.Sleep(100 * time.Millisecond) // 故意暂停0.01秒,等go1执行锁后，再开始执行.
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
 			a1.Len()
 			ch1 <- gconv.Int64(time.Now().UnixNano() / 1000 / 1000)
@@ -528,10 +528,10 @@ func TestSortedStrArray_RLockFunc(t *testing.T) {
 
 		t1 := <-ch1
 		t2 := <-ch1
-		<-ch2 //等待go1完成
+		<-ch2 // 等待go1完成
 
 		// 防止ci抖动,以豪秒为单位
-		t.AssertLT(t2-t1, 20) //go1加的读锁，所go2读的时候，并没有阻塞。
+		t.AssertLT(t2-t1, 20) // go1加的读锁，所go2读的时候，并没有阻塞。
 		t.Assert(a1.Contains("g"), true)
 	})
 }

container/glist/glist.go

@@ -11,10 +11,10 @@ package glist
 import (
 	"bytes"
 	"container/list"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type (

container/glist/glist_z_example_test.go

@@ -9,10 +9,10 @@ package glist_test
 import (
 	"container/list"
 	"fmt"
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/glist"
+	"github.com/gogf/gf/v2/frame/g"
 )
 
 func ExampleNew() {

container/glist/glist_z_unit_test.go

@@ -8,11 +8,11 @@ package glist
 
 import (
 	"container/list"
+	"testing"
+
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-
-	"testing"
 )
 
 func checkListLen(t *gtest.T, l *List, len int) bool {
@@ -46,34 +46,34 @@ func TestVar(t *testing.T) {
 	if v := l.PopBack(); v != 1 {
 		t.Errorf("EXPECT %v, GOT %v", 1, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopBack(); v != 2 {
 		t.Errorf("EXPECT %v, GOT %v", 2, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopBack(); v != nil {
 		t.Errorf("EXPECT %v, GOT %v", nil, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	l.PushBack(1)
 	l.PushBack(2)
 	if v := l.PopFront(); v != 1 {
 		t.Errorf("EXPECT %v, GOT %v", 1, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopFront(); v != 2 {
 		t.Errorf("EXPECT %v, GOT %v", 2, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopFront(); v != nil {
 		t.Errorf("EXPECT %v, GOT %v", nil, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 }
 
@@ -84,34 +84,34 @@ func TestBasic(t *testing.T) {
 	if v := l.PopBack(); v != 1 {
 		t.Errorf("EXPECT %v, GOT %v", 1, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopBack(); v != 2 {
 		t.Errorf("EXPECT %v, GOT %v", 2, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopBack(); v != nil {
 		t.Errorf("EXPECT %v, GOT %v", nil, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	l.PushBack(1)
 	l.PushBack(2)
 	if v := l.PopFront(); v != 1 {
 		t.Errorf("EXPECT %v, GOT %v", 1, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopFront(); v != 2 {
 		t.Errorf("EXPECT %v, GOT %v", 2, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 	if v := l.PopFront(); v != nil {
 		t.Errorf("EXPECT %v, GOT %v", nil, v)
 	} else {
-		//fmt.Println(v)
+		// fmt.Println(v)
 	}
 }
 
@@ -221,13 +221,13 @@ func checkList(t *gtest.T, l *List, es []interface{}) {
 		i++
 	}
 
-	//for e := l.Front(); e != nil; e = e.Next() {
+	// for e := l.Front(); e != nil; e = e.Next() {
 	//	le := e.Value.(int)
 	//	if le != es[i] {
 	//		t.Errorf("elt[%d].Value() = %v, want %v", i, le, es[i])
 	//	}
 	//	i++
-	//}
+	// }
 }
 
 func TestExtending(t *testing.T) {
@@ -283,11 +283,11 @@ func TestRemove(t *testing.T) {
 		e1 := l.PushBack(1)
 		e2 := l.PushBack(2)
 		checkListPointers(t, l, []*Element{e1, e2})
-		//e := l.Front()
+		// e := l.Front()
-		//l.Remove(e)
+		// l.Remove(e)
-		//checkListPointers(t, l, []*Element{e2})
+		// checkListPointers(t, l, []*Element{e2})
-		//l.Remove(e)
+		// l.Remove(e)
-		//checkListPointers(t, l, []*Element{e2})
+		// checkListPointers(t, l, []*Element{e2})
 	})
 }
 
@@ -322,12 +322,12 @@ func TestIssue6349(t *testing.T) {
 	if e.Value != 1 {
 		t.Errorf("e.value = %d, want 1", e.Value)
 	}
-	//if e.Next() != nil {
+	// if e.Next() != nil {
 	//    t.Errorf("e.Next() != nil")
-	//}
+	// }
-	//if e.Prev() != nil {
+	// if e.Prev() != nil {
 	//    t.Errorf("e.Prev() != nil")
-	//}
+	// }
 }
 
 func TestMove(t *testing.T) {
@@ -474,7 +474,7 @@ func TestList_PopBacks(t *testing.T) {
 		i1 := l.PopBacks(2)
 		t.Assert(i1, []interface{}{1, 2})
 
-		l.PushBacks(a2) //4.3,a,c,b,e
+		l.PushBacks(a2) // 4.3,a,c,b,e
 		i1 = l.PopBacks(3)
 		t.Assert(i1, []interface{}{"e", "b", "c"})
 	})

container/gmap/gmap_hash_any_any_map.go

@@ -7,14 +7,11 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
-	"github.com/gogf/gf/v2/internal/empty"
-
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type AnyAnyMap struct {

container/gmap/gmap_hash_int_any_map.go

@@ -8,11 +8,9 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
-	"github.com/gogf/gf/v2/internal/empty"
-
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )

container/gmap/gmap_hash_int_int_map.go

@@ -7,12 +7,10 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/internal/empty"
-
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type IntIntMap struct {

container/gmap/gmap_hash_int_str_map.go

@@ -7,10 +7,8 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
 	"github.com/gogf/gf/v2/internal/empty"
-
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )

container/gmap/gmap_hash_str_any_map.go

@@ -8,11 +8,9 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
-	"github.com/gogf/gf/v2/internal/empty"
-
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )

container/gmap/gmap_hash_str_int_map.go

@@ -8,9 +8,8 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
 	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"
 )

container/gmap/gmap_hash_str_str_map.go

@@ -8,12 +8,10 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/internal/empty"
-
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type StrStrMap struct {

container/gmap/gmap_list_map.go

@@ -7,15 +7,12 @@
 package gmap
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-
-	"github.com/gogf/gf/v2/internal/empty"
-
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/container/glist"
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/empty"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type ListMap struct {

container/gmap/gmap_tree_map.go

@@ -10,7 +10,7 @@ import (
 	"github.com/gogf/gf/v2/container/gtree"
 )
 
-// Map based on red-black tree, alias of RedBlackTree.
+// TreeMap based on red-black tree, alias of RedBlackTree.
 type TreeMap = gtree.RedBlackTree
 
 // NewTreeMap instantiates a tree map with the custom comparator.

container/gmap/gmap_z_basic_test.go

@@ -7,11 +7,11 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/util/gutil"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 func getValue() interface{} {
@@ -163,15 +163,15 @@ func Test_Map_Lock(t *testing.T) {
 
 func Test_Map_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove("key1")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("key1", m.Keys())
 	})
 }

container/gmap/gmap_z_example_any_any_test.go

@@ -8,9 +8,9 @@ package gmap_test
 
 import (
 	"fmt"
-	"github.com/gogf/gf/v2/frame/g"
 
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
 )
 
 func ExampleNew() {

container/gmap/gmap_z_unit_any_any_test.go

@@ -7,14 +7,15 @@
 package gmap_test
 
 import (
+	"testing"
+	"time"
+
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"testing"
-	"time"
 )
 
 func Test_AnyAnyMap_Var(t *testing.T) {
@@ -148,16 +149,16 @@ func Test_AnyAnyMap_Lock(t *testing.T) {
 
 func Test_AnyAnyMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewAnyAnyMapFrom(map[interface{}]interface{}{1: 1, 2: "2"})
 
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove(2)
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN(2, m.Keys())
 	})
 }

container/gmap/gmap_z_unit_int_any_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func getAny() interface{} {
@@ -150,16 +150,16 @@ func Test_IntAnyMap_Lock(t *testing.T) {
 }
 func Test_IntAnyMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewIntAnyMapFrom(map[int]interface{}{1: 1, 2: "2"})
 
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove(2)
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN(2, m.Keys())
 	})
 }

container/gmap/gmap_z_unit_int_int_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func getInt() int {
@@ -155,16 +155,16 @@ func Test_IntIntMap_Lock(t *testing.T) {
 
 func Test_IntIntMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewIntIntMapFrom(map[int]int{1: 1, 2: 2})
 
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove(2)
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN(2, m.Keys())
 	})
 }

container/gmap/gmap_z_unit_int_str_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func getStr() string {
@@ -76,8 +76,8 @@ func Test_IntStrMap_Basic(t *testing.T) {
 		t.AssertIN("a", m.Values())
 		t.AssertIN("c", m.Values())
 
-		//反转之后不成为以下 map,flip 操作只是翻转原 map
+		// 反转之后不成为以下 map,flip 操作只是翻转原 map
-		//t.Assert(m.Map(), map[string]int{"a": 1, "c": 3})
+		// t.Assert(m.Map(), map[string]int{"a": 1, "c": 3})
 		m_f := gmap.NewIntStrMap()
 		m_f.Set(1, "2")
 		m_f.Flip()
@@ -155,16 +155,16 @@ func Test_IntStrMap_Lock(t *testing.T) {
 
 func Test_IntStrMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewIntStrMapFrom(map[int]string{1: "a", 2: "b", 3: "c"})
 
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove(2)
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN(2, m.Keys())
 	})
 }

container/gmap/gmap_z_unit_list_map_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_ListMap_Var(t *testing.T) {
@@ -133,15 +133,15 @@ func Test_ListMap_Iterator(t *testing.T) {
 
 func Test_ListMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewListMapFrom(map[interface{}]interface{}{1: 1, "key1": "val1"})
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove("key1")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("key1", m.Keys())
 	})
 }

container/gmap/gmap_z_unit_str_any_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_StrAnyMap_Var(t *testing.T) {
@@ -148,16 +148,16 @@ func Test_StrAnyMap_Lock(t *testing.T) {
 }
 func Test_StrAnyMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewStrAnyMapFrom(map[string]interface{}{"a": 1, "b": "2"})
 
 		m_clone := m.Clone()
 		m.Remove("a")
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN("a", m_clone.Keys())
 
 		m_clone.Remove("b")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("b", m.Keys())
 	})
 }

container/gmap/gmap_z_unit_str_int_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_StrIntMap_Var(t *testing.T) {
@@ -152,16 +152,16 @@ func Test_StrIntMap_Lock(t *testing.T) {
 
 func Test_StrIntMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewStrIntMapFrom(map[string]int{"a": 1, "b": 2, "c": 3})
 
 		m_clone := m.Clone()
 		m.Remove("a")
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN("a", m_clone.Keys())
 
 		m_clone.Remove("b")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("b", m.Keys())
 	})
 }

container/gmap/gmap_z_unit_str_str_test.go

@@ -7,14 +7,14 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/container/garray"
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_StrStrMap_Var(t *testing.T) {
@@ -149,16 +149,16 @@ func Test_StrStrMap_Lock(t *testing.T) {
 }
 func Test_StrStrMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewStrStrMapFrom(map[string]string{"a": "a", "b": "b", "c": "c"})
 
 		m_clone := m.Clone()
 		m.Remove("a")
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN("a", m_clone.Keys())
 
 		m_clone.Remove("b")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("b", m.Keys())
 	})
 }

container/gmap/gmap_z_unit_tree_map_test.go

@@ -7,13 +7,13 @@
 package gmap_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gmap"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/gutil"
 )
 
@@ -152,15 +152,15 @@ func Test_TreeMap_Iterator(t *testing.T) {
 
 func Test_TreeMap_Clone(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
-		//clone 方法是深克隆
+		// clone 方法是深克隆
 		m := gmap.NewTreeMapFrom(gutil.ComparatorString, map[interface{}]interface{}{1: 1, "key1": "val1"})
 		m_clone := m.Clone()
 		m.Remove(1)
-		//修改原 map,clone 后的 map 不影响
+		// 修改原 map,clone 后的 map 不影响
 		t.AssertIN(1, m_clone.Keys())
 
 		m_clone.Remove("key1")
-		//修改clone map,原 map 不影响
+		// 修改clone map,原 map 不影响
 		t.AssertIN("key1", m.Keys())
 	})
 }

container/gpool/gpool.go

@@ -9,12 +9,12 @@ package gpool
 
 import (
 	"context"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
 	"time"
 
 	"github.com/gogf/gf/v2/container/glist"
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/os/gtimer"
 )
@@ -38,10 +38,10 @@ type poolItem struct {
 	expireAt int64       // Expire timestamp in milliseconds.
 }
 
-// Creation function for object.
+// NewFunc Creation function for object.
 type NewFunc func() (interface{}, error)
 
-// Destruction function for object.
+// ExpireFunc Destruction function for object.
 type ExpireFunc func(interface{})
 
 // New creates and returns a new object pool.

container/gpool/gpool_z_unit_test.go

@@ -11,9 +11,8 @@ import (
 	"testing"
 	"time"
 
-	"github.com/gogf/gf/v2/frame/g"
-
 	"github.com/gogf/gf/v2/container/gpool"
+	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
 )
 
@@ -30,29 +29,29 @@ var ef gpool.ExpireFunc = func(i interface{}) {
 func Test_Gpool(t *testing.T) {
 	gtest.C(t, func(t *gtest.T) {
 		//
-		//expire = 0
+		// expire = 0
 		p1 := gpool.New(0, nf)
 		p1.Put(1)
 		p1.Put(2)
 		time.Sleep(1 * time.Second)
-		//test won't be timeout
+		// test won't be timeout
 		v1, err1 := p1.Get()
 		t.Assert(err1, nil)
 		t.AssertIN(v1, g.Slice{1, 2})
-		//test clear
+		// test clear
 		p1.Clear()
 		t.Assert(p1.Size(), 0)
-		//test newFunc
+		// test newFunc
 		v1, err1 = p1.Get()
 		t.Assert(err1, nil)
 		t.Assert(v1, "hello")
-		//put data again
+		// put data again
 		p1.Put(3)
 		p1.Put(4)
 		v1, err1 = p1.Get()
 		t.Assert(err1, nil)
 		t.AssertIN(v1, g.Slice{3, 4})
-		//test close
+		// test close
 		p1.Close()
 		v1, err1 = p1.Get()
 		t.Assert(err1, nil)
@@ -61,7 +60,7 @@ func Test_Gpool(t *testing.T) {
 
 	gtest.C(t, func(t *gtest.T) {
 		//
-		//expire > 0
+		// expire > 0
 		p2 := gpool.New(2*time.Second, nil, ef)
 		for index := 0; index < 10; index++ {
 			p2.Put(index)
@@ -70,12 +69,12 @@ func Test_Gpool(t *testing.T) {
 		v2, err2 := p2.Get()
 		t.Assert(err2, nil)
 		t.Assert(v2, 0)
-		//test timeout expireFunc
+		// test timeout expireFunc
 		time.Sleep(3 * time.Second)
 		v2, err2 = p2.Get()
 		t.Assert(err2, errors.New("pool is empty"))
 		t.Assert(v2, nil)
-		//test close expireFunc
+		// test close expireFunc
 		for index := 0; index < 10; index++ {
 			p2.Put(index)
 		}
@@ -90,7 +89,7 @@ func Test_Gpool(t *testing.T) {
 
 	gtest.C(t, func(t *gtest.T) {
 		//
-		//expire < 0
+		// expire < 0
 		p3 := gpool.New(-1, nil)
 		v3, err3 := p3.Get()
 		t.Assert(err3, errors.New("pool is empty"))

container/gqueue/gqueue_z_example_test.go

@@ -9,9 +9,10 @@ package gqueue_test
 import (
 	"context"
 	"fmt"
+	"time"
+
 	"github.com/gogf/gf/v2/container/gqueue"
 	"github.com/gogf/gf/v2/os/gtimer"
-	"time"
 )
 
 func ExampleNew() {

container/gset/gset_any_set.go

@@ -9,6 +9,7 @@ package gset
 
 import (
 	"bytes"
+
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"

container/gset/gset_int_set.go

@@ -9,6 +9,7 @@ package gset
 
 import (
 	"bytes"
+
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/util/gconv"

container/gset/gset_str_set.go

@@ -9,11 +9,12 @@ package gset
 
 import (
 	"bytes"
+	"strings"
+
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
 	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
-	"strings"
 )
 
 type StrSet struct {

container/gset/gset_z_example_any_test.go

@@ -8,6 +8,7 @@ package gset_test
 
 import (
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
 )

container/gset/gset_z_example_int_test.go

@@ -9,6 +9,7 @@ package gset_test
 import (
 	"encoding/json"
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
 )

container/gset/gset_z_example_str_test.go

@@ -9,6 +9,7 @@ package gset_test
 import (
 	"encoding/json"
 	"fmt"
+
 	"github.com/gogf/gf/v2/container/gset"
 	"github.com/gogf/gf/v2/frame/g"
 )

container/gset/gset_z_unit_any_test.go

@@ -9,18 +9,17 @@
 package gset_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"strings"
 	"sync"
+	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
-
+	"github.com/gogf/gf/v2/util/gconv"
-	"testing"
 )
 
 func TestSet_Var(t *testing.T) {

container/gset/gset_z_unit_int_test.go

@@ -9,9 +9,6 @@
 package gset_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"strings"
 	"sync"
 	"testing"
@@ -19,7 +16,10 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func TestIntSet_Var(t *testing.T) {

container/gset/gset_z_unit_str_test.go

@@ -9,9 +9,6 @@
 package gset_test
 
 import (
-	"github.com/gogf/gf/v2/frame/g"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"strings"
 	"sync"
 	"testing"
@@ -19,7 +16,10 @@ import (
 
 	"github.com/gogf/gf/v2/container/garray"
 	"github.com/gogf/gf/v2/container/gset"
+	"github.com/gogf/gf/v2/frame/g"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func TestStrSet_Var(t *testing.T) {

container/gtree/gtree_avltree.go

@@ -8,12 +8,11 @@ package gtree
 
 import (
 	"fmt"
-	"github.com/gogf/gf/v2/internal/json"
-
-	"github.com/gogf/gf/v2/util/gconv"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // AVLTree holds elements of the AVL tree.

container/gtree/gtree_btree.go

@@ -9,13 +9,12 @@ package gtree
 import (
 	"bytes"
 	"fmt"
-	"github.com/gogf/gf/v2/internal/json"
 	"strings"
 
-	"github.com/gogf/gf/v2/util/gconv"
-
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // BTree holds elements of the B-tree.
@@ -587,9 +586,9 @@ func (tree *BTree) isLeaf(node *BTreeNode) bool {
 	return len(node.Children) == 0
 }
 
-//func (tree *BTree) isFull(node *BTreeNode) bool {
+// func (tree *BTree) isFull(node *BTreeNode) bool {
 //	return len(node.Entries) == tree.maxEntries()
-//}
+// }
 
 func (tree *BTree) shouldSplit(node *BTreeNode) bool {
 	return len(node.Entries) > tree.maxEntries()

container/gtree/gtree_redblacktree.go

@@ -8,12 +8,12 @@ package gtree
 
 import (
 	"fmt"
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
-	"github.com/gogf/gf/v2/util/gutil"
 
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/internal/rwmutex"
+	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 type color bool
@@ -119,7 +119,7 @@ func (tree *RedBlackTree) doSet(key interface{}, value interface{}) {
 			compare := tree.getComparator()(key, node.Key)
 			switch {
 			case compare == 0:
-				//node.Key   = key
+				// node.Key   = key
 				node.Value = value
 				return
 			case compare < 0:

container/gtype/gtype_bool.go

@@ -8,8 +8,9 @@ package gtype
 
 import (
 	"bytes"
-	"github.com/gogf/gf/v2/util/gconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Bool is a struct for concurrent-safe operation for type bool.
@@ -80,9 +81,8 @@ func (v *Bool) String() string {
 func (v *Bool) MarshalJSON() ([]byte, error) {
 	if v.Val() {
 		return bytesTrue, nil
-	} else {
-		return bytesFalse, nil
 	}
+	return bytesFalse, nil
 }
 
 // UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.

container/gtype/gtype_byte.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Byte is a struct for concurrent-safe operation for type byte.

container/gtype/gtype_bytes.go

@@ -9,8 +9,9 @@ package gtype
 import (
 	"bytes"
 	"encoding/base64"
-	"github.com/gogf/gf/v2/util/gconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Bytes is a struct for concurrent-safe operation for type []byte.

container/gtype/gtype_float32.go

@@ -7,10 +7,11 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"math"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Float32 is a struct for concurrent-safe operation for type float32.

container/gtype/gtype_float64.go

@@ -7,10 +7,11 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"math"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Float64 is a struct for concurrent-safe operation for type float64.

container/gtype/gtype_int.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Int is a struct for concurrent-safe operation for type int.

container/gtype/gtype_int32.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Int32 is a struct for concurrent-safe operation for type int32.

container/gtype/gtype_int64.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Int64 is a struct for concurrent-safe operation for type int64.

container/gtype/gtype_interface.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
+	"sync/atomic"
+
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/util/gconv"
-	"sync/atomic"
 )
 
 // Interface is a struct for concurrent-safe operation for type interface{}.

container/gtype/gtype_uint.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Uint is a struct for concurrent-safe operation for type uint.

container/gtype/gtype_uint32.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Uint32 is a struct for concurrent-safe operation for type uint32.

container/gtype/gtype_uint64.go

@@ -7,9 +7,10 @@
 package gtype
 
 import (
-	"github.com/gogf/gf/v2/util/gconv"
 	"strconv"
 	"sync/atomic"
+
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 // Uint64 is a struct for concurrent-safe operation for type uint64.

container/gtype/gtype_z_bench_basic_test.go

@@ -9,11 +9,11 @@
 package gtype_test
 
 import (
-	"github.com/gogf/gf/v2/container/gtype"
 	"strconv"
 	"sync/atomic"
 	"testing"
 
+	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/encoding/gbinary"
 )
 

container/gtype/gtype_z_bench_json_test.go

@@ -9,9 +9,10 @@
 package gtype_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
-	"testing"
 )
 
 var (

container/gtype/gtype_z_unit_bool_test.go

@@ -7,12 +7,12 @@
 package gtype_test
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_Bool(t *testing.T) {
@@ -27,7 +27,7 @@ func Test_Bool(t *testing.T) {
 		t.AssertEQ(iClone1.Set(true), false)
 		t.AssertEQ(iClone1.Val(), true)
 
-		//空参测试
+		// 空参测试
 		i2 := gtype.NewBool()
 		t.AssertEQ(i2.Val(), false)
 	})

container/gtype/gtype_z_unit_byte_test.go

@@ -7,13 +7,13 @@
 package gtype_test
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"sync"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_Byte(t *testing.T) {
@@ -34,7 +34,7 @@ func Test_Byte(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(byte(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewByte()
 		t.AssertEQ(i1.Val(), byte(0))
 	})

container/gtype/gtype_z_unit_bytes_test.go

@@ -7,12 +7,12 @@
 package gtype_test
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_Bytes(t *testing.T) {

container/gtype/gtype_z_unit_float32_test.go

@@ -7,12 +7,13 @@
 package gtype_test
 
 import (
+	"math"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"math"
-	"testing"
 )
 
 func Test_Float32(t *testing.T) {
@@ -22,7 +23,7 @@ func Test_Float32(t *testing.T) {
 		t.AssertEQ(iClone.Set(0.1), float32(0))
 		t.AssertEQ(iClone.Val(), float32(0.1))
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewFloat32()
 		t.AssertEQ(i1.Val(), float32(0))
 	})

container/gtype/gtype_z_unit_float64_test.go

@@ -7,12 +7,13 @@
 package gtype_test
 
 import (
+	"math"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"math"
-	"testing"
 )
 
 func Test_Float64(t *testing.T) {
@@ -21,7 +22,7 @@ func Test_Float64(t *testing.T) {
 		iClone := i.Clone()
 		t.AssertEQ(iClone.Set(0.1), float64(0))
 		t.AssertEQ(iClone.Val(), float64(0.1))
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewFloat64()
 		t.AssertEQ(i1.Val(), float64(0))
 	})

container/gtype/gtype_z_unit_int32_test.go

@@ -7,13 +7,14 @@
 package gtype_test
 
 import (
+	"math"
+	"sync"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"math"
-	"sync"
-	"testing"
 )
 
 func Test_Int32(t *testing.T) {
@@ -34,7 +35,7 @@ func Test_Int32(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(int32(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewInt32()
 		t.AssertEQ(i1.Val(), int32(0))
 	})

container/gtype/gtype_z_unit_int64_test.go

@@ -7,13 +7,14 @@
 package gtype_test
 
 import (
+	"math"
+	"sync"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"math"
-	"sync"
-	"testing"
 )
 
 func Test_Int64(t *testing.T) {
@@ -34,7 +35,7 @@ func Test_Int64(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(int64(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewInt64()
 		t.AssertEQ(i1.Val(), int64(0))
 	})

container/gtype/gtype_z_unit_int_test.go

@@ -7,12 +7,13 @@
 package gtype_test
 
 import (
+	"sync"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"sync"
-	"testing"
 )
 
 func Test_Int(t *testing.T) {
@@ -33,7 +34,7 @@ func Test_Int(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(addTimes, i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewInt()
 		t.AssertEQ(i1.Val(), 0)
 	})

container/gtype/gtype_z_unit_interface_test.go

@@ -7,11 +7,12 @@
 package gtype_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"testing"
 )
 
 func Test_Interface(t *testing.T) {
@@ -23,7 +24,7 @@ func Test_Interface(t *testing.T) {
 		t.AssertEQ(iClone.Set(t2), t1)
 		t.AssertEQ(iClone.Val().(Temp), t2)
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.New()
 		t.AssertEQ(i1.Val(), nil)
 	})

container/gtype/gtype_z_unit_string_test.go

@@ -7,11 +7,12 @@
 package gtype_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"testing"
 )
 
 func Test_String(t *testing.T) {
@@ -21,7 +22,7 @@ func Test_String(t *testing.T) {
 		t.AssertEQ(iClone.Set("123"), "abc")
 		t.AssertEQ(iClone.Val(), "123")
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewString()
 		t.AssertEQ(i1.Val(), "")
 	})

container/gtype/gtype_z_unit_uint32_test.go

@@ -7,13 +7,14 @@
 package gtype_test
 
 import (
+	"math"
+	"sync"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"math"
-	"sync"
-	"testing"
 )
 
 func Test_Uint32(t *testing.T) {
@@ -34,7 +35,7 @@ func Test_Uint32(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(uint32(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewUint32()
 		t.AssertEQ(i1.Val(), uint32(0))
 	})

container/gtype/gtype_z_unit_uint64_test.go

@@ -7,14 +7,14 @@
 package gtype_test
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
-	"github.com/gogf/gf/v2/util/gconv"
 	"math"
 	"sync"
 	"testing"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 type Temp struct {
@@ -40,7 +40,7 @@ func Test_Uint64(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(uint64(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewUint64()
 		t.AssertEQ(i1.Val(), uint64(0))
 	})

container/gtype/gtype_z_unit_uint_test.go

@@ -7,12 +7,13 @@
 package gtype_test
 
 import (
+	"sync"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gtype"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"sync"
-	"testing"
 )
 
 func Test_Uint(t *testing.T) {
@@ -33,7 +34,7 @@ func Test_Uint(t *testing.T) {
 		wg.Wait()
 		t.AssertEQ(uint(addTimes), i.Val())
 
-		//空参测试
+		// 空参测试
 		i1 := gtype.NewUint()
 		t.AssertEQ(i1.Val(), uint(0))
 	})

container/gvar/gvar.go

@@ -8,10 +8,10 @@
 package gvar
 
 import (
-	"github.com/gogf/gf/v2/internal/json"
 	"time"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/util/gconv"
 )

container/gvar/gvar_z_unit_basic_test.go

@@ -9,12 +9,12 @@ package gvar_test
 import (
 	"bytes"
 	"encoding/binary"
-	"github.com/gogf/gf/v2/util/gconv"
 	"testing"
 	"time"
 
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gconv"
 )
 
 func Test_Set(t *testing.T) {

container/gvar/gvar_z_unit_is_test.go

@@ -7,9 +7,10 @@
 package gvar_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
-	"testing"
 )
 
 func TestVar_IsNil(t *testing.T) {

container/gvar/gvar_z_unit_json_test.go

@@ -7,11 +7,12 @@
 package gvar_test
 
 import (
+	"math"
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/internal/json"
 	"github.com/gogf/gf/v2/test/gtest"
-	"math"
-	"testing"
 )
 
 func TestVar_Json(t *testing.T) {

container/gvar/gvar_z_unit_list_test.go

@@ -7,10 +7,11 @@
 package gvar_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
-	"testing"
 )
 
 func TestVar_ListItemValues_Map(t *testing.T) {

container/gvar/gvar_z_unit_map_test.go

@@ -7,10 +7,11 @@
 package gvar_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
-	"testing"
 )
 
 func TestVar_Map(t *testing.T) {

container/gvar/gvar_z_unit_slice_test.go

@@ -7,9 +7,10 @@
 package gvar_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/test/gtest"
-	"testing"
 )
 
 func TestVar_Ints(t *testing.T) {

container/gvar/gvar_z_unit_struct_test.go

@@ -7,11 +7,12 @@
 package gvar_test
 
 import (
+	"testing"
+
 	"github.com/gogf/gf/v2/container/gvar"
 	"github.com/gogf/gf/v2/frame/g"
 	"github.com/gogf/gf/v2/test/gtest"
 	"github.com/gogf/gf/v2/util/gconv"
-	"testing"
 )
 
 func TestVar_Struct(t *testing.T) {

crypto/gaes/gaes.go

@@ -11,6 +11,7 @@ import (
 	"bytes"
 	"crypto/aes"
 	"crypto/cipher"
+
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 )

crypto/gaes/gaes_test.go

@@ -11,9 +11,8 @@ package gaes_test
 import (
 	"testing"
 
-	"github.com/gogf/gf/v2/encoding/gbase64"
-
 	"github.com/gogf/gf/v2/crypto/gaes"
+	"github.com/gogf/gf/v2/encoding/gbase64"
 	"github.com/gogf/gf/v2/test/gtest"
 )
 

crypto/gdes/gdes.go

@@ -11,6 +11,7 @@ import (
 	"bytes"
 	"crypto/cipher"
 	"crypto/des"
+
 	"github.com/gogf/gf/v2/errors/gcode"
 	"github.com/gogf/gf/v2/errors/gerror"
 )

database/gdb/gdb.go

@@ -10,20 +10,17 @@ package gdb
 import (
 	"context"
 	"database/sql"
-	"github.com/gogf/gf/v2/errors/gcode"
 	"time"
 
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/os/gcmd"
-
-	"github.com/gogf/gf/v2/container/gvar"
-	"github.com/gogf/gf/v2/internal/intlog"
-
-	"github.com/gogf/gf/v2/os/glog"
-
 	"github.com/gogf/gf/v2/container/gmap"
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/intlog"
 	"github.com/gogf/gf/v2/os/gcache"
+	"github.com/gogf/gf/v2/os/gcmd"
+	"github.com/gogf/gf/v2/os/glog"
 	"github.com/gogf/gf/v2/util/grand"
 )
 
@@ -455,7 +452,7 @@ func getConfigNodeByWeight(cg ConfigGroup) *ConfigNode {
 	max := 0
 	for i := 0; i < len(cg); i++ {
 		max = min + cg[i].Weight*100
-		//fmt.Printf("r: %d, min: %d, max: %d\n", r, min, max)
+		// fmt.Printf("r: %d, min: %d, max: %d\n", r, min, max)
 		if r >= min && r < max {
 			return &cg[i]
 		} else {

database/gdb/gdb_core.go

@@ -11,17 +11,16 @@ import (
 	"context"
 	"database/sql"
 	"fmt"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/internal/intlog"
 	"reflect"
 	"strings"
 
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/utils"
-	"github.com/gogf/gf/v2/text/gstr"
-
 	"github.com/gogf/gf/v2/container/gvar"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/intlog"
+	"github.com/gogf/gf/v2/internal/utils"
 	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
 )
 

database/gdb/gdb_core_config.go

@@ -8,11 +8,11 @@ package gdb
 
 import (
 	"fmt"
-	"github.com/gogf/gf/v2/os/glog"
 	"sync"
 	"time"
 
 	"github.com/gogf/gf/v2/os/gcache"
+	"github.com/gogf/gf/v2/os/glog"
 )
 
 // Config is the configuration management object.

database/gdb/gdb_core_structure.go

@@ -10,16 +10,12 @@ import (
 	"strings"
 	"time"
 
-	"github.com/gogf/gf/v2/util/gutil"
-
-	"github.com/gogf/gf/v2/text/gstr"
-
-	"github.com/gogf/gf/v2/os/gtime"
-
 	"github.com/gogf/gf/v2/encoding/gbinary"
-
+	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/text/gregex"
+	"github.com/gogf/gf/v2/text/gstr"
 	"github.com/gogf/gf/v2/util/gconv"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 // convertFieldValueToLocalValue automatically checks and converts field value from database type

database/gdb/gdb_core_tracing.go

@@ -10,6 +10,7 @@ package gdb
 import (
 	"context"
 	"fmt"
+
 	"github.com/gogf/gf/v2"
 	"github.com/gogf/gf/v2/net/gtrace"
 	"go.opentelemetry.io/otel"

database/gdb/gdb_core_transaction.go

@@ -9,17 +9,16 @@ package gdb
 import (
 	"context"
 	"database/sql"
-	"github.com/gogf/gf/v2/errors/gcode"
-	"github.com/gogf/gf/v2/errors/gerror"
-	"github.com/gogf/gf/v2/internal/utils"
 	"reflect"
 
 	"github.com/gogf/gf/v2/container/gtype"
+	"github.com/gogf/gf/v2/errors/gcode"
+	"github.com/gogf/gf/v2/errors/gerror"
+	"github.com/gogf/gf/v2/internal/utils"
 	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/text/gregex"
 	"github.com/gogf/gf/v2/util/gconv"
 	"github.com/gogf/gf/v2/util/guid"
-
-	"github.com/gogf/gf/v2/text/gregex"
 )
 
 // TX is the struct for transaction management.