Declaración de variables básicas en Go

Clase 4 de 28 • Curso de Go

Resumen

Comenzar a programar en un nuevo lenguaje puede parecer complicado, pero entender la manera en que Go maneja las variables te facilitará mucho este proceso. A continuación, aclaramos la sintaxis básica para declarar variables en Go, mostrando distintos tipos de variables como cadenas, enteros y booleanos.

¿Cómo se declaran variables simples en Go?

Declarar variables en Go es sencillo. Para comenzar con lo básico:

Usa la palabra clave var seguida del nombre de tu variable.
Asigna un valor para que Go identifique automáticamente el tipo.
Un ejemplo claro sería:

var cadena = "inicial"

Más adelante, puedes mostrar fácilmente esta variable imprimiéndola con fmt.Println(cadena).

¿Cuáles son los tipos de datos básicos?

Los tipos de datos más sencillos que Go identifica automáticamente y que se pueden declarar directamente son:

String (cadena): datos textuales.
Int (enteros): números enteros.
Bool (booleanos): verdadero (true) o falso (false).

Por ejemplo:

var enteroUno, enteroDos int = 10, 20
var booleano = true

¿Cómo declarar múltiples variables a la vez?

Go permite declarar varias variables en una sola línea, asignando valores simultáneamente:

var enteroUno, enteroDos int = 10, 20

Esto es particularmente útil, pues simplifica el código.

¿Cuál es el valor por defecto de las variables sin asignación?

Una particularidad muy práctica de Go es que establece valores por defecto cuando no asignas explícitamente un valor. Por ejemplo, si declaras un entero sin asignarle valor alguno:

var enteroSimple int

Su valor por defecto será cero (0). Posteriormente puedes asignar valores si lo necesitas.

¿Qué otras alternativas existen para declarar variables?

Una forma más abreviada y directa para inicializar variables es usando :=:

fruta := "manzana"

Esto permite que Go infiera automáticamente el tipo de dato que estás asignando, simplificando aún más tu código.

Importante: recuerda que en Go todas las variables declaradas deben ser utilizadas; de lo contrario, no podrás compilar tu aplicación.

Ahora que conoces las distintas maneras en que puedes declarar variables en Go, puedes elegir la que mejor se adapte a tu estilo de programación. ¡Experimenta y personaliza tu proceso de aprendizaje en Go!

Pedro Muñoz Becerra

student•

Algo a destacar de la forma de declarar las variables. Go nos permite declarlas de las dos formas vistas en la clase, sin embargo la versión corta := no se permite usar fuera de funciones, debido a que go quiere mantener claridad y control, puesto que al ser declaradas fuera, ya son variables globales.

Ronaldo Jiménez

student•

Comparto este tutorial como refuerzo a lo visto: https://www.youtube.com/watch?v=275kxocPtS8

Ronaldo Jiménez

student•

package fundamentals

// Tipos de datos básicos en Go:
// Números enteros (int8, int16, int32, int64, int) positivos(uint8, uint16, uint32, uint64, uint)
// Números decimales (float32, float64)
// Booleanos (bool)
// Cadenas de texto (string)
// Runa (caracteres) (rune)
// Byte (equivalente a uint8) (byte)
// tipos de datos en Go

// Variable: Es un espacio en memoria que almacena un valor que puede cambiar durante la ejecución del programa.
// En Go, se declara usando la palabra clave `var` seguida del nombre de la variable y su tipo.

// Constante: Es un valor que no puede ser modificado una vez que ha sido asignado.
// En Go, se declara usando la palabra clave `const` seguida del nombre de la constante y tipo.
import (
	"fmt"
)

func DataTypes() {
	// Enteros
	var entero int = 42
	var pequeño int8 = 127 // -128 a 127

	// Decimales
	var decimal float32 = 3.14
	var grande float64 = 2.7182818284

	// Booleano
	var verdadero bool = true

	// String
	var texto string = "Hola, Go!"

	// Rune y Byte
	var caracter rune = '@'
	var letra byte = '@'

	fmt.Println("Entero:", entero)
	fmt.Println("Pequeño:", pequeño)
	fmt.Println("Decimal:", decimal)
	fmt.Println("Grande:", grande)
	fmt.Println("Booleano:", verdadero)
	fmt.Println("Texto:", texto)
	fmt.Println("Caracter:", caracter)
	fmt.Println("Letra (byte):", letra)
	Hello() // llamamos a la función Hello

	// inferencia de tipos
	edad := 25             // Go infiere que es int
	nombre := "JimcostDev" // Go infiere que es string
	fmt.Println("Edad:", edad)
	fmt.Println("Nombre:", nombre)

	// Si declaramos una variable sin asignarle un valor, Go le asigna su zero value:
	var sinValor int    // 0
	var sinTexto string // ""
	var sinBool bool    // false
	fmt.Println("Sin valor:", sinValor)
	fmt.Println("Sin texto:", sinTexto)
	fmt.Println("Sin booleano:", sinBool)

	//  Go no hay conversión automática, se debe hacer manualmente:
	var x int = 42
	var y float64 = float64(x) // Convertimos int a float64
	fmt.Println(y)

	// constantes
	const pi float64 = 3.1416
	const gravedad float64 = 9.8
	fmt.Println("Pi:", pi)
	fmt.Println("Gravedad:", gravedad)
}

Nicolas Alejandro Herrera

student•

Declarar múltiples variables a la vez con var

Podemos usar una sola declaración var para definir más de una variable mediante un bloque o una instrucción var. Este método es común al declarar variables a nivel de paquete. No es necesario que las variables sean del mismo tipo y todas pueden tener sus propios valores iniciales. La notación es la siguiente:

var ( <name1> <type1> = <value1> <name2> <type2> = <value2>

...

<nameN> <typeN> = <valueN> )

Nicolas Alejandro Herrera

student•

var ( <name1> <type1> = <value1> <name2> <type2> = <value2> … <nameN> <typeN> = <valueN> )