初心者が Golang を学ぶための N のヒント

1. 配列の初期化方法

var a [2]int	# 仅定义
var b = [2]int{
    
    1, 2} # 定义并初始化
c := [3]int{
    
    1, 2, 3} 
d := [...]int{
    
    1, 2, 3, 4} # 可以省略长度而采用 `...` 的方式， Go 会自动根据元素个数来计算长度
e := [2][4]int{
    
    [4]int{
    
    1, 2, 3, 4}, [4]int{
    
    5, 6, 7, 8}} # 定义并初始化二位数组
f := [2][4]int{
    
    {
    
    1, 2, 3, 4}, {
    
    5, 6, 7, 8}} # 上面的声明可以简化，直接忽略内部的类型

2. スライスの初期化方法

var a []int # 仅定义
var b = []int{
    
    1, 2} # 定义并初始化
c := []int{
    
    1, 2, 3}
d := c[:1] # 从已有Slice声明一个Slice，等价 d := c[0:1]，包含元素1， 2
e := c[1:] # 等价 e := [1:2], 包含元素2，3
f := [:] # 等价 f := [0:2], 包含元素1，2，3

3. マップの初期化方法

var a map[string]int # 声明key是字符串，值为int的map, 需要在使用之前使用make 初始化
b := make(map[string]int) # 声明并初始化
c := map[string]int{
    
    "a": 1, "b": 2} # 声明并初始化

4. セットコレクション効果の実現方法

# 定义一个类型为string的Set集合：
var set = map[string]struct{
    
    }{
    
    }

# 判断Set集合是否存在a:
if _, ok := set["a"]; ok {
    
    
    fmt.Println("set contains a")
}
# 结果：ok=false

# 先传入b，再判断Set集合是否存在b:
set["b"] = struct{
    
    }{
    
    }
if _, ok := set["b"]; ok {
    
    
    fmt.Println("set contains b")
}
# 结果：ok=true

# 遍历Set集合：
for s := range set {
    
    
	fmt.Println(s)
}

5. 文字列を分割する方法

str := "abc|def|ghi"

不带参数N的写法：
s1 := strings.Split(str, "|") 结果：[abc def ghi]

带参数N的写法，其中：
n>0：最多n个子串；最后一个子串将是未拆分的余数。
n==0：结果为零（零个子字符串）
n<0：所有子字符串
s2 := strings.SplitN(str, "|", 2) 结果：[abc def|ghi]
s3 := strings.SplitN(str, "|", 1) 结果：[abc|def|ghi]
s4 := strings.SplitN(str, "|", 0) 结果：[]
s5 := strings.SplitN(str, "|", -1) 结果：[abc def ghi] （该效果等同于不带参数N的写法）

6. 2 つの数値の最大値または最小値を取得する方法

func max(x, y int) int {
    
    
    if x > y {
    
    
        return x
    }
    return y
}

func min(x, y int) int {
    
    
    if x < y {
    
    
        return x
    }
    return y
}

7. 2 つの配列要素を交換する方法

arr[i], arr[j] = arr[j], arr[i]

8. 文字列を反転する方法

func reverse(s string) string {
    
    
    str := []rune(s)
    l := len(str)
    for i := 0; i < l/2; i++ {
    
    
        str[i], str[l-1-i] = str[l-1-i], str[i]
    }
    return string(str)
}

9. スライスの並べ替え方法

# TimePoint为自定义类型
type TimePoint []string
func (t TimePoint) Len() int           {
    
     return len(t) }
func (t TimePoint) Swap(i, j int)      {
    
     t[i], t[j] = t[j], t[i] }
func (t TimePoint) Less(i, j int) bool {
    
     return t[i] < t[j] }

func main() {
    
    
	timePoints := []string{
    
    "05:31", "22:08", "00:35"}
	sort.Sort(TimePoint(timePoints))
	fmt.Println(timePoints) // [00:35 05:31 22:08]
}

# 上方的[]string还是基础类型，那么如何对自定义类型排序，请往下看
## BikeStore为自定义类型，有一个字段amount表示自行车店拥有的自行车数量
type BikeStore struct {
    
    
    amount int
}

## 下方就是自行车店排序规则
type BikeSort []BikeStore

func (b BikeSort) Len() int {
    
    
    return len(b)
}

func (b BikeSort) Swap(i, j int) {
    
    
    b[i], b[j] = b[j], b[i]
}

func (b BikeSort) Less(i, j int) bool {
    
    
    return b[i].amount < b[j].amount
}

func main() {
    
    
    s1 := BikeSort{
    
    BikeStore{
    
    5}, BikeStore{
    
    1}, BikeStore{
    
    3}}
    sort.Sort(s1) 
    # 结果： [{
    
    1} {
    
    3} {
    
    5}]
}