Go
Tutorial Go: Tipos de datos, variables y constantes
Aprende a usar tipos de datos, variables y constantes en Go. Descubre cómo declarar, asignar y manejar datos eficientemente en tus programas con esta guía.
Aprende Go GRATIS y certifícateDeclaración y asignación de variables
En Go, la declaración de variables es un proceso fundamental que permite especificar el nombre y el tipo de las variables que se utilizarán en el programa. La sintaxis básica para declarar una variable en Go es mediante la palabra clave var
, seguida del nombre de la variable y su tipo. Por ejemplo:
var nombre string
var edad int
En estos ejemplos, se han declarado dos variables: nombre
de tipo string
y edad
de tipo int
. Es importante destacar que, al declarar una variable de esta manera, se le asigna automáticamente el valor cero correspondiente a su tipo: una cadena vacía para string
y 0
para int
.
Go también permite la declaración y asignación simultánea de variables utilizando el operador de asignación =
. Esto se puede hacer en una sola línea, lo cual es útil para inicializar variables con valores específicos desde el principio:
var altura float64 = 1.75
En este caso, la variable altura
se declara como un float64
y se inicializa con el valor 1.75
. Esta forma de declaración es común cuando se conoce el valor inicial que debe tener la variable.
Además, Go proporciona una sintaxis más concisa para la declaración y asignación de variables a través de la declaración corta con el operador :=
. Esta forma se utiliza habitualmente dentro de funciones y permite al compilador inferir el tipo de la variable basado en el valor asignado:
nombre := "Juan"
edad := 30
Aquí, las variables nombre
y edad
son declaradas e inicializadas con valores específicos, y el compilador deduce que nombre
es de tipo string
y edad
es de tipo int
.
Es importante mencionar que el uso de :=
está restringido al ámbito local de las funciones y no puede ser utilizado para la declaración de variables a nivel de paquete. Por otro lado, la declaración con var
es más versátil y puede ser utilizada tanto a nivel de paquete como dentro de funciones.
Las variables en Go pueden ser agrupadas en una sola declaración para mejorar la legibilidad del código. Esto se realiza envolviendo múltiples declaraciones de variables dentro de un bloque:
var (
nombre string
edad int
altura float64
)
Este enfoque es especialmente útil cuando se declaran varias variables relacionadas, ya que reduce la repetición de la palabra clave var
y organiza el código de manera más clara.
Finalmente, es crucial entender que la asignación de una variable puede ser cambiada en cualquier momento después de su declaración inicial, siempre que el nuevo valor sea compatible con el tipo de la variable. Esto permite que las variables en Go sean flexibles y adaptables a las necesidades cambiantes del programa.
Tipos de datos primitivos: enteros, flotantes, booleanos, cadenas
En Go, los tipos de datos primitivos son fundamentales para el manejo de datos básicos. Estos tipos incluyen enteros, flotantes, booleanos y cadenas, cada uno con características específicas que determinan su uso y comportamiento en el lenguaje.
Los enteros en Go se dividen en varias categorías según su tamaño y signo. Los tipos básicos son int
y uint
, que representan enteros con signo y sin signo, respectivamente. Además, existen variantes específicas como int8
, int16
, int32
, int64
, y sus equivalentes sin signo uint8
, uint16
, uint32
, uint64
. El tipo int
es generalmente equivalente a int32
o int64
, dependiendo de la arquitectura del sistema. Por ejemplo:
var a int = 42
var b uint = 100
var c int64 = 900000000000
Los números flotantes se utilizan para representar valores con punto decimal. Go proporciona los tipos float32
y float64
, siendo este último el más común debido a su mayor precisión. Estos tipos permiten cálculos más precisos y son esenciales para aplicaciones científicas y financieras. Por ejemplo:
var x float32 = 3.14
var y float64 = 2.718281828459045
El tipo booleano en Go se representa con bool
, que puede contener solo dos valores: true
o false
. Los booleanos son cruciales para el control de flujo y las operaciones lógicas dentro de un programa. Por ejemplo:
var isValid bool = true
var hasAccess bool = false
Las cadenas de caracteres en Go se manejan mediante el tipo string
, que es una secuencia inmutable de bytes, representando texto codificado en UTF-8. Las cadenas pueden contener texto Unicode y se delimitan por comillas dobles. Es importante destacar que las cadenas son inmutables, lo que significa que no pueden ser modificadas una vez creadas. Por ejemplo:
var saludo string = "Hola, mundo"
var mensaje string = "Go es eficiente"
Una característica destacada de Go es su capacidad para convertir tipos de manera explícita. Esto es importante cuando se necesita operar con diferentes tipos de datos primitivos. Por ejemplo, para convertir un int
a float64
, se utiliza una conversión explícita:
var entero int = 10
var flotante float64 = float64(entero)
Además, las operaciones entre tipos diferentes requieren una conversión explícita para evitar errores de compilación, asegurando que el programador sea consciente de la manipulación de datos.
Uso de constantes con la palabra clave const
En Go, las constantes se definen utilizando la palabra clave const
. A diferencia de las variables, las constantes son valores que no pueden cambiar durante la ejecución del programa. Esto las hace ideales para representar valores que deben permanecer inmutables, como los números matemáticos constantes o configuraciones que no varían. La sintaxis para declarar una constante es similar a la de una variable, pero con const
en lugar de var
:
const pi = 3.14159
const saludo = "Hola, mundo"
En estos ejemplos, pi
es una constante de tipo float64
y saludo
es una constante de tipo string
. Es importante notar que Go infiere el tipo de la constante basado en el valor asignado. Además, las constantes en Go pueden ser de tipo numérico, de cadena o booleano.
Una característica clave de las constantes en Go es que no tienen un tipo fijo hasta que son utilizadas en una expresión que requiere un tipo específico. Esto permite que las constantes numéricas se utilicen de manera flexible en cálculos sin necesidad de conversiones explícitas, siempre que el tipo final sea compatible. Por ejemplo:
const ancho = 8
const alto = 6
var area = ancho * alto // Go infiere que el resultado es de tipo int
Las constantes también pueden ser definidas en bloques para agruparlas, lo que mejora la organización del código y facilita el mantenimiento. Este enfoque es útil cuando se declaran múltiples constantes relacionadas entre sí:
const (
velocidadLuz = 299792458 // en metros por segundo
gravedadTierra = 9.80665 // en m/s^2
constantePlanck = 6.62607015e-34 // en J·s
)
Go permite el uso de iota dentro de un bloque de constantes para crear secuencias incrementales. iota
es una constante predefinida que se incrementa automáticamente dentro de un bloque de constantes, comenzando desde cero. Esto es especialmente útil para definir enumeraciones:
const (
domingo = iota // iota es 0
lunes // iota es 1
martes // iota es 2
miércoles // iota es 3
jueves // iota es 4
viernes // iota es 5
sábado // iota es 6
)
En este ejemplo, domingo
se asigna a 0, lunes
a 1, y así sucesivamente. Esto es útil para representar días de la semana o cualquier conjunto de valores que requiera una secuencia numérica.
Finalmente, es fundamental entender que las constantes en Go no pueden ser modificadas una vez definidas. Intentar cambiar el valor de una constante generará un error de compilación. Esta inmutabilidad garantiza que las constantes sean seguras y confiables para su uso en cualquier parte del programa, proporcionando una base sólida para valores que no deben cambiar.
Ejercicios de esta lección Tipos de datos, variables y constantes
Evalúa tus conocimientos de esta lección Tipos de datos, variables y constantes con nuestros retos de programación de tipo Test, Puzzle, Código y Proyecto con VSCode, guiados por IA.
Composición de structs en lugar de herencia
Estructuras de control
Arrays y slices
Control de flujo y estructuras de bucle
Métodos con receptores por valor y por puntero
Generics
Crear e invocar funciones
Operadores y expresiones
Polimorfismo a través de Interfaces
Manejo explícito de errores
Estructuras structs
Tipos de datos, variables y constantes
Introducción a Go
Punteros y referencias
Instalación Go primer programa
Errores personalizados y trazabilidad
Estructuras de datos Mapas
Cadenas de texto y manipulación
Todas las lecciones de Go
Accede a todas las lecciones de Go y aprende con ejemplos prácticos de código y ejercicios de programación con IDE web sin instalar nada.
Introducción A Go
Introducción Y Entorno
Instalación Y Primer Programa De Go
Introducción Y Entorno
Tipos De Datos, Variables Y Constantes
Sintaxis
Operadores Y Expresiones
Sintaxis
Cadenas De Texto Y Manipulación
Sintaxis
Estructuras De Control
Sintaxis
Control De Flujo Y Estructuras De Bucle
Sintaxis
Funciones
Sintaxis
Arrays Y Slices
Estructuras De Datos
Mapas
Estructuras De Datos
Punteros Y Referencias
Estructuras De Datos
Estructuras Structs
Programación Orientada A Objetos
Métodos Con Receptores Por Valor Y Por Puntero
Programación Orientada A Objetos
Polimorfismo A Través De Interfaces
Programación Orientada A Objetos
Composición De Structs En Lugar De Herencia
Programación Orientada A Objetos
Generics
Programación Orientada A Objetos
Manejo Explícito De Errores
Manejo De Errores Y Excepciones
Errores Personalizados Y Trazabilidad
Manejo De Errores Y Excepciones
Métodos Http Con Net/http
Comunicación Por Http
Api Rest Con Net/http
Comunicación Por Http
En esta lección
Objetivos de aprendizaje de esta lección
- Comprender la sintaxis para declarar y asignar variables en Go.
- Conocer los tipos de datos primitivos: enteros, flotantes, booleanos y cadenas.
- Manejar la declaración simultánea y corta de variables.
- Entender cómo agrupar variables y su modificación.
- Aprender a definir y utilizar constantes con
const
. - Aplicar conversiones explícitas entre tipos de datos.
- Usar
iota
para crear secuencias de constantes.