Variables e costanti sono concetti fondamentali nella maggior parte delle linguaggi di programmazione. Sono i blocchi di base per il salvataggio e la gestione dei dati.
In questo articolo, esamineremo come funzionano le variabili e le costanti in Go.
Indice dei contenuti:
Cosa sono le Variabili?
Una variabile è un punto di storage identificato da un nome (o identificatore) che contiene un valore. Questo valore può cambiare (o variare) durante l’esecuzione di un programma. Ecco perché si chiama variabile.
Per esempio:
myName := “temitope”
fmt.Println(myName)
myName:= ”oyedele”
fmt.Println(myName)
Abbiamo creato una variabile con un identificatore di myName che contiene un valore della stringa.
Se avete notato, abbiamo cambiato il valore in un’altra stringa, e possiamo fare questo molte volte perché le variabili consentono di fare ciò.
Le variabili consentono di memorizzare dati, che possono essere di diversi tipi, come interi, numeri a virgola mobile, stringhe o oggetti.
Come creare una variabile in Go
Esistono due modi primari per creare una variabile in Go, la dichiarazione esplicita e la dichiarazionebreve.
Dichiarazione esplicita
È il metodo tradizionale per creare una variabile in Go. Funziona utilizzando la parola chiave var e dichiarando il tipo della variabile, rendendo il tuo codice più leggibile e chiaro.
package main
import "fmt"
func main() {
var age int = 25
var name string = "Temitope"
var height float64 = 5.7
fmt.Println(age, name, height)
}
Potete vedere che, per ogni variabile, abbiamo dichiarato il suo tipo di dati prima di assegnare un valore a esso.
output:
25 Temitope 5.7
La parola chiave var e il tipo di dati possono anche essere usati senza un valore iniziale:
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)
}
In questo modo, le variabili vengono dichiarate prima senza un valore iniziale. Vengono poi assegnati valori più avanti nel codice. Avrete lo stesso output della prima.
Dichiarazione breve della variabile
La sintassi di dichiarazione della variabile in chiave (:=) è un modo più conciso per dichiarare le variabili. Questo metodo consente di dichiarare e inizializzare una variabile in una sola riga senza esplicitare esplicitamente il suo tipo, poiché il tipo viene dedotto dalla sua valore assegnato.
package main
import "fmt"
func main() {
age := 25
name := "Temitope"
height := 5.7
fmt.Println(age, name, height)
}
Qui, ogni variabile è stata dichiarata insieme al suo valore, con Go che ha dedotto il tipo dati. Per esempio, age è stata dichiarata e inizializzata con il valore 25, e Go ha dedotto il suo tipo come int. name è stata dichiarata con il valore “Temitope”, e Go ha dedotto il suo tipo come string. Infine, height è stata dichiarata con 5.7, e Go ha dedotto il suo tipo come float64.
output:
25 Temitope 5.7
Uno dei limiti della dichiarazione breve della variabile è che puoi usarlo solo all’interno di una funzione.
Dichiarazioni multiple di variabili
Puoi dichiarare e inizializzare molteplici variabili nella stessa riga separando ogni variabile con una virgola. Questo approcio è semplice e diretto. viene comunemente usato quando le variabili sono collegate o quando vuoi inizializzarle insieme. Per esempio:
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)
}
Qui, la variabile age e height sono entrambe dichiarate come interi e inizializzate con i valori 25 e 180, rispettivamente. La variabile name e city sono anche entrambe dichiarate come stringhe e inizializzate con “Temitope” e “New York”:
Output:
25 180
Temitope New York
Puoi anche dichiarare molteplici variabili in un blocco come segue:
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)
}
Qui, le variabili age, name, height e city sono dichiarate all’interno di un solo blocco var, con ogni variabile a sua volta su una riga.
Output:
25 Temitope 180 New York
Valori di default
Quando vengono dichiarate delle variabili senza essere inizializzate, queste assumono automaticamente valori di default. questi valori differiscono a seconda del tipo di variabile. Ecco un esempio di come possono essere dichiarati i valori default:
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)
}
Nel codice sopra, ecco cosa succederà:
-
La variabile intera
intValuericeverà il valore di default 0. -
Il numero a virgola mobile
floatValuericeverà il valore di default 0. -
La variabile booleana
boolValuericeverà il valore di defaultfalse. -
La stringa
stringValuericeverà il valore di default “” (stringa vuota). -
Il puntatore
ptrValue, il slicesliceValuee la mappamapValuericeveranno tutti il valore di defaultnil.
Output:
Output:
Zero values:
int: 0
float64: 0
bool: false
string:
pointer: <nil>
slice: []
map: map[]
Cosa è la Portata di una Variabile?
Le variabili possono essere dichiarate sia globalmente che localmente. La portata di una variabile determina dove può essere accessibile e modificabile nel tuo codice.
Le variabili globali sono dichiarate fuori da qualsiasi funzione, di solito all’inizio di un file, e possono essere accessibili da qualsiasi funzione all’interno dello stesso package. Ecco un esempio:
package main
import "fmt"
var globalCounter int = 0
func incrementCounter() {
globalCounter++
}
func main() {
fmt.Println("Initial Counter:", globalCounter)
incrementCounter()
fmt.Println("After Increment:", globalCounter)
}
Nell’esempio precedente, globalCounter è la variabile globale, e può essere accessibile sia dalla funzione incrementCounter che dalla funzione main.
Inoltre, il valore di globalCounter persistono tra chiamate di funzione. Questo significa che qualunque cambiamento viene fatto a questo nella funzione numero uno influirà sul suo valore in altre parti del programma.
Le variabili locali, d’altro canto, sono dichiarate all’interno di una funzione o di un blocco e sono accessibili solo in quella funzione o in quel blocco specifico. Vengono create quando viene eseguita la funzione o il blocco e distrutte una volta completata. Ad esempio:
package main
import "fmt"
func incrementCounter() {
localCounter := 0
localCounter++
fmt.Println("Local Counter:", localCounter)
}
func main() {
incrementCounter()
incrementCounter()
}
Nel codice precedente, abbiamo localCounter come variabile locale all’interno della funzione incrementCounter. Ogni volta che incrementCounter viene chiamata, una nuova localCounter viene creata, inizializzata a 0, e incrementata.
Il valore di localCounter non persiste tra chiamate di funzione, quindi non può influenzare alcuna parte del programma quando viene fatto un cambiamento alla funzione.
Naming Conventions in Go
L’adozione di nomi corretti per le variabili è fondamentale per la scrittura di codice pulito, leggibile e facile da manutenere. Go ha alcune specifiche convenzioni e regole per la nomenclatura delle variabili. Ecco alcuni di essi:
-
Utilizzare nomi descrittivi:
Utilizzare nomi che descrivano chiaramente l’obiettivo o il contenuto della variabile. Per esempio, invece di usare nomi vaghi come x o y, usare nomi come
age,totalPrice, ouserNameche chiaramente indicano cosa rappresenta la variabile. -
Utilizzare CamelCase per nomi composti da più parole: In Go, è common practice usare camelCase per i nomi di variabile composti da più parole. La prima parola è in minuscolo, e la prima lettera di ogni parola successiva è in maiuscolo.
-
Evitare l’uso di underscore: Contrariamente ad alcune altre lingue, Go preferisce camelCase all’uso di underscore per separare le parole nei nomi di variabile. Non usare underscore e adeguarsi allo stile idiomatico di Go.
-
Usa nomi brevi per variabili a breve durata: Per variabili a breve durata, come contatori o indici di ciclo, è accettabile usare nomi brevi come i, j o k.
Cos’è una costante in Go?
Le costanti sono valori immutabili definite durante la compilazione che non possono essere modificate durante l’esecuzione del programma. Sono utili per definire valori che si conoscono anticipatamente e rimarranno costanti.
Pensate a quanto stiate costruendo un negozio online dove il costo standard di spedizione è sempre di 10 dollari. Puoi dichiararlo come costante, quindi puoi usarlo in ogni parte del tuo programma ogni volta che servono applicare le spese di spedizione. Se i tassi di spedizione cambiano, devi aggiornare il valore solo in un posto.
Come dichiarare costanti in Go
Puoi dichiarare costanti usando il keyword const, seguito dal nome, dal tipo (opzionale se il valore implica il tipo) e dal valore della costante. Ecco come:
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 provi a cambiare una costante dopo averla dichiarata, riceverai un errore di compilazione.
Tipi di costanti in Go
Le costanti possono essere categorizzate come tipate o non tipate. Entrambi i tipi di costanti servono lo stesso scopo. Forniscono valori fissi e immutabili attraverso il programma. Tuttavia, differiscono nel modo in cui Go gestisce i loro tipi e nella flessibilità con cui vengono usate.
Le costanti non definite sono quelle per le quali non viene assegnato alcun tipo di dato finché non vengono utilizzate in un contesto che richiede tale tipo. Quando si dichiara una costante non definita, il compilatore di Go deduce il tipo in quel punto in cui viene utilizzata la costante. Questo rende le costanti non definite più flessibili poiché possono essere utilizzate in molti contesti senza la necessità di una conversione di 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)
}
Qui, gravity è la costante non definita. Ciò significa che Go può dedurne il tipo in base all’uso che ne viene fatto. Quando gravity viene utilizzata in un calcolo con un float64, Go la tratterà automaticamente come float64.
A differenza delle costanti non definite, le costanti definite hanno un tipo dichiarato in modo esplicito. Questo significa che possono essere utilizzate solo in contesti che corrispondono a quel tipo o possono essere convertite in un tipo compatibile. Le costanti definite sono più rigide, garantendo che il valore venga sempre trattato come il tipo specifico con cui è stata dichiarata.
package main
import "fmt"
const speedOfLight int = 299792458
func main() {
var distance int = speedOfLight * 2
fmt.Println("Distance:", distance)
}
Qui, speedOfLight è la costante definita con il tipo int.
Può essere utilizzata solo in operazioni con altri valori di tipo int o convertita in modo esplicito a un altro tipo.
Ecco qui
Nell’articolo, abbiamo approfondito cosa sono le variabili e le costanti e come dichiararle in Go.
Variabili e costanti sono strumenti chiave nella programmazione. Permettono agli sviluppatori di gestire e manipolare i dati in modo efficiente. Quando si comprende come usarle, è possibile migliorare la qualità del codice.
Condividi se questo ti è stato utile.
Source:
https://www.freecodecamp.org/news/variables-and-constants-in-go/