go常用的10个通用函数

以下是⼀些平时开发常⽤的通⽤函数，赶紧收藏起来，⼀定可以⽤得上。1.检查 slice 中某元素是否存在。

Go 语⾔没有预定义的函数⽤来检测 slice 中某元素是否存在，下⾯的代码可以帮你实现。

import \"fmt\"

func main() {

// create an array of strings

slice := []string{\"apple\

// You can check by changing element to \"orange\" if Contains(slice, \"mango\") {

fmt.Println(\"Slice contains element\") } else {

fmt.Println(\"Slice doesn't contain element\") }}

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

return false}

output:

Slice contains element

循环遍历 slice 每个元素，如果能匹配上说明存在，返回 true；否则不存在，返回 false。2.检查给定的时间是否处于某⼀时间区间内。

func main() {

currentTime := time.Now()

// Time after 18 hours of currentTime

futureTime := time.Now().Add(time.Hour * 18) // Time after 10 hours of currentTime

intermediateTime := time.Now().Add(time.Hour * 10)

if intermediateTime.After(currentTime) && intermediateTime.Before(futureTime) { fmt.Println(\"intermediateTime is between currentTime and futureTime\") } else {

fmt.Println(\"intermediateTime is not inbetween currentTime and futureTime\") }}

output:

intermediateTime is between currentTime and futureTime

给定两个时间戳，⽤于检查当前时间是否位于两者之间。Go 标准库的 time 包提供了相应的内置函数 After() 和 Before()，如果两者都返回true，那么就可以认为当前时间在给定时间之间。3.计算特定时区的当前时间戳。

import ( \"time\" \"fmt\")

func main() {

timeZone := \"Asia/Kolkata\" // timezone value loc, _ := time.LoadLocation(timeZone) currentTime = time.Now().In(loc)

fmt.Println(\"currentTime : \}

output:

// for timezone = \"Asia/Kolkata\"

currentTime : 2022-02-09 10:42:39.1079505 +0530 IST// for timezone = \"Asia/Shanghai\"

currentTime : 2022-02-09 13:14:33.986953939 +0800 CST

⾸先使⽤ time.LoadLocation() 加载给定时区，然后将其与 time.Now.In() ⼀起使⽤，以获取给定时区的当前时间。可以将变量 timeZone 的值修改成我们想要的时区。

4.将较⼩的数除以较⼤的数

如果将较⼩的整数除以较⼤的整数，则结果为 0，可以使⽤下⾯的⽅案保留⼩数。

import \"fmt\"

func main() { smallerNo := 5 largerNo := 25

result := float32(smallerNo) / float32(largerNo) fmt.Println(\"result : \}

output:result : 0.2

将两个数字都转换为浮点数，然后将它们相除，结果将保留⼩数部分。5.去重

通过下⾯的⽅案可以删除切⽚中重复项。

import \"fmt\"

func main() {

// define array of strings

fruits := []string{\"Mango\ fmt.Println(\"Array before removing duplicates : \ // Array after duplicates removal

dulicatesRemovedArray := RemoveDuplicatesFromSlice(fruits)

fmt.Println(\"Array after removing duplicates : \}

func RemoveDuplicatesFromSlice(intSlice []string) []string { keys := make(map[string]bool) list := []string{}

for _, entry := range intSlice {

if _, value := keys[entry]; !value { keys[entry] = true

list = append(list, entry) } }

return list}

output:

Array before removing duplicates : [Mango Grapes Kiwi Apple Grapes]Array after removing duplicates : [Mango Grapes Kiwi Apple]

我们定义了另⼀个切⽚，循环遍历原切⽚，如果元素在新切⽚中已经存在就忽略不处理，并返回元素不会重复的切⽚。6.随机打乱

Go 语⾔没有相关的内置函数，可以通过下⾯代码实现。

import \"fmt\"

func main() { // shuffle array

array := []string{\"India\ Shuffle(array)}

func Shuffle(array []string) {

// seed random for changing order of elements

random := rand.New(rand.NewSource(time.Now().UnixNano())) for i := len(array) - 1; i > 0; i-- { j := random.Intn(i + 1)

array[i], array[j] = array[j], array[i] }

fmt.Println(\"Shuffled array : \}

output:

Shuffled array : [UK India Canada US]

想要打乱元素，我们必须引⼊随机数，然后再交换元素。7.反转

可以通过下⾯函数来反转切⽚。

import \"fmt\"

func main() {

a := []int{1, 2, 3, 4, 5, 6} // input int array reverseArray := ReverseSlice(a)

fmt.Println(\"Reverted array : \}

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}

output:

Reverted array : [6 5 4 3 2 1]

8.元素求和

import \"fmt\"

func main() {

s := []int{10, 20, 30} sum := sumSlice(s)

fmt.Println(\"Sum of slice elements : \}

func sumSlice(array []int) int { sum := 0

for _, item := range array { sum += item }

return sum}

output:

Sum of slice elements : 60

通过循环遍历 slice 实现求和。9.将 slice 转换为逗号分隔的字符串

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

func main() {

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

func ConvertSliceToString(input []int) string { var output []string

for _, i := range input {

output = append(output, strconv.Itoa(i)) }

return strings.Join(output, \}

output:

Slice converted string : 10,20,30,40

10.将字符串以下划线分割

下⾯的代码会将给定的字符串以下划线分割。

import ( \"fmt\" \"strings\"

\"regexp\")

func main() {

snakeCase := ConvertToSnakeCase(\"ILikeProgrammingINGo123\") fmt.Println(\"String in snake case : \}

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

output:

String in snake case : i_like_programming_in_go123

作者：Nidhi D