Hola mundo en Go

1

Introducción al Curso de Golang

2

¿Qué es, por qué y quienes utilizan Go?

3

Instalar Go en Linux

4

Instalar Go en Mac

5

Instalar Go en Windows

6

Nuestras primeras líneas de código con Go

Variables, funciones y documentación

7

Variables, constantes y zero values

8

Operadores aritméticos

9

Tipos de datos primitivos

10

Paquete fmt: algo más que imprimir en consola

11

Uso de funciones

12

Go doc: La forma de ver documentación

Estructuras de control de flujo y condicionales

13

El poder de los ciclos en Golang: for, for while y for forever

14

Operadores lógicos y de comparación

15

El condicional if

16

Múltiple condiciones anidadas con Switch

17

El uso de los keywords defer, break y continue

Estructuras de datos básicas

18

Arrays y Slices

19

Recorrido de Slices con Range

20

Llave valor con Maps

21

Structs: La forma de hacer clases en Go

22

Modificadores de acceso en funciones y Structs

Métodos e interfaces

23

Structs y Punteros

24

Stringers: personalizar el output de Structs

25

Interfaces y listas de interfaces

Concurrencia y Channels

26

¿Qué es la concurrencia?

27

Primer contacto con las Goroutines

28

Channels: La forma de organizar las goroutines

29

Range, Close y Select en channels

Manejo de paquetes y Go Modules

30

Go get: El manejador de paquetes

31

Go modules: Ir más allá del GoPath con Echo

32

Modificando módulos con Go

Despedida del curso

33

Despedida

Bonus

34

Cheat Sheet Go

35

Librerías para desarrollo web con Go

36

Data Science con Go

Aún no tienes acceso a esta clase

Crea una cuenta y continúa viendo este curso

Arrays y Slices

18/36
Recursos

Aportes 20

Preguntas 6

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad? Crea una cuenta o inicia sesión.

Se puede acceder a un slice especificando dos índices, un límite bajo y uno alto, separados por dos puntos slice[low : high]. Esto selecciona un rango semiabierto que incluye el primer elemento, pero excluye el último.
Aquí pueden leer mas sobre slices

Investigando:
La diferencia principal entre los arrays es que estos tienen una longitud fija e invariable y deben declarase especifiandola

x := [5]int{0, 1 ,2, 3, 4}

mientras que los Slices tienen una longitud variable y no hay que especificarla en la declaración

var x [ ]float64

en este caso se crea un Slice con una longitud de cero
Si queremos crear un slice deberiamos usar la funcion make:

x := make([]float64, 5)

esto crea un Slice asociado a un array subjacente de longitud 5.
Los Slices siempre están asociados a un array y aunque nunca pueden ser mas largos que el aray, pueden ser mas cortos.
La función make también permite un tercer parámetro, que representa la capacidad del array, por lo que

x := make([]float64, 5, 10)

representa un Slice de longitud 5 y capacidad de 10

package main

import "fmt"

func main() {
	var array [4]int
	array[0] = 1
	array[1] = 2
	fmt.Println(array, len(array), cap(array))

	// Slice
	slice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	fmt.Println(slice, len(slice), cap(slice))

	// Métodos en el slice
	fmt.Println(slice[0])
	fmt.Println(slice[:3])
	fmt.Println(slice[2:4])
	fmt.Println(slice[4:])

	// Append
	slice = append(slice, 11)
	fmt.Println(slice)

	// Append
	newSlice := []int{12, 13, 14}
	slice = append(slice, newSlice...)
	fmt.Println(slice)
}

En Go, los arrays poseen un tamaño fijo y son inmutables, mientras que en los slices su tamaño es dinámico y los puedes modificar.

Para tener en cuenta que si haces un slice copiando otro y modicas la copia, modificas el principal también

package main

import "fmt"

func main() {
	list := []int{0,1,2,3,4,5}
	showNumberArray(list)
	list1 := list[3:]
	showNumberArray(list1)

	list1[0] = 100
	showNumberArray(list)
	showNumberArray(list1)

	list[0] = 200
	showNumberArray(list)
	showNumberArray(list1)

	list = append(list[:3], list[4:]...)
	showNumberArray(list)
	showNumberArray(list1)
}

func showNumberArray(array []int)  {
	fmt.Println(array)
}

También se puede aplicar el método de slices con los arrays para obtener parte del array. array[2:3]

Aparentemente las funciones len y cap no tienen diferencia, sin embargo, en este ejemplo se logra ver la diferencia:

nombresArray := [5]string{"Ana", "José", "Daniel", "María", "Carlos"}
nombresSlice := nombresArray[0:3]
fmt.Println(nombresSlice) // [Ana José Daniel]
fmt.Println(len(nombresSlice))  // 3

fmt.Println(cap(nombresSlice))  // 5

me parece extraño que se indique que los array son inmutables y en seguida se indique que se pueden editar sus valores. La definición de inmutable es precisamente que no se puede modificar. En este caso lo que entiendo es que en los arrays la longitud y tipo de datos que almacena es fija, pero si se pueden modificar sus valores.

Los arrays pueden tener varios tipos de datos?

Un aporte con mas ejemplos para entender mejor los slices 😃

package main

import "fmt"

func main() {
	// Array
	var array [4]int
	array[0] = 1
	array[1] = 2
	fmt.Println(array, len(array), cap(array)) // [1 2 0 0] 4 4

	// Slice
	slice := []int{0, 1, 2, 3, 4, 5, 6}
	fmt.Println(slice, len(slice), cap(slice)) // [0 1 2 3 4 5 6] 7 7
	primes := [6]int{2, 3, 5, 7, 11, 13}

	// Metodos en el slice

	//a[low : high]
	var ejemplo1 = slice[0]
	var ejemplo2 []int = slice[:3]
	var ejemplo3 []int = slice[2:4]
	var ejemplo4 []int = slice[4:]

	fmt.Println("-----------ejemplo1--------------")
	fmt.Println(ejemplo1) // 0
	fmt.Println("-----------ejemplo2---------------")
	fmt.Println(ejemplo2)                   // [0 1 2]
	fmt.Println("len:", len(ejemplo2))      // 3
	fmt.Println("capacity:", cap(ejemplo2)) // 3
	fmt.Println("-----------ejemplo3---------------")
	fmt.Println(ejemplo3)                   // [2 3]
	fmt.Println("len:", len(ejemplo3))      // 2
	fmt.Println("capacity:", cap(ejemplo3)) // 5
	fmt.Println("-----------ejemplo4---------------")
	fmt.Println(ejemplo4)                   //[4 5 6]
	fmt.Println("len:", len(ejemplo4))      //3
	fmt.Println("capacity:", cap(ejemplo4)) // 3

	//a[low : high: max]
	var ejemplo5 []int = primes[1:3:6]
	var ejemplo6 []int = primes[0:3:5]
	var ejemplo7 []int = primes[0:2:2]

	fmt.Println("-----------ejemplo5---------------")
	fmt.Println(ejemplo5)                   //[3 5]
	fmt.Println("len:", len(ejemplo5))      //2
	fmt.Println("capacity:", cap(ejemplo5)) //5
	fmt.Println("-----------ejemplo6---------------")
	fmt.Println(ejemplo6)                   // [2 3 5]
	fmt.Println("len:", len(ejemplo6))      //3
	fmt.Println("capacity:", cap(ejemplo6)) //5
	fmt.Println("-----------ejemplo7---------------")
	fmt.Println(ejemplo7)                   //[2 3]
	fmt.Println("len:", len(ejemplo7))      //2
	fmt.Println("capacity:", cap(ejemplo7)) //2

	// Append
	slice = append(slice, 7)
	fmt.Println(slice) // [0 1 2 3 4 5 6 7]

	// Append slice
	newSlice := []int{8, 9, 10}
	slice = append(slice, newSlice...)
	fmt.Println(slice) //[0 1 2 3 4 5 6 7 8 9 10]

	// Append Remove
	idx := 3
	sliceRemove := append(slice[:idx], slice[idx+1:]...)
	fmt.Println(sliceRemove) // [0 1 2 4 5 6 7 8 9 10]

}

muy recomendado, post sobre arrays en go , habla tambien de como crear arrays multidimensionales( arrays de arrays del mismo tipo) ,_ los arrays son mutables_, la asignacion es por valor y no por referencia y se puede realizar comparación directa de arrays usando el operador ==. Super recomendado para aclarar las dudas

Para quienes quieran leer en bastante más detalle respecto al tema, pueden checar este link:

https://gosamples.dev/capacity-and-length/

Ejercicio [slices + for]:

package main

import ("fmt")

func main(){
  slice := []string{"I", "Love", "Go!"}
  for i := 0; i < len(slice); i++{
    fmt.Println(slice[i])
  }
}

También se pueden hacer Arrays de dos dimensiones de la siguiente manera:
var matriz [2][2]int
fmt.Println(matriz)

Tomando la referencia del compañero Mario Martínez, el hecho de crear un slice con longitud y capacidad, infiere a que dicho slice de tipo arreglo, podrá ser mutable pero con esta pequeña característica.
Prácticamente un híbrido entre array y slice.
Acá un ejemplo:

//Para crear un slice asociado a un array de cierta longitud y capacidad
	//Un mix de arreglo y slice: arreglo mutable
	x := make([]int, 5, 7)
	//Propio de un arreglo
	x[0] = -1
	x[1] = -2
	x[2] = -3
	x[3] = -4
	x[4] = -5
	fmt.Println("Slice con array subyacente", x)
	//Propio de un slice
	y := []int{2, 4, 6, 8, 10, 12}
	x = append(x, y...)
	fmt.Println("Slice alterado", x)

Muy bien

Experimentos…

package main

import "fmt"

func main() {

	fmt.Println()
	fmt.Println("===============")
	fmt.Println("    Arrays")
	fmt.Println("===============")
	fmt.Println()

	fmt.Println("Los 'arrays' en Go son inmutables por definición y no veo forma de declararlo con la palabra clave 'const'" +
		" por lo tanto se declaró así:")
	fmt.Println()

	fmt.Println("var array [4]int")

	var array [4]int

	fmt.Println()
	fmt.Println("Es inmutable con respecto a su tamaño, pero su contenido se puede modificar. Cuando se inicializa, el contenido" +
		" toma en cada índice el valor predeterminado del tipo de dato. Interesante que imprimiéndo en consola la variable" +
		" se muestra 'gráficamente' en representación de Vector:")

	fmt.Println()
	fmt.Println(array)

	fmt.Println()
	fmt.Println("A continuación se declara un array de tipo string ( var arrayString [5]string ). Los 'zero values' serán cadenas vacías de texto:")

	fmt.Println()

	var arrayString [5]string

	fmt.Println(arrayString)

	fmt.Println()
	fmt.Println("Se asignan valores al array de tipo string:")

	arrayString[0] = "Array."
	arrayString[1] = "con."
	arrayString[2] = "cinco."
	arrayString[3] = "palabras."
	arrayString[4] = "puntoFinal."

	fmt.Println()
	fmt.Println(arrayString)

	fmt.Println()
	fmt.Println("===============")
	fmt.Println("    Slices")
	fmt.Println("===============")
	fmt.Println()

	fmt.Println("No se le indica la cantidad de elementos que va a tener")
	fmt.Println()

	var primerSlice []string
	segundoSlice := []string{}
	slicePruebas := []string{"Un.", "slice.", "recien.", "inicializado.", "punto.", "final."}

	fmt.Println("var primerSlice []string >>>", primerSlice)
	fmt.Println("segundoSlice := []string{} >>>", segundoSlice)
	fmt.Println("slicePruebas := []string{\"Un.\", \"slice.\", \"recien.\", \"inicializado.\", \"punto.\", \"final.\"} >>> ", slicePruebas)

	fmt.Println()
	fmt.Println("------------------------------------------")
	fmt.Println("Métodos en arrays y slices ... slaicing???")
	fmt.Println("------------------------------------------")
	fmt.Println()

	fmt.Println("Para la interacción con los elementos. Permiten tomar rangos de los slices, donde el límite superior es 'exclusivo'," +
		" no se incluye en el rango.")
	fmt.Println()

	var indice3 string = slicePruebas[3]
	var sliceHasta3erIndice []string = slicePruebas[:3]
	var sliceDe2al4Indice []string = slicePruebas[2:4]
	var sliceDe4IndiceEnAdelante []string = slicePruebas[4:]

	fmt.Println("slicePruebas[3] >>>", indice3)
	fmt.Println("slicePruebas[:3] >>>", sliceHasta3erIndice)
	fmt.Println("slicePruebas[2:4] >>>", sliceDe2al4Indice)
	fmt.Println("slicePruebas[4:] >>>", sliceDe4IndiceEnAdelante)

	fmt.Println()
	fmt.Println("Ahora declaro un array (inmutable) y pruebo las mismas funciones")
	fmt.Println()

	var arrayNoMutable [6]string
	arrayNoMutable[0] = "Es."
	arrayNoMutable[1] = "Una."
	arrayNoMutable[2] = "Nueva."
	arrayNoMutable[3] = "Historia."
	arrayNoMutable[4] = "Me."
	arrayNoMutable[5] = "Fui."

	fmt.Println("arrayNoMutable = ", arrayNoMutable)
	fmt.Println()

	fmt.Println("arrayNoMutable[3] >>>", arrayNoMutable[3])
	fmt.Println("arrayNoMutable[:3] >>>", arrayNoMutable[:3])
	fmt.Println("arrayNoMutable[2:4] >>>", arrayNoMutable[2:4])
	fmt.Println("arrayNoMutable[4:] >>>", arrayNoMutable[4:])
	fmt.Println()

	fmt.Println("---------------------------")
	fmt.Println("Operaciones solo con slices")
	fmt.Println("---------------------------")
	fmt.Println()

	slicePruebas = append(slicePruebas, "'1'")

	fmt.Println("Se añade un elemento >>> append(slicePruebas, \"'1'\") :\n", slicePruebas)
	fmt.Println()

	nuevoSlice := []string{"'dos'", "'tres'"}
	slicePruebas = append(slicePruebas, nuevoSlice...)

	fmt.Println("Se añade al final otro slice >>> append(slicePruebas, nuevoSlice...) :\n", slicePruebas)
	fmt.Println()

	fmt.Println("En este último lo de 'nuevoSlice...' es una operación especial que saca uno a uno los elementos y los añade.")
	fmt.Println()

	slicePruebas = append(slicePruebas, "se", "añaden", "uno", "a", "uno")
	fmt.Println("append(slicePruebas, \"se\", \"añaden\", \"uno\", \"a\", \"uno\") >>>", slicePruebas)

	fmt.Println()
	fmt.Println("------------------------------")
	fmt.Println("función 'len(array_a_analizar)")
	fmt.Println("______________________________")
	fmt.Println()

	fmt.Println("Permite conocer cuantos elementos hay en el array.")

	fmt.Println()
	fmt.Println("------------------------------")
	fmt.Println("función 'cap(array_a_analizar)")
	fmt.Println("______________________________")
	fmt.Println()

	fmt.Println("Permite conocer cual es la capacidad máxima del array.")

	fmt.Println()
	fmt.Println("...")
	fmt.Println("Aplicación de len(...) y cap(...)")
	fmt.Println()

	fmt.Println("array, len() y cap() >>>", len(array), cap(array))
	fmt.Println("arrayString, len() y cap() >>>", len(arrayString), cap(arrayString))
	fmt.Println("primerSlice, len() y cap() >>>", len(primerSlice), cap(primerSlice))
	fmt.Println("segundoSlice, len() y cap() >>>", len(segundoSlice), cap(segundoSlice))
	fmt.Println("slicePruebas, len() y cap() >>>", len(slicePruebas), cap(slicePruebas))
	fmt.Println("sliceHasta3erIndice, len() y cap() >>>", len(sliceHasta3erIndice), cap(sliceHasta3erIndice))
	fmt.Println("sliceDe2al4Indice, len() y cap() >>>", len(sliceDe2al4Indice), cap(sliceDe2al4Indice))
	fmt.Println("sliceDe4IndiceEnAdelante, len() y cap() >>>", len(sliceDe4IndiceEnAdelante), cap(sliceDe4IndiceEnAdelante))
	fmt.Println("arrayNoMutable, len() y cap() >>>", len(arrayNoMutable), cap(arrayNoMutable))
	fmt.Println("nuevoSlice, len() y cap() >>>", len(nuevoSlice), cap(nuevoSlice))
}

Si han usado el spread operator en Javascript es muy similar a lo que hace en el append la variable newSlice

append(slice, newSlice...)

holi, también se puede suprimir un elemento de un slice:
frutas:= []string{“pera”, “banana”, “uva”, “fresa”, “mango”}
fmt.Println(frutas)
fmt.Println(“en el codigo se abajo se ve cómo se suprime el valor 3 y todos se muestran”)
frutas= appendfrutas[:2], frutas[2+1:]…)
fmt.Println(frutas)

package main

import "fmt"

func main() {
	var array [4]int
	array[0] = 1
	array[1] = 2
	
	fmt.Println(array, len(array), cap(array))

	// Slice

	slice := []int{0, 1, 2, 3, 4, 5, 6}

	fmt.Println(slice, len(slice), cap(slice))

	// Metodos en el slice
	fmt.Println(slice[0])
	fmt.Println(slice[:3])
	fmt.Println(slice[2:4])
	fmt.Println(slice[4:])
	
	// Append
	slice = append(slice, 7)
	fmt.Println(slice)

	// Append nueva lista

	newSlice := []int{8, 9, 10}
	slice = append(slice, newSlice...)
	fmt.Println(slice)
	
}