Slice es una abstracción de matriz.
El segmento en sí no contiene ningún dato. Es solo una representación superior de la matriz subyacente. Cualquier modificación realizada al sector se reflejará en la matriz subyacente.
Cuando varios sectores comparten la misma matriz subyacente, la modificación de cada sector se reflejará en la matriz subyacente.
La longitud de la matriz en el lenguaje Go no se puede cambiar, pero a veces es necesario cambiar la longitud de la matriz. ¿Qué debo hacer? En este momento, se creó el segmento. Go proporciona un segmento de tipo integrado flexible y potente ("matriz dinámica"). En comparación con la matriz, la longitud del segmento no es fija. Puede agregar elementos. Incrementa la capacidad del corte.
Definir corte
// 可以声明一个未指定大小的数组来定义切片
var identifier []type
// 或使用make()函数来创建切片 capacity是可选参数
var identifier []type = make([]type, len)
或者
identifier := make([]type, len)El corte no necesita especificar la longitud.
También puede especificar la capacidad, donde la capacidad es un parámetro opcional.
make([]T, length, capacity)Aquí len es la longitud de la matriz y también la longitud inicial del segmento.
inicialización
Inicializar corte directamente
1 、
s :=[] int {
1,2,3 }Análisis:
[] significa que es un tipo de sector, el valor de inicialización de {1,2,3} es 1, 2, 3 a su vez. Su límite = len = 3
2 、
s := arr[:]Análisis:
inicialice el segmento s, que es una referencia a la matriz arr
3 、
s := arr[startIndex:endIndex]Análisis:
cree una nueva porción de los elementos bajo el subíndice startIndex a endIndex-1 en arr
4 、
s := arr[startIndex:]El endIndex predeterminado indicará el último elemento hasta arr
5 、
s := arr[:endIndex]El startIndex predeterminado indicará a partir del primer elemento de arr
6 、
s1 := s[startIndex:endIndex]Inicializar el segmento s1 por segmento s
7 、
s :=make([]int,len,cap)El segmento s es inicializado por la función incorporada make (), y [] int es el segmento cuyo tipo de elemento es int
len () 、 cap ()
El corte está indexado y la longitud se puede obtener mediante el método len ().
El corte proporciona un método para calcular la capacidad, cap (), que puede medir cuánto tiempo puede alcanzar el corte.
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)
}resultado de la operación:
len=3 cap=5 slice=[0 0 0]añadir () 、 copiar ()
Si desea aumentar la capacidad de un sector, debe crear un nuevo sector más grande y copiar el contenido del sector original.
El siguiente ejemplo describe el método de copia para copiar un sector y el método de adición para añadir nuevos elementos al sector.
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)
}El resultado de la ejecución es:
len=0 cap=0 slice=[]
len=1 cap=1 slice=[0]
len=2 cap=2 slice=[0 1]
len=5 cap=6 slice=[0 1 2 3 4]
len=5 cap=12 slice=[0 1 2 3 4]Cuando se agrega un elemento nuevo al final del segmento llamando a la función de agregar, si se excede la capacidad, se creará una nueva matriz dentro de agregar (si no termina, el original se cambia directamente). Y los elementos de la matriz original se copian en esta nueva matriz, y finalmente se devuelve el segmento construido en esta nueva matriz.
La capacidad de este nuevo segmento es el doble que la del segmento anterior (Nota: cuando se excede la capacidad del segmento, agregar creará una nueva matriz en su interior, cuyo tamaño es el doble de la capacidad del segmento original. Finalmente, agregar devuelve el valor de esta matriz Corte completo, es decir, corte de 0 a longitud-1).
El sector conserva una referencia a la matriz subyacente. Mientras exista el segmento en la memoria, la matriz no se puede recolectar como basura. Esto puede ser motivo de preocupación por la conveniencia de la gestión de memoria. Supongamos que tenemos una matriz muy grande, y solo necesitamos procesar una pequeña parte de ella, para esto creamos una porción de esta matriz y procesamos esta porción. Lo que hay que tener en cuenta aquí es que la matriz todavía existe en la memoria porque el segmento hace referencia a ella.
Una forma de resolver este problema es utilizar la función de copia func copy (dst, src [] T) int para crear una copia del segmento. De esta manera podemos usar este nuevo segmento y la matriz original se puede recolectar como basura.
Rebanada nula
Antes de que se inicialice un segmento, el valor predeterminado es nulo y la longitud es 0.
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)
}Los resultados de la operación son:
len=0 cap=0 slice=[]
切片是空的Intercepción de rebanadas
Puede establecer el corte de intercepción [límite inferior: límite superior] estableciendo el límite inferior y el límite superior.
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)
}Los resultados de la operación son:
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]