Uso de Slices

Clase 15 de 42 • Curso Práctico de Go: Creación de un Servidor Web

Contenido del curso

Introducción a Go

Nuestra Primera Aplicación Go

Lista de Tareas

Interfaces

Goroutines y Channels

Construyendo un Servidor Web

Tomar examen

Comentarios

Macarena Ugarte

student•

Los tres puntos al final de t.task[index + 1:]… (operador ellipsis) es porque el segundo parámetro del append no es un slice y la función append recibe un item, con este operador lo que hacemos es decirle a go que tome ese slice y lo “desempaquete” para que sean muchos parámetros de 1 solo item y no un slice.

Ejemplo:

t.tasks = append(t.tasks, task1, task2, task3)

Lo que haría el operador de ellipsis seria pasar un slice a este formato de muchos parámetros.

Avelino Sánchez

student•

Muy interesante este dato! Aunque en especial el nombre del operador que no lo conocía.

JULIAN FRANCO RUA

student•

Variadic Functions https://gobyexample.com/variadic-functions

Diego Ramírez

student•

Creo que se debería explicar en este punto el uso de los 3 puntos (...) no solamente decir que sino sale error de sintaxis. Gracias igual a la comunidad que si lo menciona :)

Osmar Luciano Villaba Gonzalez

student•

llevas razón, quedo bastante vago y confuso al final.

Avelino Sánchez

student•

Los arreglos (arrays) son una estructura de dato de tamaño fijo. Previamente tienen declarada su longitud y no puede ser mutada en tiempo de ejecución.

Los slices son una estructura de dato que se utiliza de manera similar a los arreglos pero con un comportamiento más similar a las listas; esto en el aspecto de que tienen una longitud variable.

Así como los arrays, los slices definen su tipo con el uso de corchetes, pero con la diferencia de que no tenemos que indicar su tamaño.

// Declaración de una variable de tipo slice
// con elementos de tipo string
var list []string

La función append sirve para agregar elementos a un slice. Ésta recibe como parámetros el slice y el elemento que se quiere agregar

// Agregando un elemento al slice
list = append(list, &quot;element&quot;)

// Eliminando un elemento del slice
// [:index] Desde el inicio hasta el índice
// [index+1:] Desde el índice hasta el final
list = append(list[:index], list[index+1]...)

// Inicializando un slice
// cuando se hace con una línea
// go no solicita la coma del último elemento
list := []string{&quot;study&quot;,&quot;clean&quot;,&quot;pay&quot;}

// Cuando se hace multi-línea. si
list := []string{
	&quot;study&quot;,
	&quot;clean&quot;,
	&quot;pay&quot;,
}

length := len(list)

El método len() nos sirve para saber la longitud de alguna estructura de datos, string, apuntador de un array o un channel.

Alexander Echeverry

student•

y como hallariamos la longitud de un arreglo de 2 dimensiones?

Osmar Luciano Villaba Gonzalez

student•

Buenisimo aporte macho!!! gracias

Carlos Javier Bazan Huaman

student•

Cuando eliminas un elemento del slice estas usando un comportamiento del slice que son los dos puntos (:) que lo que hace es obtener los elementos que se indican ( inicio : final ) asi: a[1:4] ; que basicamente es un rango de indices, similar a un substring(1,4).

Avelino Sánchez

student•

No lo había visto de esa manera, creo que relacionándolo así es más sencillo de entender y visualizar. :sm

Abdallah Abedraba

student•

11:35 No queda muy clara la explicación. Aquí la explicación.

Héctor Hugo Sandoval Marcelo

student•

Es verdad, el enlace lo explica mejor, gracias!

Ángel David Vargas Hernández

student•

El dominio ya está en venta :(

Juan Pablo Rodríguez Morales

student•

Un punto importante que encontré en la documentación, los array en GO funcionan como un conjunto de valores, no como un conjunto de referencias, es decir, al enviarlo a una función, esta hace una copia de los valores. Los slices funcionan como referencias, internamente GO utiliza slices por encima de arreglos y recomienda usarlos siempre que sea posible:

https://www.godesignpatterns.com/2014/05/arrays-vs-slices.html

Axel Somerseth Cordova Lopez

student•

Yo entendí el operador ... (ellipsis) de Go como un operador de dispersión. Lo que se hizo en el arreglo es dispersar los elementos del slice como argumentos en la función append. Aquí un ejemplo:


package main

import "fmt"

func sumar(numeros ...int) int {
	result := 0
	for _, num := range numeros {
		result += num
	}
	return result
}

func main() {
	primos := []int{2, 3, 5, 7}
	fmt.Println(sumar(primos...)) // Resultado: 17
}

Implementación de la función append en los Go Docs: ![](

Y aquí un ejemplo en Javascript que produce el mismo resultado:

const sumar = (w, x, y, z) => w + x + y + z;

const primos = [2, 3, 5, 7];

console.log(sumar(...primos)); // Resultado: 17

Daniel Alejandro Cumaco Robayo

student•

Para los del barrio que venimos sabiendo C, los arrays de aqui son los mismos de C, y los slices de golang no son mas que los malloc de C, pero en golang no hay que hacer free :v

Otra cosa, la manera de como el agrega elementos uno a uno expandiendo la memoria por cada elemento nuevo es una mala practica que pesa mucho en el performance, eso no se hace, si quieren entender porque es algo largo y complejo, pero en pocas palabras cada ves que agregas una nueva variable se hace limpieza y realocacion, a parte de que es en la memoria virtual la cua es lenta, asi que hay que tratar de evitar hacer esta operaciones a cada rato, la solucion? hacer allocacion de memoria exponencial

Si quieren que haga un blog explicando a profundidad y de como y porque implementar un sistema asi comenten y asi me animo

Jean Nuñez

student•

los slice son mucho mas poderoso sobre los arreglos porque son mas dinamicos

Carlos Nassif Trejo Garcia

student•

package main

import "fmt"


type taskList struct {
	tasks []*task
}

func(t *taskList) agregarALista(tl *task) {
	t.tasks = append(t.tasks, tl)
}

func (t *taskList) eliminarDeLista(index int) {
	// ... desempaquetar los elementos
	t.tasks = append(t.tasks[:index], t.tasks[index + 1:]...)
}

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

func (t *task) marcarCompleta() {
	t.completado = true
}

func (t *task) actualizarDescripcion(desc string) {
	t.descripcion = desc
}

func (t *task) actualizarNombre( nombre string) {
	t.nombre = nombre
}

func main() {
	t0 := &task{
		nombre:      "Completar curso go",
		descripcion: "Completar el curso de go en esta semana",
	}
	t1 := &task{
		nombre:      "Completar curso Python",
		descripcion: "Completar el curso de go en esta semana",
	}
	t2 := &task{
		nombre:      "Completar curso Mongo",
		descripcion: "Completar el curso de go en esta semana",
	}
	

	lista := &taskList{
		tasks: []*task{
			t0, t1,
		},
	}

	fmt.Println(lista.tasks[0])

	fmt.Println(len(lista.tasks))

	lista.agregarALista(t2)

	fmt.Println(len(lista.tasks))

	lista.eliminarDeLista(1)
	fmt.Println(len(lista.tasks))

	
}

Sergio Martinez Marin

student•

Humildemente, me parece que hay complicaciones extras sin necesidad, puede ser un slice normal y las funciones de manipulación del slice usan apuntadores para hacer paso de parámetros por referencia.

Fernando Moran

student•

me perdí con tanto pasos de valores con & y * y mas con struct

HOME SIETE

student•

El primer caso: recibe como parámetros un slice y los elementos que se agregaran a ese slice. El segundo caso: recibe como parámetros dos slice. Para el ejemplo de agregar elementos se usa el primer caso. Para el ejemplo de remover tareas se usa el segundo caso.

Los slices tienen una forma de excluir e incluir índices según sea nuestra conveniencia, por ejemplo:

slice := []int{0,1,2,3,4,5,6}
fmt.Println(slice[:3])

nos mostrara en consola

[0 1 2] es decir se excluye el valor de la posición 3 y se muestra sus antecesores.

fmt.Println(slice[2:4])

nos mostrará en consola [2 3] lo podemos ver como un rango de valores a mostrar, es decir se incluye el valor de la posición 2 hasta la posición 4 excluyendo este último del resultado.

fmt.Println(slice[4:])

nos mostrará en consola [4 5 6] es decir se incluye el valor del índice 4 en adelante así mismo podemos agregar un slice a otro slice

newSlice := []int{7,8,9}
slice = append(slice, newSlice…)
//nos mostrara en consola
//[0 1 2 3 4 5 6 7 8 9]

Usuario anónimo

user•

Genial :)

Jonathan Stephen Tellez Rincon

student•

//Arrays tamaño fijo var numbers1 [4]int numbers2 := [...]int{0,0,0,0}

//Slices tamaño dinamico slice1 := []int{2,3,4}

Jean Nuñez

student•

los rreglos son un poco diferente porque una vez dimensionados no se puede cambiar su longitud

Jean Nuñez

student•

los arreglos en go son inmutables

Jean Nuñez

student•

task []*task estamos agregando valores y no la referencia

Jean Nuñez

student•

loas struct tiene proiedades, como pueden ser arreglos

Jean Nuñez

student•

len para ver la Longitud del slice

// Agregando un elemento al slice
list = append(list, &quot;element&quot;)

// Eliminando un elemento del slice
// [:index] Desde el inicio hasta el índice
// [index+1:] Desde el índice hasta el final
list = append(list[:index], list[index+1]...)

// Inicializando un slice
// cuando se hace con una línea
// go no solicita la coma del último elemento
list := []string{&quot;study&quot;,&quot;clean&quot;,&quot;pay&quot;}

// Cuando se hace multi-línea. si
list := []string{
	&quot;study&quot;,
	&quot;clean&quot;,
	&quot;pay&quot;,
}

length := len(list)

package main

import "fmt"

func sumar(numeros ...int) int {
	result := 0
	for _, num := range numeros {
		result += num
	}
	return result
}

func main() {
	primos := []int{2, 3, 5, 7}
	fmt.Println(sumar(primos...)) // Resultado: 17
}

package main

import "fmt"


type taskList struct {
	tasks []*task
}

func(t *taskList) agregarALista(tl *task) {
	t.tasks = append(t.tasks, tl)
}

func (t *taskList) eliminarDeLista(index int) {
	// ... desempaquetar los elementos
	t.tasks = append(t.tasks[:index], t.tasks[index + 1:]...)
}

type task struct {
	nombre      string
	descripcion string
	completado  bool
}

func (t *task) marcarCompleta() {
	t.completado = true
}

func (t *task) actualizarDescripcion(desc string) {
	t.descripcion = desc
}

func (t *task) actualizarNombre( nombre string) {
	t.nombre = nombre
}

func main() {
	t0 := &task{
		nombre:      "Completar curso go",
		descripcion: "Completar el curso de go en esta semana",
	}
	t1 := &task{
		nombre:      "Completar curso Python",
		descripcion: "Completar el curso de go en esta semana",
	}
	t2 := &task{
		nombre:      "Completar curso Mongo",
		descripcion: "Completar el curso de go en esta semana",
	}
	

	lista := &taskList{
		tasks: []*task{
			t0, t1,
		},
	}

	fmt.Println(lista.tasks[0])

	fmt.Println(len(lista.tasks))

	lista.agregarALista(t2)

	fmt.Println(len(lista.tasks))

	lista.eliminarDeLista(1)
	fmt.Println(len(lista.tasks))

	
}

Uso de Slices

Introducción a Go

Mi primer programa en Go

Instalación en Mac y Windows

Instalar VS Code

Comandos básicos de Go

Analizando un programa en Go

Nuestra Primera Aplicación Go

Descripción del proyecto 1: Calculadora

Leer inputs desde la consola

Manejo de errores y uso de If

Switch

Lista de Tareas

Structs y Receivers

Descripción del proyecto 2: Lista de Tareas

Structs para Lista de Tareas

Punteros

Punteros en Structs

Uso de Slices

Ciclo For

Implementar For en Struct

Interfaces

¿Qué es una interfaz?

Maps

¿Por qué las Interfaces?

Creando la Interfaz Animal

Imprimiendo el contenido de una Página Web usando Interfaces

Goroutines y Channels

Introducción al problema de la Concurrencia

GoRoutines

Channels

Implementación de Goroutines y channels

Construyendo un Servidor Web

Ciclos While y For

Descripción de Servidor Web

Creando el Servidor

Manejando rutas en backend

¿Qué es un Middleware?

Manejando Request HTTP

Asignando Rutas HTTP

Agregando Middlewares

Agregando Multiples Middlewares

Agregando otro Middleware

Manejando POST

Manejando Modelos y JSON

Respondiendo Request JSON

Go Modules creando nuestro primer módulo en Go

Implementando nuestro primer módulo en Go

Conclusiones del Curso y siguientes pasos