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.

Variables y Constantes

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

Vamos 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.
Los 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:

var power int
var rangerName string

Un 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:

package main

import "fmt"

func main() {

  var power int
  var rangerName string

  fmt.Println("Power ranger red power: ", power)
  fmt.Println("Power ranger red name: ", rangerName)

}


El int es 0 y el string esta vacio.

Es posible tambien declarar varias variables del mismo tipo en la misma linea

var power,speed int

Las variables es posible iniciarlas una vez que son declaradas(tambien si hemos declarado varias en la misma linea)

var power, speed int = 100,70

Si imprimimos con:

	fmt.Println("Power ranger red power: ", power)
	fmt.Println("Power ranger red speed: ", speed)


Como 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
speed := 70
#Tambien podemos declarar varias a la vez
stamina, swordsSkill := 50, 80
# Y es posible usar distintos tipos en la misma declaración
megazordSkill, rangerName := 1000,"Scott"
## Realmente tambien infiere el tipo si inicializamos al declarar una variable
var power = 100 seria igual que lo de arriba

Si os fijais en la ultima declaración tenemos un int y un string, pues si imprimimos:

fmt.Println("Power ranger red power: ", power)
fmt.Println("Power ranger red speed: ", speed)
fmt.Println("Power ranger red stamina: ", stamina)
fmt.Println("Power ranger red swordsSkill: ", swordsSkill)
fmt.Println("Power ranger red megazordSkill: ", megazordSkill)
fmt.Println("Power ranger red name: ", rangerName)

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:

const hello = "Hello World"
const hello string = "Hello World"

Trabajar con distintos tipos

Go no traduce entre tipos como otros lenguajes, por lo que tenemos que hacerlo nosotros, si probamos con este ejemplo:

jump := 60
gravityForce := 9.8
fmt.Println(v / p * 2)

Tendriamos este error:

Como el error indica tenemos que igualar los tipos:

fmt.Println(float64(jump) / gravityForce * 2)

Esto 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).
Para 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)

Variables Privadas y Públicas

En Go existe el concepto de variables públicas y privadas, las privadas solo son visibles en el fichero donde estan.
La diferencia está en la declaración, si las declaramos con la primera letra en mayúsculas o en minusculas:

  • Minúsculas = Privada
  • Mayúsculas = Pública

Veamos un ejemplo:

Creemos una estructura de ficheros similar a esta donde tengamos el root del proyecto como comentamos en el post anterior:

Como 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:

package rangerModel

var power int
var speed int

Como vemos he puesto el nombre del paquete donde esta alojado para diferenciarlo del main.
En el main.go:

package main

import (
	"vuestroRootPath/rangerModel"
	"fmt"
)

func main() {
	power := rangerModel.power
	fmt.Println("Power ranger red power:", power)
}

Si guardamos ambos, vemos como nos da un error al instanciar el power del rangerModel:

Como tal no tenemos acceso a la variable o propiedad power de rangerModel.
Ahora vamos a cambiar el power por Power en el modelo, quedando de esta manera(de paso le ponemos un valor):

package rangerModel

var Power = 100
var speed int

Y lo mismo en el main:

func main() {
	power := rangerModel.Power
	fmt.Println("Power ranger red power:", power)
}

Ahora si imprimimos:

Es 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:

Por el momento dejamos aquí las variables básicas, más adelante seguiremos trabajando con ellas.
Nos vemos en el siguiente