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

一. 字符串

1. 字符串长度：

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

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[c])

3. 字符串比较：

s1 := "hello"
s2 := "world"
if s1 == s2 {
    fmt.Println("equal")
} else {
    fmt.Println("not equal")
}
// 输出 not equal

在这里插入代码片

4. 拼接字符串：

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

5. 字符串切割：

s := "a,b,c,d"
parts := strings.Split(s, ",")
for _, p := range parts {
    fmt.Println(p)
}
// 输出：
// a
// b
// c
// d

6. 字符串替换：

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

7. 字符串查找：

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

8. 字符串截取：

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

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

10. 字符串格式化：

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

二. 数组 - 列表

1. 创建列表：

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

2. 获取列表长度：

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

3. 访问列表元素：

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

4. 修改列表元素：

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

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]

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]

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

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

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]

9. 合并列表：

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

10. 列表复制：

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

三. 哈希表 - 字典

1. 创建哈希表：

myMap := make(map[string]int)

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

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

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

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

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

value, exists := myMap["apple"]

为了实现类似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)

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

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

5. 删除键值：

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

6. 获取哈希表长度：

length := len(myMap)

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

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

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

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

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

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

10. 复制哈希表：

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

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

今天是9.18，在此缅怀先烈，勿忘国耻，吾辈需自强！