Arrays y Slices

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)
	
}