Drei einfache Möglichkeiten, Golang-Slices zu verwenden und ihre Unterschiede

Das Folgende ist die Golang-Tutorial-Kolumne über drei einfache Möglichkeiten, Golang-Scheiben zu verwenden und ihre Unterschiede. Ich hoffe, dass sie Freunden in Not hilfreich sein wird!

Konzept

Slice ist eine praktischere, flexiblere und leistungsfähigere Datenstruktur, die auf Arrays basiert. Ein Slice speichert keine Elemente, sondern nur einen Verweis auf ein vorhandenes Array.

Drei Methoden und detaillierte Fälle

①Definieren Sie ein Slice und lassen Sie das Slice dann auf ein bereits erstelltes Array verweisen.

package main
import (    "fmt")

func main() {    var arr [5]int = [...]int {1, 2, 3, 4, 5}    var slice = arr[1:3]
    fmt.Println("arr=", arr)
    fmt.Println("slice=", slice)
    fmt.Println("slice len", len(slice))
    fmt.Println("slice cap", cap(slice))
}

②Erstellen Sie das Slice über make. Grundlegende Syntax: var Slice-Name []type = make([], len, [cap]); Parameterbeschreibung: type ist der Datentyp, len ist die Größe und cap ist die Slice-Kapazität (Kapazität muss >= Länge)

1. Erstellen eines Slice durch make kann die Slice-Größe und -Kapazität angeben
2. Wenn jedem Element des Slice kein Wert zugewiesen ist, wird der Standardwert (int, float=>0, strint=>"" , bool=> ;false)
3. Das Array, das dem von Rongguos Make-Methode erstellten Slice entspricht, wird von der unteren Ebene von make verwaltet und ist für die Außenwelt nicht sichtbar. Das heißt, auf jedes Element kann nur über Slice zugegriffen werden

package main
import (    "fmt")


func main() {    var slice []float64 = make([]float64, 5, 10)    //没有给值，默认都是0
    fmt.Println(slice)  //[0 0 0 0 0]    //赋值
    slice[1] = 5
    slice[3] = 10  
    fmt.Println(slice)  //[0 5 0 10 0]

    fmt.Println("slice大小:", len(slice)) //slice大小: 5
    fmt.Println("slice容量:", cap(slice)) //slice容量: 10}

③Definieren Sie ein Slice und geben Sie es direkt an. Für bestimmte Arrays ähnelt das Verwendungsprinzip der Make-Methode

package main
import (    "fmt")


func main() {    var slice []string = []string{"zhangsan", "lisi", "wangwu"}
    fmt.Println("slice=", slice) //slice= [zhangsan lisi wangwu]
    fmt.Println("slice len", len(slice)) //slice len 3
    fmt.Println("slice cap", cap(slice)) //slice cap 3}

Der Unterschied zwischen der ersten und der zweiten Methode

Die erste Möglichkeit besteht darin, direkt zu referenzieren Das Array. Dieses Array existiert im Voraus und ist für den Programmierer sichtbar. Die zweite Möglichkeit besteht darin, mit Make ein Array zu erstellen, das vom Slice unten verwaltet wird und für Programmierer unsichtbar ist
Ergänzung: Fragmentarische Fälle

package main
import "fmt"func main() {    // 和数组不同的是，切片的长度是可变的。    // 我们可以使用内置函数make来创建一个长度不为零的切片    // 这里我们创建了一个长度为3，存储字符串的切片，切片元素    // 默认为零值，对于字符串就是""。
    s := make([]string, 3)
    fmt.Println("emp:", s)    // 可以使用和数组一样的方法来设置元素值或获取元素值
    s[0] = "a"
    s[1] = "b"
    s[2] = "c"
    fmt.Println("set:", s)
    fmt.Println("get:", s[2])    // 可以用内置函数len获取切片的长度
    fmt.Println("len:", len(s))    // 切片还拥有一些数组所没有的功能。    // 例如我们可以使用内置函数append给切片追加值，然后    // 返回一个拥有新切片元素的切片。    // 注意append函数不会改变原切片，而是生成了一个新切片，    // 我们需要用原来的切片来接收这个新切片
    s = append(s, "d")
    s = append(s, "e", "f")
    fmt.Println("apd:", s)    // 另外我们还可以从一个切片拷贝元素到另一个切片    // 下面的例子就是创建了一个和切片s长度相同的新切片    // 然后使用内置的copy函数来拷贝s的元素到c中。
    c := make([]string, len(s))
    copy(c, s)
    fmt.Println("cpy:", c)    // 切片还支持一个取切片的操作 "slice[low:high]"    // 获取的新切片包含元素"slice[low]"，但是不包含"slice[high]"    // 下面的例子就是取一个新切片，元素包括"s[2]"，"s[3]"，"s[4]"。
    l := s[2:5]
    fmt.Println("sl1:", l)    // 如果省略low，默认从0开始，不包括"slice[high]"元素
    l = s[:5]
    fmt.Println("sl2:", l)    // 如果省略high，默认为len(slice)，包括"slice[low]"元素
    l = s[2:]
    fmt.Println("sl3:", l)    // 我们可以同时声明和初始化一个切片
    t := []string{"g", "h", "i"}
    fmt.Println("dcl:", t)    // 我们也可以创建多维切片，和数组不同的是，切片元素的长度也是可变的。
    twoD := make([][]int, 3)    for i := 0; i < 3; i++ {
        innerLen := i + 1
        twoD[i] = make([]int, innerLen)        for j := 0; j < innerLen; j++ {
            twoD[i][j] = i + j
        }
    }
    fmt.Println("2d: ", twoD)
}

//结果emp: [  ]set: [a b c]get: c
len: 3apd: [a b c d e f]
cpy: [a b c d e f]
sl1: [c d e]
sl2: [a b c d e]
sl3: [c d e f]
dcl: [g h i]
2d:  [[0] [1 2] [2 3 4]]

Das obige ist der detaillierte Inhalt vonDrei einfache Möglichkeiten, Golang-Slices zu verwenden und ihre Unterschiede. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!