Golang: Package fmt (Parte

Umas das primeiras bibliotecas que você vai usar em Go é o fmt.

Ele fornece funções para formatar e exibir texto de maneira semelhante ao printf do C, mas com algumas melhorias e simplificações.

Principais Funcionalidades do Pacote fmt

O pacote fmt pode ser dividido em três categorias principais:

Funções de impressão formatada (funções Print, Printf, Println).
Formatação de strings (funções Sprintf, Sprint, etc.).
Leitura de dados do usuário (funções Scan, Scanf, etc.).

Funções de Impressão

Print() Escreve na saída padrão, sem quebra de linha no final Println() Escreve na saída padrão, adicionando espaços entre valores e quebra de linha Printf() Formatação estilo printf (com verbos de formatação)

Exemplo:

package main

import "fmt"

func main() {
    // Print: imprime sem nova linha
    fmt.Print("Hello, ")
    fmt.Print("World!") // Saída: Hello, World!

    // Println: imprime com nova linha
    fmt.Println("Hello, World!") // Saída: Hello, World!\n

    // Printf: imprime com formatação
    name := "Lucas"
    age := 25
    fmt.Printf("Name: %s, Age: %d\n", name, age) // Saída: Name: Lucas, Age: 25
}

Formatação de Strings

Sprint() Retorna string em vez de imprimir Sprintln() Como Sprint() mas com espaços e nova linha Sprintf() Formatação que retorna string

Exemplo:

package main

import "fmt"

func main() {
    // Sprintf: retorna uma string formatada
    name := "Lucas"
    age := 25
    formatted := fmt.Sprintf("Name: %s, Age: %d", name, age)
    fmt.Println(formatted) // Saída: Name: Lucas, Age: 25

    // Sprint: retorna uma string concatenada
    concatenated := fmt.Sprint("Hello, ", "World!")
    fmt.Println(concatenated) // Saída: Hello, World!

    // Sprintln: retorna uma string concatenada com nova linha
    withNewLine := fmt.Sprintln("Hello,", "World!")
    fmt.Print(withNewLine) // Saída: Hello, World!\n
}

Leitura de Dados

Scan(): Lê entradas do usuário separadas por espaço. Scanln(): Lê entradas do usuário até o final da linha. Scanf(): Lê entradas formatadas do usuário.

Exemplo:

package main

import "fmt"

func main() {
    var name string
    var age int

    // Scan: lê entradas separadas por espaço
    fmt.Print("Enter your name and age: ")
    fmt.Scan(&name, &age)
    fmt.Printf("Name: %s, Age: %d\n", name, age)

    // Scanln: lê até o final da linha
    fmt.Print("Enter your name: ")
    fmt.Scanln(&name)
    fmt.Printf("Name: %s\n", name)

    // Scanf: lê entradas formatadas
    fmt.Print("Enter your name and age (format: Name Age): ")
    fmt.Scanf("%s %d", &name, &age)
    fmt.Printf("Name: %s, Age: %d\n", name, age)
}

Verbos de Formatação

Os verbos de formatação são usados para especificar como os dados devem ser formatados. Aqui estão alguns dos mais comuns:

Tipos Gerais:

%v: Valor padrão do tipo.
%+v: Valor padrão com os nomes dos campos (para structs).
%#v: Representação Go do valor (útil para depuração).
%T: Tipo do valor.
%%: Um literal %. Tipos Numéricos:
%d: Inteiro decimal.
%b: Binário.
%o: Octal.
%x ou %X: Hexadecimal (minúsculo ou maiúsculo).
%f: Ponto flutuante.
%e ou %E: Notação científica. Strings e Caracteres:
%s: String.
%q: String entre aspas.
%c: Caractere Unicode.
%U: Código Unicode.

Booleanos

%t: Valor booleano (true ou false).

Exemplo:

package main

import "fmt"

func main() {
    x := 26
    s := "Lucas"
    b := true

    fmt.Printf("Valor: %v, Tipo: %T\n", x, x) // Saída: Valor: 26, Tipo: int
    fmt.Printf("String: %q\n", s)            // Saída: String: "Lucas"
    fmt.Printf("Booleano: %t\n", b)          // Saída: Booleano: true
}

Existem o io.Reader e o io.Writer, que são bibliotecas que abstraem a leitura e escrita de dados. Para fluxos de dados, como arquivos ou redes. Mas vou falar mais sobre eles em outro artigo.