Go语言 数组与切片

最新推荐文章于 2024-06-18 10:30:00 发布
最新推荐文章于 2024-06-18 10:30:00 发布
阅读量257 收藏
点赞数
分类专栏： go语言 翻译 文章标签： go 数组 切片 后端 编程语言
原文链接：https://golangbot.com/arrays-and-slices/
版权

文章目录

导言

  • 原文链接: Part 11: Arrays and Slices
  • If translation is not allowed, please leave me in the comment area and I will delete it as soon as possible.

数组

数组是相同类型元素的集合。举个例子，[5, 8, 9, 79, 76]就组成了一个数组。在Go语言中，数组元素的类型必须是相同的。

声明

数组属于类型[n]T。n 表示数组元素的数量，T 表示元素类型。注意，n 也是该类型的一部分。(我们将在下面讨论)

我们有很多方式声明数组。接下来，我来一一展示。

package main

import (  
    "fmt"
)


func main() {  
    var a [3]int //int array with length 3
    fmt.Println(a)
}

var a [3]int 声明了一个长度为 3 的整型数组。数组中的每个元素，都会被自动分配为该类型的零值。在这个例子中，a 是一个整型数组，所以它的所有元素将被分配为 0 — 整型的零值。运行上面的程序将会输出 [0 0 0]。

数组的索引范围为[0, length - 1]。接下来，我们为上面的数组分配一些值。

package main

import (  
    "fmt"
)


func main() {  
    var a [3]int //int array with length 3
    a[0] = 12 // array index starts at 0
    a[1] = 78
    a[2] = 50
    fmt.Println(a)
}

a[0] 表示为数组的第一个元素分配数值。运行上面的程序，将输出[12 78 50]。

接下来，我们使用 快捷声明 创建一个相同的数组。

package main 

import (  
    "fmt"
)

func main() {  
    a := [3]int{12, 78, 50} // short hand declaration to create array
    fmt.Println(a)
}

同样地，这个程序也会输出 [12 78 50]。

其实，在快捷声明时，我们不必为数组的所有元素都分配一个数值。

package main

import (  
    "fmt"
)

func main() {  
    a := [3]int{12} 
    fmt.Println(a)
}

在上面的程序，a := [3]int{12} 声明了一个长度为 3 的数组，但只为其提供了一个值 12 。剩余的 2 个元素将被自动分配为 0。运行程序，将会输出[12 0 0]。

在声明数组时，你甚至可以省略长度，使用 ... 来让编译器识别数组长度。下面这个程序就是这样做的。

package main

import (  
    "fmt"
)

func main() {  
    a := [...]int{12, 78, 50} // ... makes the compiler determine the length
    fmt.Println(a)
}

数组长度也是类型的一部分。因此，[5]int 和 [25]int 是不同的类型。也因为这个原因，数组大小不能改变。不必担心，因为 切片 可以克服这个限制。

package main

func main() {  
    a := [3]int{5, 78, 8}
    var b [5]int
    b = a //not possible since [3]int and [5]int are distinct types
}

在上面这个程序，我们试图把 [3]int数组 分配给[5]int数组，但这是不允许的，编译器将会抛出一个异常:
cannot use a (type [3]int) as type [5]int in assignment.

数组是值类型

在 Go 中，数组是值类型，而不是引用类型。这意味着，当数组被分配给一个新的变量时，新变量的数组只是原数组的拷贝。任何在新数组上的修改，都不会影响原始数组。

package main

import "fmt"

func main() {  
    a := [...]string{"USA", "China", "India", "Germany", "France"}
    b := a // a copy of a is assigned to b
    b[0] = "Singapore"
    fmt.Println("a is ", a)
    fmt.Println("b is ", b) 
}

在上面程序中，a 的拷贝被分配给 b。随后，数组b 的第一个元素被修改为 Singapore，但这并不会影响 原始数组a。运行这个程序，输出如下:

a is [USA China India Germany France]  
b is [Singapore China India Germany France]

同样的，当数组被作为参数，传递给函数时，这个传递也是值传递，任何作用在参数的效果，都不会影响原数组。

package main

import "fmt"

func changeLocal(num [5]int) {  
    num[0] = 55
    fmt.Println("inside function ", num)

}
func main() {  
    num := [...]int{5, 6, 7, 8, 8}
    fmt.Println("before passing to function ", num)
    changeLocal(num) //num is passed by value
    fmt.Println("after passing to function ", num)
}

在上面程序中，数组 num 以值传递的方式传递给 函数changeLocal。因此，原始数组并不会因函数调用而改变。这个程序输出如下:

before passing to function  [5 6 7 8 8]  
inside function  [55 6 7 8 8]  
after passing to function  [5 6 7 8 8]

数组的长度

使用 len 函数，我们可以获取数组的长度。

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    fmt.Println("length of a is",len(a))

}

上面程序将输出:

length of a is 4

使用 range 遍历数组

for 循环可以遍历数组的元素。

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    for i := 0; i < len(a); i++ { //looping from 0 to the length of the array
        fmt.Printf("%d th element of a is %.2f\n", i, a[i])
    }
}

在上面的程序中，for 循环遍历了整个数组。程序输出如下:

0 th element of a is 67.70  
1 th element of a is 89.80  
2 th element of a is 21.00  
3 th element of a is 78.00

对于遍历数组，Go 提供了一个更好、更简洁的方法 — for 循环的 range 形式。
range 返回索引、和对应索引的数值。接下来，我们使用 range 重写上面的代码，并添加一个新功能 — 统计数组的总和。

package main

import "fmt"

func main() {  
    a := [...]float64{67.7, 89.8, 21, 78}
    sum := float64(0)
    for i, v := range a {//range returns both the index and value
        fmt.Printf("%d the element of a is %.2f\n", i, v)
        sum += v
    }
    fmt.Println("\nsum of all elements of a",sum)
}

在上面的程序中，for i, v := range a 就是 for 循环的 range 形式。运行这个程序，输出如下:

0 the element of a is 67.70  
1 the element of a is 89.80  
2 the element of a is 21.00  
3 the element of a is 78.00

sum of all elements of a 256.5

如果你只需要数值，不需要索引，那你可以使用 _空白标识符 去替换 索引。

for _, v := range a { //ignores index  
}

上面的循环忽略了索引。同样的，数值也可以被忽略。

多维数组

到目前为止，我们创建的都是一维数组。接下来，我们来创建一个多维数组。

package main

import (  
    "fmt"
)

func printarray(a [3][2]string) {  
    for _, v1 := range a {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

func main() {  
    a := [3][2]string{
        {"lion", "tiger"},
        {"cat", "dog"},
        {"pigeon", "peacock"}, //this comma is necessary. The compiler will complain if you omit this comma
    }
    printarray(a)
    var b [3][2]string
    b[0][0] = "apple"
    b[0][1] = "samsung"
    b[1][0] = "microsoft"
    b[1][1] = "google"
    b[2][0] = "AT&T"
    b[2][1] = "T-Mobile"
    fmt.Printf("\n")
    printarray(b)
}

在上面的程序中，我们使用快捷句式声明了一个 二维数组a。第 20 行的逗号是必须的，这是因为如果没有逗号，词法分析器会自动的插入分号，从而导致错误。如果你有兴趣，可以访问这个 网站 进行深入理解。

在上面的代码中，我们还声明了一个 二维数组b ，并一对一的对其赋值。这种方法也可以初始化二维数组。

printarray 函数使用了两个嵌套的 for 循环输出二维数组的内容。运行上面的程序，输出如下:

lion tiger  
cat dog  
pigeon peacock 

apple samsung  
microsoft google  
AT&T T-Mobile

这就是数组。虽然数组看起来已经足够灵活，但数组长度是固定的，这是它的缺点。我们不能增长数组的长度。于是，切片 出现了。事实上，在 Go语言 中，切片 比 数组 更常用。

切片

切片是数组之上的封装，它方便、灵活、功能强大。切片并不会拥有原始数据，它们只是引用了数组。

package main

import (  
    "fmt"
)

func main() {  
    a := [5]int{76, 77, 78, 79, 80}
    var b []int = a[1:4] //creates a slice from a[1] to a[3]
    fmt.Println(b)
}

句式 a[start:end] 表示：在 数组a 的基础上，创建了一个切片，索引区间为 [0, end - 1]。所以，a[1:4] 创建了一个切片，这个切片引用了数组区间 [1, 3] 的元素。因此，切片b 的值是 [77 78 79]。

我们还有另外一种方式创建切片。

package main

import (  
    "fmt"
)

func main() {  
    c := []int{6, 7, 8} //creates and array and returns a slice reference
    fmt.Println(c)
}

在上面的程序中，c := []int{6, 7, 8} 创建了一个长度为 3 的数组、返回一个切片引用、并将该引用传递给 切片c。

切片的修改

切片并不会拥有任何数据。它只是引用了底层数组。因此，任何对切片的修改，最终都会反映在底层数组。

package main

import (  
    "fmt"
)

func main() {  
    darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
    dslice := darr[2:5]
    fmt.Println("array before",darr)
    for i := range dslice {
        dslice[i]++
    }
    fmt.Println("array after",darr) 
}

在上面的程序中，我们创建了一个 切片dslice ，引用了数组索引 2, 3, 4。for循环 使切片的元素都增加 1。运行这个程序，我们将会发现: 对切片的修改作用到了底层数组。输出如下:

array before [57 89 90 82 100 78 67 69 59]  
array after [57 89 91 83 101 78 67 69 59]

当大量的切片共享底层数组，此时，对这些切片的修改都会影响底层数组。

package main

import (  
    "fmt"
)

func main() {  
    numa := [3]int{78, 79 ,80}
    nums1 := numa[:] //creates a slice which contains all elements of the array
    nums2 := numa[:]
    fmt.Println("array before change 1",numa)
    nums1[0] = 100
    fmt.Println("array after modification to slice nums1", numa)
    nums2[1] = 101
    fmt.Println("array after modification to slice nums2", numa)
}

在上面的程序中，num[:] 其实是 num[0:len(num)] 的简写形式。由于 nums1 和 nums2 共享相同的数组，因此最终输出为:

array before change 1 [78 79 80]  
array after modification to slice nums1 [100 79 80]  
array after modification to slice nums2 [100 101 80]

切片的长度与容量

切片的长度表示切片拥有的元素数量。而切片的容量，表示的是切片指向的底层数组拥有的元素数量。

我们使用代码来解释吧~

package main

import (  
    "fmt"
)

func main() {  
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) //length of fruitslice is 2 and capacity is 6
}

在上面的程序中，fruitslice 引用了 fruitarray 的 1、2 索引，因此 fruitslice 长度为 2。

fruitarray的长度是 7。fruitslice 引用了 fruitarray 的 1、2 索引，因此它的容量为 6 — 因为它引用的开始索引是 1，如果从 0 开始引用，那么它的容量就是 7。

运行上面的程序，输出将是:
length of slice 2 capacity 6

对于一个切片，它能访问的最大索引为 容量 - 1。 超过最大索引的访问将会引发运行时错误。

package main

import (  
    "fmt"
)

func main() {  
    fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
    fruitslice := fruitarray[1:3]
    fmt.Printf("length of slice %d capacity %d\n", len(fruitslice), cap(fruitslice)) //length of is 2 and capacity is 6
    fruitslice = fruitslice[:cap(fruitslice)] //re-slicing furitslice till its capacity
    fmt.Println("After re-slicing length is",len(fruitslice), "and capacity is",cap(fruitslice))
}

运行上面的程序，输出如下:

length of slice 2 capacity 6  
After re-slicing length is 6 and capacity is 6

使用 make 创建切片

为 func make([]T, len, cap) []T 函数 传递切片的类型、长度和容量，可以创建一个切片。cap 参数是可选的，默认等于 len。make 函数将会创建一个数组，并返回一个引用该数组的切片。

package main

import (  
    "fmt"
)

func main() {  
    i := make([]int, 5, 5)
    fmt.Println(i)
}

使用 make 创建切片时，切片元素的初始值是对应类型的零值。上面的程序输出为 [0 0 0 0 0]。

为切片追加元素

我们已经知道了，数组的长度是固定的。但，切片是动态的，使用 append函数 ，我们可以为其追加元素。append函数 定义为 func append(s []T, x ...T) []T。

在函数定义中，x ...T 表示 x 是一个接收可变长度的参数。相应的，拥有可变长度参数的函数，被称为 可变函数(variadic functions)。

现在，你可能会疑惑: 切片的底层是一个数组，而数组长度是固定的，那么切片长度为何可变呢？解释是: 当我们为切片追加元素的时候，一个新数组将会被创建，随后，原数组的元素将被拷贝给新数组，并返回一个对新数组的引用。新切片的容量将是旧切片的两倍。

这里有点谬误，因为有时并不会创建一个新数组，只有当原数组装不下所有追加后的数据时，此时才会创建一个新数组去容纳。
新切片的容量也不一定总是旧切片的两倍，当旧切片的长度小于 1024 时，新切片的容量才是旧切片的两倍

来看个代码。

package main

import (  
    "fmt"
)

func main() {  
    cars := []string{"Ferrari", "Honda", "Ford"}
    fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) //capacity of cars is 3
    cars = append(cars, "Toyota")
    fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) //capacity of cars is doubled to 6
}

在上面的程序中，cars 的容量最初是 3。当我们为其分配一个新的元素 Toyota、并将返回的切片重新传递给 cars 后，此时 cars 的容量将变为 6。程序输出如下:

cars: [Ferrari Honda Ford] has old length 3 and capacity 3  
cars: [Ferrari Honda Ford Toyota] has new length 4 and capacity 6

切片的零值是 nil。nil 切片的长度和容量都为 0。但是，我们依旧可以使用 append函数 为其追加元素。

package main

import (  
    "fmt"
)

func main() {  
    var names []string //zero value of a slice is nil
    if names == nil {
        fmt.Println("slice is nil going to append")
        names = append(names, "John", "Sebastian", "Vinay")
        fmt.Println("names contents:",names)
    }
}

在上面程序中，names 为 nil，我们为其追加 3 个元素。程序输出如下:

slice is nil going to append  
names contents: [John Sebastian Vinay]

我们也可以使用 ... 操作符为一个切片，追加另外一个切片。

package main

import (  
    "fmt"
)

func main() {  
    veggies := []string{"potatoes","tomatoes","brinjal"}
    fruits := []string{"oranges","apples"}
    food := append(veggies, fruits...)
    fmt.Println("food:",food)
}

在上面的程序中，我们通过 append函数，为 fruits切片 追加一个切片 veggies，并把返回的引用传递给 food。运行上面的程序，输出如下:

food: [potatoes tomatoes brinjal oranges apples]

将切片传递给函数

切片可以用以下结构体进行表示:

type slice struct {  
    Length        int
    Capacity      int
    ZerothElement *byte
}

切片结构包括了长度、容量、以及一个指向数组第 0 个元素的指针。当把切片作为参数传递给函数时，即使是值传递，参数的指针变量指向的是相同的底层数组。因此，当把切片作为参数时，任何在函数内对该切片参数的修改，都会影响到原切片。
接下来，我们用一段代码来说说上面是什么意思。

package main

import (  
    "fmt"
)

func subtactOne(numbers []int) {  
    for i := range numbers {
        numbers[i] -= 2
    }

}
func main() {  
    nos := []int{8, 7, 6}
    fmt.Println("slice before function call", nos)
    subtactOne(nos)                               //function modifies the slice
    fmt.Println("slice after function call", nos) //modifications are visible outside
}

这个函数的作用就是：将切片的每个值都增加 2。在函数调用结束后，输出 slice，我们会发现，这些改变影响了原切片。回忆一下，当我们在一个函数内部修改数组时，这些改变并不会作用于原数组。运行上面的程序，输出如下:

slice before function call [8 7 6]  
slice after function call [6 5 4]

多维切片

和数组类似，切片也可以有多个维度。

package main

import (  
    "fmt"
)


func main() {  
     pls := [][]string {
            {"C", "C++"},
            {"JavaScript"},
            {"Go", "Rust"},
            }
    for _, v1 := range pls {
        for _, v2 := range v1 {
            fmt.Printf("%s ", v2)
        }
        fmt.Printf("\n")
    }
}

输出如下:

C C++  
JavaScript  
Go Rust

内存优化

切片拥有对底层数组的引用，所以，只要切片还在内存中，底层数组就不会被垃圾回收。当涉及到内存管理时，我们必须考虑这个问题。
设想一下，假如我们有一个非常大的数组，但我们只需要它的一小部分。于是，我们在数组之上创建一个切片。这里就要注意下了，因为切片还引用着数组，因此，数组也一定要留在内存中。

为了保证底层数组能被垃圾回收，我们可以使用 copy函数。copy函数 定义为 func copy(dst, src []T) int，它将生成一个原切片的深拷贝。于是，我们可以使用 copy 来产生新切片，从而使底层的数组能被垃圾收集。(可能有点迷惑，看下面)

假如原数组长度是 1000，a 切片引用了它的 3 个元素，这使得原数组的内存不能被回收。于是我们可以使用 copy 函数，copy(b, a) 会在内存中生成一个长度为 3 的底层数组，并把 a 的数组元素传递给该底层数组，之后让 b 指向这个底层数组。于是，当 a 对原数组的引用被移除，长度为 1000 的原数组就可以被垃圾回收，而我们还能使用原数组的数据。

来看段代码:

package main

import (  
    "fmt"
)

func countries() []string {  
    countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
    neededCountries := countries[:len(countries)-2]
    countriesCpy := make([]string, len(neededCountries))
    copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
    return countriesCpy
}
func main() {  
    countriesNeeded := countries()
    fmt.Println(countriesNeeded)
}

在上面程序中，neededCountries := countries[:len(countries)-2]在 countries数组 之上创建了一个切片。copy(countriesCpy, neededCountries) 将 neededCountries 深拷贝给 countriesCpy，随后返回 countriesCpy。此时 countries数组 就可以被垃圾回收，因为 neededCountries 不再引用它了。

原作者留言

我已经把上面的概念整合到了一个程序，你可以在 github 下载。

优质内容来之不易，您可以通过该 链接 为我捐赠。

最后

感谢原作者的优质内容。

这是我的第一次翻译，欢迎指出文中的任何错误。

I am a gopher
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解Go语言中的数组和切片
09-21
Go语言中的数组大概相当与C/C++中的数组，固定大小，不能够动态扩展大小，而切片大概相当与C++中的Vector，可以动态扩展大小，当大小超过容量时，重新分配一块内存，然后将数据复制到新的内存区域。下面我们通过几个...
GO语言数组和切片实例详解
12-26
本文实例讲述了GO语言数组和切片的用法。分享给大家供大家参考。具体分析如下： 一、数组　 与其他大多数语言类似，Go语言的数组也是一个元素类型相同的定长的序列。 （1）数组的创建。 数组有3种创建方式：[length]...
go语言--数组和切片
weixin_44879063的博客
12-08 568
数组和切片数组1.数组的定义2.数组的特点3.多维数组切片1.切片的定义2.切片是引用类型3.切片存在默认的上下界4、切片的长度和容量5、nil切片6.使用make创建切片7.使用append对切片扩容8.copy9. 切片“陷阱” 数组 1.数组的定义 数组是一组相同的数组类型的集合，支持随机访问，以下列出了部分定义方式（在go语言中指定了大小的一组相同类型的元素叫数组，不指定大小的一组相同类型元素叫切片）。 Go的数组是值语义。一个数组变量表示整个数组，它不是指向第一个元素的指针（不像 C 语言的数组）
Go语言数组和切片
qq_43493084的博客
01-04 250
千里之行始于足下，第六步：Go语言数组和切片
Go语言之数组与切片
Dreaming_My_Dream的博客
06-23 792
Go语言之数组、切片、map
Go语言学习笔记(五)------数组与切片
Rcvisual的博客
02-19 385
一、声明和初始化 1.数组是具有相同唯一类型的一组已编号且长度固定的数据项序列（这是一种同构的数据结构）；这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。数组长度必须是一个常量表达式，并且必须是一个非负整数。数组长度也是数组类型的一部分，所以[5]int和[10]int是属于不同类型的，数组的编译时值初始化是按照数组顺序完成的。如果我们想让数组元素类型为任意类型的话可以使用空接口作为...
go语言学习之----数组和切片
xingyanghua的博客
12-05 193
1.数组和切片的区别 数组是类型相同元素的集合,go不允许在数组中混合不同类型的元素. 数组定义是需要指定数组的长度,切片不用指定 2.数组如何定义 定义方式一: { var a [3]int a[0] = 12 a[1] = 13 a[2] =14 } 定义方式二: { a := [3]int{12,13,14} } ...
go语言数组切片的使用案例
02-28
go语言数组切片的使用案例
GO语言学习之-数组和切片(二)
12-21
之前,在一里面讲过关于数组以及切片的区别,都知道 数组的长度是固定的并且数组长度属于类型的一部分，所以数组有很多的局限性。 引言: 例如: func sumArray(number [5]int) int{ sum := 0 for _, value := range ...
Go语言数组和切片总结
qq_42642142的博客
09-20 198
数组 数组定义： var 数组名 [数组大小]数据类型 初始化方式： var nums [3]int = [3]int{1,2,3} var nums = [3]int{1,2,3} var nums = [...]int{4,5,6} 数组的地址可以通过数组名来获取 &intArr 数组第一个元素的地址就是数组的首地址 func main(){ var IntArr [3]int IntArr[0] = 1 IntArr[0] = 31 IntArr[0] = 6 fmt.Pr
Go语言基础（三）：数组与切片
一点一滴铺就人生
10-07 634
文章目录一、数组1、数组的初始化（1）方法一（2）方法二（3）方法三2、数组的遍历3、多维数组（1）二维数组的定义（2）二维数组的遍历4、数组是值类型5、练习题二、切片 一、数组 数组是同一种数据类型元素的集合。 在Go语言中，数组从声明时就确定，使用时可以修改数组成员，但是数组大小不可变化。 基本语法： // 定义一个长度为3元素类型为int的数组a var a [3]int 数组的长度必须是常量，并且长度是数组类型的一部分。一旦定义，长度不能变 1、数组的初始化 （1）方法一 var testArr
06-Go语言中数组和切片
weixin_38753143的博客
06-30 298
基本语法： 数组的声明 注意事项数组的长度必须是常量，并且长度是数组类型的一部分.数组支持索引访问 、，索引的合法范围：~，不支持负数索引。代码展示 数组初始化 方式1初始化数组时可以使用初始化列表设置数组元素的值。 方式2刚开始无法确定数组长度时，一般情况下我们可以让编译器根据初始值的个数自行推断数组的长度，数组长度用: 方式3指定索引值初始化数组： 数组的遍历 方式1 方式2 多维数据 这里以二维数组为例，三维数组、四维数组类似。二维数组的定义 二维数组的遍历方式1:索引遍历 方式2:for ra.
Go 的数组和切片
技术能量站
07-24 2148
这次主要讨论Go语言的数组（array）类型和切片（slice）类型。切片是基于数组的，可变长的，并且非常轻快。一个切片的容量总是固定的，而且一个切片也只会与某一个底层数组绑定在一起。此外，切片的容量总会是在切片长度和底层数组长度之间的某一个值，并且还与切片窗口最左边对应的元素在底层数组中的位置有关系。......
Go - 4.数组和切片
最新发布
BITDDD小栈
06-18 877
Go 语言中的数组和切片类型。
go语言（5）数组和切片
weixin_43823255的博客
11-30 781
数组 1.数组定义：var 数组名 [数组大小] 数组类型 var a [5]int 2.(1)数组的地址可以通过数组名来获取：&a (2)数组第一个元素的地址就是数组的首地址 3.数组初始化的四种方式
go array和slice区别
Cabinathor的专栏
09-19 3994
来源http://www.2cto.com/kf/201401/274536.html
go初学篇(三)之数组切片
hightower的博客
03-17 2580
前言 上一篇将go的初级语法(主要是变量和常量的内容)，基础数据类型简单说了一下，到了这里大家一般都已经了解到了go的初级基础，那么对于任何一门语言数组是离不开的，数组的一系列操作在语言代码中有着很大的不同，相比于大多数语言，go的数组显得局限，因为在go中数组是一种值类型，一旦被定义，他的容量必须是固定，所以想要对其进行扩容就是不可能的，为了解决这个比较尴尬的场景，go团队引入了切片的概念，而切片的功能比其他语言的数组还要厉害几分。 数组 1.一维数组的定义与使用 1.1.定义一个数组 数组的格
go语言接口赋值
btqszl的博客
03-22 968
type Int int func(a *Int) Add(b Int) {    *a += b } func(a Int) Less(b Int) bool{    return a } type LessAdder interface {     Less(b Int) bool     Add(b Int) } func main()
golang(Go语言)中的数组（Array）与切片（Slice）
weixin_42117918的博客
08-29 4314
先抛出几个问题 声明一个 slice 并赋值为 nil, 如 var slice []int = nil，此时 len(slice) 的运行结果是什么? func(arr []int) 和 func(arr [10]int) 两个函数内部都对 arr 进行修改, 对外面的值(作为参数的数据)是否造成影响? 创建一个 slice := make([]int, 5, 10), 然后 slice[8...
go语言中，数组和切片的区别是什么
02-07
在 Go 语言中，数组是固定长度的、类型相同的一组数据。切片则是对数组的抽象，切片是可变长度的，并且可以包含任意类型的数据。 数组的长度是固定的，在声明数组时就必须指定数组的长度。数组的长度也是它的一个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值