Variáveis e constantes são conceitos fundamentais na maioria das linguagens de programação. Eles são os blocos de construção para armazenar e gerenciar dados.

Neste artigo, vamos olhar como variáveis e constantes funcionam no Go.

Sumário:

O Que são Variáveis?

Uma variável é um local de armazenamento identificado por um nome (ou identificador) que mantém um valor. Este valor pode mudar (ou variar) durante a execução de um programa. É por isso que chama-se de variável.

Por exemplo:

myName := “temitope”

fmt.Println(myName)

myName:= ”oyedele”

fmt.Println(myName)

Criamos uma variável com um identificador de myName que mantém um valor de string.

Se você notou, mudamos o valor para outra string, e podemos fazer isso várias vezes porque as variáveis permitem fazer isso.

Variáveis permitem que você armazene dados, que podem ser de diferentes tipos, como inteiros, números de ponto flutuante, strings ou objetos.

Como Criar uma Variável em Go

Existem duas formas primárias de criar uma variável em Go, declaração explícita e declaração abreviada.

Declaração Explícita

Esta é a maneira tradicional de criar uma variável em Go. Ela funciona usando a palavra-chave var e declarando o tipo da variável, fazendo com que seu código seja mais legível e 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)

}

Você pode ver que, para cada variável, declaramos seu tipo de dado antes de atribuir um valor a ela.

output:
25 Temitope 5.7

A palavra-chave var e o tipo de dado também podem ser usados sem um 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)
}

Dessa forma, as variáveis são declaradas primeiro sem um valor inicial. Eles são então atribuídos valores mais tarde no código. Você ainda terá o mesmo resultado que no primeiro exemplo.

Declaração Abreviada de Variável

A sintaxe concisa de declaração de variáveis (:=) é uma forma mais sucinta de declarar variáveis. Este método permite que você declare e inicialize uma variável em uma única linha sem explicitamente declarar seu tipo, já que o tipo é inferido a partir do valor atribuído.

package main

import "fmt"

func main() {

    age := 25

    name := "Temitope"

    height := 5.7

    fmt.Println(age, name, height)

}

Aqui, cada variável foi declarada juntamente com seu valor, com o Go inferindo o tipo de dados. Por exemplo, age foi declarado e inicializado com o valor 25, e o Go inferiu seu tipo como int. name foi declarado com o valor “Temitope”, e o Go inferiu seu tipo como string. Por último, height foi declarado com 5.7, e o Go inferiu seu tipo como float64.

output:
25 Temitope 5.7

Uma das desvantagens da declaração de variáveis resumida é que você só pode usá-la dentro de uma função.

Declarações de Múltiplas Variáveis

Você pode declarar e inicializar várias variáveis na mesma linha, separando cada variável com uma vírgula. Esta abordagem é simples e direta. É comumente usada quando as variáveis estão relacionadas ou quando você deseja inicializá-las juntas. Por exemplo:

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)
}

Aqui, a variável age e height são ambas declaradas como inteiros e inicializadas com os valores 25 e 180, respectivamente. A variável name e city também são declaradas como strings e inicializadas com “Temitope” e “New York”:

Output:
25 180
Temitope New York

Você também pode declarar várias variáveis em um bloco assim:

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)

}

Aqui, as variáveis age, name, height, e city são declaradas em um único bloco var, com cada variável tendo sua própria linha.

Output:
25 Temitope 180 New York

Valores Zero

Quando as variáveis são declaradas sem serem inicializadas, elas são atribuídas valores zero por padrão. Esses valores diferem dependendo do tipo de variável. Abaixo está um exemplo de como você pode declarar valores padrão:

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)

}

No código acima, aqui está o que vai acontecer:

  • O inteiro intValue receberá o valor zero 0.

  • O número de ponto flutuante floatValue receberá o valor zero 0.

  • O Booleano boolValue receberá o valor zero false.

  • A string stringValue receberá o valor zero “” (string vazia).

  • O ponteiro ptrValue, o slice sliceValue e o mapa mapValue receberão todos o valor zero nil.

Saída:

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

O que é um Escopo de Variável?

Variáveis podem ser declaradas globalmente ou localmente. O escopo de uma variável determina onde ela pode ser acessada e modificada dentro do seu código.

Variáveis globais são declaradas fora de qualquer função, tipicamente no topo de um arquivo, e podem ser acessadas por qualquer função dentro do mesmo pacote. Aqui está um exemplo:

package main

import "fmt"

var globalCounter int = 0

func incrementCounter() {

    globalCounter++

}

func main() {

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

    incrementCounter()

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

}

No exemplo acima, globalCounter é a variável global, e pode ser acessada tanto pela função incrementCounter quanto pela função main.

Além disso, o valor de globalCounter persiste entre chamadas de função. Isso significa que qualquer mudança feita nela em uma função afeta seu valor em outras partes do programa.

Variáveis locais, por outro lado, são declaradas dentro de uma função ou um bloco e só são acessíveis dentro dessa função ou bloco específico. Elas são criadas quando a função ou bloco é executado e destruídas quando ele é concluído. Por exemplo:

package main

import "fmt"

func incrementCounter() {

    localCounter := 0

    localCounter++

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

}

func main() {

    incrementCounter()

    incrementCounter()

}

No código acima, temos a localCounter como a variável local dentro da função incrementCounter. Cada vez que incrementCounter é chamado, uma nova localCounter é criada, inicializada com 0, e incrementada.

O valor de localCounter não persiste entre chamadas de função, então não pode afetar nenhuma parte de um programa quando uma mudança é feita na função.

Convenções de Nomenclatura em Go

A nomenclatura adequada de variáveis é crucial para escrever código limpo, legível e manutenível. Go tem algumas convenções e regras específicas para nomear variáveis. Algumas delas estão abaixo:

  • Use nomes descritivos: Use nomes que descrevam claramente o propósito ou o conteúdo da variável. Em vez de usar nomes vagos como x ou y, use nomes como age, totalPrice ou userName que claramente transmitam o que a variável representa.

  • Use CamelCase para Nomes de Várias Palavras: No Go, é uma prática comum usar camelCase para nomes de variáveis que consistem em várias palavras. A primeira palavra está em minúsculo e a primeira letra de cada palavra subsequente é maiúscula.

  • Evite Usar Underscores: Ao contrário de algumas outras linguagens, o Go prefere camelCase ao invés de usar underscores para separar palavras em nomes de variáveis. Mantenha-se ao padrão camelCase para aderir ao estilo idiomático do Go.

  • Use nomes curtos para variáveis de curta duração: Para variáveis de curta duração, como contadores de loop ou índices, é aceitável usar nomes curtos como i, j ou k.

O que são constantes em Go?

Constantes são valores imutáveis definidos em tempo de compilação que não podem ser modificados durante a execução do programa. Elas são úteis para definir valores que são conhecidos à priori e permanecerão os mesmos.

Imaginando que você está construindo uma loja online onde a taxa padrão de envio é sempre $10. Você pode declará-la como uma constante, para que possa usá-la em todo o seu programa sempre que for necessário aplicar as taxas de envio. Se as taxas de envio mudarem, você só precisa atualizar o valor em um único local.

Como declarar constantes em Go

Você pode declarar constantes usando a palavra-chave const, seguida pelo nome, o tipo (opcional se o valor implicar o tipo) e o valor da constante. Aqui está como:

package main

import "fmt"

func main() {

    const pi float64 = 3.14159

    const greeting string = "Hello, World!"

    fmt.Println("Pi:", pi)

    fmt.Println("Greeting:", greeting)

}

Se você tentar mudar uma constante após sua declaração, você receberá um erro em tempo de compilação.

Tipos de Constantes em Go

Constantes podem ser categorizadas como tipadas ou não tipadas. Ambos os tipos de constantes servem ao mesmo propósito. Eles fornecem valores fixos e imutáveis em todo o programa. No entanto, eles diferem em como o Go lida com seus tipos e quão flexíveis são quando usados.

Constantes não tipadas não são atribuídas a um tipo a menos que sejam usadas em um contexto que requer um tipo. Quando você declara uma constante não tipada, o Go inferirá o tipo no ponto em que a constante é usada. Isso torna as constantes não tipadas mais flexíveis, pois elas podem ser usadas em várias configurações sem a necessidade de conversão 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)

}

Aqui, gravity é a constante não tipada. Isso significa que o Go pode inferir seu tipo com base em como é usada. Quando gravity é usada em um cálculo com um float64, o Go automaticamente a trata como um float64.

Ao contrário das constantes não tipadas, as constantes tipadas têm um tipo declarado explicitamente. Isso significa que elas só podem ser usadas em contextos que correspondem a esse tipo ou que podem ser convertidas para um tipo compatível. As constantes tipadas são mais rigorosas, garantindo que o valor seja sempre tratado como o tipo específico com o qual foi declarado.

package main

import "fmt"

const speedOfLight int = 299792458

func main() {

    var distance int = speedOfLight * 2

    fmt.Println("Distance:", distance)

}

Aqui, speedOfLight é a constante tipada com o tipo int.

Ela só pode ser usada em operações com outros valores int ou convertida explicitamente para um tipo diferente.

Isso é o Fim

Neste artigo, nós olhamos para o que são variáveis e constantes e como declará-las em Go.

Variáveis e constantes são ferramentas críticas na programação. Elas permitem que os desenvolvedores gerenciem e manipulem dados de forma eficiente. Quando você entende como usá-las, você pode melhorar a qualidade do seu código.

Por favor, compartilhe se você achou isso útil.