GO语言基础-04-数据类型-03-切片[slice]（声明切片、初始化切片、切片赋值、切片长度、切片容量、空切片、append、copy）

已于 2022-12-26 21:54:35 修改
阅读量1.9k 收藏
点赞数 1
分类专栏： # go基础 文章标签： golang 数据结构 go语言 slice 容量
于 2022-12-01 23:19:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingzuo_1840/article/details/128124805
版权

文章目录

数组和切片的区别
数组是需要指定个数的，而切片则不需要。

1. 声明切片

  • 语法
var  SliceName []type
  • 语法示例

定义一个切片，且切片成员为字符串类型

var names []string

2. 初始化切片

声明切片的同时，为切片分配一个内存地址。

2.1 切片长度

2.1.1 初始化指定长度的切片

说明：len表示数组长度，即切片的初始长度

  • 语法
var  slice1  = make([]type, len)

在函数内，可简写做：

slice1 := make([]type, len)
  • 语法示例
var names  = make([]string,3)

函数内可以写做：

names  := make([]string,3)

当然你也可以先声明，然后在初始化

var names []string
names  = make([]string,3)

2.1.2 查看切片长度 len()

  • 语法
len(SliceName)
  • 示例
package main

import "fmt"

func main() {
	names  := make([]string,10)
	fmt.Printf("切片：%+v\n长度为：%d",names,len(names))
}

结果打印

切片：[         ]
长度为：10
  • 说明：

问：明明打印的切片没有成员，为什么长度为10？
答：可以看见我们打印出的结果是[ ]而不是[]。这里边有9个空格，即是10个成员间的9个分隔符（空格）。我们看不到成员，是因为这10个成员的值默认都是空（字串不赋值默认为空）。如果我们定义切片成员类型是int我们将看到打印出10个0（int类型不赋值，默认为0）

package main

import "fmt"

func main() {
	slice1  := make([]int,10)
	fmt.Printf("切片：%+v\n长度为：%d",slice1,len(slice1))
}

结果：

切片：[0 0 0 0 0 0 0 0 0 0]
长度为：10

2.2 切片容量

2.2.1 初始化指定容量的切片

  • cap可选，指容量。

说明：

  • len是目前的成员数
  • cap是切片的上限

每增加 一个成员，len 值加1，成员数达到cap值后，cap值翻倍。

  • 语法
slice1 := make([]type, len, cap)
  • 语法示例
names  := make([]string,3,5)

2.2.2 查看切片长度 len()

  • 语法
cap(SliceName)
  • 示例
package main

import "fmt"

func main() {
	names  := make([]string,3,5)
	fmt.Printf("切片长度为：%d,容量为：%d",len(names),cap(names))
}

结果打印

切片长度为：3,容量为：5

3 切片赋值

3.1 直接赋值

  • 语法示例

在函数内我们用:在赋值的同时也声明了切片（只用=仅赋值但不能声明切片）

names :=[]string{"刘备","关羽","张飞" }
  • 完整示例
package main
import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"}
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d",names,len(names),cap(names))
}

结果显示

打印切片：[刘备 关羽 张飞]
长度为：3
容量为：3

3.2 引用数组给切片赋值

  • 语法
s := arr[:]
  • 示例
package main

import "fmt"

func main() {
	namesArray := [3]string{"刘备","关羽","张飞"} //定义一个数组
	names  := namesArray[:]  //声明切片并用数组给切片赋值
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d",names,len(names),cap(names))
}

执行结果为：

打印切片：[刘备 关羽 张飞]
长度为：3
容量为：3

3.3 引用数组某区间给切片赋值

前提：设N为起始位置，到第M个成员。

3.3.1 从数组位置N个取到第M个元素，赋值给切片

- 语法
s := arr[N:M]
- 示例
  • 需求：从元素的位置1（刘备是位置0，关羽是位置1），取到第3个成员（第一个成员是刘备，第二个是关羽，第三个是张飞）
  • 预计：切片将取到 关羽、张飞两个成员。
  • 代码如下
package main

import "fmt"

func main() {
	namesArray := [5]string{"刘备","关羽","张飞","赵云","诸葛亮"} //定义一个数组
	names  := namesArray[1:3]
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d",names,len(names),cap(names))
}
  • 结果打印
打印切片：[关羽 张飞]
长度为：2
容量为：4
  • 说明

长度是2，因为我们取到了两个成员：关羽、张飞
容量是4，这是从起始位置1（关羽）起，计算到数组结尾（诸葛亮），一共四个位置。

虽然没有取到赵云和诸葛亮，但是容量已经加进来了

3.3.2 从数组位置N取到结尾，赋值给切片

- 语法
s := arr[N:]
- 示例
  • 代码
package main

import "fmt"

func main() {
	namesArray := [5]string{"刘备","关羽","张飞","赵云","诸葛亮"} //定义一个数组
	names  := namesArray[1:]
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d",names,len(names),cap(names))
}
  • 结果显示
打印切片：[关羽 张飞 赵云 诸葛亮]
长度为：4
容量为：4
  • 说明
    长度是4，因为我们取到了4个成员：关羽、张飞、赵云、诸葛亮
    容量是4，这是从起始位置1（关羽）起，计算到数组结尾（诸葛亮），一共四个位置。

3.3.3 从开头取到第M个元素，赋值给切片

- 语法
s := arr[:M]
- 示例
  • 需求：从开头（位置0）取到第二个成员（关羽）
package main

import "fmt"

func main() {
	namesArray := [5]string{"刘备","关羽","张飞","赵云","诸葛亮"} //定义一个数组
	names  := namesArray[:3]
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d",names,len(names),cap(names))
}

结果打印

打印切片：[刘备 关羽 张飞]
长度为：3
容量为：5
  • 说明
    长度是3，因为我们取到了3个成员：刘备、关羽、张飞
    容量是5，这是从起始位置0（刘备）起，计算到数组结尾（诸葛亮），一共四个位置。

3.4 通过切片赋值给切片

说明：通过切片s初始化切片s1

s2 := s1[N:M]

方法同数组赋值给切片

4. 空切片

4.1 仅声明的切片为空

package main

import "fmt"

func main() {
	var names []string

	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

	if names == nil {
		fmt.Printf("切片是空的")
	}else {
		fmt.Println("切片不为空")
	}
}
  • 结果
打印切片：[]
长度为：0
容量为：0
切片是空的

4.2 初始容量为0的切片不为空

package main

import "fmt"

func main() {
	var names = make([]string,0,0)
	fmt.Printf("打印切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

	if names == nil {
		fmt.Println("切片是空的")
	}else {
		fmt.Println("切片不为空")
	}
}

结果打印

打印切片：[]
长度为：0
容量为：0
切片不为空

5. append()

- 语法

  • 语法
func append(slice []Type, elems ...Type) []Type
  • 语法示例
names = append(names,"赵云")

- 示例1（添加一个成员）

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"} 
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

	names = append(names,"赵云")
	fmt.Printf("==================\n添加成员后：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
添加成员后：[刘备 关羽 张飞 赵云]
长度为：4
容量为：6
  • 说明：

结果可见，当成员达到容量上限后，再添加成员，长度增加一，但是容量会翻倍。

- 示例2（添加多个成员）

我们再继续添加成员，也想验证一下长度和容量的变化。

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"} 
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

	names = append(names,"赵云")
	fmt.Printf("==================\n添加成员后：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))


	names = append(names,"马超","黄忠","魏延")
	fmt.Printf("==================\n添加成员后：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
添加成员后：[刘备 关羽 张飞 赵云]
长度为：4
容量为：6
==================
添加成员后：[刘备 关羽 张飞 赵云 马超 黄忠 魏延]
长度为：7
容量为：12
  • 说明

可以看到，成员再次超过容量时，容量在当前容量的基础上翻倍。

- 示例3（添加成员赋值给新切片）

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"}
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

	names2 := append(names,"赵云")
	fmt.Printf("==================\n新切片：%+v\n长度为：%d\n容量为：%d\n",names2,len(names2),cap(names2))
	fmt.Printf("==================\n再次打印原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果显示
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
新切片：[刘备 关羽 张飞 赵云]
长度为：4
容量为：6
==================
再次打印原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
  • 说明：

结果可见，append对于原切片并不会造成影响。

6. copy() 函数

- 语法

func copy(dst []Type, src []Type) int

返回成功拷贝了多少个元素

- 示例1（新切片长度 >= 原切片长度）

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"}
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

    names2 := make([]string,4,4)
	num := copy(names2,names)
	fmt.Printf("==================\n新切片：%+v\n拷贝了%d个元素\n长度为：%d\n容量为：%d\n",names2,num,len(names2),cap(names2))
	fmt.Printf("==================\n再次打印原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
新切片：[刘备 关羽 张飞 ]
拷贝了3个元素
长度为：4
容量为：4
==================
再次打印原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
  • 说明

如上可见，初始化长度为4，拷贝了3个元素，但是我们可以看到新切片最后有一个空格，是第3和第4个元素的分隔符，只是第四个元素为空

- 示例2 （新切片长度 < 原切片长度）

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"}
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

    names2 := make([]string,2,4)
	num := copy(names2,names)
	fmt.Printf("==================\n新切片：%+v\n拷贝了%d个元素\n长度为：%d\n容量为：%d\n",names2,num,len(names2),cap(names2))
	fmt.Printf("==================\n再次打印原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果显示
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
新切片：[刘备 关羽]
拷贝了2个元素
长度为：2
容量为：4
==================
再次打印原切片：[刘备 关羽 张飞]
长度为：3
容量为：3

- 示例2 （新切未初始化）

新切片未初始化的结果类似于初始化长度为0的切片

  • 代码
package main

import "fmt"

func main() {
	names := []string{"刘备","关羽","张飞"} 
	fmt.Printf("原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))

    var names2 []string
	if names2 == nil{
		fmt.Println("==================\nnames2 为空")
	}else{
		fmt.Println("==================\nname2 不为空")
	}
	num := copy(names2,names)
	fmt.Printf("新切片：%+v\n拷贝了%d个元素\n长度为：%d\n容量为：%d\n",names2,num,len(names2),cap(names2))
	fmt.Printf("==================\n再次打印原切片：%+v\n长度为：%d\n容量为：%d\n",names,len(names),cap(names))
}
  • 结果
原切片：[刘备 关羽 张飞]
长度为：3
容量为：3
==================
names2 为空
新切片：[]
拷贝了0个元素
长度为：0
容量为：0
==================
再次打印原切片：[刘备 关羽 张飞]
长度为：3
容量为：3

在这里插入图片描述

玄德公笔记
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
goland创建一个不限长度的字节切片_关于Go切片，看这篇就够了
weixin_39555179的博客
12-25 570
这个一篇关于Go切片的文章，应该能满足你 99%的Go切片的使用场景01.切片的内部实现和基础功能切片是围绕着动态数组的概念来构建的，它跟数组类似，是用于管理数据集合的一种数据结构。数组一旦创建就不能更改其长度和类型，而切片就不同，切片可以按需自动增长和缩小，增长一般使用内置的 append 函数来实现，而缩小则是通过对切片再次进行切割来实现。切片内部实现切片对底层数组进行了抽象，并提供...
golang slice切片
技术的搬运工
06-24 479
string本身是不可变的，因此要改变string中的字符，需要将字符串转化成切片。在大批量添加数据时，建议一次性分配足够大的空间，以减少内存分配和数据复制开销。函数 copy 在两个 slice 间复制数据，复制长度以 len 小的为准。string底层就是一个byte的数组，因此，也可以进行切片操作。在函数内等号左半部分可以用。1、切片追加另外一个切片。4、从数组中切片赋值。2、切片追加一个元素。3、切片追加多个元素。
Go语言切片Slice
YIYIYI
06-21 2145
Go语言切片Slice
Python基础教程：切片的赋值
最新发布
2401_84558914的博客
04-29 825
Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！
golang切片简介
农家小舍
08-02 8037
创建 访问 操作 切片（slice）是Golang中数组之上的抽象；可按需自动增长与缩小。切片的底层是连续的内存块。 创建 切片本身是一个三个字段的数据结构： Data：指向底层数组的指针； Len：切片中元素的个数；len(s)获取; Cap：切片的容量（不需重新分配内存前，可容纳的元素数量）；cap(s)获取； typeSliceHeaderstruct{ Datauintptr Lenint Capint } 创建与初始化 有多种创...
深入理解Go语言中的数组和切片
12-26
//a是一个数组，注意数组是一个固定长度的，初始化时候必须要指定长度，不指定长度的话就是切片了 a := [3]int{1, 2, 3} //b是数组，是a的一份拷贝 b := a //c是切片，是引用类型，底层数组是a c := a[:] for i := 0...
go代码-Go 切片
07-16
在 Go 语言中，切片（slice）是一种非常重要的数据结构，它提供了对数组的动态视图。Go 的切片不仅高效，而且灵活，能够适应多种编程需求。本篇文章将深入探讨 Go 语言中的切片及其相关的知识点。 首先，我们需要...
untypedslice:自动类型切片的测试
07-05
1. 初始化：首先，我们需要测试不同类型的元素是否能够正确地被添加到无类型切片中，如整数、字符串、自定义结构体等。 2. 类型断言：测试代码中应该包含对切片元素进行类型断言的部分，确保在访问元素时能正确处理...
Go语言中slice的用法实例分析
09-22
在Go语言中，`slice`是一种非常重要的数据结构，它为程序员提供了动态数组的功能。slice不是数组本身，而是数组的一个视图，它包含了一个指向数组的指针以及数组的长度和容量信息。以下是对Go语言中slice用法的详细...
go-structure:golang实现的数据结构
04-22
让我们详细探讨一下这些数据结构及其在Go语言中的实现。 1. **数组**： 数组是一种固定大小的序列，其所有元素具有相同的类型。在Go中，数组声明如下： ```go var arrayName [size]dataType ``` 例如，一个...
go-tour-exercises:有用的围棋基础
07-14
- **变量声明**：使用 `var` 关键字声明变量，可以使用 `:=` 简化赋值语句，它同时声明和初始化变量。 - **常量**：使用 `const` 关键字定义常量，不可改变。 2. **Go 的数据类型**： - **基本类型**：包括整型...
Python-内置数据类型.zip
05-27
013.变量的声明_初始化_删除变量_垃圾回收机制 014.链式赋值_系列解包赋值_常量 015.内置数据类型_基本算术运算符 016.整数_不同进制_其他类型转换成整数 017.浮点数_自动转换_强制转换_增强赋值运算符 018.时间表示...
GO语言 复合类型专题
09-16
首先，结构体在GO语言中扮演着聚合数据类型的角色，类似于C语言中的struct。它们由零个或多个不同类型的数据成员组成，每个成员有自己的名称和类型。定义结构体时，每个字段后面不需要分号，如： ```go type Test ...
go代码-学习GO语言对应的结构
07-14
4. **变量（Variable）**：声明和初始化变量，可以使用`var`关键字或者直接在声明时赋值。 5. **常量（Constant）**：使用`const`关键字定义常量，它们在程序运行期间不可修改。 6. **结构体（Struct）**：自定义...
【Go编程基础】03类型与变量
04-09
在Go语言中，我们有基本类型，如整型（int）、浮点型（float32、float64）、布尔型（bool）、字符串（string），以及一些内置的复合类型，如数组、切片（slice）、映射（map）和结构体（struct）。每种类型都有其...
Go语言切片【复制（copy 、append）、剪切、删除（append、copy、len）等操作
wgchen
08-03 815
然而，如果切片 a 的长度为偶数，例如长度为 6，那么中间的元素索引为 2 和 3。然后，使用循环遍历排序后的切片，将不重复的元素移到切片的前部。使用两个 append 函数完成，即先将索引i之后的元素追加到一个长度为 j 的切片后，再将这个切片中的所有元素追加到切片 a 的索引i之后。这个示例展示了如何在切片中移动元素并维护元素的相对位置，以及如何在需要时将新的元素添加到切片的前面。最后，我们通过切片操作。的元素，无需保留切片元素原有的顺序，那么还可以使用下面这种简单的方式进行删除。
Python基础（一）：Python切片，浅拷贝、深拷贝和赋值，排序，Reduce函数
Bin 的专栏
02-20 5045
整理一下Python常用操作，包括Python切片操作、拷贝、排序、Numpy基础等，会持续更新，主要是自己mark用。
python数组切片赋值_列表切片赋值给另一个变量，浅拷贝原理解析
weixin_39811150的博客
12-05 910
把一个列表的切片赋值给另一个变量，Python内部发生了什么？如下所示，创建列表a，然后把它的一段切片赋值给b：>>>>>> a = [2, "Hello", 5, [3,4,7],{1:2}] # 创建列表a>>>>>> a[2, 'Hello', 5, [3, 4, 7], {1: 2}]>>>&g...
make创建切片之后初始化了吗_Golang的切片学习
06-07
在使用 make 创建切片时，可以选择是否对切片进行初始化。如果不进行初始化，则切片中的元素将被赋予其类型的零值，如 int 类型的切片中的元素将被赋值为 0，string 类型的切片中的元素将被赋值为空字符串。如果希望在创建切片时对其进行初始化，可以使用 make 函数的第二个参数指定切片的长度，第三个参数指定切片的容量，然后在括号中使用花括号包裹元素值，如下所示： ``` slice := make([]int, 5, 10) slice = []int{1, 2, 3, 4, 5} ``` 上面的代码中，make 函数创建了一个长度为 5，容量为 10 的 int 类型的切片，并将其赋值给 slice 变量。然后，使用花括号包裹元素值，对切片进行初始化。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

玄德公笔记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值