DEV Community: Bruno Gomes

Golang básico - Comparação de Igualdade

Bruno Gomes — Fri, 25 Oct 2024 18:58:12 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

As comparações lógicas utilizando os operadores == ou != não tem muito mistério. Ou seu código compara se os valores são iguais ou diferentes.
Mas existem alguns detalhes importantes de saber sobre o que você está comparando.

Interface `Comparable`

A primeira coisa é saber o que pode ser comparado com esses operadores, o lugar mais óbvio para saber disso é a documentação do Go: seção sobre comparadores

E outra opção é olhar a interface comparable, que foi adicionada junto com a implementação de generics do Go, todos os tipos que implementam essa interface são comparáveis.

Então basicamente todos os tipos primitivos definidos pelo Go são comparáveis, como: string, números (int, float, complex), bool.

Comparação de tipos complexos

Alguns tipos possuem condições para serem ou não comparáveis. Que é o caso de: struct, slices e channels.
Somente são comparáveis se os elementos deles também o forem.
O interessante é que o Go valida isso a nível de compilação, te ajudando a evitar erros em runtime, por exemplo:

//Esse código compila e a comparação funciona:
func main() {
    test1 := struct {
        name       string
    }{}
    test2 := struct {
        name       string
    }{}
    if test1 == test2 {
        fmt.Println("Funciona")
    }
}

No código acima estou criando dois structs com o atributos equivalentes e a comparação funciona.

//Esse código não compila
func main() {
    test1 := struct {
        name       string
        attributes map[string]string
    }{}
    test2 := struct {
        name       string
        attributes map[string]string
    }{}
    if test1 == test2 {
        fmt.Println("Cade?")
    }
}

Já esse código vai falhar na compilação com o erro invalid operation.

Isso acontece porque map não é um tipo comparável em Go.

Detalhes sobre structs e map

É bastante conveniente poder comparar structs com ==, já que esse são os tipos onde customizamos nossas modelagens.
Mas mesmo quando estiver utilizando um tipo não comparável há algumas maneiras de simplificar o código, e saber disso vai te poupar de escrever condições bem chatas.

Bom vamos imaginar que estamos trabalhando no sistema de uma escola e temos a seguinte struct não comparável:

type student struct {
    ID         int
    name       string
    age        int
    course     string
    attributes map[string]string
}

A parte boa, esse struct possui um campo ID, o que facilita muito se você estiver trabalhando com dados persistidos.

Agora imagina só se estiver trabalhando com dados ainda transientes, por exemplo se estiver lendo um arquivo e precisar fazer algum tipo de processamento antes de persistir esses dados.

Você sempre vai ter a opção de comparar campo a campo, não é nada conveniente, mas funciona. Mas você pode fazer uso de composição de struct da seguinte forma:

func main() {
    type identity struct {
        name   string
        age    int
        course string
    }
    type student struct {
        ID int
        identity
        attributes map[string]string
    }

    s1 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "10",
        },
    }
    s2 := student{
        identity: identity{
            name:   "Chuck",
            age:    10,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    s3 := student{
        identity: identity{
            name:   "Chuck",
            age:    12,
            course: "golang",
        },
        attributes: map[string]string{
            "last_score": "20",
        },
    }

    if s1.identity == s2.identity {
        fmt.Println("Achou", s1)
    }

    if s1.identity != s3.identity {
        fmt.Println("Não achou")
    }
}

A alternativa a esse código seria fazer condições como essas:

    if s1.name == s2.name && s1.age == s2.age && s1.course == s2.course {
        fmt.Println("Achou", s1)
    }

Você poderia extrair para uma função, para ficar menos confuso, mas mesmo assim teria que ficar mantendo essas comparações.

Faça bom uso de composição isso pode simplificar bastante o seu código!

Resumo

Conheça a interface comparable
Tipos primitivos são comparáveis
Tipos complexos podem ou não ser comparáveis
Use a composição a seu favor.

Go + hot reload

Bruno Gomes — Fri, 23 Feb 2024 15:05:19 +0000

Esse post é uma dica rápida para ajudar o desenvolvimento de aplicações Go ficar mais dinâmico e rápido.

Contexto

Go é uma linguagem compilada, qualquer alteração no código da sua aplicação exige que você re-compile e execute novamente.
Isso por si, não é um grande problema, pois a compilação e startup do Go é super rápido e provavelmente sua IDE tem um botão pronto para restart da aplicação.
Porém é um pouco inconveniente, e nos tira algum tempo lembrar de restartar, automatizar esse processo nos deixa mais produtivos.

Ferramenta Reflex

O reflex é uma ferramenta open source escrita em Go, ela basicamente faz watch de um diretório e quando identifica alteração de arquivos re-executa um comando.

Exemplo de uso

Instale o reflex:

go install github.com/cespare/reflex@v0.3.1

Execute o reflex:

reflex -s -r '\.go$$' -- go run .

Simples assim, nesse comando eu estou passando a flag -s para sinalizar que é um processo de longa duração e a flag -r para filtrar somente os arquivos .go.

Log de exemplo:

reflex -s -r '\.go$' -- go run .
[00] Starting service
[00] [GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
[00]  - using env:      export GIN_MODE=release
[00]  - using code:     gin.SetMode(gin.ReleaseMode)
[00] 
[00] 2024/02/23 09:12:50 Failed to connect to rabbit  dial tcp [::1]:5672: connect: connection refused
[00] 2024/02/23 09:12:50 Skipping queue setup 
[00] [GIN-debug] POST   /endpoints/               --> api/api.Handler.PostEndpoints-fm (1 handlers)
[00] [GIN-debug] GET    /endpoints/               --> api/api.Handler.GetEndpoints-fm (1 handlers)
...
[00] [GIN-debug] Listening and serving HTTP on :3000

Para mais informações de como usar o reflex, consulte o repositório no github: https://github.com/cespare/reflex

Usando Makefile

O seu comando reflex pode acabar aumentando de acordo com as configurações do seu projeto. Para não precisar ficar digitando ele várias vezes, você pode utilizar um arquivo Makefile no seu projeto, assim por exemplo:


dev:
    reflex -s -r '\.go$$' -- go run .

Com isso você só precisa utilizar make dev e pronto.

Utilizando com Docker

Se o seu projeto utiliza docker-compose para inicializar as dependências que precisam subir com seu servidor, você também pode se beneficiar do hot reload.
Você consegue alcançar isso em 3 etapas:

Criando o Makefile na raiz do projeto, como foi apresentado acima.
Crie um Dockerfile somente para desenvolvimento:

Dockerfile.local

FROM golang:1.22.0-bullseye
WORKDIR /app

RUN go install github.com/cespare/reflex@v0.3.1

Adicione command no seu service do docker-compose:

  seu-service:
    build:
      context: .
      dockerfile: Dockerfile.local
    volumes:
      - .:/app
    depends_on:
      - rabbitmq
    command: ['make', 'dev']

Com isso você pode executar seu docker compose up --build normalmente, todos seus containers vão subir e seu servidor em Go vai fazer hot reload quando você editar os arquivos .go.

Ou seja, você não precisa reiniciar ou reconstruir seu container a cada alteração de código. Deixe para fazer isso quando tiver mudanças de infraestrutura.

Golang básico - Controle de Fluxo - Complemento

Bruno Gomes — Tue, 31 May 2022 14:41:11 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.
Esse em particular é um complemento do Golang básico - Controle de Fluxo

Agora que já vimos como utilizar IF, SWITCH e FOR vamos ver algumas palavras reservadas do Go que são utilizadas para interromper ou acelerar a iteração do código.

continue

A palavra reservada continue é específica para ser utilizada com for, e serve para pular para a próxima iteração:

func main() {
    produtos := []produto{
        {
            nome:   "Produto Final",
            cor:    verde,
            status: publicado,
            criado: time.Now(),
        },
        {
            nome:   "Produto Teste",
            cor:    verde,
            status: rascunho,
            criado: time.Now(),
        },
    }

    for _, p := range produtos {
        if p.status == publicado {
            continue
        }
        fmt.Println(p)
    }
}

Executando esse código verá que somente o Produto Teste é impresso no for.

break

Essa palavra reservada pode ser utilizada em for, switch e select. E ela serve para interromper a iteração do bloco e seguir para próxima instrução do código.

// nesse for nenhum produto será impresso
for _, p := range produtos {
    if p.status == publicado {
        break
    }
    fmt.Println(p)
}
fmt.Println("Loop terminado")

p := produto{
    nome:   "Produto Teste",
    cor:    verde,
    status: rascunho,
    criado: time.Now(),
}
// nenhum case será executado
switch p.status {
case publicado:
    fmt.Println("bloco publicado", p)
case rascunho:
    if p.cor == verde {
        break
    }
    fmt.Println("bloco rascunho", p)
case congelado:
    fmt.Println("bloco congelado", p)
}
fmt.Println("switch terminado")

fallthrough

Essa é específica para ser utilizada com switch, em Go cada case do switch é exclusivo. Diferente de outras linguagens que caso precise ser exclusivo você precisa combinar o case + break.
Mas caso você tenha a necessidade de executar o mesmo case para mais de uma condição, pode fazer uso do fallthrough que transfere o controle para o case seguinte:

// nesse exemplo ambos os cases serão executados
switch p.status {
case rascunho:
    fmt.Println("bloco rascunho")
    fallthrough
case congelado:
    fmt.Println("bloco congelado")
    fmt.Println("aplica lógica compartilhada entre produtos congelados e rascunhos")
}
fmt.Println("switch terminado")

Label com `continue` e `break`

Em Go os blocos de códigos podem ter labels e podemos combinar o uso das palavras reservadas de controle com os labels. Isso acaba sendo útil quando temos operações aninhadas. Por exemplo:

func main() {
    produtos := []produto{
        {
            nome:   "Produto Final",
            cor:    verde,
            status: publicado,
            criado: time.Now(),
        },
        {
            nome:   "Produto Teste",
            cor:    verde,
            status: rascunho,
            criado: time.Now(),
        },
    }

    for _, p := range produtos {
        switch p.status {
        case publicado:
            break
        case rascunho:
            fmt.Println("bloco rascunho")
            fallthrough
        case congelado:
            fmt.Println("aplica lógica compartilhada entre produtos congelados e rascunhos")
        }
        fmt.Println("aplica regra para produtos não publicados")
    }
    fmt.Println("Loop terminado")

}

Se você executar o código vai perceber que o break do switch não interrompe a execução do for. Com o uso de label fica assim:

loopDeProduto:
    for _, p := range produtos {
        switch p.status {
        case publicado:
            break loopDeProduto
        case rascunho:
            fmt.Println("bloco rascunho")
            fallthrough
        case congelado:
            fmt.Println("aplica lógica compartilhada entre produtos congelados e rascunhos")
        }
        fmt.Println("aplica regra para produtos não publicados")
    }
    fmt.Println("Loop terminado")

Ou seja, com label você consegue controlar a iteração do for de dentro do switch. Mas poderia ser dois for aninhados também, ou qualquer outro bloco aninhado.

Bom esses recursos de controle são importantes de saber que existem, porém na minha opinião eles são bem evitáveis.
No geral quando você está fazendo operações aninhadas e precisando fazer um controle tão detalhado é um grande sinal de que talvez o seu código não esteja tão simples.
Sempre considere a expressividade do código, não o faça funcionar a qualquer custo!

Resumo

continue pula para próxima execução do for.
break interrompe execução do bloco.
fallthrough transfere controle para o case seguinte.
Labels te possibilitam controlar de blocos aninhados.
Sempre considere a expressividade do seu código.

Golang básico - Controle de Fluxo

Bruno Gomes — Sat, 28 May 2022 17:48:50 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

No primeiro post, sobre variáveis, eu mencionei que sistemas funcionam com entrada -> processamento -> saída. Nesse post vamos entender isso um pouco melhor.

Algoritmos

Toda tarefa executada por um computador é resultado de um algoritmo. Uma definição simples de entender é de que algoritmos são receitas com o passo a passo do que o computador deve fazer.
Diferente de uma receita de comida, para o computador você precisa dar todos os detalhes.

Etapas de um algoritmo

Todo algoritmo pode ser dividido em algumas etapas simples:

entrada: leitura de dados que são armazenados em variáveis.
sequência: ordem em que as etapas devem acontecer.
condições: controle de fluxo 👀
repetições: controle de fluxo 👀
saída: a resposta do problema que o algoritmo está resolvendo.

Não parece tão complicado, não é? Entendendo essas etapas você consegue entender qualquer software, não importa a linguagem, paradigma ou framework. Todos funcionam dessa maneira.
A parte boa, você provavelmente já está fera em entrada pois leu o post sobre variáveis. A parte de sequência é bem auto explicativa e vai ficar bem fácil de visualizar com um exemplo. Então vamos ao que interessa, controles de fluxos em Go.

Controle de Fluxo

Condições IF, ELSE, SWITCH

Condições com IF em go são muito parecidas com a do C e suas similares, tendo alguns detalhes.

if condicao {
    fmt.Println("faz algo genial")
}

Temos 3 coisas:

o uso da palavra reservada if.
uma condição (sem parênteses) podendo ser uma variável booleana ou uma expressão lógica.
bloco dentro de chaves {...}, que em Go é obrigatório.

// você também pode utilizar else...if 
if condicao {
    fmt.Println("faz algo genial")
} else if outra_condicao {
        fmt.Println("faz algo genial ao contrario")
} else {
        fmt.Println("desiste")
}

Expressão lógica

Se esse é um dos seus primeiros contatos com programação, esse material provavelmente não será o suficiente, mas eu espero que possa ser um incentivo para que você busque mais conhecimento, disclaimer feito. Vamos lá.

Expressões lógicas podem ter operadores de comparação e/ou operadores lógicos.

Operadores de comparação

==    igual
!=    diferente
<     menor
<=    menor ou igual
>     maior
>=    maior ou igual

Operadores lógicos

&&    conjunção (AND)
||    disjunção (OR)
!     negação

Exemplo simples

// utilizando operador de comparação + operador lógico
if produto.status == publicado && produto.cor != azul {
    fmt.Println("Produto selecionado")
}

E é basicamente dessa forma que programamos tomadas de decisões dentro do código. Mais uma vez, se esse é um dos seus primeiros contatos eu vou te sugerir o seguinte, da uma olhada em:
Álgebra Booleana
Tabela Verdade

Não se assuste pelos nomes, são tópicos que você precisa exercitar e se tiver oportunidade faça um curso de lógica de programação.

SWITCH

Switch em Go são bastante flexiveis, podendo ser usados de algumas maneiras, a maneira mais comum é criar condições para conjunto de tipos, novamente usando nosso produto como exemplo:

// bastante comum de ser usado com tipos enumerados
switch produto.cor {
case vermelho:
    fmt.Println("Desconto 20% no vermelho")
case verde:
    fmt.Println("Desconto 10% no verde")
case azul:
    fmt.Println("Desconto 5% no azul")
}

Outra sintaxe possível e também incentivada é utilizar o switch vazio e os cases com expressões lógicas, é uma maneira idiomática de evitar series grandes de if..else..if:

switch {
case meuStatus != rascunho && meuStatus != deletado:
    fmt.Println("Faz algo com produtos diferentes de rascunhos")
case meuStatus == publicado || meuStatus != congelado:
    fmt.Println("Faz algo com publicados")
case meuStatus == congelado:
    fmt.Println("Faz algo com congelados")
}

Para mais detalhes veja a documentação:
Switch_statements
Effective Go Switch

Repetições For

Em Go a única palavra reservada para laços de repetições é o for.
Vamos a alguns exemplos rápidos:

// loop infinito
for {
    fmt.Println("rodando... pra sempre")
    time.Sleep(time.Second * 1)
}

// repete enquanto a condição for verdadeira
for meuStatus != publicado {
    fmt.Println("rodando... pra sempre")
    time.Sleep(time.Second * 1)
        //... faz algum processamento que atualize meuStatus
}

// for incremental
// além a condição tem operação de inicialização: i := 0
// e uma pós operação para incrementar a variável
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

Palavra reservada `range`

Além dos exemplos acima, quando estiver iterando com slices e maps, é possível utilizar range para ambos:

personagens := []string{"Kurono", "Guts", "Eren"}
// range te devolve duas variáveis, o índice e o valor
for i, valor := range personagens {
    fmt.Println(i, valor)
}

Exatamente a mesma sintaxe para maps

personagemAnime := map[string]string{
    "Eren":   "Attack on Titan",
    "Guts":   "Berserk",
    "Kurono": "Gantz",
}
for chave, valor := range personagemAnime {
    fmt.Println(chave, valor)
}

Um detalhe importante, nem sempre queremos trabalhar com o índice do array ou a chave do mapa, é bem comum a gente só iterar pelos valores, nesse caso precisamos usar o caracter _:

personagens := []string{"Kurono", "Guts", "Eren"}
for _, valor := range personagens {
    fmt.Println(valor)
}

Resumo

Nesse post você viu como fazer o controle de fluxo de um código em Go e a estrutura de um algoritmo. E por mais que possa soar exagerado, é sério que isso pode te tornar capaz de ler qualquer código.
Mas veja, para fazermos uma analogia, é como se eu tivesse te apresentado as notas musicais em um instrumento especifico. Você agora é capaz de ler partituras e com exercício pode começar a tocar sua versão.

algoritmos são receitas
etapas de um algoritmo: entrada, sequência, condições, repetições, saída
estude mais sobre expressões lógicas
estude tabela verdade e algebra booleana

Golang básico - Arrays, Slices e Mapas

Bruno Gomes — Sat, 21 May 2022 18:15:11 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

No post anterior entendemos um pouco melhor de tipo de dados e ao fim eu mencionei alguns tipos de referência, nesse post vou dar um pouco mais detalhes, principalmente de Slices e Mapas, acredito que será bem importante para avançarmos para os próximos posts.

Estrutura de dados

Esse é um tópico bastante extenso, e um dos mais importantes dentro da ciência de computação, pode ser um pouco difícil para quem está iniciando, mas garanto que fica prazeroso de estudar e ver o quão genial são todas as possibilidades de estruturas.

Arrays

Um array é uma coleção de valores, nós vimos as variáveis, cada uma com seu tipo. O array vai te possibilitar ter vários valores de um mesmo tipo.

package main

import (
    "fmt"
)

func main() {
    // pode ser declarado com var seguido do [tamanho]tipo
    var animes [3]string
    animes[0] = "Gantz"
    animes[1] = "Berserk"
    animes[2] = "Attack on Titan"
    fmt.Println(animes)

    // também pode utilizar o operador ':=' e passar os valores entre as chaves
    personagens := [3]string{"Kurono", "Guts", "Eren"}
    fmt.Println(personagens)

    // ou substituindo o tamanho por '...'
    personagens = [...]string{"Kei Kishimoto", "Casca", "Mikasa"}
    fmt.Println(personagens)
}

Uma coisa que fica evidente, arrays tem o tamanho definido em sua criação e eles são de tamanho fixo!

Slices

São muito similares aos Arrays, porém são dinâmicos e muito mais fáceis de trabalhar, a forma mais simples de criar um Slice é utilizando a função make:

// make recebe o tipo []string e a capacidade inicial do slice
animes := make([]string, 3)

Perceba que a tipagem é muito similar a do array, e inicialmente o uso também é parecido. Bom, uma coisa importante de saber é que os Slices tem 3 propriedades:

ponteiro para um array (novamente ponteiros, em breve falaremos disso!)
len que é abreviação de length, o tamanho atual do array.
cap abreviação de capacity, quantos valores ele suporta armazenar.

package main

import (
    "fmt"
)

func main() {
    // cria um slice com tamanho 3
    animes := make([]string, 3)
    animes[0] = "Gantz"
    animes[1] = "Berserk"
    animes[2] = "Attack on Titan"
    fmt.Println(animes)
    fmt.Println(len(animes), cap(animes))

    // a função append redimensiona a capacidade do slice
    animes = append(animes, "Mob Psycho")
    fmt.Println(animes)
    fmt.Println(len(animes), cap(animes))
}

Tanto slices quanto arrays podem ser acessados pelo índice do valor:

personagens := [...]string{"Kei Kishimoto", "Casca", "Mikasa"}
fmt.Println(personagens[2])

E existe uma sintaxe muito interessante chamada slice-expression, que é uma maneira de extrair sub arrays/slices utilizando array[inicio:fim], por exemplo:

package main

import (
    "fmt"
)

func main() {
    personagens1 := [3]string{"Kurono", "Guts", "Eren"}
    fmt.Println(personagens1)
    fmt.Println(personagens1[0:2])

    personagens2 := [3]string{"Kei Kishimoto", "Casca", "Mikasa"}
    fmt.Println(personagens2)
    fmt.Println(personagens2[2:3])
}

Quando usar Array e quando usar Slice ?

Na minha opinião o mais comum é utilizar Slices, por ter essa característica mais dinâmica. Isso simplifica muito o código, te evita ter que ficar recriando arrays e redimensionando.

É uma boa usar array quando você sabe exatamente o número de valores que precisa armazenar, ou se você quer fazer uma solução super otimizada, pelo fato de arrays não fazerem uso direto de um ponteiro 👀.

Vou deixar algumas referências, que explicam a diferença entre os dois bem melhor do que eu:

Map

Essa estrutura de dados vai fazer parte da sua vida pra sempre, brincadeiras a parte, ela resolve uma série de problemas e normalmente te ajuda a deixar o seu código mais otimizado.
As principais características de um mapa é que ele é uma coleção de pares, ou melhor, de chaves e valores. E ele não é ordenado, pois trabalha com o conceito de hash, ou espalhamento.
Em outras linguagens você vai encontrar Map com outros nomes, por exemplo: dict, hash, Hashtable e HashMap

package main

import (
    "fmt"
)

func main() {
    // são iniciados com make, é opcional informar a capacidade inicial
    // e assim é definido map[tipo da chave]tipo do valor
    dicionario := make(map[string]string)
    dicionario["hi"] = "oi"
    dicionario["bye"] = "tchau"
    dicionario["hey"] = "opa"
    fmt.Println(dicionario)

    // também podem ser iniciados com valores literais
    personagemAnime := map[string]string{
        "Eren":   "Attack on Titan",
        "Guts":   "Berserk",
        "Kurono": "Gantz",
    }
    fmt.Println(personagemAnime)
}

Modificando Map

Quando você estiver resolvendo um problema com um mapa, seja um de-para, um agrupamento de dados, sumarizando totais, etc. Você vai precisar de forma incremental modificar o mapa, e para isso você precisa conhecer algumas poucas operações:

// recuperar um valor associado a uma chave
anime := personagemAnime["Eren"]
fmt.Println(anime)

// recuperar um valor associado a uma chave, e conferir se ele existe
anime, ok := personagemAnime["Naruto"]
// a variavel ok vai ser um bool sinalizando se a chave existe ou não.
fmt.Println(anime, ok)

// deleta a chave e o valor associado do mapa
delete(personagemAnime, "Kurono")

// para atualizar ou inserir 
personagemAnime["Kurono"] = "Gantz"

Desde a criação até essas operações a forma de manusear um mapa é muito parecida com slice/array. Esses pequenos detalhes fazem do Go uma linguagem tão simples.

E agora?

Voltaremos a ver Slices e Mapas quando falarmos de controle de fluxo e iterações!

Nesse momento eu vou limitar nas estruturas simples do Go, até nesse sentido a linguagem foi bastante simplificada tendo um número bem reduzido de estrutura de dados se comparado a outras linguagens. Por um lado isso é bom, pois facilita muito para quem é iniciante, o estudo é mais curto. Mas por favor, não pare nas estruturas básicas do Go 🙏.

Vou deixar algumas referências que podem ajudar a seguir com os estudos:

Junmin Lee - Tem uma série de estrutura de dados implementadas em Go

Programação Dinâmica - Conta com série de estrutura de dados em português.
Inclusive esse canal tem muito material bom com uma didática excelente, vale muito a pena se inscrever!

Resumo

arrays são coleções de um mesmo tipo de tamanho fixo.
slices são coleções de um mesmo tipo com tamanho dinâmico.
mapas são coleções não ordenadas de chaves e valores.
slices e mapas são inicializados com a função make()

Golang básico - Tipos de dados

Bruno Gomes — Thu, 19 May 2022 04:24:50 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

Nos últimos posts nós vimos que variáveis e constantes possuem tipos de dados. Esse é um conceito muito importante, ainda mais se tratando de uma linguagem compilada e fortemente tipada como é o caso do Go.

Tipos embutidos

Os tipos que veremos agora, são tipos embutidos do Go, na realidade eles são frequentes em diversas linguagens, saber de existência deles e como manipulá-los é importante na jornada da programação.

Categoria	Tipos e definição
Booleanos	`bool` é tipo mais básico e só tem dois possíveis valores `true` e `false`, voltaremos nele em controle de fluxos
Numéricos	`int32`, `float32`, `byte` são provavelmente os tipos numéricos mais comuns, eles são representações numéricas utilizadas para operações aritméticas.
Strings	`string` é a representação de textos, mas uma definição técnica mais interessante: é uma sequencia de caracteres

Um ponto importante, em Go todos esses tipos embutidos tem uma natureza primitiva!

Esses são alguns dos tipos, para saber mais utilize esses links:

Tipos de estrutura

Estruturas ou simplesmente struct, é o que nos possibilita criar tipos mais complexos (no bom sentido) para atender as necessidades e regras do nossos sistemas.

Se você olhar para a implementação do Go, vai ver que os tipos complexos são definidos com struct, por exemplo:

array - Sequencia de dados, veremos nos posts seguintes.
list - Uma implementação de uma lista duplamente ligada, podemos falar disso futuramente.

Exemplo prático com struct

Para ilustrar como elas são definidas, vamos complementar o exemplo do último post, era um produto que possuía cor e status:

package main

import (
    "fmt"
    "time"
)

type (
    cor    string
    status int
)

const (
    vermelho cor = "#ff0000"
    verde    cor = "#00ff00"
    azul     cor = "#0000ff"
)

const (
    rascunho status = iota + 1
    publicado
    congelado
    deletado
)

type produto struct {
    nome   string
    cor    cor
    status status
    criado time.Time
}

func main() {
    p := produto{
        nome:   "Produto Teste",
        cor:    verde,
        status: publicado,
        criado: time.Now(),
    }
    fmt.Println(p)
    fmt.Println(p.criado.Format(time.RFC3339))
}

No exemplo eu estou criando o tipo produto, ele possui o nome, sendo um tipo embutido string, cor e status que nós criamos no exemplo passado, e um tipo extra time.Time que é a representação de tempo/datas no Go.
Eu coloquei ela de propósito, para novamente citar que os tipos embutidos possuem uma natureza primitiva pois é só a representação de um valor, enquanto tipos complexos, como é o caso do Time, vai te fornecer atributos e uma série de comportamentos, por exemplo o método Format que eu usei acima.

Struct é classe do Go?

Resposta curta: Não!
Se você já tem experiência com alguma linguagem orientada a objetos (java, c#, php) pode acabar associando strucs com classes, o que não é um problema em si, mas pode te levar a armadilha de achar que Go é orientado a objetos.
Sempre que eu penso em classe, a definição que tenho em mente é a seguinte: é a receita de um objeto, quando instanciada te fornece estado e comportamento. E structs não funcionam exatamente assim.

Go tem um estilo próprio

Na minha interpretação, Go tem a filosofia de ser uma linguagem bastante simplificada. E a definição que eu tenho em mente para o paradigma do Go é uma linguagem procedural com elementos de OO. O mais importante dessa reflexão, é que se você pretende codificar em Go, entenda que ela tem um estilo próprio, que é bastante simples na verdade.
Deixo como sugestão essa palestra: Simplicity is Complicated

Então POO é complicada e desnecessária?

Na minha humilde opinião, a resposta é não. Eu só interpreto isso como uma decisão de design da linguagem, por simplicidade Go não é OO e ponto.
Minha dica se você é iniciante, e está entrando nesse universo de programação agora, quanto mais você aprender é melhor, isso vale para paradigmas, linguagens, frameworks, etc. E se você tiver oportunidade de estudar OO, faça isso. Domine os pilares encapsulamento, herança, interfaces e polimorfismo, isso vai te ajudar em qualquer linguagem, inclusive em Go.

Tipos de referência

Vimos os tipos embutidos e os tipos de estruturas. Por último vou mencionar rapidamente os tipos de referência, e será breve pois todos eles merecem posts exclusivos, pois possuem bastante particularidades.

Tipo	Definição
Slice	Slices são simplesmente sequencias (arrays) dinâmicos
Map	Estrutura de dados super importante, entenda como um dicionário de dados representados por chaves e valores
Interface	É a abstração para um comportamento, o exemplo mais simples de Go: Reader
Funções	Funções em Go também funcionam como tipos, por hora se lembre que funções também são tipos de referencia
Channel	E estrutura de dados utilizada para comunicação entre goroutines em sistemas concorrentes, essa definição é mais do que suficiente por agora.

Uma coisa que todos esses tipos tem em comum: ponteiro.
Isso pode soar um pouco assustador, e te levar ao passado com C e C++, mas lembre-se Go é uma linguagem moderna, apesar de você ter o conceito de ponteiros, eles são bastante simples de usar e tem uma boa justifica para existir. Mas vamos deixar para um próximo post.

Resumo

Tipos embutidos (string, int, float, bool) são primitivos.
struct nos permite criar tipos complexos.
struct != class
POO é importante
Tipos de referência: slices, maps, interfaces, funções e channels.
Go tem o conceito de ponteiros.

Golang básico - Constantes

Bruno Gomes — Wed, 18 May 2022 04:53:01 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

Constantes são muito comuns e bastante utilizadas, para quem está iniciando pode parecer confuso por elas serem semelhantes a variáveis. A principal diferença das constantes é que elas são definitivas, uma vez criada o valor não é mais alterado, como o próprio nome diz: constante.

Como funciona em Go?

Em Go as constantes são criadas na compilação do código. Uma expressão comum é dizer que é em "tempo de compilação". Enquanto as variáveis são criadas em tempo de execução (runtime). Por esse motivo as constantes só podem ser dos tipos básicos do Go: strings, números, caracteres e booleanos.

Para saber mais: https://go.dev/doc/effective_go#constants

Criando constantes

Vamos ao primeiro exemplo:

package main

import "fmt"

const (
    appName    = "go_basico"
    serverPort = 3000
)

func main() {
    fmt.Println(appName, serverPort)
}

Você também pode criar dessa forma:

package main

import "fmt"

const appName    = "go_basico"
const serverPort = 3000

func main() {
    fmt.Println(appName, serverPort)
}

Agrupando constantes

O interessante é que você agrupe suas constantes, combinando valores que sejam relacionados, isso vai deixar o código bastante simples. Por exemplo, vamos imaginar que nós temos um produto e que ele possui dois atributos: cor e status
Esses dois atributos possuem valores limitados, um conjunto de constantes:

package main

import "fmt"

// conjunto de cores
const (
    vermelho = "#ff0000"
    verde    = "#00ff00"
    azul     = "#0000ff"
)

// conjunto de status do produto
const (
    rascunho  = 1
    publicado = 2
    congelado = 3
    deletado  = 4
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Conjuntos de constantes

Se você já teve contato com outras linguagens é possível que esteja se perguntando se não poderíamos ter feito isso com
enums. A resposta é sim e não.

Sim, porque Go possui o conceito de tipos enumerados.
Não, porque em Go você não tem uma palavra reservada para criar enum.

Eu convido você que está lendo, a refletir um pouco sobre isso, algumas vezes nós podemos acabar caindo em armadilhas de se prender a nomes como enum e esquecer o que eles são em sua essência.

Bom, o que nós precisamos fazer é definir um tipo customizado para os nossos conjuntos:

type cor string
type status int

Futuramente teremos post sobre tipos e tipos customizados

package main

import (
    "fmt"
)

type cor string

const (
    vermelho cor = "#ff0000"
    verde    cor = "#00ff00"
    azul     cor = "#0000ff"
)

type status int

const (
    rascunho  status = 1
    publicado status = 2
    congelado status = 3
    deletado  status = 4
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Utilizando iota

Para conjuntos numéricos, como o nosso conjunto de status, temos a opção de usar a palavra reservada iota, ela vai gerar valores sequenciais automaticamente:

package main

import "fmt"

type cor string

const (
    vermelho cor = "#ff0000"
    verde    cor = "#00ff00"
    azul     cor = "#0000ff"
)

type status int

const (
    //por padrão iota inicia em 0
    rascunho status = iota + 1
    publicado
    congelado
    deletado
)

func main() {
    fmt.Println(vermelho, azul, verde)
    fmt.Println(rascunho, publicado, congelado, deletado)
}

Resumo

Constantes são declaradas com a palavra reservada const.
Constantes são criadas em tempo de compilação.
Agrupar constantes em conjuntos contextualizados simplifica o código.
Go possuí tipos enumerados.
A palavra reservada iota pode simplificar seu código.

Golang básico - Declarando variáveis

Bruno Gomes — Wed, 18 May 2022 03:14:41 +0000

Esse post faz parte de uma série onde pretendo compartilhar o básico essencial para desenvolver com GoLang.

A maneira mais simples de entender variáveis é lembrar que um programa funciona com entrada -> processamento -> saída. Declarar variáveis é a forma que temos de reservar espaços em memória para armazenar as entradas de dados e permitir que processamento use essas variáveis e produza algum resultado como saída.

Declarando variáveis

Em Go existem algumas maneiras de fazer isso, todas elas tem um contexto e saber onde usar vai simplificar bastante seu código.

Utilizando var com tipo explicito

Esse é tipo de declaração que usamos no inicio de uma função, quando você declara esse tipo de variável você está deixando explicito o tipo da varíavel que nos blocos seguintes vai ter o seu valor modificado (ou não). Por exemplo:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    var valor int
    if runtime.NumCPU() > 0 {
        valor = runtime.NumCPU()
    }
    fmt.Println(valor)
}

Nesse código estou declarando a variável valor de tipo int(ou seja, um número inteiro). E logo em seguida eu faço um processamento para atribuir um novo valor a essa variável.

Dica: você pode testar esse código no https://go.dev/play/

Criando e atribuindo de forma implícita

Criar variáveis implícitas é provavelmente o jeito mais fácil e prático, mas sempre se atente ao contexto. É muito comum elas serem usados dentro dos blocos, e elas normalmente são resultado da chamada a uma função ou do resultado de uma expressão, vamos ver nosso exemplo novamente:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    var valor int
    if runtime.NumCPU() > 0 {
        valor = runtime.NumCPU()
    }
    maiorQueDois := runtime.NumCPU() > 2
    fmt.Println(valor, maiorQueDois)
}

Agora nós estamos criando a variável maiorQueDois, ela é resultado da expressão runtime.NumCPU() > 2 e implicitamente o Go decide que o tipo dessa variável é bool.

Grupos de variáveis

O última forma que vamos abordar é o grupo de variáveis:

package main

import (
    "fmt"
    "runtime"
)

func main() {
    var (
        valor     = 4
        categoria = "brabo"
    )

    if runtime.NumCPU() > 0 {
        valor = runtime.NumCPU()
    }
    maiorQueDois := valor > 2
    if valor <= 4 {
        categoria = "mais ou menos"
    }
    fmt.Println(valor, maiorQueDois, categoria)
}

Grupos são uma combinação das duas formas, precisamos do var, seguido de parêntesis e as variáveis separadas por linhas. No nosso caso valor e categoria.
Perceba, quando você cria um grupo você está expressando que essas variáveis tem alguma conexão, no meu exemplo a categoria é dependente do valor.

Resumo

Declaração explicita é feita com var nomeVariavel tipo
Declaração implícita utiliza nomeVariavel := expressão
Grupo de variáveis utilizam:

var (
   nomeVariavel = `valor` ou `expressão`
)

Go é uma linguagem muito simples e de poucos comandos, sempre que for usar um tipo de declaração tente expressar sua intenção. Simplicidade e expressividade!

DEV Community: Bruno Gomes

Golang básico - Comparação de Igualdade

Interface Comparable

Comparação de tipos complexos

Detalhes sobre structs e map

Resumo

Go + hot reload

Contexto

Ferramenta Reflex

Exemplo de uso

Usando Makefile

Utilizando com Docker

Golang básico - Controle de Fluxo - Complemento

continue

break

fallthrough

Label com continue e break

Resumo

Golang básico - Controle de Fluxo

Algoritmos

Etapas de um algoritmo

Controle de Fluxo

Condições IF, ELSE, SWITCH

Expressão lógica

Operadores de comparação

Operadores lógicos

Exemplo simples

SWITCH

Repetições For

Palavra reservada range

Resumo

Golang básico - Arrays, Slices e Mapas

Estrutura de dados

Arrays

Slices

Quando usar Array e quando usar Slice ?

Map

Modificando Map

E agora?

Resumo

Golang básico - Tipos de dados

Tipos embutidos

Tipos de estrutura

Exemplo prático com struct

Struct é classe do Go?

Go tem um estilo próprio

Então POO é complicada e desnecessária?

Tipos de referência

Resumo

Golang básico - Constantes

Como funciona em Go?

Criando constantes

Agrupando constantes

Conjuntos de constantes

Utilizando iota

Resumo

Golang básico - Declarando variáveis

Declarando variáveis

Utilizando var com tipo explicito

Criando e atribuindo de forma implícita

Grupos de variáveis

Resumo

Interface `Comparable`

Label com `continue` e `break`

Palavra reservada `range`