slice.go · 測試

~~~ package toolutilv3 import ( "encoding/json" "fmt" "reflect" "sort" ) var ToolSlice = toolSliceUtil{} type toolSliceUtil struct{} /* AppendHead 向切片頭部追加元素 ChangeInterfaceToSlice 將 []interface{} 類型的切片轉換成指定類型的切片 ChangeSliceToInterface 將任意切片類型的切片轉換為 []interface{} 類型 Contains 方法可以檢查給定的切片中是否存在某個元素 ConvertSliceToMap 將結構體切片轉出[]map[string]interface{} FindDiffVales 找到兩個切片中不同的元素，返回兩個切片中不同元素組成的切片 FindSameVales 找到兩個切片中同同的元素，返回兩個切片中相同同元素組成的切片 FindOutVales 從slice1里剔除slice2存在的值 GroupByKey 將[]map[string]interface{}按某個字段分組 MapListKeyToIntSlice 函數從輸入的 []map[string]interface{} 類型的切片中提取指定 key 對應的 int 類型數值，并返回一個 []int 類型的切片。 UniqueInterface 函數用于合并多個任意類型的切片并去重 SetNilToDefaultValueByMap 字典中所有鍵名在 keys 數組中出現過且對應的鍵值為 nil 的元素改為默認值 defaultValue SetNilToDefaultValueByMapV2 處理nil值，出現在keys的nil設置成[], 其余的nil設置成"" SetNilToDefaultValueBySlice 切片中所有鍵名在 keys 數組中出現過且對應的鍵值為 nil 的元素改為默認值 defaultValue SetNilToDefaultValueBySliceV2 處理nil值，出現在keys的nil設置成[], 其余的nil設置成"" SortByKey 函數按照指定的 key 對應的值，對輸入的 []map[string]interface{} 類型的切片進行排序。 StringToSlice 將字符串解析為切片類型 StringToSliceInt 將字符串解析為Int切片類型 StringToMap 將字符串解析為字典類型 StringToMapSlice 將字符串解析為切片類型 */ //備注 // AppendHead 向切片頭部追加元素 func (s *toolSliceUtil) AppendHead(slice []interface{}, addData interface{}) []interface{} { return append([]interface{}{addData}, slice...) } // ChangeInterfaceToSlice 將 []interface{} 類型的切片轉換成指定類型的切片 func (s *toolSliceUtil) ChangeInterfaceToSlice(slice []interface{}, elementType reflect.Type) interface{} { // 創建一個新切片，使用reflect.MakeSlice函數創建 // 第一個參數是要創建的切片類型，使用reflect.SliceOf函數獲取 // 第二個參數是要創建的切片長度和容量，這里都設置為輸入 slice 的長度 newSlice := reflect.MakeSlice(reflect.SliceOf(elementType), len(slice), len(slice)) // 遍歷輸入的切片，將其中每個元素轉換成指定類型，并設置到新切片中 for i := 0; i < len(slice); i++ { // 使用reflect.ValueOf函數獲取當前元素的反射對象 // 然后調用Convert方法將其轉換成指定類型，并使用Set方法設置到新切片中 newSlice.Index(i).Set(reflect.ValueOf(slice[i]).Convert(elementType)) } // 返回轉換后的新切片，注意需要使用 .Interface() 方法將其轉換成 interface{} 類型 return newSlice.Interface() } // ChangeSliceToInterface 將任意切片類型的切片轉換為 []interface{} 類型 func (s *toolSliceUtil) ChangeSliceToInterface(slice interface{}) []interface{} { sliceValue := reflect.ValueOf(slice) if sliceValue.Kind() != reflect.Slice { panic("ToInterfaceSlice only supports slice types") } interfaceSlice := make([]interface{}, sliceValue.Len()) for i := 0; i < sliceValue.Len(); i++ { interfaceSlice[i] = sliceValue.Index(i).Interface() } return interfaceSlice } /* 參數slice是要檢查的切片，參數item是要查找的元素 */ // Contains 方法可以檢查給定的切片中是否存在某個元素 func (s *toolSliceUtil) Contains(slice interface{}, item interface{}) bool { // 使用反射獲取slice的值 v := reflect.ValueOf(slice) // 檢查v的類型是否為切片類型 if v.Kind() != reflect.Slice { return false } // 獲取slice元素的類型 elemType := v.Type().Elem() // 如果元素類型不可比較，則無法使用該方法進行查找 if !elemType.Comparable() { return false } // 遍歷整個切片 for i := 0; i < v.Len(); i++ { // 使用DeepEqual函數比較切片中的元素和要查找的元素 if reflect.DeepEqual(item, v.Index(i).Interface()) { return true } } // 如果循環結束仍未找到匹配項，則返回false return false } /* 該函數接受一個參數 slice，可以接受任何類型的切片結構體。在函數內部，我們首先使用反射獲取傳入參數的值和類型，然后遍歷每個結構體實例，將其轉換為 map[string]interface{} 類型，并添加到結果切片中。最后，返回轉換好的切片。如果傳入的參數不是切片類型或者切片元素不是結構體類型，函數會返回一個錯誤 not a slice 或者 not a struct。這可以防止代碼在運行時出現崩潰或者異常情況。 */ // ConvertSliceToMap 將結構體切片轉出[]map[string]interface{} func (s *toolSliceUtil) ConvertSliceToMap(slice interface{}) []map[string]interface{} { // 獲取slice的值 sliceValue := reflect.ValueOf(slice) // 檢查slice是否為切片類型 if sliceValue.Kind() != reflect.Slice { return []map[string]interface{}{} } // 創建一個空的map切片，用于存儲轉換后的結果 var result []map[string]interface{} // 遍歷整個slice for i := 0; i < sliceValue.Len(); i++ { // 獲取當前元素 item := sliceValue.Index(i) // 獲取當前元素的值 itemValue := reflect.ValueOf(item.Interface()) // 檢查當前元素是否為結構體類型 if itemValue.Kind() != reflect.Struct { return []map[string]interface{}{} } // 創建一個空的map，用于存儲當前元素的字段名和對應的值 itemMap := make(map[string]interface{}) // 遍歷當前元素的所有字段 for j := 0; j < itemValue.NumField(); j++ { // 獲取當前字段的名稱 fieldName := itemValue.Type().Field(j).Name // 獲取當前字段的值 fieldValue := itemValue.Field(j).Interface() // 將字段名和對應的值添加到map中 itemMap[fieldName] = fieldValue } // 將當前元素轉換為map后，將其添加到結果切片中 result = append(result, itemMap) } return result } // FindDiffVales 找到兩個切片中不同的元素，返回兩個切片中不同元素組成的切片 func (s *toolSliceUtil) FindDiffVales(slice1 []interface{}, slice2 []interface{}) []interface{} { // 創建一個空的切片，用于存儲不同的元素 diffVales := make([]interface{}, 0) // 遍歷第一個切片 for _, val1 := range slice1 { found := false // 在第二個切片中查找相同值 for _, val2 := range slice2 { if val1 == val2 { found = true break } } // 如果未找到相同值，則將其添加到不同值切片中 if !found { diffVales = append(diffVales, val1) } } // 遍歷第二個切片 for _, val2 := range slice2 { found := false // 在第一個切片中查找相同值 for _, val1 := range slice1 { if val2 == val1 { found = true break } } // 如果未找到相同值，則將其添加到不同值切片中 if !found { diffVales = append(diffVales, val2) } } // 返回兩個切片中不同元素組成的切片 return diffVales } // FindSameVales 找到兩個切片中同同的元素，返回兩個切片中相同同元素組成的切片 func (s *toolSliceUtil) FindSameVales(slice1 []interface{}, slice2 []interface{}) []interface{} { sameVales := make([]interface{}, 0) // 遍歷第一個切片 for _, val1 := range slice1 { // 在第二個切片中查找相同值 for _, val2 := range slice2 { if val1 == val2 { sameVales = append(sameVales, val1) break } } } return sameVales } // FindOutVales 從slice1里剔除slice2存在的值 func (s *toolSliceUtil) FindOutVales(slice1 []interface{}, slice2 []interface{}) []interface{} { // 創建一個map，用于存儲slice2中出現的所有元素 m := make(map[interface{}]bool) for _, i := range slice2 { m[i] = true } // 創建一個空的切片，用于存儲slice1中不同于slice2的元素 var result []interface{} for _, i := range slice1 { if !m[i] { result = append(result, i) } } // 返回slice2獨有的元素組成的切片 return result } /* 參數 slice 是一個 []map[string]interface{} 類型的切片，每個 map 中包含一條數據記錄。參數 key 和 name 都是字符串類型，分別表示按照哪個鍵進行分組和新生成的記錄的名稱。返回值是一個 []map[string]interface{} 類型的切片，其中每個 map 表示一組已經分好組的數據記錄。 */ // GroupByKey 將[]map[string]interface{}按某個字段分組 func (s *toolSliceUtil) GroupByKey(slice []map[string]interface{}, key string, name string) []map[string]interface{} { // 創建一個 map[interface{}][]interface{} 類型的變量 transformedData，用于存儲已經分組后的數據。 transformedData := make(map[interface{}][]interface{}) // 遍歷輸入的每個 map[string]interface{} 類型的數據記錄 d，在 transformedData 中找到對應的鍵 k，將其添加到分組后的列表中。 for _, d := range slice { k := d[key] if data, ok := transformedData[k]; ok { transformedData[k] = append(data, d) } else { transformedData[k] = []interface{}{d} } } // 創建一個 []map[string]interface{} 類型的切片 result，遍歷 transformedData map 中的所有鍵值對， // 并將其轉換為新的 map[string]interface{} 類型的數據記錄，并添加到 result 切片中。 result := make([]map[string]interface{}, 0, len(transformedData)) for k, v := range transformedData { m := map[string]interface{}{ key: k, name: v, } result = append(result, m) } // 返回 result 切片即可。 return result } /* 如果某個元素的 key 對應的不是 int 類型，則返回一個空的 []int 類型的切片。 */ //MapListKeyToIntSlice 函數從輸入的 []map[string]interface{} 類型的切片中提取指定 key 對應的 int 類型數值，并返回一個 []int 類型的切片。 func (s *toolSliceUtil) MapListKeyToIntSlice(list []map[string]interface{}, key string) []int { // 創建一個 []int 類型的切片 result，用于存儲提取出來的 int 數值。 result := make([]int, len(list)) // 遍歷輸入的每個 map[string]interface{} 類型的數據記錄 m，在其中找到 key 對應的值 v， // 如果 v 是 int 類型，則將其賦值給 result 切片對應的位置；否則，返回一個空的 []int 類型的切片。 for i, m := range list { if v, ok := m[key]; ok { if num, ok := v.(int); ok { result[i] = num } else { return []int{} } } else { return []int{} } } // 返回 result 切片即可。 return result } /* 參數 iList 是一個可變參數，可以接收任意數量的 []interface{} 類型的切片返回值是合并并去重后的 []interface{} 類型的切片 */ //UniqueInterface 函數用于合并多個任意類型的切片并去重 func (s *toolSliceUtil) UniqueInterface(iList ...[]interface{}) []interface{} { // 創建一個 map[interface{}]bool 類型的變量 m，用于記錄已經出現過的元素。 m := make(map[interface{}]bool) // 遍歷輸入的每個 []interface{} 類型的切片 ints，對于每個元素 i，將其添加到 m map 中。 for _, ints := range iList { for _, i := range ints { m[i] = true } } // 創建一個 []interface{} 類型的切片 result，遍歷上一步中去重后的 m map 中的所有鍵，并將其添加到 result 切片中。 var result []interface{} for k := range m { result = append(result, k) } // 返回 result 切片即可。 return result } // SetNilToDefaultValueByMap 字典中所有鍵名在 keys 數組中出現過且對應的鍵值為 nil 的元素改為默認值 defaultValue func (s *toolSliceUtil) SetNilToDefaultValueByMap(m map[string]interface{}, keys []string, defaultValue interface{}) { for _, key := range keys { if val, ok := m[key]; ok && val == nil { m[key] = defaultValue } } } // SetNilToDefaultValueByMapV2 處理nil值，出現在keys的nil設置成[], 其余的nil設置成"" func (s *toolSliceUtil) SetNilToDefaultValueByMapV2(m map[string]interface{}, keys []string) { for key, val := range m { if val == nil { if s.Contains(keys, key) { m[key] = "[]" } else { m[key] = "" } } } } // SetNilToDefaultValueBySlice 切片中所有鍵名在 keys 數組中出現過且對應的鍵值為 nil 的元素改為默認值 defaultValue func (s *toolSliceUtil) SetNilToDefaultValueBySlice(slice []map[string]interface{}, keys []string, defaultValue interface{}) { for _, m := range slice { for _, key := range keys { if val, ok := m[key]; ok && val == nil { m[key] = defaultValue } } } } // SetNilToDefaultValueBySliceV2 處理nil值，出現在keys的nil設置成[], 其余的nil設置成"" func (s *toolSliceUtil) SetNilToDefaultValueBySliceV2(slice []map[string]interface{}, keys []string) { for _, m := range slice { for key, val := range m { if val == nil { if s.Contains(keys, key) { m[key] = []interface{}{} } else { m[key] = "" } } } } } /* isAsc 參數控制是否為升序排列。如果 isAsc 為 true，則按照升序排列；否則，按照降序排列。 sort.SliceStable 可能會導致浮點數字段排序出現問題 */ // SortByKey 函數按照指定的 key 對應的值，對輸入的 []map[string]interface{} 類型的切片進行排序。 func (s *toolSliceUtil) SortByKey(slice []map[string]interface{}, key string, isAsc bool) { // 調用 sort.SliceStable 函數對 slice 進行排序，并提供一個函數作為比較器。 sort.SliceStable(slice, func(i, j int) bool { var less bool switch v := slice[i][key].(type) { case int: less = v < slice[j][key].(int) case int32: less = v < slice[j][key].(int32) case int64: less = v < slice[j][key].(int64) case float32: less = v < slice[j][key].(float32) case float64: less = v < slice[j][key].(float64) default: fmt.Println("unsupported type: $s", reflect.TypeOf(v)) return false } if isAsc { return less } return !less }) } /* str: 待解析的字符串 elementType: 切片元素的反射類型返回值: 解析后的切片 */ //StringToSlice 將字符串解析為切片類型 func (s *toolSliceUtil) StringToSlice(str string, elementType reflect.Type) interface{} { sliceType := reflect.SliceOf(elementType) sliceValue := reflect.New(sliceType).Elem() err := json.Unmarshal([]byte(str), sliceValue.Addr().Interface()) if err != nil { fmt.Println(err) } return sliceValue.Interface() } // StringToSliceInt 將字符串解析為Int切片類型 func (s *toolSliceUtil) StringToSliceInt(str string) []int { var slice []int err := json.Unmarshal([]byte(str), &slice) if err != nil { fmt.Println(err) } return slice } // StringToMap 將字符串解析為字典類型 func (s *toolSliceUtil) StringToMap(str string) map[string]interface{} { if str == "" { return map[string]interface{}{} } var m map[string]interface{} err := json.Unmarshal([]byte(str), &m) if err != nil { fmt.Println(err) return map[string]interface{}{} } return m } // StringToMapSlice 將字符串解析為切片類型 func (s *toolSliceUtil) StringToMapSlice(str string) []map[string]interface{} { if str == "" { return []map[string]interface{}{} } var m []map[string]interface{} err := json.Unmarshal([]byte(str), &m) if err != nil { fmt.Println(err) return []map[string]interface{}{} } return m } ~~~