mirror of
https://github.com/astaxie/beego.git
synced 2024-12-23 11:20:50 +00:00
171 lines
4.1 KiB
Go
171 lines
4.1 KiB
Go
// Copyright 2014 beego Author. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package utils
|
|
|
|
import (
|
|
"math/rand"
|
|
"time"
|
|
)
|
|
|
|
type reducetype func(interface{}) interface{}
|
|
type filtertype func(interface{}) bool
|
|
|
|
// InSlice checks given string in string slice or not.
|
|
func InSlice(v string, sl []string) bool {
|
|
for _, vv := range sl {
|
|
if vv == v {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// InSliceIface checks given interface in interface slice.
|
|
func InSliceIface(v interface{}, sl []interface{}) bool {
|
|
for _, vv := range sl {
|
|
if vv == v {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// SliceRandList generate an int slice from min to max.
|
|
func SliceRandList(min, max int) []int {
|
|
if max < min {
|
|
min, max = max, min
|
|
}
|
|
length := max - min + 1
|
|
t0 := time.Now()
|
|
rand.Seed(int64(t0.Nanosecond()))
|
|
list := rand.Perm(length)
|
|
for index := range list {
|
|
list[index] += min
|
|
}
|
|
return list
|
|
}
|
|
|
|
// SliceMerge merges interface slices to one slice.
|
|
func SliceMerge(slice1, slice2 []interface{}) (c []interface{}) {
|
|
c = append(slice1, slice2...)
|
|
return
|
|
}
|
|
|
|
// SliceReduce generates a new slice after parsing every value by reduce function
|
|
func SliceReduce(slice []interface{}, a reducetype) (dslice []interface{}) {
|
|
for _, v := range slice {
|
|
dslice = append(dslice, a(v))
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceRand returns random one from slice.
|
|
func SliceRand(a []interface{}) (b interface{}) {
|
|
randnum := rand.Intn(len(a))
|
|
b = a[randnum]
|
|
return
|
|
}
|
|
|
|
// SliceSum sums all values in int64 slice.
|
|
func SliceSum(intslice []int64) (sum int64) {
|
|
for _, v := range intslice {
|
|
sum += v
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceFilter generates a new slice after filter function.
|
|
func SliceFilter(slice []interface{}, a filtertype) (ftslice []interface{}) {
|
|
for _, v := range slice {
|
|
if a(v) {
|
|
ftslice = append(ftslice, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceDiff returns diff slice of slice1 - slice2.
|
|
func SliceDiff(slice1, slice2 []interface{}) (diffslice []interface{}) {
|
|
for _, v := range slice1 {
|
|
if !InSliceIface(v, slice2) {
|
|
diffslice = append(diffslice, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceIntersect returns slice that are present in all the slice1 and slice2.
|
|
func SliceIntersect(slice1, slice2 []interface{}) (diffslice []interface{}) {
|
|
for _, v := range slice1 {
|
|
if InSliceIface(v, slice2) {
|
|
diffslice = append(diffslice, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceChunk separates one slice to some sized slice.
|
|
func SliceChunk(slice []interface{}, size int) (chunkslice [][]interface{}) {
|
|
if size >= len(slice) {
|
|
chunkslice = append(chunkslice, slice)
|
|
return
|
|
}
|
|
end := size
|
|
for i := 0; i <= (len(slice) - size); i += size {
|
|
chunkslice = append(chunkslice, slice[i:end])
|
|
end += size
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceRange generates a new slice from begin to end with step duration of int64 number.
|
|
func SliceRange(start, end, step int64) (intslice []int64) {
|
|
for i := start; i <= end; i += step {
|
|
intslice = append(intslice, i)
|
|
}
|
|
return
|
|
}
|
|
|
|
// SlicePad prepends size number of val into slice.
|
|
func SlicePad(slice []interface{}, size int, val interface{}) []interface{} {
|
|
if size <= len(slice) {
|
|
return slice
|
|
}
|
|
for i := 0; i < (size - len(slice)); i++ {
|
|
slice = append(slice, val)
|
|
}
|
|
return slice
|
|
}
|
|
|
|
// SliceUnique cleans repeated values in slice.
|
|
func SliceUnique(slice []interface{}) (uniqueslice []interface{}) {
|
|
for _, v := range slice {
|
|
if !InSliceIface(v, uniqueslice) {
|
|
uniqueslice = append(uniqueslice, v)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// SliceShuffle shuffles a slice.
|
|
func SliceShuffle(slice []interface{}) []interface{} {
|
|
for i := 0; i < len(slice); i++ {
|
|
a := rand.Intn(len(slice))
|
|
b := rand.Intn(len(slice))
|
|
slice[a], slice[b] = slice[b], slice[a]
|
|
}
|
|
return slice
|
|
}
|