Go Academy · Aula

Conversões de tipos em Go

Conversões explícitas, aliases de tipos e tipos definidos

Aula 4 de 412 etapas

Conversões de tipos em Go é uma aula grátis de Go Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Go Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Go Academy inclui 4 aulas no total.

Por que usar conversões explícitas?

Go nunca converte implicitamente entre tipos. Isso evita erros sutis nos quais um inteiro pequeno ultrapassa silenciosamente o limite de um tipo maior ou um número de ponto flutuante perde precisão.

As conversões precisam ser escritas explicitamente: T(value)
O compilador detecta tipos incompatíveis em tempo de compilação
Isso torna o código Go previsível e seguro

Conversões numéricas

Converta entre tipos numéricos usando o tipo de destino como uma chamada de função:

package main

func main() {
    var i int = 42
    var f float64 = float64(i)
    var u uint = uint(f)
    _ = u
}

Risco de truncamento

Converter de um tipo maior para um menor trunca o valor. Nenhum erro é gerado — é preciso ter cuidado:

package main

func main() {
    big := int64(300)
    small := int8(big) // 300 % 256 = 44 — silent truncation!
    _ = small
}

Conversões entre string e []byte

Converter entre string e []byte copia os dados:

package main

func main() {
    s := "hello"
    b := []byte(s)   // string to byte slice
    b[0] = 'H'
    s2 := string(b)  // byte slice to string
    _ = s2
}

string e []rune

Para manipular caracteres com segurança em Unicode, converta para []rune:

package main

func main() {
    s := "Merhaba"
    runes := []rune(s)
    _ = len(runes) // character count, not byte count
}

Pacote strconv

Para converter entre strings e números, use o pacote strconv:

import "strconv"

func main() {
    n, err := strconv.Atoi("42")   // string -> int
    s := strconv.Itoa(123)          // int -> string
    _ = n; _ = err; _ = s
}

strconv.ParseFloat e FormatFloat

Analise e formate strings de ponto flutuante com segurança:

import "strconv"

func main() {
    f, err := strconv.ParseFloat("3.14", 64)
    if err != nil { return }
    s := strconv.FormatFloat(f, 'f', 2, 64) // "3.14"
    _ = s
}

Aliases de tipo vs tipos definidos

Go diferencia aliases de tipo e tipos definidos:

type Celsius float64 — novo tipo definido; precisa de conversão explícita de e para float64
type Celsius = float64 — alias; é intercambiável com float64

Exemplo de tipo definido

Os tipos definidos melhoram a clareza da API e evitam misturas acidentais:

type Celsius float64
type Fahrenheit float64

func CtoF(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

func main() {
    boiling := Celsius(100)
    _ = CtoF(boiling)
}

Conversões de interfaces

Qualquer valor pode ser convertido para um tipo de interface que ele satisfaz. Para convertê-lo de volta, é necessária uma asserção de tipo:

var i interface{} = "hello"
s, ok := i.(string) // type assertion
if ok {
    _ = s // safe to use
}

Verificação rápida

Qual função converte uma cadeia de caracteres em um inteiro em Go?

Responda na aula interativa

Recapitulação: conversões de tipos

Principais conclusões sobre conversões de tipos em Go:

Go nunca faz conversões implícitas — use a sintaxe T(value)
Conversões numéricas podem truncar valores — seja explícito quanto ao risco
[]byte(s) e string(b) copiam os dados
Use strconv.Atoi / strconv.Itoa para conversões entre cadeias de caracteres e números
Tipos definidos exigem conversões explícitas; apelidos de tipo não

Próximo curso: controle de fluxo com if, for e switch.

Grátis para começar

Aprenda Go com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Conversões de tipos em Go” é grátis?

Sim — o texto completo de “Conversões de tipos em Go” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Go Academy, atualize para CoddyKit PRO. O curso de Go Academy inclui 4 aulas no total.

O que vou aprender em “Conversões de tipos em Go”?

Conversões explícitas, aliases de tipos e tipos definidos Você pratica Go Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Go Academy?

Nenhuma experiência prévia é necessária. Go Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Conversões de tipos em Go”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Go Academy?

Sim. Cada aula de Go Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Go Academy