![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-19.45.02.png\")
\nEl int es 0 y el string esta vacio.
Vamos a ir viendo como trabajar con el lenguaje, es decir, como usar variables, arrays, slices, estructuras...etc. He pensado que es mejor hacer post mas cortos, y asi público un poco más rápido, por lo que cada post realmente tratará unicamente de un tema.Sin entretenerme más empecemos a trabajar.
\nPara los que no lo sepan, una variable es un elemento de un tipo específico(numeral, texto, etc) que usamos para gestionar y poder trabajar con ellos. Después de este resumen extraño, comento con un poco más de tecnicismos, realmente una variable es una dirección de memoria que reservamos donde almacenamos el valor que contiene la variable. Esto es importante entenderlo, en lenguajes como Go sobretodo, porque el lenguaje usa punteros (los veremos más adelante, pero resumiendo es como un acceso directo a esa dirección de memoria)
\nVamos a empezar con los tipos primitivos o básicos que tiene el lenguaje(como tal podemos crear nuestros propios tipos, pero eso ya lo veremos), aunque más que ver los tipos voy a hablar de como trabajar con ellos.
\nLos tipos básicos en Go los tenéis o en la documentación oficial o más resumido en el tour oficial del lenguaje.
En Go las variables tienen un tipado estático, y ¿esto que quiere decir?, pues que a la hora de declararlas tenemos que indicar el tipo, el cual no cambia:
\nvar power int\nvar rangerName string\nUn detalle importante, en Go no existe nil, null, undefined ni nada similar, siempre, siempre, siempre las variables son iniciadas, si no lo son por nosotros, el lenguaje automáticamente le pone 0 o "", según el caso. Si intentamos imprimir eso:
\npackage main\n\nimport "fmt"\n\nfunc main() {\n\n var power int\n var rangerName string\n\n fmt.Println("Power ranger red power: ", power)\n fmt.Println("Power ranger red name: ", rangerName)\n\n}\n\n
\nEl int es 0 y el string esta vacio.
Es posible tambien declarar varias variables del mismo tipo en la misma linea
\nvar power,speed int\nLas variables es posible iniciarlas una vez que son declaradas(tambien si hemos declarado varias en la misma linea)
\nvar power, speed int = 100,70\nSi imprimimos con:
\n\tfmt.Println("Power ranger red power: ", power)\n\tfmt.Println("Power ranger red speed: ", speed)\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-19.53.07.png\")
\nComo extra Go tiene otra forma bastante mas ágil de declarar variables e iniciarlas que infiere el tipo (un poco de azúcar sintáctico)
power := 100\nspeed := 70\n#Tambien podemos declarar varias a la vez\nstamina, swordsSkill := 50, 80\n# Y es posible usar distintos tipos en la misma declaración\nmegazordSkill, rangerName := 1000,"Scott"\n## Realmente tambien infiere el tipo si inicializamos al declarar una variable\nvar power = 100 seria igual que lo de arriba\nSi os fijais en la ultima declaración tenemos un int y un string, pues si imprimimos:
\nfmt.Println("Power ranger red power: ", power)\nfmt.Println("Power ranger red speed: ", speed)\nfmt.Println("Power ranger red stamina: ", stamina)\nfmt.Println("Power ranger red swordsSkill: ", swordsSkill)\nfmt.Println("Power ranger red megazordSkill: ", megazordSkill)\nfmt.Println("Power ranger red name: ", rangerName)\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.04.20.png\")
En cuanto a las constantes comentar que como gran parte de los lenguajes Go también las tiene, básicamente es cambiar la palabra var por const:
\nconst hello = "Hello World"\nconst hello string = "Hello World"\nGo no traduce entre tipos como otros lenguajes, por lo que tenemos que hacerlo nosotros, si probamos con este ejemplo:
\njump := 60\ngravityForce := 9.8\nfmt.Println(v / p * 2)\nTendriamos este error:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.11.51.png\")
Como el error indica tenemos que igualar los tipos:
\nfmt.Println(float64(jump) / gravityForce * 2)\nEsto ya no daria error y funcionaría sin problemas. No voy a especificar como transformar los tipos de todas las variables porque eso en la documentación esta bien explicado, y tenéis ejemplos. Tambien tenemos funciones para transformar de String a int y viceversa(esto veremos algun ejemplo mas adelante pero insisto en la documentación viene bastante bien y es realmente sencillo).
\nPara los que tenga bastante experiencia,comentar que es posible sobreescribir los métodos propios que transforman todo en String,es decir lo que usa fmt, y hacer lo que nosotros queramos(esto lo veremos mas adelante), es bastante útil cuando no podemos imprimir algunos datos o funciones directamente por algún motivo(por ejemplo con los struct)
En Go existe el concepto de variables públicas y privadas, las privadas solo son visibles en el fichero donde estan.
\nLa diferencia está en la declaración, si las declaramos con la primera letra en mayúsculas o en minusculas:
Veamos un ejemplo:
\nCreemos una estructura de ficheros similar a esta donde tengamos el root del proyecto como comentamos en el post anterior:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.40.34.png\")
\nComo vemos tenemos un fichero main.go como hemos tenido siempre, una carpeta rangerModel y dentro de esta un fichero rangerModel.go
En rangerModel.go ponemos lo siguiente:
\npackage rangerModel\n\nvar power int\nvar speed int\nComo vemos he puesto el nombre del paquete donde esta alojado para diferenciarlo del main.
\nEn el main.go:
package main\n\nimport (\n\t"vuestroRootPath/rangerModel"\n\t"fmt"\n)\n\nfunc main() {\n\tpower := rangerModel.power\n\tfmt.Println("Power ranger red power:", power)\n}\nSi guardamos ambos, vemos como nos da un error al instanciar el power del rangerModel:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.46.31.png\")
\nComo tal no tenemos acceso a la variable o propiedad power de rangerModel.
\nAhora vamos a cambiar el power por Power en el modelo, quedando de esta manera(de paso le ponemos un valor):
package rangerModel\n\nvar Power = 100\nvar speed int\nY lo mismo en el main:
\nfunc main() {\n\tpower := rangerModel.Power\n\tfmt.Println("Power ranger red power:", power)\n}\nAhora si imprimimos:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.50.04.png\")
\nEs bastante sencillo como veis, comentar que no es recomendable hacer variables públicas(o exportar variables según el lenguaje de Go), por eso nos da esta recomendación al ponerlo en mayúsculas:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-27-a-las-20.54.51.png\")
Por el momento dejamos aquí las variables básicas, más adelante seguiremos trabajando con ellas.
\nNos vemos en el siguiente
Vamos a ir viendo como trabajar con el lenguaje, es decir, como usar variables, arrays, slices, estructuras...etc. He pensado que es mejor hacer post mas cortos, y asi público un poco más rápido, por lo que cada post realmente tratará unicamente de un tema.Sin entretenerme más empecemos a trabajar.
\nPara los que no lo sepan, una variable es un elemento de un tipo específico(numeral, texto, etc) que usamos para gestionar y poder trabajar con ellos. Después de este resumen extraño, comento con un poco más de tecnicismos, realmente una variable es una dirección de memoria que reservamos donde almacenamos el valor que contiene la variable. Esto es importante entenderlo, en lenguajes como Go sobretodo, porque el lenguaje usa punteros (los veremos más adelante, pero resumiendo es como un acceso directo a esa dirección de memoria)
\nVamos a empezar con los tipos primitivos o básicos que tiene el lenguaje(como tal podemos crear nuestros propios tipos, pero eso ya lo veremos), aunque más que ver los tipos voy a hablar de como trabajar con ellos.
\nLos tipos básicos en Go los tenéis o en la documentación oficial o más resumido en el tour oficial del lenguaje.
En Go las variables tienen un tipado estático, y ¿esto que quiere decir?, pues que a la hora de declararlas tenemos que indicar el tipo, el cual no cambia:
\nvar power int\nvar rangerName string\nUn detalle importante, en Go no existe nil, null, undefined ni nada similar, siempre, siempre, siempre las variables son iniciadas, si no lo son por nosotros, el lenguaje automáticamente le pone 0 o \"\", según el caso. Si intentamos imprimir eso:
\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n\n var power int\n var rangerName string\n\n fmt.Println(\"Power ranger red power: \", power)\n fmt.Println(\"Power ranger red name: \", rangerName)\n\n}\n\n
\nEl int es 0 y el string esta vacio.
Es posible tambien declarar varias variables del mismo tipo en la misma linea
\nvar power,speed int\nLas variables es posible iniciarlas una vez que son declaradas(tambien si hemos declarado varias en la misma linea)
\nvar power, speed int = 100,70\nSi imprimimos con:
\n\tfmt.Println(\"Power ranger red power: \", power)\n\tfmt.Println(\"Power ranger red speed: \", speed)\n
\nComo extra Go tiene otra forma bastante mas ágil de declarar variables e iniciarlas que infiere el tipo (un poco de azúcar sintáctico)
power := 100\nspeed := 70\n#Tambien podemos declarar varias a la vez\nstamina, swordsSkill := 50, 80\n# Y es posible usar distintos tipos en la misma declaración\nmegazordSkill, rangerName := 1000,\"Scott\"\n## Realmente tambien infiere el tipo si inicializamos al declarar una variable\nvar power = 100 seria igual que lo de arriba\nSi os fijais en la ultima declaración tenemos un int y un string, pues si imprimimos:
\nfmt.Println(\"Power ranger red power: \", power)\nfmt.Println(\"Power ranger red speed: \", speed)\nfmt.Println(\"Power ranger red stamina: \", stamina)\nfmt.Println(\"Power ranger red swordsSkill: \", swordsSkill)\nfmt.Println(\"Power ranger red megazordSkill: \", megazordSkill)\nfmt.Println(\"Power ranger red name: \", rangerName)\n
En cuanto a las constantes comentar que como gran parte de los lenguajes Go también las tiene, básicamente es cambiar la palabra var por const:
\nconst hello = \"Hello World\"\nconst hello string = \"Hello World\"\nGo no traduce entre tipos como otros lenguajes, por lo que tenemos que hacerlo nosotros, si probamos con este ejemplo:
\njump := 60\ngravityForce := 9.8\nfmt.Println(v / p * 2)\nTendriamos este error:
\n
Como el error indica tenemos que igualar los tipos:
\nfmt.Println(float64(jump) / gravityForce * 2)\nEsto ya no daria error y funcionaría sin problemas. No voy a especificar como transformar los tipos de todas las variables porque eso en la documentación esta bien explicado, y tenéis ejemplos. Tambien tenemos funciones para transformar de String a int y viceversa(esto veremos algun ejemplo mas adelante pero insisto en la documentación viene bastante bien y es realmente sencillo).
\nPara los que tenga bastante experiencia,comentar que es posible sobreescribir los métodos propios que transforman todo en String,es decir lo que usa fmt, y hacer lo que nosotros queramos(esto lo veremos mas adelante), es bastante útil cuando no podemos imprimir algunos datos o funciones directamente por algún motivo(por ejemplo con los struct)
En Go existe el concepto de variables públicas y privadas, las privadas solo son visibles en el fichero donde estan.
\nLa diferencia está en la declaración, si las declaramos con la primera letra en mayúsculas o en minusculas:
Veamos un ejemplo:
\nCreemos una estructura de ficheros similar a esta donde tengamos el root del proyecto como comentamos en el post anterior:
\n
\nComo vemos tenemos un fichero main.go como hemos tenido siempre, una carpeta rangerModel y dentro de esta un fichero rangerModel.go
En rangerModel.go ponemos lo siguiente:
\npackage rangerModel\n\nvar power int\nvar speed int\nComo vemos he puesto el nombre del paquete donde esta alojado para diferenciarlo del main.
\nEn el main.go:
package main\n\nimport (\n\t\"vuestroRootPath/rangerModel\"\n\t\"fmt\"\n)\n\nfunc main() {\n\tpower := rangerModel.power\n\tfmt.Println(\"Power ranger red power:\", power)\n}\nSi guardamos ambos, vemos como nos da un error al instanciar el power del rangerModel:
\n
\nComo tal no tenemos acceso a la variable o propiedad power de rangerModel.
\nAhora vamos a cambiar el power por Power en el modelo, quedando de esta manera(de paso le ponemos un valor):
package rangerModel\n\nvar Power = 100\nvar speed int\nY lo mismo en el main:
\nfunc main() {\n\tpower := rangerModel.Power\n\tfmt.Println(\"Power ranger red power:\", power)\n}\nAhora si imprimimos:
\n
\nEs bastante sencillo como veis, comentar que no es recomendable hacer variables públicas(o exportar variables según el lenguaje de Go), por eso nos da esta recomendación al ponerlo en mayúsculas:
\n
Por el momento dejamos aquí las variables básicas, más adelante seguiremos trabajando con ellas.
\nNos vemos en el siguiente
En Go tenemos dos tipos de arrays o arreglos:
\nLos que llaman arrays, son arreglos con una cantidad definida de elementos,es decir, tienen un tamaño fijo y no pueden crecer.
\nLos llamados slices, que son los arreglos o arrays más comunes, en los cuales podemos añadir los elementos que queramos.
\nY porque tenemos dos tipos? Pues básicamente es por el consumo de recursos, los arrays definidos, solo se reservan los recursos que necesitan, los slices o llamemoslos arrays dinámicos tienen siempre reservado una cantidad mayor de recursos para poder crecer. Más abajo veremos como saber esta cantidad.
\nLa forma de declararlos es bastante sencilla:
\n//supongamos que son 3\nvar rangers [3]string\nrangers[0] = "Ranger Rojo"\nrangers[1] = "Ranger Negro"\nrangers[2] = "Ranger Amarillo"\n\n//El uso es como todos los arrays\nfmt.Println(rangers)\nfmt.Println(rangers[0])\nfmt.Println(rangers[1])\nfmt.Println(rangers[2])\nSi ejecutamos esto:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen0814.png\")
Hasta aqui todo parece normal, vamos a intentar añadir alguno mas:
\nrangers[3] = "Ranger Verde"\nVemos como el propio visual studio nos avisa:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen0831.png\")
\nLa única forma que tendriamos de ampliar ese array, o más bien de trabajar con los datos que contiene, es hacer una copia del array en otro con más cantidad de elementos posibles(o que fuera un slice).
Más abajo veremos como hacer eso, ya que es común para ambos tipos de array.
\nContinuemos con los slices, que serán posiblemente el tipo más usado, sobretodo al principio.
\nTenemos varias formas de crear slices, cada una tiene sus peculiaridades.
\nLa primera:
var rangers []string\n\nrangers[0] = "Ranger Rosa"\nfmt.Println(rangers)\nEn un principio todo parece normal, el compilador no se queja tampoco, cool, pero vamos a ejecutarlo:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.45.05.png\")
\nComo veis tenemos un bonito Panic (para el que no se lo imagine es como muestra los errores) pero ¿porque?
Go al inicializar los slices si lo hacemos de esa forma los inicializa por defecto "vacios" pero no entendamos vacios como cualquier otro elemento que podemos asignarle un valor directamente, si no lo inicializa con "ausencia de todo" incluso de tamaño.
\nPero esto no significa que no podamos usarlo, Go tiene un método append que nos permite añadir los elementos que necesitemos:
rangers = append(rangers, "Ranger Rosa", "Ranger Rojo")\n\nfmt.Println(rangers)\nPodriamos añadir todos los que queramos, y como vemos funciona perfectamente:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.57.07.png\")
Antes de continuar con la siguiente forma de inicializar slices vamos a hablar de "Tamaño" y "Capacidad"
\n¿¿??
\nSi jejejeje, con los slices en aplicaciones complejas tendremos que tener en cuenta estas dos cosas, pensando en la optimización por supuesto.
\nTamaño: Básicamente es el tamaño que tiene ocupado el slice, lo que en otros lenguajes consultaríamos con un array.length
\nCapacidad: Es la cantidad de recursos reservada para ese slice.
\nEs decir si pensamos en los slices como cajas, tenemos que un slice con una capacidad de 5 son 5 cajas, de las cuales 2 estan cerradas con algo dentro(tamaño 2) y otras 3 estan abiertas a la espera de tener algo dentro, pero estan ocupando su espacio en el suelo ya.
\nAhora veamos la segunda forma de crear un slice:
\nrangers := make([]string,10)\n//Aqui tendriamos un slice con 10 de tamaño y 10 de capacidad\n\nrangers := make([]string,5,10)\n//Y aqui tendriamos un slice con 5 de tamaño y 10 de capacidad\nVeamos un ejemplo de código para ilustrar un poco mejor esto:
\nvar rangers []string\nfmt.Println("Sin inicializar, es decir tamaño 0")\nfmt.Println(rangers)\n\nrangers = append(rangers, "Ranger Rosa", "Ranger Rojo")\n\nfmt.Println("Append al no inicializado")\nfmt.Println(rangers)\n\nrangers2 := make([]string, 10)\n\nfmt.Println("Usando make para asignar tamaño y capacidad iguales")\nfmt.Println(rangers2)\n\nrangers3 := make([]string, 5, 10)\n\nfmt.Println("Usando make para asignar tamaño y capacidad distintos")\nfmt.Println(rangers3)\nSi ejecutamos este código tendriamos un resultado como este:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.30.55.png\")
\nSi os fijais tenemos bastantes diferencias en cuanto a la inicialización por defecto de cada uno de los slices, el primero realmente tendria un valor similar a null, en el segundo hemos inicializado ese null con dos elementos, en el tercero se ha aplicado la inicialización por defecto de go de strings(es decir "") sobre 10 elementos, en el ultimo esa misma inicialización sobre 5.
Ahora ya podemos usar lo que llamariamos asignación directa:
\nrangers2[2] = "Ranger Verde"\nrangers3[3] = "Ranger Negro"\n\nfmt.Println(rangers2)\nfmt.Println(rangers3)\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen20.56.57.png\")
Bien hemos comprobado que podemos añadir ahora por lo menos dentro del "tamaño inicializado", si nos fijamos cada elemento tiene una posición definida dentro del slice. Veamos ahora lo que pasa si intentamos añadir en una ubicación por encima del tamaño(ojo no de la capacidad). Lo vamos a intentar on ranger3 que tiene una capacidad de 10 y un tamaño de 5:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.00.34.png\")
Vemos como nos vuelve a dar el error de que nos hemos salido del rango permitido. Para añadir por encima de esto tenemos que usar el mismo método que antes con append
\nrangers3 = append(rangers3, "Ranger Rosa", "Ranger Rojo")\nfmt.Println(rangers3)\nSi ahora ejecutamos veremos como despues del espacio que teniamos antes ha añadido los dos rangers nuevos.
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.06.25.png\")
\nOJO a lo de los espacios vamos a ver una ultima forma de inicializar Arrays y Slices y volveremos a este ejemplo para ver cosas sobre la capacidad y el tamaño.
Como última forma vamos a ver la inicialización directa de ambos casos:
\n//Array definido\nrangers2 := [2]string{"Ranger Verde", "Ranger Blanco"}\n//Slice\nrangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\t\nfmt.Println(rangers2)\t\nfmt.Println(rangers3)\nComo tal no notamos ninguna diferencia a la hora de mostrarlos:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.17.55.png\")
Atención si hacemos esto:
\nrangers2 := [3]string{"Ranger Verde", "Ranger Blanco"}\nNos añade,en este caso un string(podria ser cualquier tipo que hubieramos indicado) vacio en el elemento faltante.
\nBien ahora vamos a probar a añadir:
\nrangers2 := [2]string{"Ranger Verde", "Ranger Blanco"}\nrangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nrangers2 = append(rangers2, "Ranger Negro")\nrangers3 = append(rangers3, "Ranger Blanco")\nSi vemos el array definido se queja:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.20.36.png\")
Como tal sigue restringiendo su ampliación, lo contrario que el slice.
\nAhora vamos a ver la diferencia real entre uno y otro.
Go tiene como casi todos los lenguajes una forma de comprobar la cantidad de elementos que tiene un array,normalmente suele tener que ver con length, pues Go no iba a ser menos tenemos nuestro len:
\nrangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nfmt.Println(len(rangers3))\nEsto nos devuelve un 2, cosa normal no?? Pero como tal antes hemos hablado de la capacidad también, en este caso Go tiene también una forma de ver la capacidad que tenemos reservada(básicamente es reserva en memoria)
\nrangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nfmt.Println("Tamaño",len(rangers3))\nfmt.Println("Capacidad",cap(rangers3))\nEsto nos devolveria:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.31.12.png\")
Hasta aqui todo normal no?? Todo tiene sentido verdad?? Vale ahora vamos a añadirle algo para aumentarlo, recordemos que con capacidad 2 no podemos usar asignación directa para los siguientes elementos como tal tenemos que usar append, vamos a usar append y veamos que nos devuelve ahora:
\nrangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nrangers3 = append(rangers3, "Ranger Blanco")\n\nfmt.Println("Tamaño", len(rangers3))\nfmt.Println("Capacidad", cap(rangers3))\nPara nuestra sorpresa al ejecutar vemos esto:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.34.02.png\")
\nUPS!!! y que ha pasaaaaaooooo!!!????, es simple Go lo que hace es duplicar la capacidad anterior, por lo que si no tenemos en cuenta y tratamos con slices muy grandes, por ejemplo imaginemos un array de 100 elementos, si añadimos 1 mas para hacer 101 tendriamos una capacidad de 200 siendo realmente inecesario.
\nVeamoslo con un ejemplo añadiendo al código anterior los 2 rangers restantes:
rangers3 := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nrangers3 = append(rangers3, "Ranger Blanco")\n\nfmt.Println("Tamaño", len(rangers3))\nfmt.Println("Capacidad", cap(rangers3))\n\nrangers3 = append(rangers3, "Ranger Rojo", "Ranger Negro")\n\nfmt.Println("Tamaño", len(rangers3))\nfmt.Println("Capacidad", cap(rangers3))\nVemos que tenemos de repente una capacidad de 8:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.39.27.png\")
Creo que con esto mas o menos queda clara la diferencia entre los arrays definidos y los slices, hablando de consumo de memoria y del propio uso de uno u otro, siempre sera recomendable tener arrays definidos, veremos más adelante alguna forma de pasar de uno a otro.
\nEn el próximo post veremos tambien como trabajar con ambos, para recorrerlos, por ejemplo, y varias cosas mas.
\n","url":"https://jlgarcia.fulldev.ninja/go-go-power-ra-ah-que-no-go-parte-3-arrays-y-slices-i/","canonical_url":null,"uuid":"35e1d966-d22e-4a90-8c8c-8c46b92de7e1","codeinjection_foot":null,"codeinjection_head":null,"codeinjection_styles":null,"comment_id":"24","reading_time":7,"send_email_when_published":false,"email_subject":null,"childHtmlRehype":{"html":"En Go tenemos dos tipos de arrays o arreglos:
\nLos que llaman arrays, son arreglos con una cantidad definida de elementos,es decir, tienen un tamaño fijo y no pueden crecer.
\nLos llamados slices, que son los arreglos o arrays más comunes, en los cuales podemos añadir los elementos que queramos.
\nY porque tenemos dos tipos? Pues básicamente es por el consumo de recursos, los arrays definidos, solo se reservan los recursos que necesitan, los slices o llamemoslos arrays dinámicos tienen siempre reservado una cantidad mayor de recursos para poder crecer. Más abajo veremos como saber esta cantidad.
\nLa forma de declararlos es bastante sencilla:
\n//supongamos que son 3\nvar rangers [3]string\nrangers[0] = \"Ranger Rojo\"\nrangers[1] = \"Ranger Negro\"\nrangers[2] = \"Ranger Amarillo\"\n\n//El uso es como todos los arrays\nfmt.Println(rangers)\nfmt.Println(rangers[0])\nfmt.Println(rangers[1])\nfmt.Println(rangers[2])\nSi ejecutamos esto:
\n
Hasta aqui todo parece normal, vamos a intentar añadir alguno mas:
\nrangers[3] = \"Ranger Verde\"\nVemos como el propio visual studio nos avisa:
\n
\nLa única forma que tendriamos de ampliar ese array, o más bien de trabajar con los datos que contiene, es hacer una copia del array en otro con más cantidad de elementos posibles(o que fuera un slice).
Más abajo veremos como hacer eso, ya que es común para ambos tipos de array.
\nContinuemos con los slices, que serán posiblemente el tipo más usado, sobretodo al principio.
\nTenemos varias formas de crear slices, cada una tiene sus peculiaridades.
\nLa primera:
var rangers []string\n\nrangers[0] = \"Ranger Rosa\"\nfmt.Println(rangers)\nEn un principio todo parece normal, el compilador no se queja tampoco, cool, pero vamos a ejecutarlo:
\n
\nComo veis tenemos un bonito Panic (para el que no se lo imagine es como muestra los errores) pero ¿porque?
Go al inicializar los slices si lo hacemos de esa forma los inicializa por defecto \"vacios\" pero no entendamos vacios como cualquier otro elemento que podemos asignarle un valor directamente, si no lo inicializa con \"ausencia de todo\" incluso de tamaño.
\nPero esto no significa que no podamos usarlo, Go tiene un método append que nos permite añadir los elementos que necesitemos:
rangers = append(rangers, \"Ranger Rosa\", \"Ranger Rojo\")\n\nfmt.Println(rangers)\nPodriamos añadir todos los que queramos, y como vemos funciona perfectamente:
\n
Antes de continuar con la siguiente forma de inicializar slices vamos a hablar de \"Tamaño\" y \"Capacidad\"
\n¿¿??
\nSi jejejeje, con los slices en aplicaciones complejas tendremos que tener en cuenta estas dos cosas, pensando en la optimización por supuesto.
\nTamaño: Básicamente es el tamaño que tiene ocupado el slice, lo que en otros lenguajes consultaríamos con un array.length
\nCapacidad: Es la cantidad de recursos reservada para ese slice.
\nEs decir si pensamos en los slices como cajas, tenemos que un slice con una capacidad de 5 son 5 cajas, de las cuales 2 estan cerradas con algo dentro(tamaño 2) y otras 3 estan abiertas a la espera de tener algo dentro, pero estan ocupando su espacio en el suelo ya.
\nAhora veamos la segunda forma de crear un slice:
\nrangers := make([]string,10)\n//Aqui tendriamos un slice con 10 de tamaño y 10 de capacidad\n\nrangers := make([]string,5,10)\n//Y aqui tendriamos un slice con 5 de tamaño y 10 de capacidad\nVeamos un ejemplo de código para ilustrar un poco mejor esto:
\nvar rangers []string\nfmt.Println(\"Sin inicializar, es decir tamaño 0\")\nfmt.Println(rangers)\n\nrangers = append(rangers, \"Ranger Rosa\", \"Ranger Rojo\")\n\nfmt.Println(\"Append al no inicializado\")\nfmt.Println(rangers)\n\nrangers2 := make([]string, 10)\n\nfmt.Println(\"Usando make para asignar tamaño y capacidad iguales\")\nfmt.Println(rangers2)\n\nrangers3 := make([]string, 5, 10)\n\nfmt.Println(\"Usando make para asignar tamaño y capacidad distintos\")\nfmt.Println(rangers3)\nSi ejecutamos este código tendriamos un resultado como este:
\n
\nSi os fijais tenemos bastantes diferencias en cuanto a la inicialización por defecto de cada uno de los slices, el primero realmente tendria un valor similar a null, en el segundo hemos inicializado ese null con dos elementos, en el tercero se ha aplicado la inicialización por defecto de go de strings(es decir \"\") sobre 10 elementos, en el ultimo esa misma inicialización sobre 5.
Ahora ya podemos usar lo que llamariamos asignación directa:
\nrangers2[2] = \"Ranger Verde\"\nrangers3[3] = \"Ranger Negro\"\n\nfmt.Println(rangers2)\nfmt.Println(rangers3)\n
Bien hemos comprobado que podemos añadir ahora por lo menos dentro del \"tamaño inicializado\", si nos fijamos cada elemento tiene una posición definida dentro del slice. Veamos ahora lo que pasa si intentamos añadir en una ubicación por encima del tamaño(ojo no de la capacidad). Lo vamos a intentar on ranger3 que tiene una capacidad de 10 y un tamaño de 5:
\n
Vemos como nos vuelve a dar el error de que nos hemos salido del rango permitido. Para añadir por encima de esto tenemos que usar el mismo método que antes con append
\nrangers3 = append(rangers3, \"Ranger Rosa\", \"Ranger Rojo\")\nfmt.Println(rangers3)\nSi ahora ejecutamos veremos como despues del espacio que teniamos antes ha añadido los dos rangers nuevos.
\n
\nOJO a lo de los espacios vamos a ver una ultima forma de inicializar Arrays y Slices y volveremos a este ejemplo para ver cosas sobre la capacidad y el tamaño.
Como última forma vamos a ver la inicialización directa de ambos casos:
\n//Array definido\nrangers2 := [2]string{\"Ranger Verde\", \"Ranger Blanco\"}\n//Slice\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\t\nfmt.Println(rangers2)\t\nfmt.Println(rangers3)\nComo tal no notamos ninguna diferencia a la hora de mostrarlos:
\n
Atención si hacemos esto:
\nrangers2 := [3]string{\"Ranger Verde\", \"Ranger Blanco\"}\nNos añade,en este caso un string(podria ser cualquier tipo que hubieramos indicado) vacio en el elemento faltante.
\nBien ahora vamos a probar a añadir:
\nrangers2 := [2]string{\"Ranger Verde\", \"Ranger Blanco\"}\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers2 = append(rangers2, \"Ranger Negro\")\nrangers3 = append(rangers3, \"Ranger Blanco\")\nSi vemos el array definido se queja:
\n
Como tal sigue restringiendo su ampliación, lo contrario que el slice.
\nAhora vamos a ver la diferencia real entre uno y otro.
Go tiene como casi todos los lenguajes una forma de comprobar la cantidad de elementos que tiene un array,normalmente suele tener que ver con length, pues Go no iba a ser menos tenemos nuestro len:
\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfmt.Println(len(rangers3))\nEsto nos devuelve un 2, cosa normal no?? Pero como tal antes hemos hablado de la capacidad también, en este caso Go tiene también una forma de ver la capacidad que tenemos reservada(básicamente es reserva en memoria)
\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfmt.Println(\"Tamaño\",len(rangers3))\nfmt.Println(\"Capacidad\",cap(rangers3))\nEsto nos devolveria:
\n
Hasta aqui todo normal no?? Todo tiene sentido verdad?? Vale ahora vamos a añadirle algo para aumentarlo, recordemos que con capacidad 2 no podemos usar asignación directa para los siguientes elementos como tal tenemos que usar append, vamos a usar append y veamos que nos devuelve ahora:
\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers3 = append(rangers3, \"Ranger Blanco\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\nPara nuestra sorpresa al ejecutar vemos esto:
\n
\nUPS!!! y que ha pasaaaaaooooo!!!????, es simple Go lo que hace es duplicar la capacidad anterior, por lo que si no tenemos en cuenta y tratamos con slices muy grandes, por ejemplo imaginemos un array de 100 elementos, si añadimos 1 mas para hacer 101 tendriamos una capacidad de 200 siendo realmente inecesario.
\nVeamoslo con un ejemplo añadiendo al código anterior los 2 rangers restantes:
rangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers3 = append(rangers3, \"Ranger Blanco\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\n\nrangers3 = append(rangers3, \"Ranger Rojo\", \"Ranger Negro\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\nVemos que tenemos de repente una capacidad de 8:
\n
Creo que con esto mas o menos queda clara la diferencia entre los arrays definidos y los slices, hablando de consumo de memoria y del propio uso de uno u otro, siempre sera recomendable tener arrays definidos, veremos más adelante alguna forma de pasar de uno a otro.
\nEn el próximo post veremos tambien como trabajar con ambos, para recorrerlos, por ejemplo, y varias cosas mas.
\n","htmlAst":{"type":"root","children":[{"type":"comment","value":"kg-card-begin: markdown"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En Go tenemos dos tipos de "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arrays"}]},{"type":"text","value":" o "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arreglos"}]},{"type":"text","value":":"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"ul","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"li","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Los que llaman "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arrays"}]},{"type":"text","value":", son arreglos con una cantidad definida de elementos,es decir, tienen un tamaño fijo y no pueden crecer."}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"li","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Los llamados "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":", que son los arreglos o arrays más comunes, en los cuales podemos añadir los elementos que queramos."}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Y porque tenemos dos tipos? Pues básicamente es por el consumo de recursos, los "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arrays definidos"}]},{"type":"text","value":", solo se reservan los recursos que necesitan, los "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":" o llamemoslos "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arrays dinámicos"}]},{"type":"text","value":" tienen siempre reservado una cantidad mayor de recursos para poder crecer. Más abajo veremos como saber esta cantidad."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"arraysdefinidos"},"children":[{"type":"text","value":"Arrays definidos"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"La forma de declararlos es bastante sencilla:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"//supongamos que son 3\nvar rangers [3]string\nrangers[0] = \"Ranger Rojo\"\nrangers[1] = \"Ranger Negro\"\nrangers[2] = \"Ranger Amarillo\"\n\n//El uso es como todos los arrays\nfmt.Println(rangers)\nfmt.Println(rangers[0])\nfmt.Println(rangers[1])\nfmt.Println(rangers[2])\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Si ejecutamos esto:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen0814.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Hasta aqui todo parece normal, vamos a intentar añadir alguno mas:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers[3] = \"Ranger Verde\"\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Vemos como el propio visual studio nos avisa:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen0831.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nLa única forma que tendriamos de ampliar ese array, o más bien de trabajar con los datos que contiene, es hacer una copia del array en otro con más cantidad de elementos posibles(o que fuera un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":")."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Más abajo veremos como hacer eso, ya que es común para ambos tipos de array."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"slices"},"children":[{"type":"text","value":"SLICES"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Continuemos con los "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":", que serán posiblemente el tipo más usado, sobretodo al principio."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nTenemos varias formas de crear "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":", cada una tiene sus peculiaridades."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nLa primera:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"var rangers []string\n\nrangers[0] = \"Ranger Rosa\"\nfmt.Println(rangers)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En un principio todo parece normal, el compilador no se queja tampoco, "},{"type":"element","tagName":"em","properties":{},"children":[{"type":"text","value":"cool"}]},{"type":"text","value":", pero vamos a ejecutarlo:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.45.05.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nComo veis tenemos un bonito "},{"type":"element","tagName":"span","properties":{"style":"color:red"},"children":[{"type":"text","value":"Panic"}]},{"type":"text","value":" (para el que no se lo imagine es como muestra los errores) pero ¿porque?"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Go al inicializar los "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":" si lo hacemos de esa forma los inicializa por defecto "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"\"vacios\""}]},{"type":"text","value":" pero no entendamos vacios como cualquier otro elemento que podemos asignarle un valor directamente, si no lo inicializa con "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"\"ausencia de todo\""}]},{"type":"text","value":" incluso de tamaño."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nPero esto no significa que no podamos usarlo, Go tiene un método "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"append"}]},{"type":"text","value":" que nos permite añadir los elementos que necesitemos:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers = append(rangers, \"Ranger Rosa\", \"Ranger Rojo\")\n\nfmt.Println(rangers)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Podriamos añadir todos los que queramos, y como vemos funciona perfectamente:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.57.07.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Antes de continuar con la siguiente forma de inicializar "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":" vamos a hablar de "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"\"Tamaño\""}]},{"type":"text","value":" y "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"\"Capacidad\""}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"¿¿??"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Si jejejeje, con los slices en aplicaciones complejas tendremos que tener en cuenta estas dos cosas, pensando en la optimización por supuesto."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"ul","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"li","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Tamaño"}]},{"type":"text","value":": Básicamente es el tamaño que tiene ocupado el slice, lo que en otros lenguajes consultaríamos con un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"array.length"}]}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"li","properties":{},"children":[{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Capacidad"}]},{"type":"text","value":": Es la cantidad de recursos reservada para ese "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":"."}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Es decir si pensamos en los slices como cajas, tenemos que un slice con una capacidad de 5 son 5 cajas, de las cuales 2 estan cerradas con algo dentro(tamaño 2) y otras 3 estan abiertas a la espera de tener algo dentro, pero estan ocupando su espacio en el suelo ya."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Ahora veamos la segunda forma de crear un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":":"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers := make([]string,10)\n//Aqui tendriamos un slice con 10 de tamaño y 10 de capacidad\n\nrangers := make([]string,5,10)\n//Y aqui tendriamos un slice con 5 de tamaño y 10 de capacidad\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Veamos un ejemplo de código para ilustrar un poco mejor esto:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"var rangers []string\nfmt.Println(\"Sin inicializar, es decir tamaño 0\")\nfmt.Println(rangers)\n\nrangers = append(rangers, \"Ranger Rosa\", \"Ranger Rojo\")\n\nfmt.Println(\"Append al no inicializado\")\nfmt.Println(rangers)\n\nrangers2 := make([]string, 10)\n\nfmt.Println(\"Usando make para asignar tamaño y capacidad iguales\")\nfmt.Println(rangers2)\n\nrangers3 := make([]string, 5, 10)\n\nfmt.Println(\"Usando make para asignar tamaño y capacidad distintos\")\nfmt.Println(rangers3)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Si ejecutamos este código tendriamos un resultado como este:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.30.55.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nSi os fijais tenemos bastantes diferencias en cuanto a la inicialización por defecto de cada uno de los slices, el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"primero"}]},{"type":"text","value":" realmente tendria un valor similar a "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"null"}]},{"type":"text","value":", en el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"segundo"}]},{"type":"text","value":" hemos inicializado ese null con dos elementos, en el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"tercero"}]},{"type":"text","value":" se ha aplicado la inicialización por defecto de go de strings(es decir \"\") sobre 10 elementos, en el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"ultimo"}]},{"type":"text","value":" esa misma inicialización sobre 5."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Ahora ya podemos usar lo que llamariamos asignación directa:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers2[2] = \"Ranger Verde\"\nrangers3[3] = \"Ranger Negro\"\n\nfmt.Println(rangers2)\nfmt.Println(rangers3)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen20.56.57.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Bien hemos comprobado que podemos añadir ahora por lo menos dentro del \"tamaño inicializado\", si nos fijamos cada elemento tiene una posición definida dentro del slice. Veamos ahora lo que pasa si intentamos añadir en una ubicación por encima del "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"tamaño"}]},{"type":"text","value":"(ojo no de la capacidad). Lo vamos a intentar on "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"ranger3"}]},{"type":"text","value":" que tiene una capacidad de 10 y un tamaño de 5:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.00.34.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Vemos como nos vuelve a dar el error de que nos hemos salido del rango permitido. Para añadir por encima de esto tenemos que usar el mismo método que antes con "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"append"}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers3 = append(rangers3, \"Ranger Rosa\", \"Ranger Rojo\")\nfmt.Println(rangers3)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Si ahora ejecutamos veremos como despues del espacio que teniamos antes ha añadido los dos rangers nuevos."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.06.25.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"OJO a lo de los espacios"}]},{"type":"text","value":" vamos a ver una ultima forma de inicializar "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Arrays"}]},{"type":"text","value":" y "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Slices"}]},{"type":"text","value":" y volveremos a este ejemplo para ver cosas sobre la "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"capacidad"}]},{"type":"text","value":" y el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"tamaño"}]},{"type":"text","value":"."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como última forma vamos a ver la inicialización directa de ambos casos:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"//Array definido\nrangers2 := [2]string{\"Ranger Verde\", \"Ranger Blanco\"}\n//Slice\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\t\nfmt.Println(rangers2)\t\nfmt.Println(rangers3)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como tal no notamos ninguna diferencia a la hora de mostrarlos:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.17.55.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Atención"}]},{"type":"text","value":" si hacemos esto:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers2 := [3]string{\"Ranger Verde\", \"Ranger Blanco\"}\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Nos añade,en este caso un string(podria ser cualquier tipo que hubieramos indicado) vacio en el elemento faltante."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Bien ahora vamos a probar a añadir:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers2 := [2]string{\"Ranger Verde\", \"Ranger Blanco\"}\nrangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers2 = append(rangers2, \"Ranger Negro\")\nrangers3 = append(rangers3, \"Ranger Blanco\")\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Si vemos el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"array definido"}]},{"type":"text","value":" se queja:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.20.36.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como tal sigue restringiendo su ampliación, lo contrario que el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":"."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nAhora vamos a ver la diferencia real entre uno y otro."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"lenycap"},"children":[{"type":"text","value":"Len y Cap"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Go tiene como casi todos los lenguajes una forma de comprobar la cantidad de elementos que tiene un array,normalmente suele tener que ver con "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"length"}]},{"type":"text","value":", pues Go no iba a ser menos tenemos nuestro len:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfmt.Println(len(rangers3))\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Esto nos devuelve un 2, cosa normal no?? Pero como tal antes hemos hablado de la "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"capacidad"}]},{"type":"text","value":" también, en este caso Go tiene también una forma de ver la capacidad que tenemos reservada(básicamente es reserva en memoria)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfmt.Println(\"Tamaño\",len(rangers3))\nfmt.Println(\"Capacidad\",cap(rangers3))\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Esto nos devolveria:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.31.12.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Hasta aqui todo normal no?? Todo tiene sentido verdad?? Vale ahora vamos a añadirle algo para aumentarlo, recordemos que con "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"capacidad 2"}]},{"type":"text","value":" no podemos usar asignación directa para los siguientes elementos como tal tenemos que usar "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"append"}]},{"type":"text","value":", vamos a usar "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"append"}]},{"type":"text","value":" y veamos que nos devuelve ahora:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers3 = append(rangers3, \"Ranger Blanco\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Para nuestra sorpresa al ejecutar vemos esto:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.34.02.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"UPS!!!"}]},{"type":"text","value":" "},{"type":"element","tagName":"em","properties":{},"children":[{"type":"text","value":"y que ha pasaaaaaooooo!!!????"}]},{"type":"text","value":", es simple Go lo que hace es duplicar la capacidad anterior, por lo que si no tenemos en cuenta y tratamos con slices muy grandes, por ejemplo imaginemos un array de 100 elementos, si añadimos 1 mas para hacer 101 tendriamos una capacidad de 200 siendo realmente inecesario."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nVeamoslo con un ejemplo añadiendo al código anterior los 2 rangers restantes:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers3 := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nrangers3 = append(rangers3, \"Ranger Blanco\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\n\nrangers3 = append(rangers3, \"Ranger Rojo\", \"Ranger Negro\")\n\nfmt.Println(\"Tamaño\", len(rangers3))\nfmt.Println(\"Capacidad\", cap(rangers3))\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Vemos que tenemos de repente una capacidad de 8:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen21.39.27.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Creo que con esto mas o menos queda clara la diferencia entre los arrays definidos y los slices, hablando de consumo de memoria y del propio uso de uno u otro, siempre sera recomendable tener arrays definidos, veremos más adelante alguna forma de pasar de uno a otro."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En el próximo post veremos tambien como trabajar con ambos, para recorrerlos, por ejemplo, y varias cosas mas."}]},{"type":"text","value":"\n"},{"type":"comment","value":"kg-card-end: markdown"}],"data":{"quirksMode":false}},"tableOfContents":[{"id":"arraysdefinidos","heading":"Arrays definidos"},{"id":"slices","heading":"SLICES"},{"id":"lenycap","heading":"Len y Cap"}]},"featureImageSharp":{"base":"Untitled-2.png","publicURL":"/static/4c2a69b59a578389653f7d3cb966f439/Untitled-2.png","imageMeta":{"width":649,"height":244},"childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAICAYAAAD5nd/tAAAACXBIWXMAAAsTAAALEwEAmpwYAAABr0lEQVQoz22RPWhTURiGP+29N/eec3/aK1FjI9RBm3aSSBVBDVSzOGpwiMEhKopmsCnYyUVQwS5WxKU6iGBwdOrQqZOD+EO1HYo/mCBtySSC6+O5CQVjHF7ecw7veb6Xc0RrTa8USnV9S57ZZ2LF3rTqeBwqhiIf3++X9AO3YN11AlfGx7KKyTGX4nhXx/YJg9pGZBuOYxs5WJbVC1QdQBfm6oAwCnl+wWFixDMXPbZbGjulicx58dQko6MHKBQK5HK5jvL5/D8NDcz3NQOO4khGaJSElxXh4knFiaMZTh/22b/HwbYdpms1zpVKTNXrlMtlKpUK1Wq1v2ECVdrHPVPi+N0pns2eZ/7FNFdeP+FVY4a5xzfZcf8BA9fr7B4eZjCKSKfTZLNZ4jj+D9B1CXbuQu495OzaBt/ffWJh5RvF5m9azTbrq2tMfN1E5uZRQYhn8q7nkUql8Iz3ApN2QUAggly6xsjndRY32zz68J6Dtcs8ffuG280NrC9trOpVfJPTYdjzoX1vmEzVJmjfmEFaP5HlJoeWllhuzFJYXEA+tpAfv7Bu3enkkrz6i/EHdxf7UmCHE+cAAAAASUVORK5CYII=","aspectRatio":2.6515151515151514,"src":"/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-2.png","srcSet":"/static/4c2a69b59a578389653f7d3cb966f439/847ef/Untitled-2.png 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/91cba/Untitled-2.png 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-2.png 649w","srcWebp":"/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-2.webp","srcSetWebp":"/static/4c2a69b59a578389653f7d3cb966f439/9fca7/Untitled-2.webp 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/37a4e/Untitled-2.webp 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-2.webp 649w","sizes":"(max-width: 649px) 100vw, 649px"}}}},"next":{"id":"Ghost__Post__5a338158333e0f134c248f06","title":"Go Go Power Ra....ah que no: Go Parte1 - Intro y preparacion","slug":"go-go-power-ra-ah-que-no-go-parte1-intro-y-preparacion","featured":false,"feature_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Untitled.png","excerpt":"Empiezo con una nueva sección, mi aventura con el lenguaje GO, el cual he\ndescubierto que me encanta, es un lenguaje muy bueno y sencillo para tratar con\ntemas de concurrencia y realmente hace un montón de cosas por si solo(como su\npaquete net que hace la vida mas fácil en cuanto a servidor Web se refiere), lo\nvamos a ir viendo poco a poco. Sin mucho más empecemos\n\nInstalación\nEl lenguaje lo podemos escribir desde cualquier editor de texto pero es\nnecesario instalar el compilador y realizar algu","custom_excerpt":null,"visibility":"public","created_at_pretty":"1 May 2017","published_at_pretty":"3 Jun 2017","updated_at_pretty":"11 Oct 2017","created_at":"2017-05-01T12:36:05.000+02:00","published_at":"2017-06-03T11:45:14.000+02:00","updated_at":"2017-10-11T13:44:00.000+02:00","meta_title":null,"meta_description":null,"og_description":null,"og_image":null,"og_title":null,"twitter_description":null,"twitter_image":null,"twitter_title":null,"authors":[{"slug":"jlgarcia","url":"https://jlgarcia.fulldev.ninja/author/jlgarcia/","name":"Juan Luis Garcia Aparicio","bio":null,"cover_image":null,"profile_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/12/Perfil.jpg","location":null,"website":null,"twitter":null,"facebook":null,"meta_title":null,"meta_description":null,"coverImageSharp":null,"profileImageSharp":null}],"primary_author":{"slug":"jlgarcia","url":"https://jlgarcia.fulldev.ninja/author/jlgarcia/","name":"Juan Luis Garcia Aparicio","bio":null,"cover_image":null,"profile_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/12/Perfil.jpg","location":null,"website":null,"twitter":null,"facebook":null,"meta_title":null,"meta_description":null,"coverImageSharp":null,"profileImageSharp":{"base":"Perfil.jpg","publicURL":"/static/b0de6281fb28a266510b3b09b9243e5a/Perfil.jpg","imageMeta":{"width":307,"height":307},"childImageSharp":{"fluid":{"base64":"data:image/jpeg;base64,/9j/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wgARCAAUABQDASIAAhEBAxEB/8QAGAABAQEBAQAAAAAAAAAAAAAAAAUDBAb/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAGzw6zC6zHn+cLYP//EAB0QAAICAQUAAAAAAAAAAAAAAAEDAAIEEyEiIzL/2gAIAQEAAQUCifca8KgcKWVfUpkHsG5pxX//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAEDAQE/AR//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAECAQE/AR//xAAdEAACAgEFAAAAAAAAAAAAAAAAARARcQISIUFR/9oACAEBAAY/AhU88xkb7N06a8P/xAAcEAEAAwEAAwEAAAAAAAAAAAABABEhMUFRYXH/2gAIAQEAAT8hR2pq40aqb+xIAeXibhW9JXr8joF4TBcSNe0//9oADAMBAAIAAwAAABDzDwD/xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAEDAQE/EB//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAECAQE/EB//xAAcEAEAAgIDAQAAAAAAAAAAAAABABEhUTFhcfD/2gAIAQEAAT8QyItrELaTlatLwU63MvEW6vUNdy4LZQDn7iVApV9VLtANdWwKkuYq4Er1VZ//2Q==","aspectRatio":1,"src":"/static/b0de6281fb28a266510b3b09b9243e5a/31709/Perfil.jpg","srcSet":"/static/b0de6281fb28a266510b3b09b9243e5a/f340b/Perfil.jpg 28w,\n/static/b0de6281fb28a266510b3b09b9243e5a/22d64/Perfil.jpg 55w,\n/static/b0de6281fb28a266510b3b09b9243e5a/31709/Perfil.jpg 110w,\n/static/b0de6281fb28a266510b3b09b9243e5a/aa249/Perfil.jpg 165w,\n/static/b0de6281fb28a266510b3b09b9243e5a/0dc33/Perfil.jpg 220w,\n/static/b0de6281fb28a266510b3b09b9243e5a/60667/Perfil.jpg 307w","srcWebp":"/static/b0de6281fb28a266510b3b09b9243e5a/8678c/Perfil.webp","srcSetWebp":"/static/b0de6281fb28a266510b3b09b9243e5a/59cda/Perfil.webp 28w,\n/static/b0de6281fb28a266510b3b09b9243e5a/7da75/Perfil.webp 55w,\n/static/b0de6281fb28a266510b3b09b9243e5a/8678c/Perfil.webp 110w,\n/static/b0de6281fb28a266510b3b09b9243e5a/f282e/Perfil.webp 165w,\n/static/b0de6281fb28a266510b3b09b9243e5a/a7b21/Perfil.webp 220w,\n/static/b0de6281fb28a266510b3b09b9243e5a/f59af/Perfil.webp 307w","sizes":"(max-width: 110px) 100vw, 110px"}}}},"primary_tag":{"slug":"go","url":"https://jlgarcia.fulldev.ninja/tag/go/","name":"Go","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null},"tags":[{"slug":"go","url":"https://jlgarcia.fulldev.ninja/tag/go/","name":"Go","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null},{"slug":"golang","url":"https://jlgarcia.fulldev.ninja/tag/golang/","name":"Golang","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null}],"plaintext":"Empiezo con una nueva sección, mi aventura con el lenguaje GO, el cual he\ndescubierto que me encanta, es un lenguaje muy bueno y sencillo para tratar con\ntemas de concurrencia y realmente hace un montón de cosas por si solo(como su\npaquete net que hace la vida mas fácil en cuanto a servidor Web se refiere), lo\nvamos a ir viendo poco a poco. Sin mucho más empecemos\n\nInstalación\nEl lenguaje lo podemos escribir desde cualquier editor de texto pero es\nnecesario instalar el compilador y realizar algunas configuraciones. Desde la\npropia página Go Download [https://golang.org/dl/] están los paquetes, y las\ninstrucciones. También es posible instalarlo con Homebrew (si lo usamos).\n\nbrew install golang\n\n\nPara la correcta instalación tenemos que tener en cuenta que es necesario\nconfigurar ciertas variables de entorno, teneis toda la información en:\nInstalación GO [https://golang.org/doc/install]\n\nHaceros a la idea de que la documentación de Go es bastante completa por lo que\nen general encontraremos todo lo que necesitemos aquí:\nDocumentación GO [https://golang.org/doc/]\n\nSolo como aclaración tener en cuenta lo que comenta la documentación sobre los\nvariables de entorno, si ejecutamos algún intalador (MAC/Windows) no deberíamos\ntener que hacer nada, si algo no funciona comprobar que existe en la variable de\nentorno $PATH la referencia a Go y que es correcta:\n\nWindows\nc:\\Go\\bin\nMac\necho $PATH <- nos devuelve lo que tenemos ahora mismo en el path\nEsto deberia devolvernos una cadena de texto muy larga que en algún punto deberia poner algo similar a esto\n/usr/local/go/bin\n\n\nSi lo hacemos en Linux o con cualquier source, lo mejor es extraer el contenido\nen las rutas recomendadas y configurar las variables de entorno como aparece en\nla documentación.\n\nSi tenéis algún problema buscar en internet que hay mucha información sobre\nesto, aun así si continuáis con problemas ponerlo en los comentarios e\nintentamos resolverlo.\n\nAntes de continuar un detalle de algunas carpetas del directorio de Go, por si\nquereis buscar algo:\n\nbin <- binarios, los que instalamos con go install\npackage o pkg <- Trabajar con los wrappers dentro de nuestro código. Encapsuladores de C.\nsrc <- Todo nuestro código fuente y la librerías de terceros. Las puede descargar go al realizar los imports en nuestras clases, o las podemos poner nosotros. Aqui es donde suele buscar el origen de los imports.\n\n\nAlgunos detalles sobre GO\nGo es un lenguaje compilado no interpretado, es decir, el código es compilado\n(transformado) a lenguaje máquina con lo que se genera un ejecutable que\nfuncionará sin necesidad de nada más para la arquitectura para la que fue\ncreado. Si hablamos de los errores, en este tipo de lenguajes deberíamos verlos\nen el proceso de compilación, pero veremos como con GO podemos probar nuestro\ncódigo sin necesidad de compilar.\n\nUn lenguaje interpretado es aquel en el que un tercero(normalmente llamado\nintérprete) lee nuestro código y lo traduce a código máquina, esto sucede cada\nvez que lo ejecutamos, y los errores los detectamos en este tiempo de ejecución.\n\nGo es un lenguaje que se usa mucho para scripting en backend ya que es bastante\nrápido en ejecutar, sus librerías básicas cubren mogollón de escenarios y como\nhe comentado el mismo script lo podriamos compilar para todos los S.O, aunque\nesto depende un poco de lo que haga jejejeje, no es tan mágico como suena.\nPersonalmente me encanta por la parte de concurrencia y la parte de Web Server,\nque si mezclamos ambas cosas podemos hacer cosas muy curiosas y que consuman\npocos recursos.\nComo ejemplo pongo un caso de uso de la empresa Malwarebytes\n[https://es.malwarebytes.com/] en el que gestionan 1 Millón que bajaron sus\nconsumos en un porcentaje muy alto usando GO link\n[http://marcio.io/2015/07/handling-1-million-requests-per-minute-with-golang/].\nNo se a vosotros pero a mi me parece muy interesante poder hacer cosas como esa.\n\nEs un lenguaje con tipado estático, esto quiere decir que desde el principio al\ndeclarar las variables tenemos que indicarle el tipo que son. Aunque es cierto\nque GO tiene una forma de declaración y asignación de variables, en la que el\nlenguaje hace lo que se conoce como \"inferencia de tipos\", o lo que es lo mismo,\nel propio lenguaje define el tipo de la variable según el valor asignado(veremos\nmas adelante ambas formas)\n\nPor último comentar que es un lenguaje que tiene características similares a C\n(como puede ser que usa punteros), compila directamente en ensamblador y un\nextra que es muy útil y que nos ahorra quebraderos de cabeza es que tiene \nrecolector de basura es decir, no tenemos que controlar el estado de las\nvariables o funciones para saber si se estan usando o no, ya lo hace Go por\nnosotros y aunque afecta un poco al rendimiento (realmente es muy poquito), es\nde agradecer a la hora de programar\n\nHola Mundo\nComo ya he escrito bastante rollo, vamos a trabajar un pelín con go.\nAntes de empezar primero comprobamos que tenemos bien instalado Go, para ello\ndesde cualquier linea de comandos (da igual Windows/Mac/Linux) escribimos:\n\ngo version\n\n\nY deberíamos ver algo como esto:\n\nSi lo vemos todo va bien, si a alguien no le aparece o tiene problemas que lo\nvaya poniendo en los comentarios y vemos como lo solucionamos.\n\nAhora abrimos un fichero de texto escribimos siguiente y guardamos como main.go:\n\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Hello Power Rangers\")\n}\n\n\nCon el fichero guardado, nos situamos en la ruta donde lo tengamos en nuestra\nlinea de comandos y ejecutamos:\n\ngo run main.go\n\n\nEsto nos deberia mostrar algo similar a esto en la consola:\n\nVoilá ya tenemos nuestro hola mundo. Ya iremos viendo lo que es cada cosa que\nhemos escrito, esto es solo para que escribamos un poco y veamos que funciona.\n\nIDEs\nLo último que vamos a ver en este post, serán los IDE, que yo no se vosotros,\npero a mi el modo Chuck Norris para programar (hacerlo directamente en un\nfichero de texto) no es lo que mas me convence, si tenemos posibilidades de que\nnos ayuden un pelín de alguna forma yo lo agradezco, pero como ya he comentado\nse puede hacer con cualquier editor de texto.\n\nPara programar con Go tenemos varias opciones:\n\n * Podemos hacerlo en un fichero de texto(Chuck Norris/Bruce Lee/Yoda mode) como\n ya he comentado\n * Otra opción es usar Sublime Text una gran mayoria de vosotros ya lo\n conocereis, y como siempre pues tenemos plugins que la comunidad ha creado \n Ejemplo [https://github.com/DisposaBoy/GoSublime] lo que le daria algunas\n vitaminas a nuestro editor para trabajar con Go.\n * Tambien es posible usar Atom. Sigue la misma teoría que Sublime, tenemos\n plugins que nos ayudan con Go Ejemplo [https://atom.io/packages/go-plus]\n * Los grandes de JetBrains [https://www.jetbrains.com/] están preparando un IDE\n muy completo (como siempre previo pago), y ahora tenemos disponibles algunos\n plugins para algunos de sus IDEs actuales.\n * Para hacer pruebas o si quereis para algunas cosas de las que vayamos viendo\n podemos usar el PLAYGROUND de Go SuperPlayground [https://play.golang.org/],\n super util para compartir código.\n * Como última opción y la que más gusta es Visual Studio Code, para mi es un\n acercamiento a las aplicaciones de JetBrains (que para mi son de lo mejor que\n hay). Como es la que uso veamos un poco su configuración.\n\nVisual Studio Code\nCon cualquier IDE y como programadores, nos pueden interesar mínimo 2 cosas para\nagilizar un poco nuestro trabajo:\n\n * Que nos indique errores cuanto antes\n * Y poder hacer debug de nuestro código para poder resolver mejor los problemas\n que nos vayamos encontrando.\n\nPues estas dos cosas y algún extra como las sugerencias son las que nos ofrece\neste IDE con algunas configuraciones.\n\nLo primero es instalar el plugin de Go desde la aplicación. Para ello tenemos\nque buscar la ventana de extensiones, creo que en todas ellas esta en el menu\nsuperior de la aplicación en la pestaña ver o view, seleccionamos extensiones o \nextensions\n\nY en la ventana que nos aparece buscamos Go\n\nY entre todas las extensiones que nos aparecen buscamos la de lukehoban y la\ninstalamos.\nUna vez que termine nos pedirá reiniciar la aplicación, y una vez que reinicie\nlo mejor es crear un fichero nuevo y ponerle extension .go.\n\nHacemos esta para que el propio visual studio nos complete la instalación, ya\nque cuando guardemos el fichero nos aparecerán algunos mensajes como este:\n\nBásicamente en todos los que nos pregunte tenemos que indicarle Install All\n\nTambién es posible que nos indique que configuremos el GOPATH para que os hagáis\nuna idea ese seria el Workspace desde donde trabajaremos, si os sale eso en \nDoc-GOPATH [https://golang.org/doc/code.html#GOPATH] o en Test Install GO\n[https://golang.org/doc/install?#testing] tenéis info para que identifiquéis\nbien lo que es y podáis configurarlo correctamente.\n\nLo segundo es configurar para poder hacer debug, lo más fácil es que miréis en\nla documentación del creador Derekparker-delve\n[https://github.com/derekparker/delve/tree/master/Documentation/installation],\naquí según vuestro sistema operativo tenéis las instrucciones. En general suele\nvaler con hacer\n\ngo get github.com/derekparker/delve/cmd/dlv\n\n\nAunque depende un poco de la versión de sistema, como he comentado lo mejor es\nque miréis la documentación.\nY una vez que lo tengáis instalado ya podremos ir poniendo lo que se conoce como\npuntos de interrupción para controlar lo que hace nuestro código.\n\nCon hacer click un par de veces al lado del número de linea es suficiente. Y\npara comprobar que funciona pulsamos sobre F5 o nos vamos al menú Depurar y\npulsamos Iniciar depuración\n\n\nY entonces nuestro IDE cambiará al modo debug que lo que nos hará será parar la\nejecución del código donde tengamos los puntos y podemos ver como están las\nvariables o lo que tengamos en el código.\n\n\nComo veis en la imagen variables a la izquierda, pila de llamadas un poco más\nabajo, puntos de interrupción.... todo muy útil sobretodo cuando tenemos\nproblemas con nuestro código.\n\nY con esto finalizo este post(por fiiiin!!! ) y ya en los siguientes empezaremos\ncon lo bueno.\nSi tenéis dudas o problemas ponerlo en los comentarios.\nCiaaaao","html":"Empiezo con una nueva sección, mi aventura con el lenguaje GO, el cual he descubierto que me encanta, es un lenguaje muy bueno y sencillo para tratar con temas de concurrencia y realmente hace un montón de cosas por si solo(como su paquete net que hace la vida mas fácil en cuanto a servidor Web se refiere), lo vamos a ir viendo poco a poco. Sin mucho más empecemos
\nEl lenguaje lo podemos escribir desde cualquier editor de texto pero es necesario instalar el compilador y realizar algunas configuraciones. Desde la propia página Go Download están los paquetes, y las instrucciones. También es posible instalarlo con Homebrew (si lo usamos).
\nbrew install golang\nPara la correcta instalación tenemos que tener en cuenta que es necesario configurar ciertas variables de entorno, teneis toda la información en:
\nInstalación GO
Haceros a la idea de que la documentación de Go es bastante completa por lo que en general encontraremos todo lo que necesitemos aquí:
\nDocumentación GO
Solo como aclaración tener en cuenta lo que comenta la documentación sobre los variables de entorno, si ejecutamos algún intalador (MAC/Windows) no deberíamos tener que hacer nada, si algo no funciona comprobar que existe en la variable de entorno $PATH la referencia a Go y que es correcta:
\nWindows\nc:\\Go\\bin\nMac\necho $PATH <- nos devuelve lo que tenemos ahora mismo en el path\nEsto deberia devolvernos una cadena de texto muy larga que en algún punto deberia poner algo similar a esto\n/usr/local/go/bin\nSi lo hacemos en Linux o con cualquier source, lo mejor es extraer el contenido en las rutas recomendadas y configurar las variables de entorno como aparece en la documentación.
\nSi tenéis algún problema buscar en internet que hay mucha información sobre esto, aun así si continuáis con problemas ponerlo en los comentarios e intentamos resolverlo.
\nAntes de continuar un detalle de algunas carpetas del directorio de Go, por si quereis buscar algo:
\nbin <- binarios, los que instalamos con go install\npackage o pkg <- Trabajar con los wrappers dentro de nuestro código. Encapsuladores de C.\nsrc <- Todo nuestro código fuente y la librerías de terceros. Las puede descargar go al realizar los imports en nuestras clases, o las podemos poner nosotros. Aqui es donde suele buscar el origen de los imports.\nGo es un lenguaje compilado no interpretado, es decir, el código es compilado (transformado) a lenguaje máquina con lo que se genera un ejecutable que funcionará sin necesidad de nada más para la arquitectura para la que fue creado. Si hablamos de los errores, en este tipo de lenguajes deberíamos verlos en el proceso de compilación, pero veremos como con GO podemos probar nuestro código sin necesidad de compilar.
\nUn lenguaje interpretado es aquel en el que un tercero(normalmente llamado intérprete) lee nuestro código y lo traduce a código máquina, esto sucede cada vez que lo ejecutamos, y los errores los detectamos en este tiempo de ejecución.
\nGo es un lenguaje que se usa mucho para scripting en backend ya que es bastante rápido en ejecutar, sus librerías básicas cubren mogollón de escenarios y como he comentado el mismo script lo podriamos compilar para todos los S.O, aunque esto depende un poco de lo que haga jejejeje, no es tan mágico como suena. Personalmente me encanta por la parte de concurrencia y la parte de Web Server, que si mezclamos ambas cosas podemos hacer cosas muy curiosas y que consuman pocos recursos.
\nComo ejemplo pongo un caso de uso de la empresa Malwarebytes en el que gestionan 1 Millón que bajaron sus consumos en un porcentaje muy alto usando GO link. No se a vosotros pero a mi me parece muy interesante poder hacer cosas como esa.
Es un lenguaje con tipado estático, esto quiere decir que desde el principio al declarar las variables tenemos que indicarle el tipo que son. Aunque es cierto que GO tiene una forma de declaración y asignación de variables, en la que el lenguaje hace lo que se conoce como "inferencia de tipos", o lo que es lo mismo, el propio lenguaje define el tipo de la variable según el valor asignado(veremos mas adelante ambas formas)
\nPor último comentar que es un lenguaje que tiene características similares a C (como puede ser que usa punteros), compila directamente en ensamblador y un extra que es muy útil y que nos ahorra quebraderos de cabeza es que tiene recolector de basura es decir, no tenemos que controlar el estado de las variables o funciones para saber si se estan usando o no, ya lo hace Go por nosotros y aunque afecta un poco al rendimiento (realmente es muy poquito), es de agradecer a la hora de programar
\nComo ya he escrito bastante rollo, vamos a trabajar un pelín con go.
\nAntes de empezar primero comprobamos que tenemos bien instalado Go, para ello desde cualquier linea de comandos (da igual Windows/Mac/Linux) escribimos:
go version\nY deberíamos ver algo como esto:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-01-a-las-21.29.26.png\")
\nSi lo vemos todo va bien, si a alguien no le aparece o tiene problemas que lo vaya poniendo en los comentarios y vemos como lo solucionamos.
Ahora abrimos un fichero de texto escribimos siguiente y guardamos como main.go:
\npackage main\n\nimport "fmt"\n\nfunc main() {\n fmt.Println("Hello Power Rangers")\n}\nCon el fichero guardado, nos situamos en la ruta donde lo tengamos en nuestra linea de comandos y ejecutamos:
\ngo run main.go\nEsto nos deberia mostrar algo similar a esto en la consola:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-01-a-las-21.42.38.png\")
\nVoilá ya tenemos nuestro hola mundo. Ya iremos viendo lo que es cada cosa que hemos escrito, esto es solo para que escribamos un poco y veamos que funciona.
Lo último que vamos a ver en este post, serán los IDE, que yo no se vosotros, pero a mi el modo Chuck Norris para programar (hacerlo directamente en un fichero de texto) no es lo que mas me convence, si tenemos posibilidades de que nos ayuden un pelín de alguna forma yo lo agradezco, pero como ya he comentado se puede hacer con cualquier editor de texto.
\nPara programar con Go tenemos varias opciones:
\nCon cualquier IDE y como programadores, nos pueden interesar mínimo 2 cosas para agilizar un poco nuestro trabajo:
\nPues estas dos cosas y algún extra como las sugerencias son las que nos ofrece este IDE con algunas configuraciones.
\nLo primero es instalar el plugin de Go desde la aplicación. Para ello tenemos que buscar la ventana de extensiones, creo que en todas ellas esta en el menu superior de la aplicación en la pestaña ver o view, seleccionamos extensiones o extensions
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Screen-Shot-2017-06-02-at-21.48.18.png\")
\nY en la ventana que nos aparece buscamos Go
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Screen-Shot-2017-06-02-at-21.49.22.png\")
\nY entre todas las extensiones que nos aparecen buscamos la de lukehoban y la instalamos.
\nUna vez que termine nos pedirá reiniciar la aplicación, y una vez que reinicie lo mejor es crear un fichero nuevo y ponerle extension .go.
Hacemos esta para que el propio visual studio nos complete la instalación, ya que cuando guardemos el fichero nos aparecerán algunos mensajes como este:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Screen-Shot-2017-06-02-at-21.52.55.png\")
\nBásicamente en todos los que nos pregunte tenemos que indicarle Install All
También es posible que nos indique que configuremos el GOPATH para que os hagáis una idea ese seria el Workspace desde donde trabajaremos, si os sale eso en Doc-GOPATH o en Test Install GO tenéis info para que identifiquéis bien lo que es y podáis configurarlo correctamente.
\nLo segundo es configurar para poder hacer debug, lo más fácil es que miréis en la documentación del creador Derekparker-delve, aquí según vuestro sistema operativo tenéis las instrucciones. En general suele valer con hacer
\ngo get github.com/derekparker/delve/cmd/dlv\nAunque depende un poco de la versión de sistema, como he comentado lo mejor es que miréis la documentación.
\nY una vez que lo tengáis instalado ya podremos ir poniendo lo que se conoce como puntos de interrupción para controlar lo que hace nuestro código.
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-03-a-las-11.30.43.png\")
\nCon hacer click un par de veces al lado del número de linea es suficiente. Y para comprobar que funciona pulsamos sobre F5 o nos vamos al menú Depurar y pulsamos Iniciar depuración
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-03-a-las-11.33.03.png\")
Y entonces nuestro IDE cambiará al modo debug que lo que nos hará será parar la ejecución del código donde tengamos los puntos y podemos ver como están las variables o lo que tengamos en el código.
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/06/Captura-de-pantalla-2017-06-03-a-las-11.39.06.png\")
Como veis en la imagen variables a la izquierda, pila de llamadas un poco más abajo, puntos de interrupción.... todo muy útil sobretodo cuando tenemos problemas con nuestro código.
\nY con esto finalizo este post(por fiiiin!!! ) y ya en los siguientes empezaremos con lo bueno.
\nSi tenéis dudas o problemas ponerlo en los comentarios.
\nCiaaaao
Empiezo con una nueva sección, mi aventura con el lenguaje GO, el cual he descubierto que me encanta, es un lenguaje muy bueno y sencillo para tratar con temas de concurrencia y realmente hace un montón de cosas por si solo(como su paquete net que hace la vida mas fácil en cuanto a servidor Web se refiere), lo vamos a ir viendo poco a poco. Sin mucho más empecemos
\nEl lenguaje lo podemos escribir desde cualquier editor de texto pero es necesario instalar el compilador y realizar algunas configuraciones. Desde la propia página Go Download están los paquetes, y las instrucciones. También es posible instalarlo con Homebrew (si lo usamos).
\nbrew install golang\nPara la correcta instalación tenemos que tener en cuenta que es necesario configurar ciertas variables de entorno, teneis toda la información en:
\nInstalación GO
Haceros a la idea de que la documentación de Go es bastante completa por lo que en general encontraremos todo lo que necesitemos aquí:
\nDocumentación GO
Solo como aclaración tener en cuenta lo que comenta la documentación sobre los variables de entorno, si ejecutamos algún intalador (MAC/Windows) no deberíamos tener que hacer nada, si algo no funciona comprobar que existe en la variable de entorno $PATH la referencia a Go y que es correcta:
\nWindows\nc:\\Go\\bin\nMac\necho $PATH <- nos devuelve lo que tenemos ahora mismo en el path\nEsto deberia devolvernos una cadena de texto muy larga que en algún punto deberia poner algo similar a esto\n/usr/local/go/bin\nSi lo hacemos en Linux o con cualquier source, lo mejor es extraer el contenido en las rutas recomendadas y configurar las variables de entorno como aparece en la documentación.
\nSi tenéis algún problema buscar en internet que hay mucha información sobre esto, aun así si continuáis con problemas ponerlo en los comentarios e intentamos resolverlo.
\nAntes de continuar un detalle de algunas carpetas del directorio de Go, por si quereis buscar algo:
\nbin <- binarios, los que instalamos con go install\npackage o pkg <- Trabajar con los wrappers dentro de nuestro código. Encapsuladores de C.\nsrc <- Todo nuestro código fuente y la librerías de terceros. Las puede descargar go al realizar los imports en nuestras clases, o las podemos poner nosotros. Aqui es donde suele buscar el origen de los imports.\nGo es un lenguaje compilado no interpretado, es decir, el código es compilado (transformado) a lenguaje máquina con lo que se genera un ejecutable que funcionará sin necesidad de nada más para la arquitectura para la que fue creado. Si hablamos de los errores, en este tipo de lenguajes deberíamos verlos en el proceso de compilación, pero veremos como con GO podemos probar nuestro código sin necesidad de compilar.
\nUn lenguaje interpretado es aquel en el que un tercero(normalmente llamado intérprete) lee nuestro código y lo traduce a código máquina, esto sucede cada vez que lo ejecutamos, y los errores los detectamos en este tiempo de ejecución.
\nGo es un lenguaje que se usa mucho para scripting en backend ya que es bastante rápido en ejecutar, sus librerías básicas cubren mogollón de escenarios y como he comentado el mismo script lo podriamos compilar para todos los S.O, aunque esto depende un poco de lo que haga jejejeje, no es tan mágico como suena. Personalmente me encanta por la parte de concurrencia y la parte de Web Server, que si mezclamos ambas cosas podemos hacer cosas muy curiosas y que consuman pocos recursos.
\nComo ejemplo pongo un caso de uso de la empresa Malwarebytes en el que gestionan 1 Millón que bajaron sus consumos en un porcentaje muy alto usando GO link. No se a vosotros pero a mi me parece muy interesante poder hacer cosas como esa.
Es un lenguaje con tipado estático, esto quiere decir que desde el principio al declarar las variables tenemos que indicarle el tipo que son. Aunque es cierto que GO tiene una forma de declaración y asignación de variables, en la que el lenguaje hace lo que se conoce como \"inferencia de tipos\", o lo que es lo mismo, el propio lenguaje define el tipo de la variable según el valor asignado(veremos mas adelante ambas formas)
\nPor último comentar que es un lenguaje que tiene características similares a C (como puede ser que usa punteros), compila directamente en ensamblador y un extra que es muy útil y que nos ahorra quebraderos de cabeza es que tiene recolector de basura es decir, no tenemos que controlar el estado de las variables o funciones para saber si se estan usando o no, ya lo hace Go por nosotros y aunque afecta un poco al rendimiento (realmente es muy poquito), es de agradecer a la hora de programar
\nComo ya he escrito bastante rollo, vamos a trabajar un pelín con go.
\nAntes de empezar primero comprobamos que tenemos bien instalado Go, para ello desde cualquier linea de comandos (da igual Windows/Mac/Linux) escribimos:
go version\nY deberíamos ver algo como esto:
\n
\nSi lo vemos todo va bien, si a alguien no le aparece o tiene problemas que lo vaya poniendo en los comentarios y vemos como lo solucionamos.
Ahora abrimos un fichero de texto escribimos siguiente y guardamos como main.go:
\npackage main\n\nimport \"fmt\"\n\nfunc main() {\n fmt.Println(\"Hello Power Rangers\")\n}\nCon el fichero guardado, nos situamos en la ruta donde lo tengamos en nuestra linea de comandos y ejecutamos:
\ngo run main.go\nEsto nos deberia mostrar algo similar a esto en la consola:
\n
\nVoilá ya tenemos nuestro hola mundo. Ya iremos viendo lo que es cada cosa que hemos escrito, esto es solo para que escribamos un poco y veamos que funciona.
Lo último que vamos a ver en este post, serán los IDE, que yo no se vosotros, pero a mi el modo Chuck Norris para programar (hacerlo directamente en un fichero de texto) no es lo que mas me convence, si tenemos posibilidades de que nos ayuden un pelín de alguna forma yo lo agradezco, pero como ya he comentado se puede hacer con cualquier editor de texto.
\nPara programar con Go tenemos varias opciones:
\nCon cualquier IDE y como programadores, nos pueden interesar mínimo 2 cosas para agilizar un poco nuestro trabajo:
\nPues estas dos cosas y algún extra como las sugerencias son las que nos ofrece este IDE con algunas configuraciones.
\nLo primero es instalar el plugin de Go desde la aplicación. Para ello tenemos que buscar la ventana de extensiones, creo que en todas ellas esta en el menu superior de la aplicación en la pestaña ver o view, seleccionamos extensiones o extensions
\n
\nY en la ventana que nos aparece buscamos Go
\n
\nY entre todas las extensiones que nos aparecen buscamos la de lukehoban y la instalamos.
\nUna vez que termine nos pedirá reiniciar la aplicación, y una vez que reinicie lo mejor es crear un fichero nuevo y ponerle extension .go.
Hacemos esta para que el propio visual studio nos complete la instalación, ya que cuando guardemos el fichero nos aparecerán algunos mensajes como este:
\n
\nBásicamente en todos los que nos pregunte tenemos que indicarle Install All
También es posible que nos indique que configuremos el GOPATH para que os hagáis una idea ese seria el Workspace desde donde trabajaremos, si os sale eso en Doc-GOPATH o en Test Install GO tenéis info para que identifiquéis bien lo que es y podáis configurarlo correctamente.
\nLo segundo es configurar para poder hacer debug, lo más fácil es que miréis en la documentación del creador Derekparker-delve, aquí según vuestro sistema operativo tenéis las instrucciones. En general suele valer con hacer
\ngo get github.com/derekparker/delve/cmd/dlv\nAunque depende un poco de la versión de sistema, como he comentado lo mejor es que miréis la documentación.
\nY una vez que lo tengáis instalado ya podremos ir poniendo lo que se conoce como puntos de interrupción para controlar lo que hace nuestro código.
\n
\nCon hacer click un par de veces al lado del número de linea es suficiente. Y para comprobar que funciona pulsamos sobre F5 o nos vamos al menú Depurar y pulsamos Iniciar depuración
\n
Y entonces nuestro IDE cambiará al modo debug que lo que nos hará será parar la ejecución del código donde tengamos los puntos y podemos ver como están las variables o lo que tengamos en el código.
\n
Como veis en la imagen variables a la izquierda, pila de llamadas un poco más abajo, puntos de interrupción.... todo muy útil sobretodo cuando tenemos problemas con nuestro código.
\nY con esto finalizo este post(por fiiiin!!! ) y ya en los siguientes empezaremos con lo bueno.
\nSi tenéis dudas o problemas ponerlo en los comentarios.
\nCiaaaao
Espero que este post sea bastante rápido jejejejej.
\nEn este caso hablaremos de los Maps o lo que en otros lenguajes conoceríamos como diccionario. En general siguen las mismas teorías que los arrays o los slices en cuanto a creación y a lo referente al rendimiento, los mapas crecen dinámicamente pero podemos indicarles el tamaño lo que optimizaría un poco su rendimiento.
Empecemos con la creación. Como ya hemos visto en Go tenemos siempre varias formas de crear los elementos:
\n//var nombreVariable map[tipoClave]tipoValor\nvar rangerRojo map[string]int\n//Inicializando sin valores\nrangerRojo := map[string]int{}\n\n//Inicializando con valores. Obligatoria la coma ultima\nrangerVerde := map[string]int{\n "Fuerza": 10000,\n "Resistencia": 5000,\n}\nrangerVerde := make(map[string]int)\n//Al igual que en los arrays podemos indicar el tamaño para optimizar rendimiento.\nrangerNegro := make(map[string]int, 2) \nYa hemos visto un poco como es la creación de Maps en golang, no es muy complicado no?, veamos ahora algunos detalles de su uso.
\nCuando asignamos el valor, realmente este devuelve 2, el contenido que queremos sacar y si existe o no. Veamoslo con un ejemplo:
\nrangerRojo := map[string]int{\n "Fuerza": 10000,\n}\n\nrangerVerde := make(map[string]int)\n\npower, exist := rangerRojo["Fuerza"]\nfmt.Println("Valor: ", power, "Existe: ", exist)\n\npower2, exist2 := rangerVerde["Fuerza"]\nfmt.Println("Valor: ", power2, "Existe: ", exist2)\nHe usado dos formas de crear maps y el resultado de esto seria:
\n![\"Map](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.08.38.png\")
\nComo veis nos inicializa el valor como suele hacer Go y nos indica que no existe realmente.
En este caso Go se vuelve muy útil tiene una función propia para poder eliminar el elemento que queramos:
\ndelete(rangerRojo,"Fuerza")\nProbémoslo en un ejemplo más completo:
\nrangerRojo := map[string]int{\n\t"Fuerza": 10000,\n\t"Resistencia": 500,\n}\nfmt.Println(rangerRojo)\n\ndelete(rangerRojo, "Fuerza")\n\nfmt.Println(rangerRojo)\nY como vemos elimina el contenido sin problemas:
\n![\"Delete](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.16.50.png\")
Para recorrer un MAP usamos la misma teoría que para los arrays o slices: RANGE vamos directos al ejemplo ya que es bastante simple:
\nrangerRojo := map[string]interface{}{\n "Fuerza": 10000,\n "Resistencia": 500,\n "Inteligencia": "200",\n "Arma": "Espada",\n}\n\nfor key, value := range rangerRojo {\n fmt.Println("Clave: ", key, " Valor: ", value)\n}\nTenemos un map que tiene como claves varios strings representando las características de nuestro ranger y como valor he introducido algo que no habiamos visto todavia INTERFACE{}, bueno como resumen haceros a la idea de que es un tipo especial que funciona como un genérico, es decir, que representa cualquier valor(por eso podemos tener valores tipo INT y tipo STRING) y al recorrerlo tenemos esto:
\n![\"Range](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.34.29.png\")
\nOJO a tener en cuenta, no tiene porque hacerlo en orden sobretodo si introducimos algo a posteriori, mirar un ejemplo:
rangerRojo := map[string]interface{}{\n "Fuerza": 10000,\n "Resistencia": 500,\n "Inteligencia": 150,\n "Arma": "Espada",\n}\n\nrangerRojo["Maná"] = 150\n\nfor key, value := range rangerRojo {\n fmt.Println("Clave: ", key, " Valor: ", value)\n}\nHe añadido otra propiedad a nuestro ranger y el resultado es:
\n![\"First](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.39.11.png\")
Si lo ejecuto de nuevo:
\n![\"Second](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.40.10.png\")
Por último y como he adelantado en el ejemplo anterior:
\nBueno como ya hemos visto esto es muy sencillo:
\nrangerRojo["Maná"] = 150\n\nfmt.Println(rangerRojo)\nY nos muestra
\n![\"Print](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-20-at-21.43.26.png\")
\nPor el momento hemos terminado con los mapas, profundizaremos en el trabajo con ellos más adelante.
\nSin mucho más nos vemos en la siguiente superNinjas :)
Espero que este post sea bastante rápido jejejejej.
\nEn este caso hablaremos de los Maps o lo que en otros lenguajes conoceríamos como diccionario. En general siguen las mismas teorías que los arrays o los slices en cuanto a creación y a lo referente al rendimiento, los mapas crecen dinámicamente pero podemos indicarles el tamaño lo que optimizaría un poco su rendimiento.
Empecemos con la creación. Como ya hemos visto en Go tenemos siempre varias formas de crear los elementos:
\n//var nombreVariable map[tipoClave]tipoValor\nvar rangerRojo map[string]int\n//Inicializando sin valores\nrangerRojo := map[string]int{}\n\n//Inicializando con valores. Obligatoria la coma ultima\nrangerVerde := map[string]int{\n \"Fuerza\": 10000,\n \"Resistencia\": 5000,\n}\nrangerVerde := make(map[string]int)\n//Al igual que en los arrays podemos indicar el tamaño para optimizar rendimiento.\nrangerNegro := make(map[string]int, 2) \nYa hemos visto un poco como es la creación de Maps en golang, no es muy complicado no?, veamos ahora algunos detalles de su uso.
\nCuando asignamos el valor, realmente este devuelve 2, el contenido que queremos sacar y si existe o no. Veamoslo con un ejemplo:
\nrangerRojo := map[string]int{\n \"Fuerza\": 10000,\n}\n\nrangerVerde := make(map[string]int)\n\npower, exist := rangerRojo[\"Fuerza\"]\nfmt.Println(\"Valor: \", power, \"Existe: \", exist)\n\npower2, exist2 := rangerVerde[\"Fuerza\"]\nfmt.Println(\"Valor: \", power2, \"Existe: \", exist2)\nHe usado dos formas de crear maps y el resultado de esto seria:
\n
\nComo veis nos inicializa el valor como suele hacer Go y nos indica que no existe realmente.
En este caso Go se vuelve muy útil tiene una función propia para poder eliminar el elemento que queramos:
\ndelete(rangerRojo,\"Fuerza\")\nProbémoslo en un ejemplo más completo:
\nrangerRojo := map[string]int{\n\t\"Fuerza\": 10000,\n\t\"Resistencia\": 500,\n}\nfmt.Println(rangerRojo)\n\ndelete(rangerRojo, \"Fuerza\")\n\nfmt.Println(rangerRojo)\nY como vemos elimina el contenido sin problemas:
\n
Para recorrer un MAP usamos la misma teoría que para los arrays o slices: RANGE vamos directos al ejemplo ya que es bastante simple:
\nrangerRojo := map[string]interface{}{\n \"Fuerza\": 10000,\n \"Resistencia\": 500,\n \"Inteligencia\": \"200\",\n \"Arma\": \"Espada\",\n}\n\nfor key, value := range rangerRojo {\n fmt.Println(\"Clave: \", key, \" Valor: \", value)\n}\nTenemos un map que tiene como claves varios strings representando las características de nuestro ranger y como valor he introducido algo que no habiamos visto todavia INTERFACE{}, bueno como resumen haceros a la idea de que es un tipo especial que funciona como un genérico, es decir, que representa cualquier valor(por eso podemos tener valores tipo INT y tipo STRING) y al recorrerlo tenemos esto:
\n
\nOJO a tener en cuenta, no tiene porque hacerlo en orden sobretodo si introducimos algo a posteriori, mirar un ejemplo:
rangerRojo := map[string]interface{}{\n \"Fuerza\": 10000,\n \"Resistencia\": 500,\n \"Inteligencia\": 150,\n \"Arma\": \"Espada\",\n}\n\nrangerRojo[\"Maná\"] = 150\n\nfor key, value := range rangerRojo {\n fmt.Println(\"Clave: \", key, \" Valor: \", value)\n}\nHe añadido otra propiedad a nuestro ranger y el resultado es:
\n
Si lo ejecuto de nuevo:
\n
Por último y como he adelantado en el ejemplo anterior:
\nBueno como ya hemos visto esto es muy sencillo:
\nrangerRojo[\"Maná\"] = 150\n\nfmt.Println(rangerRojo)\nY nos muestra
\n
\nPor el momento hemos terminado con los mapas, profundizaremos en el trabajo con ellos más adelante.
\nSin mucho más nos vemos en la siguiente superNinjas :)
En este post vamos a ir viendo como se podrian hacer las cosas mas habituales con los Arrays o Slices, como puede ser recorrerlos, veremos tambien como podemos pasar de uno a otro para la optimización, sin mucho mas empezamos.
\nEmpecemos por el caso más habitual y es la necesidad de recorrer el contenido de un array, en este punto voy a adelantar alguna otra cosa que no es solo de Array o Slices, pero creo que es mejor verlo en esta parte.
\nPara recorrer un array, tipicamente lo hacemos un bucle for, pues en este caso Go tiene un proceso muy similar específico (aunque se podria simular un for normal, haciendo el código a mano pero me parece innecesario, con el código lo vereis mejor)
\nrangers := []string{"Ranger Rosa", "Ranger Amarillo"}\n\nfor index, ranger := range rangers {\n\tfmt.Println("El indice o posicion es: ", index)\n\tfmt.Println("El Ranger de esa posicion es:", ranger)\n}\nCon un resultado similar a este:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.49.53.png\")
\nComo vemos aqui tenemos un par de palabras reservadas que no habiamos usado: for y range, mas o menos os podéis imaginar la funcion que tiene cada una, básicamente esto quiere decir "Por cada índice y ranger dentro del rango de rangers....."
Bastante sencillo no?? Si os fijais tenemos la declaración corta de variables :=, lo que esta haciendo es asignar en cada vuelta, el índice y el valor en los nombres de variables que hemos puesto(podrian ser otros perfectamente).
\nY si no queremos el índice?? Básicamente ignoramos el resultado:
\nfor _, ranger := range rangers {\n\tfmt.Println("El Ranger de esa posicion es:", ranger)\n}\nEl _ en Go es un valor especial(funciona igual que en Swift por ejemplo) con el que estamos indicando que ignore ese resultado que podemos obtener de una función o cualquier otro proceso como puede ser este que acabamos de ver de recorrer un array.
\nO mas bien crear un subarray con parte del array original, es decir, veamos como partir un array para extrar el rango de posiciones que nos interese.
\nEn go tenemos la posibilidad de seleccionar un rango de X posiciones dentro de un array, de una manera bastante sencilla:
miniRangers := rangers[:2]\nfmt.Println("Hemos seleccionado del inicio a la posicion 2 sin incluirla:")\nfmt.Println(miniRangers)\n\nminiRangers2 := rangers[2:4]\nfmt.Println("Hemos seleccionado desde la posicion 2 hasta la 4 sin incluirla:")\nfmt.Println(miniRangers2)\n\nminiRangers3 := rangers[4:]\nfmt.Println("Hemos seleccionado desde la 4 hasta el final")\nfmt.Println(miniRangers3)\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.09.05.png\")
Tambien es posible asignar al mismo array o resumiendo cortar el array:
\nrangers := []string{"Ranger Rosa", "Ranger Amarillo", "Ranger Rojo", "Ranger Verde", "Ranger Negro"}\n\nrangers = rangers[2:4]\nfmt.Println("Hemos seleccionado del inicio a la posicion 2 sin incluirla:")\nfmt.Println(rangers)\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.12.15.png\")
Estos ya los hemos visto:
\nfmt.Println(len(rangers))//Para el tamaño\n\nfmt.Println(len(rangers))//Capacidad\nTambien hemos visto como añadir, ya sea en un array hasta su tamaño designado y en un slice cuando no esta inicializado:
\nvar rangersDesignados [2]string\nrangersDesignados = append(rangersDesignados,"R.Rojo","R.Verde")\n\nrangersSlices = make([]string,2,10)\nappend(rangersSlices,"R.Rojo","R.Verde")\nSiento decir que aqui el lenguaje nos falla un poco, ya que no ofrece ningun método ya preparado para esto, como tal ya tenemos que jugar nosotros. En esta página:SliceTricks
\nTenemos alguna forma de hacer las operaciones mas comunes de eliminar, cortar, etc de manera eficiente.
En un principio esto puede no parecer nada, estamos hablando de copiar un array o slice en otro......bueno pues no es tan simple, ¿recordáis lo que comentamos en el post anterior sobre tamaño y capacidad? Por refrescar rápidamente, el tamaño era la cantidad de elementos que tenia un slice o array y la capacidad la reserva de elementos que puede contener, es decir, la cantidad máxima de elementos que puede tener. Recordemos que Go lo que hace es reservar un espacio en memoria para almacenar una cantidad aproximada de datos, lo importante venia a la hora de aumentar, como tal el slice comentamos que al aumentar lo que hacia era reservarse el doble de la capacidad que tenia anteriormente. Esto con slices pequeños esta muy bien, pero ¿y si tenemos un slice de 1000 elementos? En cuanto añadamos 1 más se reservara un espacio de 2000.
\nPues bien con este escenario tenemos la accion de copiar como solución, lo que hacemos es copiar un array en otro con la capacidad ajustada a lo que queramos, la forma de usarlo es simple:
\ncopy(destino, origen)\nBastante simple no? Pues veamos un ejemplo y apliquemos un poco de lógica para optimizar el consumo:
\n//Creamos dos slices\nslice := []int{1, 2, 3, 4}\ncopia := make([]int, 4)\n\ncopy(copia, slice)\n\nfmt.Println(slice)\nfmt.Println(copia)\nComo vemos hemos creado un slice con la forma corta, con contenido, y otro vacio con un tamaño y capacidad de 4. Si imprimimos el contenido todo estaría normal, pero un detalle a tener en cuenta es que realmente copy tiene en cuenta la capacidad del slice de destino (en este caso copia), como le hemos puesto una capacidad de 4, nos copia todo el contenido. Pongamos un ejemplo si ponemos menos:
\n//Si cambiaramos copia con otra longitud\ncopia2 := make([]int, 2)\ncopy(copia2, slice)\nfmt.Println(slice)\nfmt.Println(copia2)\n//Veriamos como solo nos copia 2 elementos, \nLo mejor es controlar el tamaño(no la capacidad ojo), del slice origen y usar eso para crear el destino:
\n//para no equivocarnos lo ideal seria\ncopia3 := make([]int, len(slice))\ncopy(copia3, slice)\n\nfmt.Println(slice)\nfmt.Println(copia3)\n//Con esto si cambia el tamaño del slice la copia tambien.\n\n//Como buena practica, aunque segun el entorno, es añadir el doble del tamaño a la capacidad\ncopia4 := make([]int, len(slice), len(slice)*2) //O con la capacidad segun el caso\n \ncopy(copia4, slice)\nfmt.Println(slice)\nfmt.Println(copia4)\nBueno creo que por el momento vamos a dejar los arrays y slices para continuar con otras cosas, recordar mirar el link SliceTricks y en otro de mis post tengo algo mas de trabajo con arrays: Go Tricks I
\n","url":"https://jlgarcia.fulldev.ninja/go-parte-4-arrays-y-slices-ii/","canonical_url":null,"uuid":"fcff7b39-793f-48db-b59d-161f6b0ea711","codeinjection_foot":null,"codeinjection_head":null,"codeinjection_styles":null,"comment_id":"30","reading_time":5,"send_email_when_published":false,"email_subject":null,"childHtmlRehype":{"html":"En este post vamos a ir viendo como se podrian hacer las cosas mas habituales con los Arrays o Slices, como puede ser recorrerlos, veremos tambien como podemos pasar de uno a otro para la optimización, sin mucho mas empezamos.
\nEmpecemos por el caso más habitual y es la necesidad de recorrer el contenido de un array, en este punto voy a adelantar alguna otra cosa que no es solo de Array o Slices, pero creo que es mejor verlo en esta parte.
\nPara recorrer un array, tipicamente lo hacemos un bucle for, pues en este caso Go tiene un proceso muy similar específico (aunque se podria simular un for normal, haciendo el código a mano pero me parece innecesario, con el código lo vereis mejor)
\nrangers := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfor index, ranger := range rangers {\n\tfmt.Println(\"El indice o posicion es: \", index)\n\tfmt.Println(\"El Ranger de esa posicion es:\", ranger)\n}\nCon un resultado similar a este:
\n
\nComo vemos aqui tenemos un par de palabras reservadas que no habiamos usado: for y range, mas o menos os podéis imaginar la funcion que tiene cada una, básicamente esto quiere decir \"Por cada índice y ranger dentro del rango de rangers.....\"
Bastante sencillo no?? Si os fijais tenemos la declaración corta de variables :=, lo que esta haciendo es asignar en cada vuelta, el índice y el valor en los nombres de variables que hemos puesto(podrian ser otros perfectamente).
\nY si no queremos el índice?? Básicamente ignoramos el resultado:
\nfor _, ranger := range rangers {\n\tfmt.Println(\"El Ranger de esa posicion es:\", ranger)\n}\nEl _ en Go es un valor especial(funciona igual que en Swift por ejemplo) con el que estamos indicando que ignore ese resultado que podemos obtener de una función o cualquier otro proceso como puede ser este que acabamos de ver de recorrer un array.
\nO mas bien crear un subarray con parte del array original, es decir, veamos como partir un array para extrar el rango de posiciones que nos interese.
\nEn go tenemos la posibilidad de seleccionar un rango de X posiciones dentro de un array, de una manera bastante sencilla:
miniRangers := rangers[:2]\nfmt.Println(\"Hemos seleccionado del inicio a la posicion 2 sin incluirla:\")\nfmt.Println(miniRangers)\n\nminiRangers2 := rangers[2:4]\nfmt.Println(\"Hemos seleccionado desde la posicion 2 hasta la 4 sin incluirla:\")\nfmt.Println(miniRangers2)\n\nminiRangers3 := rangers[4:]\nfmt.Println(\"Hemos seleccionado desde la 4 hasta el final\")\nfmt.Println(miniRangers3)\n
Tambien es posible asignar al mismo array o resumiendo cortar el array:
\nrangers := []string{\"Ranger Rosa\", \"Ranger Amarillo\", \"Ranger Rojo\", \"Ranger Verde\", \"Ranger Negro\"}\n\nrangers = rangers[2:4]\nfmt.Println(\"Hemos seleccionado del inicio a la posicion 2 sin incluirla:\")\nfmt.Println(rangers)\n
Estos ya los hemos visto:
\nfmt.Println(len(rangers))//Para el tamaño\n\nfmt.Println(len(rangers))//Capacidad\nTambien hemos visto como añadir, ya sea en un array hasta su tamaño designado y en un slice cuando no esta inicializado:
\nvar rangersDesignados [2]string\nrangersDesignados = append(rangersDesignados,\"R.Rojo\",\"R.Verde\")\n\nrangersSlices = make([]string,2,10)\nappend(rangersSlices,\"R.Rojo\",\"R.Verde\")\nSiento decir que aqui el lenguaje nos falla un poco, ya que no ofrece ningun método ya preparado para esto, como tal ya tenemos que jugar nosotros. En esta página:SliceTricks
\nTenemos alguna forma de hacer las operaciones mas comunes de eliminar, cortar, etc de manera eficiente.
En un principio esto puede no parecer nada, estamos hablando de copiar un array o slice en otro......bueno pues no es tan simple, ¿recordáis lo que comentamos en el post anterior sobre tamaño y capacidad? Por refrescar rápidamente, el tamaño era la cantidad de elementos que tenia un slice o array y la capacidad la reserva de elementos que puede contener, es decir, la cantidad máxima de elementos que puede tener. Recordemos que Go lo que hace es reservar un espacio en memoria para almacenar una cantidad aproximada de datos, lo importante venia a la hora de aumentar, como tal el slice comentamos que al aumentar lo que hacia era reservarse el doble de la capacidad que tenia anteriormente. Esto con slices pequeños esta muy bien, pero ¿y si tenemos un slice de 1000 elementos? En cuanto añadamos 1 más se reservara un espacio de 2000.
\nPues bien con este escenario tenemos la accion de copiar como solución, lo que hacemos es copiar un array en otro con la capacidad ajustada a lo que queramos, la forma de usarlo es simple:
\ncopy(destino, origen)\nBastante simple no? Pues veamos un ejemplo y apliquemos un poco de lógica para optimizar el consumo:
\n//Creamos dos slices\nslice := []int{1, 2, 3, 4}\ncopia := make([]int, 4)\n\ncopy(copia, slice)\n\nfmt.Println(slice)\nfmt.Println(copia)\nComo vemos hemos creado un slice con la forma corta, con contenido, y otro vacio con un tamaño y capacidad de 4. Si imprimimos el contenido todo estaría normal, pero un detalle a tener en cuenta es que realmente copy tiene en cuenta la capacidad del slice de destino (en este caso copia), como le hemos puesto una capacidad de 4, nos copia todo el contenido. Pongamos un ejemplo si ponemos menos:
\n//Si cambiaramos copia con otra longitud\ncopia2 := make([]int, 2)\ncopy(copia2, slice)\nfmt.Println(slice)\nfmt.Println(copia2)\n//Veriamos como solo nos copia 2 elementos, \nLo mejor es controlar el tamaño(no la capacidad ojo), del slice origen y usar eso para crear el destino:
\n//para no equivocarnos lo ideal seria\ncopia3 := make([]int, len(slice))\ncopy(copia3, slice)\n\nfmt.Println(slice)\nfmt.Println(copia3)\n//Con esto si cambia el tamaño del slice la copia tambien.\n\n//Como buena practica, aunque segun el entorno, es añadir el doble del tamaño a la capacidad\ncopia4 := make([]int, len(slice), len(slice)*2) //O con la capacidad segun el caso\n \ncopy(copia4, slice)\nfmt.Println(slice)\nfmt.Println(copia4)\nBueno creo que por el momento vamos a dejar los arrays y slices para continuar con otras cosas, recordar mirar el link SliceTricks y en otro de mis post tengo algo mas de trabajo con arrays: Go Tricks I
\n","htmlAst":{"type":"root","children":[{"type":"comment","value":"kg-card-begin: markdown"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En este post vamos a ir viendo como se podrian hacer las cosas mas habituales con los Arrays o Slices, como puede ser recorrerlos, veremos tambien como podemos pasar de uno a otro para la optimización, sin mucho mas empezamos."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"recorrerunarrayoslice"},"children":[{"type":"text","value":"Recorrer un array o slice"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Empecemos por el caso más habitual y es la necesidad de recorrer el contenido de un array, en este punto voy a adelantar alguna otra cosa que no es solo de Array o Slices, pero creo que es mejor verlo en esta parte."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Para recorrer un array, tipicamente lo hacemos un bucle "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"for"}]},{"type":"text","value":", pues en este caso Go tiene un proceso muy similar específico (aunque se podria simular un for normal, haciendo el código a mano pero me parece innecesario, con el código lo vereis mejor)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers := []string{\"Ranger Rosa\", \"Ranger Amarillo\"}\n\nfor index, ranger := range rangers {\n\tfmt.Println(\"El indice o posicion es: \", index)\n\tfmt.Println(\"El Ranger de esa posicion es:\", ranger)\n}\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Con un resultado similar a este:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen08.49.53.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nComo vemos aqui tenemos un par de palabras reservadas que no habiamos usado: "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"for"}]},{"type":"text","value":" y "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"range"}]},{"type":"text","value":", mas o menos os podéis imaginar la funcion que tiene cada una, básicamente esto quiere decir \"Por cada índice y ranger dentro del rango de rangers.....\""}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Bastante sencillo no?? Si os fijais tenemos la declaración corta de variables "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":":="}]},{"type":"text","value":", lo que esta haciendo es asignar en cada vuelta, el índice y el valor en los nombres de variables que hemos puesto(podrian ser otros perfectamente)."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Y si no queremos el índice?? Básicamente ignoramos el resultado:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"for _, ranger := range rangers {\n\tfmt.Println(\"El Ranger de esa posicion es:\", ranger)\n}\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"El "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"_"}]},{"type":"text","value":" en Go es un valor especial(funciona igual que en Swift por ejemplo) con el que estamos indicando que ignore ese resultado que podemos obtener de una función o cualquier otro proceso como puede ser este que acabamos de ver de recorrer un array."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"separandounarray"},"children":[{"type":"text","value":"Separando un array"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"O mas bien crear un subarray con parte del array original, es decir, veamos como partir un array para extrar el rango de posiciones que nos interese."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nEn go tenemos la posibilidad de seleccionar un rango de X posiciones dentro de un array, de una manera bastante sencilla:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"miniRangers := rangers[:2]\nfmt.Println(\"Hemos seleccionado del inicio a la posicion 2 sin incluirla:\")\nfmt.Println(miniRangers)\n\nminiRangers2 := rangers[2:4]\nfmt.Println(\"Hemos seleccionado desde la posicion 2 hasta la 4 sin incluirla:\")\nfmt.Println(miniRangers2)\n\nminiRangers3 := rangers[4:]\nfmt.Println(\"Hemos seleccionado desde la 4 hasta el final\")\nfmt.Println(miniRangers3)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.09.05.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Tambien es posible asignar al mismo array o resumiendo cortar el array:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"rangers := []string{\"Ranger Rosa\", \"Ranger Amarillo\", \"Ranger Rojo\", \"Ranger Verde\", \"Ranger Negro\"}\n\nrangers = rangers[2:4]\nfmt.Println(\"Hemos seleccionado del inicio a la posicion 2 sin incluirla:\")\nfmt.Println(rangers)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen09.12.15.png","alt":""},"children":[]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"tamaoycapacidad"},"children":[{"type":"text","value":"Tamaño y Capacidad"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Estos ya los hemos visto:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"fmt.Println(len(rangers))//Para el tamaño\n\nfmt.Println(len(rangers))//Capacidad\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"aadir"},"children":[{"type":"text","value":"Añadir"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Tambien hemos visto como añadir, ya sea en un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"array"}]},{"type":"text","value":" hasta su tamaño designado y en un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":" cuando no esta inicializado:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"var rangersDesignados [2]string\nrangersDesignados = append(rangersDesignados,\"R.Rojo\",\"R.Verde\")\n\nrangersSlices = make([]string,2,10)\nappend(rangersSlices,\"R.Rojo\",\"R.Verde\")\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"eliminar"},"children":[{"type":"text","value":"Eliminar"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Siento decir que aqui el lenguaje nos falla un poco, ya que no ofrece ningun método ya preparado para esto, como tal ya tenemos que jugar nosotros. En esta página:"},{"type":"element","tagName":"a","properties":{"href":"https://github.com/golang/go/wiki/SliceTricks"},"children":[{"type":"text","value":"SliceTricks"}]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nTenemos alguna forma de hacer las operaciones mas comunes de eliminar, cortar, etc de manera eficiente."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"copiarspanstylecolorredimportantespan"},"children":[{"type":"text","value":"Copiar"},{"type":"element","tagName":"span","properties":{"style":"color:red"},"children":[{"type":"text","value":"(Importante)"}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En un principio esto puede no parecer nada, estamos hablando de copiar un array o slice en otro......bueno pues no es tan simple, ¿recordáis lo que comentamos en el post anterior sobre tamaño y capacidad? Por refrescar rápidamente, el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"tamaño"}]},{"type":"text","value":" era la cantidad de elementos que tenia un slice o array y la "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"capacidad"}]},{"type":"text","value":" la reserva de elementos que puede contener, es decir, la cantidad máxima de elementos que puede tener. Recordemos que Go lo que hace es reservar un espacio en memoria para almacenar una cantidad aproximada de datos, lo "},{"type":"element","tagName":"span","properties":{"style":"color:red"},"children":[{"type":"text","value":"importante"}]},{"type":"text","value":" venia a la hora de aumentar, como tal el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slice"}]},{"type":"text","value":" comentamos que al aumentar lo que hacia era reservarse el doble de la capacidad que tenia anteriormente. Esto con slices pequeños esta muy bien, pero ¿y si tenemos un slice de 1000 elementos? En cuanto añadamos 1 más se reservara un espacio de 2000."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Pues bien con este escenario tenemos la accion de "},{"type":"element","tagName":"span","properties":{"style":"color:red"},"children":[{"type":"text","value":"copiar"}]},{"type":"text","value":" como solución, lo que hacemos es copiar un array en otro con la capacidad ajustada a lo que queramos, la forma de usarlo es simple:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"copy(destino, origen)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Bastante simple no? Pues veamos un ejemplo y apliquemos un poco de lógica para optimizar el consumo:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"//Creamos dos slices\nslice := []int{1, 2, 3, 4}\ncopia := make([]int, 4)\n\ncopy(copia, slice)\n\nfmt.Println(slice)\nfmt.Println(copia)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como vemos hemos creado un slice con la forma corta, con contenido, y otro vacio con un tamaño y capacidad de 4. Si imprimimos el contenido todo estaría normal, pero un detalle a tener en cuenta es que realmente "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"copy"}]},{"type":"text","value":" tiene en cuenta la capacidad del slice de destino (en este caso copia), como le hemos puesto una capacidad de 4, nos copia todo el contenido. Pongamos un ejemplo si ponemos menos:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"//Si cambiaramos copia con otra longitud\ncopia2 := make([]int, 2)\ncopy(copia2, slice)\nfmt.Println(slice)\nfmt.Println(copia2)\n//Veriamos como solo nos copia 2 elementos, \n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Lo mejor es controlar el tamaño(no la capacidad ojo), del slice origen y usar eso para crear el destino:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"//para no equivocarnos lo ideal seria\ncopia3 := make([]int, len(slice))\ncopy(copia3, slice)\n\nfmt.Println(slice)\nfmt.Println(copia3)\n//Con esto si cambia el tamaño del slice la copia tambien.\n\n//Como buena practica, aunque segun el entorno, es añadir el doble del tamaño a la capacidad\ncopia4 := make([]int, len(slice), len(slice)*2) //O con la capacidad segun el caso\n \ncopy(copia4, slice)\nfmt.Println(slice)\nfmt.Println(copia4)\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Bueno creo que por el momento vamos a dejar los "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"arrays"}]},{"type":"text","value":" y "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"slices"}]},{"type":"text","value":" para continuar con otras cosas, recordar mirar el link "},{"type":"element","tagName":"a","properties":{"href":"https://github.com/golang/go/wiki/SliceTricks"},"children":[{"type":"text","value":"SliceTricks"}]},{"type":"text","value":" y en otro de mis post tengo algo mas de trabajo con arrays: "},{"type":"element","tagName":"a","properties":{"href":"/go-tricks-i-array-contains/"},"children":[{"type":"text","value":"Go Tricks I"}]}]},{"type":"text","value":"\n"},{"type":"comment","value":"kg-card-end: markdown"}],"data":{"quirksMode":false}},"tableOfContents":[{"id":"recorrerunarrayoslice","heading":"Recorrer un array o slice"},{"id":"separandounarray","heading":"Separando un array"},{"id":"tamaoycapacidad","heading":"Tamaño y Capacidad"},{"id":"aadir","heading":"Añadir"},{"id":"eliminar","heading":"Eliminar"},{"id":"copiarspanstylecolorredimportantespan","heading":"Copiar(Importante)"}]},"featureImageSharp":{"base":"Untitled-3.png","publicURL":"/static/4c2a69b59a578389653f7d3cb966f439/Untitled-3.png","imageMeta":{"width":649,"height":244},"childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAICAYAAAD5nd/tAAAACXBIWXMAAAsTAAALEwEAmpwYAAABr0lEQVQoz22RPWhTURiGP+29N/eec3/aK1FjI9RBm3aSSBVBDVSzOGpwiMEhKopmsCnYyUVQwS5WxKU6iGBwdOrQqZOD+EO1HYo/mCBtySSC6+O5CQVjHF7ecw7veb6Xc0RrTa8USnV9S57ZZ2LF3rTqeBwqhiIf3++X9AO3YN11AlfGx7KKyTGX4nhXx/YJg9pGZBuOYxs5WJbVC1QdQBfm6oAwCnl+wWFixDMXPbZbGjulicx58dQko6MHKBQK5HK5jvL5/D8NDcz3NQOO4khGaJSElxXh4knFiaMZTh/22b/HwbYdpms1zpVKTNXrlMtlKpUK1Wq1v2ECVdrHPVPi+N0pns2eZ/7FNFdeP+FVY4a5xzfZcf8BA9fr7B4eZjCKSKfTZLNZ4jj+D9B1CXbuQu495OzaBt/ffWJh5RvF5m9azTbrq2tMfN1E5uZRQYhn8q7nkUql8Iz3ApN2QUAggly6xsjndRY32zz68J6Dtcs8ffuG280NrC9trOpVfJPTYdjzoX1vmEzVJmjfmEFaP5HlJoeWllhuzFJYXEA+tpAfv7Bu3enkkrz6i/EHdxf7UmCHE+cAAAAASUVORK5CYII=","aspectRatio":2.6515151515151514,"src":"/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-3.png","srcSet":"/static/4c2a69b59a578389653f7d3cb966f439/847ef/Untitled-3.png 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/91cba/Untitled-3.png 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-3.png 649w","srcWebp":"/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-3.webp","srcSetWebp":"/static/4c2a69b59a578389653f7d3cb966f439/9fca7/Untitled-3.webp 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/37a4e/Untitled-3.webp 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-3.webp 649w","sizes":"(max-width: 649px) 100vw, 649px"}}}}},{"node":{"id":"Ghost__Post__5a338158333e0f134c248f14","title":"Go Tricks (I): Array contains","slug":"go-tricks-i-array-contains","featured":false,"feature_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Untitled-2.png","excerpt":"Comienzo sección nueva, en este caso son pequeños post que trataran sobre algún\ntruco para trabajar con Go, como todo existen varias formas de hacer, estas\nserán solo algunas posibles no siempre serán las mejores pero seguro que\nfuncionan ;)\n\nEn este primer post vamos a ver como comprobar si un elemento existe dentro de\nun array(o slice), lo veremos con strings pero puede ser con cualquier\ntipo(primitivo por lo menos)\n\nComo sabemos no tenemos forma directa en Go de comprobar si algo existe dentr","custom_excerpt":null,"visibility":"public","created_at_pretty":"12 Jul 2017","published_at_pretty":"13 Jul 2017","updated_at_pretty":"11 Oct 2017","created_at":"2017-07-12T21:09:31.000+02:00","published_at":"2017-07-13T11:00:34.000+02:00","updated_at":"2017-10-11T13:45:36.000+02:00","meta_title":null,"meta_description":null,"og_description":null,"og_image":null,"og_title":null,"twitter_description":null,"twitter_image":null,"twitter_title":null,"authors":[{"slug":"jlgarcia","url":"https://jlgarcia.fulldev.ninja/author/jlgarcia/","name":"Juan Luis Garcia Aparicio","bio":null,"cover_image":null,"profile_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/12/Perfil.jpg","location":null,"website":null,"twitter":null,"facebook":null,"meta_title":null,"meta_description":null,"coverImageSharp":null,"profileImageSharp":null}],"primary_author":{"slug":"jlgarcia","url":"https://jlgarcia.fulldev.ninja/author/jlgarcia/","name":"Juan Luis Garcia Aparicio","bio":null,"cover_image":null,"profile_image":"https://jlgarcia.fulldev.ninja/assets/images/2017/12/Perfil.jpg","location":null,"website":null,"twitter":null,"facebook":null,"meta_title":null,"meta_description":null,"coverImageSharp":null,"profileImageSharp":{"base":"Perfil.jpg","publicURL":"/static/b0de6281fb28a266510b3b09b9243e5a/Perfil.jpg","imageMeta":{"width":307,"height":307},"childImageSharp":{"fluid":{"base64":"data:image/jpeg;base64,/9j/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wgARCAAUABQDASIAAhEBAxEB/8QAGAABAQEBAQAAAAAAAAAAAAAAAAUDBAb/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAGzw6zC6zHn+cLYP//EAB0QAAICAQUAAAAAAAAAAAAAAAEDAAIEEyEiIzL/2gAIAQEAAQUCifca8KgcKWVfUpkHsG5pxX//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAEDAQE/AR//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAECAQE/AR//xAAdEAACAgEFAAAAAAAAAAAAAAAAARARcQISIUFR/9oACAEBAAY/AhU88xkb7N06a8P/xAAcEAEAAwEAAwEAAAAAAAAAAAABABEhMUFRYXH/2gAIAQEAAT8hR2pq40aqb+xIAeXibhW9JXr8joF4TBcSNe0//9oADAMBAAIAAwAAABDzDwD/xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAEDAQE/EB//xAAUEQEAAAAAAAAAAAAAAAAAAAAg/9oACAECAQE/EB//xAAcEAEAAgIDAQAAAAAAAAAAAAABABEhUTFhcfD/2gAIAQEAAT8QyItrELaTlatLwU63MvEW6vUNdy4LZQDn7iVApV9VLtANdWwKkuYq4Er1VZ//2Q==","aspectRatio":1,"src":"/static/b0de6281fb28a266510b3b09b9243e5a/31709/Perfil.jpg","srcSet":"/static/b0de6281fb28a266510b3b09b9243e5a/f340b/Perfil.jpg 28w,\n/static/b0de6281fb28a266510b3b09b9243e5a/22d64/Perfil.jpg 55w,\n/static/b0de6281fb28a266510b3b09b9243e5a/31709/Perfil.jpg 110w,\n/static/b0de6281fb28a266510b3b09b9243e5a/aa249/Perfil.jpg 165w,\n/static/b0de6281fb28a266510b3b09b9243e5a/0dc33/Perfil.jpg 220w,\n/static/b0de6281fb28a266510b3b09b9243e5a/60667/Perfil.jpg 307w","srcWebp":"/static/b0de6281fb28a266510b3b09b9243e5a/8678c/Perfil.webp","srcSetWebp":"/static/b0de6281fb28a266510b3b09b9243e5a/59cda/Perfil.webp 28w,\n/static/b0de6281fb28a266510b3b09b9243e5a/7da75/Perfil.webp 55w,\n/static/b0de6281fb28a266510b3b09b9243e5a/8678c/Perfil.webp 110w,\n/static/b0de6281fb28a266510b3b09b9243e5a/f282e/Perfil.webp 165w,\n/static/b0de6281fb28a266510b3b09b9243e5a/a7b21/Perfil.webp 220w,\n/static/b0de6281fb28a266510b3b09b9243e5a/f59af/Perfil.webp 307w","sizes":"(max-width: 110px) 100vw, 110px"}}}},"primary_tag":{"slug":"go","url":"https://jlgarcia.fulldev.ninja/tag/go/","name":"Go","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null},"tags":[{"slug":"go","url":"https://jlgarcia.fulldev.ninja/tag/go/","name":"Go","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null},{"slug":"golang","url":"https://jlgarcia.fulldev.ninja/tag/golang/","name":"Golang","visibility":"public","feature_image":null,"description":null,"meta_title":"Golang Ninjas","meta_description":"Aprenderemos a usar el nuevo lenguaje de Google para backend desde lo más básico a temas avanzados como concurrencia o api rest.","featureImageSharp":null}],"plaintext":"Comienzo sección nueva, en este caso son pequeños post que trataran sobre algún\ntruco para trabajar con Go, como todo existen varias formas de hacer, estas\nserán solo algunas posibles no siempre serán las mejores pero seguro que\nfuncionan ;)\n\nEn este primer post vamos a ver como comprobar si un elemento existe dentro de\nun array(o slice), lo veremos con strings pero puede ser con cualquier\ntipo(primitivo por lo menos)\n\nComo sabemos no tenemos forma directa en Go de comprobar si algo existe dentro\nde un array por lo que debemos implementarlo nosotros.\nUna forma de hacerlo es la habitual de recorrer el array e ir comprobando pero\nrealmente tenemos un par de formas(mínimo) más que yo creo que pueden ser más\neficientes, aunque siempre depende del caso concreto.\n\nPrimera:\nVeamos una típica recorriendo el array\n\nlist := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nfor _, v := range list {\n if v == \"b\" {\t\t\t\t\t\n fmt.Println(\"Existe\")\n break\n }\n}\n\n\nMétodo bastante sencillo, recorremos el array y comprobamos si es lo que\nbuscamos, en cuanto lo encuetre salimos del for. Es bastante rápido la verdad.\n\nSegunda:\nlist := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\n\nfor _, v := range list {\n set[v] = true\n}\n\nfmt.Println(set[\"b\"])\n\n\nTenemos una array de strings desordenado, lo que hacemos es crear un map(lo que\nseria un diccionario en otros lenguajes), de clave=valor donde la clave es el\ncontenido del array, y como valor le he puesto true, para que cuando comprobemos\nque existe muestre un true(aunque eso pasaria con todos), es un poquito de\nazuquitar visual que hemos puesto. Realmente nos pasaria lo mismo si intentamos\nasignar el valor de forma corta, como tal recordar que los maps al asignarlos a\notra variable nueva devuelven realmente 2 valores, el contenido del map y si\nexiste o no.\n\nComo veis bastante sencillo, tenemos un for si o si pero es bastante rápido.\nFijaos que le he puesto el último valor con la idea de que al final haremos\npruebas de cuanto tarda cada uno.\n\nTercera:\nlist := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nsort.Strings(list)\ni := sort.SearchStrings(list, \"b\")\n\nfmt.Println(list[i] == \"b\")\n\n\nLo primero que hacemos es ordenar el array y luego nos valemos del método \nSearchStrings(tiene search de todo) que tiene el objeto sort, le pasamos el\narray y lo que queremos buscar y nos devuelve la posición en la que se\nencuentra. A continuación comprobamos si el array tiene en la posición recibida\nel string que buscamos y voilá.\nOJO!! Hacemos la comprobación de list[i] == \"b\" porque el método SearchStrings\ndevuelve la posición donde deberiamos insertar el elemento en el caso de que no\nexista para que este ordenado directamente al añadirlo\n\nEsta forma a mi me gusta más pero en grandes cantidades de datos realmente\ntendriamos que probar su eficienca\n\nPruebas VERSUS\nVamos a ver la diferencia de lo que tarda cada uno, esto no es del todo válido\nya que depende de muchos factores pero es solo por ver lo que podria ser un\nacercamiento.\nVamos a crear un bucle rápido con cada tipo, que nos muestre el tiempo que ha\ntardado, pondremos unas 50 ejecuciones de cada uno para ver un poco la media,\npero siempre tener en cuenta que afecta la cantidad de código que tengamos un\nsimple Print puede alterar los valores:\n\nPrimer método\nj := 0\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \n\"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\t\nfor _, v := range list {\n if v == \"b\" {\n //Aqui podriamos hacer que muestre true o algo asi\n \tbreak\n }\n}\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n\n\nSeguiremos la misma linea para los 3, creamos una especie de bucle while en el\nque cuando sea 50 la variable j se salga de la funcion.\nEsta nos daria algo parecido a esto:\n\nLa primera ejecución tarda un poco mas y luego se mantiene, muy rápido no??(el\narray es muy pequeño jejejejje)\n\nSegundo método:\nj := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\nfor _, v := range list {\n set[v] = true\n}\n_ = set[\"b\"]\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n\n\nNos da unos tiempos de este estilo\n\nBien aqui vemos que hemos bastante mas lentos en comparación, le he puesto el _\n= set[\"b\"] para simular que haciamos algo para comprobar.\nEste método tiene una ventaja, y es que si queremos buscar algo más ya lo\ntenemos en el map set. Como desventaja es que posiblemente consumamos recursos\ninnecesariamente.\n\nTercer Método:\nj := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\n sort.Strings(list)\n i := sort.SearchStrings(list, \"b\")\n _ = (list[i] == \"b\")\n fmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n\n\nY con este ultimo obtenemos:\n\nVemos que es más rápido que el segundo pero menos que el primero. Como tal con\neste método si tenemos que realizar otra búsqueda como ya estaria ordenado seria\nmás rápida, he probado y salen unos tiempos como estos:\n\nComo veis llegamos a los nanosegundos, que no esta mal.\n\nAl final todo esto es orientativo, siempre dependerá del entorno y la cantidad\nde elementos que tenga el array. Es bastante probable que la primera forma sea\nla más rápida en la mayoría de los entornos pero al final deberemos valorarlo en\nel momento. También es cierto que es más fácil crearnos un método de utilidad\ncon la primera opción que con el resto, podríamos generalizar usando interface o\ncualquier cosa que se nos ocurra. Siendo esto bastante útil si pensamos en la\nconcurrencia como Go funciona con copias de elementos(a no ser que usemos\npunteros) no tendríamos \"condiciones de carrera\"(race conditions) a la hora de\nacceder a los elementos.\n\nEspero que os haya parecido interesante, nos vemos en el siguiente NINJA POST :)\n\nP.D: Para el que no sepa lo que es el race condition, básicamente es la\nposibilidad de que se este accediendo al mismo elemento y al mismo tiempo, lo\nque generaría varios problemas(cosa que en Go si trabajamos con copias no\ntendríamos)","html":"Comienzo sección nueva, en este caso son pequeños post que trataran sobre algún truco para trabajar con Go, como todo existen varias formas de hacer, estas serán solo algunas posibles no siempre serán las mejores pero seguro que funcionan ;)
\nEn este primer post vamos a ver como comprobar si un elemento existe dentro de un array(o slice), lo veremos con strings pero puede ser con cualquier tipo(primitivo por lo menos)
\nComo sabemos no tenemos forma directa en Go de comprobar si algo existe dentro de un array por lo que debemos implementarlo nosotros.
\nUna forma de hacerlo es la habitual de recorrer el array e ir comprobando pero realmente tenemos un par de formas(mínimo) más que yo creo que pueden ser más eficientes, aunque siempre depende del caso concreto.
Veamos una típica recorriendo el array
\nlist := []string{"a", "z", "j", "f", "i", "v", "r", "c", "l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\nfor _, v := range list {\n if v == "b" {\t\t\t\t\t\n fmt.Println("Existe")\n break\n }\n}\nMétodo bastante sencillo, recorremos el array y comprobamos si es lo que buscamos, en cuanto lo encuetre salimos del for. Es bastante rápido la verdad.
\nlist := []string{"a", "x", "z", "j", "f", "i", "v", "r", "c", "l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\nset := make(map[string]bool)\n\nfor _, v := range list {\n set[v] = true\n}\n\nfmt.Println(set["b"])\nTenemos una array de strings desordenado, lo que hacemos es crear un map(lo que seria un diccionario en otros lenguajes), de clave=valor donde la clave es el contenido del array, y como valor le he puesto true, para que cuando comprobemos que existe muestre un true(aunque eso pasaria con todos), es un poquito de azuquitar visual que hemos puesto. Realmente nos pasaria lo mismo si intentamos asignar el valor de forma corta, como tal recordar que los maps al asignarlos a otra variable nueva devuelven realmente 2 valores, el contenido del map y si existe o no.
\nComo veis bastante sencillo, tenemos un for si o si pero es bastante rápido. Fijaos que le he puesto el último valor con la idea de que al final haremos pruebas de cuanto tarda cada uno.
\nlist := []string{"a", "x", "z", "j", "f", "i", "v", "r", "c", "l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\nsort.Strings(list)\ni := sort.SearchStrings(list, "b")\n\nfmt.Println(list[i] == "b")\nLo primero que hacemos es ordenar el array y luego nos valemos del método SearchStrings(tiene search de todo) que tiene el objeto sort, le pasamos el array y lo que queremos buscar y nos devuelve la posición en la que se encuentra. A continuación comprobamos si el array tiene en la posición recibida el string que buscamos y voilá.
\nOJO!! Hacemos la comprobación de list[i] == "b" porque el método SearchStrings devuelve la posición donde deberiamos insertar el elemento en el caso de que no exista para que este ordenado directamente al añadirlo
Esta forma a mi me gusta más pero en grandes cantidades de datos realmente tendriamos que probar su eficienca
\nVamos a ver la diferencia de lo que tarda cada uno, esto no es del todo válido ya que depende de muchos factores pero es solo por ver lo que podria ser un acercamiento.
\nVamos a crear un bucle rápido con cada tipo, que nos muestre el tiempo que ha tardado, pondremos unas 50 ejecuciones de cada uno para ver un poco la media, pero siempre tener en cuenta que afecta la cantidad de código que tengamos un simple Print puede alterar los valores:
j := 0\nfor {\n t1 := time.Now()\n list := []string{"a", "z", "j", "f", "i", "v", "r", "c", \n"l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\t\nfor _, v := range list {\n if v == "b" {\n //Aqui podriamos hacer que muestre true o algo asi\n \tbreak\n }\n}\n\nfmt.Println("Tiempo total: ", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nSeguiremos la misma linea para los 3, creamos una especie de bucle while en el que cuando sea 50 la variable j se salga de la funcion.
\nEsta nos daria algo parecido a esto:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.07.51.png\")
\nLa primera ejecución tarda un poco mas y luego se mantiene, muy rápido no??(el array es muy pequeño jejejejje)
j := 0\n\nfor {\n t1 := time.Now()\n list := []string{"a", "z", "j", "f", "i", "v", "r", "c", "l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\nset := make(map[string]bool)\nfor _, v := range list {\n set[v] = true\n}\n_ = set["b"]\n\nfmt.Println("Tiempo total: ", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nNos da unos tiempos de este estilo
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.12.25.png\")
\nBien aqui vemos que hemos bastante mas lentos en comparación, le he puesto el _ = set["b"] para simular que haciamos algo para comprobar.
\nEste método tiene una ventaja, y es que si queremos buscar algo más ya lo tenemos en el map set. Como desventaja es que posiblemente consumamos recursos innecesariamente.
j := 0\n\nfor {\n t1 := time.Now()\n list := []string{"a", "z", "j", "f", "i", "v", "r", "c", "l", "p", "h", "w", "k", "e", "u", "s", "b"}\n\n sort.Strings(list)\n i := sort.SearchStrings(list, "b")\n _ = (list[i] == "b")\n fmt.Println("Tiempo total: ", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nY con este ultimo obtenemos:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.18.12.png\")
\nVemos que es más rápido que el segundo pero menos que el primero. Como tal con este método si tenemos que realizar otra búsqueda como ya estaria ordenado seria más rápida, he probado y salen unos tiempos como estos:
\n![\"\"](\"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.20.45.png\")
\nComo veis llegamos a los nanosegundos, que no esta mal.
Al final todo esto es orientativo, siempre dependerá del entorno y la cantidad de elementos que tenga el array. Es bastante probable que la primera forma sea la más rápida en la mayoría de los entornos pero al final deberemos valorarlo en el momento. También es cierto que es más fácil crearnos un método de utilidad con la primera opción que con el resto, podríamos generalizar usando interface o cualquier cosa que se nos ocurra. Siendo esto bastante útil si pensamos en la concurrencia como Go funciona con copias de elementos(a no ser que usemos punteros) no tendríamos "condiciones de carrera"(race conditions) a la hora de acceder a los elementos.
\nEspero que os haya parecido interesante, nos vemos en el siguiente NINJA POST :)
\nP.D: Para el que no sepa lo que es el race condition, básicamente es la posibilidad de que se este accediendo al mismo elemento y al mismo tiempo, lo que generaría varios problemas(cosa que en Go si trabajamos con copias no tendríamos)
\n","url":"https://jlgarcia.fulldev.ninja/go-tricks-i-array-contains/","canonical_url":null,"uuid":"5cb27cd0-996d-4bc8-ae3c-d717d236f9a6","codeinjection_foot":null,"codeinjection_head":null,"codeinjection_styles":null,"comment_id":"32","reading_time":6,"send_email_when_published":false,"email_subject":null,"childHtmlRehype":{"html":"Comienzo sección nueva, en este caso son pequeños post que trataran sobre algún truco para trabajar con Go, como todo existen varias formas de hacer, estas serán solo algunas posibles no siempre serán las mejores pero seguro que funcionan ;)
\nEn este primer post vamos a ver como comprobar si un elemento existe dentro de un array(o slice), lo veremos con strings pero puede ser con cualquier tipo(primitivo por lo menos)
\nComo sabemos no tenemos forma directa en Go de comprobar si algo existe dentro de un array por lo que debemos implementarlo nosotros.
\nUna forma de hacerlo es la habitual de recorrer el array e ir comprobando pero realmente tenemos un par de formas(mínimo) más que yo creo que pueden ser más eficientes, aunque siempre depende del caso concreto.
Veamos una típica recorriendo el array
\nlist := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nfor _, v := range list {\n if v == \"b\" {\t\t\t\t\t\n fmt.Println(\"Existe\")\n break\n }\n}\nMétodo bastante sencillo, recorremos el array y comprobamos si es lo que buscamos, en cuanto lo encuetre salimos del for. Es bastante rápido la verdad.
\nlist := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\n\nfor _, v := range list {\n set[v] = true\n}\n\nfmt.Println(set[\"b\"])\nTenemos una array de strings desordenado, lo que hacemos es crear un map(lo que seria un diccionario en otros lenguajes), de clave=valor donde la clave es el contenido del array, y como valor le he puesto true, para que cuando comprobemos que existe muestre un true(aunque eso pasaria con todos), es un poquito de azuquitar visual que hemos puesto. Realmente nos pasaria lo mismo si intentamos asignar el valor de forma corta, como tal recordar que los maps al asignarlos a otra variable nueva devuelven realmente 2 valores, el contenido del map y si existe o no.
\nComo veis bastante sencillo, tenemos un for si o si pero es bastante rápido. Fijaos que le he puesto el último valor con la idea de que al final haremos pruebas de cuanto tarda cada uno.
\nlist := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nsort.Strings(list)\ni := sort.SearchStrings(list, \"b\")\n\nfmt.Println(list[i] == \"b\")\nLo primero que hacemos es ordenar el array y luego nos valemos del método SearchStrings(tiene search de todo) que tiene el objeto sort, le pasamos el array y lo que queremos buscar y nos devuelve la posición en la que se encuentra. A continuación comprobamos si el array tiene en la posición recibida el string que buscamos y voilá.
\nOJO!! Hacemos la comprobación de list[i] == \"b\" porque el método SearchStrings devuelve la posición donde deberiamos insertar el elemento en el caso de que no exista para que este ordenado directamente al añadirlo
Esta forma a mi me gusta más pero en grandes cantidades de datos realmente tendriamos que probar su eficienca
\nVamos a ver la diferencia de lo que tarda cada uno, esto no es del todo válido ya que depende de muchos factores pero es solo por ver lo que podria ser un acercamiento.
\nVamos a crear un bucle rápido con cada tipo, que nos muestre el tiempo que ha tardado, pondremos unas 50 ejecuciones de cada uno para ver un poco la media, pero siempre tener en cuenta que afecta la cantidad de código que tengamos un simple Print puede alterar los valores:
j := 0\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \n\"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\t\nfor _, v := range list {\n if v == \"b\" {\n //Aqui podriamos hacer que muestre true o algo asi\n \tbreak\n }\n}\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nSeguiremos la misma linea para los 3, creamos una especie de bucle while en el que cuando sea 50 la variable j se salga de la funcion.
\nEsta nos daria algo parecido a esto:
\n
\nLa primera ejecución tarda un poco mas y luego se mantiene, muy rápido no??(el array es muy pequeño jejejejje)
j := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\nfor _, v := range list {\n set[v] = true\n}\n_ = set[\"b\"]\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nNos da unos tiempos de este estilo
\n
\nBien aqui vemos que hemos bastante mas lentos en comparación, le he puesto el _ = set[\"b\"] para simular que haciamos algo para comprobar.
\nEste método tiene una ventaja, y es que si queremos buscar algo más ya lo tenemos en el map set. Como desventaja es que posiblemente consumamos recursos innecesariamente.
j := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\n sort.Strings(list)\n i := sort.SearchStrings(list, \"b\")\n _ = (list[i] == \"b\")\n fmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\nY con este ultimo obtenemos:
\n
\nVemos que es más rápido que el segundo pero menos que el primero. Como tal con este método si tenemos que realizar otra búsqueda como ya estaria ordenado seria más rápida, he probado y salen unos tiempos como estos:
\n
\nComo veis llegamos a los nanosegundos, que no esta mal.
Al final todo esto es orientativo, siempre dependerá del entorno y la cantidad de elementos que tenga el array. Es bastante probable que la primera forma sea la más rápida en la mayoría de los entornos pero al final deberemos valorarlo en el momento. También es cierto que es más fácil crearnos un método de utilidad con la primera opción que con el resto, podríamos generalizar usando interface o cualquier cosa que se nos ocurra. Siendo esto bastante útil si pensamos en la concurrencia como Go funciona con copias de elementos(a no ser que usemos punteros) no tendríamos \"condiciones de carrera\"(race conditions) a la hora de acceder a los elementos.
\nEspero que os haya parecido interesante, nos vemos en el siguiente NINJA POST :)
\nP.D: Para el que no sepa lo que es el race condition, básicamente es la posibilidad de que se este accediendo al mismo elemento y al mismo tiempo, lo que generaría varios problemas(cosa que en Go si trabajamos con copias no tendríamos)
\n","htmlAst":{"type":"root","children":[{"type":"comment","value":"kg-card-begin: markdown"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Comienzo sección nueva, en este caso son pequeños post que trataran sobre algún truco para trabajar con Go, como todo existen varias formas de hacer, estas serán solo algunas posibles no siempre serán las mejores pero seguro que funcionan ;)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"En este primer post vamos a ver como comprobar si un elemento existe dentro de un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"array(o slice)"}]},{"type":"text","value":", lo veremos con strings pero puede ser con cualquier tipo(primitivo por lo menos)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como sabemos no tenemos forma directa en Go de comprobar si algo existe dentro de un array por lo que debemos implementarlo nosotros."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nUna forma de hacerlo es la habitual de recorrer el array e ir comprobando pero realmente tenemos un par de formas(mínimo) más que yo creo que pueden ser más eficientes, aunque siempre depende del caso concreto."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"primera"},"children":[{"type":"text","value":"Primera:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Veamos una típica recorriendo el array"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nfor _, v := range list {\n if v == \"b\" {\t\t\t\t\t\n fmt.Println(\"Existe\")\n break\n }\n}\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Método bastante sencillo, recorremos el array y comprobamos si es lo que buscamos, en cuanto lo encuetre salimos del for. Es bastante rápido la verdad."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"segunda"},"children":[{"type":"text","value":"Segunda:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"list := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\n\nfor _, v := range list {\n set[v] = true\n}\n\nfmt.Println(set[\"b\"])\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Tenemos una array de strings desordenado, lo que hacemos es crear un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"map"}]},{"type":"text","value":"(lo que seria un diccionario en otros lenguajes), de clave=valor donde la clave es el contenido del array, y como valor le he puesto true, para que cuando comprobemos que existe muestre un "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"true"}]},{"type":"text","value":"(aunque eso pasaria con todos), es un poquito de azuquitar visual que hemos puesto. Realmente nos pasaria lo mismo si intentamos asignar el valor de forma corta, como tal recordar que los maps al asignarlos a otra variable nueva devuelven realmente 2 valores, el contenido del map y si existe o no."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Como veis bastante sencillo, tenemos un for si o si pero es bastante rápido. Fijaos que le he puesto el último valor con la idea de que al final haremos pruebas de cuanto tarda cada uno."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"tercera"},"children":[{"type":"text","value":"Tercera:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"list := []string{\"a\", \"x\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nsort.Strings(list)\ni := sort.SearchStrings(list, \"b\")\n\nfmt.Println(list[i] == \"b\")\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Lo primero que hacemos es ordenar el array y luego nos valemos del método "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"SearchStrings"}]},{"type":"text","value":"(tiene search de todo) que tiene el objeto sort, le pasamos el array y lo que queremos buscar y nos devuelve la posición en la que se encuentra. A continuación comprobamos si el array tiene en la posición recibida el string que buscamos y voilá."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"OJO!! Hacemos la comprobación de list[i] == \"b\" porque el método SearchStrings devuelve la posición donde deberiamos insertar el elemento en el caso de que no exista para que este ordenado directamente al añadirlo"}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Esta forma a mi me gusta más pero en grandes cantidades de datos realmente tendriamos que probar su eficienca"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h2","properties":{"id":"pruebasversus"},"children":[{"type":"text","value":"Pruebas VERSUS"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Vamos a ver la diferencia de lo que tarda cada uno, esto no es del todo válido ya que depende de muchos factores pero es solo por ver lo que podria ser un acercamiento."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nVamos a crear un bucle rápido con cada tipo, que nos muestre el tiempo que ha tardado, pondremos unas 50 ejecuciones de cada uno para ver un poco la media, pero siempre tener en cuenta que afecta la cantidad de código que tengamos un simple "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"Print"}]},{"type":"text","value":" puede alterar los valores:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"primermtodo"},"children":[{"type":"text","value":"Primer método"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"j := 0\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \n\"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\t\nfor _, v := range list {\n if v == \"b\" {\n //Aqui podriamos hacer que muestre true o algo asi\n \tbreak\n }\n}\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Seguiremos la misma linea para los 3, creamos una especie de bucle while en el que cuando sea 50 la variable "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"j"}]},{"type":"text","value":" se salga de la funcion."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nEsta nos daria algo parecido a esto:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.07.51.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nLa primera ejecución tarda un poco mas y luego se mantiene, muy rápido no??(el array es muy pequeño jejejejje)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"segundomtodo"},"children":[{"type":"text","value":"Segundo método:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"j := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\nset := make(map[string]bool)\nfor _, v := range list {\n set[v] = true\n}\n_ = set[\"b\"]\n\nfmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Nos da unos tiempos de este estilo"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.12.25.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nBien aqui vemos que hemos bastante mas lentos en comparación, le he puesto el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"_ = set[\"b\"]"}]},{"type":"text","value":" para simular que haciamos algo para comprobar."},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nEste método tiene una ventaja, y es que si queremos buscar algo más ya lo tenemos en el "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"map"}]},{"type":"text","value":" set. Como desventaja es que posiblemente consumamos recursos innecesariamente."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"h3","properties":{"id":"tercermtodo"},"children":[{"type":"text","value":"Tercer Método:"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"div","properties":{"className":["kg-card","kg-code-card","gatsby-highlight"],"dataLanguage":"text"},"children":[{"type":"element","tagName":"pre","properties":{"className":["language-text"]},"children":[{"type":"element","tagName":"code","properties":{"className":["language-text"]},"children":[{"type":"text","value":"j := 0\n\nfor {\n t1 := time.Now()\n list := []string{\"a\", \"z\", \"j\", \"f\", \"i\", \"v\", \"r\", \"c\", \"l\", \"p\", \"h\", \"w\", \"k\", \"e\", \"u\", \"s\", \"b\"}\n\n sort.Strings(list)\n i := sort.SearchStrings(list, \"b\")\n _ = (list[i] == \"b\")\n fmt.Println(\"Tiempo total: \", time.Since(t1))\n\nif j == 50 {\n break\n}\nj++\n"}]}]}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Y con este ultimo obtenemos:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.18.12.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nVemos que es más rápido que el segundo pero menos que el primero. Como tal con este método si tenemos que realizar otra búsqueda como ya estaria ordenado seria más rápida, he probado y salen unos tiempos como estos:"},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\n"},{"type":"element","tagName":"img","properties":{"src":"https://jlgarcia.fulldev.ninja/assets/images/2017/07/Screen-Shot-2017-07-13-at-09.20.45.png","alt":""},"children":[]},{"type":"element","tagName":"br","properties":{},"children":[]},{"type":"text","value":"\nComo veis llegamos a los nanosegundos, que no esta mal."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Al final todo esto es orientativo, siempre dependerá del entorno y la cantidad de elementos que tenga el array. Es bastante probable que la primera forma sea la más rápida en la mayoría de los entornos pero al final deberemos valorarlo en el momento. También es cierto que es más fácil crearnos un método de utilidad con la primera opción que con el resto, podríamos generalizar usando "},{"type":"element","tagName":"strong","properties":{},"children":[{"type":"text","value":"interface"}]},{"type":"text","value":" o cualquier cosa que se nos ocurra. Siendo esto bastante útil si pensamos en la concurrencia como Go funciona con copias de elementos(a no ser que usemos punteros) no tendríamos "},{"type":"element","tagName":"em","properties":{},"children":[{"type":"text","value":"\"condiciones de carrera\""}]},{"type":"text","value":"(race conditions) a la hora de acceder a los elementos."}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"Espero que os haya parecido interesante, nos vemos en el siguiente NINJA POST :)"}]},{"type":"text","value":"\n"},{"type":"element","tagName":"p","properties":{},"children":[{"type":"text","value":"P.D: Para el que no sepa lo que es el race condition, básicamente es la posibilidad de que se este accediendo al mismo elemento y al mismo tiempo, lo que generaría varios problemas(cosa que en Go si trabajamos con copias no tendríamos)"}]},{"type":"text","value":"\n"},{"type":"comment","value":"kg-card-end: markdown"}],"data":{"quirksMode":false}},"tableOfContents":[{"id":"primera","heading":"Primera:"},{"id":"segunda","heading":"Segunda:"},{"id":"tercera","heading":"Tercera:"},{"id":"pruebasversus","heading":"Pruebas VERSUS","items":[{"id":"primermtodo","heading":"Primer método"},{"id":"segundomtodo","heading":"Segundo método:"},{"id":"tercermtodo","heading":"Tercer Método:"}]}]},"featureImageSharp":{"base":"Untitled-2.png","publicURL":"/static/4c2a69b59a578389653f7d3cb966f439/Untitled-2.png","imageMeta":{"width":649,"height":244},"childImageSharp":{"fluid":{"base64":"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAAICAYAAAD5nd/tAAAACXBIWXMAAAsTAAALEwEAmpwYAAABr0lEQVQoz22RPWhTURiGP+29N/eec3/aK1FjI9RBm3aSSBVBDVSzOGpwiMEhKopmsCnYyUVQwS5WxKU6iGBwdOrQqZOD+EO1HYo/mCBtySSC6+O5CQVjHF7ecw7veb6Xc0RrTa8USnV9S57ZZ2LF3rTqeBwqhiIf3++X9AO3YN11AlfGx7KKyTGX4nhXx/YJg9pGZBuOYxs5WJbVC1QdQBfm6oAwCnl+wWFixDMXPbZbGjulicx58dQko6MHKBQK5HK5jvL5/D8NDcz3NQOO4khGaJSElxXh4knFiaMZTh/22b/HwbYdpms1zpVKTNXrlMtlKpUK1Wq1v2ECVdrHPVPi+N0pns2eZ/7FNFdeP+FVY4a5xzfZcf8BA9fr7B4eZjCKSKfTZLNZ4jj+D9B1CXbuQu495OzaBt/ffWJh5RvF5m9azTbrq2tMfN1E5uZRQYhn8q7nkUql8Iz3ApN2QUAggly6xsjndRY32zz68J6Dtcs8ffuG280NrC9trOpVfJPTYdjzoX1vmEzVJmjfmEFaP5HlJoeWllhuzFJYXEA+tpAfv7Bu3enkkrz6i/EHdxf7UmCHE+cAAAAASUVORK5CYII=","aspectRatio":2.6515151515151514,"src":"/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-2.png","srcSet":"/static/4c2a69b59a578389653f7d3cb966f439/847ef/Untitled-2.png 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/91cba/Untitled-2.png 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/d382d/Untitled-2.png 649w","srcWebp":"/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-2.webp","srcSetWebp":"/static/4c2a69b59a578389653f7d3cb966f439/9fca7/Untitled-2.webp 175w,\n/static/4c2a69b59a578389653f7d3cb966f439/37a4e/Untitled-2.webp 350w,\n/static/4c2a69b59a578389653f7d3cb966f439/10386/Untitled-2.webp 649w","sizes":"(max-width: 649px) 100vw, 649px"}}}}}]}},"pageContext":{"slug":"go-go-power-ra-go-parte-2-el-lenguaje-variables-tipos-primitivos","prev":"go-go-power-ra-ah-que-no-go-parte-3-arrays-y-slices-i","next":"go-go-power-ra-ah-que-no-go-parte1-intro-y-preparacion","tag":"go","limit":3,"skip":0,"primaryTagCount":6,"collectionPaths":{}}}, "staticQueryHashes": ["1272700106","1676991999","2138873178","2546165603","2681841279","2938721187","293880488","3052966952","4156497161"]}