/
slice.go
140 lines (118 loc) · 2.66 KB
/
slice.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
// Package arrutil provides some util functions for array, slice
package arrutil
import (
"reflect"
"strconv"
"strings"
"github.com/gookit/goutil/mathutil"
)
// Reverse string slice [site user info 0] -> [0 info user site]
func Reverse(ss []string) {
ln := len(ss)
for i := 0; i < ln/2; i++ {
li := ln - i - 1
// fmt.Println(i, "<=>", li)
ss[i], ss[li] = ss[li], ss[i]
}
}
// StringsRemove an value form an string slice
func StringsRemove(ss []string, s string) []string {
var ns []string
for _, v := range ss {
if v != s {
ns = append(ns, v)
}
}
return ns
}
// StringsToInts string slice to int slice
func StringsToInts(ss []string) (ints []int, err error) {
for _, str := range ss {
iVal, err := strconv.Atoi(str)
if err != nil {
return []int{}, err
}
ints = append(ints, iVal)
}
return
}
// TrimStrings trim string slice item.
func TrimStrings(ss []string, cutSet ...string) (ns []string) {
hasCutSet := len(cutSet) > 0 && cutSet[0] != ""
for _, str := range ss {
if hasCutSet {
ns = append(ns, strings.Trim(str, cutSet[0]))
} else {
ns = append(ns, strings.TrimSpace(str))
}
}
return
}
// IntsHas check the []int contains the given value
func IntsHas(ints []int, val int) bool {
for _, ele := range ints {
if ele == val {
return true
}
}
return false
}
// Int64sHas check the []int64 contains the given value
func Int64sHas(ints []int64, val int64) bool {
for _, ele := range ints {
if ele == val {
return true
}
}
return false
}
// StringsHas check the []string contains the given element
func StringsHas(ss []string, val string) bool {
for _, ele := range ss {
if ele == val {
return true
}
}
return false
}
// Contains array(strings, ints, uints) should be contains the given value(int(X),string).
func Contains(arr, val interface{}) bool {
if val == nil || arr == nil {
return false
}
// if is string value
if strVal, ok := val.(string); ok {
if ss, ok := arr.([]string); ok {
return StringsHas(ss, strVal)
}
return false
}
// as int value
intVal, err := mathutil.Int64(val)
if err != nil {
return false
}
if int64s, ok := toInt64Slice(arr); ok {
return Int64sHas(int64s, intVal)
}
return false
}
// NotContains array(strings, ints, uints) should be not contains the given value.
func NotContains(arr, val interface{}) bool {
return false == Contains(arr, val)
}
func toInt64Slice(arr interface{}) (ret []int64, ok bool) {
rv := reflect.ValueOf(arr)
if rv.Kind() != reflect.Slice {
return
}
for i := 0; i < rv.Len(); i++ {
i64, err := mathutil.Int64(rv.Index(i).Interface())
if err != nil {
return []int64{}, false
}
ret = append(ret, i64)
}
ok = true
return
}