Variáveis e constantes são conceitos fundamentais em linguagens de programação. Elas são as peas de construção para armazenar e gerenciar dados.

Neste artigo, vamos ver como as variáveis e constantes funcionam em Go.

Tabela de conteúdos:

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 chamamos 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 que isso seja feito.

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

Há duas maneiras 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)
}

Desta 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 de declaração de variável abreviada (:=) é uma maneira mais concisa 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, pois 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 dado. Por exemplo, age foi declarado e inicializado com o valor de 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 fim, height foi declarado com 5.7, e o Go inferiu seu tipo como float64.

output:
25 Temitope 5.7

Um dos desvantagens da declaração de variável abreviada é que você só pode usá-la dentro de uma função.

Declarações de Variáveis Múltiplas

Você pode declarar e inicializar várias variáveis na mesma linha, separando cada variável por vírgula. Esta abordagem é simples e direta. Ela é comumente usada quando as variáveis estão relacionadas ou quando você quer 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, as variáveis age e height são declaradas ambas como inteiros e inicializadas com os valores 25 e 180, respectivamente. As variáveis name e city também são declaradas ambas como strings e inicializadas com “Temitope” e “New York”:

Output:
25 180
Temitope New York

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

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 dentro de um único bloco var, com cada variável em sua própria linha.

Output:
25 Temitope 180 New York

Zero Values

Quando variáveis são declaradas sem serem inicializadas, elas recebem 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, slice sliceValue e map 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, normalmente no topo de um arquivo, e elas 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 ela é acessível 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 nele 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 bloco e são acessíveis apenas dentro desse função ou bloco específico. Elas são criadas quando a função ou bloco é executado e destruído assim que 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 o localCounter como variável local dentro da função incrementCounter. Cada vez que incrementCounter é chamado, uma nova localCounter é criada, inicializada em 0, e incrementada.

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

Convenções de Nomenclatura em Go

A nomeação correta de variáveis é crucial para a escrita de código limpo, legível e mantível. O Go tem algumas convenções e regras específicas para a nomeação de variáveis. Abaixo estão algumas delas:

  • Use nomes descritivos:

    Use nomes que claramente descrevem o propósito ou conteúdo da variável. Por exemplo, ao invés de usar nomes vagos como x ou y, use nomes como idade, precoTotal, ou nomeUsuario que transmitam claramente o que a variável representa.

  • Use CamelCase para nomes de variáveis compostos: No Go, é prática comum usar CamelCase para nomes de variáveis compostos. A primeira palavra está em minúsculas, e a primeira letra de cada palavra subsequente está em maiúsculas.
  • Evite usar underlines: Ao contrário de outras linguagens, o Go prefere CamelCase antes de usar underlines para separar palavras em nomes de variáveis. Adhera a CamelCase para manter o estilo idiomático do Go.

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

O que são Constantes em Go?

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

Imagine que você está construindo um site de loja online onde a taxa de frete padrão é sempre de $10. Você pode declará-la como uma constante, para que possa usá-la em todo o seu programa sempre que forem necessárias as taxas de frete. Se as taxas de frete mudarem, você precisará atualizar o valor em apenas um local.

Como declarar Constantes em Go

Você pode declarar constantes usando a palavra-chave const, seguida do nome, do tipo (opcional se o valor implica o tipo) e do 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 depois de declarada, então você receberá um erro de compilação.

Tipos de Constantes em Go

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

Valores constantes não-tipados não são atribuídos um tipo a menos que sejam usados em um contexto que exija 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ários cenários sem exigir 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 ela é usada. Quando gravity é usada em uma calculação com um float64, o Go automaticamente a trata como um float64.

Diferentemente 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 correspondam a esse tipo ou sejam convertidos para um tipo compátível. Constantes tipadas são mais estritas, garantindo que o valor sempre seja tratado como o tipo específico 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 de int ou convertida explicitamente para um tipo diferente.

Encerramento

Neste artigo, nós olhámos 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. Permitem que desenvolvedores gerenciem e manipulem dados de forma eficiente. Quando você entender como usá-las, você pode melhorar a qualidade do seu código.

Por favor, compartilhe se encontrou isso útil.