Se você já trabalha com Go a algum tempo, muito provavelmente você já conhece e utiliza o %s, %d e o \n. Pois bem, nesse post vamos abordar os principais os verbos disponíveis para te ajudar na hora de formatar uma string em Go.

Se você é novo em Go, saiba que os verbos que vamos abordar nesse post podem ser utilizados com as funções Printf, Sprintf e Errorf do package fmt, assim como as funções Fatalf, Panicf e Printf do package log.

Para começar, vamos a um exemplo bem simples utilizando somente os dois verbos que já comentamos. Digamos que nosso programa, sempre que alguém pede um novo café, exibe o nome da pessoa e a quantidade de café que ela consumiu no dia.

func main() {
    name := "Tiago"
    coffee := 5

    fmt.Printf("Olá %s, você já bebeu %d cafés hoje", name, coffee)
}

Ao ser executado, o %s será substituido pelo conteúdo da váriavel name, e o %d pela vafiável coffee.

Agora vamos fazer o print de uma variável do tipo ponto flutuante.

func main() {
    result := float32(7) / 3
    fmt.Printf("O resultado da divisão é %f", result)
}
// saída: O resultado da divisão é 2.333333

Por padrão o %f exibe 6 casas decimais, mas se você quiser mudar esse número é só adicionar o tamanho que deseja entre o % e o f.

func main() {
    result := float32(7) / 3
    fmt.Printf("O resultado da divisão é %.2f", result)
}
// saída: O resultado da divisão é 2.33

Você também pode limitar a largura da parte inteira do ponto flutuante.

func main() {
    result := float32(7) / 3
    fmt.Printf("O resultado da divisão é %10.2f", result)
}
// saída: O resultado da divisão é       2.33

Simples não?! Mas como podemos ver no exemplo abaixo, nem todo ponto flutuante pode ser tratado com %f.

func main() {
    pi := 3.14159265359
    fmt.Printf("O valor de pi é %f", pi)
}
// saída: O valor de pi é 3.141593

Ao executar esse programa, o resultado exibido está incorreto, já que o valor de PI não pode ser arredondado.

Para contornar esse problema, podemos usar o %v, que básicamente exibe qualquer valor em sua forma natural.

type Person struct {
    Name string
    Age  uint8
}

func main() {
    pi := 3.14159265359
    fmt.Printf("O valor de pi é %v\n", pi)

    person := Person{"Tiago", 31}
    fmt.Printf("%v", person)
}
// saída: O valor de pi é 3.14159265359
//        {Tiago 31}

Como %v exibe qualquer valor, vamos fazer uma pequena mudança nesse último programa para exibir o tipo de dado que está na variável. Essa mudança consiste em básicamente adicionar um %T a mensagem e duplicar a passagem da variável na função, para ela seja utilizada tanto para %T, como para o %v.

type Person struct {
    Name string
    Age  uint8
}

func main() {
    pi := 3.14159265359
    fmt.Printf("tipo: %T - O valor de pi é %v\n", pi, pi)

    person := Person{"Tiago", 31}
    fmt.Printf("tipo: %T - %v", person, person)
}
// saída: tipo: float64 - O valor de pi é 3.14159265359
//        tipo: main.Person - {Tiago 31}

Para finalizar, vou deixar uma tabela com os principais verbos disponíveis em Go.

Verbo	Descrição
%d	Inteiro em formato decimal
%x, %o, %b	inteiro dem formato hexadecimal, octal e binário
%f, %g, %e	número de ponto flutuante
%t	booleano
%c	runa (código Unicode, exibido como caractere)
%s	string
%q	string “abc” ou runa ‘c’ entre aspas
%v	qualquer valor em um formato natural
%T	tipo de qualquer valor
%%	sinal de porcentagem literal

Deixem suas dúvidas nos comentários.

Até a próxima!

Faça parte da comunidade!

Receba os melhores conteúdos sobre Go, Kubernetes, arquitetura de software, Cloud e esteja sempre atualizado com as tendências e práticas do mercado.