Go基础Slice教程详解

type slice struct { 
 Length  int
 Capacity  int
 ZerothElement *byte
}

[]元素类型>{元素1, 元素2, …}

c := []int{6, 7, 8}

s1 := make([]int, 5) //长度和容量都是 5
 s2 := make([]int, 3, 10) //长度是3，容量是10
 fmt.Println(cap(s1),s2)

slice :=[]int{1,2,3,4,5}
 slice1 := slice[:]
 slice2 := slice[0:]
 slice3 := slice[:5]
 fmt.Println(slice1)
 fmt.Println(slice2)
 fmt.Println(slice3)

slice := []int{1, 2, 3, 4, 5}
 newSlice := slice[1:3]
 newSlice[0] = 10
 fmt.Println(slice)
 fmt.Println(newSlice)

package main
import (
 "fmt"
)
func main() {
 arr := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
 slice := arr[2:5]
 fmt.Println("array before", arr)
 for i := range slice {
  slice[i]++
 }
 fmt.Println("array after ", arr)
}

array before [0 1 2 3 4 5 6 7 8 9]
array after [0 1 3 4 5 5 6 7 8 9]

package main
import (
 "fmt"
)
func main() {
 array := [4]int{10, 20 ,30, 40}
 slice1 := array[:]
 slice2 := array[:]
 fmt.Println("array before change:", array)
 slice1[0] = 60
 fmt.Println("array after modification to slice slice1:", array)
 slice2[1] = 70
 fmt.Println("array after modification to slice slice2:", array)
}

array before change: [10 20 30 40]
array after modification to slice slice1: [60 20 30 40]
array after modification to slice slice2: [60 70 30 40]

package main
import (
 "fmt"
)
func main() {
 fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
 fruitslice := fruitarray[1:3]
 fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) // length of is 2 and capacity is 6
}

package main
import (
 "fmt"
)
func main() {
 fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
 fruitslice := fruitarray[1:3]
 fmt.Printf("length of slice %d capacity %d\n", len(fruitslice), cap(fruitslice)) // length of is 2 and capacity is 6
 fruitslice = fruitslice[:cap(fruitslice)] // re-slicing furitslice till its capacity
 fmt.Println("After re-slicing length is",len(fruitslice), "and capacity is",cap(fruitslice))
}

length of slice 2 capacity 6 
After re-slicing length is 6 and capacity is 6

func append（s[]T，x ... T）[]T

package main
import (
 "fmt"
)
func main() {
 str := []string{"a", "b", "c"}
 fmt.Println("strs:", str, " length:", len(str), "capacity:", cap(str))
 str = append(str, "d")
 fmt.Println("strs:", str, " length:", len(str), " capacity:", cap(str))
}

strs: [a b c] length: 3 capacity: 3
strs: [a b c d] length: 4 capacity: 6

package main
import ( 
 "fmt"
)
func main() { 
 var strs []string //zero value of a slice is nil
 if strs == nil {
  fmt.Println("slice is nil going to append")
  strs = append(strs, "a", "b", "c")
  fmt.Println("string contents:",strs)
 }
}

slice is nil going to append
string contents: [a b c]

package main
import (
  "fmt"
)
func main() {
  veggies := []string{"potatoes", "tomatoes", "brinjal"}
  fruits := []string{"oranges", "apples"}
  food := append(veggies, fruits...)
  fmt.Println("food:",food)
}

func main() {
  s1 := []int{1,2,3,4,5}
  fmt.Printf("s1:%p %d %d %v\n",s1,len(s1),cap(s1),s1)
  s2 :=append(s1,6)
  fmt.Printf("s3:%p %d %d %v\n",s2,len(s2),cap(s2),s2)
  s3 := s1[0:4]
  fmt.Printf("s3:%p %d %d %v\n",s3,len(s3),cap(s3),s3)
  s4 := append(s3,6)
  fmt.Printf("s4:%p %d %d %v\n",s4,len(s4),cap(s4),s4)
  fmt.Printf("s1:%p %d %d %v\n",s1,len(s1),cap(s1),s1)
  s5 := append(s4,8)
  fmt.Printf("s5:%p %d %d %v\n",s5,len(s5),cap(s5),s5)
}

package main
import (
  "fmt"
)
func subtactOne(numbers []int) {
  for i := range numbers {
    numbers[i] -= 2
  }
}
func main() {
  nos := []int{8, 7, 6}
  fmt.Println("slice before function call", nos)
  subtactOne(nos)                // function modifies the slice
  fmt.Println("slice after function call", nos) // modifications are visible outside
}

array before function call [8 7 6] 
array after function call [6 5 4]

package main
import (
  "fmt"
)
func main() { 
   pls := [][]string {
      {"C", "C++"},
      {"JavaScript"},
      {"Go", "Rust"},
      }
  for _, v1 := range pls {
    for _, v2 := range v1 {
      fmt.Printf("%s ", v2)
    }
    fmt.Printf("\n")
  }
}

C C++ 
JavaScript 
Go Rust
copy

func copy(dst，src[]T)int`
package main
import (
  "fmt"
)
func main() {
  s1 :=[]int{1,2,3,4,5}
  fmt.Println("s1",s1)
  s2 := make([]int,len(s1))
  fmt.Println("s2",s2)
  copy(s2,s1)
  fmt.Println("s2",s2)
  s3 :=make([]int,len(s1)-2)
  copy(s3,s1);
  fmt.Println("s3",s3)
  s4 :=make([]int,len(s1)-1)
  copy(s4[1:3],s1[2:4]);
  fmt.Println("s4",s4)
}

s1 [1 2 3 4 5]
s2 [0 0 0 0 0]
s2 [1 2 3 4 5]
s3 [1 2 3]
s4 [0 3 4 0]