Go Cheat Sheet
Ultimo aggiornamento
Hello World e struttura del programma
Ogni programma Go vive in un package; il punto di ingresso è func main nel package main.
| Operazione | Sintassi |
|---|---|
| Dichiarazione del package | package main |
| Importare un package | import "fmt" |
| Importare più package | import (\n "fmt"\n "os"\n) |
| Punto di ingresso | func main() { ... } |
| Stampare una riga | fmt.Println("Hello, World!") |
| Stampa formattata | fmt.Printf("%d items\n", n) |
| Eseguire un file | go run main.go |
| Compilare un binario | go build |
Variabili e tipi
Go è tipizzato staticamente ma può dedurre i tipi con :=.
| Operazione | Sintassi |
|---|---|
| Dichiarare con il tipo | var age int = 30 |
| Dichiarare con inferenza | var name = "Ada" |
| Dichiarazione breve | count := 0 |
| Più variabili insieme | x, y := 1, 2 |
| Costante | const Pi = 3.14 |
| Valori zero | 0, "", false, nil |
| Tipi di base | int, float64, string, bool, byte, rune |
| Conversione di tipo | f := float64(i) |
Controllo del flusso
Go ha una sola parola chiave per i cicli, for, e niente parentesi intorno alle condizioni.
| Operazione | Sintassi |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| If con istruzione di inizializzazione | if v, ok := m[k]; ok { ... } |
| Ciclo for (stile C) | for i := 0; i < 10; i++ { ... } |
| Ciclo in stile while | for x < 100 { ... } |
| Ciclo infinito | for { ... } |
| Range su una slice | for i, v := range items { ... } |
| Switch | switch day { case 1: ...; default: ... } |
| Switch senza espressione | switch { case x > 0: ... } |
| Break / continue | break, continue |
Funzioni
Le funzioni sono valori di prima classe e possono restituire più risultati.
| Operazione | Sintassi |
|---|---|
| Funzione base | func add(a int, b int) int { return a + b } |
| Parametri con tipo condiviso | func add(a, b int) int { ... } |
| Più valori di ritorno | func divmod(a, b int) (int, int) { return a / b, a % b } |
| Valori di ritorno con nome | func split(sum int) (x, y int) { x = sum / 2; return } |
| Funzione variadica | func sum(nums ...int) int { ... } |
| Funzione anonima | f := func() { ... } |
| Closure | func counter() func() int { ... } |
| Defer (eseguito al return) | defer file.Close() |
Slice e array
Gli array hanno una dimensione fissa; le slice sono viste dinamiche sugli array.
| Operazione | Sintassi |
|---|---|
| Array a dimensione fissa | var a [3]int |
| Letterale slice | nums := []int{1, 2, 3} |
| Creare una slice con make | s := make([]int, 0, 10) |
| Aggiungere elementi | s = append(s, 4) |
| Lunghezza / capacità | len(s), cap(s) |
| Ricavare una slice da una slice | s[1:3] |
| Copiare | copy(dst, src) |
| Iterare | for i, v := range s { ... } |
Map
Le map sono le tabelle hash integrate di Go.
| Operazione | Sintassi |
|---|---|
| Creare una map con make | m := make(map[string]int) |
| Letterale map | m := map[string]int{"a": 1, "b": 2} |
| Impostare un valore | m["c"] = 3 |
| Leggere un valore | v := m["a"] |
| Verificare se esiste | v, ok := m["x"] |
| Eliminare una chiave | delete(m, "a") |
| Lunghezza | len(m) |
| Iterare | for k, v := range m { ... } |
Struct e metodi
Le struct raggruppano campi; i metodi aggiungono comportamento tramite un receiver.
| Operazione | Sintassi |
|---|---|
| Definire una struct | type Point struct { X, Y int } |
| Creare un'istanza | p := Point{X: 1, Y: 2} |
| Accedere a un campo | p.X |
| Puntatore a una struct | p := &Point{1, 2} |
| Metodo con receiver per valore | func (p Point) Dist() float64 { ... } |
| Metodo con receiver puntatore | func (p *Point) Move(dx int) { p.X += dx } |
| Struct incorporata | type Circle struct { Point; R int } |
| Tag delle struct | Name string con un tag json:"name" tra backtick |
Interfacce
Le interfacce si soddisfano implicitamente: qualsiasi tipo con i metodi giusti va bene.
| Operazione | Sintassi |
|---|---|
| Definire un'interfaccia | type Shape interface { Area() float64 } |
| Implementare (implicito) | func (c Circle) Area() float64 { ... } |
| Interfaccia vuota (any) | var x interface{} oppure var x any |
| Asserzione di tipo | s, ok := x.(string) |
| Type switch | switch v := x.(type) { case int: ... } |
| Interfaccia Stringer | func (p Point) String() string { ... } |
Goroutine e channel
Le goroutine sono thread leggeri; i channel si passano valori tra loro.
| Operazione | Sintassi |
|---|---|
| Avviare una goroutine | go doWork() |
| Creare un channel | ch := make(chan int) |
| Channel con buffer | ch := make(chan int, 5) |
| Inviare su un channel | ch <- 42 |
| Ricevere da un channel | v := <-ch |
| Chiudere un channel | close(ch) |
| Range su un channel | for v := range ch { ... } |
| Select sui channel | select { case v := <-ch: ...; default: ... } |
| Wait group | var wg sync.WaitGroup; wg.Add(1); wg.Wait() |
| Mutex | var mu sync.Mutex; mu.Lock(); mu.Unlock() |
Gestione degli errori
Go restituisce gli errori come valori: non esistono eccezioni.
| Operazione | Sintassi |
|---|---|
| Restituire un errore | func read() (string, error) { return "", err } |
| Controllare un errore | if err != nil { return err } |
| Creare un errore | errors.New("not found") |
| Errore formattato | fmt.Errorf("bad id %d", id) |
| Incapsulare un errore | fmt.Errorf("load: %w", err) |
| Estrarre / confrontare | errors.Is(err, os.ErrNotExist) |
| Confrontare per tipo | errors.As(err, &target) |
| Panic / recover | defer func() { recover() }() |
La sintassi di Go che usi di più, in una sola pagina. Questa cheat sheet di Go è un riferimento rapido per il linguaggio di base: variabili e tipi, slice e map, struct e interfacce, più le goroutine e i channel che rendono Golang così forte nella concorrenza.
Tutto quello che trovi qui è Go standard e si compila con la toolchain ufficiale. Copia quello che ti serve oppure prova ogni frammento dal vivo nel playground Go, senza installare nulla. Stai imparando Go? Il corso interattivo gratuito di Go di Coddy copre slice, struct, interfacce e goroutine passo dopo passo.
Domande frequenti sulla cheat sheet di Go
Questa cheat sheet di Go è gratuita?
Sì. Questa cheat sheet di Go è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna quando devi controllare un'operazione sulle slice, uno schema con i channel o un metodo di una struct.
Qual è la differenza tra := e var in Go?
var x = 0 dichiara una variabile e funziona ovunque, anche a livello di package. x := 0 è la dichiarazione breve di variabile: dichiara e assegna insieme, deduce il tipo e si può usare solo dentro una funzione. Usa var quando ti serve un tipo esplicito o una variabile a livello di package, e := per dichiarazioni locali concise.Cosa sono le goroutine e i channel?
Una goroutine è un thread leggero gestito dal runtime di Go: ne avvii una scrivendo
go someFunc(). I channel sono tubi tipizzati che permettono alle goroutine di comunicare in sicurezza: una goroutine invia con ch <- v e un'altra riceve con <-ch. Insieme formano il modello di concorrenza di Go, riassunto dal motto "condividi la memoria comunicando".Posso esercitarmi con Go online?
Sì. Apri il playground Go per eseguire nel browser qualsiasi frammento di questa cheat sheet, senza installare la toolchain di Go. Quando vuoi un percorso strutturato, il corso interattivo gratuito di Go di Coddy ti porta passo dopo passo da variabili e slice fino a goroutine e channel.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dagli argomenti più comuni (variabili, controllo del flusso, funzioni) fino a quelli avanzati (goroutine, channel, gestione degli errori), così puoi usare le prime sezioni fin dal primo giorno e arrivare al resto con il tempo.
Risorse correlate
Altre cheat sheet
