Primeiros passos com Golang!

Como instalar golang no Linux Ubuntu

Iremos usar docker para rodar o golang na versão 1.12.0-alpine3.9

Criando Dockerfile com imagem golang:1.12.0-alpine3.9

Criando a pasta

mkdir first-steps-golang

Acessando a pasta

cd first-steps-golang

Criando Dockerfile

touch Dockerfile

FROM golang:1.12.0-alpine3.9 as builder

WORKDIR /build

COPY go.mod .

RUN go mod download

COPY . .

RUN go build -o main . 

FROM scratch

WORKDIR /build

COPY --from=builder /build .

CMD [ "./main" ]

Criando o arquivo go.mod

touch go.mod

Na raiz do projeto terá um arquivo go.mod com esse conteúdo:

module calc

go 1.12

Em seguida iremos criar a pasta calc

mkdir calc

E criaremos o arquivo de calc em go

cd calc && touch calc.go

Dentro do arquivo cal.go, criamos uma func de divisão.

package calc seria referente ao pacote de calc

package calc

func Division(a, b int) int {
    return a / b
}

Iremos criar o arquivo main.go para executar o cálculo

touch main.go

Dentro do arquivo main.go

package main seria referente ao pacote main

Iremos importar o calc e fmt

package main

import (
    "calc/calc"
    "fmt"
)

func main() {
    var num1 int = 4
    num2 := 2
    result := calc.Division(num1, num2)

    fmt.Println(result)
}

Em seguida iremos fazer o build da imagem em go, na raiz do projeto aonde o Dockerfile esta.

docker build -t williamkoller/first-steps-golang .

Rodaremos a imagem gerado com esse comando

docker run -t williamkoller/first-steps-golang

Resultado gerado

Agora iremos trabalhar com erros em Golang

No arquivo calc.go

Iremos adicionar uma tratativa de erro

Podemos notar que importamos o erros do golang e no returno estamos usando o nil (como se fosse um ponteiro).

package calc

import "errors"

func Division(a, b int) (int, error) {
    if b == 0 {
        return 0, errors.New("denominator cannot be zero")
    }

    return (a / b), nil
}

No arquivo main.go

Passa a ser assim:

package main

import (
    "calc/calc"
    "fmt"
)

func main() {
    var num1 int = 4
    num2 := 0
    result, err := calc.Division(num1, num2)

    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println(result)
}

Iremos fazer o build da imagem novamente para ter essa nova versão de código

docker build -t williamkoller/first-steps-golang .

Em seguida rodar a nova imagem

docker run -t williamkoller/first-steps-golang

Com esse resultado:

Esse é o resultado gerado com docker e golang

Espero ter ajudado!