Apuntes del lenguaje de programación Go

1
2
3
4

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 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

1
2
3

bin/
pkg/
src/

1
2

src/github.com/salvari/miAppGo
src/gilab.com/salvari/mach5

1
2

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

1
2

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

1

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

1
2

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

1
2
3
4
5
6

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 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

1

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

1

go mod init example.com/modulename

1
2
3
4
5
6
7
8

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

1
2
3
4
5
6
7

package main

import "fmt"

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

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)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 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()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

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

1
2
3
4
5
6
7
8

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

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

1
2
3
4
5
6
7

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

1
2
3

module pomodoro

go 1.17

1
2

import "pomodoro/timer"
import "pomodoro/notification"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

    // 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
            }
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    // 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")
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

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 {
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 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
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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
}

1
2
3

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

1
2
3

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

1
2
3
4
5
6
7

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 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!"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// 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

1
2
3

type error interface {
    Error() string
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

func doStuff() (int, error) {
}

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 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)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

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")
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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)
// }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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"}
}

1
2
3
4
5

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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"}}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

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())
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

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()))),
	)
}

1

go get -u github.com/gdamore/tcell

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

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

1
2

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

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