Arrays y Slices
## Objetivos de Aprendizaje
- Comprender arrays y su tamaño fijo
- Dominar slices con tamaño dinámico
- Usar make, append, len, cap
- Entender internos de slices y arrays subyacentes
- Copiar e iterar
## Arrays
### Declaración
```go
var nums [5]int // Array de 5 enteros, inicializado a cero
var ages [3]int = [3]int{20, 25, 30}
prices := [4]float64{9.99, 19.99, 29.99, 39.99}
```
### Con Ellipsis
```go
scores := [...]int{95, 85, 78, 92} // El compilador cuenta elementos
fmt.Println(len(scores)) // 4
```
### Longitud del Array
```go
nums := [5]int{1, 2, 3, 4, 5}
fmt.Println(len(nums)) // 5
```
### Acceder a Elementos
```go
nums := [5]int{10, 20, 30, 40, 50}
fmt.Println(nums[0]) // 10 (primer elemento)
fmt.Println(nums[4]) // 50 (último elemento)
nums[2] = 35 // Modificar elemento
```
## Slices
### Declaración de Slice
```go
slice := []int{1, 2, 3, 4, 5} // Literal de slice
var slice []int // slice nil
emptySlice := []int{} // Slice vacío (no nil)
```
### Array a Slice
```go
nums := [5]int{1, 2, 3, 4, 5}
slice := nums[1:4] // Elementos en índice 1, 2, 3
fmt.Println(slice) // [2 3 4]
// Slice completo
all := nums[:] // [1 2 3 4 5]
firstThree := nums[:3] // [1 2 3]
lastTwo := nums[3:] // [4 5]
```
### Sintaxis de Slice
```go
slice[start:end] // start inclusivo, end exclusivo
slice[start:] // desde start hasta el final
slice[:end] // desde el principio hasta end-1
slice[:] // slice completo
```
## Función make
### Crear Slice
```go
slice := make([]int, 5) // Slice de 5 ints, inicializado a cero
slice := make([]int, 5, 10) // Slice con longitud 5, capacidad 10
```
### Crear Map
```go
m := make(map[string]int, 100) // Map con capacidad inicial
```
### Crear Channel
```go
ch := make(chan int, 10) // Canal con buffer
```
## len y cap
### Longitud vs Capacidad
```go
slice := make([]int, 3, 10)
fmt.Println(len(slice)) // 3 (número de elementos)
fmt.Println(cap(slice)) // 10 (espacio disponible)
```
### Slice Nil
```go
var slice []int // slice nil
fmt.Println(len(slice)) // 0
fmt.Println(cap(slice)) // 0
```
### Slice Vacío
```go
slice := []int{}
fmt.Println(len(slice)) // 0
fmt.Println(cap(slice)) // 0
```
## Función append
### append Básico
```go
slice := []int{1, 2, 3}
slice = append(slice, 4) // [1 2 3 4]
slice = append(slice, 5, 6) // [1 2 3 4 5 6]
```
### Append de Otro Slice
```go
slice1 := []int{1, 2, 3}
slice2 := []int{4, 5, 6}
slice1 = append(slice1, slice2...) // [1 2 3 4 5 6]
```
### Crecer Slice
```go
slice := make([]int, 0, 2) // capacidad 2
slice = append(slice, 1) // [1]
slice = append(slice, 2) // [1 2]
slice = append(slice, 3) // [1 2 3] - capacidad se duplica
```
## Internos de Slice
### Estructura
Un slice tiene tres componentes:
1. Puntero al array subyacente
2. Longitud (número de elementos)
3. Capacidad (espacio disponible)
```go
type SliceHeader struct {
Data uintptr
Len int
Cap int
}
```
### Respaldado por Array
```go
array := [5]int{1, 2, 3, 4, 5}
slice := array[1:4] // Apunta a elementos 2, 3, 4
slice[0] = 10 // Modifica el array subyacente
fmt.Println(array) // [1 10 3 4 5]
```
### Reslicing
```go
slice := []int{1, 2, 3, 4, 5}
s := slice[1:3] // [2 3]
s = s[:cap(s)] // Reslice para extender
fmt.Println(s) // [2 3 4 5]
```
## Función copy
### Copia Básica
```go
src := []int{1, 2, 3}
dst := make([]int, len(src))
n := copy(dst, src)
fmt.Println(dst, n) // [1 2 3] 3
```
### Copia Parcial
```go
src := []int{1, 2, 3, 4, 5}
dst := make([]int, 2)
n := copy(dst, src)
fmt.Println(dst, n) // [1 2] 2
```
### Slices Superpuestos
```go
slice := []int{1, 2, 3, 4, 5}
n := copy(slice[2:], slice[:3])
fmt.Println(slice) // [1 2 1 2 3]
```
## Iteración
### Bucle Range
```go
slice := []int{10, 20, 30}
for i, v := range slice {
fmt.Printf("Índice: %d, Valor: %d\n", i, v)
}
// Solo índice
for i := range slice {
fmt.Println(i)
}
// Solo valor
for _, v := range slice {
fmt.Println(v)
}
```
### Con Variable de Índice
```go
slice := []string{"a", "b", "c"}
for i := 0; i < len(slice); i++ {
fmt.Printf("%d: %s\n", i, slice[i])
}
```
## Filtrar Slices
### Sin Asignación
```go
slice := []int{1, 2, 3, 4, 5, 6}
result := slice[:0]
for _, v := range slice {
if v%2 == 0 {
result = append(result, v)
}
}
fmt.Println(result) // [2 4 6]
```
## Ordenar Slices
### Importar sort
```go
import "sort"
slice := []int{3, 1, 4, 1, 5, 9}
sort.Ints(slice)
fmt.Println(slice) // [1 1 3 4 5 9]
strings := []string{"banana", "apple", "cherry"}
sort.Strings(strings)
fmt.Println(strings) // [apple banana cherry]
```
### Orden Inverso
```go
slice := []int{3, 1, 4, 1, 5, 9}
sort.Sort(sort.Reverse(sort.IntSlice(slice)))
fmt.Println(slice) // [9 5 4 3 1 1]
```
### Orden Personalizado
```go
type Person struct {
Name string
Age int
}
people := []Person{
{"Alice", 30},
{"Bob", 25},
{"Charlie", 35},
}
sort.Slice(people, func(i, j int) bool {
return people[i].Age < people[j].Age
})
```
## Operaciones Comunes
### Eliminar Elemento
```go
slice := []int{1, 2, 3, 4, 5}
i := 2 // Eliminar elemento en índice 2
slice = append(slice[:i], slice[i+1:]...)
fmt.Println(slice) // [1 2 4 5]
```
### Push/Pop
```go
slice := []int{1, 2, 3}
// Push
slice = append(slice, 4) // [1 2 3 4]
// Pop
last := slice[len(slice)-1]
slice = slice[:len(slice)-1]
fmt.Println(last) // 4
```
### Operaciones de Pila
```go
stack := []int{}
// Push
stack = append(stack, 1)
stack = append(stack, 2)
stack = append(stack, 3)
// Pop
top := stack[len(stack)-1]
stack = stack[:len(stack)-1]
fmt.Println(top) // 3
```
## Slices 2D
### Declaración de Slice 2D
```go
matrix := [][]int{
{1, 2, 3},
{4, 5, 6},
{7, 8, 9},
}
for i := range matrix {
for j := range matrix[i] {
fmt.Printf("%d ", matrix[i][j])
}
fmt.Println()
}
```
### Array Irregular
```go
jagged := make([][]int, 3)
for i := range jagged {
jagged[i] = make([]int, i+1)
for j := range jagged[i] {
jagged[i][j] = i*j
}
}
```
## Resumen
- Los arrays tienen tamaño fijo, los slices son dinámicos
- Los slices consisten en puntero, longitud y capacidad
- `make()` crea slices con longitud y capacidad especificadas
- `append()` añade elementos, duplicando capacidad cuando es necesario
- Los slices referencian arrays subyacentes - modificaciones afectan todos los slices
- `len()` retorna número de elementos, `cap()` retorna espacio disponible
- `copy()` copia elementos entre slices
- Usar `sort.Ints()`, `sort.Strings()`, `sort.Slice()` para ordenar
Comments
Comments powered by Giscus
To enable comments, add your Giscus embed code here.
Learn more about Giscus →