Go, também conhecida como Golang, é uma linguagem de tipo estaticamente. Isso significa que o tipo de cada variável é conhecido em tempo de compilação, proporcionando segurança e previsibilidade ao seu código. No entanto, isto também exige que qualquer conversão de um tipo para outro seja explícita e deliberada. Neste artigo, exploraremos os vários mecanismos de conversão e conversão de tipos disponíveis no Go, desde conversões numéricas básicas até interfaces mais complexas e conversões de ponteiro.

1. Conversões de tipo básico

Go permite a conversão entre tipos básicos como números inteiros, números de ponto flutuante e strings, mas essas conversões devem ser feitas explicitamente.

Tipos Numéricos

As conversões entre diferentes tipos numéricos são diretas, mas devem ser explícitas:

var i int = 42
var f float64 = float64(i)  // int to float64
var u uint = uint(i)        // int to uint

Neste exemplo, convertemos um int em float64 e em uint. Essas conversões são explícitas porque Go não realiza conversões de tipo automáticas (implícitas).

Fatia de string e byte

Go strings são imutáveis, mas podem ser convertidas de e para fatias de bytes ([]byte), que são mutáveis:

var s string = "hello"
var b []byte = []byte(s)   // string to []byte
var s2 string = string(b)  // []byte to string

Da mesma forma, você pode converter entre strings e fatias de runas ([]rune), onde rune é um alias de tipo para int32:

var r []rune = []rune(s)   // string to []rune
var s3 string = string(r)  // []rune to string

2. Conversões de tipo personalizado

No Go, você pode definir seus próprios tipos com base nos existentes. As conversões entre tipos personalizados e seus tipos subjacentes são explícitas:

type MyInt int
var i int = 10
var mi MyInt = MyInt(i)   // int to MyInt
var i2 int = int(mi)      // MyInt to int

Esta conversão explícita é necessária para garantir que o compilador possa verificar a segurança do seu código.

3. Conversões de ponteiro

Ponteiros em Go fazem referência ao endereço de memória de uma variável. Você pode converter entre um valor e seu ponteiro:

var x int = 42
var p *int = &x     // int to *int (pointer to int)
var y int = *p      // *int to int (dereferencing)

4. Conversões de tipo de interface

Interfaces em Go são usadas para definir um conjunto de métodos. Você pode converter entre tipos e interfaces concretos:

var a interface{} = 42    // int to interface{}
var b int = a.(int)       // interface{} to int (type assertion)

Asserções de tipo

Uma asserção de tipo fornece acesso ao valor concreto de uma interface:

if v, ok := a.(int); ok {
    fmt.Println("a is an int:", v)
}

Interruptor de tipo

Uma opção de tipo permite que você execute diferentes ações com base no tipo dinâmico de uma interface:

switch v := a.(type) {
case int:
    fmt.Println("a is an int:", v)
case string:
    fmt.Println("a is a string:", v)
default:
    fmt.Println("a is of unknown type")
}

5. Conversões inseguras

O pacote inseguro permite que você ignore a segurança de tipo do Go, permitindo conversões que de outra forma seriam ilegais:

import "unsafe"

var i int = 42
var p *int = &i
var fp *float64 = (*float64)(unsafe.Pointer(p))  // *int to *float64

Aviso: conversões inseguras devem ser usadas com moderação e somente quando for absolutamente necessário, pois podem levar a um comportamento indefinido.

6. Conversões de tipo de canal

Canais são um recurso poderoso no Go, permitindo a comunicação entre goroutines. Você pode converter entre canais bidirecionais e unidirecionais:

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. Conversões de estrutura e array


Conversões entre structs ou arrays com layouts idênticos requerem conversão explícita:



type Point struct {
    X, Y int
}

type Coord struct {
    X, Y int
}

var p Point = Point{1, 2}
var c Coord = Coord(p)  // Convert Point to Coord (same field types)





  
  
  8. Conversões de fatias


Slices são referências a matrizes e, embora você possa converter entre fatias do mesmo tipo, a conversão entre diferentes tipos de fatias requer uma conversão explícita:



var a []int = []int{1, 2, 3}
var b []int = a[1:]  // Convert a slice to another slice of the same type





  
  
  9. Conversões de interface nulas


Um valor nulo em Go pode ser atribuído a qualquer tipo de interface:



var x interface{} = nil
var y error = nil





  
  
  10. Conversões de tipo de função


As funções Go podem ser convertidas para diferentes tipos, desde que as assinaturas sejam compatíveis:



type FuncType func(int) int

func square(x int) int {
    return x * x
}

var f FuncType = FuncType(square)  // Convert function to FuncType





  
  
  11. Conversão de matriz em fatia


Você pode criar uma fatia a partir de um array, que é essencialmente uma referência ao array:



var arr [5]int = [5]int{1, 2, 3, 4, 5}
var sl []int = arr[:]  // Convert array to slice





  
  
  Conclusão


A conversão e conversão de tipos em Go são explícitas por design, tornando o código mais seguro e fácil de entender. Ao exigir conversões explícitas, Go ajuda a evitar bugs sutis que podem surgir da coerção implícita de tipo, comum em algumas outras linguagens de programação. Compreender essas conversões e usá-las corretamente é crucial para escrever programas Go robustos e eficientes.