1 Struttura di base di un programma in Go

Un programma in Go inizia con la dichiarazione di un pacchetto, seguita dall'importazione dei pacchetti necessari, dalle dichiarazioni di variabili a livello di pacchetto, costanti e tipi, e infine dalle funzioni contenute all'interno del pacchetto. Prendendo come esempio "Hello World", di seguito è riportata una tipica struttura di base di un programma in Go:

package main // Dichiara il pacchetto principale, indicando un programma eseguibile in modo indipendente

import "fmt" // Importa il pacchetto fmt, che contiene funzioni di input e output

// funzione main, il punto di ingresso del programma
func main() {
    fmt.Println("Ciao, mondo!") // Stampa Ciao Mondo sul terminale
}

Concetto e Scopo dei Pacchetti

Nel linguaggio Go, un pacchetto è una raccolta di più file sorgente Go e funge da meccanismo di riuso del codice a un livello superiore. Ogni file in Go appartiene a un pacchetto, e il nome del pacchetto dovrebbe essere lo stesso nome della directory in cui risiede.

Regole di denominazione dei file sorgente

La denominazione dei file sorgente Go segue generalmente lettere minuscole e non contiene spazi o caratteri speciali, come hello_world.go. Il nome del file sorgente non deve essere coerente con il nome del pacchetto, ma le dichiarazioni del pacchetto in tutti i file all'interno dello stesso pacchetto dovrebbero avere nomi di pacchetto coerenti.

Uso dei commenti nel programma

Nel linguaggio Go, i commenti si presentano in due forme: commenti su una singola riga che iniziano con // e commenti su più righe che iniziano con /* e terminano con */. Il contenuto dei commenti è ignorato dal compilatore.

// Questo è un commento su una singola riga

/*
Questo è un commento su più righe
che si estende su più
righe.
*/

2 La funzione main e il punto di ingresso del programma

In un programma Go, la funzione main è appositamente progettata come punto di ingresso del programma. Il runtime Go chiama automaticamente la funzione main all'interno del pacchetto principale per avviare l'esecuzione del programma.

package main

import "fmt"

func main() {
    fmt.Println("Ciao, mondo!")
}

La funzione main non accetta argomenti e non restituisce valori. Dopo l'esecuzione della funzione main, il programma termina automaticamente. Se è necessario restituire un codice di stato quando il programma termina, dovrebbe essere utilizzata la funzione os.Exit.

3 Compilazione ed esecuzione del programma

Uso del comando go build

L'esecuzione del comando go build compilerà il file sorgente e genererà un file eseguibile. Nel terminale, spostati nella directory in cui si trova il file sorgente e inserisci il seguente comando:

go build hello_world.go

Dopo un'attuazione di successo, vedrai un file eseguibile chiamato hello_world (o hello_world.exe su Windows) nella directory corrente.

Uso del comando go run

Il comando go run compila ed esegue il programma Go, il che è molto conveniente per un rapido test e sviluppo. Per eseguire il programma Hello World, puoi inserire:

go run hello_world.go

Dopo l'esecuzione di questo comando, dovresti vedere immediatamente l'output "Ciao, mondo!" nel terminale.

4. Output del programma

In un programma Go, la funzione Println fornita dal pacchetto fmt può essere utilizzata per stampare informazioni sul terminale. Di seguito è riportato un esempio di codice che stampa "Ciao, mondo!" sul terminale:

package main

import "fmt"

func main() {
    fmt.Println("Ciao, mondo!") // Output al terminale
}

Dopo l'esecuzione del programma, l'output può essere visualizzato direttamente nel terminale della riga di comando. Inoltre, è possibile soddisfare requisiti di output più complessi utilizzando il pacchetto log o manipolando direttamente lo stream di output standard os.Stdout.

import "os"
os.Stdout.WriteString("Ciao, mondo!\n") // Manipolazione diretta dello stream di output standard

import "log"
log.Println("Ciao, mondo!") // Utilizzo del pacchetto di log per l'output, che include informazioni sulla data e sull'ora

Questi metodi di output di base sono importanti mezzi di interazione con gli utenti e vengono comunemente utilizzati per il debug dei programmi per stampare informazioni critiche.