Ir Idioma rebanada (Slice)

rebanada Ir lenguaje es un conjunto de abstracción.

Ir longitud de la matriz no se puede cambiar, por lo que la colección no es tan útil en ciertos escenarios, Go proporciona una solución flexible, potente capacidad de la sección tipo ( "matriz dinámica"), en comparación con la longitud de la matriz rebanada no es fijo , los elementos se pueden agregar cuando los aumentos de capacidad adicionales pueden hacer rodajas.

rebanada definido

Se puede declarar una matriz de tamaño no especificado para definir el corte:

var identifier []type

de longitud que se explica en rodajas.

O para crear una rebanada usando make () Función:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

También puede especificar la capacidad, donde la capacidad es opcional.

make([]T, length, capacity)

Aquí len es la longitud de la matriz y también la longitud inicial de la rebanada.

inicialización de la rebanada

s :=[] int {1,2,3 } 

secciones de inicialización directos [] representan un tipo de sector, {1,2,3} valores de inicialización seguido de 1,2,3 su tapa len = = 3

s := arr[:] 

Inicialización rebanada s, es una referencia a la matriz arr

s := arr[startIndex:endIndex] 

Se va a crear un nuevo segmento con el elemento en el índice startIndex endIndex-1 en virtud de arr

s := arr[startIndex:] 

El último elemento tiene al arr defecto cuando endIndex

s := arr[:endIndex] 

Indicando a partir del primer elemento del arreglo de tiempo predeterminado startIndex

s1 := s[startIndex:endIndex] 

Trozo a trozo s initialize s1

s :=make([]int,len,cap) 

A través de una función de cierre de los contactos () Inicializa rebanada s, [] int identifica sus elementos de tipo int rebanadas

la función len () y la tapa ()

Slice es indexada y se puede obtener por el método de longitud len ().

Slice proporciona un método para calcular el límite máximo de la capacidad () se puede medir hasta un número máximo de las rebanadas.

Los siguientes ejemplos específicos:

package main

import "fmt"

func main() {
   var numbers = make([]int,3,5)

   printSlice(numbers)
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Ejecutar la salida anterior ejemplo es:

len=3 cap=5 slice=[0 0 0]

Vacío (cero) en rodajas

Una rebanada antes de defecto no inicializada es nula, una longitud de 0, los ejemplos son los siguientes:

package main

import "fmt"

func main() {
   var numbers []int

   printSlice(numbers)

   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Ejecutar la salida anterior ejemplo es:

len=0 cap=0 slice=[]
切片是空的

intercepción de la rebanada

Puede establecer la rebanada de intercepción [-límite inferior: del límite superior ] estableciendo inferior y superior, los ejemplos son los siguientes:

package main

import "fmt"

func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}   
   printSlice(numbers)

   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)

   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])

   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])

   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])

   numbers1 := make([]int,0,5)
   printSlice(numbers1)

   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)

   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)

}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

Ejecutar los resultados de la salida el código de seguridad:

len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
numbers == [0 1 2 3 4 5 6 7 8]
numbers[1:4] == [1 2 3]
numbers[:3] == [0 1 2]
numbers[4:] == [4 5 6 7 8]
len=0 cap=5 slice=[]
len=2 cap=9 slice=[0 1]
len=3 cap=7 slice=[2 3 4]

append () y copiar () Función

Si se desea aumentar la capacidad de la rebanada, debemos crear un nuevo y más grande porción de los fragmentos originales de todo el contenido se copia.

El código siguiente describe la copia de la división y el método de copia para agregar un nuevo elemento para anexar método de la rebanada.

package main

import "fmt"

func main() {
   var numbers []int
   printSlice(numbers)

   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)

   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)

   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)

   /* 创建切片 numbers1 是之前切片的两倍容量*/
   numbers1 := make([]int, len(numbers), (cap(numbers))*2)

   /* 拷贝 numbers 的内容到 numbers1 */
   copy(numbers1,numbers)
   printSlice(numbers1)   
}

func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

La salida se se ejecuta el código anterior:

len=0 cap=0 slice=[]
len=1 cap=2 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=8 slice=[0 1 2 3 4]
len=5 cap=16 slice=[0 1 2 3 4]