golang中的一些實用功能

​

通過使用一些通用代碼來節省時間，而無需單獨實作它們。以下是一些開發中經常會用到的函數實作的清單。

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、反轉數組

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)
}