当前位置：极客教程 > Go 语言 > Go 教程 > Golang 分片

Golang 分片

Golang 分片

在Go语言中，slice比数组更强大、更灵活、更方便，是一种轻量级的数据结构。切片是一个可变长度的序列，它存储相似类型的元素，你不允许在同一个切片中存储不同类型的元素。它就像一个有索引值和长度的数组，但片断的大小是可以调整的，它们不像数组那样有固定的大小。在内部，slice和数组是相互联系的，slice是对一个底层数组的引用。分片 中的第一个索引位置总是0，最后一个是（分片的长度-1）。

分片的声明

一个片断的声明就像一个数组，但它不包含片断的大小。所以它可以根据需求增长或缩小。

语法

[]T
or 
[]T{}
or 
[]T{value1, value2, value3, ...value n}

这里，T是元素的类型。比如说。

var my_slice[]int

切片的组成部分

一个片断包含三个组成部分。

  • 指针 : 指针用来指向数组的第一个元素，该元素可以通过分片访问。在这里，不需要指出的元素是数组的第一个元素。
  • 长度： 长度是数组中存在的元素总数。
  • 容量： 容量表示它可以扩展到的最大尺寸。

让我们借助一个例子来讨论所有这些组成部分。

例子

// Golang program to illustrate
// the working of the slice components
package main
 
import "fmt"
 
func main() {
 
    // Creating an array
    arr := [7]string{"This", "is", "the", "tutorial",
                         "of", "Go", "language"}
 
    // Display array
    fmt.Println("Array:", arr)
 
    // Creating a slice
    myslice := arr[1:6]
 
    // Display slice
    fmt.Println("Slice:", myslice)
 
    // Display length of the slice
    fmt.Printf("Length of the slice: %d", len(myslice))
 
    // Display the capacity of the slice
    fmt.Printf("\nCapacity of the slice: %d", cap(myslice))
}

输出

Array: [This is the tutorial of Go language]
Slice: [is the tutorial of Go]
Length of the slice: 5
Capacity of the slice: 6

解释： 在上面的例子中，我们从给定的数组中创建一个分片。这里分片的指针指向索引1，因为分片的下限被设置为1，所以它从索引1开始访问元素。分片的长度是5，这意味着分片中存在的元素总数是5，分片的容量是6，意味着它最多可以存储6个元素。

Golang中的分片

如何创建和初始化一个片断？

在Go语言中，可以通过以下方式来创建和初始化一个分片。

  • 使用slice literal： 你可以使用slice literal来创建一个slice。创建slice literal和数组 literal一样，但有一点不同的是，你不允许在方括号[]中指定slice的大小。如下面的例子所示，这个表达式的右边是分片的字面意思。
var my_slice_1 = []string{"Geeks", "for", "Geeks"}

注意： 一定要记住，当你使用字符串字头创建一个片断时，它首先创建一个数组，然后返回一个片断引用。

例子

// Golang program to illustrate how
// to create a slice using a slice
// literal
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    // using the var keyword
    var my_slice_1 = []string{"Geeks", "for", "Geeks"}
 
    fmt.Println("My Slice 1:", my_slice_1)
 
    // Creating a slice
    //using shorthand declaration
    my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
    fmt.Println("My Slice 2:", my_slice_2)
}

输出

My Slice 1: [Geeks for Geeks]
My Slice 2: [12 45 67 56 43 34 45]
  • 使用数组： 我们已经知道slice是数组的引用 ，所以你可以从给定的数组中创建一个slice。为了从给定的数组中创建一个分片，首先你需要指定下限和上限，这意味着分片可以从数组的下限到上限中获取元素。它不包括从上界开始的元素。如下面的例子所示：
    语法
array_name[low:high]

这个语法将返回一个新的片断。

注意： 下限的默认值是0，上限的默认值是给定数组中元素的总数。

例子

// Golang program to illustrate how to
// create slices from the array
package main
 
import "fmt"
 
func main() {
 
    // Creating an array
    arr := [4]string{"Geeks", "for", "Geeks", "GFG"}
 
    // Creating slices from the given array
    var my_slice_1 = arr[1:2]
    my_slice_2 := arr[0:]
    my_slice_3 := arr[:2]
    my_slice_4 := arr[:]
 
    // Display the result
    fmt.Println("My Array: ", arr)
    fmt.Println("My Slice 1: ", my_slice_1)
    fmt.Println("My Slice 2: ", my_slice_2)
    fmt.Println("My Slice 3: ", my_slice_3)
    fmt.Println("My Slice 4: ", my_slice_4)
}

输出

My Array:  [Geeks for Geeks GFG]
My Slice 1:  [for]
My Slice 2:  [Geeks for Geeks GFG]
My Slice 3:  [Geeks for]
My Slice 4:  [Geeks for Geeks GFG]
  • 使用已经存在的片断： 也允许从给定的片断创建一个片断。为了从给定的片断创建一个片断，首先你需要指定下限和上限，这意味着片断可以从给定的片断中抽取元素，从下限开始到上限。它不包括从上界开始的元素。如下面的例子所示：
    语法
slice_name[low:high]

这个语法将返回一个新的片断。

注意： 下限的默认值是0，上限的默认值是给定片断中存在的元素总数。

例子

// Golang program to illustrate how to
// create slices from the slice
package main
 
import "fmt"
 
func main() {
 
    // Creating s slice
    oRignAl_slice := []int{90, 60, 40, 50,
        34, 49, 30}
 
    // Creating slices from the given slice
    var my_slice_1 = oRignAl_slice[1:5]
    my_slice_2 := oRignAl_slice[0:]
    my_slice_3 := oRignAl_slice[:6]
    my_slice_4 := oRignAl_slice[:]
    my_slice_5 := my_slice_3[2:4]
 
    // Display the result
    fmt.Println("Original Slice:", oRignAl_slice)
    fmt.Println("New Slice 1:", my_slice_1)
    fmt.Println("New Slice 2:", my_slice_2)
    fmt.Println("New Slice 3:", my_slice_3)
    fmt.Println("New Slice 4:", my_slice_4)
    fmt.Println("New Slice 5:", my_slice_5)
}

输出

Original Slice: [90 60 40 50 34 49 30]
New Slice 1: [60 40 50 34]
New Slice 2: [90 60 40 50 34 49 30]
New Slice 3: [90 60 40 50 34 49]
New Slice 4: [90 60 40 50 34 49 30]
New Slice 5: [40 50]
  • 使用make()函数： 你也可以使用go库提供的make()函数 来创建一个片子。这个函数需要三个参数，即类型、长度和容量。这里，容量值是可选的。它分配了一个底层数组，其大小等于给定的容量，并返回一个指向底层数组的片断。一般来说，make()函数是用来创建一个空片的。这里，空片是那些包含空数组引用的片子。
    语法
func make([]T, len, cap) []T

例子

// Go program to illustrate how to create slices
// Using make function
package main
 
import "fmt"
 
func main() {
 
    // Creating an array of size 7
    // and slice this array  till 4
    // and return the reference of the slice
    // Using make function
    var my_slice_1 = make([]int, 4, 7)
    fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",
                   my_slice_1, len(my_slice_1), cap(my_slice_1))
 
    // Creating another array of size 7
    // and return the reference of the slice
    // Using make function
    var my_slice_2 = make([]int, 7)
    fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",
                   my_slice_2, len(my_slice_2), cap(my_slice_2))
     
}

输出

Slice 1 = [0 0 0 0], 
length = 4, 
capacity = 7
Slice 2 = [0 0 0 0 0 0 0], 
length = 7, 
capacity = 7

如何在一个切片上迭代？

你可以通过以下方式对分片进行迭代。

  • 使用for循环： 这是迭代分片的最简单方法，如下例所示：
    例子
// Golang program to illustrate the
// iterating over a slice using
// for loop
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the", "tutorial",
        "of", "Go", "language"}
 
    // Iterate using for loop
    for e := 0; e < len(myslice); e++ {
        fmt.Println(myslice[e])
    }
}

输出

This
is
the
tutorial
of
Go
language
  • 在for循环中使用范围： 允许在for循环中使用范围来迭代一个片断。在for循环中使用range，你可以得到索引和元素值，如例子所示：
    例子
// Golang program to illustrate the iterating
// over a slice using range in for loop
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the", "tutorial",
                                 "of", "Go", "language"}
 
    // Iterate slice
    // using range in for loop
    for index, ele := range myslice {
        fmt.Printf("Index = %d and element = %s\n", index+3, ele)
    }
}

输出

Index = 3 and element = This
Index = 4 and element = is
Index = 5 and element = the
Index = 6 and element = tutorial
Index = 7 and element = of
Index = 8 and element = Go
Index = 9 and element = language
  • 在for循环中使用空白标识符： 在范围for循环中，如果你不想获得元素的索引值，那么你可以使用空白(_)来代替索引变量，如下例所示：
    例。
// Golang program to illustrate the iterating over
// a slice using range in for loop without an index
package main
 
import "fmt"
 
func main() {
 
    // Creating a slice
    myslice := []string{"This", "is", "the",
        "tutorial", "of", "Go", "language"}
 
    // Iterate slice
    // using range in for loop
    // without index
    for _, ele := range myslice {
        fmt.Printf("Element = %s\n", ele)
    }
}

输出

Element = This
Element = is
Element = the
Element = tutorial
Element = of
Element = Go
Element = language

关于Slice的重要观点

  • 零值分片： 在Go语言中，你可以创建一个不包含任何元素的零值分片。所以这个片断的容量和长度都是0。无片断不包含数组引用，如下例所示：
    例子
// Go program to illustrate a zero value slice
package main
 
import "fmt"
 
func main() {
 
    // Creating a zero value slice
    var myslice []string
    fmt.Printf("Length = %d\n", len(myslice))
    fmt.Printf("Capacity = %d ", cap(myslice))
 
}

输出

Length = 0
Capacity = 0
  • 修改slice： 我们已经知道slice是一个引用类型，它可以引用一个底层数组。因此，如果我们改变了切片中的一些元素，那么这些改变也应该发生在引用的数组中。或者换句话说，如果你在切片中做了任何改变，那么它也会反映在数组中，如下面的例子所示：

例

// Golang program to illustrate
// how to modify the slice
package main
 
import "fmt"
 
func main() {
 
    // Creating a zero value slice
    arr := [6]int{55, 66, 77, 88, 99, 22}
    slc := arr[0:4]
 
    // Before modifying
 
    fmt.Println("Original_Array: ", arr)
    fmt.Println("Original_Slice: ", slc)
 
    // After modification
    slc[0] = 100
    slc[1] = 1000
    slc[2] = 1000
 
    fmt.Println("\nNew_Array: ", arr)
    fmt.Println("New_Slice: ", slc)
}

输出

Original_Array:  [55 66 77 88 99 22]
Original_Slice:  [55 66 77 88]

New_Array:  [100 1000 1000 88 99 22]
New_Slice:  [100 1000 1000 88]
  • 片断的比较： 在片断中，你只能使用 == 运算符来检查给定的片断是否为零。如果你试图用 == 运算符来比较两个片断，那么它会给你一个错误，如下面的例子所示：
    例子
// Golang program to check if
// the slice is nil or not
package main
 
import "fmt"
 
func main() {
 
    // creating slices
    s1 := []int{12, 34, 56}
    var s2 []int
 
    // If you try to run this commented
    // code compiler will give an error
    /*s3:= []int{23, 45, 66}
      fmt.Println(s1==s3)
    */
 
    // Checking if the given slice is nil or not
    fmt.Println(s1 == nil)
    fmt.Println(s2 == nil)
}

输出

false
true

注意： 如果你想比较两个片断，那么使用range for loop来匹配每个元素，或者你可以使用 DeepEqual 函数。

  • 多维切片： 多维切片就像多维数组一样，只是切片不包含大小。
    例子
// Go program to illustrate the multi-dimensional slice
package main
 
import "fmt"
 
func main() {
 
    // Creating multi-dimensional slice
    s1 := [][]int{{12, 34},
        {56, 47},
        {29, 40},
        {46, 78},
    }
 
    // Accessing multi-dimensional slice
    fmt.Println("Slice 1 : ", s1)
 
    // Creating multi-dimensional slice
    s2 := [][]string{
        []string{"Geeks", "for"},
        []string{"Geeks", "GFG"},
        []string{"gfg", "geek"},
    }
 
    // Accessing multi-dimensional slice
    fmt.Println("Slice 2 : ", s2)
 
}

输出

Slice 1 :  [[12 34] [56 47] [29 40] [46 78]]
Slice 2 :  [[Geeks for] [Geeks GFG] [gfg geek]]
  • 分片的排序： 在Go语言中，你可以对分片中的元素进行排序。Go语言的标准库提供了排序包，其中包含了不同类型的排序方法，用于对ints、 float64s和strings的片断进行排序。 这些函数总是以升序对切片中的元素进行排序。
    例子
// Go program to illustrate how to sort
// the elements present in the slice
package main
 
import (
    "fmt"
    "sort"
)
 
func main() {
 
    // Creating Slice
    slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"}
    slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89}
 
    fmt.Println("Before sorting:")
    fmt.Println("Slice 1: ", slc1)
    fmt.Println("Slice 2: ", slc2)
 
    // Performing sort operation on the
    // slice using sort function
    sort.Strings(slc1)
    sort.Ints(slc2)
 
    fmt.Println("\nAfter sorting:")
    fmt.Println("Slice 1: ", slc1)
    fmt.Println("Slice 2: ", slc2)
 
}

输出

Before sorting:
Slice 1:  [Python Java C# Go Ruby]
Slice 2:  [45 67 23 90 33 21 56 78 89]

After sorting:
Slice 1:  [C# Go Java Python Ruby]
Slice 2:  [21 23 33 45 56 67 78 89 90]

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Go语言 精品教程