diff --git a/container/garray/garray_normal_any.go b/container/garray/garray_normal_any.go
index 1f7c41e10..dada3606b 100644
--- a/container/garray/garray_normal_any.go
+++ b/container/garray/garray_normal_any.go
@@ -824,6 +824,9 @@ func (a *Array) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *Array) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]interface{}, len(a.array))
diff --git a/container/garray/garray_normal_int.go b/container/garray/garray_normal_int.go
index a6fd90160..cf2ca1cb1 100644
--- a/container/garray/garray_normal_int.go
+++ b/container/garray/garray_normal_int.go
@@ -802,6 +802,9 @@ func (a *IntArray) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *IntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]int, len(a.array))
diff --git a/container/garray/garray_normal_str.go b/container/garray/garray_normal_str.go
index 26861c443..58fdc59a4 100644
--- a/container/garray/garray_normal_str.go
+++ b/container/garray/garray_normal_str.go
@@ -815,6 +815,9 @@ func (a *StrArray) IsEmpty() bool {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *StrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]string, len(a.array))
diff --git a/container/garray/garray_sorted_any.go b/container/garray/garray_sorted_any.go
index 20e1dfb2b..a4aafa192 100644
--- a/container/garray/garray_sorted_any.go
+++ b/container/garray/garray_sorted_any.go
@@ -800,6 +800,9 @@ func (a *SortedArray) getComparator() func(a, b interface{}) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]interface{}, len(a.array))
diff --git a/container/garray/garray_sorted_int.go b/container/garray/garray_sorted_int.go
index b1ded91a9..7090c6823 100644
--- a/container/garray/garray_sorted_int.go
+++ b/container/garray/garray_sorted_int.go
@@ -747,6 +747,9 @@ func (a *SortedIntArray) getComparator() func(a, b int) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedIntArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]int, len(a.array))
diff --git a/container/garray/garray_sorted_str.go b/container/garray/garray_sorted_str.go
index 69dbd79ba..5a4e8e046 100644
--- a/container/garray/garray_sorted_str.go
+++ b/container/garray/garray_sorted_str.go
@@ -760,6 +760,9 @@ func (a *SortedStrArray) getComparator() func(a, b string) int {
 
 // DeepCopy implements interface for deep copy of current type.
 func (a *SortedStrArray) DeepCopy() interface{} {
+	if a == nil {
+		return nil
+	}
 	a.mu.RLock()
 	defer a.mu.RUnlock()
 	newSlice := make([]string, len(a.array))
diff --git a/container/glist/glist.go b/container/glist/glist.go
index 463256931..95958eaed 100644
--- a/container/glist/glist.go
+++ b/container/glist/glist.go
@@ -550,6 +550,10 @@ func (l *List) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (l *List) DeepCopy() interface{} {
+	if l == nil {
+		return nil
+	}
+
 	l.mu.RLock()
 	defer l.mu.RUnlock()
 
diff --git a/container/gmap/gmap_hash_any_any_map.go b/container/gmap/gmap_hash_any_any_map.go
index 571c327f5..60e8ef408 100644
--- a/container/gmap/gmap_hash_any_any_map.go
+++ b/container/gmap/gmap_hash_any_any_map.go
@@ -15,6 +15,7 @@ import (
 	"github.com/gogf/gf/v2/util/gconv"
 )
 
+// AnyAnyMap wraps map type `map[interface{}]interface{}` and provides more map features.
 type AnyAnyMap struct {
 	mu   rwmutex.RWMutex
 	data map[interface{}]interface{}
@@ -501,6 +502,10 @@ func (m *AnyAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *AnyAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
+
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[interface{}]interface{}, len(m.data))
diff --git a/container/gmap/gmap_hash_int_any_map.go b/container/gmap/gmap_hash_int_any_map.go
index fabba0528..291c6c37c 100644
--- a/container/gmap/gmap_hash_int_any_map.go
+++ b/container/gmap/gmap_hash_int_any_map.go
@@ -503,6 +503,9 @@ func (m *IntAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]interface{}, len(m.data))
diff --git a/container/gmap/gmap_hash_int_int_map.go b/container/gmap/gmap_hash_int_int_map.go
index 65b8c8896..4b336d002 100644
--- a/container/gmap/gmap_hash_int_int_map.go
+++ b/container/gmap/gmap_hash_int_int_map.go
@@ -473,6 +473,9 @@ func (m *IntIntMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]int, len(m.data))
diff --git a/container/gmap/gmap_hash_int_str_map.go b/container/gmap/gmap_hash_int_str_map.go
index 8a3f5c895..92b8de8a6 100644
--- a/container/gmap/gmap_hash_int_str_map.go
+++ b/container/gmap/gmap_hash_int_str_map.go
@@ -473,6 +473,9 @@ func (m *IntStrMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *IntStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[int]string, len(m.data))
diff --git a/container/gmap/gmap_hash_str_any_map.go b/container/gmap/gmap_hash_str_any_map.go
index cde3fad81..24ec1cc3d 100644
--- a/container/gmap/gmap_hash_str_any_map.go
+++ b/container/gmap/gmap_hash_str_any_map.go
@@ -489,6 +489,9 @@ func (m *StrAnyMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrAnyMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]interface{}, len(m.data))
diff --git a/container/gmap/gmap_hash_str_int_map.go b/container/gmap/gmap_hash_str_int_map.go
index 875601dda..0f3ef5d7b 100644
--- a/container/gmap/gmap_hash_str_int_map.go
+++ b/container/gmap/gmap_hash_str_int_map.go
@@ -477,6 +477,9 @@ func (m *StrIntMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrIntMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]int, len(m.data))
diff --git a/container/gmap/gmap_hash_str_str_map.go b/container/gmap/gmap_hash_str_str_map.go
index 0a5e85620..595f5bfa7 100644
--- a/container/gmap/gmap_hash_str_str_map.go
+++ b/container/gmap/gmap_hash_str_str_map.go
@@ -466,6 +466,9 @@ func (m *StrStrMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *StrStrMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[string]string, len(m.data))
diff --git a/container/gmap/gmap_list_map.go b/container/gmap/gmap_list_map.go
index 8a9553cf1..3197a5cad 100644
--- a/container/gmap/gmap_list_map.go
+++ b/container/gmap/gmap_list_map.go
@@ -594,6 +594,9 @@ func (m *ListMap) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (m *ListMap) DeepCopy() interface{} {
+	if m == nil {
+		return nil
+	}
 	m.mu.RLock()
 	defer m.mu.RUnlock()
 	data := make(map[interface{}]interface{}, len(m.data))
diff --git a/container/gset/gset_any_set.go b/container/gset/gset_any_set.go
index e67ed2a70..444745a9c 100644
--- a/container/gset/gset_any_set.go
+++ b/container/gset/gset_any_set.go
@@ -513,6 +513,9 @@ func (set *Set) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *Set) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	data := make(map[interface{}]struct{}, len(set.data))
diff --git a/container/gset/gset_int_set.go b/container/gset/gset_int_set.go
index 8dab1b02a..3c741ef23 100644
--- a/container/gset/gset_int_set.go
+++ b/container/gset/gset_int_set.go
@@ -472,6 +472,9 @@ func (set *IntSet) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *IntSet) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (
diff --git a/container/gset/gset_str_set.go b/container/gset/gset_str_set.go
index 2280c387c..3b6f4381a 100644
--- a/container/gset/gset_str_set.go
+++ b/container/gset/gset_str_set.go
@@ -502,6 +502,9 @@ func (set *StrSet) UnmarshalValue(value interface{}) (err error) {
 
 // DeepCopy implements interface for deep copy of current type.
 func (set *StrSet) DeepCopy() interface{} {
+	if set == nil {
+		return nil
+	}
 	set.mu.RLock()
 	defer set.mu.RUnlock()
 	var (
diff --git a/container/gtype/gtype_bool.go b/container/gtype/gtype_bool.go
index 507f61a25..b85dfd912 100644
--- a/container/gtype/gtype_bool.go
+++ b/container/gtype/gtype_bool.go
@@ -99,5 +99,8 @@ func (v *Bool) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Bool) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewBool(v.Val())
 }
diff --git a/container/gtype/gtype_byte.go b/container/gtype/gtype_byte.go
index 0424ac6d8..836231c57 100644
--- a/container/gtype/gtype_byte.go
+++ b/container/gtype/gtype_byte.go
@@ -78,5 +78,8 @@ func (v *Byte) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Byte) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewByte(v.Val())
 }
diff --git a/container/gtype/gtype_bytes.go b/container/gtype/gtype_bytes.go
index 18eba1311..e01ee4182 100644
--- a/container/gtype/gtype_bytes.go
+++ b/container/gtype/gtype_bytes.go
@@ -86,6 +86,9 @@ func (v *Bytes) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Bytes) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	oldBytes := v.Val()
 	newBytes := make([]byte, len(oldBytes))
 	copy(newBytes, oldBytes)
diff --git a/container/gtype/gtype_float32.go b/container/gtype/gtype_float32.go
index b22fa55e0..82289abbd 100644
--- a/container/gtype/gtype_float32.go
+++ b/container/gtype/gtype_float32.go
@@ -90,5 +90,8 @@ func (v *Float32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Float32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewFloat32(v.Val())
 }
diff --git a/container/gtype/gtype_float64.go b/container/gtype/gtype_float64.go
index 4a5187f82..ce44abd15 100644
--- a/container/gtype/gtype_float64.go
+++ b/container/gtype/gtype_float64.go
@@ -90,5 +90,8 @@ func (v *Float64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Float64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewFloat64(v.Val())
 }
diff --git a/container/gtype/gtype_int.go b/container/gtype/gtype_int.go
index 47c378535..32a610fbe 100644
--- a/container/gtype/gtype_int.go
+++ b/container/gtype/gtype_int.go
@@ -78,5 +78,8 @@ func (v *Int) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt(v.Val())
 }
diff --git a/container/gtype/gtype_int32.go b/container/gtype/gtype_int32.go
index 7980396ba..58ad36a3b 100644
--- a/container/gtype/gtype_int32.go
+++ b/container/gtype/gtype_int32.go
@@ -78,5 +78,8 @@ func (v *Int32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt32(v.Val())
 }
diff --git a/container/gtype/gtype_int64.go b/container/gtype/gtype_int64.go
index 4d5612160..54e72c12d 100644
--- a/container/gtype/gtype_int64.go
+++ b/container/gtype/gtype_int64.go
@@ -78,5 +78,8 @@ func (v *Int64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Int64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInt64(v.Val())
 }
diff --git a/container/gtype/gtype_interface.go b/container/gtype/gtype_interface.go
index 73d30edc9..9e57abb6f 100644
--- a/container/gtype/gtype_interface.go
+++ b/container/gtype/gtype_interface.go
@@ -75,5 +75,8 @@ func (v *Interface) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Interface) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewInterface(deepcopy.Copy(v.Val()))
 }
diff --git a/container/gtype/gtype_string.go b/container/gtype/gtype_string.go
index f3e442eb2..b753e0faa 100644
--- a/container/gtype/gtype_string.go
+++ b/container/gtype/gtype_string.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"
 )
 
 // String is a struct for concurrent-safe operation for type string.
@@ -69,3 +70,11 @@ func (v *String) UnmarshalValue(value interface{}) error {
 	v.Set(gconv.String(value))
 	return nil
 }
+
+// DeepCopy implements interface for deep copy of current type.
+func (v *String) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
+	return NewString(v.Val())
+}
diff --git a/container/gtype/gtype_uint.go b/container/gtype/gtype_uint.go
index d8d067156..fa00f472d 100644
--- a/container/gtype/gtype_uint.go
+++ b/container/gtype/gtype_uint.go
@@ -78,5 +78,8 @@ func (v *Uint) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint(v.Val())
 }
diff --git a/container/gtype/gtype_uint32.go b/container/gtype/gtype_uint32.go
index 8a1db4d0d..58df2e2cd 100644
--- a/container/gtype/gtype_uint32.go
+++ b/container/gtype/gtype_uint32.go
@@ -78,5 +78,8 @@ func (v *Uint32) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint32) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint32(v.Val())
 }
diff --git a/container/gtype/gtype_uint64.go b/container/gtype/gtype_uint64.go
index 8372bb32f..3b54eb63c 100644
--- a/container/gtype/gtype_uint64.go
+++ b/container/gtype/gtype_uint64.go
@@ -78,5 +78,8 @@ func (v *Uint64) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Uint64) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return NewUint64(v.Val())
 }
diff --git a/container/gvar/gvar.go b/container/gvar/gvar.go
index 15e82eb14..a343089df 100644
--- a/container/gvar/gvar.go
+++ b/container/gvar/gvar.go
@@ -198,5 +198,8 @@ func (v *Var) UnmarshalValue(value interface{}) error {
 
 // DeepCopy implements interface for deep copy of current type.
 func (v *Var) DeepCopy() interface{} {
+	if v == nil {
+		return nil
+	}
 	return New(deepcopy.Copy(v.Val()), v.safe)
 }
diff --git a/internal/deepcopy/deepcopy.go b/internal/deepcopy/deepcopy.go
index 52198d43f..e379f5fd1 100644
--- a/internal/deepcopy/deepcopy.go
+++ b/internal/deepcopy/deepcopy.go
@@ -57,7 +57,7 @@ func Copy(src interface{}) interface{} {
 // limited support for what it can handle. Add as needed.
 func copyRecursive(original, cpy reflect.Value) {
 	// check for implement deepcopy.Interface
-	if original.CanInterface() {
+	if original.CanInterface() && original.IsValid() && !original.IsZero() {
 		if copier, ok := original.Interface().(Interface); ok {
 			cpy.Set(reflect.ValueOf(copier.DeepCopy()))
 			return
diff --git a/os/gtime/gtime_time.go b/os/gtime/gtime_time.go
index 2ab944746..0061070c4 100644
--- a/os/gtime/gtime_time.go
+++ b/os/gtime/gtime_time.go
@@ -482,5 +482,8 @@ func (t *Time) NoValidation() {}
 
 // DeepCopy implements interface for deep copy of current type.
 func (t *Time) DeepCopy() interface{} {
+	if t == nil {
+		return nil
+	}
 	return New(t.Time)
 }
diff --git a/os/gtime/gtime_z_example_time_test.go b/os/gtime/gtime_z_example_time_test.go
index 06f139334..84a42dda7 100644
--- a/os/gtime/gtime_z_example_time_test.go
+++ b/os/gtime/gtime_z_example_time_test.go
@@ -15,9 +15,7 @@ import (
 	"github.com/gogf/gf/v2/os/gtime"
 )
 
-// New creates and returns a Time object with given parameter.
-// The optional parameter can be type of: time.Time/*time.Time, string or integer.
-func ExampleNew() {
+func ExampleNew_Basic() {
 	curTime := "2018-08-08 08:08:08"
 	timer, _ := time.Parse("2006-01-02 15:04:05", curTime)
 	t1 := gtime.New(&timer)
@@ -40,6 +38,13 @@ func ExampleNew() {
 	// 2018-08-08 08:08:08
 }
 
+func ExampleNew_WithFormat() {
+	fmt.Println(gtime.New("20220629133225", "YmdHis").Format("Y-m-d H:i:s"))
+
+	// Output:
+	// 2022-06-29 13:32:25
+}
+
 // Now creates and returns a time object of now.
 func ExampleNow() {
 	t := gtime.Now()
diff --git a/os/gtime/gtime_z_unit_time_test.go b/os/gtime/gtime_z_unit_time_test.go
index 350bc8c19..9527b71e5 100644
--- a/os/gtime/gtime_z_unit_time_test.go
+++ b/os/gtime/gtime_z_unit_time_test.go
@@ -13,6 +13,7 @@ import (
 
 	"github.com/gogf/gf/v2/os/gtime"
 	"github.com/gogf/gf/v2/test/gtest"
+	"github.com/gogf/gf/v2/util/gutil"
 )
 
 func Test_New(t *testing.T) {
@@ -407,3 +408,24 @@ func Test_Issue1681(t *testing.T) {
 		t.Assert(gtime.New("2022-03-08T03:01:14+08:00").Local().Time, gtime.New("2022-03-07T19:01:14Z").Local().Time)
 	})
 }
+
+func Test_DeepCopy(t *testing.T) {
+	type User struct {
+		Id          int
+		CreatedTime *gtime.Time
+	}
+	gtest.C(t, func(t *gtest.T) {
+		u1 := &User{
+			Id:          1,
+			CreatedTime: gtime.New("2022-03-08T03:01:14+08:00"),
+		}
+		u2 := gutil.Copy(u1).(*User)
+		t.Assert(u1, u2)
+	})
+	// nil attribute.
+	gtest.C(t, func(t *gtest.T) {
+		u1 := &User{}
+		u2 := gutil.Copy(u1).(*User)
+		t.Assert(u1, u2)
+	})
+}
diff --git a/util/gutil/gutil_z_unit_copy_test.go b/util/gutil/gutil_z_unit_copy_test.go
index bab144f1f..087121c60 100755
--- a/util/gutil/gutil_z_unit_copy_test.go
+++ b/util/gutil/gutil_z_unit_copy_test.go
@@ -15,6 +15,12 @@ import (
 )
 
 func Test_Copy(t *testing.T) {
+	gtest.C(t, func(t *gtest.T) {
+		t.Assert(gutil.Copy(0), 0)
+		t.Assert(gutil.Copy(1), 1)
+		t.Assert(gutil.Copy("a"), "a")
+		t.Assert(gutil.Copy(nil), nil)
+	})
 	gtest.C(t, func(t *gtest.T) {
 		src := g.Map{
 			"k1": "v1",