Golang básico - Tipos de dados
Tags: go, tutorial, iniciante, portugues
Published: 2022-05-19 04:24:50

---
title: Golang básico - Tipos de dados
published: true
description: 
tags: #go #golang #tutorial #iniciante #portugues
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wsrivp5deyklmxxxa6ok.jpeg
series: Golang básico
---
> 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:*
* [go.dev](https://go.dev/ref/spec#Types)
* [tutorialspoint](https://www.tutorialspoint.com/go/go_data_types.htm)
* [w3schools](https://www.w3schools.com/go/go_data_types.php)
* [geeksforgeeks](https://www.geeksforgeeks.org/data-types-in-go/)

## 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](https://github.com/golang/go/blob/master/src/go/types/array.go) - Sequencia de dados, veremos nos posts seguintes.
* [list](https://github.com/golang/go/blob/master/src/container/list/list.go) - 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`:

```go
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**

{% embed https://www.youtube.com/watch?v=rFejpH_tAHM %}

### 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](https://github.com/golang/go/blob/master/src/io/io.go#L83-L85)| 
| 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.