Accesarea elementelor unui slice
Citirea unei valori dintr-un slice se face prin index: pune numărul poziției între paranteze pătrate.
Pozițiile se numără de la 0, deci [0] este primul element și [1] al doilea, continuând la fel prin tot slice-ul.
Exemplu
Afișarea indexurilor 0 și 2 arată prima și a treia valoare din prices:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
prices := []int{10, 20, 30}
fmt.Println(prices[0])
fmt.Println(prices[2])
}
Modificarea elementelor unui slice
Atribuirea la un index suprascrie valoarea stocată acolo.
Exemplu
A treia valoare din prices se schimbă din 30 în 50:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
prices := []int{10, 20, 30}
prices[2] = 50
fmt.Println(prices[0])
fmt.Println(prices[2])
}
Adăugarea elementelor la un slice
Funcția append() adaugă valori noi după ultimul element. Atribuie rezultatul înapoi slice-ului, așa cum arată sintaxa:
Exemplu
Două valori noi, 20 și 21, se adaugă la sfârșitul lui myslice1. Lungimea lui crește de la 6 la 8, iar capacitatea crește pentru a face loc:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
myslice1 := []int{1, 2, 3, 4, 5, 6}
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("lungime = %d\n", len(myslice1))
fmt.Printf("capacitate = %d\n", cap(myslice1))
myslice1 = append(myslice1, 20, 21)
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("lungime = %d\n", len(myslice1))
fmt.Printf("capacitate = %d\n", cap(myslice1))
}
Sintaxă
slice_name = append(slice_name, element1, element2, ...)
Adăugarea unui slice la alt slice
append() poate adăuga și un slice întreg la sfârșitul altuia, așa cum arată sintaxa.
Notă: Cele trei puncte de după slice2 sunt obligatorii. Ele îi spun lui Go să transmită elementele slice-ului unul câte unul.
Exemplu
Valorile din myslice2 vin după cele din myslice1, iar rezultatul combinat ajunge în myslice3:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
myslice1 := []int{1, 2, 3}
myslice2 := []int{4, 5, 6}
myslice3 := append(myslice1, myslice2...)
fmt.Printf("myslice3=%v\n", myslice3)
fmt.Printf("lungime=%d\n", len(myslice3))
fmt.Printf("capacitate=%d\n", cap(myslice3))
}
Sintaxă
slice3 = append(slice1, slice2...)
Modificarea lungimii unui slice
Lungimea unui array este fixă, dar lungimea unui slice se poate schimba.
Exemplu
myslice1 acoperă la început patru elemente din arr1, apoi este secționat din nou până la două. Adăugarea a patru valori îl aduce la șase, ceea ce depășește capacitatea lui de 5, așa că și capacitatea crește:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
arr1 := [6]int{9, 10, 11, 12, 13, 14}
myslice1 := arr1[1:5]
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("lungime = %d\n", len(myslice1))
fmt.Printf("capacitate = %d\n", cap(myslice1))
myslice1 = arr1[1:3]
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("lungime = %d\n", len(myslice1))
fmt.Printf("capacitate = %d\n", cap(myslice1))
myslice1 = append(myslice1, 20, 21, 22, 23)
fmt.Printf("myslice1 = %v\n", myslice1)
fmt.Printf("lungime = %d\n", len(myslice1))
fmt.Printf("capacitate = %d\n", cap(myslice1))
}
Eficiența memoriei
Un slice păstrează în memorie întregul array de bază, chiar dacă folosești doar o mică parte din el.
Așadar, când array-ul este mare și ai nevoie doar de câteva dintre elementele lui, varianta mai bună este să le copiezi cu funcția copy().
Copiază-le într-un slice nou, iar acel slice primește propriul array de bază, care conține doar ce îți trebuie. Astfel programul tău folosește mai puțină memorie.
Exemplu
numbers conține 15 valori, dar sunt necesare doar primele 5. Ele sunt copiate în numbersCopy, creat cu make(), care are o lungime și o capacitate de doar 5:
Ieșire: program Go și ieșirea capturată
package main
import ("fmt")
func main() {
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}
// Slice-ul original
fmt.Printf("numbers = %v\n", numbers)
fmt.Printf("lungime = %d\n", len(numbers))
fmt.Printf("capacitate = %d\n", cap(numbers))
// Creează o copie doar cu numerele necesare
neededNumbers := numbers[:len(numbers)-10]
numbersCopy := make([]int, len(neededNumbers))
copy(numbersCopy, neededNumbers)
fmt.Printf("numbersCopy = %v\n", numbersCopy)
fmt.Printf("lungime = %d\n", len(numbersCopy))
fmt.Printf("capacitate = %d\n", cap(numbersCopy))
}
Sintaxă
copy() primește două slice-uri, o destinație dest și o sursă src, și copiază datele din sursă în destinație. Valoarea returnată îți spune câte elemente au fost copiate.
copy(dest, src)