La declaración y el uso de slice en el lenguaje Go

1. La definición de rebanada

    Slice en el lenguaje Go es una especie de matriz dinámica, que es una extensión de la matriz.

• En comparación con las matrices, la longitud del corte no es fija y se pueden agregar elementos que pueden aumentar la capacidad del corte.
• El corte en sí no tiene ningún dato, son solo referencias a matrices existentes.
• El corte es relativo a la matriz, no es necesario establecer la longitud y el valor de configuración no se usa en [], que es relativamente libre.
• Conceptualmente, un segmento es como una estructura. Esta estructura contiene tres elementos:
  1) Puntero, que apunta a la posición inicial especificada por el segmento en la matriz;
  2) Longitud, que es la longitud del segmento;
  3) Máximo Longitud, es decir, la longitud desde el principio del segmento hasta la última posición de la matriz.

En segundo lugar, la sintaxis de los cortes

2.1 Declarar rebanada

    2.1.1 Declare una matriz de longitud no especificada para definir el corte

• era identificador [] tipo
• No es necesario explicar la longitud;
• El modo de instrucción y el modificador no inicializado es un modificador vacío. Este corte es nulo por defecto y su longitud es 0.

    2.1.2 Utilice la función make () para crear cortes:

• var slice1 [] type = make ([] type, len)
• Puede abreviarse como: slice1: = make ([] type, len)
• Puede especificar la capacidad, donde la capacidad es un parámetro opcional: hacer ([] T, longitud, capacidad)

//mySlice.go

package main

import (
	"fmt"
)

func main() {
    
    
	//fmt.Println("Hello World!")
	//1)切片
	var numbers = make([]int, 3, 5)
	fmt.Printf("%T\n", numbers)
	fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers)
}

El efecto es el siguiente:

Figura (1) Imprima la longitud, la capacidad y los elementos de datos del corte

2.2 Inicialización

2.2.1 Inicializar directamente el segmento

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

2.2.2 Inicialización de cortes mediante la interceptación de arreglos

   数组： arr := [5]int {1,2,3,4,5}

• 1) s: = arr [:]
  contiene todos los elementos de la matriz
• 2) s: = arr [startIndex: endIndex]
  crea el elemento debajo del subíndice startIndex a endIndex-1 en arr como un nuevo corte (cerrado antes y abierto), la longitud es endIndex-startIndex
• 3) s: = arr [startIndex:]
  indicará el último elemento hasta el último elemento de arr por defecto endIndex;
• 4) s: = arr [: endIndex]
  comenzará desde el primer elemento de arr por defecto.

2.2.3 Inicializar corte a corte interceptación

    Puede establecer el corte de intercepción estableciendo el límite inferior y el límite superior [límite inferior: límite superior]
//mySlice2.go

package main

import (
	"fmt"
)

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

func main() {
    
    
	//fmt.Println("Hello World!")
	//1)切片
	// var numbers = make([]int, 3, 5)
	// fmt.Printf("%T\n", numbers)
	// fmt.Printf("len=%d cap=%d slice=%v\n", len(numbers), cap(numbers), numbers)

	//2)截取切片
	numbers := []int{
    
    0, 1, 2, 3, 4, 5, 6, 7, 8}
	printSlice(numbers)

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

	//打印子切片，从索引1到索引4,左闭右开,[1,4)
	fmt.Println("numbers[1:4]== ", numbers[1:4])

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

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

	//打印子切片，[0,2)
	number2 := numbers[:2]
	printSlice(number2)

	//打印子切片，[2,5)
	number3 := numbers[2:5]
	printSlice(number3)
}

    El efecto es el siguiente:

Figura (2) Mediante el método de interceptación, para obtener el corte

Tres, las funciones len () y cap () en el segmento

• El grado de corte es el número de elementos del corte.
• La capacidad de un corte es el número de elementos en la matriz subyacente a partir del índice donde se creó el corte.
• El corte es indexable y la longitud puede obtenerse mediante el método len (). El corte proporciona un método para calcular la capacidad, cap (), que puede medir la longitud máxima del corte. [El resultado del cálculo de matriz cap () es el mismo que len ()].
• Lo que es práctico es obtener una cierta parte de la matriz, len cut <= cap cut <= len array.
• El resultado de cap () determina los detalles de atención de la intercepción de corte.
  //mySlice02.go

// mySliceCap project main.go
package main

import (
	"fmt"
)

func main() {
    
    
	sliceCap()
}

func sliceCap() {
    
    
	arry := [...]string{
    
    "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k"}
	fmt.Println("cap(arry)= ", cap(arry), arry)

	//截取数组，形成切片
	sli01 := arry[2:8]
	fmt.Printf("%T\n", sli01)
	fmt.Println("cap(sli01)= ", cap(sli01), sli01)

	sli02 := arry[4:7]
	fmt.Println("cap(sli02)= ", cap(sli02), sli02)

	//截取切片，形成切片
	sli03 := sli01[3:9]
	fmt.Println("截取sli01[3:9]后形成sli03: ", sli03)

	sli04 := sli02[4:7]
	fmt.Println("截取sli02[4:7]后形成sli04: ", sli04)

	//切片是引用类型
	sli04[0] = "x"
	fmt.Print(arry, sli01, sli02, sli03, sli04)

}

    Los resultados son los siguientes:

Figura (3) La función cap () en el sector

Cuarto, el corte es un tipo de referencia.

• Un segmento no tiene datos propios, es solo una referencia a la matriz subyacente, y cualquier modificación realizada en el segmento se reflejará en la matriz subyacente.
• Las matrices son tipos de valor, pero son tipos de referencia.

    El caso de modificar la matriz es el siguiente:
//mySlice04.go

// mySliceCmp project main.go
package main

import (
	"fmt"
)

func main() {
    
    
	a := [4]float64{
    
    67.7, 89.8, 21, 78}
	b := []int{
    
    2, 3, 5}
	fmt.Printf("变量a -- 地址: %p, 类型: %T, 数值: %v, 长度: %d\n", &a, a, a, len(a))
	fmt.Printf("变量b -- 地址: %p, 类型: %T, 数值: %v, 长度: %d\n", &b, b, b, len(b))
	c := a
	d := b
	fmt.Printf("变量c -- 地址: %p, 类型: %T, 数值: %v, 长度: %d\n", &c, c, c, len(c))
	fmt.Printf("变量d -- 地址: %p, 类型: %T, 数值: %v, 长度: %d\n", &d, d, d, len(d))
	a[1] = 200
	fmt.Println("a= ", a, " c= ", c)
	d[0] = 100
	fmt.Println("b= ", b, " d= ", d)
}

    Los resultados son los siguientes:

Figura (4) Modificar el valor en la matriz

• Modificación del valor de corte
      Cuando varias páginas comparten la misma matriz subyacente, los cambios realizados por cada elemento se reflejarán en la matriz.
      Modifique el valor en el segmento, el ejemplo es el siguiente:
  //mySlice04.go

// mySliceChg project main.go
package main

import (
	"fmt"
)

func main() {
    
    
	//定义数组
	arry := [3]int{
    
    1, 2, 3}

	//根据数组截取切片
	nums1 := arry[:]
	nums2 := arry[:]
	fmt.Println("arry= ", arry)

	nums1[0] = 100
	fmt.Println("arry= ", arry)

	nums2[1] = 200
	fmt.Println("arry= ", arry)

	fmt.Printf("变量arry  --地址: %p\n", &arry)
	fmt.Printf("变量nums1 --地址: %p\n", &nums1)
	fmt.Printf("变量nums2 --地址: %p\n", &nums2)
}

    Los resultados son los siguientes:

Figura (5) Modificar el valor en el sector