在 Go 中使用切片的容量和长度的技巧

Go 学习笔记(11)— 切片定义、切片初始化、数组和切片差异、字符串和切片转换、len()、cap()、空 nil 切片、append()、copy() 函数、删除切片元素 1. 切片的定义 Go 语言切片是对数组的抽象。Go中提供了一种灵活,功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的,可以追加元素,在追加时可能使切片的容量增大。 2. 定义切片 声明一个未指定大小的数组来定义切片: var identifier []type 切片不需要说明长度。 或使用make()函数来创建切片: var slice1 []type = make([]... 阅读详情


快速测试 - 下面的代码输出什么?

vals := make([]int, 5)   for i := 0; i < 5; i++ {    vals = append(vals, i) } fmt.Println(vals)  

如果你猜测的是 [0 0 0 0 0 0 1 2 3 4],那你是对的。

如果你在测试中做错了,你也不用担心。这是在过渡到 Go 语言的过程中相当常见的错误,在这篇文章中,我们将说明为什么输出不是你预期的,以及如何利用 Go 的细微差别来使你的代码更有效率。

切片 vs 数组

在 Go 中同时有数组(array)和切片(slice)。这可能令人困惑,但一旦你习惯了,你会喜欢上它。请相信我。

切片和数组之间存在许多差异,但我们要在本文中重点介绍的内容是数组的大小是其类型的一部分,而切片可以具有动态大小,因为它们是围绕数组的封装。

这在实践中意味着什么?那么假设我们有数组 val a [10]int。该数组具有固定大小,且无法更改。如果我们调用 len(a),它总是返回 10,因为这个大小是类型的一部分。因此,如果你突然需要在数组中超过 10 个项,则必须创建一个完全不同类型的新对象,例如 val b [11]int,然后将所有值从 a 复制到 b。

在特定情况下,含有集合大小的数组是有价值的,但一般而言,这不是开发人员想要的。相反,他们希望在 Go 中使用类似于数组的东西,但是随着时间的推移,它们能够随时增长。一个粗略的方式是创建一个比它需要大得多的数组,然后将数组的一个子集视为数组。下面的代码是个例子。

var vals [20]int   for i := 0; i < 5; i++ {    vals[i] = i * i } subsetLen := 5 fmt.Println("The subset of our array has a length of:", subsetLen) // Add a new item to our array vals[subsetLen] = 123   subsetLen++   fmt.Println("The subset of our array has a length of:", subsetLen)  

在代码中,我们有一个长度为 20 的数组,但是由于我们只使用一个子集,代码中我们可以假定数组的长度是 5,然后在我们向数组中添加一个新的项之后是 6。

这是(非常粗略地说)切片是如何工作的。它们包含一个具有设置大小的数组,就像我们前面的例子中的数组一样,它的大小为 20。

它们还跟踪程序中使用的数组的子集 - 这就是 append 属性,它类似于上一个例子中的 subsetLen 变量。

最后,一个切片还有一个 capacity,类似于前面例子中我们的数组的总长度(20)。这是很有用的,因为它会告诉你的子集在无法容纳切片数组之前可以增长的大小。当发生这种情况时,需要分配一个新的数组,但所有这些逻辑都隐藏在 append 函数的后面。

简而言之,使用 append 函数组合切片给我们一个非常类似于数组的类型,但随着时间的推移,它可以处理更多的元素。

我们再来看一下前面的例子,但是这次我们将使用切片而不是数组。

var vals []int   for i := 0; i < 5; i++ {    vals = append(vals, i)  fmt.Println("The length of our slice is:", len(vals))  fmt.Println("The capacity of our slice is:", cap(vals)) } // Add a new item to our array vals = append(vals, 123)   fmt.Println("The length of our slice is:", len(vals))   fmt.Println("The capacity of our slice is:", cap(vals)) // Accessing items is the same as an array fmt.Println(vals[5])   fmt.Println(vals[2])  

我们仍然可以像数组一样访问我们的切片中的元素,但是通过使用切片和 append 函数,我们不再需要考虑背后数组的大小。我们仍然可以通过使用 len 和 cap 函数来计算出这些东西,但是我们不用担心太多。简洁吧?

回到测试

记住这点,让我们回顾前面的测试,看下什么出错了。

vals := make([]int, 5)   for i := 0; i < 5; i++ {    vals = append(vals, i) } fmt.Println(vals)  

当调用 make 时,我们允许最多传入 3 个参数。第一个是我们分配的类型,第二个是类型的“长度”,第三个是类型的“容量”(这个参数是可选的)。

通过传递参数 make([]int, 5),我们告诉程序我们要创建一个长度为 5 的切片,在这种情况下,默认的容量与长度相同 - 本例中是 5。

虽然这可能看起来像我们想要的那样,这里的重要区别是我们告诉我们的切片,我们要将“长度”和“容量”设置为 5,假设你想要在初始的 5 个元素之后添加新的元素,我们接着调用 append 函数,那么它会增加容量的大小,并且会在切片的最后添加新的元素。

如果在代码中添加一条 Println() 语句,你可以看到容量的变化。

vals := make([]int, 5)   fmt.Println("Capacity was:", cap(vals))   for i := 0; i < 5; i++ {    vals = append(vals, i)  fmt.Println("Capacity is now:", cap(vals)) } fmt.Println(vals)  

最后,我们最终得到 [0 0 0 0 0 0 1 2 3 4] 的输出而不是希望的 [0 1 2 3 4]。

如何修复它呢?好的,这有几种方法,我们将讲解两种,你可以选取任何一种在你的场景中最有用的方法。

直接使用索引写入而不是 append

第一种修复是保留 make 调用不变,并且显式地使用索引来设置每个元素。这样,我们就得到如下的代码:

vals := make([]int, 5)   for i := 0; i < 5; i++ {    vals[i] = i } fmt.Println(vals)  

在这种情况下,我们设置的值恰好与我们要使用的索引相同,但是你也可以独立跟踪索引。

比如,如果你想要获取 map 的键,你可以使用下面的代码。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog": struct{}{},    "cat": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, len(m))  i := 0  for key := range m {    ret[i] = key    i++  }  return ret }

这样做很好,因为我们知道我们返回的切片的长度将与 map 的长度相同,因此我们可以用该长度初始化我们的切片,然后将每个元素分配到适当的索引中。这种方法的缺点是我们必须跟踪 i,以便了解每个索引要设置的值。

这就让我们引出了第二种方法……

使用 0 作为你的长度并指定容量

与其跟踪我们要添加的值的索引,我们可以更新我们的 make 调用,并在切片类型之后提供两个参数。第一个,我们的新切片的长度将被设置为 0,因为我们还没有添加任何新的元素到切片中。第二个,我们新切片的容量将被设置为 map 参数的长度,因为我们知道我们的切片最终会添加许多字符串。

这会如前面的例子那样仍旧会在背后构建相同的数组,但是现在当我们调用 append 时,它会将它们放在切片开始处,因为切片的长度是 0。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog": struct{}{},    "cat": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, 0, len(m))  for key := range m {    ret = append(ret, key)  }  return ret }

如果 append 处理它,为什么我们还要担心容量呢?

接下来你可能会问:“如果 append 函数可以为我增加切片的容量,那我们为什么要告诉程序容量呢?”

事实是,在大多数情况下,你不必担心这太多。如果它使你的代码变得更复杂,只需用 var vals []int 初始化你的切片,然后让 append 函数处理接下来的事。

但这种情况是不同的。它并不是声明容量困难的例子,实际上这很容易确定我们的切片的最后容量,因为我们知道它将直接映射到提供的 map 中。因此,当我们初始化它时,我们可以声明切片的容量,并免于让我们的程序执行不必要的内存分配。

如果要查看额外的内存分配情况,请在 Go Playground 上运行以下代码。每次增加容量,程序都需要做一次内存分配。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog":       struct{}{},    "cat":       struct{}{},    "mouse":     struct{}{},    "wolf":      struct{}{},    "alligator": struct{}{},  })) } func keys(m map[string]struct{}) []string {    var ret []string  fmt.Println(cap(ret))  for key := range m {    ret = append(ret, key)    fmt.Println(cap(ret))  }  return ret }

现在将此与相同的代码进行比较,但具有预定义的容量。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog":       struct{}{},    "cat":       struct{}{},    "mouse":     struct{}{},    "wolf":      struct{}{},    "alligator": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, 0, len(m))  fmt.Println(cap(ret))  for key := range m {    ret = append(ret, key)    fmt.Println(cap(ret))  }  return ret }

在第一个代码示例中,我们的容量从 0 开始,然后增加到 1、 2、 4, 最后是 8,这意味着我们不得不分配 5 次数组,最后一个容纳我们切片的数组的容量是 8,这比我们最终需要的要大。

另一方面,我们的第二个例子开始和结束都是相同的容量(5),它只需要在 keys() 函数的开头分配一次。我们还避免了浪费任何额外的内存,并返回一个能放下这个数组的完美大小的切片。

不要过分优化

如前所述,我通常不鼓励任何人做这样的小优化,但如果最后大小的效果真的很明显,那么我强烈建议你尝试为切片设置适当的容量或长度。

这不仅有助于提高程序的性能,还可以通过明确说明输入的大小和输出的大小之间的关系来帮助澄清你的代码。

总结

本文并不是对切片或数组之间差异的详细讨论,而是简要介绍了容量和长度如何影响切片,以及它们在方案中的用途。


本文转载自:http://www.linuxprobe.com/slice-size-length.html

快速测试 - 下面的代码输出什么?

vals := make([]int, 5)   for i := 0; i &lt; 5; i++ {    vals = append(vals, i) } fmt.Println(vals)  

如果你猜测的是 [0 0 0 0 0 0 1 2 3 4],那你是对的。

如果你在测试中做错了,你也不用担心。这是在过渡到 Go 语言的过程中相当常见的错误,在这篇文章中,我们将说明为什么输出不是你预期的,以及如何利用 Go 的细微差别来使你的代码更有效率。

切片 vs 数组

在 Go 中同时有数组(array)和切片(slice)。这可能令人困惑,但一旦你习惯了,你会喜欢上它。请相信我。

切片和数组之间存在许多差异,但我们要在本文中重点介绍的内容是数组的大小是其类型的一部分,而切片可以具有动态大小,因为它们是围绕数组的封装。

这在实践中意味着什么?那么假设我们有数组 val a [10]int。该数组具有固定大小,且无法更改。如果我们调用 len(a),它总是返回 10,因为这个大小是类型的一部分。因此,如果你突然需要在数组中超过 10 个项,则必须创建一个完全不同类型的新对象,例如 val b [11]int,然后将所有值从 a 复制到 b。

在特定情况下,含有集合大小的数组是有价值的,但一般而言,这不是开发人员想要的。相反,他们希望在 Go 中使用类似于数组的东西,但是随着时间的推移,它们能够随时增长。一个粗略的方式是创建一个比它需要大得多的数组,然后将数组的一个子集视为数组。下面的代码是个例子。

var vals [20]int   for i := 0; i < 5; i++ {    vals[i] = i * i } subsetLen := 5 fmt.Println("The subset of our array has a length of:", subsetLen) // Add a new item to our array vals[subsetLen] = 123   subsetLen++   fmt.Println("The subset of our array has a length of:", subsetLen)  

在代码中,我们有一个长度为 20 的数组,但是由于我们只使用一个子集,代码中我们可以假定数组的长度是 5,然后在我们向数组中添加一个新的项之后是 6。

这是(非常粗略地说)切片是如何工作的。它们包含一个具有设置大小的数组,就像我们前面的例子中的数组一样,它的大小为 20。

它们还跟踪程序中使用的数组的子集 - 这就是 append 属性,它类似于上一个例子中的 subsetLen 变量。

最后,一个切片还有一个 capacity,类似于前面例子中我们的数组的总长度(20)。这是很有用的,因为它会告诉你的子集在无法容纳切片数组之前可以增长的大小。当发生这种情况时,需要分配一个新的数组,但所有这些逻辑都隐藏在 append 函数的后面。

简而言之,使用 append 函数组合切片给我们一个非常类似于数组的类型,但随着时间的推移,它可以处理更多的元素。

我们再来看一下前面的例子,但是这次我们将使用切片而不是数组。

var vals []int   for i := 0; i < 5; i++ {    vals = append(vals, i)  fmt.Println("The length of our slice is:", len(vals))  fmt.Println("The capacity of our slice is:", cap(vals)) } // Add a new item to our array vals = append(vals, 123)   fmt.Println("The length of our slice is:", len(vals))   fmt.Println("The capacity of our slice is:", cap(vals)) // Accessing items is the same as an array fmt.Println(vals[5])   fmt.Println(vals[2])  

我们仍然可以像数组一样访问我们的切片中的元素,但是通过使用切片和 append 函数,我们不再需要考虑背后数组的大小。我们仍然可以通过使用 len 和 cap 函数来计算出这些东西,但是我们不用担心太多。简洁吧?

回到测试

记住这点,让我们回顾前面的测试,看下什么出错了。

vals := make([]int, 5)   for i := 0; i < 5; i++ {    vals = append(vals, i) } fmt.Println(vals)  

当调用 make 时,我们允许最多传入 3 个参数。第一个是我们分配的类型,第二个是类型的“长度”,第三个是类型的“容量”(这个参数是可选的)。

通过传递参数 make([]int, 5),我们告诉程序我们要创建一个长度为 5 的切片,在这种情况下,默认的容量与长度相同 - 本例中是 5。

虽然这可能看起来像我们想要的那样,这里的重要区别是我们告诉我们的切片,我们要将“长度”和“容量”设置为 5,假设你想要在初始的 5 个元素之后添加新的元素,我们接着调用 append 函数,那么它会增加容量的大小,并且会在切片的最后添加新的元素。

如果在代码中添加一条 Println() 语句,你可以看到容量的变化。

vals := make([]int, 5)   fmt.Println("Capacity was:", cap(vals))   for i := 0; i < 5; i++ {    vals = append(vals, i)  fmt.Println("Capacity is now:", cap(vals)) } fmt.Println(vals)  

最后,我们最终得到 [0 0 0 0 0 0 1 2 3 4] 的输出而不是希望的 [0 1 2 3 4]。

如何修复它呢?好的,这有几种方法,我们将讲解两种,你可以选取任何一种在你的场景中最有用的方法。

直接使用索引写入而不是 append

第一种修复是保留 make 调用不变,并且显式地使用索引来设置每个元素。这样,我们就得到如下的代码:

vals := make([]int, 5)   for i := 0; i < 5; i++ {    vals[i] = i } fmt.Println(vals)  

在这种情况下,我们设置的值恰好与我们要使用的索引相同,但是你也可以独立跟踪索引。

比如,如果你想要获取 map 的键,你可以使用下面的代码。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog": struct{}{},    "cat": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, len(m))  i := 0  for key := range m {    ret[i] = key    i++  }  return ret }

这样做很好,因为我们知道我们返回的切片的长度将与 map 的长度相同,因此我们可以用该长度初始化我们的切片,然后将每个元素分配到适当的索引中。这种方法的缺点是我们必须跟踪 i,以便了解每个索引要设置的值。

这就让我们引出了第二种方法……

使用 0 作为你的长度并指定容量

与其跟踪我们要添加的值的索引,我们可以更新我们的 make 调用,并在切片类型之后提供两个参数。第一个,我们的新切片的长度将被设置为 0,因为我们还没有添加任何新的元素到切片中。第二个,我们新切片的容量将被设置为 map 参数的长度,因为我们知道我们的切片最终会添加许多字符串。

这会如前面的例子那样仍旧会在背后构建相同的数组,但是现在当我们调用 append 时,它会将它们放在切片开始处,因为切片的长度是 0。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog": struct{}{},    "cat": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, 0, len(m))  for key := range m {    ret = append(ret, key)  }  return ret }

如果 append 处理它,为什么我们还要担心容量呢?

接下来你可能会问:“如果 append 函数可以为我增加切片的容量,那我们为什么要告诉程序容量呢?”

事实是,在大多数情况下,你不必担心这太多。如果它使你的代码变得更复杂,只需用 var vals []int 初始化你的切片,然后让 append 函数处理接下来的事。

但这种情况是不同的。它并不是声明容量困难的例子,实际上这很容易确定我们的切片的最后容量,因为我们知道它将直接映射到提供的 map 中。因此,当我们初始化它时,我们可以声明切片的容量,并免于让我们的程序执行不必要的内存分配。

如果要查看额外的内存分配情况,请在 Go Playground 上运行以下代码。每次增加容量,程序都需要做一次内存分配。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog":       struct{}{},    "cat":       struct{}{},    "mouse":     struct{}{},    "wolf":      struct{}{},    "alligator": struct{}{},  })) } func keys(m map[string]struct{}) []string {    var ret []string  fmt.Println(cap(ret))  for key := range m {    ret = append(ret, key)    fmt.Println(cap(ret))  }  return ret }

现在将此与相同的代码进行比较,但具有预定义的容量。

package main import "fmt" func main() {    fmt.Println(keys(map[string]struct{}{    "dog":       struct{}{},    "cat":       struct{}{},    "mouse":     struct{}{},    "wolf":      struct{}{},    "alligator": struct{}{},  })) } func keys(m map[string]struct{}) []string {    ret := make([]string, 0, len(m))  fmt.Println(cap(ret))  for key := range m {    ret = append(ret, key)    fmt.Println(cap(ret))  }  return ret }

在第一个代码示例中,我们的容量从 0 开始,然后增加到 1、 2、 4, 最后是 8,这意味着我们不得不分配 5 次数组,最后一个容纳我们切片的数组的容量是 8,这比我们最终需要的要大。

另一方面,我们的第二个例子开始和结束都是相同的容量(5),它只需要在 keys() 函数的开头分配一次。我们还避免了浪费任何额外的内存,并返回一个能放下这个数组的完美大小的切片。

不要过分优化

如前所述,我通常不鼓励任何人做这样的小优化,但如果最后大小的效果真的很明显,那么我强烈建议你尝试为切片设置适当的容量或长度。

这不仅有助于提高程序的性能,还可以通过明确说明输入的大小和输出的大小之间的关系来帮助澄清你的代码。

总结

本文并不是对切片或数组之间差异的详细讨论,而是简要介绍了容量和长度如何影响切片,以及它们在方案中的用途。


本文转载自:http://www.linuxprobe.com/slice-size-length.html

Go语言获取数组长度的方法 主要介绍了Go语言获取数组长度的方法,实例分析了len函数的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下 立即下载

相关推荐

Creo报许可证错误License request failed for feature的解决方案

有些朋友用了一段时间打开creo软件,出现icense request failed for feature”错误,这个是Creo许可证出现了问题,一般是许可证文件无效或是已过期,导致Creo软件通信出现故障,就会出现Creo License request failed for feature, Requsesting CreoPMA_SSQ ,Run ptcstatus.bat server status。第三步:键盘按win+R,在运行窗口里输入:cmd,然后点确定。第八步:点击系统,找到系统信息。

Q82556499的博客 3万+

Go 语言切片

定义切片 var identifier []type    切片不需要说明长度。   使用make()函数来创建切片 var slice1 []type = make([]type, len)    也可以简写成: slice1 := make([]type, len)      也可以指定容量,其中capacity为可选参数  make([]T, length, ca...

冷月醉雪的博客 505

本地部署 pyvideotrans(视频翻译配音工具)

语音识别选择faster-whisper(本地),模型选择预先下载并保存的medium,然后选择好要处理的视频以及保存到的位置,这里我选择了一个名为why not的英文演讲视频,保存在桌面_vedio_out文件下。将附件中faster-medium.7z 和 faster-small.7z解压到项目中的models目录下, 解压后,目录中应该存在 models--Systran--faster-whisper-small。en.m4a|.wav = 原始视频中的音频文件(包含所有背景音和人声)

西唯兵欧泡的博客 2344

Golang中切片的长度和容量的区别

golang中切片的长度和容量的区别。

weixin_46967779的博客 1150

CTP接口入门

该文章主要讲什么 这篇文章的面向对象是有一些C++基础,并且想用C++来做程式化交易的同学。 这篇文章可以算是我的程式化学习笔记中的一篇。其中介绍了CTP的简单的使用方式,并且附上了一些代码以及我在试用的时候遇到的一些小坑。 什么是CTP CTP是上海期货推出的一套可供程序调用的交易接口。就好比官方给程序化交易提供了的一个专门的业务窗口。 接口相关文件下载 CTP接口可以在上期...

weizehua的专栏 4万+

Springboot项目中使用邮箱验证码注册登录的代码实现

本文介绍了在Spring Boot应用中实现邮箱验证码注册和登录功能的完整方案。文章首先概述了三种用户认证方式(邮箱验证码注册/登录和传统密码登录),然后详细说明了实现所需的技术栈(Spring Boot、Spring Security、JWT等)。重点阐述了邮件服务配置、验证码生成与存储的核心实现,包括QQ邮箱授权码获取、Thymeleaf邮件模板处理以及验证码缓存管理。最后展示了发送验证码和用户注册的API实现,为开发者提供了完整的参考方案。该方案兼顾安全性和用户体验,适合现代Web应用的用户认证需求。

BXCQ_xuan的技术专栏 | 实战干货·实践教程·学习笔记 1341

Go 知识点(15)— 切片长度和容量

1. 切片声明时默认的长度和容量 1.1 切片声明时不指定容量 切片在使用 make 声明时,如果没有显式的说明切片的容量,那么默认容量和切片的长度保持一致。 func main() { s1 := make([]int, 3) fmt.Println("s1 length: ", len(s1)) // s1 length: 3 fmt.Println("s1 capacity: ", cap(s1)) // s1 capacity: 3 fmt.Printf("s1 value: %#v

wohu1104的专栏 6653

数学概念 | 旋转矩阵、欧拉角、四元数

旋转矩阵、欧拉角、四元数概念及相关运算;

NapoleonCoder的博客 772

GoLang学习笔记(二十一)切片的长度和容量

切片的长度是切片中元素的数量 切片的容量是从创建切片的索引开始的底层数组中元素的数量 切片是可索引的,并且可以由len()方法获取长度,切片提供了计算容量的方法cap(),可以测量切片最长可以达到多少。 切片实际的是获取数组的某一部分,len切片<=cap切片<=len数组 cap()的结果决定了切片截取的注意细节 var sTest01 []int func sliceTest0...

ynzcxx的博客 5524

ubuntu20.04开机黑屏卡在/dev/sda1:clean,***files,***blocks,解决心得记录

这个问题如果你百度,会发现目前有很多种解决方法。 有更新显卡驱动的,有卸载上一次安装软件的,还有各种奇奇怪怪的故障原因。 如果你是属于上述情况,那么按照百度和论坛的各种指引操作一般都能解决。 但我这里主要说一种特殊情况,就是我什么也没有操作,我什么也没干。就是正常使用系统关了机突然就报错了。 这也是自己亲自遇到的问题,做个小记录方便以后自己回顾。 上一次出现这种情况我重装系统了,这次用了两个月又出现了,重装成本太高,我接受不了,于是找到解决办法。 首先找个终端进入,进入终端的方法很多,用安装u盘

qq_41517017的博客 2万+

基于Keil软件实现OLED显示(江协科技HAL库)

没有HAL库的OLED驱动文件,可以看过来

2401_82728381的博客 1453

golang 切片详解

Go 中的切片是一种灵活且高效的表示数组的方式,并且由于其动态大小和附加功能,它们经常用来代替数组。切片是对数组的一部分的引用。它是一种数据结构,通过指定起始索引和部分长度来描述数组的一部分。这允许您像使用独立数组一样使用数组的一部分。Go语言中切片比数组更强大、更灵活、更方便,是一种轻量级的数据结构。切片是一个变长序列,用于存储相似类型的元素,不允许在同一个切片中存储不同类型的元素。它就像一个具有索引值和长度的数组,但是切片的大小是调整大小的,它们不像数组那样是固定大小的。在内部,切片和数组是相互连接的,

m0_37698352的博客 2556

LLCC68芯片系统架构与LoRa驱动开发核心解析

LoRa射频收发器是低功耗广域物联网(LPWAN)的关键组件,其本质是集成了调制解调器、协议引擎、数据缓冲区与电源管理的专用SoC。理解其工作模式状态机(Sleep/Standby/TX/RX)与SPI主机接口时序规范,是实现稳定通信的基础。LLCC68通过寄存器映射与命令集双接口抽象硬件控制,支持LoRa扩频调制与FSK兼容模式,具备高链路预算(157 dB)和DC-DC/LDO动态电源切换能力。典型应用场景包括远距离传感器节点、智能表计与工业无线监测系统。本文深入剖析LLCC68的信号链路径、中断机制与

weixin_29859471的博客 284

【golang】slice实践以及底层原理

的底层实现有助于编写高效的 Go 代码,尤其是在处理大量数据或需要高性能的并发程序时。)取决于从切片的起始位置到底层数组末尾的元素数量。切片操作不会复制底层数组的数据,而是通过指针引用。是 Go 语言中非常强大的数据结构,它提供了动态数组的功能,同时在性能上也有很好的表现。的容量,Go 运行时会自动创建一个新的底层数组,并将旧数组的元素复制到新数组中。是一种非常常用的数据结构,它是对数组的一个抽象和封装。提供了灵活的动态数组操作,底层通过数组实现。的实践和底层实现对编写高效的 Go 程序至关重要。

Senkorl blog 723

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

深入理解 Golang 切片原理

通过对 Golang 切片原理的深入理解,我们可以更好地运用切片进行编程。切片的灵活性和高效性使其在处理数据集合时非常方便,但同时也需要注意其与数组的引用关系以及扩容机制,避免在使用过程中出现意外的行为。希望本文能够帮助读者更好地掌握 Golang 切片的原理和使用技巧,提升 Golang 编程能力。如果您对 Golang 编程的其他方面,如并发编程、网络编程、数据结构与算法等感兴趣,欢迎关注我的博客,我将持续分享更多相关的技术文章和经验总结。如果您在阅读过程中有任何疑问或建议,欢迎在评论区留言。

m0_57836225的博客 925

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

Go语言中的数组和切片 len cap append copy

先来看看Golang中的数组 其实在循环那一节用到过数组,我快速介绍一下。 数组中是固定长度的连续空间(内存区域) 数组中所有元素的类型是一样的 var a1 [10]int //初始化数组 var b1 = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} 多维数组 //声明二维数组,只要 任意加中括号,可以声明更多维,相应占用空间指数上指 v...

机智的程序员小熊 1301

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

Golang 语言中数组和切片的区别

01 介绍 在很多编程语言中都有数组,而切片类型却不常见。实际上,Golang 语言中的切片的底层存储也是基于数组。因为数组是固定长度的,而切片比数组更加灵活,所以在 Golang 语言中,数组使用的并不多,切片使用更加广泛。 02 数组和切片的区别 数组的零值是元素类型的零值,切片的零值是nil; 数组是固定长度,切片是可变的长度 数组是值类型,切片是引用类型 数组: func main () { var arr1 [4]int fmt.Printf("arr1 val:%d

weixin_44014995的博客 2514

golang int切片排序_go语言基础教程——数组与切片

今天是golang专题的第五篇,这一篇我们将会了解golang中的数组和切片的使用。数组与切片golang当中数组和C++中的定义类似,除了变量类型写在后面。比如我们要声明一个长度为10的int型的数组,会写成这样:vara[10]int数组的长度定义了之后不能改变,这点和C++以及Java是一样的。但是在我们日常使用的过程当中,除非我们非常确定数组长度不会发生变化,否则我们一般不会使用数组,...

weixin_29194693的博客 792

Go 语言是如何实现切片扩容的?【slice】

slice(切片)代表变长的序列,序列中每个元素都有相同的类型。一个slice类型一般写作[]T,其中T代表slice中元素的类型。slice的语法和数组很像,只是没有固定长度而已。数组和slice之间有着紧密的联系。一个slice是一个轻量级的数据结构,提供了访问数组子序列(或者全部)元素的功能,slice的底层引用一个数组对象。...

JavaPub 683

go语言切片和指针,make与new函数

引子 因为数组的长度是固定的并且数组长度属于类型的一部分,所以数组有很多的局限性。 例如: func arraySum(x [3]int) int{ sum := 0 for _, v := range x{ sum = sum + v } return sum } 这个求和函数只能接受[3]int类型,其他的都不支持。 再比如, a := [3]int{1, 2, 3} 数组a中已经有三个元素了,我们不能再继续往数组a中添加新元素了。 切片 切片(Sli

weixin_44706011的博客 1428

Golang的切片学习

感谢参考原文-http://bjbsair.com/2020-03-27/tech-info/7060/ 因为数组的长度是固定的并且数组长度属于类型的一部分,所以数组有很多的局限性。 例如: func arraySum(x [3]int) int{ sum := 0 for _, v := range x{ sum = sum + v } ...

hdx柿子的博客 117

Go语言 ( 切片)

本文主要介绍Go语言中切片(slice)及它的基本使用。 引子 因为数组的长度是固定的并且数组长度属于类型的一部分,所以数组有很多的局限性。 例如: func arraySum(x [3]int) int{ sum := 0 for _, v := range x{ sum = sum + v } return sum ...

a86123969的博客 211

Go语言 切片 Slice

go语言切片(slices)详细解读,切片是一种数据结构 切片可以按需动态增长和缩小 切片的底层内存也是连续块分配,能享受及使用索引,迭代,垃圾回收

ziyi813的博客 405

Go 切片

目录: 切片定义 修改切片 切片的长度和容量 通过make函数来初始化切片 切片的函数传递类型 切片定义 切片是有数组建议的一种方便、灵活且功能强大的包装(wrapper)。切片本身不拥有任何数据,它只是对现有数组的引用 创建一个切片 第一种方式 package main import "fmt" func main() { a:=[9]int{1,2,43} fmt.Pr...

番茄炒蛋君的博客 235

golang 切片

定义切片         var identifier []type         var slice1 []type = make([]type, len) 或 slice1 := make([]type, len)         make([]T, length, capacity)    这里 len 是数组的长度并且也是切片的初始长度, capacity是切片的初始容量切片初始化   ...

Geek猫的专栏 307

Go切片基础知识

Go切片基础知识 /*Slice可理解为可变长数组Arrey,一般使用append()函数,详细用法查看Go语言文档。 1. 切片:切片是数组的一个引用,因此切片是引用类型。但自身是结构体,值拷贝传递。 2. 切片的长度可以改变,因此,切片是一个可变的数组。 3. 切片遍历方式和数组一样,可以用len()求长度。表示可用元素数量,读写操作不能超过该限制。 4. cap可以求出slice最大扩张容量,不能超出数组限制。0 <= len(slice) <= len(array),其中array是sl

qq_44265131的博客 377
上一篇: 经验分享git命令入门到精通
下一篇: Linux系统学习窗口的正确打开方式
linuxprobe2017
博客等级 码龄10年 123粉丝 294原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值