笔试中常用的Golang库

输入输出库

fmt

fmt.Scan()

fmt.Scan()多用来获取已知长度、已知数量的变量输入。从os.Stdin中获取数据。

它将碰到第一个空格或换行符之前的内容赋值给变量。如果 Scan()中有多个变量，变量值用空格或换行符分割。所以换行和空格是不能存储到变量内的。

func main() {
	var t int
	fmt.Scan(&t)
	for i := 0; i < t; i++ {
		var n int
		fmt.Scan(&n)
		sum := 0
		for j := 0; j < n; j++ {
			var a int
			fmt.Scan(&a)
			sum += a
		}
		fmt.Println(sum)
	}
}

fmt.Scanln

fmt.Scanln()和fmt.Scan()的用法类似，但唯一区别是当读取多个变量当时候，遇到换行符Scanln()会直接结束，未读到输入值的变量为零值；Scan()会等待，直到输入的值满足参数的个数后再遇到换行符才会结束。

通常情况下使用Scan()就够了。

bufio

bufio.NewScanner

bufio.NewScanner常用于不确定要输入多少数据的情况。例如：

func main() {
    // 从标准输入输出 os.Stdin 中读取数据
	inputBuf := bufio.NewScanner(os.Stdin)
    // inputBuf.Scan() 用来循环读取下一行 直到出现io.EOF
	for inputBuf.Scan() {
		data := inputBuf.Text()
		tmpStrs := strings.Split(data, ",")
		sort.Slice(tmpStrs, func(i, j int) bool {
			if strings.Compare(tmpStrs[i], tmpStrs[j]) < 0 {
				return true
			} else {
				return false
			}
		})
		for i, s := range tmpStrs {
			if i != len(tmpStrs)-1 {
				fmt.Printf("%s,", s)
			} else {
				fmt.Printf("%s\n", s)
			}
		}
	}
}

排序库 Sort

对 float64 切片进行排序：sort.Float64s(s)

import (
	"fmt"
	"sort"
)

func main() {
	s := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // unsorted
	sort.Float64s(s)
	fmt.Println(s)
    // [-3.8 -1.3 0.7 2.6 5.2]
}

对 int 切片进行排序：sort.Ints(s)

import (
	"fmt"
	"sort"
)

func main() {
	s := []int{5, 2, 6, 3, 1, 4} // unsorted
	sort.Ints(s)
	fmt.Println(s)
    // [1 2 3 4 5 6]
}

对 slice 使用自定义排序顺序：sort.Slice(x any, less func(i, j int) bool)

import (
	"fmt"
	"sort"
)

func main() {
	people := []struct {
		Name string
		Age  int
	}{
		{"Gopher", 7},
		{"Alice", 55},
		{"Vera", 24},
		{"Bob", 75},
	}

	sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
	fmt.Println("By age:", people)
    // By age: [{Gopher 7} {Vera 24} {Alice 55} {Bob 75}]
}

字符串处理

strings

Split ¶

根据指定字符进行分割，需要注意字符串首尾：func Split(s, sep string) []string

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Printf("%q\n", strings.Split("a,b,c", ","))
	fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
	fmt.Printf("%q\n", strings.Split(" xyz ", ""))
    fmt.Printf("%q\n", strings.Split(" xyz ", " "))
	fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))
}

// Output:
// ["a" "b" "c"]
// ["" "man " "plan " "canal panama"]
// [" " "x" "y" "z" " "]
// ["" "xyz" ""]
// [""]

Index

找到子串的起始位置，如果没有返回 -1: func Index(s, substr string) int

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(strings.Index("chicken", "ken"))
	fmt.Println(strings.Index("chicken", "dmr"))
}

// Output:
// 4
// -1

strconv

Atoi

字符串类型的数字转化为 int 类型：func Atoi(s string) (int, error)

package main

import (
	"fmt"
	"strconv"
)

func main() {
	v := "10"
	if s, err := strconv.Atoi(v); err == nil {
		fmt.Printf("%T, %v", s, s)
	}

}

// Output:

// int, 10

Itoa

将 int 类型转为字符串：func Itoa(i int) string

package main

import (
	"fmt"
	"strconv"
)

func main() {
	i := 10
	s := strconv.Itoa(i)
	fmt.Printf("%T, %v\n", s, s)

}

// Output:

// string, 10

ParseInt

灵活的将字符串转为正整数：func ParseInt(s string, base int, bitSize int) (i int64, err error)
三个参数的含义依次是：
- 要转换的字符串
- 转换为几进制，可以是0，2 ~ 36，我们一般用10进制
- 具体的int类型，可以是 0， 8， 16，32，和64，代表 int，int8，int16，int32和int64，一般用 0 转换为int类型

package main

import (
	"fmt"
	"strconv"
)

func main() {
	v32 := "-354634382"
	if s, err := strconv.ParseInt(v32, 10, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v32, 16, 32); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

	v64 := "-3546343826724305832"
	if s, err := strconv.ParseInt(v64, 10, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}
	if s, err := strconv.ParseInt(v64, 16, 64); err == nil {
		fmt.Printf("%T, %v\n", s, s)
	}

}

// int64, -354634382
// int64, -3546343826724305832

ParseFloat

用于将字符串转化为 float 类型：func ParseFloat(s string, bitSize int) (float64, error)
参数：
- s：将要转化的字符串
- bitSize：可选 32 或 64 代表转化为 float32 还是 float64

FormatFloat

用于将 float 转化为字符串类型：func FormatFloat(f float64, fmt byte, prec, bitSize int) string
参数说明：
- f：所需要转化的浮点数
- fmt：格式，有 ‘b’,’e’,‘E’,‘f’,‘g’,‘G’,‘x’,‘X’ 这些选项，一般使用 ‘f’ 表示没有指数
- prec：表示精度，小数点后保留几位
- bitSize：有 32 和 64 两种选项，表示 float32 或 float64 类型

package main

import (
    "fmt"
    "strconv"
)

func main() {
    f := 3.1415926
    s := strconv.FormatiFloat(f, 'f', 2, 64)
    fmt.Println(s) 
}

// 3.14

FormatInt

将 Int 为字符串类型：func FormatInt(i int64, base int) string
参数说明：
- i：表示要转化的浮点数
- base：进制，可选 2到36

package main

import (
	"fmt"
	"strconv"
)

func main() {
	v := int64(-42)

	s10 := strconv.FormatInt(v, 10)
	fmt.Printf("%T, %v\n", s10, s10)

	s16 := strconv.FormatInt(v, 16)
	fmt.Printf("%T, %v\n", s16, s16)

}

// Output:

// string, -42
// string, -2a