From 0f854e46d84c98cdb365935c178d31e87a3b580b Mon Sep 17 00:00:00 2001 From: John Date: Fri, 22 Feb 2019 09:08:46 +0800 Subject: [PATCH] refact Merge function for garray; add more frequently-used type alias for gf --- g/container/garray/garray_normal_int.go | 27 ++++++++--------- g/container/garray/garray_normal_interface.go | 27 ++++++++--------- g/container/garray/garray_normal_string.go | 27 ++++++++--------- g/container/garray/garray_sorted_int.go | 28 ++++++++--------- g/container/garray/garray_sorted_interface.go | 30 ++++++++----------- g/container/garray/garray_sorted_string.go | 28 ++++++++--------- g/g.go | 29 +++++++++++++----- 7 files changed, 94 insertions(+), 102 deletions(-) diff --git a/g/container/garray/garray_normal_int.go b/g/container/garray/garray_normal_int.go index 18e8d4e1b..93e3c0282 100644 --- a/g/container/garray/garray_normal_int.go +++ b/g/container/garray/garray_normal_int.go @@ -458,23 +458,20 @@ func (a *IntArray) RLockFunc(f func(array []int)) *IntArray { } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Append is Append supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *IntArray) Merge(array interface{}) *IntArray { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, gconv.Ints(f.Slice())...) - } else if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, gconv.Ints(f.Slice())...) - } else { - a.array = append(a.array, gconv.Ints(array)...) - } + switch v := array.(type) { + case *Array: a.Append(gconv.Ints(v.Slice())...) + case *IntArray: a.Append(gconv.Ints(v.Slice())...) + case *StringArray: a.Append(gconv.Ints(v.Slice())...) + case *SortedArray: a.Append(gconv.Ints(v.Slice())...) + case *SortedIntArray: a.Append(gconv.Ints(v.Slice())...) + case *SortedStringArray: a.Append(gconv.Ints(v.Slice())...) + default: + a.Append(gconv.Ints(array)...) } return a } diff --git a/g/container/garray/garray_normal_interface.go b/g/container/garray/garray_normal_interface.go index 956f27445..6c1f76a5f 100644 --- a/g/container/garray/garray_normal_interface.go +++ b/g/container/garray/garray_normal_interface.go @@ -450,23 +450,20 @@ func (a *Array) RLockFunc(f func(array []interface{})) *Array { } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Append is Append supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *Array) Merge(array interface{}) *Array { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, gconv.Interfaces(f.Slice())...) - } else if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, gconv.Interfaces(f.Slice())...) - } else { - a.array = append(a.array, gconv.Interfaces(array)...) - } + switch v := array.(type) { + case *Array: a.Append(gconv.Interfaces(v.Slice())...) + case *IntArray: a.Append(gconv.Interfaces(v.Slice())...) + case *StringArray: a.Append(gconv.Interfaces(v.Slice())...) + case *SortedArray: a.Append(gconv.Interfaces(v.Slice())...) + case *SortedIntArray: a.Append(gconv.Interfaces(v.Slice())...) + case *SortedStringArray: a.Append(gconv.Interfaces(v.Slice())...) + default: + a.Append(gconv.Interfaces(array)...) } return a } diff --git a/g/container/garray/garray_normal_string.go b/g/container/garray/garray_normal_string.go index 877c50d33..c44438b70 100644 --- a/g/container/garray/garray_normal_string.go +++ b/g/container/garray/garray_normal_string.go @@ -457,23 +457,20 @@ func (a *StringArray) RLockFunc(f func(array []string)) *StringArray { } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Append is Append supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *StringArray) Merge(array interface{}) *StringArray { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, gconv.Strings(f.Slice())...) - } else if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, gconv.Strings(f.Slice())...) - } else { - a.array = append(a.array, gconv.Strings(array)...) - } + switch v := array.(type) { + case *Array: a.Append(gconv.Strings(v.Slice())...) + case *IntArray: a.Append(gconv.Strings(v.Slice())...) + case *StringArray: a.Append(gconv.Strings(v.Slice())...) + case *SortedArray: a.Append(gconv.Strings(v.Slice())...) + case *SortedIntArray: a.Append(gconv.Strings(v.Slice())...) + case *SortedStringArray: a.Append(gconv.Strings(v.Slice())...) + default: + a.Append(gconv.Strings(array)...) } return a } diff --git a/g/container/garray/garray_sorted_int.go b/g/container/garray/garray_sorted_int.go index 07dcf5fd1..c2a7cfab3 100644 --- a/g/container/garray/garray_sorted_int.go +++ b/g/container/garray/garray_sorted_int.go @@ -432,25 +432,21 @@ func (a *SortedIntArray) RLockFunc(f func(array []int)) *SortedIntArray { } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Add is Add supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *SortedIntArray) Merge(array interface{}) *SortedIntArray { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, gconv.Ints(f.Slice())...) - } else if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, gconv.Ints(f.Slice())...) - } else { - a.array = append(a.array, gconv.Ints(array)...) - } + switch v := array.(type) { + case *Array: a.Add(gconv.Ints(v.Slice())...) + case *IntArray: a.Add(gconv.Ints(v.Slice())...) + case *StringArray: a.Add(gconv.Ints(v.Slice())...) + case *SortedArray: a.Add(gconv.Ints(v.Slice())...) + case *SortedIntArray: a.Add(gconv.Ints(v.Slice())...) + case *SortedStringArray: a.Add(gconv.Ints(v.Slice())...) + default: + a.Add(gconv.Ints(array)...) } - sort.Ints(a.array) return a } diff --git a/g/container/garray/garray_sorted_interface.go b/g/container/garray/garray_sorted_interface.go index 316555112..48544e16b 100644 --- a/g/container/garray/garray_sorted_interface.go +++ b/g/container/garray/garray_sorted_interface.go @@ -439,27 +439,21 @@ func (a *SortedArray) RLockFunc(f func(array []interface{})) *SortedArray { } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Add is Add supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *SortedArray) Merge(array interface{}) *SortedArray { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, gconv.Interfaces(f.Slice())...) - } else if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, gconv.Interfaces(f.Slice())...) - } else { - a.array = append(a.array, gconv.Interfaces(array)...) - } + switch v := array.(type) { + case *Array: a.Add(gconv.Interfaces(v.Slice())...) + case *IntArray: a.Add(gconv.Interfaces(v.Slice())...) + case *StringArray: a.Add(gconv.Interfaces(v.Slice())...) + case *SortedArray: a.Add(gconv.Interfaces(v.Slice())...) + case *SortedIntArray: a.Add(gconv.Interfaces(v.Slice())...) + case *SortedStringArray: a.Add(gconv.Interfaces(v.Slice())...) + default: + a.Add(gconv.Interfaces(array)...) } - sort.Slice(a.array, func(i, j int) bool { - return a.compareFunc(a.array[i], a.array[j]) < 0 - }) return a } diff --git a/g/container/garray/garray_sorted_string.go b/g/container/garray/garray_sorted_string.go index c0fd90f38..6ead68b12 100644 --- a/g/container/garray/garray_sorted_string.go +++ b/g/container/garray/garray_sorted_string.go @@ -427,25 +427,21 @@ func (a *SortedStringArray) RLockFunc(f func(array []string)) *SortedStringArray } // Merge two arrays. The parameter can be any garray type or slice type. +// The difference between Merge and Add is Add supports only specified slice type, +// but Merge supports more variable types. // -// 合并两个数组. +// 合并两个数组, 支持任意的garray数组类型及slice类型. func (a *SortedStringArray) Merge(array interface{}) *SortedStringArray { - a.mu.Lock() - defer a.mu.Unlock() - if a == array { - a.array = append(a.array, a.array...) - } else { - if f, ok := array.(apiSliceString); ok { - a.array = append(a.array, f.Slice()...) - } else if f, ok := array.(apiSliceInterface); ok { - a.array = append(a.array, gconv.Strings(f.Slice())...) - } else if f, ok := array.(apiSliceInt); ok { - a.array = append(a.array, gconv.Strings(f.Slice())...) - } else { - a.array = append(a.array, gconv.Strings(array)...) - } + switch v := array.(type) { + case *Array: a.Add(gconv.Strings(v.Slice())...) + case *IntArray: a.Add(gconv.Strings(v.Slice())...) + case *StringArray: a.Add(gconv.Strings(v.Slice())...) + case *SortedArray: a.Add(gconv.Strings(v.Slice())...) + case *SortedIntArray: a.Add(gconv.Strings(v.Slice())...) + case *SortedStringArray: a.Add(gconv.Strings(v.Slice())...) + default: + a.Add(gconv.Strings(array)...) } - sort.Strings(a.array) return a } diff --git a/g/g.go b/g/g.go index 8020645bf..797391177 100644 --- a/g/g.go +++ b/g/g.go @@ -3,34 +3,49 @@ // 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 g import "github.com/gogf/gf/g/container/gvar" -// 框架动态变量，可以用该类型替代interface{}类型 -type Var = gvar.Var +// Universal variable type, like generics. +// +// 动态变量类型，可以用该类型替代interface{}类型 +type Var = gvar.Var +// Frequently-used map type alias. +// // 常用map数据结构(使用别名) -type Map = map[string]interface{} +type Map = map[interface{}]interface{} +type MapAnyStr = map[interface{}]string +type MapAnyInt = map[interface{}]int +type MapStrAny = map[string]interface{} type MapStrStr = map[string]string type MapStrInt = map[string]int +type MapIntAny = map[int]interface{} type MapIntStr = map[int]string type MapIntInt = map[int]int +// Frequently-used slice type alias. +// // 常用list数据结构(使用别名) type List = []Map +type ListAnyStr = []map[interface{}]string +type ListAnyInt = []map[interface{}]int +type ListStrAny = []map[string]interface{} type ListStrStr = []map[string]string type ListStrInt = []map[string]int +type ListIntAny = []map[int]interface{} type ListIntStr = []map[int]string type ListIntInt = []map[int]int // 常用slice数据结构(使用别名) type Slice = []interface{} +type SliceAny = []interface{} type SliceStr = []string type SliceInt = []int -type Array = Slice -type ArrayStr = SliceStr -type ArrayInt = SliceInt +type Array = []interface{} +type ArrayAny = []interface{} +type ArrayStr = []string +type ArrayInt = []int