Pergi - Irisan

Go Slice adalah abstraksi dari Go Array. Go Array memungkinkan Anda untuk mendefinisikan variabel yang dapat menampung beberapa item data dari jenis yang sama tetapi tidak menyediakan metode bawaan untuk meningkatkan ukurannya secara dinamis atau mendapatkan sub-arraynya sendiri. Irisan mengatasi batasan ini. Ini menyediakan banyak fungsi utilitas yang dibutuhkan pada Array dan banyak digunakan dalam pemrograman Go.

Mendefinisikan sepotong

Untuk menentukan slice, Anda dapat mendeklarasikannya sebagai array tanpa menentukan ukurannya. Atau, Anda bisa menggunakanmake berfungsi untuk membuat irisan.

var numbers []int /* a slice of unspecified size */
/* numbers == []int{0,0,0,0,0}*/
numbers = make([]int,5,5) /* a slice of length 5 and capacity 5*/

fungsi len () dan cap ()

Slice adalah abstraksi atas larik. Ini sebenarnya menggunakan array sebagai struktur yang mendasari. Itulen() fungsi mengembalikan elemen yang disajikan dalam potongan di mana cap()fungsi mengembalikan kapasitas potongan (yaitu, berapa banyak elemen yang dapat ditampung). Contoh berikut menjelaskan penggunaan slice -

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

len = 3 cap = 5 slice = [0 0 0]

Irisan nol

Jika sebuah slice dideklarasikan tanpa input, maka secara default, slice diinisialisasi sebagai nil. Panjang dan kapasitasnya nol. Misalnya -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   if(numbers == nil){
      fmt.Printf("slice is nil")
   }
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

len = 0 cap = 0 slice = []
slice is nil

Subslicing

Slice memungkinkan batas bawah dan batas atas ditentukan untuk mendapatkan sub-bagian yang digunakannya[lower-bound:upper-bound]. Misalnya -

package main

import "fmt"

func main() {
   /* create a slice */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)
   
   /* print the original slice */
   fmt.Println("numbers ==", numbers)
   
   /* print the sub slice starting from index 1(included) to index 4(excluded)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   
   /* missing lower bound implies 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   
   /* missing upper bound implies len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   
   /* print the sub slice starting from index 0(included) to index 2(excluded) */
   number2 := numbers[:2]
   printSlice(number2)
   
   /* print the sub slice starting from index 2(included) to index 5(excluded) */
   number3 := numbers[2:5]
   printSlice(number3)
   
}
func printSlice(x []int){
   fmt.Printf("len = %d cap = %d slice = %v\n", len(x), cap(x),x)
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

len = 9 cap = 9 slice = [0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len = 0 cap = 5 slice = []
len = 2 cap = 9  slice = [0 1]
len = 3 cap = 7 slice = [2 3 4]

fungsi append () dan copy ()

Satu dapat meningkatkan kapasitas irisan menggunakan append()fungsi. Menggunakancopy()fungsi, konten potongan sumber disalin ke potongan tujuan. Misalnya -

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)
   
   /* append allows nil slice */
   numbers = append(numbers, 0)
   printSlice(numbers)
   
   /* add one element to slice*/
   numbers = append(numbers, 1)
   printSlice(numbers)
   
   /* add more than one element at a time*/
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
   
   /* create a slice numbers1 with double the capacity of earlier slice*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)
   
   /* copy content of numbers to numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Ketika kode di atas dikompilasi dan dijalankan, itu menghasilkan hasil sebagai berikut -

len = 0 cap = 0 slice = []
len = 1 cap = 2 slice = [0]
len = 2 cap = 2 slice = [0 1]
len = 5 cap = 8 slice = [0 1 2 3 4]
len = 5 cap = 16 slice = [0 1 2 3 4]