Para a conversão de valores envolvendo strings, vamos utilizar as funções contidas no package strconv disponibilizada pela linguagem Go. Com esse package, temos acesso às funções de conversão de valores do formato string para formato int, float e etc.

Sintaxe

import "strconv"

O assunto casting em Go pode ser visto em Go Básico: Cast. A formatação de dados pode ser vista em Go Básico: Formatação de Dados.

Para a conversão de dados primitivos, vamos utilizar as funções mostradas na sintaxe abaixo:

Sintaxe

func FormatInt(i int64, base int) string

func FormatInt(i UInt64, base int) string

func FormatFloat(f float64, fmt byte, prec int, bitSize int) string

func FormatBool(x bool) string

func Itoa(i int) string

func Atoi(s string) (int, error)

func ParseInt(s string, base int, bitSize int) ( int64, error ) 

func ParseFloat(s string, bitSize int) (float64, error)

func ParseBool(str string) (bool, error)

Onde

i,f,x,s: valores para conversão
base: base numérica 2, 10, 16. São aceitas bases até 36.
fmt: formato: 
    'b': -ddddp±ddd
    'e':-d.dddde±dd
    'f': -ddd.dddd
    'x':-0xd.ddddp±ddd
prec: número de casas decimais
bitSize: tamanho do dado em bits: 8, 16, 32 e 64

Exemplo 1

package main

import (
	"fmt"
	"strconv"
)

func main() {

	a := strconv.Itoa(12)
	fmt.Printf("%q\n", a)

	// string -> inteiro
	b, _ := strconv.Atoi("12")
	fmt.Printf("%d\n", b)

	// string -> bool
	c, _ := strconv.ParseBool("true")
	fmt.Printf("%t\n", c)

	// string -> float
	d, _ := strconv.ParseFloat("9.99", 32) //32 bits
	fmt.Printf("%0.2f\n", d)

	// string -> int
	e, _ := strconv.ParseInt("100", 10, 32) //base 10, 32bits
	fmt.Printf("%d\n", e)

	// string -> int
	f := strconv.FormatInt(-1, 10)
	fmt.Printf("%q\n", f)

	g := strconv.FormatFloat(9.99, 'f', 2, 32)
	fmt.Printf("%q\n", g)

	h := strconv.FormatBool(false)
	fmt.Printf("%q\n", h)

}

Saída

"12"
12
true
9.99
100
"-1"
"9.99"
"false"

Com o novo tipo de dados criado acima podemos criar, por exemplo, vetores de ponteiros para função como mostrado no exemplos abaixo:

Exemplo 2

package main

import (
	"fmt"
	"time"
)

func main() {
    
    dataNow := time.Now(); //data do momento
    
    //data para string
    str_data := fmt.Sprintf("%02d/%02d/%d",dataNow.Day(),dataNow.Month(),dataNow.Year())
    
    //data-string para data/hora
    data, _ := time.Parse("2/1/2006", str_data) //layout 2/1/2006" -> dd/mm/aaaa

	ano, mes, dia := data.Date()
	
	fmt.Printf("%02d-%02d-%d", dia, mes, ano)
}

Saída

08/09/2025
08/09/2025

Caso seja necessário a conversão de um valor hexadecimal contido em uma string para um tipo numérico inteiro, por exemplo, usamos as funções ParseUint ou ParseInt do package strconv:

Sintaxe

func FormatInt(s string, <base> int, bitSize int) (i int64, err error)
func FormatUInt(s string, <base> int, bitSize int) (i uint64, err error)

Onde

s: string contendo valor
<base>: base numérica para conversão
bitSize: tamanho do valor em bits contido em s

Exemplo 3

package main

import (
	"fmt"
	"strconv"
)

func main() {
	shex, _ := strconv.ParseUint("ABCD", 16, 16) //base: 16 , bitSize: 16-bits
	fmt.Printf("%X", shex)
}

Saída

ABCD

A conversão oposta ao que foi visto no exemplo acima em que um valor inteiro para string hexadecimal, pode ser feita utilizando a função Sprintf do package fmt como pode ser visto no exemplo a seguir:

Sintaxe

func Sprintf(format string, <a> ...any) string

Onde

format: string com formatar para conversão
<a>: valor inteiro. decimal ou hexadecimal

Exemplo 4

package main

import (
	"fmt"
)

func main() {

	shex := fmt.Sprintf("%x", 0xabcd)
	fmt.Println(shex)

	shex = fmt.Sprintf("%04x", 0x00cd) //padding com zero
	fmt.Println(shex)
}

Saída

abcd
00cd

1. 30/10/2025 - revisão 4 - Adição: sintaxe FormatUInt - 'funções básicas', Conversão 'string hex <-> int'
2. 08/09/2025 - revisão 3 - Ajustes: pontuais, sintaxes e target de links internos; Adição: conversão 'data'
3. 16/09/2024 - revisão 2 - Ajustes gramaticais
4. 30/08/2024 - revisão 1 - Correção em links de objetivos
5. 21/08/2023 - versão inicial