Go - 【字符串，数组，哈希表】常用操作

一. 字符串

1. 字符串长度：

s := "hello"
l := len(s)
fmt.Println(l) // 输出 5
1
2
3

2. 遍历字符串：

s := "hello"
for i, c := range s {
    fmt.Printf("%d:%c ", i, c)
}
// 输出：0:h 1:e 2:l 3:l 4:o

for i := 0; i < len(s); i ++ {
	fmt.Printf("%s ", s[i])
}
1
2
3
4
5
6
7
8
9

3. 字符串比较：

s1 := "hello"
s2 := "world"
if s1 == s2 {
    fmt.Println("equal")
} else {
    fmt.Println("not equal")
}
// 输出 not equal
1
2
3
4
5
6
7
8

在这里插入代码片
1

4. 拼接字符串：

s1 := "hello"
s2 := "world"
s3 := s1 + " " + s2
fmt.Println(s3) // 输出 hello world
1
2
3
4

5. 字符串切割：

s := "a,b,c,d"
parts := strings.Split(s, ",")
for _, p := range parts {
    fmt.Println(p)
}
// 输出：
// a
// b
// c
// d
1
2
3
4
5
6
7
8
9
10

6. 字符串替换：

s := "hello world"
s = strings.Replace(s, "world", "go", -1)
fmt.Println(s) // 输出 hello go
1
2
3

7. 字符串查找：

s := "hello world"
idx := strings.Index(s, "world")
fmt.Println(idx) // 输出 6
1
2
3

8. 字符串截取：

s := "hello world"
substr := s[0:5]
fmt.Println(substr) // 输出 hello
1
2
3

9. 字符串转换:

s := "123"
n, err := strconv.Atoi(s)
if err != nil {
    fmt.Println(err)
} else {
    fmt.Printf("n=%d, type=%T\n", n, n)
    // 输出 n=123, type=int
}

s = strconv.Itoa(n)
fmt.Printf("s=%s, type=%T\n", s, s)
// 输出 s=123, type=string
1
2
3
4
5
6
7
8
9
10
11
12

10. 字符串格式化：

name := "Tom"
age := 18
s := fmt.Sprintf("name=%s, age=%d", name, age)
fmt.Println(s) // 输出 name=Tom, age=18
1
2
3
4

11. 判断字符时候在字符串当中

import "strings"

func contains(s string, c byte) bool {
    return strings.ContainsRune(s, rune(c))
}

func index(s string, c byte) int {
    return strings.IndexByte(s, c)
}

// contains函数使用了strings包的ContainsRune函数，该函数可以判断一个字符是否在字符串中。
// index函数使用了strings包的IndexByte函数，该函数可以返回字符在字符串中的位置。
1
2
3
4
5
6
7
8
9
10
11
12

12. 排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    strSlice := []string{"abc", "aaa", "bce", "bcd"}
    
    // 正序排序
    sort.Strings(strSlice)
    fmt.Println("正序：", strSlice)
    
    // 反序排序
    sort.Sort(sort.Reverse(sort.StringSlice(strSlice)))
    fmt.Println("反序：", strSlice)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二. 数组 - 列表

1. 创建列表：

myList := []int{1, 2, 3, 4, 5}
1

2. 获取列表长度：

length := len(myList)  // 等于 5
1

3. 访问列表元素：

firstElement := myList[0]     // 等于 1
lastElement := myList[len(myList)-1]  // 等于 5
sublist := myList[1:3]         // 等于 [2,3]
1
2
3

4. 修改列表元素：

myList[0] = 10     // 现在 myList 等于 [10, 2, 3, 4, 5]
1

5. 添加元素：

myList = append(myList, 6)       // 现在 myList 等于 [10, 2, 3, 4, 5, 6]
myList = append(myList, 7, 8)    // 现在 myList 等于 [10, 2, 3, 4, 5, 6, 7, 8]
1
2

6. 删除元素：

myList = append(myList[:0], myList[1:]...)  // 现在 myList 等于 [2, 3, 4, 5, 6, 7, 8]
myList = append(myList[:2], myList[3:]...) // 从列表中删除第 3 个元素，现在 myList 等于 [2, 3, 5, 6, 7, 8]
1
2

7. 检查元素是否在列表中：

for _, element := range myList {
    if element == 3 {
        fmt.Println("3 在列表中")
    }
}
1
2
3
4
5

8. 列表排序：

sort.Ints(myList)          // 现在 myList 等于 [2, 3, 5, 6, 7, 8]
sort.Sort(sort.Reverse(sort.IntSlice(myList)))   // 现在 myList 等于 [8, 7, 6, 5, 3, 2]
1
2

9. 合并列表：

newList := append(myList, []int{9, 10}...)  // 等于 [2, 3, 5, 6, 7, 8, 9, 10]
1

10. 列表复制：

copyOfList := make([]int, len(myList))
copy(copyOfList, myList)  // 等于 [2, 3, 5, 6, 7, 8]
1
2

三. 哈希表 - 字典

1. 创建哈希表：

myMap := make(map[string]int)
1

2. 在哈希表中设置键值：

myMap["apple"] = 1
myMap["banana"] = 2
myMap["orange"] = 3
1
2
3

3. 从哈希表中获取键值：

value := myMap["apple"]    // 等于 1
1

Go的map数据类型没有类似Python中的get()方法，但可以通过访问哈希表中的值及其存在状态的方式来实现相似的功能。
我们可以使用以下代码来获取键为 “apple” 的值：

value, exists := myMap["apple"]
1

为了实现类似Python中的get()方法的功能，我们可以将代码向下修改：

func getValue(myMap map[string]int, key string, defaultValue int) int {
    if value, exists := myMap[key]; exists {
        return value
    }
    return defaultValue
}

value := getValue(myMap, "apple", 0)
1
2
3
4
5
6
7
8

4. 检查键是否在哈希表中：

if _, ok := myMap["apple"]; ok {
    fmt.Println("apple 在哈希表中")
}
1
2
3

5. 删除键值：

delete(myMap, "apple")      // 从哈希表中删除键值 "apple"
1

6. 获取哈希表长度：

length := len(myMap)
1

7. 迭代哈希表中的键值对：

for key, value := range myMap {
    fmt.Printf("key: %s, value: %d\n", key, value)
}
1
2
3

8. 判断哈希表是否为空：

if len(myMap) == 0 {
    fmt.Println("哈希表为空")
}
1
2
3

9. 创建和初始化哈希表：

myMap := map[string]int{
    "apple": 1,
    "banana": 2,
    "orange": 3,
}
1
2
3
4
5

10. 复制哈希表：

copyOfMap := make(map[string]int)
for key, value := range myMap {
    copyOfMap[key] = value
}
1
2
3
4

11. 判断键是否存在哈希表中

func main() {
    dict := map[string]int{
        "foo": 1,
        "bar": 2,
        "baz": 3,
    }

    // 判断 "foo" 是否在字典中
    if _, ok := dict["foo"]; ok {
        fmt.Println("found foo")
    } else {
        fmt.Println("not found foo")
    }

    // 判断 "qux" 是否在字典中
    if _, ok := dict["qux"]; ok {
        fmt.Println("found qux")
    } else {
        fmt.Println("not found qux")
    }
}

// 如果dict字典中存在"foo"键，则输出"found foo"，否则输出"not found foo"。
// 同理，如果dict字典中不存在"qux"键，则输出"not found qux"。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

12. 字典排序

使用 sort.Slice 函数对 map 的键或值进行排序

package main

import (
    "fmt"
    "sort"
)

func main() {
    dict := map[string]int{
        "foo": 1,
        "bar": 2,
        "baz": 3,
    }

    keys := make([]string, 0, len(dict))
    for k := range dict {
        keys = append(keys, k)
    }

    sort.Slice(keys, func(i, j int) bool {
        return keys[i] < keys[j]
    })

    for _, k := range keys {
        fmt.Printf("%v: %v\n", k, dict[k])
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

先创建一个字符串类型的列表 keys，用于存储 map 中的键。然后，使用 range 遍历 dict，将其中的键添加到 keys 列表中。接着，使用 sort.Slice 函数对 keys 列表进行排序，排序函数使用匿名函数的方式进行定义，在该函数中，使用 < 符号来比较两个键的大小。最后，使用遍历的方式输出排序后的键和相应的值。

以上就是关于Go - 【字符串，数组，哈希表】常用操作的基本使用，希望对你有所帮助！