- Published on
Array dan Slice di Golang
- Authors
- Name
- Enggar Tivandi
Array dan Slice di Golang
Kali ini saya ingin membagikan artikel mengenai array dan slice di golang. Seperti yang kita tahu di golang terdapat struktur data array dan slice, yang membedakan keduanya adalah di bagian kapasitasnya. Jika array di golang kapasitasnya adalah tetap maka slice di golang dapat bertambah. Untuk lebih jelasnya bisa dilihat contoh kode dibawah ini
package main
import (
"fmt"
)
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slc := []int{1, 2, 3, 4, 5}
fmt.Println(arr) // output: [1, 2, 3, 4, 5]
fmt.Println(len(arr)) // output: 5
fmt.Println(cap(arr)) // output: 5
fmt.Println(slc) // output: [1, 2, 3, 4, 5]
fmt.Println(len(arr)) // output: 5
fmt.Println(cap(arr)) // output: 5
}
Menambah data
Untuk menambah data di slice kita dapat menggunakan fungsi append untuk cara penggunaanya bisa dilihat contoh kode dibawah ini
package main
import (
"fmt"
)
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slc := []int{1, 2, 3, 4, 5}
fmt.Println(arr) // output: [1, 2, 3, 4, 5]
fmt.Println(len(arr)) // output: 5
fmt.Println(cap(arr)) // output: 5
fmt.Println(slc) // output: [1, 2, 3, 4, 5]
fmt.Println(len(arr)) // output: 5
fmt.Println(cap(arr)) // output: 5
// menambahkan data ke slice
slc = append(slc, 1, 2, 3, 4, 5, 6)
fmt.Println(slc) // output: [1 2 3 4 5 1 2 3 4 5 6]
fmt.Println(len(slc)) // output: 11
fmt.Println(cap(slc)) // output: 12
}
lalu apa yang terjadi apabila kita menambahkan data baru ke array? karena array memiliki kapasitas yang tetap maka ketika kita menambahkan data baru ke dalam array hasilnya akan error.
arr = append(arr, 1, 2, 3, 4, 5, 6)
apabila kode diatas di run / di kompilasi maka akan muncul error seperti ini
Memotong data
Ketika kita memotong array maka hasil dari potongan tersebut adalah berupa slice. untuk memotong data kita bisa menggunakan cara seperti ini
data[start:end]
Ketika kita memotong data menggunakan bentuk seperti diatas maka cara bacanya adalah seperti ini
Potong data dari index-start hingga index-end
contoh kodenya seperti ini
slc := []int{1, 2, 3, 4, 5}
fmt.Println(slc[0:2]) // [1, 2]
data[start:]
Ketika kita memotong data menggunakan bentuk seperti diatas maka cara bacanya adalah seperti ini
Potong data dari index-start hingga akhir index data / paling ujung kanan
contoh kodenya seperti ini
slc := []int{1, 2, 3, 4, 5}
fmt.Println(slc[2:]) // [3, 4, 5]
data[:end]
Ketika kita memotong data menggunakan bentuk seperti diatas maka cara bacanya adalah seperti ini
Potong data dari awal index data / paling ujung kiri hingga index-end
contoh kodenya seperti ini
slc := []int{1, 2, 3, 4, 5}
fmt.Println(slc[:3]) // [1, 2, 3]
data[:]
Ketika kita memotong data menggunakan bentuk seperti diatas maka cara bacanya adalah seperti ini
Potong data dari awal index data / paling ujung kiri hingga akhir index data / paling ujung kanan
ini bisa disebut juga merubah bentuk data ke slice jika tipe data asalnya berupa array. untuk contoh kodenya seperti ini
slc := []int{1, 2, 3, 4, 5}
fmt.Println(slc[:]) // [1, 2, 3, 4, 5]
data[start:end:cap]
Ketika kita memotong data sebenarnya kapasitas dari data yang dipotong akan sama seperti data asal. untuk memodifikasi kapasitas data di slice yang baru kita bisa menambahkan parameter setelah penunjuk index akhir slice. untuk contoh penggunaanya seperti berikut
slc := []int{1, 2, 3, 4 ,5}
newSlc1 := slc[0:2]
fmt.Println(newSlc1) // [1, 2]
fmt.Println(len(newSlc1)) // 2
fmt.Println(cap(newSlc1)) // 5
newSlc2 := slc[0:2:2] // memotong data dari index ke-0 hingga index ke-2 dan ubah kapasitas datanya menjadi 2
fmt.Println(newSlc2) // [1, 2]
fmt.Println(len(newSlc2)) // 2
fmt.Println(cap(newSlc2)) // 2
Menghapus data
Di golang kita bisa menghapus data dari slice namun tidak di array. untuk menghapus data di slice kita bisa menggunakan beberapa teknik, misalnya seperti berikut
- append
Kita bisa menghapus data dari slice dengan cara memotong slice lalu menggabungkannya dengan slice baru. contoh penggunaanya seperti ini
package main
import "fmt"
func main() {
slc := []int{1, 2, 3, 4, 5, 6}
// delete data index-2
slc = append(slc[:2], slc[3:]...)
fmt.Println(slc) // [1, 2, 4, 5, 6]
fmt.Println(len(slc)) // 5
fmt.Println(cap(slc)) // 6
}
apabila ingin merubah kapasitasnya sekalian kita bisa menambahkan parameter setelah index potong
package main
import "fmt"
func main() {
slc := []int{1, 2, 3, 4, 5, 6}
// delete data index-2
-- slc = append(slc[:2], slc[3:]...)
++ slc = append(slc[:2:len(slc)-1]. slc[3:]...)
fmt.Println(slc) // [1, 2, 4, 5, 6]
fmt.Println(len(slc)) // 5
-- fmt.Println(cap(slc)) // 6
++ fmt.Println(cap(slc)) // 5
}
- Menukar posisi
Kita bisa menukar posisi data yang ingin dihapus dengan data paling akhir, sehingga ketika kita ingin menghapusnya cukup memotong bagian jumlah data - 1
package main
import "fmt"
func main() {
slc := []int{1, 2, 3, 4, 5}
// hapus data index-3
slc[3] = slc[len(slc)-1]
slc = slc[:len(slc)-1]
fmt.Println(slc) // [1, 2, 3, 5]
}
- Menggunakan fungsi
slices.Delete
Jika menggunakan golang versi 1.2 keatas maka ada fungsi baru Delete dari package slices. kita bisa menggunakannya untuk mendelete data dari slice cara penggunaanya seperti berikut
package main
import (
"fmt"
"slices"
)
func main() {
slc := []int{1, 2, 3, 4, 5}
// menghapus data dari index-0 hingga index-3
slc = slices.Delete(slc, 0, 3)
fmt.Println(slc) // [4, 5]
fmt.Println(len(slc)) // 2
fmt.Println(cap(slc)) // 5
}
Memodifikasi data
Baik di array maupun di slice kita bisa langsung melakukan perubahan data dengan menyeleksi index yang akan diubah lalu mengisikan nilai baru kedalamnya. contoh penggunaanya seperti ini:
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slc := []int{6, 7, 8, 9}
fmt.Println("Data original:")
fmt.Println("Array:", arr) // [1, 2, 3, 4, 5]
fmt.Println("Slice:", slc) // [6, 7, 8, 9]
// ubah data index-2 menjadi 10
fmt.Println("\nData setelah diubah:")
arr[2] = 10
fmt.Println("Array:", arr) // [1, 2, 10, 4, 5]
slc[2] = 10
fmt.Println("Slice:", slc) // [6, 7, 10, 9]
}
melakukan modifikasi data terlihat sederhana, namun ketika kita memotong data dari array / slice perlu diperhatikan bahwa perubahan data di slice baru akan berdampak ke data sumber ketika index yang diubah masih dalam jangkauan kapasitas data sumber. contohnya seperti ini
package main
import "fmt"
func main() {
arr := [5]int{1, 2, 3, 4, 5}
slc := []int{6, 7, 8, 9}
fmt.Println("Data original:")
fmt.Println("Array:", arr) // [1, 2, ,3, 4, 5]
fmt.Println("Slice:", slc) // [6, 7, 8, 9]
newArr := arr[:]
newSlc := slc[:]
// perubahan data akan berefek pada variable arr dan slc karena index masih dalam jangkauan kapasitas arr dan slc
newArr[3] = 11
newSlc[2] = 12
fmt.Println("\nData copy:")
fmt.Println("Array:", newArr) // [1, 2, 3, 11, 5]
fmt.Println("Slice:", newSlc) // [6, 7, 12, 9]
fmt.Println("\nData original:")
fmt.Println("Array:", arr) // [1, 2, 3, 11, 5]
fmt.Println("Slice:", slc) // [6, 7, 12, 9]
newArr = append(newArr, 67, 99)
newSlc = append(newSlc, 100, 1000)
fmt.Println("\nData copy:")
fmt.Println("Array:", newArr) // [1, 2, 3, 11, 5, 67, 99]
fmt.Println("Array Len:", len(newArr)) // 7
fmt.Println("Array Cap:", cap(newArr)) // 10
fmt.Println("\nSlice:", newSlc) // [6, 7, 12, 9, 100, 1000]
fmt.Println("Slice Len:", len(newSlc)) // 6
fmt.Println("Slice Cap:", cap(newSlc)) // 8
// perubahan data tidak akan berefek pada arr dan slc karena index berada diluar jangkauan kapasitas arr dan slc
newArr[5] = 130
newSlc[5] = 130
fmt.Println("\nData copy:")
fmt.Println("Array:", newArr) // [1, 2, 3, 11, 5, 67, 130]
fmt.Println("Slice:", newSlc) // [6, 7, 12, 9, 100, 1000, 130]
fmt.Println("\nData original:")
fmt.Println("Array:", arr) // [1, 2, 3, 11, 5]
fmt.Println("Slice:", slc) // [6, 7, 12, 9]
}
Sederhananya jika kita mengubah index ke-2 yang data awalnya memiliki kapasitas 10 maka, data asli juga akan ikut berubah. namun jika kita memodifikasi data index diatas 10 maka data asli tidak akan ikut berefek
Mungkin sekian penjelasan array dan slice di golang dari saya, jika ada kesalahan dari penjelasan diatas bisa komen dibawah. terima kasih.