GO语言基础笔记(三):复合类型

发布时间:2023年12月28日

????????深入学习Go语言中的复合类型:数组、切片、映射(Map)和结构体。这些类型是构建复杂数据结构和实现复杂逻辑的基础。

目录

1. 数组(Array)

?遍历数组

多维数组

数组作为函数参数?

2. 切片(Slice)

切片的长度和容量

添加元素到切片

切片的切片操作

使用make创建切片?

多维切片?

遍历切片?

3. 映射(Map)

检索映射中的元素

删除映射中的元素

使用make创建映射

遍历映射

4. 结构体(Struct)

结构体作为函数参数

使用指针操作结构体

定义结构体的方法


1. 数组(Array)

  • 定义:数组是具有相同类型元素的固定长度序列。
  • 声明方式var arr [n]Type,其中n是数组的长度,Type是存储元素的类型。
  • 特点:长度固定,一旦声明,长度不能改变。
var arr [5]int
arr[0] = 1
fmt.Println(arr) // 输出:[1 0 0 0 0]

?遍历数组

    // 使用for循环遍历数组
    for i := 0; i < len(arr2); i++ {
        fmt.Printf("arr2[%d] = %d\n", i, arr2[i])
    }

    // 使用for range遍历数组
    for index, value := range arr2 {
        fmt.Printf("索引:%d, 值:%d\n", index, value)
    }

多维数组

    // 声明一个二维数组
    var matrix [2][3]int
    matrix[0] = [3]int{1, 2, 3}
    matrix[1] = [3]int{4, 5, 6}
    fmt.Println("二维数组:", matrix)

数组作为函数参数?

    // 数组作为函数参数
    sum := sumArray(arr2)
    fmt.Println("数组和:", sum)
}

// 函数接受一个整型数组作为参数
func sumArray(arr [5]int) int {
    sum := 0
    for _, value := range arr {
        sum += value
    }
    return sum
}

2. 切片(Slice)

  • 定义:切片是对数组的封装,提供更灵活、更强大的序列接口。
  • 声明方式var slice []Type,切片不需要指定长度。
  • 特点:长度可变,可以动态地增长或缩短。
slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice) // 输出:[1 2 3 4]

切片的长度和容量

    // 使用len和cap函数
    fmt.Println("长度:", len(slice2), "容量:", cap(slice2))

添加元素到切片

    // 添加元素到切片
    slice2 = append(slice2, 6)
    fmt.Println("添加元素后的切片:", slice2)

切片的切片操作

    // 创建切片的切片
    subSlice := slice2[1:3]
    fmt.Println("切片的切片:", subSlice)

使用make创建切片?

    // 使用make创建切片
    slice3 := make([]int, 3) // 长度为3的切片
    fmt.Println("使用make创建的切片:", slice3)

多维切片?

    // 创建一个二维切片
    twoDSlice := make([][]int, 3)
    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoDSlice[i] = make([]int, innerLen)
        for j := 0; j < innerLen; j++ {
            twoDSlice[i][j] = i + j
        }
    }
    fmt.Println("二维切片:", twoDSlice)

遍历切片?

    // 使用for range遍历切片
    for index, value := range slice2 {
        fmt.Printf("索引:%d, 值:%d\n", index, value)
    }
}

3. 映射(Map)

  • 定义:映射是存储键值对的无序集合。
  • 声明方式var mapVar map[KeyType]ValueType
  • 特点:键唯一,通过键快速检索对应的值。
m := make(map[string]int)
m["key1"] = 7
m["key2"] = 13
fmt.Println(m) // 输出:map[key1:7 key2:13]

检索映射中的元素

    // 检索键值对
    age, ok := map2["Alice"]
    if ok {
        fmt.Println("Alice的年龄:", age)
    } else {
        fmt.Println("Alice不在映射中")
    }

删除映射中的元素

    // 删除键值对
    delete(map2, "Bob")
    fmt.Println("删除Bob后的映射:", map2)

使用make创建映射

    // 使用make创建映射
    map3 := make(map[string]int)
    map3["Dave"] = 28
    fmt.Println("使用make创建的映射:", map3)

遍历映射

    // 使用for range遍历映射
    for key, value := range map2 {
        fmt.Printf("键:%s, 值:%d\n", key, value)
    }
}

4. 结构体(Struct)

  • 定义:结构体是一种聚合数据类型,它将不同类型的数据聚合到一个复合类型中。
  • 声明方式type StructName struct { Field1 Type1; Field2 Type2; ... }
  • 特点:非常适合用来创建数据模型。
type Person struct {
    Name string
    Age  int
}

var p Person
p.Name = "Alice"
p.Age = 30
fmt.Println(p) // 输出:{Alice 30}

结构体作为函数参数

    // 调用函数,传递结构体作为参数
    printPerson(person1)
    printPerson(person2)
}

// 函数接受一个Person类型的参数
func printPerson(p Person) {
    fmt.Printf("%s is %d years old.\n", p.Name, p.Age)
}

使用指针操作结构体

    // 使用指针修改结构体
    changeName(&person1, "Alice Cooper")
    fmt.Println("Updated Person 1:", person1)
}

// 函数接受一个指向Person的指针,并修改其中的字段
func changeName(p *Person, newName string) {
    p.Name = newName
}

定义结构体的方法

// Person类型的方法
func (p Person) Greet() {
    fmt.Println("Hi, my name is", p.Name)
}

func main() {
    person1 := Person{Name: "Alice", Age: 30}
    person1.Greet() // 调用Person的方法
}

文章来源:https://blog.csdn.net/weixin_44120785/article/details/135177591
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。