当前位置：首页 > news >正文

Go：复合数据结构

news 来源：原创 2025/9/12 11:58:51

数组

定义：数组是固定长度、元素数据类型相同的序列。元素通过索引访问，索引从 0 到数组长度减 1 。可用len函数获取元素个数。
初始化：默认元素初始值为类型零值（数字为 0 ）。可使用数组字面量初始化，如var q [3]int = [3]int{1, 2, 3} ，也可简化为q := [...]int{1, 2, 3} ，省略号使数组长度由初始化元素个数决定。
类型特性：数组长度是类型一部分，[3]int和[4]int是不同类型，且长度须是编译时可确定的常量表达式。
比较规则：若元素类型可比较，数组也可比较，用==判断两边元素值是否完全相同，!=判断是否不同。不同长度数组不能比较。

在函数中的传递

函数传参时，传入数组会创建副本，值传递方式使传递大数组低效，且函数内修改不影响原始数组。可传递数组指针，函数内对指针指向数组的修改会反映到原始数组，如zero函数通过指针将[32]byte数组元素清零。

slice

定义：slice 是拥有相同类型元素的可变长度序列，写法为[]T ，T为元素类型，可看作底层数组的动态视图。
底层结构：底层是数组，slice 有指针（指向数组第一个可访问元素）、长度（可访问元素个数）和容量（从第一个元素到底层数组最后一个元素间元素个数）三个属性，用len和cap函数获取长度和容量。
与数组关系：一个底层数组可对应多个 slice ，slice 可引用数组任意位置，元素可重叠。
创建新 slice：用s[i:j]（0 ≤ i ≤ j ≤ cap(s) ）操作符创建新 slice ，引用原 slice 从i到j - 1索引位置元素，省略i默认从 0 开始，省略j默认到len(s) - 1 。
引用越界情况：引用超过容量会导致程序宕机；超过长度会使最终 slice 比原 slice 长。

与字符串、数组操作对比

字符串子串操作和字节 slice 操作类似，都写作x[m:n] ，但字符串返回字符串，字节 slice 返回字节 slice 。

在函数中的传递

传递 slice 给函数时，因包含指向数组元素指针，函数内可修改底层数组元素，如reverse函数可就地反转整型 slice 元素。
比较：slice 不能直接用==比较是否相同，因元素非直接关联，可自定义函数深度比较。标准库bytes.Equal可比较字节 slice 。
特殊值：值为nil的 slice 长度和容量为零，无对应底层数组；非nil但长度和容量为零的 slice 有底层数组。检查 slice 是否为空用len(s) == 0而非s == nil 。

创建

make函数可创建指定元素类型、长度和容量的 slice ，容量参数可省略，此时长度和容量相等

append 函数

基本用法：内置函数append用于将元素追加到 slice 后面。
原理：append操作需检查 slice 容量。若容量足够，在原底层数组基础上扩展 slice 并添加元素；若容量不足，创建新的足够大容量的底层数组，将原 slice 元素复制到新数组，再追加新元素。

func main() {var x, y []intfor i := 0; i < 10; i++ {y = appendInt(x, i)fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)x = y}
}func appendInt(x []int, y int) []int {var z []intzlen := len(x) + 1if zlen <= cap(x) {z = x[:zlen]} else {zcap := max(zlen, 2 * len(x))z = make([]int, zlen, zcap)copy(z, x)}z[len(x)] = yreturn z
}

示例：appendInt函数模拟append功能。当 slice 容量足够（zlen <= cap(x) ）时，直接在原 slice 扩展；容量不足时，新数组容量一般扩展为原 slice 长度的 2 倍（通过zcap计算），用make创建新数组，再用copy函数将原 slice 元素复制到新数组，最后追加新元素并返回新 slice 。

copy 函数

copy函数用于将一个 slice 元素复制到另一个 slice ，参数分别为目标 slice 和源 slice ，返回值是实际复制的元素个数（两个 slice 长度的较小值）。

append 函数增长策略

每次append操作若导致 slice 容量改变，意味着底层数组重新分配和元素复制。以示例程序展示每次追加元素时 slice 容量变化，如容量不够时会成倍扩展，以减少内存分配次数。实际内置append函数增长策略更复杂，无法预先确定一次调用是否引发新内存分配。

注意事项

使用append后通常需将结果重新赋值给原 slice 变量 ，因为函数可能改变 slice 指针、长度或容量。
对于任何可能改变 slice 相关属性的函数调用，都要注意更新 slice 变量。并且appendInt只能添加单个元素，而内置append可同时添加多个元素甚至另一个 slice 的所有元素。

slice 就地修改

func nonempty(strings []string) []string {i := 0for _, s := range strings {if s != "" {strings[i] = si++}}return stirngs[:i]
}

nonempty函数：用于从字符串列表 slice 中去除空字符串。通过遍历输入的strings slice ，将非空字符串依次复制到原 slice 前面位置，最后返回有效元素部分（strings[:i] ）。该函数输入和输出的 slice 共用底层数组，避免重新分配数组，也可利用append函数实现类似功能。

实现栈

可用 slice 实现栈，通过append向 slice 尾部追加元素实现入栈操作（stack = append(stack, v) ），栈顶元素为stack[len(stack) - 1] ，通过stack = stack[:len(stack) - 1]实现出栈操作。

移除操作

保持顺序移除：要从 slice 中间移除元素并保留剩余元素顺序，使用copy函数，将指定位置（i ）之后元素向前移动覆盖被移除元素位置，如copy(slice[i:], slice[i + 1:]) ，然后返回处理后的 slice（slice[:len(slice) - 1] ）。
不保持顺序移除：若无需保持顺序，可将 slice 最后一个元素赋值给被移除元素位置，如slice[i] = slice[len(slice) - 1] ，再返回处理后的 slice（slice[:len(slice) - 1] ）。

map

定义：map是散列表的引用，是拥有键值对元素的无序集合，类型为map[K]V ，K为键类型，V为值类型。键类型须可通过==操作符比较，值类型无限制。

创建与初始化

用make函数创建，如ages := make(map[string]int) ；
也可用字面量新建带初始化键值对的map ，如ages := map[string]int{"alice": 31, "charlie": 34} ，还可分步赋值。
空map表示为map[string]int{} 。

操作

元素访问：通过下标方式访问，如ages["alice"] ，键不存在时返回值类型零值。
元素删除：使用delete函数根据键移除元素，如delete(ages, "alice") ，操作安全，键不存在也不会出错。
元素修改与新增：可通过赋值语句修改或新增元素，如ages["bob"] = ages["bob"] + 1 ，快捷赋值方式（+= 、++ ）同样适用，但不能获取map元素地址。

遍历

用for循环结合range关键字遍历，如for name, age := range ages { fmt.Printf("%s\t%d\n", name, age) } ，元素迭代顺序不固定。若要按键顺序遍历，对于字符串键，可借助sort包的Strings函数对键排序后再遍历。

零值与特殊情况

map类型零值是nil ，大部分map操作可在零值map上执行，但向零值map设置元素会导致错误，设置元素前需初始化。
通过下标访问map元素时，可使用多值返回判断元素是否存在，如age, ok := ages["bob"]; if!ok { /*...*/ } 。

比较

map不可直接比较，唯一合法比较是和nil比较。要判断两个map是否相同，需编写循环逐个比较键值对。

func main() {seen := make(map[string]bool)input := bufio.NewScanner(os.Stdin)for input.Scan() {line := input.Text()if !seen[line] {seen[line] = truefmt.Println(line)}}if err := input.Err(); err != nil {fmt.Fprintf(os.Stderr, "dedup: %v\n", err)os.Exit(1)}
}

去重示例：dedup程序利用map存储已出现的行，确保相同行不重复输出。

结构体

type Employee struct {ID intName stringAddress stringDoB time.TimePosition stringSalary intManagerId int
}

定义：结构体是将多个任意类型的命名变量组合在一起的聚合数据类型，每个变量是结构体成员。以员工信息记录为例，可定义Employee结构体包含ID、Name、Address等成员。
成员访问与操作：
- 通过点号（. ）访问结构体成员，如dilbert.Name 。
- 可对成员赋值，如dilbert.Salary -= 5000 ；也可获取成员地址，通过指针访问修改，如position := &dilbert.Position; *position = "Senior " + *position 。
- 结构体指针同样用点号访问成员，如employeeOfTheMonth.Position += " (proactive team player)" 。

定义规则

成员变量一般一行写一个，相同类型的连续成员变量可写在一行。成员变量顺序影响结构体同一性，改变顺序会定义出不同结构体类型。
首字母大写的成员变量是可导出的，是 Go 语言的访问控制机制。

限制与应用

type tree struct {value intleft, right *tree
}func Sort(values []int) {var root *treefor _, v := range values {root = add(root, v)}appendValues(values[:0], root)
}func add(t *tree,  value int) *tree {if t == nil {t = new(tree)t.value = valuereturn t}if value < t.value{t.left = add(t.left, value)} else {t.right = add(t.right, value)}return t
}func appendValues(values[]int, t *tree) []int{if t != nil {values = appendValues(values, t.left)values = append(values, t.value)values = appendValues(values, t.right)}return values
}

一个结构体类型不能包含自身类型的成员变量，但可包含自身类型的指针，用于创建递归数据结构，如链表、树。
示例：给出用二叉树实现插入排序，包括Sort函数构建二叉树并排序、appendValues函数按序追加元素、add函数向二叉树插入节点。

零值

结构体零值由成员零值组成，很多情况下零值是合理可用的初始状态，如bytes.Buffer和sync.Mutex 。还提到空结构体struct{} ，无成员变量，长度为 0 ，可用于一些节省内存且语法简单的场景，如在map中作值类型来替代集合。

结构体字面量

第一种格式：按成员变量顺序为每个成员指定值，如Point结构体，p := Point{1, 2} 。此格式要求记住成员顺序，在结构体成员扩充或顺序调整时不利于代码维护，常用于结构体定义所在包或成员顺序有明显约定的小结构体，如image.Point 、color.RGBA 。
第二种格式：通过指定部分或全部成员变量的名称和值来初始化结构体变量，如anim := gif.GIF{LoopCount: nframes} 。未指定值的成员取其类型零值，成员顺序无要求，使用更广泛。
两种初始化方式不能混合使用，且第一种方式不能绕过不可导出变量的访问限制。
值传递：结构体类型的值可作为参数传递给函数或作为函数返回值，如Scale函数将Point结构体按比率缩放并返回新的Point 。
指针传递：出于效率和修改结构体内容的需求，大型结构体常以指针形式传递给函数或从函数返回 。

创建与初始化

可使用&Point{1, 2}直接创建并初始化Point结构体变量并获取其地址，这等价于pp := new(Point); *pp = Point{1, 2} ，且&Point{1, 2}可直接用于表达式或函数调用中。

结构体比较

若结构体的所有成员变量都可比较，那么这个结构体就是可比较的。可使用==或!=操作符对结构体进行比较。==操作符按顺序比较两个结构体变量的成员变量，以Point结构体为例，p := Point{1, 2}和q := Point{2, 1} ，p == q与p.X == q.X && p.Y == q.Y等价，结果都为false 。

type address struct {hostname stringport int
}
hits := make(map[address]int)
hits[address{"golang.org", 443}]++

和其他可比较类型一样，可比较的结构体类型能作为map的键类型。

结构体嵌套和匿名成员

type Circle struct {X, Y, Radius int
}type Wheel struct {X, Y, Radius, Spokes int
}var w Wheel
w.X = 8
w.Y = 8
w.Radius = 5
w.Spokes = 20

type Circle struct {Center PointRadius int
}type Wheel struct {Circle  circleSpokes  int
}//  var w Wheel
// w.Circle.Center.X = 8
// w.Circle.Center.Y = 8
// w.Circle.Radius = 5
// w.Spokes = 20// 等价于上面
var w Wheel
w.X = 8
w.Y = 8
w.Radius = 5
w.Spokes = 20

以 2D 绘图程序中形状库为例，最初定义Circle和Wheel结构体，Wheel包含Circle所有属性及额外的Spokes属性。随着形状增多，重构提取出Point结构体，将Circle定义为包含Center Point和Radius ，Wheel包含Circle和Spokes ，但此时访问Wheel成员变得繁琐。

Go 语言允许定义不带名称的结构体成员（匿名成员），其类型须是命名类型或指向命名类型的指针。如Circle结构体中嵌入Point ，Wheel结构体中嵌入Circle 。使用匿名成员后，可直接通过外层结构体访问内层成员，如w.X等价于w.Circle.Point.X 。

结构体字面量初始化

w = Wheel{Circle{point{8, 8}, 5}, 20}
// or
w = Wheel{Circle: Circle{Point: Point(X: 8, Y: 8),Radius = 5,}Spokes: 20, // 尾部的逗号是必需的
}

结构体字面量不能直接以简洁方式初始化嵌套结构体，需遵循形状类型定义。给出两种合法初始化Wheel结构体的方式，一种是w = Wheel{Circle{Point{8, 8}, 5}, 20} ，另一种是详细展开的方式。

注意事项

一个结构体中不能定义两个相同类型的匿名成员，会引起冲突。
匿名成员的可导出性由其类型决定，即使外层结构体不可导出，仍可通过快捷方式访问可导出匿名成员的内部变量，但在声明该匿名成员的包外，显式指定不可导出匿名成员的方式不被允许。
匿名成员不仅可以是结构体类型，任何命名类型或指向命名类型的指针都可以，这种机制是将简单类型组合成复杂复合类型的重要方式，是 Go 语言面向对象编程方式的核心。

JSON

JSON 是一种用于发送和接收格式化信息的标准，是 JavaScript 值的 Unicode 编码，能表示字符串、数字、布尔值、数组和对象等。它是基本数据类型和复合数据类型的高效、可读性强的表示方法。JSON 的数组是元素序列，用逗号分隔、方括号括起；对象是键值对映射，键为字符串，用逗号分隔、花括号括起。

Go 对 JSON 的支持

Go 通过标准库encoding/json等对 JSON 等格式提供编码和解码支持。

编码（Marshal ）：将 Go 数据结构（如结构体、数组、slice、map 等）转换为 JSON 格式称为marshal ，由json.Marshal函数实现。如将movies（[]Movie类型）转换为 JSON ，json.Marshal生成字节 slice ，包含无多余空白字符的字符串。json.MarshalIndent可输出整齐格式化的结果，通过设置前缀和缩进字符串实现。结构体成员名作为 JSON 对象字段名（通过反射），可通过成员标签（field tag ）指定对应 JSON 字段名及其他选项，如omitempty表示成员值为零值或空时不输出到 JSON 。
解码（Unmarshal ）：将 JSON 字符串解码为 Go 数据结构的过程叫unmarshal ，由json.Unmarshal实现。合理定义 Go 数据结构，可选择将部分 JSON 数据解码到结构体对象，也可丢弃部分数据。

// github.go
package githubimport ("encoding/json""fmt""net/http""net/url""strings"
)const IssueURL = "https://api.github.com/repos/%s/issues/%d"type IssuesSearchResult struct {TotalCount int `json:"total_count"`Items      []*Issue
}type Issue struct {Number    intHTMLURL   string `json:"html_url"`Title     stringState     stringUser      *UserCreatedAt string `json:"created_at"`Body      string
}type User struct {Login   stringHTMLURL string `json:"html_url"`
}func SearchIssues(terms []string) (*IssuesSearchResult, error) {q := url.QueryEscape(strings.Join(terms, " "))resp, err := http.Get(IssueURL + "?q=" + q)if err != nil {return nil, err}if resp.StatusCode != http.StatusOK {resp.Body.Close()return nil, fmt.Errorf("search query failed: %s", resp.Status)}var result IssuesSearchResultif err := json.NewDecoder(resp.Body).Decode(&result); err != nil {resp.Body.Close()return nil, err}resp.Body.Close()return &result, nil
}

// issues.go
package mainimport ("fmt""log""os""gopl.io/ch4/github"
)func main() {result, err := github.SearchIssues(os.Args)if err != nil {log.Fatal(err)}fmt.Printf("%d issues:\n", result.TotalCount)for _, item := range result.Items {fmt.Printf("#%-5d %9.9s %.55s\n", item.Number, item.User.Login, item.Title)}
}

示例：以查询 GitHub 提供的 issue 跟踪接口为例，定义相关结构体（如IssuesSearchResult 、Issue等），通过SearchIssues函数发送 HTTP 请求获取 JSON 信息，并将其解析为 Go 结构体。还可使用json.Decoder流解码方式依次从字节流解码多个 JSON 实体，并将结果格式化输出。

文本和HTML 模板

文本模板

模板基础：当格式化需求复杂且需格式与代码分离时，可使用text/template包。模板中用{{...}}包裹表达式，能实现输出值、选择结构体成员、调用函数方法、描述控制逻辑（如if - else 、range循环）等功能。
示例：以 GitHub 问题列表展示为例，通过模板输出符合条件的 issue 数量及每个 issue 的序号、用户、标题、创建时长等信息。模板操作中，点号（. ）表示当前值，{{.TotalCount}}输出总数，{{range .Items}}和{{end}}创建循环，符号|用于操作间传递结果，如{{.Title | printf "%.64s"}} 。
模板使用：使用模板需先解析再执行。通过template.New创建模板，Funcs添加自定义函数（如daysAgo ），Parse解析模板，template.Must处理解析错误，最后Execute执行模板并输出结果。

HTML 模板

安全特性：html/template包功能类似text/template ，但能自动转义 HTML、JavaScript、CSS 和 URL 中的字符串，避免注入攻击等安全问题。
示例展示：将 GitHub 问题列表以 HTML 表格形式输出，定义模板并解析执行，生成的 HTML 在浏览器中展示。对比展示text/template和html/template对特殊字符处理的差异，html/template能正确转义 HTML 元字符，防止结构改变和安全风险。
printf “%.64s”}}` 。
模板使用：使用模板需先解析再执行。通过template.New创建模板，Funcs添加自定义函数（如daysAgo ），Parse解析模板，template.Must处理解析错误，最后Execute执行模板并输出结果。