【golang】建议收藏的golang瑞士军刀-9个工具方法

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 element

2.检查给定时间是否属于两个时间戳之间

使用下面的函数检查给定的时间是否属于两个时间戳之间。

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.2

5. 从数组中删除重复项

新定义了一个分片，并通过检查该值是否已经存在于新分片中来分配，返回没有重复的分片。

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_go123

var matchChars = regexp.MustCompile("(.)([A-Z][a-z]+)")   // 匹配 ${1}=(前面任意字符) ${2}=(大写+小写...) 分割
var matchAlpha = regexp.MustCompile("([a-z0-9])([A-Z])")  // 匹配 ${1}=(数字或者小写) ${2}=(大写) 分割

使用字母、数字和特殊字符编译正则表达式，然后用已编译的正则表达式替换给定的字符串以下划线(_),它将在所需位置添加 _。

10. 小结

9个工具日常编程中应该是比较常用的，建议收藏。