Conversión entre tipos de datos numéricos y cadenas en Go

Clase 5 de 28 • Curso de Go

Resumen

Dominar la conversión de tipos de datos en Go es esencial para combinar variables de diferente naturaleza y optimizar tus aplicaciones. Saber manejar correctamente números enteros, flotantes y cadenas te permitirá tener el control al realizar operaciones y evitar errores inesperados.

¿Cómo declarar variables numéricas en Go?

En Go es posible definir variables numéricas explícita o implícitamente. Veamos dos maneras prácticas:

Explícita:

var numeroEntero int = 10

Implícita:

numeroDos := 20

Ambas opciones son válidas y funcionales según el contexto de uso.

¿Qué ocurre al sumar diferentes tipos numéricos?

Cuando trabajas con tipos de datos diferentes, como variables enteras y flotantes, Go te exige una conversión explícita del tipo de dato. Observa este ejemplo:

var numeroEntero int = 10
var numeroDoble float64 = 20.5
resultado := numeroEntero + int(numeroDoble)
fmt.Println(resultado)

Aquí necesitas convertir la variable flotante numeroDoble a entero antes de sumar. Ten presente que Go truncará, no redondeará; por ejemplo, 20.5 se convierte en 20.

¿Cómo concatenar cadenas correctamente?

La concatenación de cadenas se realiza de forma sencilla usando el operador +. Mira cómo es posible unir nombre y apellido:

var nombre string = "Juan"
apellido := "González"
nombreCompleto := nombre + " " + apellido
fmt.Println(nombreCompleto)

Este bloque crea una cadena llamada nombreCompleto y la visualiza fácilmente en la consola.

¿Te animas a probar?

Un ejercicio práctico es escribir un código similar que muestre tu nombre y tu edad en consola:

Define una cadena con tu nombre.
Crea una variable entera con tu edad.
Imprime ambos valores en consola usando fmt.Println().

Comparte tu experiencia y resultados en los comentarios, ¡me encantaría saber cómo te fue!

Jehú Frayle

student•

Respecto al último ejercicio, puede que alguno haya intentando algo como string(edad) y se hayan topado con la pared de que eso sencillamente no funciona ¿por qué? 🔄 Conversión entre tipos en Go:* En Go, podemos convertir un float64 a int usando int(valor), porque los tipos numéricos pueden convertirse directamente entre sí. Esto simplemente descarta la parte decimal (no redondea).

Pero para convertir un int a string, no podemos usar string(valor) porque eso no convierte el número a texto, sino al carácter Unicode correspondiente al valor del número. Por ejemplo, string(65) devuelve "A", no "65".Por eso, para convertir un número entero a texto, usamos una función especial del paquete strconv llamada strconv.Itoa(valor) (Integer to ASCII), que sí devuelve el número como texto, como en:strconv.Itoa(20) // devuelve "20" En resumen:
- ✅ int(x) → entre tipos numéricos.
- ❌ string(número) → da un carácter, no un número como texto.
- ✅ strconv.Itoa(número) → convierte correctamente el número a string.

Ezequiel Vásquez

student•

Muchas gracias por la ayuda, me vino de maravilla:

Jehú Frayle

student•

No terminé de entender la analogía, pero me pareció muy gracioso el "Ah mira, parece regiomontano"

Miguel Angel Reyes Moreno

student•

Jajaja dicen que los de Monterrey son muy "codos" o bien tacaños. Por eso, Go no quiso subir 20.5 a 21, sino que lo dejó en 20 ajajaj

Ronaldo Jiménez

student•

Una herramienta muy buena para aprender y porbar es el Go Playground: https://go.dev/play/

Miguel Angel Reyes Moreno

student•

Para el ejercicio final, basta con hacer:

fmt.Printf("Nombre: %s, Edad: %d \n", nombre, edad)

Catalano Nicolas

student•

miNombre := "Nicolas"
miEdad := 30

fmt.Printf("Mi nombre es %s y mi edad es %d\n", miNombre, miEdad)

Ronaldo Jiménez

student•

package fundamentals

// Principales especificadores de formato en Go:
// %s: Para cadenas de texto.
// %d: Para enteros decimales.
// %f: Para números de punto flotante.
// %.nf: Para números de punto flotante con n decimales. ejem: %.2f
// %t: Para valores booleanos.
// %c: Para caracteres individuales.
// %b: Para representación binaria de un entero.
// %e: Para notación científica.
// %x: Para representación hexadecimal.
// %T: Para mostrar el tipo de una variable.
// %v: Para imprimir el valor de una variable, independientemente de su tipo.

import "fmt"

// formateo de texto en Go
func Formatted() {
	var nombre string = "Ronaldo"
	var edad int = 25
	var altura float64 = 1.84
	var esEstudiante bool = true
	var caracter rune = 'R'

	fmt.Println("Ejemplo de uso de auxiliares de formato:")
	fmt.Printf("Nombre: %s\n", nombre)
	fmt.Printf("Nombre: %v\n", nombre)
	fmt.Printf("Edad: %d años\n", edad)
	fmt.Printf("Altura: %.2f metros\n", altura)
	fmt.Printf("Es estudiante: %t\n", esEstudiante)
	fmt.Printf("Primer letra del nombre: %c\n", caracter)
	fmt.Printf("Edad en binario: %b\n", edad)
	fmt.Printf("Altura en notación científica: %e\n", altura)
	fmt.Printf("Edad en hexadecimal: %x\n", edad)
	fmt.Printf("Tipo de la variable 'nombre': %T\n", nombre)
	fmt.Println()

	// alinear la salida
	fmt.Printf("%-10s | %10s\n", "Nombre", "Edad")
	fmt.Printf("%-10s | %10d\n", "Carlos", 25)
	fmt.Printf("%-10s | %10d\n", "Sofía", 30)
	fmt.Println()

	// bases numéricas
	num := 42
	fmt.Printf("Decimal: %d\n", num)
	fmt.Printf("Binario: %b\n", num)
	fmt.Printf("Octal: %o\n", num)
	fmt.Printf("Hexadecimal: %x\n", num)

	// guardar la salida en una variable
	s := fmt.Sprintf("Nombre: %s, Edad: %d, Altura: %.2f", nombre, edad, altura)
	fmt.Println(s)
}

Ramger Deivi Duran

student•

package main

// File: main.go
import "fmt"

var name string = "Ramger"
var edad int = 30

func main() {

	fmt.Println("Hola mi nombre es " + name + " y tengo " + fmt.Sprint(edad) + " años.")
}

Ramger Deivi Duran

student•

Un dato muy importante, puedes decalara la variable fuera de la función de esta forma:

var numeroEntero int = 10
```Ahora si lo haces con esta declaración:

```js
apellido := "González"
```Te dira que no encuentra esa variable.

Yamid Horacio Rodríguez

student•

Jeisson Malaver

student•

Comparto ejemplos de redondeo usando el package "math"

// Redondeo hacia arriba

redondeoArriba := int(math.Ceil(numeroDoble))

// Redondeo hacia abajo

redondeoAbajo := int(math.Floor(numeroDoble))

// Redondeo al entero más cercano (si .5, redondea hacia arriba)

redondeoCercano := int(math.Round(numeroDoble))

Sebastian Pérez

student•

Comparto dos formas de concatenar un String y una Integer. 1. Una es usando el paquete strconv y su método Itoa que convierte ese integer en string 2. Usando el método Sprintf permite interpolar variables directamente en cadenas de texto, Hazte de cuenta el formato f"" en python pero de una manera mas especifica. %s especifica que en esa ubicación la variable va hacer de tipo string. Y el %d significa que va a ser de tipo integer

Francisco Angel Rocha Montesinos

student•

package main

import "fmt"

func main(){

  miNombre := "Francisco Rocha"
  miEdad := 25

  miInfo := fmt.Sprintf("Hola mi nombre es %s y mi edad es %d", miNombre, miEdad)

  fmt.Println(miInfo)

  
}
```Hola esta es mi solucion del pequeño reto que dejo el profe