1.检查数组中是否存在元素
golang没有内置的检测元素存在的函数。遍历切片并将过滤元素与数组匹配，如果它存在于数组中，它将返回否则为 false。
import "fmt"
func main() {
// create an array of strings
slice := []string{"apple", "orange", "mango"}
// 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 element2.检查给定时间是否属于两个时间戳之间
使用下面的函数检查给定的时间是否属于两个时间戳之间。
import (
"time"
"fmt"
)
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 in between currentTime and futureTime")
}
}
output:
intermediateTime is between currentTime and futureTime给定两个时间戳，用于检查当前时间是否位于两者之间。Golang 时间包提供了一个内置的功能来检查它。我们用过After Before方法如果两者都为真，那么当前时间在给定时间之间。
3. 查找特定时区的当前时间戳
import (
"time"
"fmt"
)
func main() {
timeZone := "Asia/Shanghai"
location, _ := time.LoadLocation(timeZone)
kKLocation, _ := time.LoadLocation("Asia/Kolkata")
fmt.Println(time.Now())
fmt.Println(time.Now().In(location))
fmt.Println(time.Now().In(kKLocation)) // "Asia/Kolkata" 加尔各答 印度著名港口
}
output:
2022-08-27 09:44:40.674908 +0800 CST m=+0.001288835
2022-08-27 09:44:40.675057 +0800 CST
2022-08-27 07:14:40.675063 +0530 IST
4. 用一个较小的数字除以一个较大的数字
如果将一个较小的整数除以一个较大的整数，结果是0，可以使用下面的备选方案作为解决方案。
import "fmt"
func main() {
smallerNo := 5
largerNo := 25
result := float32(smallerNo) / float32(largerNo)
fmt.Println("result : ", result)
}
output:
result : 0.25. 从数组中删除重复项
新定义了一个分片，并通过检查该值是否已经存在于新分片中来分配，返回没有重复的分片。
import "fmt"
func main() {
// define array of strings
fruits := []string{"Mango", "Grapes", "Kiwi", "Apple", "Grapes"}
fmt.Println("Array before removing duplicates : ", fruits)
// Array after duplicates removal
dulicatesRemovedArray := RemoveDuplicatesFromSlice(fruits)
fmt.Println("Array after removing duplicates : ", dulicatesRemovedArray)
}
func RemoveDuplicatesFromSlice(intSlice []string) []string {
keys := make(map[string]struct{})
list := []string{}
for _, entry := range intSlice {
if _, ok := keys[entry]; !ok {
keys[entry] = struct{}{}
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. 如何对数组进行洗牌
Golang 没有一个内置的洗牌数组元素的功能，找到下面的代码片段来执行洗牌。
import "fmt"
func main() {
// shuffle array
array := []string{"India", "US", "Canada", "UK"}
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 : ", array)
}
output:
Shuffled array : [US India Canada UK]要在数组中洗牌元素，我们必须使用随机的，然后交换元素。
7. 反转一个数组
import "fmt"
func main() {
a := []int{1, 2, 3, 4, 5, 6} // input int array
reverseArray := ReverseSlice(a)
fmt.Println("Reverted array : ", reverseArray) // print output
}
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]从中间除数组(长度/2) ，并在 pos 变量的帮助下跨越边界线交换两个位置。也就是说，如果数组的长度为6，那么交换将按照array[2] <-> array [3]、array[1] <-> array [4]和array[0] <-> array [5]的顺序进行。
8. 将一个切片转换为逗号分隔的字符串
import (
"fmt"
"strings"
"strconv"
)
func main() {
result := ConvertSliceToString([]int{10, 20, 30, 40})
fmt.Println("Slice converted string : ", result)
}
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给定一个切片作为输入，循环它并将其添加到字符串数组中，然后用逗号(,) strings.Join将生成的字符串数组连接起来。
9. 将给定的字符串转换为蛇形字符串(这个很有用)
下面的代码片段将把给定的字符串转换为蛇形格式。然而，它可以在lib库的帮助下完成，也可以在不使用lib库的情况下完成。
import (
"fmt"
"strings"
"regexp"
)
func main() {
snakeCase := ConvertToSnakeCase("ILikeProgrammingINGo123")
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)
}
output:
String in snake case : i_like_programming_in_go123var matchChars = regexp.MustCompile("(.)([A-Z][a-z]+)") // 匹配 ${1}=(前面任意字符) ${2}=(大写+小写...) 分割
var matchAlpha = regexp.MustCompile("([a-z0-9])([A-Z])") // 匹配 ${1}=(数字或者小写) ${2}=(大写) 分割
使用字母、数字和特殊字符编译正则表达式，然后用已编译的正则表达式替换给定的字符串以下划线(_),它将在所需位置添加 _。
10. 小结
9个工具日常编程中应该是比较常用的，建议收藏。