Imprimindo valores com Go

Imprimindo valores com Go

Um dos assuntos primordiais que você precisa aprender em toda linguagem de programação, está relacionado com a impressão de valores no console, ou melhor dizendo... como mostrar um texto puro por meio de suas aplicações.

E você já viu isso em lições anteriores, você se lembra? 😉

Anteriormente, nós chegamos a usar uma biblioteca chamada de FMT, que nos permitiu imprimir valores em nosso terminal (prompt de comando) por meio das nossas aplicações em Go.

E hoje, nos iremos nos concentrar nela!

Agora chega de papo, e vamos direto ao que interessa! 😋

Criando seu projeto de testes

Dentro da pasta JornadaGoLang, nos iremos criar uma nova pasta chamada de 4-imprimindo-valores-no-console, onde dentro dela, vamos criar o nosso arquivo main.go:

package main

func main(){

}

Feito isso, vamos aprender um pouco mais sobre a biblioteca FMT.

O que é a biblioteca FMT?

Ela nada mais é do que um pacote que já vem instalado por padrão junto ao GoLang, que é usada para realizar formatações de texto além de executar a saída dos mesmos.

Com ela você será capaz de fornece funções para imprimir e escanear entradas no console, formatar strings e lidar com a saída formatada de maneira eficiente.

Para usá-la em seu projeto, você precisa importá-la da seguinte forma:

import "fmt"

Ou caso você já tenha muitos imports dentro do seu arquivo, basta fazer isso da seguinte forma:

import (
      //..outros imports declarados aqui
      "fmt"
)

A utilização dessa biblioteca acontece de forma bem simples, onde podemos fazer o uso de algumas funções (Print(), Println() e Printf()) para mostrar valores no console.

Imprimindo valores com o FMT

Para imprimir valores no console, você pode fazer o uso de três principais funções:

Observação: antes de começarmos, certifique-se de que você importou a biblioteca FMT dentro do seu arquivo main.go:

package main

import "fmt"

func main(){

}

A primeira função que nós iremos usar é o Print(), que tem o objetivo de imprimir um determinado texto sem realizar uma quebra de linha, vejamos:

package main

import "fmt"

func main(){
	fmt.Print("Olá, ")
	fmt.Print("Micilini!")
}

Ao rodar o seu projeto (go run main.go), teremos a seguinte saída:

Olá, Micilini!

E sim, você pode repetir todas as funções disponíveis na biblioteca quantas vezes você quiser dentro da função main() 😀

A segunda função, é a Println(), que tem o objetivo de imprimir um determinado texto realizando uma quebra de linha, vejamos:

package main

import "fmt"

func main(){
	fmt.Println("Vamos aprender: ")
	fmt.Println("GoLANG!")
}

Ao rodar o seu projeto (go run main.go), teremos a seguinte saída:  

Vamos aprender:
GoLANG!

Perceba que houve um quebra de linha entre esses dois textos. O que é o comportamento esperado da função println().

Em seguida, nós temos o Printf() que também imprime valores no console, porém faz isso de forma um pouco mais avançada, tão avançada que você vai precisar dar uma olhada na próxima lição que fala sobre Variáveis em Go.

Mas não se preocupe, você pode voltar nesta lição quando você quiser 😁

package main

import "fmt"

func main(){
        nome := "João Vitor"
        idade := 25
        fmt.Printf("Nome: %s, Idade: %d\n", nome, idade)
}

Observe que estamos mostrando no console o resultado armazenado dentro das variáveis nome e idade. Observe também que usamos o \n para fazer uma quebra de linha após o final da mensagem (o mesmo pode ser aplicado no Print()).

Ao rodar o seu projeto (go run main.go), teremos a seguinte saída:    

Nome: João Vitor, Idade: 25

É importante ressaltar que dependendo do tipo de valor que a variável armazena, você pode utilizar alguns comandos (%s, %d...) diferentes, observe:

%s: para mostrar uma string.

%d: para mostrar um inteiro decimal.

%f: para mostrar um float (padrão 6 casas decimais).

%.2f: para mostrar um float com 2 casas decimais.

%t: para mostrar um booleano.

%v: para mostrar um valor no formato padrão.

%T: para mostrar o tipo da variável.

%p: para mostrar o endereço de memória.

Lendo valores com o FMT

Se é possível imprimir valores com o FMT, será que conseguimos ler o que o usuário digitou no console também por meio dele?

E a resposta é sim, para isso, você deverá usar algumas funções, como:

Observação: você vai precisar aprender a criar variáveis em GoLang antes de prosseguir adiante.

Começando pelo Scan(), ele é responsável por esperar uma entrada do usuário no terminal, e após o envio desse texto, a própria função o salva dentro de uma variável para que nós possamos usá-la depois:

package main

import "fmt"

func main(){
	//Scan():
	var nomeusuario string
        fmt.Print("Digite seu nome: ")
        fmt.Scan(&nomeusuario)
        fmt.Println("Seja bem-vindo,", nomeusuario)
}

Perceba que criamos uma variável chamada nomeusuario do tipo String que vai receber o valor digitado no console, e por fim, o mesmo será mostrado de volta ao usuário com uma mensagem de boas vindas.

Ao rodar o seu projeto (go run main.go), teremos essa saída:      

Digite seu nome: [seu nome]
Seja bem-vindo, [seu nome]

Observação: para enviar seu texto ao Scan() aperte [ENTER] do seu teclado.

No caso do Scanln(), o funcionamento é o mesmo, a diferença é que ele executa uma quebra de linha logo após a entrada do usuário:

package main

import "fmt"

func main(){
	//Scanln():
	var idadeusuario string
        fmt.Print("Digite sua idade: ")
        fmt.Scanln(&idadeusuario)
        fmt.Printf("Você tem: %s anos!", idadeusuario)
}

Ao rodar o seu projeto (go run main.go), teremos essa saída:        

Digite sua idade: [sua-idade]
Você tem: [sua idade] anos!

Aviso importante: se você tentou usar o Scan() em conjunto com o Scanln():

//Scan():
var nomeusuario string
fmt.Print("Digite seu nome: ")
fmt.Scan(&nomeusuario)
fmt.Println("Seja bem-vindo,", nomeusuario)

//Scanln():
var idadeusuario string
fmt.Print("Digite sua idade: ")
fmt.Scanln(&idadeusuario)
fmt.Printf("Você tem: %s anos!", idadeusuario)

Talvez você tenha notado, que a leitura do Scanln() não foi chamada. Isso aconteceu porque a função fmt.Scan() não consome a quebra de linha (\n) deixada pelo Enter, o que pode afetar a leitura subsequente do fmt.Scanln().

E a melhor forma de evitar este problema, é usar apenas Scanln() para ler strings completas.

Por fim, nós temos o Scanf(), que é capaz de ler entradas com formatação. Observe:

package main

import "fmt"

func main() {
    var nome string
    var idade int

    fmt.Print("Digite seu nome e idade (ex: João 25): ")
    fmt.Scanf("%s %d", &nome, &idade)

    fmt.Printf("Nome: %s, Idade: %d\n", nome, idade)
}

Note que estamos lendo os inputs deixados pelo usuário, ao mesmo tempo que já salvamos dentro de nossas variáveis.

🚨 Observação: Scanf() usa espaços como delimitadores, então "João Silva 25" falharia porque "%s" só pegaria "João".

Não se esqueça de que você pode usar aqueles comandos (%s, %d...) que vimos logo acima aqui também 🙂

Além disso, a biblioteca FMT conta com algumas funções capazes de escrever em arquivos de buffer, situações muito comuns quando abrimos um arquivo (.txt por exemplo), e queremos implementar mais conteúdo dentro dele.

Mas esse tipo de coisa só veremos em lições futuras, ok? 😌

Imprimindo erros com o FMT

Você também pode imprimir mensagens de erros com a biblioteca FMT, para isso, você pode usar a função Errorf() da seguinte forma:

package main

import "fmt"

func main(){
    //ErrorF():
    err := fmt.Errorf("ocorreu um erro inesperado")
    fmt.Println(err)
}

A saída será:

ocorreu um erro inesperado

Também é possível gerar erros com valores dinâmicos, observe:

package main

import "fmt"

func main(){
    //ErrorF():
    err := fmt.Errorf("ocorreu um erro inesperado: %d" , 5)
    fmt.Println(err)
}

Concatenando valores com FMT

Com a biblioteca, você também consegue concatenar alguns valores em string, e para isso, usamos as funções Sprint() e Sprintf(), ou mesmo usando Printf() para imprimir direto no console.

Começando pelo Printf(), se você possui dois valores do tipo texto, você pode usar o sinal de +:

fmt.Println("Olá " + "Mundo!");

fmt.Println("Olá " + "Mundo! " + "- Portal Micilini");

A mesma coisa pode ser aplicada caso você tenha uma variável que seja do tipo string:

x := "Micilini"
fmt.Println("Olá " + "Mundo! "  + x)

Entretanto, quando você tem um outro tipo que não é do tipo string, como por exemplo um número:

x := 12
fmt.Println("Olá " + "Mundo! "  + x)

O compilador do GoLang te retornará um erro de conversão. E para resolver isso, você pode fazer o uso do Sprint() da seguinte forma:

pi := 3.1415

piString := fmt.Sprint(pi)
fmt.Println("O valor de PI é: " + piString)

Note que o Sprint() converteu o valor em uma string antes de enviá-la para o Println().

Já o Sprintf(), como você já deve imaginar, ele adiciona uma quebra de linha no final:

nometres := "Maria"
idadetres := 30
salariotres := 3500.75

// Usando fmt.Sprintf para formatar uma string
mensagemtres := fmt.Sprintf("Olá, meu nome é %s, tenho %d anos e meu salário é R$ %.2f.", nometres, idadetres, salariotres)

fmt.Println(mensagemtres)

Observe também que o uso da virgula nos possibilita fazer concatenações sem conversões:

nomedois := "Ana"
idadedois := 28

fmt.Println("Nome:", nomedois, "| Idade:", idadedois)

A mesma coisa pode ser observada quando usamos aqueles comandos que vimos no começo desta lição:

fmt.Printf("Nome: %s, Idade: %d\n", nomeum, idadeum)

Incrível, não acha? 😎

Repositório da lição

Todos os arquivos relacionados com esta lição, podem ser encontrados nos seguintes repositórios abaixo:

Conclusão

Nesta lição, você aprendeu a imprimir valores no console por meio da biblioteca FMT.

E como já iniciamos o assunto de variáveis antes da hora, que tal aprendermos um pouco mais sobre elas na próxima lição?

Te aguardo lá!