go语言数组与切片

简介: go语言数组与切片

一、数组定义、遍历、截取、比较

package array_test
 
import "testing"
 
//数组
func TestArrayInit(t *testing.T) {
  //默认初始化零值
  var arr [3]int
  //初始化并赋值
  arr1 := [4]int{1, 2, 3, 4}
  //初始化,自动获取数组长度
  arr2 := [...]int{1, 2, 3, 4}
  t.Log(arr[0], arr[1])
  t.Log(arr1, arr2)
  //  数组遍历
  for i := 0; i < len(arr2); i++ {
    t.Log(arr2[i])
  }
  //range遍历
  for i, e := range arr2 {
    t.Log(i, e)
  }
  //  range遍历 使用占位
  for i, _ := range arr2 {
    t.Log(i)
  }
  //  多维数组申明
  arr3 := [2][2]int{{1, 2}, {1, 2}}
  t.Log(arr3)
  //  数组截取[开始(包含),结束(不包含)] 使用len不会越界
  arr4 := [...]int{1, 2, 3, 4, 5}
  t.Log(arr4[1:2]) //2
  t.Log(arr4[1:])  //2 3 4 5
  t.Log(arr4[:2])  //1 2
}
 
//  数组可比较,维数、顺序、值相同 true
func TestArrayComparing(t *testing.T) {
  a := [...]int{1, 2, 3, 4}
  b := [...]int{1, 2, 3, 4}
  t.Log(a == b)
}
=== RUN   TestArrayInit
    array_test.go:13: 0 0
    array_test.go:14: [1 2 3 4] [1 2 3 4]
    array_test.go:17: 1
    array_test.go:17: 2
    array_test.go:17: 3
    array_test.go:17: 4
    array_test.go:21: 0 1
    array_test.go:21: 1 2
    array_test.go:21: 2 3
    array_test.go:21: 3 4
    array_test.go:25: 0
    array_test.go:25: 1
    array_test.go:25: 2
    array_test.go:25: 3
    array_test.go:29: [[1 2] [1 2]]
    array_test.go:32: [2]
    array_test.go:33: [2 3 4 5]
    array_test.go:34: [1 2]
--- PASS: TestArrayInit (0.00s)
=== RUN   TestArrayComparing
    array_test.go:41: true
--- PASS: TestArrayComparing (0.00s)
PASS

二、切片定义、添加、扩容、比较

package slice_test
 
import "testing"
 
//切片
func TestSlice(t *testing.T) {
  //  申明
  var s0 []int
  t.Log(len(s0), cap(s0))
  s0 = append(s0, 50)
  t.Log(len(s0), cap(s0))
  //申明并初始化
  s1 := []int{1, 2, 3, 4}
  t.Log(len(s1), cap(s1))
  //使用make初始化
  s2 := make([]int, 3, 5)
  t.Log("初始化", len(s2), cap(s2))
  s2 = append(s2, 6)
  t.Log(s2[0], s2[1], s2[2], s2[3])
  t.Log("添加元素后:", len(s2), cap(s2))
}
 
//切片扩容,翻倍
func TestSliceGrowing(t *testing.T) {
  s := []int{}
  for i := 0; i < 10; i++ {
    //地址可能发生变化,重新赋值
    s = append(s, i)
    t.Log(len(s), cap(s))
 
  }
}
 
//共享切片
func TestSliceShareMemory(t *testing.T) {
  //初始化
  year := []string{"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "sep", "Oct", "Nov", "Dec"}
  t.Log("year", len(year), cap(year))
  //切片1
  q2 := year[3:6]
  t.Log(q2, len(q2), cap(q2))
  //切片2
  summer := year[5:8]
  t.Log(summer, len(summer), cap(summer))
  summer[0] = "Unknow"
  t.Log(q2)
  t.Log(year)
}
 
//切片比较
func TestSliceComparing(t *testing.T) {
  a := []int{1, 2, 3, 4}
  b := []int{1, 2, 3, 4}
  t.Log(a, b)
  //t.Log(a == b)
}
=== RUN   TestSlice
    slice_test.go:9: 0 0
    slice_test.go:11: 1 1
    slice_test.go:14: 4 4
    slice_test.go:17: 初始化 3 5
    slice_test.go:19: 0 0 0 6
    slice_test.go:20: 添加元素后: 4 5
--- PASS: TestSlice (0.00s)
=== RUN   TestSliceGrowing
    slice_test.go:29: 1 1
    slice_test.go:29: 2 2
    slice_test.go:29: 3 4
    slice_test.go:29: 4 4
    slice_test.go:29: 5 8
    slice_test.go:29: 6 8
    slice_test.go:29: 7 8
    slice_test.go:29: 8 8
    slice_test.go:29: 9 16
    slice_test.go:29: 10 16
--- PASS: TestSliceGrowing (0.00s)
=== RUN   TestSliceShareMemory
    slice_test.go:38: year 12 12
    slice_test.go:41: [Apr May Jun] 3 9
    slice_test.go:44: [Jun Jul Aug] 3 7
    slice_test.go:46: [Apr May Unknow]
    slice_test.go:47: [Jan Feb Mar Apr May Unknow Jul Aug sep Oct Nov Dec]
--- PASS: TestSliceShareMemory (0.00s)
=== RUN   TestSliceComparing
    slice_test.go:54: [1 2 3 4] [1 2 3 4]
--- PASS: TestSliceComparing (0.00s)
PASS

三、区别

1、数组是定长度,切片是边长度;

2、数组可以相互比较,切片不可以;

3、数组是值传递,切片是引用传递;

相关文章
|
4月前
|
存储 JSON 安全
Go语言切片,使用技巧与避坑指南
Go语言中的切片(Slice)是动态引用数组的高效数据结构,支持扩容与截取。本文从切片基础、常用操作到高级技巧全面解析,涵盖创建方式、`append`扩容机制、共享陷阱及安全复制等内容。通过代码示例详解切片特性,如预分配优化性能、区分`nil`与空切片、处理多维切片等。掌握这些核心知识点,可编写更高效的Go代码。
168 2
|
8月前
|
运维 监控 算法
监控局域网其他电脑:Go 语言迪杰斯特拉算法的高效应用
在信息化时代,监控局域网成为网络管理与安全防护的关键需求。本文探讨了迪杰斯特拉(Dijkstra)算法在监控局域网中的应用,通过计算最短路径优化数据传输和故障检测。文中提供了使用Go语言实现的代码例程,展示了如何高效地进行网络监控,确保局域网的稳定运行和数据安全。迪杰斯特拉算法能减少传输延迟和带宽消耗,及时发现并处理网络故障,适用于复杂网络环境下的管理和维护。
|
3月前
|
数据采集 机器学习/深度学习 存储
Go语言实战案例 - 找出切片中的最大值与最小值
本案例通过实现查找整数切片中的最大值与最小值,帮助初学者掌握遍历、比较和错误处理技巧,内容涵盖算法基础、应用场景及完整代码示例,适合初学者提升编程能力。
|
2月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇,讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容,提升网络请求效率。通过实战掌握高并发编程技巧,构建爬虫、内容聚合器等工具,涵盖 WaitGroup、超时控制、错误处理等核心知识点。
|
2月前
|
数据采集 JSON Go
Go语言实战案例:实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇,详细介绍如何使用 Go 构建 HTTP 客户端,涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程,并通过实战代码演示如何并发请求多个 URL,适合希望掌握 Go 网络编程基础的开发者。
|
3月前
|
JSON 前端开发 Go
Go语言实战:创建一个简单的 HTTP 服务器
本篇是《Go语言101实战》系列之一,讲解如何使用Go构建基础HTTP服务器。涵盖Go语言并发优势、HTTP服务搭建、路由处理、日志记录及测试方法,助你掌握高性能Web服务开发核心技能。
|
3月前
|
Go
如何在Go语言的HTTP请求中设置使用代理服务器
当使用特定的代理时,在某些情况下可能需要认证信息,认证信息可以在代理URL中提供,格式通常是:
251 0
|
4月前
|
JSON 编解码 API
Go语言网络编程:使用 net/http 构建 RESTful API
本章介绍如何使用 Go 语言的 `net/http` 标准库构建 RESTful API。内容涵盖 RESTful API 的基本概念及规范,包括 GET、POST、PUT 和 DELETE 方法的实现。通过定义用户数据结构和模拟数据库,逐步实现获取用户列表、创建用户、更新用户、删除用户的 HTTP 路由处理函数。同时提供辅助函数用于路径参数解析,并展示如何设置路由器启动服务。最后通过 curl 或 Postman 测试接口功能。章节总结了路由分发、JSON 编解码、方法区分、并发安全管理和路径参数解析等关键点,为更复杂需求推荐第三方框架如 Gin、Echo 和 Chi。
|
4月前
|
Go 索引
Go语言中使用切片需要注意什么?
本文详细讲解了Go语言中切片(Slice)的使用方法与注意事项。切片是对数组连续片段的引用,具有灵活的操作方式。文章从定义与初始化、长度与容量、自动扩容、共享底层数组、复制、边界检查、零值到拼接等方面展开,并配以示例代码演示。通过学习,读者可深入了解切片的工作原理及优化技巧,避免常见陷阱,提升编程效率与代码质量。
115 2
|
5月前
|
分布式计算 Go C++
初探Go语言RPC编程手法
总的来说,Go语言的RPC编程是一种强大的工具,让分布式计算变得简单如同本地计算。如果你还没有试过,不妨挑战一下这个新的编程领域,你可能会发现新的世界。
118 10