comacero_apuntes/content/posts/notes_general/notes_golang.md

---
weight: 4
title: "Apuntes del lenguaje de programación Go"
date: 2021-05-18T09:55:41+0200
draft: false
summary: "Apuntes de Go"
categories:
  - notes
tags:
  - golang
  - programacion
---

{{< admonition type=warning title="Work in progress" open=true >}}

Apuntes incompletos del lenguaje de programación Go

{{< /admonition >}}



## Referencias

- [Documentación Oficial](https://godoc.org/)
- [CodeReviewComments](https://github.com/golang/go/wiki/CodeReviewComments)
- [Golang 101 hacks](https://nanxiao.gitbooks.io/golang-101-hacks/content/)
- [Un video curso de Traversy Media](http://www.tonvid.com/info.php?video_id=SqrbIlUwR0U)
- [Un video curso de 7 horas de freeCodeCamp](http://www.tonvid.com/info.php?video_id=YS4e4q9oBaU)
- [Go Workshop Book](https://subscription.packtpub.com/book/ppprogramming/9781838647940)
- [Awesome Go](https://awesome-go.com/)
- [Golang by example: All design patterns in Go](https://golangbyexample.com/all-design-patterns-golang/)
- [Design Patters](https://refactoring.guru/design-patterns/go) (lo mismo pero con más dibujitos)
- [Go Modules](https://go.dev/blog/using-go-modules)
- [Build a web app in Golang](https://astaxie.gitbooks.io/build-web-application-with-golang/content/en/01.1.html)

### Books
- Esencia del lenguaje Go: ["The Go Programming Language" Addison-Wesley](https://www.amazon.es/dp/0134190440/ref=cm_sw_r_cp_apa_fabc_7-7WFbSZRP6WG)
- Panorámica del go-stdlib: ["Mastering Go" Packt Publishing; 2nd Revised edition](https://www.amazon.es/dp/1838559337/ref=cm_sw_r_u_apa_i_DB8VXX0DNT6NPRMRAMHJ)

## Instalación

- Bajamos el paquete con la última versión desde la [página oficial](https://go.dev/dl/).
- Y lo descomprimimos como root en `/usr/local/`

```bash
cd ~/tmp/go
wget https://go.dev/dl/go1.17.5.linux-amd64.tar.gz
sudo cp /usr/local/go /usr/local/go.bkp
sudo tar -C /usr/local -xvzf go1.17.4.linux-amd64.tar.gz
```

Después de instalar es importante ajustar las rutas en `.profile` (ver la explicación en el siguiente punto):

```bash
# golang
if [ -d "/usr/local/go" ] ; then
#    export GOROOT="/usr/local/go"
#    PATH="$PATH:$GOROOT/bin"
fi
if [ -d "$HOME/go" ] ; then
    export GOPATH="$HOME/go"
    PATH="$PATH:$GOPATH/bin"
fi

export PATH
```

{{< admonition type=danger title="GOROOT" open=true >}}

Varios autores ([un ejemplo](https://dave.cheney.net/2013/06/14/you-dont-need-to-set-goroot-really)) recomiendan **NO** establecer el valor de `GOROOT` cuando usamos la localización estándar. Así que he comentado esa parte en mi fichero `~/.profile`

{{< /admonition >}}



### Configuración del entorno de Go

{{< admonition type=info title="Referencias" open=false >}}
- [Golang Doc: gopath_code](https://golang.org/doc/gopath_code)
- [Golang Enviroment Configuration](https://www.metaltoad.com/blog/golang-environment-configuration)
- [Build a Web Application with Golang](https://astaxie.gitbooks.io/build-web-application-with-golang/content/en/01.0.html)
{{< /admonition >}}

Para dejar configurado el entorno de trabajo en _Go_ conviene conocer las siguientes variables de entorno (aunque hay [más](https://golang.org/doc/)):

**GOROOT**

: Es el directorio donde se localiza la biblioteca estándar de _Go_. Por defecto _Go_ asume la ruta `/usr/local/go`, así que estrictamente hablando **NO** es necesario establecer esta variable si has instalado en `/usr/local`. (Con [retoques de esta variable](https://golang.org/doc/manage-install) es posible instalar varias versiones de _Go_)

**GOBIN**

: Es el directorio donde quedan instalados los binarios de _Go_ cuando ejecutamos un comando `go install ...`. Solo deberías tocar esta variable si no quieres instalar los binarios en la localización por defecto: `$GOPATH/bin`.

**GOOS**

: especifica el sistema operativo, es opcional. En mi caso tiene valor `linux`

**GOARCH**

: especifica la arquitectura del procesador de nuestra máquina, también es opcional, en mi caso es `amd64`

**GOPATH**

: La ruta a nuestro directorio de trabajo (nuestro _workspace_). Esta variable es **obligatoria** y **no tiene valor por defecto**, podeis ponerla en donde tenga sentido para vosotros, por ejemplo `/home/salvari/code/go`

Evidentemente tenemos que dejar las variables de entorno exportadas y añadir al `PATH` de nuestro usuario las que correspondan (ver punto anterior)

{{< admonition type=tip title="Ver el entorno" open=true >}}

Puedes ver el entorno completo de Go con el comando `go env`

{{< /admonition >}}


#### Más de GOPATH

{{< admonition type=warning title="Abandonando GOPATH" open=true >}}

Estamos usando ya go 1.17. Hay planes firmes para abandonar el tratamiento de dependencias via `GOPATH` y centrarse exclusivamente en gestionarlas a través de módulos.

Todo lo que comento aquí de `GOPATH` hay que tratarlo con pinzas.

{{< /admonition >}}


_Go_ espera que en el directorio `$GOPATH` haya tres subdirectorios:

```bash
bin/
pkg/
src/
```

- `bin/` contiene los ejecutables que se generan cuando ejecutamos `go install ...`
- `pkg/` contiene los paquetes instalados en nuestro sistema con `go get ...`
- `src/` **aquí es donde deberíamos alojar nuestro código fuente** (no es obligatorio)

Como hemos dicho en `$GOPATH/src/` es donde tenemos que programar, ahí es donde tiene que estar nuestro código fuente, pero ojo la ruta exacta de nuestros proyectos es función de nuestra plataforma de control de código, y tiene que tener la forma `Source-Control-Platform/User/Repository`.

Por ejemplo podríamos tener los siguientes proyectos en el directorio `src/`:
```bash
src/github.com/salvari/miAppGo
src/gilab.com/salvari/mach5
```

### Instalación de herramientas

#### _golint_ y _godoc_

**Ya no** instalamos con los comandos:

```bash
go get -u golang.org/x/lint/golint
go get -u  golang.org/x/tools/cmd/godoc
```

El comando `go get` se usa exclusivamente para añadir dependencias al módulo que estemos creando.

Los binarios que queremos usar en nuestro sistema se instalan con el nuevo estilo de instalación [recomendado](https://go.dev/doc/go-get-install-deprecation) desde go v1.17:

```bash
go install golang.org/x/lint/golint@latest
go install golang.org/x/tools/cmd/godoc@latest
```

Alternativamente podemos instalar **todas** las herramientas de _Go_ con:

```bash
go get -u golang.org/x/tools/...
```

Pero con esta opción me falla la instalación de `gopls`, una herramienta que necesito en mi configuración de _Emacs_

#### _gopls_ para protocolos LSP en editores

Desde un directorio **que no sea el GOPATH**

```bash
# GO111MODULE=on  # not needed with 'go install'
go install golang.org/x/tools/gopls@latest
```

#### Herramientas adicionales

-  gopkgs
-  go-outline
-  dlv
-  dlv-dap
-  staticcheck

```bash
go install github.com/uudashr/gopkgs/v2/cmd/gopkgs@latest
go install github.com/ramya-rao-a/go-outline@latest
go install github.com/go-delve/delve/cmd/dlv@latest
go install github.com/go-delve/delve/cmd/dlv@master
go install honnef.co/go/tools/cmd/staticcheck@latest
go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
```

### Alias para zsh

```zsh
# golang aliases
alias gob='go build'        # Build your code
alias goc='go clean'        # Removes object files from package source directories
alias god='go doc'          # Prints documentation comments
alias gof='go fmt'          # Gofmt formats (aligns and indents) Go programs.
alias gofa='go fmt ./...'   # Run go fmt for all packages in current directory, recursively
alias gog='go get'          # Downloads packages and then installs them to $GOPATH
alias goi='go install'      # Compiles and installs packages to $GOPATH
alias gol='go list'         # Lists Go packages
alias gom='go mod'          # Access to operations on modules
alias gop='cd $GOPATH'      # Takes you to $GOPATH
alias gopb='cd $GOPATH/bin' # Takes you to $GOPATH/bin
alias gops='cd $GOPATH/src' # Takes you to $GOPATH/src
alias gor='go run'          # Compiles and runs your code
alias got='go test'         # Runs tests
alias gov='go vet'          # Vet examines Go source code and reports suspicious constructs
```

## Go Modules

Básicamente un módulo (_Go Module_) es una colección de paquetes (_packages_) almacenados en un arbol de directorios que tiene un fichero `go.mod` en su raiz. El fichero `go.mod` especifica el _module path_ que es la ruta canónica al módulo que se usará para importarlo, y todas las depencias requeridas por el módulo, es decir el conjunto de módulos (otros módulos) que serán necesarios para compilar con éxito este módulo. Cada dependencia se especifica con su correspondiente _module path_ y un número de versión semántica (_semantic version_)

### Crear un módulo

El comando para crear un módulo es: `go mod init`

Antiguamente el compilador distinguía dos formas de funcionamiento, el _go module mode_ y el _gopath mode_. A estas alturas tenemos que usar el _go module mode_ el otro está en desuso. De hecho el compilador ahora funciona en _go module mode_ por defecto.

Si estamos en un directorio por debajo del `$GOPATH` nuestro directorio de proyecto debería tener esta forma:

```bash
$GOPATH/src/example.com/$USER/moduleName
```

En este caso el comando `go mod init` no necesita parámetros, genera un _module path_ basado en la estructura de directorios.

Si estamos trabajando en un directorio fuera del `$GOPATH` tendremos que especificar el _module path_ en el comando:

```bash
go mod init example.com/modulename
```

### Actualizar el fichero `.mod`

Ejecutamos: `go mod tidy`


## TDD (_Test Drived Development_) en Go

{{< admonition type=info title="Referencias" open=true >}}

- [Learn Go with Tests](https://quii.gitbook.io/learn-go-with-tests/) Un buen sitio para empezar
- [An introduction to Testing in Go](https://tube.cthd.icu/watch?v=GlA57dHa5Rg) Un video muy ilustrativo
- [Advanced Testing in Go](https://tube.cthd.icu/watch?v=S1O0XI0scOM) Continuación del anterior


{{< /admonition >}}

TDD es una buena práctica:
- Mejora la calidad del código
- En general hace que escribamos un código más desacoplado (tiendes a aislar más las cosas para facilitar los test)
- Tiene la ventaja obvia de tener todo controlado con test fáciles de repetir
- Bien escritos valen como documentación de bajo nivel
- Previene regresiones (fallos que reaparecen al avanzar en el desarrollo)
- Potencia la arquitectura y diseño modulares

### Tres reglas ###

Se suele hablar del ciclo: ""rojo, verde y refactorizar" (_red, green and refactor_)

- Primero hay que escribir un test que falla
- Hay que programar lo justo para que el test no falle. No se puede escribir más código que el necesario para que el test no falle.
- Se revisa el código para refinarlo (tanto el código producto como el código de los test)


Los pasos que nos proponen en la página de _Learn Go with Test_:
- Escribe un test
- Haz lo necesario para que el compilador pase sin errores
- Ejecuta el test, comprueba que falla y que el mensaje de fallo es significativo
- Escribe el código suficiente para que el test no falle
- Refina el código (_Refactor_)

Nos dicen literalmente:

    Este ciclo puede parecer tedioso pero es importante mantenerlo.

    Al hacerlo no solo te aseguras de tener test significativos, sino que aseguras un buen diseño del software respaldado por la seguridad que dan los test.

    Ver fallar el test es un paso importante por qué permite comprobar el mensaje de error (que debe ser significativo) Como desarrollador puede ser muy difícil trabajar con código cuando los mensajes de fallo de los test no dan una idea clara de que está pasando.

    Asegurándote de que los test se ejecutan rápido y estableciendo un entorno de trabajo que facilite escribir los test puedes "entrar en sintonía" y programar de la forma más eficiente posible.

    Si no escribes los test, te verás obligado a comprobar el funcionamiento del código ejecutándolo manualmente, eso rompera tu concentracion y a la larga te hara perder bastante mas tiempo que escribir correctamente los test.

### Sintáxis para test

Escribir un test es como escribir una función pero:
- Tiene que estar en un fichero de la forma `xxx_test.go`
- El nombre de la función que implementa el test tiene que empezar por `Test`
- La función que implementa el test tiene que tener un único argumento: `t *testing.T`
- Para poder usar ese tipo de argumento y otras facilidades de testeo es necesario hacer `import "testing"`


### Código independiente es más fácil de testear ###

En el ejemplo _Hello World_ es mejor escribir una funcion que devuelve la cadena con el saludo que una función que escribe el saludo. Por que así somos independientes de la salida que puede ser por pantalla, por una página web, por un mensaje, escrita, etc. etc. Y de paso es más simple de testear.


## Go

`_`

: Es el _black identifier_ podemos usarlo para pasar de variables que
  no vamos a usar.

  ```golang
  a = "Una cadena"
  for _, r := range a {
      fmt.Println(r)
  }

  ```

`make`

:  Parece que vale para hacer un _alloc_ de memoria.

   ```golang
   counts := make(map[string]int)
   ```

`time`

:  La especificación de formatos tiene su gracia ¬_¬ [ver referencia](https://golang.org/src/time/format.go)

### Arrays

```go
var myArray1 = [3]int            // will be filled with so called
                                 // zero values, for integers: 0

var myArray2 = [5]int{1,2,3,4,5} // number of values between { } can
                                 // not be larger than size (ofc)

var myArray3 = […]int{1,2,3,4}   // the compiler will count the
                                 // array elements for you
```

- [Diferencias entre array y slice](https://gist.github.com/josephspurrier/b5713f9a534afe3cfdd2)
- [The Geek Stuff: Golang Array vs Slice](https://www.thegeekstuff.com/2019/03/golang-slice-examples/)
- [A comprehensive guide on array and slices in Go](https://www.sohamkamani.com/golang/arrays-vs-slices/)
- [Go: Array vs Slices Bonanza](https://medium.com/@marty.stepien/arrays-vs-slices-bonanza-in-golang-fa8d32cd2b7c)
- [Slice Tricks by Ian Lance Taylor](https://github.com/golang/go/wiki/SliceTricks)
- [DigitalOcean: Understanding array and slices in Go](https://www.digitalocean.com/community/tutorials/understanding-arrays-and-slices-in-go)


## Go Cheat Sheet

Copia descarada de [esto](https://github.com/a8m/golang-cheat-sheet)


### Crédito

La mayor parte de lo que se cuenta en esta sección está copiado de [golang-cheat-sheet](https://github.com/a8m/golang-cheat-sheet)

Los créditos originales avisan de que la mayor parte de los ejemplos tomados de [A Tour of Go](http://tour.golang.org/), una excelente introducción al lenguage __Go__


### Go en resumen

* Lenguaje Imperativo
* Tipado estático
* Sintáxis muy similar a la de C (pero con menos paréntesis y sin punto y coma obligatorio) la estructura es parecida a la de Oberon-2
* Compila a código nativo (nada de vm)
* No hay clases, pero tiene _structs_ con métodos
* Interfaces
* No implementa herencia. Hay algo llamado [type embedding](http://golang.org/doc/effective%5Fgo.html#embedding)
* Las Funciones son ciudadanos de primera clase
* Las Funciones pueden devolver múltiples valores
* Tiene _closures_
* Hay Punteros pero sin aritmética de punteros
* La concurrencia es _"Built-in"_ mediante las primitivas: _Goroutines_ y _Channels_

### Sintáxis básica

#### Hello World

Fichero `hello.go`:

```go
package main

import "fmt"

func main() {
    fmt.Println("Hello Go")
}
```

`$ go run hello.go`

### Operadores

#### Aritméticos
|Operador|Descripción|
|--------|-----------|
|`+`|addition|
|`-`|subtraction|
|`*`|multiplication|
|`/`|quotient|
|`%`|remainder|
|`&`|bitwise and|
|`\|`|bitwise or|
|`^`|bitwise xor|
|`&^`|bit clear (and not)|
|`<<`|left shift|
|`>>`|right shift|

#### Comparación
|Operador|Descripción|
|--------|-----------|
|`==`|equal|
|`!=`|not equal|
|`<`|less than|
|`<=`|less than or equal|
|`>`|greater than|
|`>=`|greater than or equal|

#### Lógicos
|Operador|Descripción|
|--------|-----------|
|`&&`|logical and|
|`\|\|`|logical or|
|`!`|logical not|

#### Otros
|Operador|Descripción|
|--------|-----------|
|`&`|address of / create pointer|
|`*`|dereference pointer|
|`<-`|send / receive operator (see 'Channels' below)|

### Declaraciones
__El tipo va después del indentificador de variable__
```go
var foo int                 // declaración sin inicialización
var foo int = 42            // declaración con inicialización
var foo, bar int = 42, 1302 // declaración e inicialización múltiples
var foo = 42                // se omite el tipo, será inferido
foo := 42                   // abreviado, sólo es válido en el cuerpo de las funciones,
                            // el tipo siempre es implícito
const constant = "Esto es una constante"

// iota se puede usar para números que se incrementan, empezando por cero
const (
    _ = iota
    a
    b
    c = 1 << iota
    d
)
    fmt.Println(a, b) // 1 2 (0 is skipped)
    fmt.Println(c, d) // 8 16 (2^3, 2^4)
```

### Funciones

```go
// una función simple
func functionName() {}

// función con parámetros (aquí también va el tipo después de la variable)
func functionName(param1 string, param2 int) {}

// multiples parámetros del mismo tipo
func functionName(param1, param2 int) {}

// podemos especificar el tipo devuelto por la función
func functionName() int {
    return 42
}

// Pueden devolver multiples valores
func returnMulti() (int, string) {
    return 42, "foobar"
}
var x, str = returnMulti()

// si los  valores devueltos tienen nombre no hace falta especificarlos en el Return
func returnMulti2() (n int, s string) {
    n = 42
    s = "foobar"
    // n and s will be returned
    return
}
var x, str = returnMulti2()
```

#### Funciones como valores y _closures_

```go
func main() {
    // asignar una función a una variable
    add := func(a, b int) int {
        return a + b
    }
    // usar el nombre para llamar a la función
    fmt.Println(add(3, 4))
}

// 'Closures', lexically scoped: Las funciones pueden acceder valores que estában dentro del alcance (scope)
// cuando se definió la función

func scope() func() int{
    outer_var := 2
    foo := func() int { return outer_var}
    return foo
}

func another_scope() func() int{
    // won't compile because outer_var and foo not defined in this scope
    outer_var = 444
    return foo
}


// Closures
func outer() (func() int, int) {
    outer_var := 2
    inner := func() int {
        outer_var += 99 // outer_var from outer scope is mutated.
        return outer_var
    }
    inner()
    return inner, outer_var // return inner func and mutated outer_var 101
}
```

#### Variadic Functions

```go
func main() {
	fmt.Println(adder(1, 2, 3)) 	// 6
	fmt.Println(adder(9, 9))	// 18

	nums := []int{10, 20, 30}
	fmt.Println(adder(nums...))	// 60
}

// Usando ... antes del nombre del tipo del último parámetro indicamos que la función acepta cero o mas parámetros de ese tipo
// La función se usa como cualquier otra, excepto que podemos pasar tantos parámetros como queramos del último parámetro definido
func adder(args ...int) int {
	total := 0
	for _, v := range args { // Iterates over the arguments whatever the number.
		total += v
	}
	return total
}
```

### Tipos _Built-in_

```
bool

string

int  int8  int16  int32  int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32 ~= a character (Unicode code point) - very Viking

float32 float64

complex64 complex128
```

### Conversión de tipos

```go
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)

// alternative syntax
i := 42
f := float64(i)
u := uint(f)
```

### Paquetes (_Packages_)

{{< admonition type=info title="Referencias" open=false >}}
* [Golangbot: Go Packages](https://golangbot.com/go-packages/)
* [The Go blog: Using Go Modules](https://blog.golang.org/using-go-modules)
* [How to write Go code with GOPATH](https://golang.org/doc/gopath_code)
{{< /admonition >}}

Las unidades de encapsulado en _Go_ de menor a mayor nivel serían:
- Funciones
- Paquetes
- Módulos

Los paquetes nos permiten organizar los ficheros de código para hacerlos modulares y reutilizables además de facilitar el mantenimiento del software.

* Cada fichero de código _Go_ debe pertenecer a un paquete. La pertenencia se declara con `package` al principio de cada uno de los ficheros fuente, evidentemente un paquete puede "poseer" varios ficheros.
* Los ejecutables están en el paquete `main`. Es un paquete especial.
* Por convención los programas ejecutables (los del paquete `main`) se llaman comandos (_commands_). El resto se llaman simplemente paquetes (_packages_)
* Por convención: <nombre_del_paquete> == último nombre del _import path_ (import path `math/rand` => package `rand`) Lo normal es que todos los ficheros del paquete `rand` se guarden en el directorio `rand/`
* Si el identificador empieza con mayúscula: se exporta el símbolo (será visible desde otros paquetes)
* Si el identificador empieza con minúscula: privado (no será visible desde otros paquetes)

Los **módulos** son coleciones de paquetes. Son imprescindibles para crear nuestros propios paquetes por qué la ruta de nuestros paquetes viene dada por el **módulo**. En cuanto quieras empezar a organizar tu código en paquetes inevitablemente tendrás que crear también **módulos**.

El flujo típico de trabajo para un proyecto estructurado con _Packages_ sería el siguiente:

- Supongamos que nuestro proyecto será un "pomodoro" y que va a gestionar _Timers_ y _Notifications_ (por decir algo)
- Creamos el directorio del proyecto que vamos a llamar `pomodoro`, dentro de ese directorio tendremos el _package main_ con los "comandos".
  ```bash
  mkdir pomodoro
  cd pomodoro
  touch main.go
  ```
- Iniciamos el modulo en la raiz del proyecto
  ```bash
  go mod init pomodoro

  # Aunque lo mas correcto sería iniciarlo como
  go mod init gitlab/salvari/pomodoro
  ```
- Creamos los subdirectorios para los _packages_: `timer` y `notification`. Dentro de los subdirectorios creamos un fichero de código (pueden ser tantos ficheros como queramos)
  ```bash
  mkdir timer
  touch timer/timer.go
  mkdir notification
  touch notification/notification.go
  ```

Tendremos una estructura de directorios:

```bash
pomodoro
├── go.mod
├── main.go
├── notification
│   └── notification.go
└── timer
    └── timer.go
```

El contenido del fichero `go.mod` será (la versión de go depende de lo que tengas instalado):

```go
module pomodoro

go 1.17
```

Cada fichero con extensión `.go` debe empezar **siempre** con la declaración del _package_. En nuestro caso `main.go` declarará `package main` y por ejemplo `notification.go` declarará `package notification`.

Ya tenemos todo estructurado, ahora en nuestros ficheros de código podremos hacer _imports_ de este estilo

```go
import "pomodoro/timer"
import "pomodoro/notification"
```

#### Gestión de dependencias con módulos en Go

<https://go.dev/blog/go116-module-changes>
<https://stackoverflow.com/questions/53368187/go-modules-installing-go-tools/57317864#57317864>


### Control del flujo de programa

#### If

```go
func main() {
	// Basic one
	if x > 10 {
		return x
	} else if x == 10 {
		return 10
	} else {
		return -x
	}

	// You can put one statement before the condition
	if a := b + c; a < 42 {
		return a
	} else {
		return a - 42
	}

	// Type assertion inside if
	var val interface{}
	val = "foo"
	if str, ok := val.(string); ok {
		fmt.Println(str)
	}
}
```

#### Bucles
```go
    // Solo hay bucle `for`, no hay `while`, ni `until`
    for i := 1; i < 10; i++ {
    }
    for ; i < 10;  { // bucle while
    }
    for i < 10  { // se pueden omitir los ; si solo hay una condición
    }
    for { // Si omitimos la condición tenemos un  while (true)
    }

    // Podemos usar use break/continue en el bucle activo
    // o usar break/continue con etiquetas (para bucles más externos)
here:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if i == 0 {
                continue here
            }
            fmt.Println(j)
            if j == 2 {
                break
            }
        }
    }

there:
    for i := 0; i < 2; i++ {
        for j := i + 1; j < 3; j++ {
            if j == 1 {
                continue
            }
            fmt.Println(j)
            if j == 2 {
                break there
            }
        }
    }
```

#### Switch

```go
    // switch statement
    switch operatingSystem {
    case "darwin":
        fmt.Println("Mac OS Hipster")
        // cases break automatically, no fallthrough by default
    case "linux":
        fmt.Println("Linux Geek")
    default:
        // Windows, BSD, ...
        fmt.Println("Other")
    }

    // al igual que con el 'for' y el 'if' podemos tener una sentencia de asignación justo antes de la variable del switch
    switch os := runtime.GOOS; os {
    case "darwin": ...
    }

    // se pueden hacer comparaciones en los casos del switch
    number := 42
    switch {
        case number < 42:
            fmt.Println("Smaller")
        case number == 42:
            fmt.Println("Equal")
        case number > 42:
            fmt.Println("Greater")
    }

    // los casos pueden ser listas de valores separados por comas
    var char byte = '?'
    switch char {
        case ' ', '?', '&', '=', '#', '+', '%':
            fmt.Println("Should escape")
    }
```

### Arrays, Slices, Ranges

#### Arrays

- Tienen longitud fija. Los _arrays_ de longitudes **son tipos diferentes**
- No pueden redimensionarse
- El índice empieza en cero
- Un array **no es un puntero** en Go

```go
var a [10]int // declara un array de enteros (int) con longitud 10. ¡La longitud determina el tipo!
a[3] = 42     // establece el valor de un elemento
i := a[3]     // lee el valor de un elemento

// array literals
var a = [2]int{1, 2}
a := [2]int{1, 2} //shorthand
a := [...]int{1, 2} // elipsis -> El compilador infiere la longitud del array

// no hay paso por referencia
arr1 := arr2  // Se hace una copia
arr1 := &arr2 // Se copia la referencia

// multidimensionales
// var variable_name [SIZE1][SIZE2]…[SIZEN] variable_type

a := [3][4]int{
    {0, 1, 2, 3} , // initializers for row indexed by 0
    {4, 5, 6, 7} , // initializers for row indexed by 1
    {8, 9, 10, 11} // initializers for row indexed by 2}
```

#### Slices

- Un _slice_ es una abstracción apuntando a un array.
- Se pueden crear a partir de un array existente, en caso contrario Go creará el array detrás de las bambalinas
- No se especifica la dimensión
- Realmente un _slice_ son tres datos:
    - Un puntero a la secuencia de datos en memoria
    - Una longitud (_lenght_, `len(a)`) que almacena el número de elementos
    - Una capacidad (_capacity_, `cap(a)`) que es el total de posiciones reservadas en memoria
- Cuando se asigna un _slice_ en realidad se copian esos valores, así que **se copia la referencia**
- Si un _slice_ tiene que crecer el compilador normalmente es conservador y **duplica** la capacidad. Eso implicará re-localizaciones del array subyacente en memoria

```go
var a []int                              // declare a slice - similar to an array, but length is unspecified
var a = []int {1, 2, 3, 4}               // declare and initialize a slice (backed by the array given implicitly)
a := []int{1, 2, 3, 4}                   // shorthand
chars := []string{0:"a", 2:"c", 1: "b"}  // ["a", "b", "c"]


var b = a[lo:hi]	// creates a slice (view of the array) from index lo to hi-1
var b = a[1:4]		// slice from index 1 to 3
var b = a[:3]		// missing low index implies 0
var b = a[3:]		// missing high index implies len(a)
a =  append(a,17,3)	// append items to slice a
c := append(a,b...)	// concatenate slices a and b

// create a slice with make
a = make([]byte, 5, 5)	// first arg length, second capacity
a = make([]byte, 5)	// capacity is optional

// create a slice from an array
x := [3]string{"Лайка", "Белка", "Стрелка"}
s := x[:] // a slice referencing the storage of x
```

#### Operaciones sobre _Arrays_ y _Slices_

`len(a)` devuelve la longitud de un _array_ o _slice_ `a`. Es un _built-in_ no un atributo o método del *array*.

```go
// iterar sobre un array o slice
for i, e := range a {
    // i es el  index, e es el elemento
}

// si no vamos a usar el índice:
for _, e := range a {
    // e es el elemento
}

// si solo queremos usar el índice
for i := range a {
}

// Desde Go 1.4 se puede iterar sin variables:
for range time.Tick(time.Second) {
    // hacer algo cada segundo
}
```

### Maps

- Los mapas (_maps_) son inmutables
- No se garantiza ningún orden

```go
var m map[string]int
m = make(map[string]int)
m["key"] = 42
fmt.Println(m["key"])

delete(m, "key")

elem, ok := m["key"] // test if key "key" is present and retrieve it, if so

// map literal
var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}

// iterate over map content
for key, value := range m {
}

```

### Structs

No hay clases en __Go__, solo _structs_. Las _structs_ pueden tener métodos.

```go
// Una struct es un tipo. También es una colección de campos

// Declaración
type Vertex struct {
    X, Y int
}

// Creación
var v = Vertex{1, 2}
var v = Vertex{X: 1, Y: 2}          // Creación de la struct definiendo sus valores con clave
var v = []Vertex{{1,2},{5,2},{5,5}} // Creación de un slice de structs

// Acceso a miembros de la struct
v.X = 4

// Se pueden declarar métodos sobre structs. La referencia a la struct que recibe el método
// tiene que ir entre la palabra clave 'func' y el nombre del método
// LA ESTRUCTURA SE COPIA EN CADA LLAMADA AL MÉTODO
func (v Vertex) Abs() float64 {
    return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

// Invocando el método
v.Abs()

// Para los métodos que mutan la estructura usamos punteros a esa struct
// como tipos. De esta forma EVITAMOS LA COPIA de la estructura al invocar el método
func (v *Vertex) add(n float64) {
    v.X += n
    v.Y += n
}
```

Tenemos un caso especial con los contructores. Si queremos evitar que se construyan objetos sin usar el constructor:

```go
package matrix

type matrix struct {             // NO EXPORTADO
 ....
}
func NewMatrix(rows, cols int) *matrix {
    m := new(matrix)
    m.rows = rows
    m.cols = cols
    m.elems = make([]float, rows*cols)
    return m
}

```

Como no exportamos la estructura base, solo se pueden construir nuevos objetos a través del constructor.

La función `NewMatrix` puede simplificarse fácilmente:

```go
func NewMatrix(rows, cols, int) *matrix {
    return &matrix{rows, cols, make([]float, rows*cols)}
}
```

{{< admonition type=warning title="structs y exportacion" open=true >}}
Si el nombre de la `struct` o de alguno de sus campos empieza por minúscula **no serán visibles** fuera de la propia `struct`
{{< /admonition >}}

**Anonymous structs:**

Más económicas y seguras que usar: `map[string]interface{}`.

```go
point := struct {
	X, Y int
}{1, 2}
```

### Punteros

```go
p := Vertex{1, 2}  // p es de tipo Vertex
q := &p            // q es un puntero a un Vertex
r := &Vertex{1, 2} // r también es un puntero a un Vertex

// El tipo de un puntero a un Vertex es *Vertex

var s *Vertex = new(Vertex) // new crea un puntero a una nueva instancia de Vertex
```

### Interfaces

- Un _interface_ es una especie de "contrato".
- Dentro del _interface_ especificamos las funciones que tiene que soportar un tipo para satisfacer el _interface_
- El _interface_ nos da una capa extra de abstracción, podemos definir una función que procese o devuelva el "tipo" definido por el _interface_


```go
// declaración
type Awesomizer interface {
    Awesomize() string
}

// los tipos no declaran en ningún sitio implementar un interface
type Foo struct {}

// los tipos que implementan todos los métodos de un interface, satifacen ese interface implicitamente
func (foo Foo) Awesomize() string {
    return "Awesome!"
}
```

### Embedding

There is no subclassing in Go. Instead, there is interface and struct embedding.

```go
// ReadWriter implementations must satisfy both Reader and Writer
type ReadWriter interface {
    Reader
    Writer
}

// Server exposes all the methods that Logger has
type Server struct {
    Host string
    Port int
    *log.Logger
}

// initialize the embedded type the usual way
server := &Server{"localhost", 80, log.New(...)}

// methods implemented on the embedded struct are passed through
server.Log(...) // calls server.Logger.Log(...)

// the field name of the embedded type is its type name (in this case Logger)
var logger *log.Logger = server.Logger
```

### Errores

No hay gestión de excepciones en __Go__. Las funciones que pueden lanzar un _Error_ simplemente devuelven un valor adicional de tipo `Error`.

El _interface_ `Error` tiene esta pinta:
```go
type error interface {
    Error() string
}
```

Una función que puede devolver un error:

```go
func doStuff() (int, error) {
}

func main() {
    result, err := doStuff()
    if err != nil {
        // handle error
    } else {
        // all is good, use result
    }
}
```

### Concurrency

#### Goroutines

Goroutines are lightweight threads (managed by Go, not OS threads). `go f(a, b)` starts a new goroutine which runs `f` (given `f` is a function).

```go
// just a function (which can be later started as a goroutine)
func doStuff(s string) {
}

func main() {
    // using a named function in a goroutine
    go doStuff("foobar")

    // using an anonymous inner function in a goroutine
    go func (x int) {
        // function body goes here
    }(42)
}
```

#### Channels

```go
ch := make(chan int) // create a channel of type int
ch <- 42             // Send a value to the channel ch.
v := <-ch            // Receive a value from ch

// Non-buffered channels block. Read blocks when no value is available, write blocks until there is a read.

// Create a buffered channel. Writing to a buffered channels does not block if less than <buffer size> unread values have been written.
ch := make(chan int, 100)

close(ch) // closes the channel (only sender should close)

// read from channel and test if it has been closed
v, ok := <-ch

// if ok is false, channel has been closed

// Read from channel until it is closed
for i := range ch {
    fmt.Println(i)
}

// select blocks on multiple channel operations, if one unblocks, the corresponding case is executed
func doStuff(channelOut, channelIn chan int) {
    select {
    case channelOut <- 42:
        fmt.Println("We could write to channelOut!")
    case x := <- channelIn:
        fmt.Println("We could read from channelIn")
    case <-time.After(time.Second * 1):
        fmt.Println("timeout")
    }
}
```

##### Channel Axioms

- A send to a nil channel blocks forever

  ```go
  var c chan string
  c <- "Hello, World!"
  // fatal error: all goroutines are asleep - deadlock!
  ```
- A receive from a nil channel blocks forever

  ```go
  var c chan string
  fmt.Println(<-c)
  // fatal error: all goroutines are asleep - deadlock!
  ```
- A send to a closed channel panics

  ```go
  var c = make(chan string, 1)
  c <- "Hello, World!"
  close(c)
  c <- "Hello, Panic!"
  // panic: send on closed channel
  ```
- A receive from a closed channel returns the zero value immediately

  ```go
  var c = make(chan int, 2)
  c <- 1
  c <- 2
  close(c)
  for i := 0; i < 3; i++ {
      fmt.Printf("%d ", <-c)
  }
  // 1 2 0
  ```

### Printing

```go
fmt.Println("Hello, 你好, नमस्ते, Привет, ᎣᏏᏲ") // basic print, plus newline
p := struct { X, Y int }{ 17, 2 }
fmt.Println( "My point:", p, "x coord=", p.X ) // print structs, ints, etc
s := fmt.Sprintln( "My point:", p, "x coord=", p.X ) // print to string variable

fmt.Printf("%d hex:%x bin:%b fp:%f sci:%e",17,17,17,17.0,17.0) // c-ish format
s2 := fmt.Sprintf( "%d %f", 17, 17.0 ) // formatted print to string variable

hellomsg := `
 "Hello" in Chinese is 你好 ('Ni Hao')
 "Hello" in Hindi is नमस्ते ('Namaste')
` // multi-line string literal, using back-tick at beginning and end
```

### Reflection

#### Type Switch

A type switch is like a regular switch statement, but the cases in a type switch specify types (not values), and those values are compared against the type of the value held by the given interface value.

```go
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}

func main() {
	do(21)
	do("hello")
	do(true)
}
```

### Snippets

#### HTTP Server

```go
package main

import (
    "fmt"
    "net/http"
)

// define a type for the response
type Hello struct{}

// let that type implement the ServeHTTP method (defined in interface http.Handler)
func (h Hello) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    fmt.Fprint(w, "Hello!")
}

func main() {
    var h Hello
    http.ListenAndServe("localhost:4000", h)
}

// Here's the method signature of http.ServeHTTP:
// type Handler interface {
//     ServeHTTP(w http.ResponseWriter, r *http.Request)
// }
```


## Misc

* Para ver el entorno usamos `go env`


## TDD con Go

* [TDD with Go](https://leanpub.com/golang-tdd/read)

Para que funcionen correctamente los comandos `go build`, `go clean` y `go test` parece que es necesario haber definido correctamente `go.mod` (con `go mod init`)

`go test` buscará ficheros nombrados como `*_test.go` para ejecutarlos.

Dentro de esos de test habrá bloques funcionales con la firma: `func TestXxxx(t *testing.T)`

Los test fallidos se informan con `t.Errorf`

### Ciclo de test

El ciclo de trabajo se resume en _**Red, Green, Refactor**_.

* Para implementar una nueva funcionalidad el primer paso debe ser escribir los test que capturan los requisitos de esa nueva funcionalidad. Estos test obviamente fallarán (_Red_ o rojo de fallo).
* La segunda fase consiste en implementar el código necesario para cumplir con los test y queden todos en verde (_Green_). El código debe minimizarse para cumplir los test sin "sobreimplementar" nada.
* El último paso es el _refactoring_. **No** implementamos nueva funcionalidad en este paso, se trata simplemente de hacer un código de calidad re-escribiendo el código de la segunda fase. **No** es un paso opcional, es imprescindible revisar el código y garantizar la coherencia y calidad del mismo.

### Vicios en TDD
1. Escribir demasiados test a la vez
2. Concentrarse exclusivamente en los _happy path_ y la cobertura del código
3. No considerar los diferentes escenarios
4. Demasiadas comprobaciones (_asserts_) en un sólo test
5. Probar cosas diferentes en el mismo caso de prueba
6. Escribir test triviales para mantener el código cubierto
7. No ejecutar los test con frecuencia
8. No seguir siempre las tres fases. Especialmente implementando código sin escribir antes el test
9. Hacer _asserts_ que no prueban nada
10. Crear test difíciles de mantener

### Dobles de prueba (_test doubles_)
Una implementación simplificada de algún tipo para facilitar las pruebas

Casos posibles:

_**Dummies**_

:    Tipos sin ningún comportamiento, se implementan únicamente para cumplir con la firma de alguna función que queremos probar

_**Stubs**_ ("breves")

:    Tipos que implementan el comportamiento mínimo para pasar un test

***Mocks*** (parodias)

:    Implementaciones parciales que permiten definir como suponemos que serán los métodos sobre el tipo

***Spies*** (espías)

:    Implementaciones parciales que nos permiten comprobar que métodos han sido invocados

***Fakes*** (falsificaciones)

:    Implementaciones ligeras pero completas, por ejemplo implementar una base de datos en memoria a efectos de pruebas



## Paquetes útiles

### `flag`

Este paquete nos permite leer parámetros pasados en la llamada al programa por linea de comandos.

### `encoding/json`

Este paquete nos permite salvar o recuperar estructuras de datos desde ficheros _json_

{{< admonition type=warning title="Referencias" open=false >}}
* [json con golang](https://golangdocs.com/json-with-golang)
* [read a json file](https://golangdocs.com/golang-read-json-file)
* [Parse json to a nested struct](https://penthaa.medium.com/golang-how-to-parse-json-data-into-a-nested-struct-29be89ce2ae8)
{{< /admonition >}}


**_marshalling_**

: El proceso de codificar nuestra estructura de datos en _json_.

**_unmarshalling_**

: El proceso inverso al anterior para pasar de json a una estructura de datos


#### Arrays y Slices

Podemos codificar en _json_ arrays o slices de _Go_

```go
package main

import (
	"encoding/json"
	"fmt"
)

type Book struct {
	Name   string
	Author string
}

func main() {

	//--------------------------------------------------
	// Marshalling
	book := Book{"C++ programming language", "Bjarne Stroutsrup"}
	my_json, err := json.Marshal(book)

	if err != nil {
		fmt.Println(err)
	}

	fmt.Printf("Json for book is: %s\n", string(my_json)) // {"Name":"C++ programming language","Author":"Bjarne Stroutsrup"}

	//--------------------------------------------------
	// Unmarshalling
	codString := `{"Name":"The Name of the Wind","Author":"Patrick Rothfuss"}`

	var cod Book

	err = json.Unmarshal([]byte(codString), &cod)

	if err != nil {
		fmt.Println(err)
	}

	fmt.Printf("Book for json is: %v\n", cod)

	//--------------------------------------------------
	// Arrays and Slices
	// You can marshall/unmarshall to array or slice

	var books []Book

	booksJson := `[{"Name": "Hacking for Dummies", "Author": "Kevin Beaver"},
                   {"Name": "Kerberos", "Author": "Jason Garman"}]`

	err = json.Unmarshal([]byte(booksJson), &books)

	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("Slice for json is: %v\n", books)

	some_books := []Book{
		{Name: "Libro Uno", Author: "Author Uno"},
		{Name: "Libro Dos", Author: "Author Dos"},
	}

	some_books_json, err := json.Marshal(some_books)

	fmt.Printf("json for slice is: %v\n", string(some_books_json))
}
```

#### Atributos "a medida" para _json_

Podemos añadir atributos _json_ a una `struct` que vamos a leer o a salvar con _json_.

```go
package main

import (
	"encoding/json"
	"fmt"
)

type Book struct {
	Name   string `json:"title"`   // IMPORTANTE: Nada de espacios al definir los atributos
	Author string `json:"artist"`
}

func main() {

	//--------------------------------------------------
	// Marshalling
	book := Book{"C++ programming language", "Bjarne Stroutsrup"}
	my_json, err := json.Marshal(book)

	if err != nil {
		fmt.Println(err)
	}

	fmt.Printf("Json for book is: %s\n", string(my_json)) // {"title":"C++ programming language","artist":"Bjarne Stroutsrup"}
}
```

Además de cambiar los nombres de los campos podemos especificar un par de atributos `json` más:

- `.omitempty`: nos permite saltarnos los datos si el campo está vacio
- `"-"` : nos permite saltarnos este campo por completo

```go
type userdata struct {
        login string `json:"username"`
        real_name string `json:"name, .omitempty"`
        password string `json:"-"`
}
```

#### _json_ y maps

Siempre podemos cargar el _json_ en un `map`, especialmente si no están muy bien estructurados:

```go
package main

import (
    "fmt"
    "encoding/json"
)

func main() {
    unstructuredJson := `{"os": {"Windows": "Windows OS","Mac": "OSX","Linux": "Ubuntu"},"compilers": "gcc"}`

    var result map[string]interface{}

    json.Unmarshal([]byte(unstructuredJson), &result)

    fmt.Println(result["os"])    // map[Linux:Ubuntu Mac:OSX Windows:Windows OS]
}
```

Por supuesto podemos también salvarlos en _json_:

```go
package main

import (
    "fmt"
    "encoding/json"
)

type Address struct {
    Street string
    City string
}

type Person struct {
    Name string
    Address Address
}

func main() {
    p := Person{
        Name: "Sherlock Holmes",
        Address: Address{
            "22/b Baker street",
            "London",
        },
    }

    str, err := json.Marshal(p)

    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(str))  // {"Name":"Sherlock Holmes","Address":{"Street":"22/b Baker street","City":"London"}}
}
```

### `os/exec`

<https://www.darrencoxall.com/golang/executing-commands-in-go/>

Este paquete es parte de la biblioteca estándar de _Go_. Nos permite ejecutar comandos de sistema.

Tres casos típicos:

- Lanzar un comando y capturar su salida
- Lanzar un comando y comprobar el _exit code_
- Lanzar comandos de larga duración

```go
package main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"strings"
	"syscall"
)

// printCommand prints command
func printCommand(cmd *exec.Cmd) {
	fmt.Printf("==> Executing: %s\n", strings.Join(cmd.Args, " "))
}

// printError print human friendly error objects
func printError(err error) {
	if err != nil {
		os.Stderr.WriteString(fmt.Sprintf("==> Error: %s\n", err.Error()))
	}
}

// printOutput prints command output
func printOutput(outs []byte) {
	if len(outs) > 0 {
		fmt.Printf("==> Output: %s\n", string(outs))
	}
}

// main el cuerpo ppal del programa
func main() {
	// Create an *exec.Cmd
	// Capture Stdout and Stderr together
	cmd := exec.Command("echo", "Called from Go!")
	printCommand(cmd)
	output, err := cmd.CombinedOutput() // runs cmd and return combined output
	printError(err)
	printOutput(output) // => go version

	// Create an *exec.Cmd
	cmd = exec.Command("go", "version")

	// Stdout buffer
	cmdOutput := &bytes.Buffer{}
	// Attach buffer to command
	cmd.Stdout = cmdOutput

	// Execute command
	printCommand(cmd)
	err = cmd.Run() // will wait for command to return
	printError(err)
	// Only output the commands stdout
	printOutput(cmdOutput.Bytes())

	// create a command that will fail
	cmd = exec.Command("ls", "/imaginary/dir")
	var waitStatus syscall.WaitStatus
	if err := cmd.Run(); err != nil {
		printError(err)
		// Did the command fail because of an unsuccessful exit code
		if exitError, ok := err.(*exec.ExitError); ok {
			waitStatus = exitError.Sys().(syscall.WaitStatus)
			printOutput([]byte(fmt.Sprintf("%d", waitStatus.ExitStatus())))
		}
	} else {
		// Command was successful
		waitStatus = cmd.ProcessState.Sys().(syscall.WaitStatus)
		printOutput([]byte(fmt.Sprintf("%d", waitStatus.ExitStatus())))
		printOutput(cmdOutput.Bytes())
	}
}
```

Para el último caso _comandos de larga duración_, no queremos que nuestro programa espere al resultado del comando. Es mejor hacerlo de forma asíncrona.

```go
package main

import (
	"bytes"
	"fmt"
	"os"
	"os/exec"
	"time"
)

// printError print human friendly error objects
func printError(err error) {
	if err != nil {
		os.Stderr.WriteString(fmt.Sprintf("==> Error: %s\n", err.Error()))
	}
}

// printOutput prints command output
func printOutput(outs []byte) {
	if len(outs) > 0 {
		fmt.Printf("==> Output: %s\n", string(outs))
	}
}

// main()  programa ppal
func main() {
	cmd := exec.Command("cat", "/dev/random") // creamos un comando
	randomBytes := &bytes.Buffer{}            // creamos un buffer
	cmd.Stdout = randomBytes                  // asociamos la salida estándar al buffer

	err := cmd.Start() // Lanzamos el comando de forma asíncrona
	printError(err)

	// Create a ticker that outputs elapsed time
	ticker := time.NewTicker(time.Second)
	go func(ticker *time.Ticker) {
		now := time.Now()
		for _ = range ticker.C {
			printOutput(
				[]byte(fmt.Sprintf("%s", time.Since(now))),
			)
		}
	}(ticker)

	// Create a timer that will kill the process
	timer := time.NewTimer(time.Second * 4)
	go func(timer *time.Timer, ticker *time.Ticker, cmd *exec.Cmd) {
		for _ = range timer.C {
			err := cmd.Process.Signal(os.Kill)
			printError(err)
			ticker.Stop()
		}
	}(timer, ticker, cmd)

	// Only proceed once the process has finished
	cmd.Wait()
	printOutput(
		[]byte(fmt.Sprintf("%d bytes generated!", len(randomBytes.Bytes()))),
	)
}
```



### `tcell`

Este paquete nos permite implementar interfaces de usuario basados en texto.

Instalamos:

```bash
go get -u github.com/gdamore/tcell
```

Recomiendan mirar primero el ejemplo incluido `mouse`


## Casos prácticos

### Leer y escribir json

Básico:

```go
package main

import (
	"encoding/json"
	"fmt"
)

// main ...
func main() {
	x := map[string]string{
		"foo": "bar",
	}
	data, _ := json.Marshal(x)
	fmt.Printf("Data contains:\n%s\n", (data))
}
```

Result:

```bash
Data contains:
{"foo":"bar"}
```

Un poco más complicado:

```go
package main

import (
	"encoding/json"
	"fmt"
)

// main ...
func main() {

	type person struct {
		Name        string `json:"name"`
		Age         int    `json:"age"`
		Description string `json:"descr,omitempty"`   // DON'T use spaces in tags
		secret      string // Unexported fields are Unmarshaled
	}

	x := person{
		Name:   "Bob",
		Age:    32,
		secret: "Shhh!",
	}

	data, _ := json.Marshal(x)
	fmt.Printf("Data contains:\n%s\n", (data))
}
```

Un ejemplo de *unmarshalling*, aunque siempre es preferible usar una `struc` si conocemos de antemano la estructura de los datos:

```go
package main

import (
	"encoding/json"
	"fmt"
)

// main test json
func main() {
	data := []byte(`{"foo":"bar"}`)

	var x interface{}
	_ = json.Unmarshal(data, &x)
	fmt.Printf("x contains:\n%s\n", x)
}
```

Un ejemplo de :

```go

```


## Best Practices






## Para estudiar

- <https://stackoverflow.com/questions/27178635/cast-a-struct-pointer-to-interface-pointer-in-golang>
- [Advanced Command Execution in Go](https://blog.kowalczyk.info/article/wOYk/advanced-command-execution-in-go-with-osexec.html)
- [Executing shell commands in Go](https://medium.com/rungo/executing-shell-commands-script-files-and-executables-in-go-894814f1c0f7)