slice.go · 測試

~~~ /* Package toolutilv4 提供了一組通用切片函數，函數目錄： - AppendHead(AppendHeadInt,AppendHeadStr,AppendHeadSliceMap) 在切片頭部追加一個整數元素，并返回新的切片 - Contains(ContainsInt,ContainStr) 檢查給定的切片中是否存在某個元素 - ConvertSliceToMap 將結構體切片轉出[]map[string]interface{} - FindDiffVales(FindDiffValesInt,FindDiffValesStr) 找到兩個切片中不同的元素，返回兩個切片中不同元素組成的切片 - FindSameVales(FindSameValesInt,FindSameValesStr) 找到兩個切片中同同的元素，返回兩個切片中相同同元素組成的切片 - FindOutVales(FindOutValesInt,FindOutValesStr) 從slice1里剔除slice2存在的值 - FilterSlice 模糊搜索 - GroupByKey 將[]map[string]interface{}按某個字段分組 - MapListKeyToSlice(MapListKeyToSliceInt, MapListKeyToSliceStr) 從輸入的 []map[string]interface{} 類型的切片中提取指定 key 對應的類型數值，并返回一個對應類型的切片 - MoveToFirst 移動第一位 - Paginate 分頁 - RemoveKeysFromMaps 刪除指定key - Unique(UniqueInt, UniqueString) 切片去重 - SortByKey 函數按照指定的 key 對應的值，對輸入的 []map[string]interface{} 類型的切片進行排序。 - StringToSlice(StringToSliceInt, StringToSliceStr) 將字符串解析為對應切片類型 */ package toolutilv4 import ( "encoding/json" "fmt" "reflect" "sort" "strings" ) var ToolSlice = toolSliceUtil{} type toolSliceUtil struct{} // AppendHeadInt 在切片頭部追加一個整數元素，并返回新的切片 func (s *toolSliceUtil) AppendHeadInt(slice []int, addData int) []int { return append([]int{addData}, slice...) } // AppendHeadStr 在切片頭部追加一個整數元素，并返回新的切片 func (s *toolSliceUtil) AppendHeadStr(slice []string, addData string) []string { return append([]string{addData}, slice...) } // AppendHeadSliceMap 在切片頭部追加一個整數元素，并返回新的切片 func (s *toolSliceUtil) AppendHeadSliceMap(slice []map[string]interface{}, addData map[string]interface{}) []map[string]interface{} { // 創建一個新的切片，容量為原切片長度加1 newSlice := make([]map[string]interface{}, len(slice)+1) // 在新切片的開頭添加 addData 元素 newSlice[0] = addData // 將原切片的元素拷貝到新切片中，從索引1開始，覆蓋掉原切片的位置 copy(newSlice[1:], slice) // 返回新的切片 return newSlice } // ContainsInt 檢查給定的切片中是否存在某個元素 func (s *toolSliceUtil) ContainsInt(slice []int, item int) bool { // 遍歷整個切片 for i := 0; i < len(slice); i++ { // 比較切片中的元素和要查找的元素 if slice[i] == item { return true } } // 如果循環結束仍未找到匹配項，則返回false return false } // ContainStr 方法可以檢查給定的切片中是否存在某個元素 func (s *toolSliceUtil) ContainStr(slice []string, item string) bool { // 遍歷整個切片 for i := 0; i < len(slice); i++ { // 比較切片中的元素和要查找的元素 if slice[i] == item { 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 } // FindDiffValesInt 找到兩個切片中不同的元素，返回兩個切片中不同元素組成的切片 func (s *toolSliceUtil) FindDiffValesInt(slice1 []int, slice2 []int) []int { // 創建一個空的切片，用于存儲不同的元素 diffVals := make([]int, 0) // 使用map存儲第一個切片中的元素，以便快速查找 lookup := make(map[int]struct{}) for _, val := range slice1 { lookup[val] = struct{}{} } // 遍歷第二個切片 for _, val := range slice2 { // 如果第二個切片中的元素不在第一個切片中，則添加到不同值切片中 if _, ok := lookup[val]; !ok { diffVals = append(diffVals, val) } } // 返回兩個切片中不同元素組成的切片 return diffVals } // FindDiffValesStr找到兩個切片中不同的元素，返回兩個切片中不同元素組成的切片 func (s *toolSliceUtil) FindDiffValesStr(slice1 []string, slice2 []string) []string { // 創建一個空的切片，用于存儲不同的元素 diffVals := make([]string, 0) // 使用map存儲第一個切片中的元素，以便快速查找 lookup := make(map[string]struct{}) for _, val := range slice1 { lookup[val] = struct{}{} } // 遍歷第二個切片 for _, val := range slice2 { // 如果第二個切片中的元素不在第一個切片中，則添加到不同值切片中 if _, ok := lookup[val]; !ok { diffVals = append(diffVals, val) } } // 返回兩個切片中不同元素組成的切片 return diffVals } // FindSameValesInt 找到兩個切片中同同的元素，返回兩個切片中相同同元素組成的切片 func (s *toolSliceUtil) FindSameValesInt(slice1 []int, slice2 []int) []int { sameVals := make([]int, 0) // 使用map存儲第一個切片中的元素，以便快速查找 lookup := make(map[int]struct{}) for _, val := range slice1 { lookup[val] = struct{}{} } // 遍歷第二個切片 for _, val := range slice2 { // 如果第二個切片中的元素在第一個切片中，則添加到相同值切片中 if _, ok := lookup[val]; ok { sameVals = append(sameVals, val) } } // 返回兩個切片中相同元素組成的切片 return sameVals } // FindSameValesStr 找到兩個切片中同同的元素，返回兩個切片中相同同元素組成的切片 func (s *toolSliceUtil) FindSameValesStr(slice1 []string, slice2 []string) []string { sameVals := make([]string, 0) // 使用map存儲第一個切片中的元素，以便快速查找 lookup := make(map[string]struct{}) for _, val := range slice1 { lookup[val] = struct{}{} } // 遍歷第二個切片 for _, val := range slice2 { // 如果第二個切片中的元素在第一個切片中，則添加到相同值切片中 if _, ok := lookup[val]; ok { sameVals = append(sameVals, val) } } // 返回兩個切片中相同元素組成的切片 return sameVals } func (s *toolSliceUtil) FindSameValesOfInt(slice1 []int, slice2 []int) []int { sameVales := make([]int, 0) // 遍歷第一個切片 for _, val1 := range slice1 { // 在第二個切片中查找相同值 for _, val2 := range slice2 { if val1 == val2 { sameVales = append(sameVales, val1) break } } } return sameVales } // FindOutValesInt 從slice1里剔除slice2存在的值 func (s *toolSliceUtil) FindOutValesInt(slice1 []int, slice2 []int) []int { // 創建一個map，用于存儲slice2中出現的所有元素 m := make(map[int]bool) for _, i := range slice2 { m[i] = true } // 創建一個空的切片，用于存儲slice1中不同于slice2的元素 var result []int for _, i := range slice1 { if !m[i] { result = append(result, i) } } // 返回slice2獨有的元素組成的切片 return result } // FindOutValesStr 從slice1里剔除slice2存在的值 func (s *toolSliceUtil) FindOutValesStr(slice1 []string, slice2 []string) []string { // 創建一個map，用于存儲slice2中出現的所有元素 m := make(map[string]bool) for _, i := range slice2 { m[i] = true } // 創建一個空的切片，用于存儲slice1中不同于slice2的元素 var result []string for _, i := range slice1 { if !m[i] { result = append(result, i) } } // 返回slice2獨有的元素組成的切片 return result } // 模糊搜索 func (s *toolSliceUtil) FilterSlice(slice []map[string]interface{}, key string, value interface{}) []map[string]interface{} { result := make([]map[string]interface{}, 0) for _, item := range slice { if val, ok := item[key]; ok && strings.Contains(fmt.Sprintf("%v", val), fmt.Sprintf("%v", value)) { result = append(result, item) } } 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 類型的切片。 */ //MapListKeyToSliceInt 函數從輸入的 []map[string]interface{} 類型的切片中提取指定 key 對應的 int 類型數值，并返回一個 []int 類型的切片。 func (s *toolSliceUtil) MapListKeyToSliceInt(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 } func (s *toolSliceUtil) MapListKeyToSliceStr(list []map[string]interface{}, key string) []string { // 創建一個 []int 類型的切片 result，用于存儲提取出來的 int 數值。 result := make([]string, 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.(string); ok { result[i] = num } else { return []string{} } } else { return []string{} } } // 返回 result 切片即可。 return result } // 移動第一位 func (s *toolSliceUtil) MoveToFirst(slice []map[string]interface{}, key string, value interface{}) { for i, item := range slice { if val, ok := item[key]; ok && val == value { // 將匹配到的元素移動到切片的第一位 copy(slice[1:i+1], slice[:i]) slice[0] = item break } } } // 分頁 func (s *toolSliceUtil) Paginate(data []map[string]interface{}, pageNumber, itemsPerPage int) []map[string]interface{} { if len(data) == 0 { return nil } // 計算切片的總頁數 totalPages := (len(data) + itemsPerPage - 1) / itemsPerPage // 確保頁碼在有效范圍內 if pageNumber < 1 { pageNumber = 1 } else if pageNumber > totalPages { pageNumber = totalPages } // 計算切片的起始索引和結束索引 startIndex := (pageNumber - 1) * itemsPerPage endIndex := startIndex + itemsPerPage // 防止結束索引越界 if endIndex > len(data) { endIndex = len(data) } // 返回分頁數據 return data[startIndex:endIndex] } // 刪除指定key func (s *toolSliceUtil) RemoveKeysFromMaps(slice []map[string]interface{}, keysToRemove []string) []map[string]interface{} { // 創建新的切片用于存儲刪除鍵后的結果 updatedSlice := make([]map[string]interface{}, 0) // 遍歷原始切片 for _, item := range slice { // 創建新的 map 用于存儲刪除鍵后的元素 updatedItem := make(map[string]interface{}) // 復制原始 map 的鍵值對到新的 map for k, v := range item { // 檢查當前鍵是否需要刪除 if !contains(keysToRemove, k) { updatedItem[k] = v } } // 將刪除鍵后的元素添加到新的切片 updatedSlice = append(updatedSlice, updatedItem) } return updatedSlice } func contains(slice []string, key string) bool { for _, v := range slice { if v == key { return true } } return false } func (s *toolSliceUtil) UniqueInt(slice []int) []int { seen := make(map[int]bool) result := []int{} for _, num := range slice { if !seen[num] { result = append(result, num) seen[num] = true } } return result } func (s *toolSliceUtil) UniqueString(slice []string) []string { seen := make(map[string]bool) result := []string{} for _, num := range slice { if !seen[num] { result = append(result, num) seen[num] = true } } return result } type SortField struct { Key string IsAsc bool } func (s *toolSliceUtil) SortByKey(slice []map[string]interface{}, fields []SortField) { // 調用 sort.SliceStable 函數對 slice 進行排序，并提供一個函數作為比較器。 sort.SliceStable(slice, func(i, j int) bool { for _, field := range fields { key := field.Key isAsc := field.IsAsc switch v1 := slice[i][key].(type) { case int: v2, _ := slice[j][key].(int) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } case int32: v2, _ := slice[j][key].(int32) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } case int64: v2, _ := slice[j][key].(int64) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } case float32: v2, _ := slice[j][key].(float32) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } case float64: v2, _ := slice[j][key].(float64) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } case string: v2, _ := slice[j][key].(string) if v1 != v2 { if isAsc { return v1 < v2 } else { return v1 > v2 } } default: fmt.Printf("unsupported type for key '%s': %s\n", key, reflect.TypeOf(v1)) return false } } return false }) } func compareJsonNumbers(a, b json.Number) bool { af, aErr := a.Float64() bf, bErr := b.Float64() if aErr != nil || bErr != nil { ai, aErr := a.Int64() bi, bErr := b.Int64() if aErr != nil || bErr != nil { fmt.Println("unsupported json.Number format") return false } return ai < bi } return af < bf } // StringToSliceInt 將字符串解析為Int切片類型 func (s *toolSliceUtil) StringToSliceInt(str string) []int { var slice []int err := json.Unmarshal([]byte(str), &slice) if err != nil { return []int{} } return slice } func (s *toolSliceUtil) StringToSliceStr(str string) []string { var slice []string err := json.Unmarshal([]byte(str), &slice) if err != nil { return []string{} } return slice } ~~~