Tutorial básico de Golang

Sentencias de control de Golang

Funciones y métodos de Golang

Estructuras de Golang

Slice y array de Golang

Cadenas (String) de Golang

Punteros de Golang

Interfaces de Golang

Concurrencia de Golang

Excepciones (Error) de Golang

Misceláneos de Golang

Copia de cortes de Go Arreglos como parámetros de función de Go

Cortes del lenguaje Go (Slice)

En el lenguaje de programación Go, el slice es másArrayMuy potente, flexible, conveniente y ligero, es una estructura de datos de baja latencia. Slice es una secuencia de longitud variable, utilizada para almacenar elementos del mismo tipo, no se permite almacenar elementos de diferentes tipos en el mismo slice. Al igual que un array con índices y longitud, pero el tamaño del slice puede ajustarse, y el slice no está en un tamaño fijo como el array. Internamente, el slice y el array están conectados, y el slice es una referencia al array base. Permite almacenar elementos repetidos.La primera posición de índice en la rebanada siempre es 0, mientras que la última posición de índice será (longitud de la rebanada - 1). 1).

Declaración de rebanada

La declaración de rebanada es como un array, pero no incluye el tamaño de la rebanada. Por lo tanto, puede crecer o reducirse según sea necesario.

语法：

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

Aquí, T es el tipo de elemento. Por ejemplo:

var my_slice[]int

Composición de la rebanada

La rebanada contiene tres componentes:

Puntero:El puntero se utiliza para apuntar al primer elemento del array que se puede acceder a través de la rebanada. Aquí, el elemento al que se apunta no tiene que ser el primer elemento del array.
Longitud:La longitud es el número total de elementos que existen en el array.
Capacidad:La capacidad representa el tamaño máximo que se puede expandir.

Vamos a discutir todos estos componentes con ejemplos:

ejemplo

//Rebanada
package　main
import　"fmt"
func　main()　{
　　　　//Crear un array
　　　　arr　:=　[7string{"esto", "es", "Golang", "básico", "tutorial", "en línea", "es.oldtoolbag.com"}
　　　　//Mostrar array
　　　　fmt.Println("Array:", arr)
　　　　//creación de lista
　　　　myslice := arr[1:6]
　　　　//Mostrar rebanada
　　　　fmt.Println("Rebanada:", myslice)
　　　　//Mostrar longitud de rebanada
　　　　fmt.Printf("Longitud de rebanada: %d", len(myslice))
　　　　//Mostrar capacidad de rebanada
　　　　fmt.Printf("\nCapacidad de rebanada: %d", cap(myslice))
}

salida：

Array: [esto es el tutorial básico de Golang en línea es.oldtoolbag.com]
Rebanada: [es el tutorial básico de Golang en línea]
Longitud de rebanada:　5
Capacidad de rebanada:　6

Explicación de uso:En el ejemplo anterior, creamos una rebanada a partir del array dado. Aquí, el puntero de la rebanada apunta al índice1porque el límite inferior de la rebanada se establece en1por lo que comienza a acceder desde el índice1La longitud de la rebanada es5representa el número total de elementos en la rebanada.5mientras que la rebanada6La capacidad representa el número máximo que se puede almacenar6elementos.

¿Cómo crear e inicializar una rebanada?

En el lenguaje Go, se puede crear e inicializar una rebanada de la siguiente manera:

Uso de rebanadas:PuedeUso de rebanadasCrear rebanadas. La creación de una rebanada literal es como una literal de array, pero hay una diferencia, es que no se permite especificar el tamaño de la rebanada dentro de los corchetes []. Como se muestra en el siguiente ejemplo, el lado derecho de la expresión es una rebanada literal.

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

Nota：Recuerde, cuando crea un slice usando texto de cadena, primero crea un array y luego devuelve una referencia al slice.

ejemplo

//　Crear un literal de slice
package　main
import　"fmt"
func　main()　{
　　　　//Crear un slice usando la palabra clave var
　　　　var my_slice_1　= []string{"w3codeboxs, "for", "w3codeboxs}
　　　　fmt.Println("Mi Slice　1:", my_slice_1)
　　　　//creación de lista
　　　　//Usar declaración abreviada
　　　　my_slice_2　:=　[]int{12,　45,　67,　56,　43,　34,　45}
　　　　fmt.Println("Mi Slice　2:", my_slice_2)
}

salida：

Mi Slice　1:    [w3codeboxs for w3codeboxs]
Mi Slice　2: [12　45　67　56　43　34　45]

Usar el array:Ya sabemosEl slice es una referencia al arrayPor lo tanto, puede crear un slice a partir del array dado. Para crear un slice a partir del array dado, primero se debe especificar el límite inferior y el límite superior, lo que significa que el slice puede comenzar a obtener elementos desde el límite inferior hasta el límite superior en el array. No incluye los elementos que comienzan desde el límite superior. Como se muestra en el siguiente ejemplo:
语法：
```
array_name[low:high]
```
Esta sintaxis devolverá un nuevo slice.
Nota：El límite inferior por defecto es 0, y el límite superior por defecto es el número total de elementos existentes en el array dado.

ejemplo

//Crear un slice a partir de un array
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//Crear un array
　　　　arr　:=　[4]string{"w3codeboxs, "for", "w3codeboxs, "GFG"}　
　　
　　　　//Crear un slice a partir de un array　
　　　　var my_slice_1　= arr[1:2]　
　　　　my_slice_2　:= arr[0:]　
　　　　my_slice_3　:= arr[:2]　
　　　　my_slice_4　:= arr[:]　
　　
　　　　//Mostrar resultado
　　　　fmt.Println("Mi array:    ", arr)　
　　　　fmt.Println("Mi Slice　1:    ", my_slice_1)　
　　　　fmt.Println("Mi Slice　2:    ", my_slice_2)　
　　　　fmt.Println("Mi Slice　3:    ", my_slice_3)　
　　　　fmt.Println("Mi Slice　4:    ", my_slice_4)　
}

salida：

Mi array:    [w3codeboxs for w3codeboxs GFG]
Mi Slice　1:    [for]
Mi Slice　2:    [w3codeboxs for w3codeboxs GFG]
Mi Slice　3:    [w3codeboxs for]
Mi Slice　4:    [w3codeboxs for w3codeboxs GFG]

Usar el slice existente:También se puede crear un slice a partir de un slice dado. Para crear un slice a partir de un slice dado, primero se debe especificar el límite inferior y el límite superior, lo que significa que el slice puede comenzar a obtener elementos desde el límite inferior hasta el límite superior en el slice dado. No incluye los elementos que comienzan desde el límite superior. Como se muestra en el siguiente ejemplo:

语法：

slice_name[low:high]

Esta sintaxis devolverá un nuevo slice.

Nota：El límite inferior por defecto es 0, y el límite superior por defecto es el número total de elementos existentes en el slice dado.

ejemplo

//Crear un slice a partir de un slice
package　main
import　"fmt"
func　main()　{
　　　　//creación de lista
　　　　oRignAl_slice := []int{90,　60,　40,　50,　34,　49,　30}
　　　　//Crear un slice a partir de un slice existente
　　　　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]
　　　　//Mostrar resultado
　　　　fmt.Println("Origenal slice:", 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)
}

salida：

原始切片: [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()函数：您还可以使用go库提供的make()函数创建切片。此函数采用三个参数，即类型，长度和容量。在此，容量值是可选的。它为底层数组分配的大小等于给定的容量，并返回一个切片，该切片引用底层数组。通常，make()函数用于创建一个空切片。在这里，空切片是包含空数组引用的那些切片。

语法：

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

ejemplo

//使用make函数
package　main
import　"fmt"
func　main()　{
　　　　//创建大小为7的数组
　　　　//将此数组切成4
　　　　//并返回切片的引用
　　　　//使用make函数
　　　　var my_slice_1　= make([]int,　4,　7)
　　　　fmt.Printf("Slice　1　= %v, \
length = %d, \
capacity = %d\n", my_slice_1, len(my_slice_1), cap(my_slice_1))
　　　　//创建另一个大小为7的数组
　　　　//并返回切片的引用
　　　　//使用make函数
　　　　var my_slice_2　= make([]int,　7)
　　　　fmt.Printf("Slice　2　= %v, \
length = %d, \
capacity = %d\n", my_slice_2, len(my_slice_2), cap(my_slice_2))
}

salida：

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

如何遍历一个切片？

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

使用for循环：这是迭代切片的最简单方法，如以下示例所示：

ejemplo

//　for循环迭代切片
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//creación de lista
　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　//使用for循环进行迭代
　　　　for e := 0; e < len(myslice); e++　{　
　　　　　　　　fmt.Println(myslice[e])　
　　　　}　
}

salida：

This
is
the
tutorial
of
Go
language

在for循环中使用范围：允许使用for循环中的范围对切片进行迭代。在for循环中使用range，可以获得索引和元素值，如示例所示：

ejemplo

//在for循环中使用范围的切片
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//creación de lista
　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　　　　　//迭代切片
　　　　　　　　//在for循环中使用range
　　　　for index, ele := range myslice {　
　　　　　　　　fmt.Printf("Index = %d and element = %s\n", index+3, ele)　
　　　　}　
}

salida：

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循环中使用空白标识符：在for循环范围内，如果您不想获取元素的索引值，则可以使用空格（_）代替索引变量，如以下示例所示：

ejemplo

//在for循环中使用范围的切片而没有索引　
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//creación de lista　
　　　　myslice　:=　[]string{"This", "is", "the", "tutorial", "of", "Go", "language"}　
　　
　　　　　　　　//迭代切片
　　　　　　　　//在for循环中使用range
　　　　　　　　//没有索引
　　　　for　_,　ele　:=　range　myslice　{　
　　　　　　　　fmt.Printf("Element　=　%s\n", ele)　
　　　　}　
}

salida：

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

关于切片的要点

零值切片：在Go语言中，允许您创建一个不包含任何元素的零切片。因此，此片的容量和长度为0。nil切片不包含数组引用，如以下示例所示：

ejemplo

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

salida：

Length　=　0
Capacity　=　0

修改Slice：正如我们已经知道slice是引用类型一样，它可以引用基础数组。因此，如果我们更改切片中的某些元素，则更改也应发生在引用数组中。换句话说，如果您对切片进行了任何更改，则切片也会反映在数组中，如以下示例所示：

ejemplo

//如何修改切片
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//创建零值切片
　　　　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)　
}

salida：

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]

comparación de lista：en la lista, solo se puede usar==operador para verificar si la lista dada existe.==bajo la ayuda del operador de comparación de dos listas, se lanzará un error, como se muestra en el siguiente ejemplo:

ejemplo

//juzgar si la lista es cero
package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//creación de lista
　　　　s1　:=　[]int{12,　34,　56}　
　　　　var　s2　[]int
　　
　　　　　　　　//si intenta ejecutar este comentario
　　　　　　　　//el compilador de código dará un error
　　　　/*s3:=　[]int{23,　45,　66}　
　　　　　　fmt.Println(s1==s3)　
　　　　*/
　　
　　　　//verificar si la lista dada es nil
　　　　fmt.Println(s1　==　nil)　
　　　　fmt.Println(s2　==　nil)　
}

salida：

false
true

Nota：Si desea comparar dos listas, utilice el bucle de rango para coincidir cada elemento, o puede usarDeepEqualfunciones.

Lista multidimensional：Una lista multidimensional es similar a un array multidimensional, pero las listas no tienen un tamaño.

ejemplo

package　main　
　　
import　"fmt"
　　
func　main()　{　
　　
　　　　//creación de lista multidimensional
　　　　s1　:=　[][]int{{12,　34},　
　　　　　　　　{56,　47},　
　　　　　　　　{29,　40},　
　　　　　　　　{46,　78},　
　　　　}　
　　
　　　　//acceso a lista multidimensional
　　　　fmt.Println("Slice　1　:　",　s1)　
　　
　　　　//creación de lista multidimensional　
　　　　s2　:=　[][]string{　
　　　　　　　　[]string{"w3codeboxs",　"for"},　
　　　　　　　　[]string{"w3codeboxs",　"GFG"},　
　　　　　　　　[]string{"gfg",　"w3codebox"},　
　　　　}　
　　
　　　　//acceso a lista multidimensional
　　　　fmt.Println("Slice　2　:　",　s2)　
　　
}

salida：

Corte　1　:　　[[12　34]]56　47]]29　40]　[46　78]]
Corte　2　:　　[[w3codeboxs　for]　[w3codeboxs　GFG]　[gfg　w3codebox]]

ordenamiento de lista:En el lenguaje Go, se puede ordenar los elementos existentes en una lista. El paquete estándar de Go proporciona el paquete sort, que contiene funciones para ordenar int, float64y diferentes métodos de ordenamiento para listas de cadenas. Estas funciones siempre ordenan las listas disponibles en orden ascendente.

ejemplo

//elementos existentes en la lista
package　main　
　　
import　(　
　　　　"fmt"
　　　　"sort"
)　
　　
func　main()　{　
　　
　　　　//creación de lista
　　　　slc1　:=　[]string{"Python",　"Java",　"C#",　"Go",　"Ruby"}　
　　　　slc2　:=　[]int{45,　67,　23,　90,　33,　21,　56,　78,　89}　
　　
　　　　fmt.Println("Antes de ordenar:\　
　　　　fmt.Println("Slice　1:　",　slc1)　
　　　　fmt.Println("Slice　2:　",　slc2)　
　　
　　　　//función de ordenamiento para la lista
　　　　sort.Strings(slc1)　
　　　　sort.Ints(slc2)　
　　
　　　　fmt.Println("\nordenado:\　
　　　　fmt.Println("Slice　1:　",　slc1)　
　　　　fmt.Println("Slice　2:　",　slc2)　
　　
}

salida：

antes de ordenar:
Corte　1:　　[Python　Java　C#　Go　Ruby]
Corte　2:　　[45　67　23　90　33　21　56　78　89]
ordenado:
Corte　1:　　[C#　Go　Java　Python　Ruby]
Corte　2:　　[21　23　33　45　56　67　78　89　90]

Copia de cortes de Go Arreglos como parámetros de función de Go