Come Utilizzare Variabili e Costanti in Go

Variabili sono un concetto di programmazione importante da padroneggiare. Sono simboli che rappresentano un valore che si sta utilizzando in un programma.

Questa guida coprirà alcuni concetti di base sulle variabili e le migliori pratiche per utilizzarle all’interno dei programmi Go che crei.

Capire le Variabili

In termini tecnici, una variabile è l’assegnazione di una posizione di memorizzazione a un valore associato a un nome simbolico o identificatore. Utilizziamo il nome della variabile per fare riferimento a quel valore memorizzato all’interno di un programma di computer.

Possiamo pensare a una variabile come a un’etichetta con un nome, che si lega a un valore.

Diciamo che abbiamo un numero intero, 1032049348, e vogliamo memorizzarlo in una variabile invece di riscrivere continuamente il lungo numero. Per raggiungere questo obiettivo, possiamo usare un nome facile da ricordare, come la variabile i. Per memorizzare un valore in una variabile, usiamo la seguente sintassi:

i := 1032049348

Possiamo pensare a questa variabile come a un’etichetta legata al valore.

L’etichetta ha il nome della variabile i scritto su di essa e si lega al valore intero 1032049348.

La frase i := 1032049348 è una dichiarazione e un’istruzione di assegnazione composta da diverse parti:

• il nome della variabile (i)
• l’assegnazione di dichiarazione breve della variabile (:=)
• il valore che viene assegnato al nome della variabile (1032049348)
• il tipo di dato inferito da Go (int)

Vedremo più avanti come impostare esplicitamente il tipo nella prossima sezione.

Insieme, queste parti compongono l’istruzione che imposta la variabile i uguale al valore dell’intero 1032049348.

Non appena assegniamo una variabile a un valore, inizializziamo o creiamo quella variabile. Una volta fatto ciò, siamo pronti a utilizzare la variabile al posto del valore.

Una volta impostato i uguale al valore di 1032049348, possiamo utilizzare i al posto dell’intero, quindi stampiamolo:

package main

import "fmt"

func main() {
	i := 1032049348
	fmt.Println(i)
}

Output
1032049348

Possiamo anche eseguire rapidamente e facilmente operazioni matematiche utilizzando variabili. Con i := 1032049348, possiamo sottrarre il valore intero 813 con la seguente sintassi:

fmt.Println(i - 813)

Output
1032048535

In questo esempio, Go esegue il calcolo per noi, sottraendo 813 dalla variabile i per restituire la somma 1032048535.

Parlando di matematica, le variabili possono essere impostate uguali al risultato di un’equazione matematica. Puoi anche sommare due numeri e memorizzare il valore della somma nella variabile x:

x := 76 + 145

Potresti aver notato che questo esempio sembra simile all’algebra. Allo stesso modo in cui utilizziamo lettere e altri simboli per rappresentare numeri e quantità all’interno di formule ed equazioni, le variabili sono nomi simbolici che rappresentano il valore di un tipo di dato. Per una corretta sintassi Go, dovrai assicurarti che la tua variabile sia sul lato sinistro di qualsiasi equazione.

Andiamo avanti e stampiamo x:

package main

import "fmt"

func main() {
	x := 76 + 145
	fmt.Println(x)
}

Output
221

Go ha restituito il valore 221 perché la variabile x è stata impostata uguale alla somma di 76 e 145.

Le variabili possono rappresentare qualsiasi tipo di dato, non solo numeri interi:

s := "Hello, World!"
f := 45.06
b := 5 > 9 // Un valore booleano restituirà true o false
array := [4]string{"item_1", "item_2", "item_3", "item_4"}
slice := []string{"one", "two", "three"}
m := map[string]string{"letter": "g", "number": "seven", "symbol": "&"}

Se stampi una di queste variabili, Go restituirà ciò a cui quella variabile è equivalente. Lavoreremo con l’istruzione di assegnazione per il tipo di dato slice stringa:

package main

import "fmt"

func main() {
	slice := []string{"one", "two", "three"}
	fmt.Println(slice)
}

Output
[one two three]

Abbiamo assegnato il valore di []string{"one", "two", "three"} alla variabile slice, e poi abbiamo utilizzato la funzione fmt.Println per stampare quel valore chiamando slice.

Le variabili funzionano creando un piccolo spazio di memoria all’interno del tuo computer che accetta valori specificati che poi sono associati a quello spazio.

Dichiarazione delle Variabili

In Go, ci sono diversi modi per dichiarare una variabile, e in alcuni casi, più di un modo per dichiarare esattamente la stessa variabile e valore.

Possiamo dichiarare una variabile chiamata i di tipo di dato int senza inizializzazione. Ciò significa che dichiareremo uno spazio per mettere un valore, ma non gli daremo un valore iniziale:

var i int

Questo crea una variabile dichiarata come i di tipo di dato int.

Possiamo inizializzare il valore utilizzando l’operatore di uguale (=), come nel seguente esempio:

var i int = 1

In Go, entrambe queste forme di dichiarazione sono chiamate dichiarazioni di variabili lunghe.

Possiamo anche utilizzare dichiarazione di variabile breve:

i := 1

In questo caso, abbiamo una variabile chiamata i e un tipo di dato int. Quando non specifichiamo un tipo di dato, Go inferirà il tipo di dato.

Con i tre modi per dichiarare variabili, la comunità Go ha adottato le seguenti convenzioni:

• Utilizzare solo la forma lunga, var i int, quando non si inizializza la variabile.

• Utilizzare la forma breve, i := 1, quando si dichiara e si inizializza.

• Se non si desidera che Go inferisca il tipo di dato, ma si vuole comunque utilizzare la dichiarazione di variabile breve, si può avvolgere il valore nel tipo desiderato, con la seguente sintassi:

i := int64(1)

Non è considerata convenzione in Go utilizzare la forma di dichiarazione di variabile lunga quando si inizializza il valore:

var i int = 1

È buona pratica seguire come la comunità Go dichiara tipicamente le variabili in modo che altri possano leggere i tuoi programmi senza problemi.

Valori Zero

Tutti i tipi built-in hanno un valore zero. Qualsiasi variabile allocata è utilizzabile anche se non le è mai stato assegnato un valore. Possiamo vedere i valori zero per i seguenti tipi:

package main

import "fmt"

func main() {
	var a int
	var b string
	var c float64
	var d bool

	fmt.Printf("var a %T = %+v\n", a, a)
	fmt.Printf("var b %T = %q\n", b, b)
	fmt.Printf("var c %T = %+v\n", c, c)
	fmt.Printf("var d %T = %+v\n\n", d, d)
}

Output
var a int =  0
var b string = ""
var c float64 = 0
var d bool = false

Abbiamo utilizzato il verbo %T nell’istruzione fmt.Printf. Questo indica alla funzione di stampare il tipo di dato per la variabile.

In Go, poiché tutti i valori hanno un valore zero, non possiamo avere valori indefiniti come in alcuni altri linguaggi. Ad esempio, un booleano in alcuni linguaggi potrebbe essere indefinito, vero o falso, il che permette tre stati per la variabile. In Go, non possiamo avere più di due stati per un valore booleano.

Denominazione delle Variabili: Regole e Stile

La denominazione delle variabili è abbastanza flessibile, ma ci sono alcune regole da tenere a mente:

• I nomi delle variabili devono essere composti da una sola parola (cioè senza spazi).
• I nomi delle variabili devono essere costituiti solo da lettere, numeri e underscore (_).
• I nomi delle variabili non possono iniziare con un numero.

Seguendo queste regole, diamo un’occhiata sia ai nomi di variabili validi che non validi:

Inoltre, tieni presente che nella denominazione delle variabili sono sensibili alle maiuscole. Questi nomi userName, USERNAME, UserName e uSERnAME sono tutti variabili completamente diverse. È buona pratica evitare di utilizzare nomi di variabili simili all’interno di un programma per garantire che sia tu che i tuoi collaboratori, attuali e futuri, possiate tenere d’occhio le vostre variabili.

Sebbene le variabili siano sensibili alle maiuscole, il caso della prima lettera di una variabile ha un significato speciale in Go. Se una variabile inizia con una lettera maiuscola, allora quella variabile è accessibile al di fuori del pacchetto in cui è stata dichiarata (o esportata). Se una variabile inizia con una lettera minuscola, allora è disponibile solo all’interno del pacchetto in cui è dichiarata.

var Email string
var password string

Email inizia con una lettera maiuscola e può essere accessibile da altri pacchetti. password inizia con una lettera minuscola e è accessibile solo all’interno del pacchetto in cui è dichiarata.

È comune in Go utilizzare nomi di variabili molto brevi. Dato il caso tra l’uso di userName e user per una variabile, sarebbe idiomatico scegliere user.

Anche l’ambito gioca un ruolo nella brevità del nome della variabile. La regola è che più piccolo è l’ambito in cui esiste la variabile, più breve è il nome della variabile:

names := []string{"Mary", "John", "Bob", "Anna"}
for i, n := range names {
	fmt.Printf("index: %d = %q\n", i, n)
}

Utilizziamo la variabile names in un ambito più ampio, quindi è comune assegnarle un nome più significativo per facilitare la memorizzazione di ciò che rappresenta nel programma. Tuttavia, utilizziamo le variabili i e n immediatamente nella riga di codice successiva e poi non le utilizziamo più… A causa di ciò, non confonderà chi legge il codice sul dove le variabili sono utilizzate o cosa significano.

Successivamente, affrontiamo alcune note sullo stile delle variabili. Lo stile prevede l’uso di MixedCaps o mixedCaps piuttosto che di underscore per i nomi composti da più parole.

La cosa più importante riguardo allo stile è essere coerenti e che il team con cui lavori sia d’accordo sullo stile.

Riassegnazione delle Variabili

Come suggerisce la parola “variabile”, possiamo modificare facilmente le variabili Go. Ciò significa che possiamo associare un valore diverso a una variabile già assegnata attraverso la riassegnazione. La possibilità di riassegnare è utile perché durante l’esecuzione di un programma potremmo dover accettare valori generati dall’utente in variabili già inizializzate. Potremmo anche dover cambiare l’assegnazione a qualcosa di già definito.

Sapere che possiamo facilmente riassegnare una variabile può essere utile quando si lavora su un grande programma scritto da qualcun altro e non è chiaro quali variabili siano già definite.

Assegniamo il valore di 76 a una variabile chiamata i di tipo int, poi assegniamole un nuovo valore di 42:

package main

import "fmt"

func main() {
	i := 76
	fmt.Println(i)

	i = 42
	fmt.Println(i)
}

Output
76
42

Questo esempio mostra che possiamo prima assegnare alla variabile i il valore di un intero, e poi riassegnare la variabile i assegnandole questa volta il valore di 42.

Poiché Go è un linguaggio tipizzato, non possiamo assegnare un tipo a un altro. Ad esempio, non possiamo assegnare il valore "Sammy" a una variabile di tipo int:

i := 72
i = "Sammy"

Tentare di assegnare tipi diversi tra loro comporterà un errore di compilazione:

Output
cannot use "Sammy" (type string) as type int in assignment

Go non ci permetterà di utilizzare un nome di variabile più di una volta:

var s string
var s string

Output
s redeclared in this block

Se proviamo a utilizzare la dichiarazione breve di variabile più di una volta per lo stesso nome di variabile, riceveremo anche un errore di compilazione. Questo può accadere per sbaglio, quindi capire cosa significa il messaggio di errore è utile:

i := 5
i := 10

Output
no new variables on left side of :=

Analogamente alla dichiarazione di variabili, prestare attenzione alla denominazione delle tue variabili migliorerà la leggibilità del tuo programma per te e per gli altri, quando lo rivisiterai in futuro.

Assegnazione Multipla

Go ci consente anche di assegnare diverse variabili a diverse variabili nella stessa riga. Ciascuna di queste variabili può essere di un tipo di dati diverso:

j, k, l := "shark", 2.05, 15
fmt.Println(j)
fmt.Println(k)
fmt.Println(l)

Output
shark
2.05
15

In questo esempio, la variabile j è stata assegnata alla stringa "shark", la variabile k è stata assegnata al float 2.05, e la variabile l è stata assegnata all’intero 15.

Questo approccio all’assegnazione di più variabili a più valori in una sola riga può ridurre il numero di righe nel codice. Tuttavia, è importante non compromettere la leggibilità per avere meno righe di codice.

Variabili Globali e Locali

Quando si utilizzano variabili all’interno di un programma, è importante tenere a mente l’ambito delle variabili. L’ambito di una variabile si riferisce a particolari luoghi da cui è accessibile all’interno del codice di un dato programma. Ciò significa che non tutte le variabili sono accessibili da tutte le parti di un dato programma – alcune variabili saranno globali e altre saranno locali.

Le variabili globali esistono al di fuori delle funzioni. Le variabili locali esistono all’interno delle funzioni.

Diamo un’occhiata a variabili globali e locali in azione:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global

Qui utilizziamo `var g = "global"` per creare una variabile globale al di fuori della funzione. Poi definiamo la funzione `printLocal()`. All’interno della funzione, una variabile locale chiamata `l` viene assegnata e poi stampata. Il programma termina chiamando `printLocal()` e poi stampando la variabile globale `g`.

Poiché `g` è una variabile globale, possiamo fare riferimento ad essa in `printLocal()`. Modifichiamo il programma precedente per farlo:

package main

import "fmt"


var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
	fmt.Println(g)
}

func main() {
	printLocal()
	fmt.Println(g)
}

Output
local
global
global

Iniziamo dichiarando una variabile globale `g`, `var g = "global"`. Nella funzione `main`, chiamiamo la funzione `printLocal`, che dichiara una variabile locale `l` e la stampa, `fmt.Println(l)`. Poi, `printLocal` stampa la variabile globale `g`, `fmt.Println(g)`. Anche se `g` non era definita all’interno di `printLocal`, poteva comunque essere accessibile perché era stata dichiarata in uno scope globale. Infine, la funzione `main` stampa anche `g`.

Ora proviamo a chiamare la variabile locale al di fuori della funzione:

package main

import "fmt"

var g = "global"

func printLocal() {
	l := "local"
	fmt.Println(l)
}

func main() {
	fmt.Println(l)
}

Output
undefined: l

Non possiamo utilizzare una variabile locale al di fuori della funzione in cui viene assegnata. Se provi a farlo, riceverai un errore `undefined` durante la compilazione.

Diamo un’occhiata a un altro esempio in cui utilizziamo lo stesso nome di variabile per una variabile globale e una locale:

package main

import "fmt"

var num1 = 5

func printNumbers() {
	num1 := 10
	num2 := 7  

	fmt.Println(num1)
	fmt.Println(num2)
}

func main() {
	printNumbers()
	fmt.Println(num1)
}

Output
10
7
5

In questo programma, abbiamo dichiarato la variabile num1 due volte. Prima, abbiamo dichiarato num1 a livello globale, var num1 = 5, e poi all’interno dell’ambito locale della funzione printNumbers, num1 := 10. Quando stampiamo num1 dal programma main, vediamo il valore di 5 stampato. Questo perché main vede solo la dichiarazione della variabile globale. Tuttavia, quando stampiamo num1 dalla funzione printNumbers, vede la dichiarazione locale e stamperà il valore di 10. Anche se printNumbers crea una nuova variabile chiamata num1 e le assegna un valore di 10, non influisce sull’istanza globale di num1 con il valore di 5.

Quando si lavora con variabili, è necessario considerare anche quali parti del programma avranno bisogno di accedere a ciascuna variabile; adottando una variabile globale o locale di conseguenza. In programmi Go, troverai che le variabili locali sono tipicamente più comuni.

Costanti

Le costanti sono come variabili, tranne per il fatto che non possono essere modificate una volta dichiarate. Le costanti sono utili per definire un valore che verrà utilizzato più volte nel programma, ma non dovrebbe essere in grado di cambiare.

Ad esempio, se volessimo dichiarare l’aliquota fiscale per un sistema di carrello della spesa, potremmo utilizzare una costante e poi calcolare le tasse in diverse aree del nostro programma. In futuro, se l’aliquota fiscale cambia, dobbiamo solo modificare quel valore in un unico punto del nostro programma. Se avessimo usato una variabile, potrebbe accadere che accidentalmente cambiassimo il valore da qualche parte nel nostro programma, il che comporterebbe un calcolo errato.

Per dichiarare una costante, possiamo utilizzare la seguente sintassi:

const shark = "Sammy"
fmt.Println(shark)

Output
Sammy

Se tentiamo di modificare una costante dopo che è stata dichiarata, otterremo un errore in fase di compilazione:

Output
cannot assign to shark

Le costanti possono essere untyped. Questo può essere utile quando si lavora con numeri come dati di tipo intero. Se la costante è untyped, viene convertita esplicitamente, mentre le costanti typed non lo sono. Vediamo come possiamo utilizzare le costanti:

package main

import "fmt"

const (
	year     = 365
	leapYear = int32(366)
)

func main() {
	hours := 24
	minutes := int32(60)
	fmt.Println(hours * year)    
	fmt.Println(minutes * year)   
	fmt.Println(minutes * leapYear)
}

Output
8760
21900
21960

Se dichiari una costante con un tipo, sarà esattamente di quel tipo. Qui, quando dichiariamo la costante leapYear, la definiamo come tipo di dato int32. Pertanto, è una costante typed, il che significa che può operare solo con tipi di dato int32. La costante year che dichiariamo senza tipo, quindi è considerata untyped. A causa di ciò, puoi utilizzarla con qualsiasi tipo di dato intero.

Quando hours è stato definito, è stato inferito che fosse di tipo int perché non gli abbiamo dato esplicitamente un tipo, hours := 24. Quando abbiamo dichiarato minutes, l’abbiamo dichiarato esplicitamente come int32, minutes := int32(60).

Ora analizziamo ogni calcolo e spieghiamo perché funziona:

hours * year

In questo caso, hours è un int, e years è non tipizzato. Quando il programma viene compilato, converte esplicitamente years in un int, consentendo il successo dell’operazione di moltiplicazione.

minutes * year

In questo caso, minutes è un int32, e year è non tipizzato. Quando il programma viene compilato, converte esplicitamente years in un int32, consentendo il successo dell’operazione di moltiplicazione.

minutes * leapYear

In questo caso, minutes è un int32, e leapYear è una costante tipizzata di int32. Non c’è nulla da fare per il compilatore questa volta poiché entrambe le variabili sono già dello stesso tipo.

Se proviamo a moltiplicare due tipi che sono tipizzati e non compatibili, il programma non compilerà:

fmt.Println(hours * leapYear)

Output
invalid operation: hours * leapYear (mismatched types int and int32)

In questo caso, hours è stato inferito come un int, e leapYear è stato dichiarato esplicitamente come un int32. Poiché Go è un linguaggio tipizzato, un int e un int32 non sono compatibili per operazioni matematiche. Per moltiplicarli, sarebbe necessario convertire uno in un int32 o un int.

Conclusione

In questo tutorial abbiamo esaminato alcuni dei casi d’uso comuni delle variabili all’interno di Go. Le variabili sono un elemento costitutivo fondamentale della programmazione, fungendo da simboli che rappresentano il valore di un tipo di dato che utilizziamo in un programma.