Go 언어 조각을 해석하는 방법

青灯夜游
풀어 주다: 2022-12-22 12:19:35
원래의
5629명이 탐색했습니다.

Go 언어에서 슬라이스는 배열의 연속 조각에 대한 참조이므로 슬라이스는 참조 유형입니다. 이 조각은 전체 배열이 될 수도 있고 시작과 문자열로 식별되는 일부 항목의 하위 항목이 될 수도 있습니다. 끝 인덱스 설정. 슬라이스의 메모리 분포는 연속적이므로 슬라이스는 가변 크기의 배열로 처리될 수 있습니다. 슬라이스는 기본 배열에 대한 포인터, 슬라이스가 액세스하는 요소 수(즉, 길이), 슬라이스가 확장할 수 있는 요소 수(즉, 용량)의 세 가지 필드가 있는 데이터 구조입니다.

Go 언어 조각을 해석하는 방법

이 튜토리얼의 운영 환경: Windows 7 시스템, GO 버전 1.18, Dell G3 컴퓨터.

슬라이스는 배열의 연속 조각에 대한 참조이므로 슬라이스는 참조 유형입니다(C/C++의 배열 유형 또는 Python의 목록 유형과 더 유사함). 이 조각은 전체 배열이 될 수 있습니다. , 시작 및 끝 인덱스로 식별되는 일부 항목의 하위 집합일 수도 있습니다. 끝 인덱스로 식별되는 항목은 조각에 포함되지 않습니다.

Go 언어의 슬라이스 내부 구조에는 주소, 크기 및 용량이 포함됩니다. 슬라이스는 일반적으로 데이터 세트를 빠르게 조작하는 데 사용됩니다. 데이터 세트를 케이크 자르기에 비유하면 슬라이스는 원하는 "조각"입니다. 절단 공정 시작 위치(슬라이스의 시작 위치)와 절단 크기(슬라이스의 크기)를 포함하여 용량은 아래 그림과 같이 슬라이스를 담는 포켓의 크기로 이해할 수 있습니다.

Go 언어 조각을 해석하는 방법
그림: 슬라이스 구조 및 메모리 할당

슬라이스의 메모리 분포는 연속적이므로 슬라이스를 가변 크기의 배열로 처리할 수 있습니다.

슬라이스에는 세 개의 필드가 있는 데이터 구조가 있습니다. 이러한 데이터 구조에는 Go 언어가 기본 배열에서 작동하는 데 필요한 메타데이터가 포함되어 있습니다. 이 세 필드는 기본 배열에 대한 포인터이며, 슬라이스에서 액세스하는 요소 수입니다. 즉, 길이) 및 확장할 요소 수(예: 용량)입니다. 길이와 용량의 차이에 대해서는 나중에 자세히 설명하겠습니다.

Go 언어 조각을 해석하는 방법

배열 또는 슬라이스에서 새 슬라이스 생성

슬라이스는 기본적으로 배열 또는 슬라이스 자체일 수 있는 연속 메모리 영역을 가리킵니다.

연속 메모리 영역에서 슬라이스를 생성하는 것은 일반적인 작업입니다. 형식은 다음과 같습니다.

slice [开始位置 : 结束位置]
로그인 후 복사

구문은 다음과 같습니다.

  • 슬라이스: 대상 슬라이스 개체를 나타냅니다. 대상 슬라이스 객체의 인덱스

  • 끝 위치: 대상 슬라이스의 끝 인덱스에 해당합니다.

  • 배열에서 슬라이스를 생성합니다. 코드는 다음과 같습니다.

    var a  = [3]int{1, 2, 3}
    fmt.Println(a, a[1:2])
    로그인 후 복사
  • 여기서 a는 3개의 정수 요소가 있는 배열이고 1~3의 값으로 초기화됩니다. a[1:2]를 사용하여 새 슬라이스, 코드 실행 결과는 다음과 같습니다.
[1 2 3]  [2]
로그인 후 복사

여기서 [2]는 [1:2] 슬라이싱 작업의 결과입니다.

배열 또는 슬라이스에서 새 슬라이스를 생성하는 데는 다음과 같은 특징이 있습니다.

제거되는 요소 수는 다음과 같습니다. 끝 위치 - 시작 위치

  • 제거된 요소에는 해당 인덱스가 포함되지 않습니다. 끝 위치이며 슬라이스의 마지막 요소는 슬라이스 [len(slice)] Get을 사용합니다.

  • 기본 시작 위치를 사용하는 경우 연속 영역의 처음부터 끝까지를 의미합니다. 기본 끝 위치가 사용된다는 것은 시작 위치부터 전체 연속 영역의 끝까지를 의미합니다.

  • 둘 다 동시에 기본값으로 설정되면 슬라이스 자체와 동일합니다.

  • 0이면 빈 슬라이스와 동일하며 일반적으로 슬라이스 재설정에 사용됩니다.

  • 인덱스 위치에 따라 슬라이스 요소 값을 가져올 때 값 범위는 (0~len(slice)-1)입니다. 제한을 초과하면 슬라이스 생성 시 런타임 오류가 보고됩니다. 끝 위치는 len(slice)에 채워질 수 있지만 오류는 보고되지 않습니다.

  • 예제를 통해 슬라이싱의 특징을 알아봅시다.
  • 1) 지정된 범위에서 슬라이스 생성

슬라이스와 배열은 분리할 수 없습니다. 배열을 사무실 건물로 이해하면 슬라이스는 사용자에게 서로 다른 연속 층을 임대하는 것입니다. 그리고 최종 층에서 이 프로세스는 슬라이스를 생성합니다.

var highRiseBuilding [30]int
for i := 0; i < 30; i++ {
        highRiseBuilding[i] = i + 1
}
// 区间
fmt.Println(highRiseBuilding[10:15])
// 中间到尾部的所有元素
fmt.Println(highRiseBuilding[20:])
// 开头到中间指定位置的所有元素
fmt.Println(highRiseBuilding[:2])
로그인 후 복사

코드 출력은 다음과 같습니다.

코드에는 30층짜리 고층 건물이 구성됩니다. 서로 다른 독립 층을 나타내는 1부터 30까지의 배열 범위 중 출력 결과는 임대 및 판매 계획이 다릅니다.

코드 설명은 다음과 같습니다.

Go 언어 조각을 해석하는 방법8라인, 간격층을 임대해 보세요.

11호선, 20층 이상 임대.

  • 14호선, 2층 이하 임대층, 주로 상업상점.

切片有点像C语言里的指针,指针可以做运算,但代价是内存操作越界,切片在指针的基础上增加了大小,约束了切片对应的内存区域,切片使用中无法对切片内部的地址和大小进行手动调整,因此切片比指针更安全、强大。

2) 表示原有的切片

生成切片的格式中,当开始和结束位置都被忽略时,生成的切片将表示和原切片一致的切片,并且生成的切片与原切片在数据内容上也是一致的,代码如下:

a := []int{1, 2, 3}
fmt.Println(a[:])
로그인 후 복사

a 是一个拥有 3 个元素的切片,将 a 切片使用 a[:] 进行操作后,得到的切片与 a 切片一致,代码输出如下:

[1 2 3]
로그인 후 복사

3) 重置切片,清空拥有的元素

把切片的开始和结束位置都设为 0 时,生成的切片将变空,代码如下:

a := []int{1, 2, 3}
fmt.Println(a[0:0])
로그인 후 복사

代码输出如下:

Go 언어 조각을 해석하는 방법

直接声明新的切片

除了可以从原有的数组或者切片中生成切片外,也可以声明一个新的切片,每一种类型都可以拥有其切片类型,表示多个相同类型元素的连续集合,因此切片类型也可以被声明,切片类型声明格式如下:

var name []Type
로그인 후 복사

其中 name 表示切片的变量名,Type 表示切片对应的元素类型。

下面代码展示了切片声明的使用过程:

// 声明字符串切片
var strList []string

// 声明整型切片
var numList []int

// 声明一个空切片
var numListEmpty = []int{}

// 输出3个切片
fmt.Println(strList, numList, numListEmpty)

// 输出3个切片大小
fmt.Println(len(strList), len(numList), len(numListEmpty))

// 切片判定空的结果
fmt.Println(strList == nil)
fmt.Println(numList == nil)
fmt.Println(numListEmpty == nil)
로그인 후 복사

代码输出结果:

Go 언어 조각을 해석하는 방법

代码说明如下:

  • 第 2 行,声明一个字符串切片,切片中拥有多个字符串。

  • 第 5 行,声明一个整型切片,切片中拥有多个整型数值。

  • 第 8 行,将 numListEmpty 声明为一个整型切片,本来会在{}中填充切片的初始化元素,这里没有填充,所以切片是空的,但是此时的 numListEmpty 已经被分配了内存,只是还没有元素。

  • 第 11 行,切片均没有任何元素,3 个切片输出元素内容均为空。

  • 第 14 行,没有对切片进行任何操作,strList 和 numList 没有指向任何数组或者其他切片。

  • 第 17 行和第 18 行,声明但未使用的切片的默认值是 nil,strList 和 numList 也是 nil,所以和 nil 比较的结果是 true。

  • 第 19 行,numListEmpty 已经被分配到了内存,但没有元素,因此和 nil 比较时是 false。

切片是动态结构,只能与 nil 判定相等,不能互相判定相等。声明新的切片后,可以使用 append() 函数向切片中添加元素。

使用 make() 函数构造切片

如果需要动态地创建一个切片,可以使用 make() 内建函数,格式如下:

make( []Type, size, cap )
로그인 후 복사

其中 Type 是指切片的元素类型,size 指的是为这个类型分配多少个元素,cap 为预分配的元素数量,这个值设定后不影响 size,只是能提前分配空间,降低多次分配空间造成的性能问题。

示例如下:

a := make([]int, 2)
b := make([]int, 2, 10)

fmt.Println(a, b)
fmt.Println(len(a), len(b))
로그인 후 복사

代码输出如下:

Go 언어 조각을 해석하는 방법

其中 a 和 b 均是预分配 2 个元素的切片,只是 b 的内部存储空间已经分配了 10 个,但实际使用了 2 个元素。

容量不会影响当前的元素个数,因此 a 和 b 取 len 都是 2。

温馨提示

使用 make() 函数生成的切片一定发生了内存分配操作,但给定开始与结束位置(包括切片复位)的切片只是将新的切片结构指向已经分配好的内存区域,设定开始与结束位置,不会发生内存分配操作。

切片的使用

切片的使用和数组是一模一样的:

func main() {
    slice1 := []int{1,2,3,4}
    fmt.Println(slice1[1])
}
로그인 후 복사

切片创建切片

切片之所以称为切片,是因为它只是对应底层数组的一部分,看如下所示代码:

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]
}
로그인 후 복사

为了说明上面的代码,我们看下面的这张图:
picture alt

第一个切片slice 能够看到底层数组全部5 个元素的容量,不过之后的newSlice 就看不到。对于newSlice,底层数组的容量只有4 个元素。newSlice 无法访问到它所指向的底层数组的第一个元素之前的部分。所以,对newSlice 来说,之前的那些元素就是不存在的。

需要记住的是,现在两个切片共享同一个底层数组。如果一个切片修改了该底层数组的共享部分,另一个切片也能感知到,运行下面的代码:

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]

    slice[1] = 200
    fmt.Println(newSlice[0])
}
로그인 후 복사

运行结果如下:

200
로그인 후 복사

切片只能访问到其长度内的元素。试图访问超出其长度的元素将会导致语言运行时异常,比如对上面的newSlice,他只能访问索引为1和2的元素(不包括3),比如:

func main() {
    slice := []int{10, 20, 30, 40, 50}
    newSlice := slice[1:3]

    fmt.Println(newSlice[3])
}
로그인 후 복사

运行代码,控制台会报错:

panic: runtime error: index out of range

goroutine 1 [running]:
main.main()
    E:/go-source/go-arr/main.go:20 +0x11
로그인 후 복사

子切片的容量

我们知道切片可以再生出切片,那么子切片的容量为多大呢?我们来测试一下:

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    fmt.Println(cap(slice1))
}
로그인 후 복사

控制台打印结果为:

9
9
로그인 후 복사

从结果我们可以推测,子切片的容量为底层数组的长度减去切片在底层数组的开始偏移量,比如在上面的例子中,slice1的偏移值为1,底层数组的大小为10,所以两者相减,得到结果9。

向切片中追加元素

go提供了append方法用于向切片中追加元素,如下所示:

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    slice2 := append(slice1, 1)
    slice2[0] = 10001
    fmt.Println(slice)
    fmt.Println(cap(slice2))
}
로그인 후 복사

输出结果如下:

[0 10001]
9
로그인 후 복사

此时slice,slice1,slice2共享底层数组,所以只要一个切片改变了某一个索引的值,会影响到所有的切片,还有一点值得注意,就是slice2的容量为9,记住这个值。

为了说明问题,我把例子改为如下所示代码:

func main() {
    slice := make([]int, 2, 10)
    slice1 := slice[1:2]
    slice2 := append(slice1, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2 = append(slice2, 1)
    slice2[0] = 10001
    fmt.Println(slice)
    fmt.Println(slice1)
    fmt.Println(cap(slice2))
}
로그인 후 복사

此时我们再次打印结果,神奇的事情出现了:

[0 0]
[0]
18
로그인 후 복사

虽然我们改变0位置的值,但是并没有影响到原来的slice和slice1,这是为啥呢?我们知道原始的slice2对应的底层数组的容量为9,经过我们一系列的append操作,原始的底层数组已经无法容纳更多的元素了,此时Go会分配另外一块内存,把原始切片从位置1开始的内存复制到新的内存地址中,也就是说现在的slice2切片对应的底层数组和slice切片对应的底层数组完全不是在同一个内存地址,所以当你此时更改slice2中的元素时,对slice已经来说,一点儿关系都没有。

另外根据上面的打印结果,你也应该猜到了,当切片容量不足的时候,Go会以原始切片容量的2倍建立新的切片,在我们的例子中2*9=18,就是这么粗暴。

如何创建子切片时指定容量

在前面的例子中,我们创建子切片的时候,没有指定子切片的容量,所以子切片的容量和我们上面讨论的计算子切片的容量方法相等,那么我们如何手动指定子切片的容量呢?

在这里我们借用《Go实战》中的一个例子:

func main() {
    source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
    slice := source[2:3:4]
    fmt.Println(cap(slice))
}
로그인 후 복사

如果你仔细看的话,上面的子切片的生成方式和普通的切片有所不同,[]里面有三个部分组成,,第一个值表示新切片开始元素的索引位置,这个例子中是2。第二个值表示开始的索引位置(2)加上希望包括的元素的个数(1),2+1 的结果是3,所以第二个值就是3。为了设置容量,从索引位置2 开始,加上希望容量中包含的元素的个数(2),就得到了第三个值4。所以这个新的切片slice的长度为1,容量为2。还有一点大家一定要记住,你指定的容量不能比原先的容量,这里就是source的容量大,加入我们这样设置的话:

func main() {
    source := []string{"Apple", "Orange", "Plum", "Banana", "Grape"}
    slice := source[2:3:10]
    fmt.Println(cap(slice))
}
로그인 후 복사

运行结果如下,报错了,哈哈:

panic: runtime error: slice bounds out of range [::10] with capacity 5

goroutine 1 [running]:
main.main()
    E:/learn-go/slice/main.go:7 +0x1d
로그인 후 복사

迭代切片

关于如何迭代切片,我们可以使用range配置来使用,如下:

func main() {
    slice:=[]int{1,2,4,6}
    for _, value:=range slice{
        fmt.Println(value)
    }
}
로그인 후 복사

关于迭代切片,大家有一点需要注意,就以上面的例子为例,value只是slice中元素的副本,为啥呢?我们来验证这一点:

func main() {
    slice:=[]int{1,2,4,6}
    for index, value:=range slice{
        fmt.Printf("value[%d],indexAddr:[%X],valueAddr:[%X],sliceAddr:[%X]\n",value,&index,&value,&slice[index])
    }
}
로그인 후 복사

控制台打印结果如下:

value[1],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010380]
value[2],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010388]
value[4],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010390]
value[6],indexAddr:[C00000A0B8],valueAddr:[C00000A0D0],sliceAddr:[C000010398]
로그인 후 복사

从上面的结果可以看到index和value的地址始终是不变的,所以它们始终是同一个变量,只是变量引用地址的内容发生了变化,从而验证迭代的时候,只能是切片元素的副本,最后看看sliceAddr代表的地址相隔8个字节,因为在64位系统上,每一个int类型的大小为8个字节。

函数间传递切片

函数间传递切片,也是以值的方式传递的,但是你还记得这篇博文开头给出的切片的布局么?
picture alt
切片由三个部分组成,包括指向底层数组的指针,当前切片的长度,当前切片的容量,所以切片本身并不大,我们来测试一个切片的大小:

func main() {
    slice:=[]int{1,2,4,6}
    fmt.Println(unsafe.Sizeof(slice))
}
로그인 후 복사

测试结果为:

24
로그인 후 복사

也就是这个slice切片的大小为24字节,所以当切片作为参数传递的时候,几乎没有性能开销,还有很重要的一点,参数生成的副本的地址指针和原始切片的地址指针是一样的,因此,如果你在函数里面修改了切片,那么会影响到原始的切片,我们来验证这点:

func main() {
    slice:=[]int{1,2,4,6}
    handleSlice(slice)
    fmt.Println(slice)
}
로그인 후 복사

打印结果:

[100 2 4 6]
로그인 후 복사

【相关推荐:Go视频教程编程教学

위 내용은 Go 언어 조각을 해석하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!

관련 라벨:
원천:php.cn
본 웹사이트의 성명
본 글의 내용은 네티즌들의 자발적인 기여로 작성되었으며, 저작권은 원저작자에게 있습니다. 본 사이트는 이에 상응하는 법적 책임을 지지 않습니다. 표절이나 침해가 의심되는 콘텐츠를 발견한 경우 admin@php.cn으로 문의하세요.
최신 이슈
인기 튜토리얼
더>
최신 다운로드
더>
웹 효과
웹사이트 소스 코드
웹사이트 자료
프론트엔드 템플릿