From 3c78cdcc34bb1d44f8a7b7b117aff844401b1866 Mon Sep 17 00:00:00 2001
From: lijianbin <513837235@.qq.com>
Date: Thu, 10 Nov 2022 10:11:42 +0800
Subject: [PATCH] =?UTF-8?q?=E5=A2=9E=E5=8A=A0=E6=95=B0=E5=AD=97=E5=9E=8B?=
 =?UTF-8?q?=E5=AD=97=E7=AC=A6=E5=88=87=E7=89=87=E6=8E=92=E5=BA=8F=E5=87=BD?=
 =?UTF-8?q?=E6=95=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 slice.go      | 153 +++++++++++++++++++++++++++++---------------------
 slice_test.go |   8 +++
 2 files changed, 98 insertions(+), 63 deletions(-)

diff --git a/slice.go b/slice.go
index 97d3bf8..d9191c5 100644
--- a/slice.go
+++ b/slice.go
@@ -4,85 +4,112 @@
 package helper
 
 import (
-	"errors"
-	"fmt"
+    "errors"
+    "fmt"
+    "sort"
 )
 
 // 求差集
 func Diff(slice1, slice2 []string) []string {
-	m := make(map[string]int)
-	nn := make([]string, 0)
-	inter := Intersect(slice1, slice2)
-	for _, v := range inter {
-		m[v]++
-	}
+    m := make(map[string]int)
+    nn := make([]string, 0)
+    inter := Intersect(slice1, slice2)
+    for _, v := range inter {
+        m[v]++
+    }
 
-	for _, value := range slice1 {
-		times, _ := m[value]
-		if times == 0 {
-			nn = append(nn, value)
-		}
-	}
-	return nn
+    for _, value := range slice1 {
+        times, _ := m[value]
+        if times == 0 {
+            nn = append(nn, value)
+        }
+    }
+    return nn
 }
 
 // 求交集
 func Intersect(slice1, slice2 []string) []string {
-	m := make(map[string]int)
-	nn := make([]string, 0)
-	for _, v := range slice1 {
-		m[v]++
-	}
+    m := make(map[string]int)
+    nn := make([]string, 0)
+    for _, v := range slice1 {
+        m[v]++
+    }
 
-	for _, v := range slice2 {
-		times, _ := m[v]
-		if times == 1 {
-			nn = append(nn, v)
-		}
-	}
-	return nn
+    for _, v := range slice2 {
+        times, _ := m[v]
+        if times == 1 {
+            nn = append(nn, v)
+        }
+    }
+    return nn
 }
 
 // 求并集
 func Union(slice1, slice2 []string) []string {
-	m := make(map[string]int)
-	for _, v := range slice1 {
-		m[v]++
-	}
+    m := make(map[string]int)
+    for _, v := range slice1 {
+        m[v]++
+    }
 
-	for _, v := range slice2 {
-		times, _ := m[v]
-		if times == 0 {
-			slice1 = append(slice1, v)
-		}
-	}
-	return slice1
+    for _, v := range slice2 {
+        times, _ := m[v]
+        if times == 0 {
+            slice1 = append(slice1, v)
+        }
+    }
+    return slice1
 }
 
 func Unique(originals interface{}) (interface{}, error) {
-	temp := map[string]struct{}{}
-	switch slice := originals.(type) {
-	case []string:
-		result := make([]string, 0, len(originals.([]string)))
-		for _, item := range slice {
-			key := fmt.Sprint(item)
-			if _, ok := temp[key]; !ok {
-				temp[key] = struct{}{}
-				result = append(result, item)
-			}
-		}
-		return result, nil
-	case []int64:
-		result := make([]int64, 0, len(originals.([]int64)))
-		for _, item := range slice {
-			key := fmt.Sprint(item)
-			if _, ok := temp[key]; !ok {
-				temp[key] = struct{}{}
-				result = append(result, item)
-			}
-		}
-		return result, nil
-	default:
-		return nil, errors.New(fmt.Sprintf("Unknown type: %T", slice))
-	}
+    temp := map[string]struct{}{}
+    switch slice := originals.(type) {
+    case []string:
+        result := make([]string, 0, len(originals.([]string)))
+        for _, item := range slice {
+            key := fmt.Sprint(item)
+            if _, ok := temp[key]; !ok {
+                temp[key] = struct{}{}
+                result = append(result, item)
+            }
+        }
+        return result, nil
+    case []int64:
+        result := make([]int64, 0, len(originals.([]int64)))
+        for _, item := range slice {
+            key := fmt.Sprint(item)
+            if _, ok := temp[key]; !ok {
+                temp[key] = struct{}{}
+                result = append(result, item)
+            }
+        }
+        return result, nil
+    default:
+        return nil, errors.New(fmt.Sprintf("Unknown type: %T", slice))
+    }
+}
+
+// 将切片字符串(数字型)排序
+func StringSliceSort(str []string, sort_type string) ([]string, error) {
+    int_arr := []int{}
+    string_arr := []string{}
+
+    if len(str) < 1 {
+        return []string{}, nil
+    }
+
+    for _, val := range str {
+        int_arr = append(int_arr, ToInt(val))
+    }
+
+    if sort_type == "desc" {
+        sort.Sort(sort.Reverse(sort.IntSlice(int_arr)))
+    }else{
+        sort.Ints(int_arr)
+    }
+
+    for _, val_int := range int_arr {
+        string_arr = append(string_arr, ToStr(val_int))
+    }
+
+    return string_arr, nil
 }
diff --git a/slice_test.go b/slice_test.go
index 118a6bc..27f2698 100644
--- a/slice_test.go
+++ b/slice_test.go
@@ -31,3 +31,11 @@ func Test_Unique(t *testing.T) {
 	ret, err := Unique(str)
 	fmt.Println(ret, err)
 }
+
+func Test_StringSliceSort(t *testing.T) {
+	var str = []string{"10", "2", "5"}
+	ret, err := StringSliceSort(str,"asc")
+	fmt.Println(ret, err)
+	ret2, err := StringSliceSort(str,"desc")
+	fmt.Println(ret2, err)
+}