1. Variabili e Costanti

In Golang, le variabili e le costanti sono due concetti fondamentali che svolgono un ruolo molto importante in un programma.

  • Una variabile è un identificatore nominato utilizzato per memorizzare dati in un programma. In Golang, la parola chiave var viene utilizzata per dichiarare le variabili.
  • Una costante è un identificatore il cui valore non può essere modificato nel programma. In Golang, la parola chiave const viene utilizzata per dichiarare le costanti.

2 Dichiarazione e Inizializzazione delle Variabili in Golang

2.1 Dichiarazione e Assegnazione di una Singola Variabile

Nel linguaggio Go, la parola chiave var viene utilizzata per dichiarare una variabile con il formato var nome_variabile tipo. Dopo la dichiarazione, la variabile può ricevere un valore nel codice successivo, o può essere direttamente inizializzata al momento della dichiarazione. Ad esempio:

var eta int // Dichiarare una variabile intera di nome eta
eta = 25    // Assegnare un valore alla variabile

var nome string = "Alice" // Dichiarare e inizializzare la variabile nome

2.2 Dichiarazione di Più Variabili

Il linguaggio Go supporta la dichiarazione simultanea di più variabili, il che può rendere il codice più conciso. La dichiarazione bulk viene solitamente fatta all'inizio di una funzione o a livello di pacchetto. Ad esempio:

var (
    nome, cognome string
    eta             int
)

nome = "John"
cognome = "Doe"
eta = 30

Nella precedente dichiarazione bulk, nome e cognome sono dichiarati come stringhe, mentre eta è un intero.

2.3 Inferenza del Tipo e Dichiarazione Breve di Variabili

Nel linguaggio Go, non è sempre necessario specificare esplicitamente il tipo della variabile. Se viene fornita un'espressione di inizializzazione durante la dichiarazione di una variabile, Go può inferire il tipo della variabile. Questo è noto come inferenza del tipo. La dichiarazione breve delle variabili utilizzando := può semplificare l'istruzione per dichiarare e inizializzare le variabili basandosi sull'inferenza del tipo. Ad esempio:

citta := "Pechino"  // Utilizzare la dichiarazione breve di variabili per dichiarare e inizializzare simultaneamente la città
paese := "Cina"  // il paese è inferito come tipo stringa

È importante notare che le dichiarazioni brevi delle variabili possono essere utilizzate solo all'interno delle funzioni e non possono essere utilizzate a livello globale.

2.4 Dichiarazione delle Variabili al di Fuori delle Funzioni

Le variabili dichiarate al di fuori delle funzioni hanno un ambito a livello di pacchetto. Queste variabili sono visibili e accessibili in tutto il pacchetto. Ad esempio:

var variabileGlobale string = "Sono globale" // Dichiarazione di una variabile globale

func stampaVariabileGlobale() {
    fmt.Println(variabileGlobale) // Accesso alla variabile globale all'interno della funzione
}

Le variabili globali possono essere condivise tra qualsiasi funzione all'interno del pacchetto, ma devono essere utilizzate con attenzione per evitare potenziali conflitti di denominazione e riferimenti non chiari.

Suggerimento: Capire il codice di funzione di base qui è sufficiente, spiegazioni dettagliate delle funzioni saranno fornite nelle sezioni successive.

3 Tipi di Dati Basici e Valori Zero

3.1 Tipi di Dati Basici in Golang

Nel linguaggio Go, ogni tipo di variabile fornisce semantica esplicita e caratteristiche comportamentali. Ecco alcuni tipi di dati basici comuni:

  • int, int8, int16, int32, int64: Diverse gamme di numeri interi
  • uint, uint8, uint16, uint32, uint64: Numeri interi non firmati
  • float32, float64: Numeri in virgola mobile
  • bool: Valori booleani (vero o falso)
  • string: Stringhe

3.2 Concetto di Valori Zero

Nel linguaggio Go, le variabili vengono automaticamente inizializzate al valore zero del loro tipo dopo la dichiarazione. Il valore zero si riferisce al valore predefinito del tipo corrispondente quando una variabile non è esplicitamente inizializzata. Questo non è comune in alcuni altri linguaggi, ma in Go, assicura che tutte le variabili abbiano sempre un valore iniziale valido. Ecco i valori zero per ciascun tipo di dati base:

  • Il valore zero per un numero intero è 0
  • Il valore zero per un numero in virgola mobile è 0.0
  • Il valore zero per un booleano è false
  • Il valore zero per una stringa è una stringa vuota ""

Ad esempio:

var i int     // Il valore zero è 0
var f float64 // Il valore zero è 0.0
var b bool    // Il valore zero è false
var s string  // Il valore zero è ""

Comprendere il concetto di valori zero è molto importante, in quanto può aiutare gli sviluppatori a comprendere il comportamento dell'inizializzazione delle variabili e può essere utilizzato per prevenire errori di puntatore nullo o non inizializzato.

4. Ambito delle Variabili

4.1 Variabili Locali

Le variabili locali sono variabili definite all'interno di una funzione e possono essere accessibili solo all'interno di quella funzione. Anche i parametri delle funzioni appartengono alle variabili locali. Dal momento della creazione fino al completamento dell'esecuzione della funzione, le variabili locali scompaiono. Ogni volta che una funzione viene chiamata, le variabili locali vengono ricreate.

func esempioVariabileLocale() {
    var variabileLocale int = 10 // Questa è una variabile locale
    fmt.Println(variabileLocale)
}

func main() {
    esempioVariabileLocale() // Output: 10
    // fmt.Println(variabileLocale) // Questo causerà un errore di compilazione perché variabileLocale non è visibile qui
}

Nell'esempio sopra, variabileLocale può essere accessibile solo all'interno della funzione esempioVariabileLocale.

4.2 Variabili Globali

Le variabili globali sono variabili definite al di fuori delle funzioni e possono essere accessibili in qualsiasi file all'interno dello stesso package. Se si desidera utilizzare variabili globali in altri package, il nome della variabile deve iniziare con una lettera maiuscola, in conformità con le regole di controllo degli accessi di Go.

package main

import "fmt"

var variabileGlobale int = 20 // Questa è una variabile globale

func main() {
    fmt.Println(variabileGlobale) // Output: 20
    cambiaGlobale()
    fmt.Println(variabileGlobale) // Output: 30
}

func cambiaGlobale() {
    variabileGlobale = 30 // Cambia il valore della variabile globale
}

In questo esempio, variabileGlobale è visibile sia nella funzione main che nella funzione cambiaGlobale.

5 Dichiarazione e Uso delle Costanti

5.1 La Parola chiave const

Usiamo la parola chiave const per definire costanti. Le costanti sono valori che non possono essere modificati e una volta definite, il loro valore non può essere cambiato. Le costanti possono essere di qualsiasi tipo di dato di base come interi, numeri in virgola mobile, booleani o stringhe.

const Pi = 3.14 // Dichiarare una costante float
const StrCostante string = "Ciao, Mondo!" // Dichiarare una costante stringa

func main() {
    fmt.Println(Pi)
    fmt.Println(StrCostante)
}

5.2 Costanti Enumerative

Il linguaggio Go non ha un tipo di enumerazione specifico, ma è possibile utilizzare la parola chiave iota per realizzare un'enumerazione. All'interno di un blocco const, ogni dichiarazione costante aggiuntiva incrementerà il valore di iota di 1.

const (
    Domenica = iota  // 0
    Lunedì          // 1
    Martedì         // 2
    Mercoledì       // 3
    Giovedì        // 4
    Venerdì         // 5
    Sabato         // 6
)

func main() {
    fmt.Println(Domenica)    // Output: 0
    fmt.Println(Sabato)  // Output: 6
}

Il codice sopra dichiara un'enumerazione per i giorni della settimana, dove iota si inizializza a 0 all'interno del blocco const e incrementa di 1 per ogni dichiarazione successiva.

5.3 Ambito delle Costanti

L'ambito delle costanti è simile a quello delle variabili. Se una costante è definita all'interno di una funzione, il suo ambito è limitato a quella funzione. Se una costante è definita al di fuori di una funzione (globalmente), il suo ambito è l'intero package, e se la prima lettera è maiuscola, può essere accessibile in altri package.

Gestire l'ambito delle costanti aiuta a ridurre l'inquinamento dell'ambito globale e migliora la manutenibilità e la leggibilità del programma.

const CostanteGlobale = "Questa è una costante globale"

func main() {
    const CostanteLocale = "Questa è una costante locale"
    fmt.Println(CostanteGlobale)  // Questo è valido
    fmt.Println(CostanteLocale)   // Questo è valido
}

func unAltraFunzione() {
    // fmt.Println(CostanteLocale) // Questo causerà un errore di compilazione: CostanteLocale non è visibile in questa funzione
    fmt.Println(CostanteGlobale)  // Questo è valido
}

In questo esempio, CostanteLocale può essere accessibile solo all'interno della funzione main, mentre CostanteGlobale può essere accessibile in tutto il package.