共计 3485 个字符，预计需要花费 9 分钟才能阅读完成。
0.1、索引
https://waterflow.link/articles/1663921524839
通过应用一些通用代码来节省时间，而无需独自实现它们。以下是一些开发中常常会用到的函数实现的列表。
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)
}
正文完
