​

通过使用一些通用代码来节省时间，而无需单独实现它们。以下是一些开发中经常会用到的函数实现的列表。

1、检查数组中元素是否存在

Golang 没有预定义的函数来检查数组中元素的存在。以下代码片段为您完成相同的工作。

很简单，遍历一遍数组检查元素是否存在。

package main

import "fmt"

func main() {

    slice := []string{"apple", "grapes", "mango"}

    if Contains(slice, "mango") {
        fmt.Println("元素存在")
    } else {
        fmt.Println("元素不存在")
    }
}

func Contains(slice []string, element string) bool {
    for _, i := range slice {
        if i == element {
            return true
        }
    }
    return false
}

2、检查给定的时间是否在两个时间戳之间

给定两个时间戳，用于检查当前时间是否位于两者之间。 Golang 时间包提供了一个内置函数来检查它。我们使用了 .After() 和 .Before() 方法，如果两者都为真，那么我们可以承认当前时间在给定时间之间。

package main

import (
    "fmt"
    "time"
)

func main() {
    currentTime := time.Now()
    // 当前时间的18小时后
    rightTime := time.Now().Add(time.Hour * 18)
    // 当前时间的10小时之前
    leftTime := time.Now().Add(-time.Hour * 10)

    if IsBetweenTime(currentTime, leftTime, rightTime) {
        fmt.Println("当前时间在范围内")
    } else {
        fmt.Println("当前时间不在范围内")
    }
}

func IsBetweenTime(curTime, leftTime, rightTime time.Time) bool {
    if curTime.After(leftTime) && curTime.Before(rightTime) {
        return true
    }
    return false
}

3、查找特定时区的当前时间戳

首先使用 time.LoadLocation() 加载给定时区的位置，然后将其与 time.Now.In() 一起使用，以获取给定时区的当前时间。您可以将 timeZone 变量的值修改为所需的值。

package main

import (
    "fmt"
    "time"
)

func main() {
    timeZone := "Asia/Kolkata"
    currentTime := CurrentTimeByTimeZone(timeZone)
    fmt.Println("currentTime : ", currentTime)
    timeZone = "Asia/ShangHai"
    currentTime = CurrentTimeByTimeZone(timeZone)
    fmt.Println("currentTime : ", currentTime)
}

func CurrentTimeByTimeZone(timeZone string) time.Time {
    loc, _ := time.LoadLocation(timeZone)
    return time.Now().In(loc)
}

4、从数组中删除重复项

我们定义了另一个切片并通过检查新切片中是否已存在该值来分配第一个值。它返回没有重复的切片。

package main

import (
    "fmt"
)

func main() {
    fruits := []string{"Mango", "Grapes", "Kiwi", "Apple", "Grapes"}
    fmt.Println("删除重复项之前 : ", fruits)

    dulicatesRemovedArray := SliceUnique(fruits)
    fmt.Println("删除重复项之后 : ", dulicatesRemovedArray)
}

func SliceUnique(intSlice []string) []string {
    keys := make(map[string]bool)
    list := make([]string, 0)
    for _, entry := range intSlice {
        if _, value := keys[entry]; !value {
            keys[entry] = true
            list = append(list, entry)
        }
    }
    return list
}

5、随机打乱数组

要打乱数组中的元素，我们必须使用随机数然后交换元素。

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {

    array := []string{"India", "US", "Canada", "UK"}
    fmt.Println("Origin array : ", array)
    shuffleArr := Shuffle(array)
    fmt.Println("Shuffled array : ", shuffleArr)
}

func Shuffle(array []string) []string {
    // New 返回一个使用来自 src 的随机值的新 Rand 生成其他随机值
    random := rand.New(rand.NewSource(time.Now().UnixNano()))
    for i := len(array) - 1; i > 0; i-- {
        // Intn 以 int 形式返回半开区间 [0,n) 中的非负伪随机数。
        j := random.Intn(i + 1)
        array[i], array[j] = array[j], array[i]
    }
    return array
}

6、反转数组

将数组从中间（长度/ 2）分开，并在 pos 变量的帮助下交换两个跨边界的位置。即如果有长度为 6 的数组，则交换将按数组 [2] <-> 数组 [3]、数组 [1] <-> 数组 [4] 和数组 [0] <-> 数组 [5] 的顺序进行]。

package main

import (
    "fmt"
)

func main() {
    a := []int{1, 2, 3, 4, 5, 6, 7}
    reverseArray := ReverseSlice(a)
    fmt.Println("反转后 : ", reverseArray)
}

func ReverseSlice(a []int) []int {
    for i := len(a)/2 - 1; i >= 0; i-- {
        pos := len(a) - 1 - i
        a[i], a[pos] = a[pos], a[i]
    }
    return a
}

7、将切片转换为某个分隔符分隔的字符串

package main

import (
    "fmt"
    "strconv"
    "strings"
)

func main() {
    result := ConvertSliceToString("&", []int{10, 20, 30, 40})
    fmt.Println("Slice converted string : ", result)
}

func ConvertSliceToString(separator string, input []int) string {
    var output []string
    for _, i := range input {
        output = append(output, strconv.Itoa(i))
    }
    return strings.Join(output, separator)
}

8、将给定的字符串转换为snake_case

package main

import (
    "fmt"
    "regexp"
    "strings"
)

func main() {
    snakeCase := ConvertToSnakeCase("ILikeProgrammingINGo")
    fmt.Println("String in snake case : ", snakeCase)
}

func ConvertToSnakeCase(input string) string {
    var matchChars = regexp.MustCompile("(.)([A-Z][a-z]+)")
    var matchAlpha = regexp.MustCompile("([a-z0-9])([A-Z])")

    snake := matchChars.ReplaceAllString(input, "${1}_${2}")
    snake = matchAlpha.ReplaceAllString(snake, "${1}_${2}")
    return strings.ToLower(snake)
}