Guida Introduttiva a Go

Questa guida ti mostrerà come iniziare a imparare il linguaggio Go. Dal punto di vista sintattico non è difficile da imparare, potrai essere operativo in pochi giorni. Tuttavia, per convenzione, prima di iniziare ufficialmente, dobbiamo prima comprendere il suo contesto e le sue origini.

Contesto

Il linguaggio Go è stato creato da tre grandi figure:

• Ken Thompson, vincitore del Premio Turing, fondatore del sistema Unix, fondatore del linguaggio B, fondatore del linguaggio C
• Rob Pike, uno degli autori del sistema operativo Plan9, uno degli inventori di UTF-8, leader del design del linguaggio Go
• Robert Griesemer, sviluppatore del motore JS V8, il più giovane dei tre

C'è anche la moglie di Rob Pike, Renee French, che ha progettato il logo di Go, che è una marmotta blu.

Un giorno, mentre i tre ingegneri si annoiavano durante l'attesa della compilazione di un lungo progetto C++, Rob Pike ebbe improvvisamente un'idea innovativa: voleva progettare un linguaggio di programmazione semplice, compatto, a compilazione rapida e con prestazioni eccellenti, in modo da non dover più affrontare lunghe attese durante ogni compilazione. Dopo un breve brainstorming, i tre tennero una breve riunione il 20 settembre 2007 e iniziarono a discutere e progettare un prototipo preliminare di questo linguaggio. Fu proprio da questo momento che nacque ufficialmente il linguaggio Go. Successivamente, questo piccolo team ha attratto sempre più sviluppatori con la stessa visione, e infine il 10 novembre 2009, Google ha ufficialmente open-sourced il linguaggio Go con la licenza BSD-3-Clause, ha lanciato la prima versione preliminare e ha formato un team di sviluppo ufficiale.

Suggerimento

Vale la pena notare che potresti vedere da qualche parte qualcuno chiamarlo Golang, incluso il nome del repository Github di questo sito che si chiama Golang-Doc, ma il suo nome ufficiale è sempre stato Go. All'inizio, poiché il dominio go era già stato registrato, il dominio del sito ufficiale ha adottato golang.org, il che ha portato i nuovi arrivati a pensare erroneamente che si chiamasse Golang.

Successivamente, il team Go ha trascorso tre anni di progettazione e sviluppo e ha pubblicato la prima versione ufficiale Go 1.0 nel marzo 2012 (a quel tempo la toolchain e il runtime di Go erano ancora scritti in linguaggio C, fino a Go 1.5 che ha completato il bootstrap). Da allora, sono stati pubblicati due aggiornamenti minori ogni anno, e il progetto è stato mantenuto e gestito fino ad oggi.

I tre fondatori si sono effettivamente ritirati molto tempo fa. Per la maggior parte del tempo, il leader del team è stato Russ Cox, che ha partecipato allo sviluppo già prima che il linguaggio Go fosse pubblicato esternamente, e ha gestito il team Go per 12 anni, fino alle sue dimissioni nell'agosto 2024, quando Austin Clements ha preso il comando e ha guidato il lavoro di sviluppo successivo.

Se vuoi approfondire la storia del linguaggio Go, visita Go History per saperne di più.

Caratteristiche

• Sintassi semplice Il linguaggio Go ha fatto compromessi tra libertà e flessibilità, ottenendo in cambio una migliore manutenibilità e una curva di apprendimento più graduale.
• Distribuzione amichevole I file binari compilati staticamente di Go non dipendono da ambienti di runtime aggiuntivi e la velocità di compilazione è molto rapida.
• Compilazione incrociata Go richiede solo di impostare due parametri durante la compilazione per compilare programmi eseguibili su altre piattaforme.
• Concorrenza nativa Il supporto di Go per la concorrenza è nativo, basta una parola chiave per avviare una goroutine asincrona.
• Garbage Collection Go ha eccellenti prestazioni GC, nella maggior parte dei casi la latenza GC non supera 1 millisecondo.
• Libreria standard ricca Dall'elaborazione di stringhe all'analisi AST del codice sorgente, una libreria standard potente e ricca è la solida base del linguaggio Go.
• Toolchain completa Go ha una toolchain di sviluppo completa che copre compilazione, testing, gestione delle dipendenze, analisi delle prestazioni e molto altro.

Il linguaggio Go ha abbandonato l'ereditarietà, ha indebolito l'OOP, le classi, la metaprogrammazione, i generics, le espressioni Lambda e altre caratteristiche, offrendo buone prestazioni e una bassa difficoltà di apprendimento. È adatto per lo sviluppo di servizi cloud, lo sviluppo di server di applicazioni e la programmazione di rete. Include GC integrato, quindi gli sviluppatori non devono gestire manualmente la memoria, e la compilazione statica e la compilazione incrociata sono molto amichevoli anche per gli operatori DevOps.

Il linguaggio Go ha anche molti svantaggi, come la gestione degli errori criticata, i generics incompleti, una libreria standard ricca ma con poche strutture dati integrate, il tipo interface{} ovunque, nessun tipo di enumerazione, e inoltre il team di sviluppo di Go è molto testardo e non è bravo ad ascoltare i suggerimenti della comunità, ecc. (Al contrario, Rust fa molto meglio in termini di gestione degli errori, generics, gestione delle dipendenze, enumerazioni, interfacce, ecc.)

In generale, dobbiamo vedere un linguaggio in modo dialettico. Come linguaggio ingegnerizzato, Go può migliorare notevolmente il livello minimo di un team, anche se gli sviluppatori hanno competenze scarse, raramente si verifica il caso in cui una mela marcia rovina tutto il cesto. Allo stesso tempo, grazie alla sintassi semplice e alla bassa difficoltà di apprendimento, le persone possono iniziare rapidamente un progetto. Sebbene Go esista da poco più di dieci anni, un numero considerevole di aziende ha scelto Go come linguaggio principale, il che indica anche che Go sta gradualmente diventando più popolare.

A proposito, Go è anche un linguaggio completamente open source, mantenuto dalla comunità e da Google. L'indirizzo ufficiale è nel repository di Google, e c'è un repository mirror identico su Github. Se sei interessato, puoi anche partecipare al design del linguaggio.

Sito ufficiale: The Go Programming Language

Repository open source di Google: google/go: Google Open Source

Repository Github: golang/go: The Go programming language

TIP

L'autore ha inviato PR a Go, se vuoi sapere come contribuire al codice Go, puoi leggere questo articolo che ho scritto: Come contribuire al codice Go.

Credo che molti abbiano sentito più o meno parlare di Rust, che è un linguaggio di programmazione per scopi generali ad alte prestazioni. La sua nascita è avvenuta un anno prima di Go, Go 1 è stato ufficialmente pubblicato nel 2012, mentre la versione ufficiale di Rust è stata pubblicata nel 2015. Entrambi sono linguaggi moderni, e all'autore piacciono molto entrambi. Si sviluppano in aree diverse, se non sei soddisfatto dell'efficienza di esecuzione e della capacità espressiva di Go, puoi provare Rust, ma la sua difficoltà di apprendimento è ben lontana dalla semplicità di Go.

Installazione

Download di Go: Downloads - The Go Programming Language

Stable Version si riferisce alle due versioni stabili attualmente in manutenzione, Archived Version si riferisce alle versioni storiche non più mantenute. Visita Note di rilascio per saperne di più sulle regole di manutenzione e sulle informazioni sulle versioni storiche.

Windows

Per la piattaforma Windows, ci sono due tipi disponibili: installer e archive. Il primo è un pacchetto di installazione, basta fare clic e fare clic, si consiglia di utilizzare il secondo, che ti farà familiarizzare con la struttura delle directory del linguaggio Go, e in caso di problemi futuri non sarai colto alla sprovvista. Scegli di scaricare il file zip, che contiene il codice sorgente del linguaggio Go, la toolchain e alcuni documenti, estrailo in un percorso specificato, quindi devi configurare due variabili di ambiente di sistema.

• GOROOT - Percorso di installazione del linguaggio Go
• GOPATH - Percorso di archiviazione delle dipendenze del linguaggio Go

Dopo averli impostati, aggiungi due nuove voci alla variabile di ambiente di sistema PATH

• %GOROOT%\bin: Questo è l'indirizzo del programma binario di Go
• %GOPATH%\bin: Questo è l'indirizzo di archiviazione dei file binari delle dipendenze di terze parti che verranno scaricati in futuro

Esegui il comando go version in powershell, se viene visualizzata correttamente la versione, significa che l'installazione è corretta.

PS C:\user\username> go version
go version go1.21.3 windows/amd64

Per aggiornare, basta scaricare un nuovo zip e sovrascrivere la directory di installazione originale.

Linux

Prendendo Ubuntu come esempio, copia il link della versione desiderata e scaricalo localmente

$ wget https://golang.google.cn/dl/go1.21.1.linux-amd64.tar.gz

Estrai nella directory specificata

$ tar -C ~/go -xzf go1.21.1.linux-amd64.tar.gz

Imposta le variabili di ambiente nel file $HOME/.bashrc

export GOROOT=$HOME/go
export GOPATH=$HOME/gopath
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

Dopo aver completato, controlla la versione installata per confermare l'installazione corretta

$ go version
go version go1.21.1 linux/amd64

Per aggiornare, basta scaricare un nuovo tar.gz e sovrascrivere la directory di installazione originale.

Gestione dell'installazione

Il metodo di installazione sopra descritto è sufficiente per l'uso di base. Personalmente consiglio di utilizzare la seguente struttura di directory per archiviare il linguaggio Go e i suoi file derivati

go/
|
|--root/
|  |
|  |--go1.21.3/
|  |
|  |--go1.20.10/
|
|--mod/
|  |
|  |--bin/
|  |
|  |--libs/
|
|--cache/
|
|--temp/
|
|--env

Spiegazione:

• La directory go/root viene utilizzata per archiviare i file sorgente delle varie versioni del linguaggio Go
• go/mod corrisponde a GOPATH
• go/mod/libs corrisponde a GOMODCACHE, ovvero l'indirizzo di archiviazione delle dipendenze di terze parti scaricate
• go/mod/bin corrisponde a GOBIN, l'indirizzo di archiviazione dei file binari delle dipendenze di terze parti
• go/cache corrisponde a GOCACHE, per archiviare i file di cache
• go/temp corrisponde a GOTMPDIR, per archiviare i file temporanei
• go/env corrisponde a GOENV, il file di configurazione delle variabili di ambiente globali

Con questo metodo, durante l'aggiornamento non è necessario sovrascrivere la directory di installazione originale, basta archiviarla nella directory go/root, quindi modificare la variabile di ambiente di sistema GOROOT nella cartella della versione specificata in quella directory. Per impostazione predefinita, il file env viene letto dal percorso GOROOT/env, impostando la variabile di sistema GOENV per separarla da GOROOT, evitando le modifiche alla configurazione delle variabili di ambiente di Go quando cambia la versione. Di seguito sono riportate le impostazioni iniziali del file env.

GO111MODULE=on
GOCACHE=go/cache
GOMODCACHE=go/mod/libs
GOBIN=go/mod/bin
GOTMPDIR=go/temp

Questo è solo uno stile di directory che preferisco personalmente, visita Comandi - Variabili di ambiente per saperne di più sulle variabili di ambiente, puoi personalizzare completamente in base alle tue preferenze.

Gestione di più versioni

Ho scritto uno strumento di gestione di più versioni govm, che funziona meglio con la struttura di directory sopra descritta. Può gestire più versioni di Go locali, puoi cambiare versione in qualsiasi momento, cercare e scaricare altre versioni di Go e installarle localmente.

$ govm search 1.22 -n 10
go1.22.6           76 MB
go1.22.5           76 MB
go1.22.4           76 MB
go1.22.3           76 MB
go1.22.2           76 MB
go1.22.1           76 MB
go1.22.0           76 MB

$ govm install 1.22.4
Fetch go1.22.4 from https://dl.google.com/go/go1.22.4.windows-amd64.zip
Downloading go1.22.4.windows-amd64.zip 100% |████████████████████████████████████████| (76/76 MB, 32 MB/s) [2s]
Extract go1.22.4.windows-amd64.zip to local store
Remove archive from cache
Version go1.22.4 installed

$ govm use 1.22.4
Use go1.22.4 now

# Riaccedi alla shell
$ go version
go version go1.22.4 windows/amd64

Se vuoi sapere come scrivere strumenti da riga di comando con Go, non disdegnare di usare govm come riferimento per il progetto, è anche scritto in Go.

Editor

Per quanto riguarda gli IDE principali per il linguaggio Go, al momento consiglio solo i seguenti due:

1. GoLand: prodotto da JetBrains, potente, supporto completo, ma a pagamento, puoi considerare la versione community di IDEA con plugin
2. VS Code: gratuito, editor universale, con plugin può scrivere in qualsiasi linguaggio

Se ci sono altri editor più adatti alle tue abitudini di utilizzo, puoi usarli, non importa quale editor usi. Se stai solo scrivendo brevi esercizi di codice, puoi provare goplay fornito ufficialmente, che può eseguire codice Go online.

TIP

Se stai utilizzando JetBrains Toolbox, puoi provare uno strumento da riga di comando che ho scritto AutoToolBox, che può generare un menu contestuale di Windows per Toolbox, come mostrato nell'immagine seguente.

Messaggi

La difficoltà complessiva del linguaggio Go non è elevata, se hai una base in altri linguaggi, imparare sarà molto semplice. Durante l'apprendimento, se incontri punti difficili da comprendere, puoi saltarli per ora. Imparare qualsiasi linguaggio significa prima comprendere approssimativamente la sintassi e la struttura generale del linguaggio, quindi approfondire alcune caratteristiche e dettagli. Anche la filosofia di questa documentazione è la stessa, adatta per l'apprendimento introduttivo. L'autore è solo uno studente ordinario, inevitabilmente ci saranno omissioni ed errori, se trovi errori puoi inviare una PR su Github, se pensi che la documentazione sia buona puoi mettere una Star su Github.

Se sei uno sviluppatore di linguaggi OOP forti, come Java, C#, ecc., non entrare con il pensiero OOP come preconcetto, altrimenti troverai molti design di Go incomprensibili e sarà molto difficile scrivere codice. Anche l'autore era così all'inizio.

Panoramica

Di seguito viene presentata una semplice introduzione al contenuto di questo sito, in modo che tu possa leggere in base alle tue esigenze. Alcune pagine vuote indicano che non sono ancora state aggiornate.

• Introduzione al linguaggio: Spiega principalmente il contenuto relativo al linguaggio Go stesso, più teorico.
  • Sintassi di base: Spiega principalmente alcune sintassi di base, come le regole sintattiche di if, for, ecc.
  • Sintassi avanzata: Spiega alcune cose uniche di Go, riguardanti moduli, test, goroutine e altri contenuti correlati.
  • Libreria standard: Una semplice introduzione alla libreria standard integrata di Go, poiché il contenuto della libreria standard è davvero troppo vasto, viene aggiornata occasionalmente.
  • Principi di implementazione: Spiega principalmente alcuni principi di design interni del linguaggio Go, come la pianificazione delle goroutine, la gestione della memoria, il garbage collection, ecc.
• Ecosistema della comunità: Spiega principalmente l'ecosistema circostante Go, più applicativo.
  • Database: Operazioni sui database principali tramite Go.
  • Microservizi: Introduce alcuni strumenti di microservizi correlati a Go.
  • Librerie di terze parti: Introduce alcune librerie di terze parti scritte in Go, aggiornate occasionalmente, oppure puoi visualizzare direttamente in Navigazione delle dipendenze.

Vai a Preparati per iniziare per iniziare l'apprendimento introduttivo