Go (noto anche come Golang) è un linguaggio di programmazione open-source, tipizzato staticamente. È stato originariamente sviluppato da Google. Alcune caratteristiche degne di nota di Go includono semplicità, alte prestazioni, leggibilità ed efficienza.
Come qualsiasi altro linguaggio di programmazione di rilievo, la libreria standard di Go offre un ricco set di pacchetti. Tuttavia, possiamo anche estendere le funzionalità incorporando pacchetti di terze parti. Questa guida mostrerà come importare i pacchetti e incorporarli nei tuoi progetti Go.
Prerequisiti
Per seguire questa guida, avrai bisogno dei seguenti componenti pronti a tua disposizione:
- Un server Ubuntu configurato correttamente. Scopri di più su come configurare il tuo server Ubuntu su CloudSigma.
- L'ambiente di programmazione Go. Puoi usare questa guida su come installare Go su Ubuntu.
- Un editor di testo moderno, ad esempio, Vim, Sublime Text, Atom, Visual Studio Code, Brackets, ecc. Questa guida utilizzerà Visual Studio Code .
Passo 1 – Installazione di Go
Abbiamo già discusso dell'installazione del nucleo del linguaggio di programmazione Go su Ubuntu 20.04. Tuttavia, c’è un metodo alternativo più semplice: g (un gestore di versioni Go leggero).
Il motivo per cui useremo g è che nessuna delle versioni di Go disponibili nei repository dei pacchetti di Ubuntu o tramite snap presenta l'ultima versione di Go disponibile (v1.18 al momento della stesura di questa guida). Si raccomanda sempre di utilizzare l'ultima versione disponibile di qualsiasi pacchetto di linguaggio di programmazione.
Il seguente comando eseguirà lo script di installazione di g :
|
1 |
wget -qO- https://git.io/g-install | sh -s |
Affinché le modifiche abbiano effetto, devi riavviare la sessione della shell. Dopo il riavvio, verifica l'installazione:
|
1 |
go version |
|
1 |
which go |
Dopo aver installato Go, si raccomanda anche di installare gopls . È il server di linguaggio ufficiale di Go. È compatibile con molti editor di testo come VS Code, Vim, Emacs, Sublime Text, Atom e molti altri. Esegui il seguente comando:
|
1 |
go install golang.org/x/tools/gopls@latest |
Il nostro ambiente di programmazione Go è ora pronto.
Passo 2 – Creazione di uno script Go di esempio
Tutti i codici mostrati in questa guida entreranno in un singolo script Go. Crea uno script Go di esempio:
|
1 |
touch practice.go |
Dopo aver apportato modifiche allo script, possiamo eseguirlo utilizzando il seguente comando Go:
|
1 |
go run practice.go |
Qui, il compilatore Go eseguirà il codice in modalità interprete.
Passo 3 – Utilizzo dei pacchetti della libreria standard
Go viene fornito con una vasta collezione nella sua libreria standard. Consiste in numerosi pacchetti, ad esempio:
- fmt: Implementa l'I/O formattato con funzioni analoghe al C ( printf e scanf ).
- http: Questo pacchetto fornisce funzioni per la creazione di servizi web, l'invio e il recupero di dati tramite il protocollo http , ecc.
Per incorporare qualsiasi pacchetto in un progetto Go, deve essere implementato utilizzando l'istruzione import . L'istruzione è dichiarata dalla parola chiave import insieme ai nomi dei pacchetti. Ad esempio, per importare math/rand , l'istruzione import sarebbe simile a questa:
|
1 |
import "math/rand" |
Il seguente codice implementa varie funzioni dal pacchetto math/rand :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main import "math/rand" func main() { for i := 0; i < 10; i++ { println(rand.Intn(25)) } } |
Questo codice mostra un semplice ciclo for che stampa sullo schermo 10 numeri interi casuali (da 0 a 24). Qui:
- rand.Int() : questa chiamata di funzione restituisce un numero intero casuale.
- rand.Intn() : si comporta in modo simile a rand.Int() ma accetta un parametro che definisce l'intervallo per i numeri interi casuali (da 0 al numero specificato).
Successivamente, esegui il codice:
|
1 |
go run practice.go |
L'output sarà simile a questo:
Nota che l'output sarà esattamente lo stesso poiché il seed per il generatore di numeri casuali è un valore fisso per impostazione predefinita. Questa è la natura di un generatore di numeri pseudocasuali. Puoi saperne di più su random seed qui.
Step 4 – Importare pacchetti multipli
I progetti più grandi e complessi devono incorporare più pacchetti. Come si importano nel codice Go? Un'opzione valida è utilizzare singole istruzioni di importazione per ciascun pacchetto importato. Tuttavia, questo approccio è inefficiente rispetto alla seguente struttura di importazione:
|
1 2 3 4 5 6 7 8 9 |
import ( "<package_1>" "<package_2>" "<package_3>" ) |
Qui, una singola istruzione di importazione incorpora più pacchetti contemporaneamente. Ciò riduce la quantità di codice da scrivere migliorando al contempo la leggibilità.
Il seguente codice mette in azione questa funzionalità:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Esegui il codice:
|
1 |
go run practice.go |
L'output sarà simile a questo:
Step 5 – Installare librerie Go aggiuntive
La libreria standard di Go include numerosi pacchetti utili. Questi sono, per progettazione, di uso generale. Consente agli sviluppatori di creare i propri pacchetti sopra la libreria standard per soddisfare le loro esigenze specifiche. Dai un'occhiata al database dei pacchetti Go ufficiale.
E se avessi bisogno di implementare un pacchetto Go di terze parti? Go viene fornito con il comando go install ( go get è deprecato). Può recuperare qualsiasi pacchetto Go di terze parti da Internet.
A scopo dimostrativo, installeremo il pacchetto cobra-cli . Il seguente comando Go scaricherà e installerà i file necessari e integrerà il pacchetto nel sistema di librerie di Go:
|
1 |
go install github.com/spf13/cobra-cli@latest |
Il binario di cobra-cli dovrebbe trovarsi nella seguente posizione:
|
1 |
ls -l $GOPATH/bin |
Gli altri file del pacchetto dovrebbero trovarsi nella seguente posizione:
|
1 |
ls -l $GOPATH/pkg/mod/github.com/spf13 |
A partire da Go v1.11, i moduli Go definiscono la versione del pacchetto che si desidera importare. Questo è spiegato in dettaglio qui: GitHub dei moduli Go.
Step 6 – Alias dei pacchetti
In varie situazioni, potresti riscontrare nomi di pacchetti in conflitto tra i pacchetti locali e quelli importati. È qui che l'aliasing può risolvere la collisione. La struttura dell'aliasing si presenta in questo modo:
|
1 |
import <alias> "import_package_name" |
Modifichiamo il nostro semplice programma Go per incorporare fmt_alias come alias per il pacchetto fmt :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
package main import ( fmt_alias "fmt" "math/rand" ) func main() { for i := 0; i < 10; i++ { fmt_alias.Printf("%d) %d\n", i, rand.Intn(25)) } } |
Nota che invece di usare fmt.Printf() , stiamo usando l'alias del pacchetto fmt_alias.Printf() .
Tuttavia, Go non è molto favorevole agli alias. Quando si utilizzano gli alias per evitare collisioni di nomi di importazione, si consiglia di creare l'alias per l'importazione più locale o specifica del progetto. Ad esempio, se si desidera avere sia un pacchetto locale strings sia un pacchetto di sistema strings , allora dovresti creare l'alias per il pacchetto locale, non per quello di sistema.
La migliore pratica consiste nell'evitare del tutto le collisioni di nomi.
Step 7 – Formattazione delle importazioni
Abbiamo imparato a dichiarare tutte le importazioni utilizzando una singola istruzione import . E se avessi diverse importazioni? Ad esempio:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import ( "fmt" "os" "github.com/example/foo" "github.com/example/bar" "math/rand" "github.com/abc/pqr/xyz" ) |
La formattazione delle importazioni ordina i pacchetti in un ordine specifico, migliorando la coerenza del codice. Poiché ordina solo l'ordine delle importazioni, previene anche commit casuali. Inoltre, evita inutili rimescolamenti di codice e revisioni del codice confuse.
La maggior parte degli editor moderni formatterà le importazioni automaticamente. In alternativa, supporteranno goimports. È una pratica comune nel settore utilizzare goimports invece di ordinare manualmente le importazioni. Inoltre, goimports riflette anche le modifiche di stile nel codice.
Ecco come il blocco import potrebbe apparire dopo aver applicato goimports :
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
import ( fmt_alias "fmt" "math/rand" "os" "github.com/example/foo" "github.com/example/bar" "github.com/abc/pqr/xyz" ) |
Noti qualche pattern?
- Tutte le librerie standard sono raggruppate per prime.
- I gruppi sono separati da righe vuote, migliorando la leggibilità del codice.
Considerazioni finali
Le importazioni in Go sono una potente funzionalità che consente di chiamare funzioni non integrate in Go. Sebbene la libreria standard offra molti pacchetti di uso generale, Go supporta anche pacchetti di terze parti. Questa guida mostra come importare pacchetti Go integrati e di terze parti.
In questa guida abbiamo eseguito i nostri programmi Go utilizzando l'interprete. Tuttavia, è possibile compilare il codice in binari autonomi per ottenere prestazioni migliori. Puoi saperne di più su come compilare i programmi Go qui. Se vuoi imparare come distribuire un'applicazione web Go con Nginx, consulta questo tutorial. Inoltre, puoi dare un'occhiata alla nostra guida che mostra come scrivere i tuoi pacchetti Go.
Sei uno sviluppatore Go? CloudSigma offre supporto per l'API Go per un'integrazione perfetta con i tuoi progetti.
Buona programmazione!
Commenti
Ancora nessun commento. Scrivi il primo.