# Linguagem Go para Iniciantes
## Autores
* Alexander Dorneles
* André Hoffmann
* Ariel Azzi
* Carlos Machado
* Gian Boschetti
## Introdução
A linguagem Go, também conhecida como Golang, é utilizada para programação procedural, funcional, orientado a objetos e concorrente, ou seja a linguagem é multiparadigma. Desenvolvida na empresa Google por Robert Griesemer, Rob Pike e Ken Thompson em 2007, e lançada "Open Source" em 2009. Os programas são estruturados utilizando pacotes, a fim de obter um gerenciamento eficiente de dependências.
### Importância e potêncial da linguagem
Go foi criada como uma linguagem à prova do futuro para enfrentar os desafios do presente e antecipar os desafios do futuro. Ele é compilado para a fim de fornecer um feedback mais rápido que provê economia de tempo e dinheiro. Esta linguagem possui um coletor de lixo automático, tornando o uso da memória da máquina mais eficiente, todavia variaveis sem utilização serão limpas da memória.
### Empresa que a usam
As empresas que já aderiram o Go são: Google, YouTube, Apple, Docker, BBC, The Economist, The New York Times, IBM, Twitter e Facebook.
## Hello World
Para realizarmos o nosso primeiro teste, faremos o famoso hello world. Sendo necessário importar o pacote "fmt", para utilizar o Println.
```go=
package main
import "fmt"
func main() {
fmt.Println("Hello World!")
}
```
## Variáveis e Tipo de Dados
Para declararmos variáveis é necessário iniciar com a declaração var que funciona como uma lista de variáveis e onde por fim passamos o tipo das variáveis.
A variável pode ou não ser inicializada, caso seja, não é necessária o tipo da variável pode ser omitida, assumindo o tipo do inicializador.
```go=
var i, j int = 1, 2
```
Outra forma de declarar as variáveis é utilizando a forma curta onde declaramos o nome da variável seguido pelo simbolo **:=** que e por fim o valor, assim, será atribuido à variável o tipo referente ao valor.
```go=
a := 3
b, c, d := true, false, "Hello!"
```
Para declarar constantes é necessário colocar a palavra reservada const na frente do nome da variável, constantes não podem ser declaradas com a sintaxe **:=**.
```go=
const Pi = 3.14
```
No exemplo acima não foi informado um tipo para á constante, mas como declaramos ela como numérica com casa decimal, a variável recebe um tipo **float64**.
## Tipos de Dados
Os tipos de dados em Go podem ser representados por valores numéricos, booleanos, strings e números complexos.
Para os números complexos o Go providencia dois tamanhos distintos, **complex64** e **complex128**. O tipo complex pode construir uma função matemática para valores reais e imaginários, como por exemplo na seguinte declaração,
**var x complex128 = complex(1, 2)** // 1+2i.
Existem diversas formas de declarar tipos inteiros, variando o número de bytes no final da palavra int, também podendo conter a letra **u** no ínicio da declaração, indicando que o número será unsigned (sem sinal ou positivo).
O tipo float indica que o valor será flutuante, ou seja, a variável pertence aos números reais, podendo ter 32 e 64 bytes.
```go=
bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // pseudônimo para uint8
rune // pseudônimo para int32
float32 float64
complex64 complex128
```
Exemplo de declarações:
```go=
func main() {
var i int
var f float64
var b bool
var s string
}
```
Quando uma variável não recebe um valor inicial explícito, ela recebe valor 0 para tipos numéricos, false para booleanos e "" para strings.
### Array e Matriz
Para declarar um array e/ou matriz, é muito similar com outras linguagens de programação, como Java.
Uma matriz é o mesmo que um array bi-dimensional ou maior.
Exemplo array
```go=
func main() {
var v [5]int //valor 5 indica o tamanho do array
var v2 :=int{1,2,3,4,5}
}
```
Exemplo matriz
```go=
func main() {
var v [5][2]int //valor 5 indica o tamanho da linha e o 2 o tamanho da coluna da matriz
}
```
### Slice
Diferente das matrizes que possuem tamanho fixo o slice pode ser definido como dinamicamente redimensionavel, sendo geralmente usado com mais frequência do que as matrizes e podendo ser comparado à estruturas de listas utilizada por outras linguagens de programação.
A formação do slice é definida por exemplo **a[min : max]**, onde o **min** seria o limite inferior e **max** o limite superior do slice.
Neste intervalos entre o valor minimo e máximo do slice, o valor minimo é incluído e o valor máximo é excluído.
```go=
func main() {
var s []int = numbers[1:4]
}
```
Também podemos utilizar a função **make** para criar slices, facilitando a construção para as estruturas de armazenamento, funcionando assim como criar matrizes dinamicamente.
```go=
func main() {
a := make([]int, 5) // slice a com tamanho 5
}
```
## Operações Básicas
Go disponibiliza vários tipos de operadores, seguindo uma formatação comum em várias linguagens:
- Operadores Aritméticos: `+`,`-`,`*`,`/`,`%`
- Operadores de Comparação:`==`, `!=`, `<`, `>`, `>=`, `<=`
- Operadores de incrementação/decrementação: `++`, `--`
### Exemplos
```go=
var a = 5;
var b = 2;
var soma = a+b; // Resultado: 7
var divisao = a/b; // Resultado: 2
var comparacaoIg = a==b; // Resultado:false
var comparacaoSup = a>=b; //Resultado: true
var resultado = (a+b)*(a-b)/2; // Resultado: 10
```
## Estrutura da linguagem
Go disponibiliza estruturas com sintaxe simples e com leitura fluida. É uma linguagem baseada em funções e nessa não possui classes, assim como heranças.
### Controle de fluxo
#### Condição if
``` go=
import "fmt"
if 7%2 == 0 {
fmt.println("7 é par");
} else {
fmt.println("7 é impar");
}
```
#### Condição switch
``` go=
var i = 6/2;
fmt.Print("Escreva ", i, " como ");
switch i {
case 1:
fmt.Println("um");
case 2:
fmt.Println("dois");
case 3:
fmt.Println("três");
}
```
### Laços de Repetição
``` go=
for j := 7; j <= 9; j++ {
fmt.Println(j)
}
```
Em Go não existe o laço de repetição `while`, sendo utilizado o comando `for` com a mesma estrutura
``` go=
var i = 1
for i <= 3 {
fmt.Println(i)
i = i + 1
}
```
### Funções
Para criar uma função é necessário o comando `func` , os parâmetro (com seu tipo), e o tipo do retorno
Atenção: O tipo do parâmetro vem **após** o seu nome
``` go=
package main
import "fmt"
func add(x int, y int) int {
return x + y
}
func main() {
fmt.Println(add(42, 13)) // Resultado: 55
}
```
O Go permite que uma função retorne mais de um valor ao mesmo tempo. Para isto é necessário declarar seus tipos conforme o exemplo
``` go=
package main
import "fmt"
func swap(x, y string) (string, string) {
return y, x
}
func main() {
a, b := swap("hello", "world")
fmt.Println(a, b) //Resultado: "world hello"
}
```
Você também pode fazer recursões:
``` go=
func fatorial(n int) int {
if n == 0 {
return 1
}
return n * fatorial(n-1)
}
```
### Tratamento de Exceções
Go não contém a estrutura `try/catch`, como é comum em outras linguagens. Seu tratamento de exceções é da seguinte forma:
``` go=
package main
import (
"fmt"
"os"
)
func main() {
f, err := os.Open("filename.ext")
if err != nil {
log.Fatal(err)
}
}
```
## Pacotes
Devido a linguagem ser baseada em pacotes, existem uma infinidade desses. No site da linguagem, https://golang.org/pkg/, pode-se encontrar os pacotes disponíveis. Para você utilizar um pacote, deve-se realizar o comando import com os nomes do pacotes desejados como no exemplo a seguir:
``` go=
package main
import (
"fmt"
"os"
)
```
## Conclusão
Como a linguagem Go é uma linguagem compilada, com tipificação rígida, e é digitada estaticamente, as pessoas que desenvolvem utilizando essa devem ser muito atentos, de tal forma que seus códigos sejam limpos, assim como seguros.
A linguagem Go pelo fato de ser de rápida execução e consumir pouco processamento, está sendo cada vez mais utilizada em programas complexos.
## Referências:
* https://golang.org
* https://go-tour-br.appspot.com/basics/2
* https://www.geeksforgeeks.org/go-programming-language-introduction/
* https://qarea.com/blog/8-reasons-you-need-to-go-golang
* https://callicoder.com/golang-basic-types-operators-type-conversion
* https://gobyexample.com/
* https://www.oreilly.com/library/view/the-go-programming/9780134190570/ebook_split_030.html
* https://www.tutorialspoint.com/go/go_multi_dimensional_arrays.htm
Google Drive
Gist
Clipboard
Sign in with Wallet
