Berbeda dengan array, dengan slice kita bisa mengelompokkan data berapapun yang kita inginkan tanpa harus menentukan panjang datanya. Selain itu panjang jumlah datanya tidak menenentukan jenis slice karena ukuran slice bisa bermacam -macam, yang menentukan jenis slice hanyalah tipe data yang akan dipopulasikan.
Mendefinisikan dan Mengelompokkan Data Menggunakan Slice
Cara untuk mendefinisikan slice adalah dengan menggunakan fungsi make, dengan argumen tipe data dan panjang jumlah data yang digunakan.
package main
import "fmt"
func main() {
nilai := make([]int, 3)
nilai[0] = 90
nilai[1] = 60
nilai[2] = 70
fmt.Println(nilai)
}
Menggunakan Sintak Literal
Sintak literal untuk mendefinisikan slice sama dengan array, dan jumlah ukuran datanya mengikuti jumlah nilai literalnya.
package main
import "fmt"
func main() {
nilai := []int{90, 60, 70}
fmt.Println(nilai)
}
Menambahkan elemen ke slice
Keuntungan menggunakan slice yaitu dapat leluasa menambahkan elemen karena penjang jumlah datanya lebih dinamis. Fungsi append dapat digunakan untuk menambahkan satu atau lebih dari satu data ke dalam slice dipisahkan menggunakan koma.
package main
import "fmt"
func main() {
nilai := []int{90, 60, 70}
nilai = append(nilai, 50, 80)
fmt.Println(nilai)
}
Setiap slice memiliki backing array, tetapi slice datanya independen. Contoh berikut menunjukkan bahwa merubah suatu slice tidak merubah slice lain.
package main
import "fmt"
func main() {
nilai1 := []int{90, 60, 70}
nilai2 := nilai1
nilai3 := append(nilai1, 3, 4)
nilai1[0] = 80
fmt.Println("Nilai 1:", nilai1)
fmt.Println("Nilai 2:", nilai2)
fmt.Println("Nilai 2:", nilai3)
}
Hasil output:
Nilai 1: [80 60 70]
Nilai 2: [80 60 70]
Nilai 3: [90 60 70 3 4]
Dari hasil program diatas menunjukkan bahwa nilai1 dan nilai2 memiliki backing array yang sama sehingga ketika nilai1 dirubah nilai2 juga ikut berubah, namun slice nilai1 dan nilai3 masing-masing adalah slice yang independen, sehingga ketika nilai1 berubah, nilai3 tidak berubah.
Menentukan Kapasitas Slice
Jika ingin membatasi jumlah item pada slice, kita bisa menentukan kapasitas ketika menggunakan fungsi make.
Seperti yang di sebutkan sebelumnya panjang data adalah jumlah data yang saat ini digunakan, sedangkan kapasitas adalah jumlah data yang dapat disimpan dalam slice tersebut.
package main
import "fmt"
func main() {
nama := make([]string, 2, 5)
nama[0] = "Peci"
nama[1] = "Blangkon"
fmt.Println("nama :", nama)
fmt.Println("Jumlah :", len(nama))
fmt.Println("Kapasitas :", cap(nama))
}
Menggabungkan dua atau lebih Slice
Fundi append tidak hanya untuk menambahkan nilai kedalam slice tapi juga menggabungkan dua slice atau lebih.
Untuk menggabungkan slice, pada argumen append(), slice kedua dan setelahnya yang akan digabungkan harus diikuti dengan tanda titik tiga (...). Hal ini dikarenakan built-in append() adalah untuk menambahkan nilai, jadi jika kita memberi nama arraynya saja, maka akan muncul pesan error ketika dikompile.
package main
import "fmt"
func main() {
buah := make([]string, 2, 5)
buah[0] = "Semangka"
buah[1] = "Durian"
buahLain := []string{"Jambu", "Mangga"}
buahBuahan := append(buah, buahLain...)
fmt.Println("buah :", buah)
fmt.Println("buahLain :", buahLain)
fmt.Println("buahBuahan :", buahBuahan)
}
Membuat Slice dari Array
Slice dapat dibuat menggunakan nilai yang telah dikelompokkan menggunakan array.
Berikut contoh membuat slice pada variabelseringDibeli kita menyalin data dari array produk degan menggunakan jangkauan antara data kedua sampai data keempat. Sedangkan variabel stok menyalin semua data array untuk dijadikan slice.
package main
import "fmt"
func main() {
produk := [5]string{"Topi", "Baju", "Kaos", "Celana", "Jas Hujan"}
seringDibeli := produk[1:4]
stok := produk[:]
fmt.Println("Produk yang sering dibeli:", seringDibeli)
fmt.Println("Persediaan :", stok)
}
Menentukan Kapasitas Saat Membuat Slice Dari Array
Jangkauan juga dapat digunakan untuk menentukan jangkauan kapasitas maksimum slice yang akan dibuat ketika membuat slice dari array.
Contoh pada program berikut variabel seringDibeli, kita membuat slice dari array menggunakan jangkauan data kedua hingga data ketiga, dan menentukan maksimum kapasitas dari elemen kedua hingga elemen ke lima.
package main
import "fmt"
func main() {
produk := [5]string{"Topi", "Baju", "Kaos", "Celana", "Jas Hujan"}
seringDibeli := produk[1:3:5]
stok := produk[:]
fmt.Printf("produk %v jumlahnya %d dan kapasitasnya %d\n",
produk, len(produk), cap(produk))
fmt.Printf("seringDibeli %v jumlahnya %d dan kapasitasnya %d\n",
seringDibeli, len(seringDibeli), cap(seringDibeli))
fmt.Printf("stok %v jumlahnya %d dan kapasitasnya %d\n",
stok, len(stok), cap(stok))
}
Jika program dijalankan maka kapasitas slice seringDibeli adalah 4, dikarenakan jangkauannya dimulai dari elemen kedua pada array hingga kelima.
produk [Topi Baju Kaos Celana Jas Hujan] jumlahnya 5 dan kapasitasnya 5
seringDibeli [Baju Kaos] jumlahnya 2 dan kapasitasnya 4
stok [Topi Baju Kaos Celana Jas Hujan] jumlahnya 5 dan kapasitasnya 5
Menggunakan Fungsi copy()
Fungsi copy() menyalin elemen antar dua slice. Fungsi ini akan memastikan slice memiliki kapasitas yang cukup untuk menyalin data dari slice lain.
package main
import "fmt"
func main() {
produk := [5]string{"Topi", "Baju", "Kaos",
"Celana", "Jas Hujan"}
stok := produk[2:]
dijual := make([]string, 2)
copy(dijual, stok)
fmt.Printf("produk = %v\n", produk)
fmt.Printf("stok = %v\n", stok)
fmt.Printf("dijual = %v\n", dijual)
}
Menyalin Slice dengan ukuran yang berbeda
Jika slice tujuan ukurannya lebih besar daripada slice yang akan disalin, maka penyalinan akan dilakukan hingga elemen akhir slice yang disalin.
Berikut contoh penyalinan berhenti hingga akhir elemen slice produkPengganti.
package main
import "fmt"
func main() {
produk := []string{"Topi", "Baju", "Kaos",
"Celana", "Jas Hujan"}
produkPengganti := []string{"Sepatu", "Tas"}
copy(produk, produkPengganti)
fmt.Printf("produk = %v\n", produk)
}
Menghapus Elemen Slice
Untuk menghapus elemen pada slice kita bisa memanfaatkan jangkauan ketika menggunakan fungsi append().
package main
import "fmt"
func main() {
produk := []string{"Topi", "Baju", "Kaos",
"Celana", "Jas Hujan"}
hapusIndex := 2
fmt.Println("Produk yang di hapus :", produk[hapusIndex])
produk = append(produk[:hapusIndex],
produk[hapusIndex+1:]...)
fmt.Printf("produk = %v\n", produk)
}
Mengurutkan Slice
Untuk mengurutkan data pada slice, kita dapat menggunakan standar librari dalam paket sort yang mendefinisikan beberapa fungsi untuk mengurutkan beberapa jenis slice.
Contoh program berikut mengurutkan slice berjenis string menggunakan fungsi sort.Strings().
package main
import (
"fmt"
"sort"
)
func main() {
produk := []string{"Topi", "Baju", "Kaos",
"Celana", "Jas Hujan"}
fmt.Printf("produk = %v\n", produk)
sort.Strings(produk)
fmt.Printf("urutan = %v\n", produk)
}
Membandingkan Slice
Berbeda dengan array, slice hanya dibandingkan dengan nilai nil, membandingkan antar dua slice akan menampikan pesan error.
Cara lain untuk membandingkan slice adalah dengan menggunakan fungsi DeepEqual() yang disediakan pada standar librari dengan nama paket reflect
package main
import (
"fmt"
"reflect"
)
func main() {
produk := []string{"Topi", "Baju", "Kaos", "Celana", "Jas Hujan"}
stok := produk[:]
sama := reflect.DeepEqual(produk, stok)
fmt.Printf("produk dan stok adalah slice yang sama: %v\n", sama)
}
Menggunakan array dari sebuah slice
Jika kita membutuhkan array, misalnya untuk digunakan pada sebuah fungsi yang hanya dapat menggunakan array, maka kita bisa mengkonversi slice secara eksplisit menjadi array menggunakan pointer.
package main
import (
"fmt"
)
func main() {
produk := []string{"Topi", "Baju", "Kaos", "Celana", "Jas Hujan"}
produkArray := (*[3]string)(produk)
fmt.Println("Produk :", produk)
fmt.Println("ProdukArray :", *produkArray)
}
Hal yang diperhatikan saat menentukan tipe array yang akan dibuat selain tipe data array, jumlah elemen bisa kurang atau sama dengan slice yang disalin, tetapi tidak boleh melebihi jumlah elemen pada slice.