Was ist Slice in Golang?

In Golang ist ein Slice ein Verweis auf ein zusammenhängendes Fragment eines Arrays. Dieses Fragment kann das gesamte Array oder eine Teilmenge einiger Elemente sein, die durch die Start- und Endindizes identifiziert werden. Die interne Struktur von Slices in der Go-Sprache umfasst im Allgemeinen Adresse, Größe und Kapazität. Wenn ein Datensatz mit dem Schneiden eines Kuchens verglichen wird, ist ein Slice das gewünschte „Stück“. Der Prozess umfasst den Startpunkt (die Startposition der Scheibe) und die Größe des Schnitts (die Größe der Scheibe). Die Kapazität kann als die Größe der Tasche verstanden werden, in der sich die Scheibe befindet.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Ein Slice ist ein Verweis auf ein kontinuierliches Fragment eines Arrays, daher ist ein Slice ein Referenztyp (also eher dem Array-Typ in C/C++ oder dem Listentyp in Python ähnlich). Dieses Fragment kann das gesamte Array sein Es kann sich auch um eine Teilmenge einiger durch den Start- und Endindex identifizierter Elemente handeln. Es ist zu beachten, dass die durch den Endindex identifizierten Elemente nicht im Slice enthalten sind.

Die interne Struktur von Slices in der Go-Sprache umfasst im Allgemeinen Adresse, Größe und Kapazität, um einen Datensatz schnell zu bearbeiten. Wenn ein Datensatz mit dem Schneiden eines Kuchens verglichen wird, ist ein Slice das gewünschte „Stück“. Der Schneidvorgang Einschließlich des Startpunkts (der Startposition der Scheibe) und der Größe des Schnitts (der Größe der Scheibe) kann die Kapazität als die Größe der Tasche verstanden werden, in der sich die Scheibe befindet, wie in der folgenden Abbildung dargestellt.

Abbildung: Slice-Struktur und Speicherzuordnung

Neues Slice aus einem Array oder Slice generieren

Ein Slice zeigt standardmäßig auf einen kontinuierlichen Speicherbereich, der ein Array oder das Slice selbst sein kann.

Das Generieren von Slices aus einem kontinuierlichen Speicherbereich ist eine übliche Operation:

slice [开始位置 : 结束位置]

Die Syntax lautet wie folgt:

• Slice: stellt das Ziel-Slice-Objekt dar;

• Startposition: entspricht der Index des Ziel-Slice-Objekts;

• Endposition: entspricht dem Endindex des Ziel-Slice.

Generieren Sie ein Slice aus einem Array. Der Code lautet wie folgt:

var a  = [3]int{1, 2, 3}
fmt.Println(a, a[1:2])

wobei a ein Array mit 3 ganzzahligen Elementen ist, initialisiert auf die Werte 1 bis 3, verwenden Sie a[1:2], um ein neues zu generieren Slice, Das Ergebnis der Ausführung des Codes ist wie folgt:

[1 2 3]  [2]

wobei [2] das Ergebnis einer [1:2]-Slicing-Operation ist.

Das Generieren eines neuen Slice aus einem Array oder Slice hat die folgenden Eigenschaften:

• Die Anzahl der herausgenommenen Elemente ist: Endposition – Startposition;

• Die herausgenommenen Elemente enthalten nicht den entsprechenden Index Endposition, und das letzte Element des Slice verwendet Slice [len(slice)] Get; Wenn die Standardstartposition verwendet wird, bedeutet dies vom Anfang des kontinuierlichen Bereichs bis zur Endposition; Wenn die Standard-Endposition verwendet wird, bedeutet dies von der Startposition bis zum Ende des gesamten kontinuierlichen Bereichs.

• Wenn beide gleichzeitig standardmäßig eingestellt sind, entspricht dies dem Slice selbst Sind sie gleichzeitig 0, entspricht dies einem leeren Slice und wird im Allgemeinen zum Zurücksetzen des Slice verwendet.

• Wenn der Slice-Elementwert entsprechend der Indexposition genommen wird, beträgt der Wertebereich (0~len(slice)-1). Wenn er den Grenzwert überschreitet, wird beim Generieren des Slice ein Laufzeitfehler gemeldet Die Endposition kann in len(slice) ausgefüllt werden, es wird jedoch kein Fehler gemeldet. [Verwandte Empfehlungen:

  Go-Video-Tutorial
]

• Machen wir uns anhand von Beispielen mit den Eigenschaften des Slicing vertraut.

• 1) Slices aus dem angegebenen Bereich generieren

Slices und Arrays sind untrennbar miteinander verbunden. Wenn das Array als Bürogebäude verstanden wird, bedeutet Slicing die Vermietung verschiedener aufeinanderfolgender Etagen an Benutzer. Der Vermietungsprozess erfordert die Auswahl der Startetage. und im Endgeschoss werden durch diesen Prozess Slices generiert:

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])

Die Codeausgabe lautet wie folgt:

Im Code wird ein 30-stöckiges Hochhaus erstellt Der Bereich des Arrays reicht von 1 bis 30 und repräsentiert verschiedene unabhängige Etagen. Die Ausgabeergebnisse sind unterschiedliche Miet- und Verkaufspläne.

Die Codebeschreibung lautet wie folgt:

Zeile 8, versuchen Sie, eine Intervalletage zu vermieten.

Linie 11, zu vermieten ab 20 Etagen.

Linie 14, Anmietung von Etagen unter 2 Etagen, in der Regel gewerbliche Geschäfte.

• Slices sind ein bisschen wie Zeiger in der C-Sprache, aber auf Kosten von Speicheroperationen außerhalb der Grenzen erhöhen sie die Größe, die dem Slice entspricht Wenn Sie ein Slice verwenden, können Sie nicht auf das Innere des Slice zugreifen. Adresse und Größe werden manuell angepasst, sodass Slices sicherer und leistungsfähiger sind als Zeiger.

• 2) Stellt das Original-Slice dar.

Wenn im Format der Generierung von Slices die Start- und Endpositionen ignoriert werden, stellt das generierte Slice ein Slice dar, das mit dem Original-Slice übereinstimmt, und das generierte Slice stimmt mit dem überein Original-Slice in den Daten Der Inhalt ist ebenfalls konsistent, der Code lautet wie folgt:

• a := []int{1, 2, 3}
  fmt.Println(a[:])

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

  

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

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

  a := []int{1, 2, 3}
  fmt.Println(a[0:0])

  代码输出如下：

  

  直接声明新的切片

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

  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)

  代码输出结果：

  

  代码说明如下：

  • 第 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))

  代码输出如下：

  

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

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

  温馨提示

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

  更多编程相关知识，请访问：编程视频！！

  Das obige ist der detaillierte Inhalt vonWas ist Slice in Golang?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!