Las variables y las constantes son conceptos fundamentales en la mayoría de los lenguajes de programación. Son los bloques de construcción para almacenar y gestionar datos.

En este artículo, veremos cómo funcionan las variables y las constantes en Go.

Tabla de contenidos:

¿Qué son las Variables?

Una variable es un lugar de almacenamiento identificado por un nombre (o identificador) que contiene un valor. Este valor puede cambiar (o variar) durante la ejecución de un programa. Por eso se llama variable.

Por ejemplo:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

Creamos una variable con un identificador de miNombre que contiene un valor de cadena.

Si te has fijado, hemos cambiado el valor a otra cadena, y podemos hacerlo varias veces porque las variables pueden hacerlo.

Las variables permiten almacenar datos, que pueden ser de diferentes tipos, como enteros, números de coma flotante, cadenas u objetos.

Cómo crear una variable en Go

Existen dos formas principales de crear una variable en Go, la declaración explícita y la declaración abreviada.

Declaración explícita

Esta es la forma tradicional de crear una variable en Go. Funciona utilizando la palabra clave var y declarando el tipo de la variable, lo que hace que tu código sea más legible y claro.

package main

import "fmt"

func main() {

    var age int = 25

    var name string = "Temitope"

    var height float64 = 5.7

    fmt.Println(age, name, height)

}

Puedes ver que, para cada variable, declaramos su tipo de dato antes de asignarle un valor.

output:
25 Temitope 5.7

La palabra clave var y el tipo de dato también se pueden utilizar sin tener un valor inicial:

package main

import "fmt"

func main() {
    var age int
    var name string
    var height float64

    age = 25
    name = "Temitope"
    height = 5.7

    fmt.Println(age, name, height)
}

De esta forma, las variables se declaran primero sin un valor inicial. Luego se les asignan valores más adelante en el código. Seguirá teniendo la misma salida que la primera.

Declaración abreviada de variables

La sintaxis de declaración de variables abreviada (:=) es una manera más concisa de declarar variables. Este método permite declarar y inicializar una variable en una sola línea sin expresar explícitamente su tipo, ya que el tipo se infiere de la valor asignado.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

Aquí, cada variable fue declarada junto con su valor, con Go infiriendo el tipo de datos. Por ejemplo, age fue declarada e inicializada con un valor de 25, y Go infirió su tipo como int. name fue declarada con el valor “Temitope”, y Go infirió su tipo como string. Finalmente, height fue declarada con 5.7, y Go infirió su tipo como float64.

output:
25 Temitope 5.7

Uno de los inconvenientes de la declaración abreviada de variables es que solo se puede usar dentro de una función.

Declaraciones de Variables Múltiples

Puedes declarar y inicializar varias variables en la misma línea separándolas con comas. Esta aproximación es simple y directa. Es comúnmente usada cuando las variables están relacionadas o cuando quieres inicializarlas juntas. Por ejemplo:

package main

import "fmt"

func main() {

    var age, height int = 25, 180

    var name, city string = "Temitope", "New York"

    fmt.Println(age, height)

    fmt.Println(name, city)
}

Aquí, la variable age y height ambas declaradas como enteros e inicializadas con los valores 25 y 180, respectivamente. La variable name y city también ambas declaradas como cadenas y inicializadas con “Temitope” y “New York”:

Output:
25 180
Temitope New York

También puedes declarar varias variables en un bloque como sigue:

package main

import "fmt"

func main() {

    var (
        age int = 25

        name string = "Temitope"

        height int = 180

        city string = "New York"
    )

    fmt.Println(age, name, height, city)

}

Aquí, las variables age, name, height, y city son declaradas dentro de un solo bloque var, con cada variable en su propia línea.

Output:
25 Temitope 180 New York

Valores cero

Cuando se declaran variables sin inicializar, por defecto se les asigna un valor cero. Estos valores pueden diferir según el tipo de variable. A continuación se muestra un ejemplo de cómo se pueden declarar valores por defecto:

package main

import "fmt"

func main() {

    var intValue int

    var floatValue float64

    var boolValue bool

    var stringValue string

    var ptrValue *int

    var sliceValue []int

    var mapValue map[string]int

    fmt.Println("Zero values:")

    fmt.Println("int:", intValue)

    fmt.Println("float64:", floatValue)

    fmt.Println("bool:", boolValue)

    fmt.Println("string:", stringValue)

    fmt.Println("pointer:", ptrValue)

    fmt.Println("slice:", sliceValue)

    fmt.Println("map:", mapValue)

}

En el código anterior, esto es lo que va a ocurrir:

  • La variable entera intValue tendrá el valor cero 0.

  • El número flotante floatValue tendrá el valor cero 0.

  • La variable booleana boolValue tendrá el valor cero false.

  • La cadena de texto stringValue tendrá el valor cero “” (cadena vacía).

  • El puntero ptrValue, el slice sliceValue y el mapa mapValue tendrán todos el valor cero nil.

Salida:

Output:
Zero values:
int: 0
float64: 0
bool: false
string: 
pointer: <nil>
slice: []
map: map[]

¿Qué es el Alcance de unaVariable?

Las variables pueden declararse globalmente o localmente. El alcance de una variable determine dónde pueden accederse y modificarse dentro de tu código.

Variables globales se declaran fuera de cualquier función, típicamente en la parte superior de un archivo, y pueden ser accedidas por cualquier función dentro del mismo paquete. Aquí tienes un ejemplo:

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

    fmt.Println("Initial Counter:", globalCounter)

    incrementCounter()

    fmt.Println("After Increment:", globalCounter)

}

En el ejemplo anterior, globalCounter es la variable global, y es accesible tanto por la función incrementCounter como por la función main.

Además, el valor de globalCounter persiste a través de las llamadas a la función. Esto significa que cualquier cambio realizado en ella en una función afecta su valor en otras partes del programa.

Por otro lado, las variables locales se declaran dentro de una función o un bloque y solo son accesibles dentro de esa función o bloque específico. Se crean cuando se ejecuta la función o el bloque y se destruyen una vez que se completa. Por ejemplo:

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

    fmt.Println("Local Counter:", localCounter)

}

func main() {

    incrementCounter()

    incrementCounter()

}

En el código anterior, tenemos la localCounter como variable local dentro de la función incrementCounter. Cada vez que se llama a incrementCounter, se crea una nueva localCounter, se inicializa en 0 y se incrementa.

El valor de localCounter no persiste entre las llamadas a la función, por lo que no puede afectar a ninguna parte de un programa cuando se realiza un cambio en la función.

Convenciones de Nomenclatura en Go

La nomenclatura correcta de variables es crucial para escribir código limpio, legible y mantenible. Go tiene algunas convenciones y reglas específicas para nombrar variables. A continuación, algunas de ellas:

  • Utilice nombres descriptivos: Utilice nombres que claramente describan el propósito o contenido de la variable. En lugar de usar nombres vagos como x o y, use nombres como edad, precioTotal o nombreUsuario que claramente transmitan lo que representa la variable.

  • Utilice CamelCase para nombres de varias palabras: En Go, es una práctica común utilizar CamelCase para los nombres de variables que constan de varias palabras. La primera palabra está en minúscula y la primera letra de cada palabra posterior está en mayúscula.

  • Evite usar guiones bajos: A diferencia de otros lenguajes, Go prefiere CamelCase sobre el uso de guiones bajos para separar palabras en los nombres de variables. Manténgase al estilo idiomático de Go utilizando CamelCase.

  • Usar Nombres Cortos para Variables de Vida Corta: Para variables de vida corta, como contadores o índices de bucle, es aceptable usar nombres cortos como i, j o k.

¿Qué son las Constantes en Go?

Las constantes son valores inmutables definidos en tiempo de compilación que no se pueden modificar a lo largo de la ejecución del programa. Son útiles para definir valores que se conocen con anticipación y que permanecerán iguales.

Imagina que estás construyendo una tienda online donde el costo estándar de envío es siempre de $10. Puedes declararlo como una constante, de modo que puedas usarlo en todo tu programa cada vez que se necesiten aplicar cargos de envío. Si cambian las tasas de envío, solo necesitas actualizar el valor en un solo lugar.

Cómo Declarar Constantes en Go

Puedes declarar constantes usando la palabra clave const, seguida del nombre, el tipo (opcional si el valor implica el tipo) y el valor de la constante. Aquí tienes cómo hacerlo:

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

Si intentas cambiar una constante después de su declaración, obtendrás un error de compilación.

Tipos de Constantes en Go

Las constantes se pueden categorizar como tipadas o no tipadas. Ambos tipos de constantes sirven el mismo propósito. Proporcionan valores fijos e inmutables a través del programa. Sin embargo, difieren en cómo Go maneja sus tipos y qué tan flexibles son cuando se utilizan.

Las constantes sin tipo no se asignan un tipo a menos que se utilicen en un contexto que requiera un tipo. Cuando declaras una constante sin tipo, Go infiere el tipo en el punto en el que se utiliza la constante. Esto hace que las constantes sin tipo sean más flexibles porque pueden usarse en varios ajustes sin necesidad de conversión de tipo.

package main

import "fmt"

const gravity = 9.81

func main() {

    var height int = 10

    var acceleration float64 = gravity * float64(height)

    fmt.Println("Acceleration:", acceleration)

}

Aquí, gravity es la constante sin tipo. Esto significa que Go puede inferir su tipo basándose en cómo se utiliza. Cuando gravity se utiliza en una calculadora con un float64, Go automáticamente la tratará como un float64.

A diferencia de las constantes sin tipo, las constantes con tipo tienen un tipo declarado explícitamente. Esto significa que solo se pueden usar en contextos que se ajusten a ese tipo o se puedan convertir a un tipo compatible. Las constantes con tipo son más estrictas, garantizando que el valor siempre se trate como el tipo específico declarado.

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

Aquí, speedOfLight es la constante con tipo del tipo int.

Solo se puede utilizar en operaciones con otros valores de int o convertirse explícitamente a un tipo diferente.

Eso es todo

En este artículo, revisamos qué son las variables y las constantes y cómo declararlas en Go.

Las variables y las constantes son herramientas críticas en la programación. Permiten a los desarrolladores administrar y manipular los datos de manera eficiente. Cuando entiendes cómo utilizarlas, puedes mejorar la calidad de tu código.

Por favor, comparte si encontraste esto útil.