var a = [2]int {1,2}
var b [3]int
b = a // wrong, a and b are different type
var a = [2]int {1,2}
b := a // copy a and assign to b
b[0] = 3
//此时a = [1,2], b = [3, 2]
a := [2][2]int {
{1,2},
{3,4},
} // 最后一个逗号不能少,否则会报错
1. var a [5]int = {1,2,3,4,5}
var b []int = a[1:4] // b = [2,3,4]
2. c := []int {6,7,8} // c = [6,7,8]
a := [...]int {1,2,3,4,5}
b := a[1:4] // a = [1,2,3,4,5], b = [2,3,4]
b[0] = 10 // a = [1,10,3,4,5], b = [10,3,4], b切片length为3,capacity为4(capacity为原数组起始索引到结束包含的元素个数,不能超过原数组capacity)
make(type, len, cap)
a := make([]int, 5, 5) // default为0, a = [0,0,0,0,0]
a := [...]string {"apple", "pair", "banana"} // len = 3, cap = 3
a = append(a, "peach") // len = 4, cap = 6, 长度增加1,当长度超过cap,cap double
当新的元素被添加到切片时,会创建一个新的数组。现有数组的元素被复制到这个新数组中,并返回这个新数组的新切片引用。注意是返回一个新的切片。如果一个函数传入切片,如果在此函数内对切片做append操作,原被传入切片不会变化。
func change(s ...string){
s[1] = "afternoon"
s = append(s, "world")
fmt.Println(s)
}
func main(){
welcome := []string {"good", "morning"}
change(welcome...)
fmt.Println(welcome)
}
输出:
good afternoon world
good afternoon
var list []string
if list == nil{
list = append(list, "apple", "banana")
}
animal := []string {"dog", "cat", "pig", "bird"}
plant := []string {"grass", "tree", "flower"}
obj := append(animal, plant...) // 将切片添加到另一个切片
切片持有对底层数组的引用。只要切片在内存中,数组就不能被垃圾回收。在内存管理方面,这是需要注意的。让我们假设我们有一个非常大的数组,我们只想处理它的一小部分。然后,我们由这个数组创建一个切片,并开始处理切片。这里需要重点注意的是,在切片引用时数组仍然存在内存中。
一种解决方法是使用 copy 函数 func copy(dst,src[]T)int
来生成一个切片的副本。这样我们可以使用新的切片,原始数组可以被垃圾回收。
func countries() []string {
countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
neededCountries := countries[:len(countries)-2]
countriesCpy := make([]string, len(neededCountries))
copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
return countriesCpy
}
func main() {
countriesNeeded := countries()
fmt.Println(countriesNeeded)
}
https://studygolang.com/articles/12121