---
# System prepended metadata

title: Linguagem Go para Iniciantes

---

# Linguagem Go para Iniciantes

![](https://sentry.io/_assets/logos/go-9192ee98c4a9c19c96b7f69825b3445638c3a4b6129c936012acf74390bfe240.svg =400x)

## 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