O Go (ou golang) é uma linguagem criada em 2007 pela equipe de desenvolvimento do Google. Tinha como objetivo facilitar o desenvolvimento de sistemas sem a necessidade de se utilizar outras linguagens de programação.
Vamos ver neste artigo suas principais estruturas de controle, bem como a criação de funções.
O famoso olá mundo!
Normalmente, o primeiro exercício em uma linguagem desconhecida da gente é o "olá mundo". Apenas escrevemos código na nova linguagem que exibe essa mensagem.
Embora não pareça nada demais, é um indicativo de que o seu ambiente foi corretamente construído, para que você possa realmente aprender a nova ferramenta.
No caso do Go, é um pouco mais simples que outras linguagens, como Java por exemplo:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
}
Para rodarmos esse programa por linha de comando, não precisamos compilá-lo antes. Basta que salvemos esse código num arquivo .go (olamundo.go, por exemplo):
$ go run olamundo.go
Olá mundo Go!
Declarar variáveis também é bem simples:
numero1 := 1
Nesse caso, estamos declarando uma variável chamada numero1, e atribuindo o valor 1 a ela. Note o operador de atribuição ( :=).
Essa atribuição foi feita logo abaixo da mensagem inicial:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
}
Vamos então rodar esse programa...ops!
$ go run olamundo.go
# command-line-arguments
./olamundo.go:8:2: numero1 declared and not used
Repare que declaramos uma variável, mas esta não é usada em nenhuma parte do sistema, o que faz com que o interpretador go lance um erro de compilação. Esse recurso é bem interessante, pois disciplina o programador a manter somente o código que ele precisa. O time de criação da linguagem justifica a inclusão dessa característica no FAQ da linguagem. Basicamente:
The presence of an unused variable may indicate a bug, while unused imports just slow down compilation, an effect that can become substantial as a program accumulates code and programmers over time. For these reasons, Go refuses to compile programs with unused variables or imports, trading short-term convenience for long-term build speed and program clarity.
Logo, verificamos que eles se preocuparam não somente com variáveis que não são usadas, mas também com imports desnecessários, que podem fazer com que o processo de compilação fique mais lento. A explicação completa pode ser vista em https://golang.org/doc/faq#unused_variables_and_imports
Para que possamos remover esse erro, devemos dar uma finalidade a essa variável. No nosso caso, vamos apenas imprimir seu valor:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
fmt.Println(numero1)
}
E temos como saída:
$ go run olamundo.go
Olá mundo Go!
1
Nada muito inesperado, não é mesmo? Repare que, diferente de outras linguagens como Java por exemplo, a sintaxe é menos verbosa e burocrática. Não precisamos colocar ponto-e-vírgula no final de nossas instruções.
Podemos declarar outro número, e somarmos os 2, gerando um terceiro número:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
fmt.Println(numero1)
numero2 := 2
numero3 := numero1 + numero2
fmt.Println(numero3)
}
E se precisarmos comparar ambos os números, imprimindo quem é o maior? Teremos que comparar os números. Para isso, podemos usar instruções if/else e fazer as comparações:
if numero1 < numero2 {
fmt.Println("O número 1 é menor que o número 2")
} else if(numero1 == numero2){
fmt.Println("Os números 1 e 2 são iguais")
} else {
fmt.Println("O número 1 é maior que o número 2")
}
Repare que as instruções if podem ou não ter sua condicional entre parênteses. Normalmente elas são escritas sem os parênteses mesmo. Fiz aqui apenas para mostrar que é possível.
Podemos inclusive refatorar este código, de forma que tenhamos apenas uma instrução de impressão de mensagens para todos esses condicionais. Para isso, podemos declarar uma variável do tipo String:
var mensagem string
E atribuir valores a ela de acordo com as condicionais:
if numero1 < numero2 {
mensagem = "O número 1 é menor que o número 2"
} else if(numero1 == numero2) {
mensagem = "Os números 1 e 2 são iguais"
} else {
mensagem = "O número 1 é maior que o número 2"
}
fmt.Println(mensagem)
Há alguns pontos a se considerar. Diferente da maioria das linguagens, a declaração de variáveis do Go começa com a palavra chave var, seguida do nome da variável. Não há necessidade de declarar o tipo, embora possa ser necessário numa variável como essa, que pode ser usada em diversos pontos da função, garantindo que qualquer atribuição a ela seja do tipo declarado.
Além disso, note como a atribuição de valores à variável mensagem foi feita. Agora não usamos mais o operador :=, mas apenas o = . Para o Go, quando inicializamos uma variável com um determinado valor (o caso dos números por exemplo) usamos o primeiro operador. Nos demais, o segundo.
Mas, e se precisarmos verificar todos os números divisíveis por 5 entre 0 e 100, por exemplo? Para isso, podemos usar um looping, juntamente com o if:
for i := 0; i <= 50; i ++ {
if i % 5 == 0 {
fmt.Println(i, " é um número divisível por 5")
}
}
Repare que, assim como o if, o for também não precisa de parênteses. Esta característica, combinada com outras da linguagem, contribuem para tornar o código menos verboso.
Além disso, fizemos a concatenação entre o valor de i e uma string (com s minúsculo mesmo. Diferente de linguagens como Java por exemplo (e semelhante ao C#), string escreve-se com letra minúscula).
A saída desse código será:
$ go run olamundo.go
Olá mundo Go!
1
3
O número 1 é menor que o número 2
0 é um número divisível por 5
5 é um número divisível por 5
10 é um número divisível por 5
15 é um número divisível por 5
20 é um número divisível por 5
25 é um número divisível por 5
30 é um número divisível por 5
35 é um número divisível por 5
40 é um número divisível por 5
45 é um número divisível por 5
50 é um número divisível por 5
Agora que vimos as principais estruturas de controle em Go, vamos revisitar o código que já criamos:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
fmt.Println(numero1)
numero2 := 2
numero3 := numero1 + numero2
fmt.Println(numero3)
var mensagem string
if numero1 < numero2 {
mensagem = "O número 1 é menor que o número 2"
} else if(numero1 == numero2) {
mensagem = "Os números 1 e 2 são iguais"
} else {
mensagem = "O número 1 é maior que o número 2"
}
fmt.Println(mensagem)
for i := 0; i <= 50; i ++ {
if i % 5 == 0 {
fmt.Println(i, " é um número divisível por 5")
}
}
}
Temos código que lida com tarefas diferentes. Podemos organizá-lo em funções.
Comecemos com nosso primeiro cenário: a soma de 2 números:
numero1 := 1
fmt.Println(numero1)
numero2 := 2
fmt.Println(soma2numeros(numero1, numero2))
A função soma2numeros está abaixo:
func soma2numeros(n1, n2 int)
int {
return n1 + n2
}
Como os argumentos da função são do mesmo tipo, podemos simplificar a declaração de tipos, especificando-o apenas uma vez. Além disso, de forma semelhante à declaração de variáveis, colocamos o retorno da função no final de sua assinatura. Essa maneira de declarar tipos, seja de variáveis ou de funções, é algo a se destacar no Go, visto que a maioria das linguagens coloca a declaração de tipo antes da variável ou da função.
Podemos criar também uma função para encapsular a verificação de qual número é maior. Essa não retornará nada. Apenas exibirá no console quem é o maior número. O código dessa função está abaixo:
func qualEhOMaiorNumero(n1, n2 int){
var mensagem string
if n1 < n2 {
mensagem = "O número 1 é menor que o número 2"
} else if(n1 == n2) {
mensagem = "Os números 1 e 2 são iguais"
} else {
mensagem = "O número 1 é maior que o número 2"
}
fmt.Println(mensagem)
}
Como podemos ver, como ele não retorna nada, não colocamos nenhum tipo de retorno. Agora é só chamar a função no método main(), substituindo o código anterior por ela:
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
fmt.Println(numero1)
numero2 := 2
fmt.Println(soma2numeros(numero1, numero2))
qualEhOMaiorNumero(numero1, numero2)
for i := 0; i <= 50; i ++ {
if i % 5 == 0 {
fmt.Println(i, " é um número divisível por 5")
}
}
}
Por último, vamos encapsular o código que verifica quais os números divisíveis por 5:
func numerosDivisiveisPor5Entre0e50(){
for i := 0; i <= 50; i ++ {
if i % 5 == 0 {
fmt.Println(i, " é um número divisível por 5")
}
}
}
E o nosso código final ficará assim:
package main
import "fmt"
func main(){
fmt.Println("Olá mundo Go!")
numero1 := 1
fmt.Println(numero1)
numero2 := 2
fmt.Println(soma2numeros(numero1, numero2))
qualEhOMaiorNumero(numero1, numero2)
numerosDivisiveisPor5Entre0e50()
}
func soma2numeros(n1, n2 int) int {
return n1 + n2
}
func qualEhOMaiorNumero(n1, n2 int){
var mensagem string
if n1 < n2 {
mensagem = "O número 1 é menor que o número 2"
} else if(n1 == n2) {
mensagem = "Os números 1 e 2 são iguais"
} else {
mensagem = "O número 1 é maior que o número 2"
}
fmt.Println(mensagem)
}
func numerosDivisiveisPor5Entre0e50(){
for i := 0; i <= 50; i ++ {
if i % 5 == 0 {
fmt.Println(i, " é um número divisível por 5")
}
}
}
Considerações finais
Vimos como criar estruturas básicas de controle em Go, tais como declaração de variáveis, if/else, loopings e funções. Com esses recursos, é possível a criação de programas simples em Go.
Entretanto, caso queira saber mais, há o livro Programando em Go, do Caio Filipini, disponível na Casa do Código.
E aqui na Alura temos alguns curso para iniciar sua carreira em GO.
Bons estudos e até a próxima!
