Formas de declarar variables en Go

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:09

Formas de declarar variables en Go

Curso de Go

Clase 4 de 28

Clase 4 / 28

Recursos

Declarar variables en Go es uno de los primeros pasos para escribir código limpio en este lenguaje, y entender su sintaxis básica te ahorra confusiones cuando el proyecto crece. Aquí verás cómo crear variables de tipo string, int y bool, además de las distintas formas que Go acepta para hacerlo, ideal si vienes de otros lenguajes y quieres dominar lo esencial antes de avanzar.

¿Cómo se declara una variable string en Go?

La forma más directa de crear una variable en Go es usar la palabra reservada var, seguida del nombre y el valor inicial. Go infiere el tipo automáticamente a partir del valor que asignas [01:30].

go package main

import "fmt"

func main() { var cadena = "inicial" fmt.Println(cadena) }

Al pasar el cursor sobre cadena, el editor muestra que Go la reconoce como string sin necesidad de declararlo de forma explícita. Y si solo importas un paquete, puedes omitir los paréntesis del bloque import y dejarlo en una sola línea.

¿Qué hace la palabra var en Go? Declara una variable y, si le asignas un valor, Go deduce automáticamente su tipo. También puedes especificar el tipo manualmente con sintaxis como var cadena string.

¿Cómo declarar varias variables en una sola línea?

Go permite agrupar varias variables del mismo tipo en una sola declaración, algo útil cuando trabajas con valores numéricos relacionados.

go var enteroUno, enteroDos int = 10, 20 fmt.Println(enteroUno) fmt.Println(enteroDos)

Aquí ambos elementos son de tipo int. Y aunque Go es un lenguaje tipado estáticamente, puedes imprimir valores numéricos directamente con fmt.Println sin convertirlos a cadena, lo cual hace la experiencia más fluida que en otros lenguajes [02:50].

¿Cómo se declara un booleano?

Los valores bool siguen exactamente la misma lógica que los demás tipos. Asignas true o false y Go lo identifica:

go var booleano = true fmt.Println(booleano)

¿Qué pasa si declaro una variable sin asignarle valor?

En Go puedes declarar una variable indicando solo su tipo, sin asignarle un valor inicial. Esto es útil cuando vas a calcular o recibir el valor más adelante en tu código [03:50].

go var enteroSimple int fmt.Println(enteroSimple) // imprime 0 enteroSimple = 10 fmt.Println(enteroSimple) // imprime 10

Go asigna un valor por defecto según el tipo. Para enteros ese valor es 0, lo cual evita errores de variables no inicializadas que sí ocurren en otros lenguajes.

¿Cuál es el valor por defecto de un int en Go? Es 0. Para string el valor por defecto es una cadena vacía "" y para bool es false.

¿Cuál es la forma corta de declarar variables en Go?

La sintaxis más popular y divertida en Go es el operador de asignación corta :=, que combina declaración e inferencia de tipo en una sola línea [04:30].

go fruta := "manzana" fmt.Println(fruta)

No escribes var ni declaras el tipo, pero Go reconoce fruta como string. Es una abreviación que verás constantemente en proyectos reales y librerías.

¿Por qué Go marca error si no uso una variable?

Go aplica una regla estricta: si declaras una variable y no la utilizas, el compilador no te dejará ejecutar tu programa. Lo mismo ocurre con paquetes importados sin usar. Esta filosofía obliga a mantener el código limpio desde el inicio.

¿Cómo ejecutar el archivo y ver los resultados?

Una vez tienes tu archivo main.go dentro de la carpeta variables, abres la terminal y corres:

bash cd variables go run main.go

La salida muestra cada valor en orden:

inicial para la variable de tipo string.
10 y 20 para los enteros declarados en una sola línea.
true para el booleano.
0 y luego 10 para el entero declarado sin valor inicial.
manzana para la variable creada con :=.

Go admite todas estas formas de declaración, así que la elección depende de cuál te resulte más cómoda y legible. Mi recomendación es que pruebes las cinco y te quedes con la que mejor se adapte al estilo del equipo o proyecto donde trabajes. ¿Cuál de estas sintaxis usarías tú primero? Cuéntamelo en los comentarios.

Juan Diego Mejia Maestre

Hace 9 meses

💎 GUÍA MAESTRA: VARIABLES EN GO (GOLANG)

En Go, el manejo de variables es estricto y eficiente. El lenguaje es estáticamente tipado, lo que significa que el tipo se define en compilación, evitando errores comunes en ejecución.

📊 1. TIPOS DE DATOS Y VALORES POR DEFECTO (ZERO VALUES)

Si declaras una variable pero no le asignas un valor, Go le otorga uno automáticamente (Zero Value). No existe undefined.

Cadenas (string): Su valor por defecto es un string vacío "".
Enteros (int, int8, int64): Su valor por defecto es 0.
Booleanos (bool): Su valor por defecto es false.
Flotantes (float32, float64): Su valor por defecto es 0.0.
Tipos complejos (Punteros, interfaces, slices): Su valor por defecto es nil.

🖋️ 2. FORMAS DE DECLARACIÓN

Existen tres caminos para crear variables según tu necesidad:

A. Declaración con palabra clave var Se usa para declarar variables con o sin valor inicial. Es la única forma permitida a nivel global (fuera de funciones).

Ejemplo: var mensaje string = "Hola"
Ejemplo: var contador int (Inicia automáticamente en 0)

B. Declaración Múltiple Puedes optimizar espacio declarando varias variables en una sola línea.

Ejemplo: var a, b, c int = 1, 2, 3
Ejemplo: var nombre, activo = "Gopher", true (Inferencia mixta de tipos)

C. Operador Corto (:=) Es la forma más usada por su brevedad, pero solo funciona dentro de funciones. Go infiere el tipo automáticamente basándose en el valor.

Ejemplo: puntos := 50

⚡ 3. TRUCOS Y REGLAS DE ORO

Variables de Bloque: Para evitar repetir la palabra var, agrupa tus definiciones entre paréntesis.

var (
    identificador = "ID-99"
    intentos      = 3
    conectado     = false
)

El Operador Blank (_): Go es estricto: variable declarada y no usada genera error de compilación. Si una función devuelve un valor que no necesitas, asígnalo al guion bajo para ignorarlo. resultado, _ := calcularDatos()
Conversión Explicita (Casting): Go jamás convierte tipos de forma automática. No puedes sumar un int con un float64 sin convertir uno de ellos primero. var suma = float64(entero) + decimal

💡 DATOS EXTRA PARA TU NOTION

Eficiencia en Memoria: Puedes usar tipos específicos como int8 (para números hasta 127) o uint8 (alias byte) para optimizar recursos en aplicaciones de alto rendimiento.
Convención de Nombres: En Go se prefiere el estilo camelCase (ej: userName) sobre el snake_case.
Visibilidad (Exportación): * Si empieza con Mayúscula (Exportada): Es pública y accesible desde otros paquetes.
- Si empieza con minúscula (privada): Solo funciona dentro de su paquete.

🚫 NIL vs NULL: El Concepto de Vacío en Go

En Go, no existe null. Se utiliza la palabra clave nil. Sin embargo, a diferencia de otros lenguajes, nil no es un "comodín" para cualquier variable; solo ciertos tipos pueden ser nil.

🔍 1. ¿Qué tipos pueden ser nil?

En Go, no puedes asignar nil a un int o a un string. Solo los tipos por referencia o de estructura compleja lo permiten:

Punteros (*T)
Slices (Arreglos dinámicos)
Maps (Diccionarios)
Interfaces
Channels (Canales de comunicación)
Functions (Funciones asignadas a variables)

⚖️ 2. Diferencia Clave: Zero Value vs Nil

Go asigna un valor útil por defecto a los tipos básicos en lugar de dejarlos como null.

Tipos Básicos: Un int vacío es 0, un string vacío es "", un bool vacío es false. Nunca son nil.
Tipos por Referencia: Un puntero o un mapa sin inicializar sí son nil.

⚡ 3. Trucos y Peligros con nil

Pánico por Nil (Panic): Si intentas acceder a una propiedad o llamar a un método de un puntero que es nil, Go lanzará un error de "runtime panic" y la app se cerrará.
Comparación de Errores: En Go, los errores son valores. Si una función no tiene problemas, devuelve nil. Por eso verás mucho este código: if err != nil { return err }
Maps y Slices: * Un Slice nil se puede usar en un len() o cap() y dará 0 sin romperse.
- Un Map nil se puede leer (dará el zero value), pero si intentas escribir en él sin inicializarlo con make(), el programa explotará.

📝 Ejemplo Práctico

var p *int       // Puntero a entero, valor inicial: nil
var s []int      // Slice, valor inicial: nil
var m map[string]int // Map, valor inicial: nil

if p == nil {
    fmt.Println("El puntero no apunta a nada")
}

💡 Dato Interesante: ¿Por qué no "null"?

El nombre nil proviene de la tradición de lenguajes como Lisp y Smalltalk. Significa "nada" en latín. Los creadores de Go lo eligieron para diferenciar el comportamiento de los tipos de referencia de los tipos de valor simple del lenguaje.

Yeison Esneider Rivera Quintero

Hace un mes

Que gran resumen, gracias por el aporte!

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Formas de declarar variables en Go