---
# System prepended metadata

title: 'Um, dois, três e GO'

---

# Um, dois, três e GO
## A linguagem do Google
### Autores
* Luan Medeiros Silveira
* Guilherme Borba Rodrigues
* Ariel de Almeida Aleknovic
### Introdução
Foi criada em novembro de 2009 pela Google, também chamada de GoLang e lançada em código livre. Baseada em trabalhos feitos no sistema operacional do chamado Inferno (Sistema Operacional para criação e suporte a serviços distribuídos), seu projeto inicial da linguagem foi feito em setembro de 2007. Atualmente, há implementações para Windows, Linux, Mac OS X e FreeBSD.

Existe uma semelhança em declarações com a linguagem C, e suas declarações com Pascal. Uma das suas principais características é a ausência dos parênteses em volta das estruturas if e também for.
Das suas ausências tem como principais: Tratamento de exceção, herança, sobrecarga de métodos, entre outros.

Seus principais paradigmas são: Programação estruturada, imperativa, concorrente, orientada a objetos(mais conhecida), etc.

é uma linguagem fácil de codificar e limpa, o tornando eficiente. Seus mecanismos de concorrência tem seu intuito de tornar mais prático, assim o influenciando no proveito de inúmeros núcleos e também máquina de rede. Outra nota positiva que sua fase de compilação é rapida em sua transmissão do código à maquina ainda tem a conveniência de garbage collection e o poder de reflexão em tempo de execução. Tipagem estática e sua compilação rápida, que parece uma linguagem interpretada digitada de forma dinâmica.

Uma das grandes importâncias como exemplo é o seu uso em ciência de dados. Traz uma ferramenta muito importante pois ela é usada para extrair o valor comercial de grandes conjuntos de dados, tornado uma vantagem competitiva para as empresas, abrangendo artifício como IA (inteligência articial), aprendizado de máquina e outras ferramentas. Sua ajuda com prototipagem como produção, acaba sendo uma linguagem mais robusta para colocar as soluções de ciência dos dados em produção.

Seu crescimento e potencial é grande diante outras linguagens, por questões de popularidade e simplicidade. em dados de 2017, ela estava na posição 13º das mais usadas/procuradas(4)(9). Ela também tem seu diferencial em trabalhar com núcleos, não apenas um. Diferencia também em grande escala que distingui de outras linguagens. Um código de fácil leitura tem maior impacto trazendo uma melhor estrutura para futuros erros a serem consertados. 

Outras empresas além da Google também utilizam ela: Netflix, The Economist, The New York Times, IBM, GitHub, etc.

### Hello World
Como breve introdução do código, temos como início o hello world de GO:
```go
//Hello World
package main

import "fmt"

func main() {
	fmt.Println("Olá, Luan")
}
```

### Operadores
Toda e qualquer tarefa dentro de um algoritmo é feita utilizando operadores, que por sua vez, irá executar alguma ação baseada em seu tipo.

Cada tipo de operador é responsável por uma determinada operação. Alguns são popularmente conhecidos, dentro e fora da programação, como é o caso dos operadores aritméticos.
#### Aritméticos
Operadores aritméticos são responsáveis pela realização de operações básicas de processamento, muitas vezes utilizadas em nosso cotidiano.

|Operador|Descrição|Exemplo|Saída|
|--------|-----------|-----------|-----------|
|`+`|soma|`fmt.Println(4 + 8)`|`12`|
|`-`|subtração|`fmt.Println(8 - 3)`|`5`|
|`*`|multiplicação|`fmt.Println(5 * 2)`|`10`|
|`/`|divisão|`fmt.Println(15 / 3)`|`5`|
|`%`|modulo (resto da divisão)|`fmt.Println(17 % 2)`|`1`|
|`++`|incremento|`num1 := 20`<br>`fmt.Println(num++)`|`21`|
|`--`|decremento|`num1 := 20`<br>`fmt.Println(num--)`|`19`|

#### Relacionais
Operadores relacionais verificam uma expressão e retornam um valor boolean de aceitação true ou negação false .

|Operador|Descrição|
|--------|-----------|
|`==`|igual|
|`!=`|diferente|
|`<`|menor que|
|`<=`|menor ou igual que|
|`>`|maior que|
|`>=`|maior ou igual que|

#### Lógicos
Como o nome já diz, são responsáveis por definir uma lógica baseada em critérios e valores relacionais.

|Operador|Descrição|
|--------|-----------|
|`&&`|lógico E|
|`||`|lógico OU|
|`!`|lógico NÃO (negação)|    


#### Atribuição
Operadores de atribuição possibilitam que valores de variáveis sejam alterados de diversas formas.

| Operador | Descrição |
| -------- | -------- | -------- |
|    `=`     | atribuição      |
|    `+=`    | soma e atribuição      |
|    `-=`     | subtração e atribuição      |
|    `\*=`     | multiplicação e atribuição      |
|    `/=`     | divisão e atribuição      |
|    `%=`     | módulo e atribuição      |


#### Outros
|Operator|Description|
|--------|-----------|
|`&`|retorna o endereço de um objeto / cria um ponteiro|
|`*`|desreferencia um ponteiro|
|`<-`|envia / recebe|

### Estrutura da linguagem

#### Repetições

for é o único construtor de looping do Go. Aqui estão três tipos básicos de for loops.

* Tipo mais comum, com uma única condição:
```go
    i := 1
for i <= 3 {
    fmt.Println(i)
    i = i + 1
}
```

* Um clássico inicial/condição/final for loop.

```go
for j := 7; j <= 9; j++ {
    fmt.Println(j)
}
```
* for sem uma condição será repetido várias vezes até que você dê um break no loop ou return da função de fechamento.
```go    
for {
    fmt.Println("loop")
    break
}
```

#### If/Else
A ramificação com if e else em Go é direta.

Aqui está um exemplo básico.
```go
if 7%2 == 0 {
    fmt.Println("7 é par")
} else {
    fmt.Println("7 é ímpar")
}
```
Você pode ter uma condição if sem um else.
```go
if 8%4 == 0 {
    fmt.Println("8 é divisível por 4")
}
```
Uma instrução pode preceder condições; qualquer variável declarada nessa condição está disponível para todas as ramificações.
```go
if num := 9; num < 0 {
    fmt.Println(num, "é negativo")
} else if num < 10 {
    fmt.Println(num, "tem 1 dígito")
} else {
    fmt.Println(num, "tem vários dígitos")
}
```
Note que você não precisa de parênteses nas condições em Go, mas os colchetes são necessários.

#### Switch/case
Instruções switch expressam condições através de vários ramos.

Aqui está um switch básico.
```go
i := 2
fmt.Print("escreva ", i, " como ")
switch i {
case 1:
    fmt.Println("um")
case 2:
    fmt.Println("dois")
case 3:
    fmt.Println("três")
}
```
Você pode usar vírgulas para separar várias expressões na mesma condição case. Nós usamos também, o case opcional default nesse exemplo.
```go
switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
    fmt.Println("é final de semana")
default:
    fmt.Println("é dia de semana")
}
```
switch sem uma expressão é uma forma alternativa de expressar a lógica if/else. Aqui nós também podemos mostrar como as expressões case podem ser não-constantes.
```go    
t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("é antes do meio dia")
default:
    fmt.Println("é depois do meio dia")
}
```
#### Erros
No Go é idiomático comunicar erros através de um explícito, valor de retorno separado. Isso contrasta com as excessões usadas em linguagens como Java e Ruby e resultados únicos sobrecarregados / valores de erros algumas vezes usados em C. Go torna fácil ver quais funções retornam erros e o tratamento deles usando construções da mesma linguagem empregada para qualquer outra tarefa não-erro.

```go
// Por convenção, os erros são o último valor de retorno e
// possuem o tipo `error`, uma interface integrada.
func f1(arg int) (int, error) {
	if arg == 42 {

		// `errors.New` constrói um valor básico `error`
		// com a mensagem de erro dada.
		return -1, errors.New("não pode trabalhar com 42")

	}

	// Um valor zero na posição de erro indica que
	// não houve erro.
	return arg + 3, nil
}

// É possível usar tipos personalizados como `error`s
// implementando o método `Error()` neles. Aqui está
// uma variante do exemplo acima que usa um tipo personalizado
// para representar explicitamente um argumento de erro.
type argError struct {
	arg  int
	prob string
}

func (e *argError) Error() string {
	return fmt.Sprintf("%d - %s", e.arg, e.prob)
}

func f2(arg int) (int, error) {
	if arg == 42 {

		// Nesse caso use a sintaxe `&argError` para construir
		// uma nova estrutura, fornecendo valores para os dois
		// campos `arg` e `prob`.
		return -1, &argError{arg, "não pode trabalhar com ele."}
	}
	return arg + 3, nil
}

func main() {

	// Os dois loop no teste abaixo mostra cada uma de nossas
	// funções retorno-erro. Note que o uso de um
	// erro inline verificada na linha `if` é um idioma
	// comum no código Go.
	for _, i := range []int{7, 42} {
		if r, e := f1(i); e != nil {
			fmt.Println("f1 falhou:", e)
		} else {
			fmt.Println("f1 funcionou:", r)
		}
	}
	for _, i := range []int{7, 44} {
		if r, e := f2(i); e != nil {
			fmt.Println("f2 falhou:", e)
		} else {
			fmt.Println("f2 funcionou:", r)
		}
	}

	// Se você quiser usar programaticamente os dados no
	// erro personalizado, você precisará pegar o erro como uma
	// instância do tipo de erro personalizado através de um tipo
	// afirmação.
	_, e := f2(42)
	if ae, ok := e.(*argError); ok {
		fmt.Println(ae.arg)
		fmt.Println(ae.prob)
	}
}
```
#### Goroutines e Canais
Goroutines são basicamente a forma que a linguagem da suporte a threads, para usar esse recurso basta passar a palavras reservada go e a função que será executada.

```go
go minha_funcao()
```
No mesmo contexto de threads, os Canais são a forma utilizada pela linguagem para sincroniza-las. O termo done é usado para sincronizar threads com esse recurso. Vejamos um exemplo abaixo utilizando Goroutines e canais:
```go
package main

import (
	"fmt"
	"time"
)

func say(s string, done chan string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
	done <- "Terminei"
	
}

func main() {
	done := make(chan string)
	go say("world", done)
	fmt.Println(<-done)
}

```


### Variáveis
Go é uma linguagem categorizada como fortemente tipada, ou seja, os tipos de dados são claramente explicitadas e não mudam durante o programa.
os termos *var* e *:=* são usados para declarar variáveis, sendo possível declarar mais de uma por vez. Caso uma variável não seja inicializada, ela tem o valor de zero para tipos numéricos, false para booleanos ou "" (Vazia) para Strings.


```go
//Declarando uma variável
var x int

//inicializado e declarando mais de uma variável
var z, y int = 10 , 5
```
### Tipos de dados
Go conta com tipos primitivos e tipos compostos de dados, vejamos alguns exemplos de ambos os caso.
##### primitivos:
```go
//Booleanos
var mortal bool = false
//String 
var nome string = Sócrates
//float32
var altura float32 = 1.83
```

##### compostos:
```go
//structs
type Pessoa struct {
    nome string
    vivo bool
}
//matrizes
Var matrizes [100]int32

//slices, uma "matriz" dinâmica.
var meu_slice[] int

//Maps: usada para associar chave e valor
map[TipoChave]TipoValor
```
### Funções

Funções são fundamentais no Go. Aprendendo alguns exemplos:

```go
package main
import "fmt"

//A função irá pegar dois inteiros e retorna sua soma como um int. 
//Go não vai retornar automaticamente o valor da última expressão, o tornando explícito.
func somaFrutas(laranja int, banana int) int {
    return laranja + banana
}
//Chama uma função como esperado, com nome(args).
func main() {
    qntFrutas := somaFrutas(1, 2)
    fmt.Println("1+2 =", qntFrutas)
}
```
```go
$ go run funções.go
1+2 = 3
```
### Múltiplos Valores
Go foi construído para suportar múltiplos valores de retorno. Esse recurso é usado muitas vezes na idiomática do Go, por exemplo para retornar ambos os resultados e valores de erros de uma função.
```go
package main
import "fmt"

//O (int, int) nessa assinatura de função vem mostrar que há dois retornos
func vals() (int, int) {
    return 3, 7
}

func main() {
//2 valores(empada e pastel) de retorno diferentes da chamada com múltiplas atribuições é usado

  empada, pastel := vals()
  fmt.Println(empada)
  fmt.Println(pastel)
  
//Um subconjunto de valores de retorno, usamos o identificador em branco _ para identificar e deixar 'obsoleto'
  _, bife := vals()
  fmt.Println(bife)
}
```

### Bibliotecas:
Go conta com uma biblioteca padrão cheia de recursos. Essa biblioteca padrão apresenta pacotes para criação de web Server, manipulação de bytes, ferramentas para trabalhar com criptografia e diversas outras funções.
Quando falamos de bibliotecas de terceiros a história é um pouco diferente. O suporte para eles é complicado. “go-elasticsearch”, a principal biblioteca ainda está com “in progress”. Outra biblioteca muito usada pela comunidade, a “go-mgo/mgo” não está mais sendo atualizada com seu ultimo commit sendo em 5 de julho do ano passado.



### Conclusão

Um tutorial breve e didático, traz uma roupagem de como funciona Go explicitando suas ferramentas e trazendo sua maneira simples e prática de programar. Como outras linguagens do seu principal paradigma, ela se torna para o programador uma aliada, assim adquirindo cada vez mais adeptos. E como vimos, uma linguagem trazendo uma solução para performance.

Aprender a utilizar a Go é uma boa alternativa para se diferenciar no mercado de trabalho e estar por dentro de uma linguagem que vem ganhando importância!

Para você que quer conhecer melhor a linguagem, existe diversos cursos online, como a:

* Alura (6)-> Sua interatividade o torna atrativo, entra afundo na linguagem.
* DevMedia (7)-> Com um vídeo introdutório, te coloca no mundo da Go.
* Udemy (8)-> Curso mais completo, tem um passo avançado para ir ainda mais afundo na linguagem.


### Referências
https://golang.org/ (1)
https://github.com/golang/go (2)
https://gopher.pro.br/post/variaveis/ (3)
https://www.freelancermap.com/freelancer-tips/pt/12165-aprender-google-go (4)
http://www.inf.ufes.br/~vitorsouza/wp-content/uploads/teaching-lp-20142-seminario-go.pdf (5)
https://www.alura.com.br/curso-online-golang (6)
https://www.devmedia.com.br/primeiros-passos-com-a-linguagem-google-go/34344 (7)
https://www.udemy.com/course/cursodego/ (8)
https://blog.mandic.com.br/artigos/porque-a-linguagem-go-e-a-mais-popular-de-todos-os-tempos/ (9)
https://medium.com/gommunity/operadores-c7e1a41cfd4 (10)
http://goporexemplo.golangbr.org/ (11)
https://medium.com/trainingcenter/goroutines-e-go-channels-f019784d6855 (12)