Tutoriales básicos de Golang

Sentencias de control de Golang

Funciones & Métodos de Golang

Estructuras de Golang

Cortes & Arrays de Golang

Cadenas (String) de Golang

Punteros de Golang

Interfaz de Golang

Concurrencia de Golang

Excepciones (Error) de Golang

Misceláneos de Golang

Copia de arreglos de Go Funciones utilizadas como campos de estructura de Go

Arreglos del lenguaje Go

El lenguaje de programación Go tiene arrays muy similares a otros lenguajes de programación. A veces, en un programa, necesitamos almacenar un conjunto de datos del mismo tipo, como una lista de calificaciones de estudiantes. Este tipo de conjunto se almacena en un array en el programa. El array es una secuencia de longitud fija, utilizada para almacenar elementos del mismo tipo en la memoria. Dado que su longitud fija, no es tan popular como el Slice (corte) en el lenguaje Go.
En el array, se permite almacenar cero o más elementos. Al utilizar el operador de índice [] y la posición de cero, se indexa los elementos del array, lo que significa que el índice del primer elemento esarray [0]，el índice del último elemento esarray [longitud(array)-1]}}.

creación y acceso al array

En el lenguaje Go, los arrays se crean de dos formas diferentes:

usando la palabra clave var:En el lenguaje Go, se crea un array usando la palabra clave var con nombre, tamaño y tipo de elemento específico.
sintaxis:
```
Var　array_name[length]Type
或
var　array_name[length]Typle{item1,　item2,　item3,　...itemN}
```
Puntos importantes:

En el lenguaje Go, los arrays son mutables, por lo que puede usar la sintaxis array [índice] en el lado izquierdo de la asignación para establecer el elemento del array en el índice dado.
```
Var　array_name[index]　=　element[object　Object]
```
Puede acceder a los elementos del array usando el valor de índice o usando el bucle for.
El tipo de array en el lenguaje Go es unidimensional.
La longitud del array es fija y no se puede cambiar.
Puede almacenar elementos repetidos en el array.

示例

//creando un array usando la palabra clave var
//accediendo al array usando su valor de índice
package main
import "fmt"
func main() {
　　　　//creando un array de tipo cadena usando la palabra clave var
　　　　var　myarr　[3]string
　　　　//asignación de elementos usando el índice
　　　　myarr[0]　=　"GFG"
　　　　myarr[1]　=　"es.oldtoolbag.com"
　　　　myarr[2]　=　"w3codebox"
　　　　//acceso a los elementos del array
　　　　//usando el valor de índice
　　　　fmt.Println("los elementos del array:")
　　　　fmt.Println("elemento　1:　",　myarr[0])
　　　　fmt.Println("elemento　2:　",　myarr[1)]
　　　　fmt.Println("elemento　3:　",　myarr[2)]
{}

Salida:

los elementos del array:
elemento　1:　　GFG
elemento　2:　　es.oldtoolbag.com
elemento　3:　　w3codebox

usando la declaración abreviada:En el lenguaje Go, los arrays también se pueden declarar con declaraciones abreviadas. Es más flexible que la declaración anterior.

sintaxis:

array_name:=　[length]Type{item1,　item2,　item3,...itemN}[object　Object]

示例

//uso del array con declaración abreviada
//acceso al array usando el bucle for
package main
import "fmt"
func main() {
　　　　//declaración abreviada del array
　　　　4]string{"w3codebox3codeboxs1231",　"es.oldtoolbag.com"}
　　　　//elemento accedido, usando el array en el bucle for
　　　　fmt.Println("los elementos del array:")
　　　　for　i　:=　0;　i　<　3;　i++　{
　　　　　　　　fmt.Println(arr[i])
　　　　{}
{}

Salida:

los elementos del array:
w3codebox
gfg
w3codeboxs1231

arrays multidimensionales

Ya sabemos que el array es unidimensional, pero se permite crear arrays multidimensionales. Los arrays multidimensionales son arrays de arrays de tipo idéntico. En el lenguaje Go, puede usar la siguiente sintaxis para crear arrays multidimensionales:

Array_name[Length1][Length2]..[LengthN]Type

您可以使用Var关键字或Uso de la declaración abreviada来创建多维数组，如下例所示。

注意：在多维数组中，如果用户未使用某个值初始化单元格，则编译器将自动将其初始化为零。Golang中没有未初始化的概念。

示例

package main
import "fmt"
func main() {
　　　　//创建和初始化
　　　　//二维数组
　　　　//Uso de la declaración abreviada
　　　　//这里需要用（，）逗号
　　　　3][3
　　　　　　　　]string{{"C#
　　　　　　　　{"Java", "Scala", "Perl"},++{"C
　　　　//", "Go", "HTML"}}
　　　　//Uso del bucle for para acceder al valor
　　　　fmt.Println("Elementos del array:",　1)")
　　　　for x := 0; x <　3; x++　{
　　　　　　　　for y := 0; y <　3; y++　{
　　　　　　　　　　　　fmt.Println(arr[x][y])
　　　　　　　　{}
　　　　{}
　　　　//Crear un array bidimensional
　　　　//Crear un array con la palabra clave var
　　　　//e inicializar uno
　　　　//Uso de un array de dimensiones con índices
　　　　var arr1　[2][2]int
　　　　arr1[0][0] =　100
　　　　arr1[0][1] =　200
　　　　arr1[1][0] =　300
　　　　arr1[1][1] =　400
　　　　//Acceder al valor del array
　　　　fmt.Println("Elementos del array:",　2)")
　　　　for p := 0; p <　2; p++　{
　　　　　　　　for q := 0; q <　2; q++　{
　　　　　　　　　　　　fmt.Println(arr1[p][q])
　　　　　　　　{}
　　　　{}
{}

Salida:

Los elementos del array　1
C#
C
Python
Java
Scala
Perl
C++
Go
HTML
Los elementos del array　2
100
200
300
400

Consejos sobre arrays

En el array, si no se inicializa explícitamente el array,Este arraydelEl valor predeterminado es 0.

示例

package main　
　　
import "fmt"
　　
func main() {　
　　
//Crear un array de tipo int, que almacena dos elementos
//Aquí, no inicializamos el array, por lo que el valor del array es cero
var myarr[2]int　
fmt.Println("Elementos del array:", myarr)　
　　
{}

Salida:

Elementos del array: [0 0]

En el array, puedeUso deMétodo len()ObtenerArrayLongitud,Como se muestra a continuación:

示例

package main
import "fmt"
func main() {
　　　　//Crear un array
　　　　//Uso de la declaración abreviada
　　　　arr1　:=[3]int{9,　7,　6{}
　　　　arr2　:=[...]int{9,　7,　6,　4,　5,　3,　2,　4{}
　　　　arr3　:=[3]int{9,　3,　5{}
　　　　//　Calcular el tamaño del array con el método len
　　　　fmt.Println("Array1Tiene una longitud de: len(arr1))
　　　　fmt.Println("Array2Tiene una longitud de: len(arr2))
　　　　fmt.Println("Array3Tiene una longitud de: len(arr3))
{}

Salida:

Array1Tiene una longitud de:　3
Array2Tiene una longitud de:　8
Array3Tiene una longitud de:　3

在数组中，Si el punto y coma " ..."Es visible en la posición de longitud, por lo que el tamaño del array se determina por los elementos inicializados. Ejemplo:

示例

//El uso del punto y coma en el array
package main
import "fmt"
func main() {
　　　　//Crear un array de tamaño determinado
　　　　//basado en la cantidad de elementos
　　　　//Se utiliza el punto y coma
　　　　myarray := [...]string{"GFG", "gfg", "w3"codeboxs", "es.oldtoolbag.com", "w"3codebox"}
　　　　fmt.Println("数组元素:　", myarray)
　　　　//数组的长度
　　　　//由...决定
　　　　//使用len()方法
　　　　fmt.Println("数组的长度为:", len(myarray))
{}

Salida:

数组元素:　　[GFG gfg w3codeboxs es.oldtoolbag.com w3codebox]
数组的长度为:　5

在数组中，允许您在array 在指定元素范围内进行迭代。如下例所示：

示例

//如何迭代数组
package main
import "fmt"
func main() {
　　　　//创建一个数组，其大小
　　　　//省略号表示
　　　　myarray := [...]int{29,　79,　49,　39,　20,　49,　48,　49{}
　　　　//使用for循环迭代数组
　　　　for x := 0; x < len(myarray); x++　{
　　　　　　　　fmt.Printf("%d\n", myarray[x])
　　　　{}
{}

Salida:

在Go语言中，数组的值类型不是引用类型。因此，当将数组分配给新变量时，在新变量中所做的更改不会影响原始数组。如下例所示：

示例

package main
import "fmt"
func main() {
　　　　//创建一个数组，其大小
　　　　//省略号表示
　　　　my_array := [...]int{100,　200,　300,　400,　500}
　　　　fmt.Println("原始数组(改变前):", my_array)
　　　　//创建一个新变量
　　　　//并使用my_array进行初始化
　　　　new_array := my_array
　　　　fmt.Println("新数组(改变前):", new_array)
　　　　//将索引0处的值更改为500
　　　　new_array[0] =　500
　　　　fmt.Println("新数组(改变后):", new_array)
　　　　fmt.Println("原始数组(改变后):", my_array)
{}

Salida:

原始数组(改变前):　[100　200　300　400　500]
新数组(改变前):　[100　200　300　400　500]
新数组(改变后):　[500　200　300　400　500]
原始数组(改变后):　[100　200　300　400　500]

在数组中，如果数组的元素类型是可比较的，则数组类型也是可比较的。因此，我们可以使用==运算符直接比较两个数组。如下例所示：

示例

//如何比较两个数组
package main
import "fmt"
func main() {
　　　　arr1　:=[3]int{9,　7,　6{}
　　　　arr2　:=[...]int{9,　7,　6{}
　　　　arr3　:=[3]int{9,　5,　3{}
　　　　//使用==运算符比较数组
　　　　fmt.Println(arr1　==[2)
　　　　fmt.Println(arr2　==[3)
　　　　fmt.Println(arr1　==[3)
　　　　//这将导致错误，因为
　　　　//　arr1和arr4其类型不匹配
　　　　/*
　　　　　　　arr4:=[4]int{9,7,6{}
　　　　　　　fmt.Println(arr1==arr4)
　　　　*/
{}

Salida:

true
false
false

Copia de arreglos de Go Funciones utilizadas como campos de estructura de Go