Ecco il programma completo. Premi Run.
Nessuna di queste righe è facoltativa. Il resto della pagina spiega cosa fa ciascuna.
Riga per riga
package main
Ogni file Go inizia con una clausola package che indica il package a cui appartiene. Il nome main è speciale: segna il package come programma eseguibile. Qualsiasi altro nome (package utils, package hello) crea una libreria che altro codice importa ma che non può essere eseguita da sola.
import "fmt"
import porta dentro un altro package così puoi usarlo. fmt è il package di formattazione e stampa della libreria standard. Dopo l'import, i suoi nomi esportati si raggiungono attraverso il nome del package: fmt.Println, fmt.Printf, fmt.Sprintf.
Per importare più package, usa un blocco tra parentesi con un percorso per riga:
import (
"fmt"
"strings"
)
Go si rifiuta di compilare un file che importa un package senza usarlo. Così le liste di dipendenze restano oneste, ed è il primo errore in cui inciampano quasi tutti.
func main()
func dichiara una funzione. main nel package main è il punto di ingresso: il programma parte quando parte main e finisce quando main ritorna. Non prende argomenti e non restituisce nulla. Gli argomenti da riga di comando arrivano da os.Args, e i codici di uscita da os.Exit.
fmt.Println("Hello, World!")
Println stampa i suoi argomenti, mette uno spazio tra l'uno e l'altro e aggiunge un a capo. Il nome inizia con la maiuscola perché da un package si esportano solo i nomi con l'iniziale maiuscola. fmt.println con la p minuscola è un errore di compilazione.
Stampare più di una stringa
Println accetta un numero qualsiasi di valori di qualsiasi tipo. Printf ti dà il controllo sul formato:
%s viene sostituito da una stringa e %d da un intero. Printf e Print non aggiungono l'a capo, quindi il \n lo scrivi tu. La tabella completa dei verbi è nella pagina di fmt.Printf.
Eseguilo sul tuo computer
Con Go installato, salva il programma come main.go in una cartella vuota ed eseguilo:
go run main.go
Hello, World!
go run compila il file in un binario temporaneo e lo esegue. Per produrre un binario da tenere e copiare altrove, usa go build:
go mod init example.com/hello
go build
./hello
Hello, World!
go build ha bisogno di un modulo (un file go.mod), che viene creato da go mod init. Il binario prende il nome dall'ultima parte del percorso del modulo, qui hello (hello.exe su Windows). La differenza tra run, build e install è spiegata in go run e go build.
Dove sono finiti i punti e virgola
La grammatica di Go usa i punti e virgola, ma non li scrivi quasi mai. Il compilatore ne inserisce uno alla fine di ogni riga il cui ultimo token potrebbe chiudere un'istruzione: un identificatore, un letterale, ), } e alcune parole chiave come return. Questa regola è il motivo per cui fallisce questo stile, molto comune in altri linguaggi:
func main()
{
fmt.Println("Hello, World!")
}
./main.go:6:1: syntax error: unexpected semicolon or newline before {
È stato inserito un punto e virgola dopo func main(), quindi la { sulla riga successiva è un errore. La graffa di apertura va sempre sulla stessa riga. La stessa regola vale per if, for, switch e per ogni altro blocco.
I primi errori, spiegati
Questi sono i messaggi che vede chi comincia nella prima ora, esattamente come li stampa Go 1.24.
Un import o una variabile non usati.
package main
import (
"fmt"
"os"
)
func main() {
x := 5
fmt.Println("hi")
}
./main.go:5:2: "os" imported and not used
./main.go:9:2: declared and not used: x
Sono entrambi errori di compilazione, non avvisi. Cancella l'import o la variabile. Se devi tenere una variabile mentre fai debug, assegnala all'identificatore vuoto: _ = x.
Nome di funzione in minuscolo.
./main.go:6:6: undefined: fmt.println
I nomi non esportati sono invisibili fuori dal loro package. Usa fmt.Println.
Il nome di package sbagliato.
package example.com/hello is not a main package
Il file dice package hello (o qualsiasi cosa diversa da main) e hai provato a eseguirlo. Cambialo in package main.
Modulo mancante.
go: go.mod file not found in current directory or any parent directory; see 'go help modules'
go build e go run . lavorano sui moduli. Esegui go mod init example.com/hello una volta nella cartella. go run main.go, che indica un file, funziona anche senza.
Formattazione
Go ha un solo stile di codice ufficiale, e gofmt lo applica. Eseguilo su ogni file che scrivi:
go fmt ./...
Usa i tab per l'indentazione, allinea commenti e campi delle struct e normalizza gli spazi. Gli editor con supporto per Go lo eseguono al salvataggio. Il codice Go ha lo stesso aspetto ovunque, quindi non c'è niente da configurare e niente da discutere in code review.
Domande frequenti
Come si scrive hello world in Go?
Salva questo come main.go:
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
Poi esegui go run main.go. Stampa Hello, World!.
Perché un programma Go ha bisogno di package main?
package main dice al compilatore che questo package è un programma eseguibile e non una libreria. Il programma parte dalla funzione main del package main. Qualsiasi altro nome di package produce una libreria, e go run la rifiuta con "is not a main package".
Perché in Go la graffa di apertura va sulla stessa riga?
Go inserisce automaticamente un punto e virgola alla fine delle righe che potrebbero chiudere un'istruzione, anche dopo func main(). Una { sulla riga successiva aprirebbe quindi un blocco separato, e il compilatore segnala syntax error: unexpected semicolon or newline before {. La graffa deve stare sulla stessa riga.
Cosa significa fmt in Go?
fmt è il package della libreria standard per input e output formattati (il nome abbrevia "format"). fmt.Println stampa i suoi argomenti separati da spazi e con un a capo finale; fmt.Printf stampa usando una stringa di formato.
