Go 語言切片(Slice)

在Go語言中，切片比數(shù)組更強大，靈活，方便，并且是輕量級的數(shù)據(jù)結(jié)構(gòu)。slice是一個可變長度序列，用于存儲相同類型的元素，不允許在同一slice中存儲不同類型的元素。就像具有索引值和長度的數(shù)組一樣，但是切片的大小可以調(diào)整，切片不像數(shù)組那樣處于固定大小。在內(nèi)部，切片和數(shù)組相互連接，切片是對基礎(chǔ)數(shù)組的引用。允許在切片中存儲重復(fù)元素。切片中的第一個索引位置始終為0，而最后一個索引位置將為（切片的長度– 1）。

切片聲明

切片的聲明就像數(shù)組一樣，但是不包含切片的大小。因此它可以根據(jù)需要增長或縮小。

語法：

[]T

或

[]T{}

或

[]T{value1, value2, value3, ...value n}

在此，T是元素的類型。例如：

var my_slice[]int

切片的組成

切片包含三個組件：

• 指針：指針用于指向可通過切片訪問的數(shù)組的第一個元素。在這里，指向的元素不必是數(shù)組的第一個元素。

• 長度：長度是數(shù)組中存在的元素總數(shù)。

• 容量：容量表示可以擴(kuò)展的最大大小。

讓我們借助示例討論所有這些組件：

//切片
package main

import "fmt"

func main() {

    //創(chuàng)建一個數(shù)組
    arr := [7]string{"這", "是", "Golang", "基礎(chǔ)", "教程", "在線", "www.soo66.com"}

    //顯示數(shù)組
    fmt.Println("數(shù)組:", arr)

    //創(chuàng)建切片
    myslice := arr[1:6]

    //顯示切片
    fmt.Println("切片:", myslice)

    //顯示切片的長度
    fmt.Printf("切片長度: %d", len(myslice))

    //顯示切片的容量
    fmt.Printf("\n切片容量: %d", cap(myslice))
}

輸出：

數(shù)組: [這 是 Golang 基礎(chǔ) 教程 在線 www.soo66.com]
切片: [是 Golang 基礎(chǔ) 教程 在線]
切片長度: 5
切片容量: 6

用法解釋：在上面的實例中，我們從給定的數(shù)組中創(chuàng)建一個切片。這里，片的指針指向索引1，因為片的下界被設(shè)置為1，所以它開始訪問來自索引1的元素。切片的長度為5，表示切片中元素的總數(shù)為5，而切片6的容量表示最多可以存儲6個元素。

如何創(chuàng)建和初始化切片？

在Go語言中，可以使用以下方式創(chuàng)建和初始化切片：

• 使用切片字面量：您可以使用切片字面量創(chuàng)建切片。切片字面量的創(chuàng)建就像數(shù)組字面量一樣，但是有一個區(qū)別，即不允許您在方括號[]中指定切片的大小。如下例所示，該表達(dá)式的右側(cè)是切片字面量。

  var my_slice_1 = []string{"nhooos", "for", "nhooos"}

  注意：切記，當(dāng)您使用字符串文字創(chuàng)建切片時，它首先創(chuàng)建一個數(shù)組，然后返回對其的切片引用。

  示例

  // 使用切片創(chuàng)建切片字面量
  package main
  
  import "fmt"
  
  func main() {
  
      //使用var關(guān)鍵字,創(chuàng)建切片
      var my_slice_1 = []string{"nhooos", "for", "nhooos"}
  
      fmt.Println("My Slice 1:", my_slice_1)
  
      //創(chuàng)建切片
      //使用簡寫聲明
      my_slice_2 := []int{12, 45, 67, 56, 43, 34, 45}
      fmt.Println("My Slice 2:", my_slice_2)
  }

  輸出：

  My Slice 1: [nhooos for nhooos]
  My Slice 2: [12 45 67 56 43 34 45]

• 使用數(shù)組：我們已經(jīng)知道切片是數(shù)組的引用，因此您可以根據(jù)給定的數(shù)組創(chuàng)建切片。要從給定數(shù)組創(chuàng)建切片，首先需要指定下限和上限，這意味著slice可以從下限到上限開始獲取數(shù)組中的元素。它不包括上面從上限開始的元素。如下例所示：

  語法：

  array_name[low:high]

  此語法將返回一個新切片。

  注意：下限的默認(rèn)值為0，上限的默認(rèn)值為給定數(shù)組中存在的元素總數(shù)。

• 示例

  //從數(shù)組創(chuàng)建切片
  package main 
    
  import "fmt"
    
  func main() { 
    
      //創(chuàng)建一個數(shù)組
      arr := [4]string{"nhooos", "for", "nhooos", "GFG"} 
    
      //從給定數(shù)組創(chuàng)建切片 
      var my_slice_1 = arr[1:2] 
      my_slice_2 := arr[0:] 
      my_slice_3 := arr[:2] 
      my_slice_4 := arr[:] 
    
      //顯示結(jié)果
      fmt.Println("我的數(shù)組: ", arr) 
      fmt.Println("My Slice 1: ", my_slice_1) 
      fmt.Println("My Slice 2: ", my_slice_2) 
      fmt.Println("My Slice 3: ", my_slice_3) 
      fmt.Println("My Slice 4: ", my_slice_4) 
  }

  輸出：

  我的數(shù)組:  [nhooos for nhooos GFG]
  My Slice 1:  [for]
  My Slice 2:  [nhooos for nhooos GFG]
  My Slice 3:  [nhooos for]
  My Slice 4:  [nhooos for nhooos GFG]

• 使用已經(jīng)存在的切片：也可以從給定的切片創(chuàng)建切片。要從給定切片創(chuàng)建切片，首先需要指定下限和上限，這意味著slice可以從給定切片中從下限到上限開始獲取元素。它不包括上面從上限開始的元素。如下例所示：

  語法：

  slice_name[low:high]

  此語法將返回一個新切片。

  注意：下限的默認(rèn)值為0，上限的默認(rèn)值為給定切片中存在的元素總數(shù)。

  示例

  //從切片創(chuàng)建切片
  package main
  
  import "fmt"
  
  func main() {
  
      //創(chuàng)建切片
      oRignAl_slice := []int{90, 60, 40, 50, 34, 49, 30}
  
      //從給定的切片創(chuàng)建切片
      var my_slice_1 = oRignAl_slice[1:5]
      my_slice_2 := oRignAl_slice[0:]
      my_slice_3 := oRignAl_slice[:6]
      my_slice_4 := oRignAl_slice[:]
      my_slice_5 := my_slice_3[2:4]
  
      //顯示結(jié)果
      fmt.Println("原始切片:", oRignAl_slice)
      fmt.Println("新切片 1:", my_slice_1)
      fmt.Println("新切片 2:", my_slice_2)
      fmt.Println("新切片 3:", my_slice_3)
      fmt.Println("新切片 4:", my_slice_4)
      fmt.Println("新切片 5:", my_slice_5)
  }

  輸出：

  原始切片: [90 60 40 50 34 49 30]
  新切片 1: [60 40 50 34]
  新切片 2: [90 60 40 50 34 49 30]
  新切片 3: [90 60 40 50 34 49]
  新切片 4: [90 60 40 50 34 49 30]
  新切片 5: [40 50]

• 使用make()函數(shù)：您還可以使用go庫提供的make()函數(shù)創(chuàng)建切片。此函數(shù)采用三個參數(shù)，即類型，長度和容量。在此，容量值是可選的。它為底層數(shù)組分配的大小等于給定的容量，并返回一個切片，該切片引用底層數(shù)組。通常，make()函數(shù)用于創(chuàng)建一個空切片。在這里，空切片是包含空數(shù)組引用的那些切片。

  語法：

  func make([]T, len, cap) []T

  示例

  //使用make函數(shù)
  package main
  
  import "fmt"
  
  func main() {
  
      //創(chuàng)建大小為7的數(shù)組
      //將此數(shù)組切成4
      //并返回切片的引用
      //使用make函數(shù)
      var my_slice_1 = make([]int, 4, 7)
      fmt.Printf("Slice 1 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_1, len(my_slice_1), cap(my_slice_1))
  
      //創(chuàng)建另一個大小為7的數(shù)組
      //并返回切片的引用
      //使用make函數(shù)
      var my_slice_2 = make([]int, 7)
      fmt.Printf("Slice 2 = %v, \nlength = %d, \ncapacity = %d\n",my_slice_2, len(my_slice_2), cap(my_slice_2))
  
  }

  輸出：

  Slice 1 = [0 0 0 0], 
  length = 4, 
  capacity = 7
  Slice 2 = [0 0 0 0 0 0 0], 
  length = 7, 
  capacity = 7

如何遍歷一個切片？

您可以使用以下方式遍歷切片：

• 使用for循環(huán)：這是迭代切片的最簡單方法，如以下示例所示：

  示例

  // for循環(huán)迭代切片
  package main 
    
  import "fmt"
    
  func main() { 
    
      //創(chuàng)建切片
      myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"} 
    
      //使用for循環(huán)進(jìn)行迭代
      for e := 0; e < len(myslice); e++ { 
          fmt.Println(myslice[e]) 
      } 
  }

  輸出：

  This
  is
  the
  tutorial
  of
  Go
  language

• 在for循環(huán)中使用范圍：允許使用for循環(huán)中的范圍對切片進(jìn)行迭代。在for循環(huán)中使用range，可以獲得索引和元素值，如示例所示：

  示例

  //在for循環(huán)中使用范圍的切片
  package main 
    
  import "fmt"
    
  func main() { 
    
      //創(chuàng)建切片
      myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"} 
    
          //迭代切片
          //在for循環(huán)中使用range
      for index, ele := range myslice { 
          fmt.Printf("Index = %d and element = %s\n", index+3, ele) 
      } 
  }

  輸出：

  Index = 3 and element = This
  Index = 4 and element = is
  Index = 5 and element = the
  Index = 6 and element = tutorial
  Index = 7 and element = of
  Index = 8 and element = Go
  Index = 9 and element = language

• 在for循環(huán)中使用空白標(biāo)識符：在for循環(huán)范圍內(nèi)，如果您不想獲取元素的索引值，則可以使用空格（_）代替索引變量，如以下示例所示：
  

  示例

  //在for循環(huán)中使用范圍的切片而沒有索引 
  package main 
    
  import "fmt"
    
  func main() { 
    
      //創(chuàng)建切片 
      myslice := []string{"This", "is", "the", "tutorial", "of", "Go", "language"} 
    
          //迭代切片
          //在for循環(huán)中使用range
          //沒有索引
      for _, ele := range myslice { 
          fmt.Printf("Element = %s\n", ele) 
      } 
  }

  輸出：

  Element = This
  Element = is
  Element = the
  Element = tutorial
  Element = of
  Element = Go
  Element = language

關(guān)于切片的要點

1. 零值切片：在Go語言中，允許您創(chuàng)建一個不包含任何元素的零切片。因此，此片的容量和長度為0。nil切片不包含數(shù)組引用，如以下示例所示：

   示例

   package main 
     
   import "fmt"
     
   func main() { 
     
       // 創(chuàng)建零值切片
       var myslice []string 
       fmt.Printf("Length = %d\n", len(myslice)) 
       fmt.Printf("Capacity = %d ", cap(myslice)) 
     
   }

   輸出：

   Length = 0
   Capacity = 0

2. 修改Slice：正如我們已經(jīng)知道slice是引用類型一樣，它可以引用基礎(chǔ)數(shù)組。因此，如果我們更改切片中的某些元素，則更改也應(yīng)發(fā)生在引用數(shù)組中。換句話說，如果您對切片進(jìn)行了任何更改，則切片也會反映在數(shù)組中，如以下示例所示：

   示例

   //如何修改切片
   package main 
     
   import "fmt"
     
   func main() { 
     
       //創(chuàng)建零值切片
       arr := [6]int{55, 66, 77, 88, 99, 22} 
       slc := arr[0:4] 
     
       //修改前
     
       fmt.Println("Original_Array: ", arr) 
       fmt.Println("Original_Slice: ", slc) 
     
       //修改后 
       slc[0] = 100 
       slc[1] = 1000 
       slc[2] = 1000 
     
       fmt.Println("\nNew_Array: ", arr) 
       fmt.Println("New_Slice: ", slc) 
   }

   輸出：

   Original_Array:  [55 66 77 88 99 22]
   Original_Slice:  [55 66 77 88]
   
   New_Array:  [100 1000 1000 88 99 22]
   New_Slice:  [100 1000 1000 88]

3. 切片的比較：在切片中，您只能使用==運算符檢查給定切片是否存在。如果嘗試在==運算符的幫助下比較兩個切片，則會拋出錯誤，如下例所示：

   示例

   //判斷切片是否為零
   package main 
     
   import "fmt"
     
   func main() { 
     
       //創(chuàng)建切片
       s1 := []int{12, 34, 56} 
       var s2 []int
     
           //如果你嘗試運行這個注釋
           //代碼編譯器將給出一個錯誤
       /*s3:= []int{23, 45, 66} 
         fmt.Println(s1==s3) 
       */
     
       //檢查給定的片是否為nil
       fmt.Println(s1 == nil) 
       fmt.Println(s2 == nil) 
   }

   輸出：

   false
   true

   注意：如果要比較兩個切片，請使用循環(huán)范圍匹配每個元素，或者可以使用DeepEqual函數(shù)。

4. 多維切片：多維切片與多維數(shù)組一樣，只是切片不包含大小。

   示例

   package main 
     
   import "fmt"
     
   func main() { 
     
       //創(chuàng)建多維切片
       s1 := [][]int{{12, 34}, 
           {56, 47}, 
           {29, 40}, 
           {46, 78}, 
       } 
     
       //訪問多維切片
       fmt.Println("Slice 1 : ", s1) 
     
       //創(chuàng)建多維切片 
       s2 := [][]string{ 
           []string{"nhooos", "for"}, 
           []string{"nhooos", "GFG"}, 
           []string{"gfg", "nhooo"}, 
       } 
     
       //訪問多維切片
       fmt.Println("Slice 2 : ", s2) 
     
   }

   輸出：

   Slice 1 :  [[12 34] [56 47] [29 40] [46 78]]
   Slice 2 :  [[nhooos for] [nhooos GFG] [gfg nhooo]]

5. 切片排序：在Go語言中，可以對切片中存在的元素進(jìn)行排序。  Go語言的標(biāo)準(zhǔn)庫提供了sort包，其中包含用于對int，float64和字符串切片進(jìn)行排序的不同類型的排序方法。 這些函數(shù)始終按升序?qū)捎迷剡M(jìn)行切片排序。

   示例

   //切片中存在的元素
   package main 
     
   import ( 
       "fmt"
       "sort"
   ) 
     
   func main() { 
     
       //創(chuàng)建切片
       slc1 := []string{"Python", "Java", "C#", "Go", "Ruby"} 
       slc2 := []int{45, 67, 23, 90, 33, 21, 56, 78, 89} 
     
       fmt.Println("在排序之前:") 
       fmt.Println("Slice 1: ", slc1) 
       fmt.Println("Slice 2: ", slc2) 
     
       //切片使用排序函數(shù)
       sort.Strings(slc1) 
       sort.Ints(slc2) 
     
       fmt.Println("\n排序后:") 
       fmt.Println("Slice 1: ", slc1) 
       fmt.Println("Slice 2: ", slc2) 
     
   }

   輸出：

   排序前:
   Slice 1:  [Python Java C# Go Ruby]
   Slice 2:  [45 67 23 90 33 21 56 78 89]
   
   排序后:
   Slice 1:  [C# Go Java Python Ruby]
   Slice 2:  [21 23 33 45 56 67 78 89 90]