slice

于 2024-09-02 21:05:30 发布
阅读量343 收藏 3
点赞数 13
分类专栏： Golang 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73337964/article/details/141827960
版权

slic

1.切片通过函数，传的是什么？

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := make([]int, 5, 10)
	printSlice(&s)
	test(s)
}

func test(i []int) {
	printSlice(&i)
}

func printSlice(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v\n", ss)
}

运行结果：

&{Data:824633827808 Len:5 Cap:10}
&{Data:824633827808 Len:5 Cap:10}

2.在函数里面改变切片，函数外的切片会改变吗？

1.切片做参数传递，修改切片内容影响原切片。

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := make([]int, 5)
	case1(s)
	printSliceStruct(&s)
}

func case1(s []int) {
	s[1] = 1
	printSliceStruct(&s)
}

func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824633779184 Len:5 Cap:5}，&[0 1 0 0 0]
&{Data:824633779184 Len:5 Cap:5}，&[0 1 0 0 0]

2.引用参数传递的时候，在另个函数内部扩容了，那么就会分配新的内存地址，再修改这个切片就不会影响原切片了。

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := make([]int, 5)
	case2(s)
	printSliceStruct(&s)
}

func case2(s []int) {
	s = append(s, 0)
	s[1] = 1
	printSliceStruct(&s)
}

func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824633827808 Len:6 Cap:10}，&[0 1 0 0 0 0]
&{Data:824633779184 Len:5 Cap:5}，&[0 0 0 0 0]

总结：传递切片的时候如果切片的修改要反应外部最好使用指针。就是说，如果传值，那么扩容前可以反应到外部，一旦扩容就不再影响外部，传指针的话，无论是否扩容，指针都能追踪上。

以下是这个案例：

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := make([]int, 5)
	//case1(s)
	//case2(s)
	case3(&s)
	printSliceStruct(&s)
}
func case3(s *[]int) {
	*s = append(*s, 0)
	(*s)[1] = 1
	printSliceStruct(s)
}
func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824634425344 Len:6 Cap:10}，&[0 1 0 0 0 0]
&{Data:824634425344 Len:6 Cap:10}，&[0 1 0 0 0 0]

3.截取切片

问：通过:操作得到的新切片和原切片是什么关系？

答：截取切片只是修改了底层数组的起始指向和末尾指向，长度为截取长度，容量为起始指向到末尾指向的大小。用截取切片初始化新切片也是值传递。

4.删除元素

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	s := []int{0, 1, 2, 3, 4}
	printSliceStruct(&s)

	s1 := append(s[:1], s[2:]...)

	printSliceStruct(&s1)
	printSliceStruct(&s)
}

func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824633779184 Len:5 Cap:5}，&[0 1 2 3 4]
&{Data:824633779184 Len:4 Cap:5}，&[0 2 3 4]
&{Data:824633779184 Len:5 Cap:5}，&[0 2 3 4 4]

分析：

切片没有内置的删除函数，而是使用append函数实现删除的功能。

第二个print打印和第三个print打印相比之下，可以知道append函数实现的删除不是真的删除，而是后边的数据向前覆盖，这也导致最后的数据没有改变。

5.新增元素

Golang中新增元素就是使用append函数，有两种情况：

  1. 切片的底层数组容量足够。那么，使用append添加新元素后的切片与元切片共享底层数组。
  2. 切片的底层数组容量不足。那么，append会返回一个新的底层数组。
package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	case1()
}

func case1() {
	sc := make([]int, 3, 5)
	printSliceStruct(&sc)
	s1 := append(sc, 1)
	printSliceStruct(&sc)
	printSliceStruct(&s1)
	s1[0] = 10
	printSliceStruct(&sc)
	printSliceStruct(&s1)
	fmt.Println("--")
	s2 := append(sc, 1, 2, 3, 4, 5, 6)
	printSliceStruct(&sc)
	printSliceStruct(&s2)
	s2[2] = 20
	printSliceStruct(&sc)
	printSliceStruct(&s1)
}

func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824633779184 Len:3 Cap:5}，&[0 0 0]
&{Data:824633779184 Len:3 Cap:5}，&[0 0 0]
&{Data:824633779184 Len:4 Cap:5}，&[0 0 0 1]
&{Data:824633779184 Len:3 Cap:5}，&[10 0 0]
&{Data:824633779184 Len:4 Cap:5}，&[10 0 0 1]
--
&{Data:824633779184 Len:3 Cap:5}，&[10 0 0]
&{Data:824633827808 Len:9 Cap:10}，&[10 0 0 1 2 3 4 5 6]
&{Data:824633779184 Len:3 Cap:5}，&[10 0 0]
&{Data:824633779184 Len:4 Cap:5}，&[10 0 0 1]

6.深度拷贝

Golang中切片的传递，底层数组是浅拷贝（操作原来切片会影响新切片），那么有没有深度拷贝的方法呢？

package main

import (
	"fmt"
	"reflect"
	"unsafe"
)

func main() {
	case1()
}

func case1() {
	var s1 = []int{1, 2, 3, 4}
	var s2 = make([]int, 5)
	copy(s2, s1)//按长度最短的copy
	printSliceStruct(&s1)
	printSliceStruct(&s2)
}

func printSliceStruct(s *[]int) {
	/*
		reflect.SliceHeader：用来描述切片的底层实现
		unsafe.Pointer：是一个通用类型的指针，可以用作不同类型指针相互转换
	*/
	ss := (*reflect.SliceHeader)(unsafe.Pointer(s))
	fmt.Printf("%+v，%v\n", ss, s)
}

输出结果：

&{Data:824633803200 Len:4 Cap:4}，&[1 2 3 4]
&{Data:824633779184 Len:5 Cap:5}，&[1 2 3 4 0]

7.面试题

package main

import (
	"fmt"
)

func main() {
	doAppend := func(s []int) {
		s = append(s, 1)
		printSliceStruct(s)
	}
	s := make([]int, 8, 8)
	doAppend(s[:4])
	printSliceStruct(s)
	doAppend(s)
	printSliceStruct(s)
}

func printSliceStruct(s []int) {
	fmt.Println(s)
	fmt.Printf("len=%d cap=%d\n", len(s), cap(s))
}

输出结果：

[0 0 0 0 1]
len=5 cap=8
[0 0 0 0 1 0 0 0]
len=8 cap=8
[0 0 0 0 1 0 0 0 1]
len=9 cap=16
[0 0 0 0 1 0 0 0]
len=8 cap=8
席万里
关注
  • 13
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
slice 切片
yjwlike的博客
04-21 784
什么是切片 切片就是底层数组的一部分, 修改切片底层数组也会相应改变, 共享一个底层数据的不同切片都会更改, 而且切片的长度灵活多变, 切片是golang中复杂数据类型的一种, 具有长度和容量,分别通过len()和cap()来获取 创建切片 创建切片有三种方式, 一种通过底层数据创建, 一种直接创建切片, 一种是通过make函数 1. 通过底层数组 (需要指定上界下界 example => array[1:4]) 切片的上下界有默认值, 上界为0 , 下界为数组或切片的长度 pac
slice matlab,Matlab画图之slice命令
weixin_31063289的博客
04-02 3685
满意答案7a6o8yb42015.08.12采纳率：55%等级：8已帮助：212人close all;clc;clear;A = [1 2 2 251 3 3 211 4 4 202 5 5 192 6 7 31];x = A(:, 1)';y = A(:, 2)';z = A(:, 3)';s = A(:, 4)';% ...
Slice
weixin_43243916的博客
10-09 1090
Slice简单介绍
slice填充
唐顺才的博客
07-23 3524
区块链底层使用merkle tree，需要对数据([]byte)进行填充等操作。 本文封装了这些操作。 源码结构： root@jack-VirtualBox:~/test/slice# tree . ├── go.mod ├── go.sum ├── main.go ├── misc │ └── util.go └── tt 1 directory, 5 files root@jack-VirtualBox:~/test/slice# main.go package main import .
go 切片Slice
weixin_39171666的博客
05-20 1988
go slice，切片初始化，切片底层数据结构，nil和空切片，位移法(删除指定元素)，删除指定位置 ，切片插入(指定位置插入)，切片过滤，切片头尾插入/删除，扩容策略， 1024，256，内存对齐，map类型切片，打印切片地址，打印切片底层引用数组地址， 切片注意事项，及时将切片底层引用数组释放掉！
slice详解
sinat_34863938的博客
01-27 9178
一、基本原理 1、基本内容 2、小总结 切片之间是不能比较的，我们不能使用==操作符来判断两个切片是否含有全部相等元素。 切片唯一合法的比较操作是和nil比较。 一个nil值的切片并没有底层数组。 一个nil值的切片的长度和容量都是0。但是我们不能说一个长度和容量都是0的切片一定是nil 对一个切片的修改会影响另一个切片的内容 切片的遍历方式和数组是一致的，支持索引遍历和for range遍历。 “操作切片的本质是操作底层数组 ” 3、相关函数 append() 可以为切片动态添加元素。 可以
slice()
qq_42238554的博客
11-18 1943
slice() 作用：返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。原始数组不会被改变。 注意：不会改变原数组 描述： slice 不会修改原数组，只会返回一个浅复制了原数组中的元素的一个新数组。原数组的元素会按照下述规则拷贝： 如果该元素是个对象引用 （不是实际的对象），slice 会拷贝这个对象引用到新的数组里。两个对象...
Go Slice详解
Z451835239的博客
06-09 912
GO slice代表变长的序列，它的底层是数组。一个切片由3部分组成：指针、长度和容量。指针指向底层数组，长度代表slice当前的长度，容量代表底层数组的长度。 换句话说，slice自身维护了一个指针属性，指向它底层数组的某些元素的集合。......
slice截取
qq_59076775的博客
04-06 1282
slice截取
npm-slice2js:Slice到JavaScript编译器的Npm软件包
05-01
slice2js 将Slice文件编译为JavaScript。 安装 npm install slice2js --save-dev 用法 var slice2js = require ( 'slice2js' ) ; 方法 slice2js.compile(args [, options]) 返回一个对象。 args Array 传递给...
西门子S7-1200PLC如何使用Slice方式对变量进行寻址？.docx
07-13
西门子 S7-1200 PLC 使用 Slice 方式对变量进行寻址 Siemens S7-1200 PLC 使用 Slice 方式对变量进行寻址是指在编程中使用 Slice（片段访问）方式来访问和操作变量。Slice 方式可以选择包含所声明变量的特定地址...
Golang中的Slice与数组及区别详解
01-21
在golang中有数组和Slice两种数据结构，Slice是基于数组的实现，是长度动态不固定的数据结构，本质上是一个对数组字序列的引用，提供了对数组的轻量级访问。那么我们今天就给大家详细介绍下Golang中的Slice与数组， ...
js中slice()方法的使用说明
12-11
该Javascript示例解释：这个示例用到了数组(Array)对象的Slice(start,[end])方法，该方法返回一个新数组，包含了源函数从start到 end 所指定的元素，但是不包括end元素，比如a.slice(0,3)；如果 start 为负，将...
Array.prototype.slice.apply的使用方法
12-10
`Array.prototype.slice.apply` 是 JavaScript 中的一个巧妙技巧，用于将 `arguments` 对象转换为一个真正的数组。在JavaScript中，`arguments` 是一个类数组对象，它包含了函数被调用时传入的所有参数，但并不是...
如何完美实现 Go 服务的平滑升级
禅与代码的艺术
08-27 1520
首先通过一个具体的实验，演示了 Go 服务升级是如何引起的请求 502,从而引起平滑升级的必要性。其次，介绍了 Go 语言原生的信号处理框架，为后续讲解平滑升级打下基础。最后，讲解了如何实现 Go 服务的平滑退出以及开源框架 gracehttp。
golang 于 goland 无法运行
m0_63416413的博客
08-27 665
goland中直接删除配置( Edit Configurations )，或者把运行模式从 File 改为 Package 即可解决。命令行 go build -o main.go 等等。command-line-arguements 等等。直接goland运行。
Go语言的编程规则和秘籍
最新发布
一个被知识诅咒的人
09-01 611
本文介绍了Go语言的两条关键编程规则及其相关操作。首先，Go语言要求所有导入的包必须在代码中实际使用，未使用的包会导致编译错误。通过在包名前添加下划线，可以避免此限制但不建议这样做。其次，Go对大括号的使用有严格要求，大括号必须与函数声明在同一行，否则会引发编译错误。此外，本文还介绍了如何下载和管理外部Go包，使用`go get`命令可以轻松获取并编译外部包，并展示了删除中间文件和包的方法。了解并遵循这些规则有助于编写更高质量的Go代码。
初识 Go 语言，环境配置有问题
沐爸的博客
08-26 1043
Go 语言以其简洁的语法、强大的标准库和高效的并发模型而广受欢迎。初识Go，分享一下环境搭建，遇到了一些问题。
slice sampling
11-27
Slice sampling 是一种用于连续分布的贝叶斯推断的马尔可夫链蒙特卡洛方法。它通过在目标分布上进行水平切片来进行采样，而不需要提议分布。slice sampling的优点是其相对简单的实现和能够自适应地调整步长。它通常用于处理高维和复杂的分布，因为它不需要事先指定一个提议分布。 这种方法从一个随机的位置开始，在概率分布上的等高线上将其水平切分。然后在给定这个水平切片上采样。接着，更新参数并移动到下一个切片，直到获得所需数量的样本。因此slice sampling不需要指定提议分布，而是通过动态地切片来自适应地调整步长。 slice sampling的一个重要的应用是在贝叶斯统计推断中，它可以用来估计未知参数的后验分布。它也被用于机器学习和模式识别的问题中，如回归分析、聚类等方面。 总的来说，slice sampling是一种非常有用的概率推断方法，能够适应各种类型的分布，而不需要指定提议分布，因此得到了广泛的应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

席万里

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

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

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

打赏作者

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

抵扣说明：

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

余额充值