Go, también conocido como Golang, es un lenguaje escrito estáticamente. Esto significa que el tipo de cada variable se conoce en el momento de la compilación, lo que proporciona seguridad y previsibilidad en su código. Sin embargo, esto también requiere que cualquier conversión de un tipo a otro sea explícita y deliberada. En este artículo, exploraremos los diversos mecanismos de conversión y conversión de tipos disponibles en Go, desde conversiones numéricas básicas hasta interfaces más complejas y conversiones de puntero.

1. Conversiones de tipos básicos

Go permite la conversión entre tipos básicos como números enteros, números de punto flotante y cadenas, pero estas conversiones deben realizarse explícitamente.

Tipos numéricos

Las conversiones entre diferentes tipos numéricos son sencillas pero deben ser explícitas:

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

En este ejemplo, convertimos un int en un float64 y en un uint. Estas conversiones son explícitas porque Go no realiza conversiones de tipo automáticas (implícitas).

Segmento de cadena y byte

Las cadenas Go son inmutables, pero se pueden convertir hacia y desde segmentos de bytes ([]byte), que son mutables:

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

De manera similar, puedes convertir entre cadenas y sectores de runas ([]rune), donde rune es un alias de tipo para int32:

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

2. Conversiones de tipos personalizados

En Go, puedes definir tus propios tipos basados ​​en los existentes. Las conversiones entre tipos personalizados y sus tipos subyacentes son 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 conversión explícita es necesaria para garantizar que el compilador pueda verificar la seguridad de su código.

3. Conversiones de puntero

Los punteros en Go hacen referencia a la dirección de memoria de una variable. Puedes convertir entre un valor y su puntero:

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

4. Conversiones de tipos de interfaz

Las interfaces en Go se utilizan para definir un conjunto de métodos. Puede convertir entre tipos e interfaces concretos:

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

Tipo de afirmaciones

Una aserción de tipo proporciona acceso al valor concreto de una interfaz:

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

Tipo de interruptor

Un cambio de tipo le permite realizar diferentes acciones según el tipo dinámico de una interfaz:

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. Conversiones inseguras

El paquete inseguro le permite eludir la seguridad de tipos de Go, lo que permite conversiones que de otro modo serían ilegales:

import "unsafe"

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

Advertencia: Las conversiones no seguras deben usarse con moderación y solo cuando sea absolutamente necesario, ya que pueden generar un comportamiento indefinido.

6. Conversiones de tipos de canales

Los canales son una característica poderosa en Go, que permite la comunicación entre gorutinas. Puedes convertir entre canales bidireccionales y unidireccionales:

ch := make(chan int)
var sendOnlyChan chan




  
  
  7. Conversiones de estructuras y matrices


Las conversiones entre estructuras o matrices con diseños idénticos requieren conversión 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. Conversiones de sectores


Los sectores son referencias a matrices y, si bien puedes convertir entre sectores del mismo tipo, la conversión entre diferentes tipos de sectores requiere una conversión 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. Conversiones de interfaz nulas


Se puede asignar un valor nulo en Go a cualquier tipo de interfaz:


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





  
  
  10. Conversiones de tipos de funciones


Las funciones Go se pueden convertir a diferentes tipos, siempre que las firmas sean compatibles:


type FuncType func(int) int

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

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





  
  
  11. Conversión de matriz a segmento


Puedes crear un segmento a partir de una matriz, que es esencialmente una referencia a la matriz:


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





  
  
  Conclusión


La conversión de tipos y las conversiones en Go son explícitas por diseño, lo que hace que el código sea más seguro y fácil de entender. Al requerir conversiones explícitas, Go ayuda a prevenir errores sutiles que pueden surgir de la coerción de tipos implícita, común en algunos otros lenguajes de programación. Comprender estas conversiones y usarlas correctamente es crucial para escribir programas Go sólidos y eficientes.