Go conceptos básicos con ejemplos

By | 11/24/2017

Una de las cosas que más me gustan de Go es su simplicidad de código y su rapidez tanto en el aprendizaje como en su ejecución.

Te explico los conceptos básicos de Go para iniciarte en este lenguaje. Go es un lenguaje simple de aprender y si ya conoces cualquier otro lenguaje en pocas horas puedes asimilar su semántica.

Estas son las sintaxis iniciales que deberías comprender, con ejemplos muy simples, para iniciarte en Go.

Go Variables

¿Como crear variables en Golang?

La palabra reservada para crear variables en Golang es “var” a continuación va el nombre de la variable y le sigue el tipo.

var hello string = "hello word"

Puedes declarar múltiples variables para el mismo tipo

var hello1, hello2, hello3 string = "hello word"

En golang todas las variables tienen siempre un valor predefinido

var s string
fmt.Println(s=="") // imprime "true"
var i int
fmt.Println(i==0) // imprime "true

Golang cuenta con tipado dinámico por lo que es capaz de inferir el tipo de dato

i := 123  // entero
name := "Gustavo" // string

Ejemplos de variables:

package main

import "fmt"

func main() {

	// var string
	var hello string = "hello word"
	fmt.Println(hello)

	// var int
	var age int = 30;
	fmt.Println("Age ", age);

	// var float
	var fb float64 = 30.12345678901234567890;
	fmt.Println("Float fb ", fb);

	// multiple assignations
	var hi, word string = "hi", "word"
	fmt.Println(hi, word)

	// default value of variable int
	var defaultInt int
	fmt.Println("Value of defaultInt", defaultInt)

	// default value of boolean
	var defaultBoolean bool
	fmt.Println("Value of defaultBoolean", defaultBoolean)

	// short variable declarations
	great := "great work";
	fmt.Println(great);

	// type inference
	var b = true
	fmt.Println("Value of b", b)

}
$ go run variables.go
hello word
Age  30
Float fb  30.123456789012344
hi word
Value of defaultInt 0
Value of defaultBoolean false
great work
Value of b true

Go constantes

¿Cómo crear constantes en Golang?

En golang puedes crear constantes usando la palabra reservada “const”.

const s string = "hello"

Aquí van algunos ejemplos de uso de constantes:

package main

import "fmt"

// declare constant
const (
	MaxAge = 30
	MinAge = 15
)

func main() {

	// declare constant
	const months = 12

	// use constant
	var age int = 30
	fmt.Println("Age in months ", months * age);

	// use constant
	fmt.Println("Max age", MaxAge)
	fmt.Println("Min Age", MinAge)

}

$ go run constant.go
Age in months  360
Max age 30
Min Age 15

Go Arreglos

¿Cómo crear arreglos en golang?

En golang un array tiene esta forma.

var i [5]int

Primero el keyword var, luego el nombre de la variable y la cantidad de elementos para el tipo definido. Los arreglos tienen un tamaño predefinido y no es posible redimensionarlos, una vez creado el arreglo con su tamaño este conserva su dimensión y no es factible cambiarlo en tiempo de ejecución.

package main

import "fmt"

func main() {

	var a [2]string
	a[0] = "Hello"
	a[1] = "World"
	fmt.Println("Position 0 ", a[0])
	fmt.Println("Values of a", a)

	// array with assignment
	fibonacci := [11]int{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55}
	fmt.Println("Values of fibonacci", fibonacci)

	// array with 3 position and two assignment
	array := [3]int{0, 1}
	fmt.Println("Values of array", array)


	// array multi-dimensional
	var twoDimensionArray [2][3]int
	twoDimensionArray[0][0] = 1
	twoDimensionArray[0][1] = 2
	twoDimensionArray[0][2] = 3

	twoDimensionArray[1][0] = 4
	twoDimensionArray[1][1] = 5
	twoDimensionArray[1][2] = 6

	fmt.Println("Values of twoDimensionArray", twoDimensionArray)

}

Position 0  Hello
Values of a [Hello World]
Values of fibonacci [0 1 1 2 3 5 8 13 21 34 55]
Values of array [0 1 0]
Values of twoDimensionArray [[1 2 3] [4 5 6]]

Go Slices

¿Qué son los Slices en Golang?

Los slices podemos pensarlos como “tipo de arreglo” pero de tamaño dinámicos. A diferencia de los arreglos que no puedes redimensionar, los slices sí es factible cambiarlos en tamaño.

En un arreglo debes declarar el tamaño de antemano, en cambio un slice lo defines de esta forma:

var colors []string

Observa que no hemos indicado el tamaño.

package main

import "fmt"

func main() {

	// slide without data
	var colors []string
	fmt.Println("Colors without data", colors)

	colors = append(colors, "red")
	fmt.Println("Colors data", colors)

	// slice
	cities := []string{"buenos aires", "sao paulo", "new york"}
	fmt.Println("Cities", cities)

	// slice using make
	m := make([]int, 5)
	fmt.Printf("Slice m - lenght=%d capacity=%d values %v", len(m), cap(m), m)
	fmt.Println()

	mc := make([]int, 0, 5)
	fmt.Printf("Slice mc - lenght=%d capacity=%d values %v", len(mc), cap(mc), mc)
	fmt.Println()

}

..

$ go run slices.go
Colors without data []
Colors data [red]
Cities [buenos aires sao paulo new york]
Slice m - lenght=5 capacity=5 values [0 0 0 0 0]
Slice mc - lenght=0 capacity=5 values []

Go For

¿Cómo crear un for en Golang?

Go maneja los ciclos de manera muy simple en vista de que tiene solo un tipo de ciclo definido por el loop “for”.

El loop “for” en Golang luce parecido al “for” en java o en “C” con la diferencia de que no usas paréntesis y son requeridas las llaves {}

El for en Golang se compone de
-Inicialización de la variable
-La condición por la cual el loop continua su ejecución o no.
-Una instrucción que se ejecuta en cada iteración

package main

import "fmt"

func main() {

	// for
	for i := 0; i < 5; i++ {
		fmt.Println(i)
	}

	// for continued
	sum := 1
	for ; sum < 100; {
		sum += sum
	}
	fmt.Println("sum", sum)

	// for like while
	sumb := 1
	for sumb < 1000 {
		sumb += sumb
	}
	fmt.Println("sumb", sumb)

	// infinite for
	x := 0
	for {
		// do something in a loop and break manually
		x++
		if (x >= 10) {
			fmt.Println("infite loop break")
			break
		}
	}
}

$ go run for.go
0
1
2
3
4
sum 128
sumb 1024
infite loop break

Go Range

¿Qué es un Range en Golang?

En Golang “range” te permite iterar los elementos de distintas estructuras de datos. Por ejemplo puedes usar “range” para iterar un arreglo, un slice, un map, una cadena de texto.

package main

import "fmt"

func main() {

	// create array and range from this array
	var numbers = []int{2, 4, 6, 8}
	for i, v := range numbers {
		fmt.Println("index of array", i, "value or array", v)
	}

	// create slice and range from this slice
	nums := []int{2, 4, 6}
	sum := 0
	for i, v := range nums {
		sum += v
		fmt.Println("index of slice", i, "sum", sum)
	}

	// create a map and range from this map
	fruits := map[string]string{"o": "orange", "b": "banana"}
	for k, v := range fruits {
		fmt.Println("key of map", k, "value of map", v)
	}

	// create string and range from this string
	s := "golan hello word"
	for i, c := range s {
		fmt.Println("index of character", i, "character", string(c))
	}

}

$ go run range.go
index of array 0 value or array 2
index of array 1 value or array 4
index of array 2 value or array 6
index of array 3 value or array 8
index of slice 0 sum 2
index of slice 1 sum 6
index of slice 2 sum 12
key of map o value of map orange
key of map b value of map banana
index of character 0 character g
index of character 1 character o
index of character 2 character l
index of character 3 character a
index of character 4 character n
index of character 5 character  
index of character 6 character h
index of character 7 character e
index of character 8 character l
index of character 9 character l
index of character 10 character o
index of character 11 character  
index of character 12 character w
index of character 13 character o
index of character 14 character r
index of character 15 character d

Go If/Else

¿Cómo usar if/else en Golang

En Go para las declaraciones “if” no son requeridos los paréntesis (), pero si son obligatorias las llaves {}.

package main

import (
	"fmt"
)

func main() {

	// common if statement
	s := "hi"
	if s == "hi" {
		fmt.Println("Hello")
	} else if s == "bye" {
		fmt.Println("See you")
	} else {
		fmt.Println("How’s it going")
	}

	// if statement with operation
	x := 10
	n := 180
	if v := x + n; v <= 100 {
		fmt.Println("value is less or equal than 100 ", v)
	} else if v <= 200 {
		fmt.Println("value is less or equal than 200 ", v)
	} else {
		fmt.Println("the value is greater than 200", v)
	}

	// if without else
	i := 8
	j := 4
	if i % j == 0 {
		fmt.Println("It is divisible")
	}
}

$ go run ifelse.go
Hello
value is less or equal than 200  190
It is divisible

Go Switch

¿Cómo usar Switch en Golang?

Switch es otro control condicional que te permite controlar el flujo de tu código.

Observa que en Golang para el switch no es necesario agregar break como sucede por ejemplo en Java. El break esta implicito. Puedes agregar opcionalmente “default” para que en el caso de que ninguna condición se cumpla. Además, es posible comparar más de un valor en un “case”.

package main

import (
	"fmt"
	"time"
)

func main() {

	// basic switch - 'break' it is not necessary
	value := 4
	switch value {
	case 1:
		fmt.Println("value is one")
	case 2:
		fmt.Println("value is two")
	case 3:
		fmt.Println("value is three")
	case 4, 5:
		fmt.Println("value is four or five")
	default:
		fmt.Println("I do not recognize the value")
	}

	// switch without condition, like if
	t := time.Now()
	switch {
	case t.Hour() < 12:
		fmt.Println("Good morning!")
	case t.Hour() < 17:
		fmt.Println("Good afternoon")
	default:
		fmt.Println("Go home")
	}
}

$ go run switch.go
value is four or five
Good afternoon

Go Maps

¿Cómo crear Mapas en Golang?

Al igual que en otros lenguajes un mapa relaciona un key con un valor.
Así creas un mapa en Golang con un key entero que represente un id, y un valor que represente un el nombre de un producto:

// map literal
var x = map[int]string{
      1: "coffee",
      2: "te",
      3: "chocolate",
}

// adding more elements
x[4] = "cappuccino"
fmt.Println("key value of map x", x)


// retrieve one element
product := x[2]
fmt.Println("Product of key 2", product)

// delete element
delete(x, 2)

// check if element exist
element, okExist := x[1]
if(okExist) {
      fmt.Println("Element with id 1 is",element)
}

key value of map x map[1:coffee 2:te 3:chocolate 4:cappuccino]
Product of key 2 te
Element with id 1 is coffee

Para crear un map vacío en Golang usas la función make

// create a map using make
m := make(map[string]string)
m["key1"] = "value1"
m["key2"] = "value2"
fmt.Println("key value of map m", m)
key value of map m map[key1:value1 key2:value2]

Go Funciones

¿Cómo crear funciones en Golang

En Golang las funciones pueden recibir cero o más argumentos y retornar cualquier cantidad de elementos acordes al tipo.

package main

import "fmt"

// function receive two arg and return one
func plus(a int, b int) int {
      return a + b
}

// function receive two arg and return two
func hello(h string, w string) (string, string) {
      return h, w
}

func main() {
      fmt.Println("plus", plus(2, 6))
      fmt.Println(hello("hello", "golang"))
}

La salida de estas funciones

$ go run functions.go
plus 8
hello golang

Go Structs (estructuras)

¿Qué son y cómo crear structs en Golang?

Un Struct en Golang define una estructura de fields / campos. Si vienes de Java lo puedes pensar como una clase que no permite herencia pero que sí permite composición. El acceso a los campos es directo desde el struct, es decir, no requieres getters y setters.

package main

import "fmt"

type User struct {
      Name     string
      LastName string
}

func main() {

      u := User{"Albert", "Einstein"}
      fmt.Println(u)

      fmt.Println(u.Name, "was a genius");
}
$ go run structs.go
{Albert Einstein}
Albert was a genius

Go Métodos

¿Cómo se escribe un método en Golang?

En Golang un método es un tipo de función con un receptor definido como argumento.
Observa que a diferencia de las funciones comunes este receptor va entre el keyword “func” y el nombre del método.

Por ejemplo, si tienes un Struct User que representa un usuario

type User struct {
	Name     string
	LastName string
}

puedes definir un método cuyo receptor sea ese User

func (u User) CheckGenius() bool {
      return u.Name == "Albert"
}

que luego debes usar de este modo

func main() {

	u := User{"Albert", "Einstein"}


	// using method throw User.CheckGenius
	fmt.Println("Method CheckGenius", u.Name, u.CheckGenius())


}


Así queda el código, en Golang escribes este método afuera del Struct.

package main

import "fmt"

type User struct {
      Name     string
      LastName string
}

// this is a method
func (u User) CheckGenius() bool {
      return u.Name == "Albert"
}

// this is a common function
func CheckGenius(u User) bool {
      return u.Name == "Albert"
}

func main() {

      u := User{"Albert", "Einstein"}

      // using method throw User.CheckGenius
      fmt.Println("Method CheckGenius", u.Name, u.CheckGenius())

      // using a common function
      fmt.Println("Function CheckGenius", CheckGenius(u))

}

Go Imports

¿Cómo importas en Go?

Para importar en Go puedes hacerlo agrupado o linea por linea

Import linea por linea

package main

import "fmt"
import "time"

Import agrupado (recomendado).

package main

import (
	"fmt"
	"time"
)

func main() {
	h, m, s := time.Now().Clock()
	fmt.Println("Hour: ", h)
	fmt.Println("Minute: ", m)
	fmt.Println("Second: ", s)
}
$ go run imports.go
Hour:  13
Minute:  20
Second:  48

Go Packages

¿Cómo organiza Go sus archivos?

Go organiza sus programas en paquetes y se inicia su ejecución en el package main

package main

func main() {
      print("Hola, Mundo!")
}
$ go run packages.go
Hola, Mundo!

Go, por convención, usa como nombre de package el último elemento de la ruta de los import.

Por ejemplo, si importamos el paquete “math / rand”, esto incluye todos los archivos que se encuentran en el paquete rand.

package main

import (
	"fmt"
	"math/rand"
)

func main() {
	fmt.Println("Random number", rand.Intn(10))
}

Referencias:
Estos ejemplos están basados en la excelente Guia oficial de Go

Compartir esto:

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *