Introduzione al linguaggio Go
Go, noto anche come Golang, è un linguaggio di programmazione open-source sviluppato dagli ingegneri di Google Robert Griesemer, Rob Pike e Ken Thompson. È stato progettato per essere semplice, efficiente e affidabile. Go è ideale per lo sviluppo di applicazioni moderne, in particolare nel campo dei sistemi infrastrutturali lato server e backend. Grazie alla sua sintassi semplice, al supporto integrato per la concorrenza e alle eccellenti prestazioni, Go è diventato una scelta popolare tra gli sviluppatori per la realizzazione di applicazioni web, microservizi e sistemi distribuiti.
L'ecosistema di Go è cresciuto rapidamente dal suo rilascio nel 2009, offrendo una vasta gamma di librerie e strumenti che gli sviluppatori possono sfruttare. Aziende come Dropbox, Uber e Docker hanno scelto Go per i loro sistemi backend sottostanti, evidenziando ulteriormente la sua importanza e rilevanza nell'ambiente tecnologico odierno.
Questo articolo si propone di fornire una solida base di Go e della sua sintassi, concentrandosi sulle caratteristiche principali del linguaggio per iniziare il vostro viaggio nella programmazione Go.
Installazione e configurazione di Go
Prima di iniziare a lavorare con Go, è necessario installare il linguaggio sul computer. Seguite questi passaggi per iniziare:
- Visitate il sito ufficiale di Go e scaricate il file di installazione appropriato per il vostro sistema operativo.
- Aprire il file scaricato e seguire le istruzioni di installazione fornite dal programma di installazione.
- Impostare la variabile d'ambiente
PATHin modo da includere la directory di installazione di Go. In questo modo i comandi di Go saranno disponibili dalla riga di comando. Sui sistemi Unix, è possibile aggiungere la seguente riga al file.bashrco.profile:export PATH=$PATH:/usr/local/go/bin - Riavviare il terminale o il prompt dei comandi per applicare le modifiche.
- Confermate che Go è stato installato correttamente eseguendo il seguente comando nel vostro terminale:
go version
Se l'installazione è andata a buon fine, nell'output verrà visualizzata la versione di Go installata sul computer.
Ora che Go è installato sul computer, è il momento di immergersi nelle nozioni di base del linguaggio.
Comprendere la sintassi e i tipi di dati di Go
La sintassi di Go è stata progettata per essere semplice e di facile lettura. In questa sede verranno illustrati alcuni elementi essenziali del linguaggio, tra cui i pacchetti, le importazioni, le variabili e i tipi di dati di base.
Pacchetti e importazioni
I programmi Go sono organizzati in pacchetti, che aiutano a modularizzare e gestire il codice. Un pacchetto è essenzialmente una directory contenente uno o più file sorgente Go. La prima riga di ogni file Go deve dichiarare il pacchetto a cui appartiene:
pacchetto mainNell'esempio precedente, il file sorgente appartiene al pacchetto "main". Il blocco di codice che segue la dichiarazione del pacchetto consiste tipicamente in dichiarazioni di importazione che includono altri pacchetti necessari al programma:
import ( "fmt" "math" )La dichiarazione di importazione specifica i pacchetti da importare nel file corrente, consentendo di accedere alle loro caratteristiche esportate, come le funzioni e le variabili.
Variabili e costanti
Le variabili in Go possono essere dichiarate utilizzando la parola chiave var, seguita dal nome della variabile, dal tipo e dal valore iniziale opzionale:
var x int = 10Se viene fornito il valore iniziale, Go può dedurre il tipo, consentendo di omettere la dichiarazione del tipo:
var x = 10 // x è un intÈ anche possibile utilizzare la sintassi di Go per la dichiarazione di una variabile breve, che infonde automaticamente il tipo e assegna un valore iniziale:
x := 10 // x è un intLe costanti possono essere dichiarate utilizzando la parola chiave const. I loro valori devono essere noti al momento della compilazione e non possono essere modificati durante l'esecuzione del programma:
const PI = 3,14159Tipi di dati fondamentali
Go dispone di diversi tipi di dati fondamentali, tra cui:
- Interi: Gli interi firmati possono essere dichiarati con
int,int8,int16,int32oint64. I numeri interi senza segno possono essere definiti conuint,uint8,uint16,uint32ouint64. - Numeri in virgola mobile: Possono essere definiti con
float32ofloat64. - Numeri complessi: I numeri complessi sono dichiarati con
complex64ocomplex128. - Booleani: I booleani sono rappresentati dal tipo di dati
boole possono avere il valoretrueofalse. - Stringhe: Le stringhe di Go sono sequenze di caratteri codificati in UTF-8. Sono immutabili e la loro lunghezza è limitata. Sono immutabili e la loro lunghezza viene determinata in fase di esecuzione.
Inoltre, Go supporta tipi di dati compositi, quali:
- Array: Sequenze di elementi dello stesso tipo a lunghezza fissa.
- Fette: Sequenze di lunghezza dinamica di elementi dello stesso tipo.
- Mappe: Raccolte non ordinate di coppie chiave-valore, dove le chiavi e i valori possono avere qualsiasi tipo specificato.
Man mano che si continua a imparare Go, si potranno combinare questi tipi di dati e strutture di base per costruire applicazioni più complesse e versatili.
Funzioni e metodi in Go
Le funzioni sono uno degli elementi essenziali di qualsiasi linguaggio di programmazione e Go non fa eccezione. Le funzioni in Go sono definite con la parola chiave func, seguita dal nome della funzione, dai parametri di ingresso, dal tipo di ritorno e dal corpo della funzione. Le funzioni in Go possono restituire più valori, rendendo più facile la gestione di operazioni complesse e il controllo degli errori.
Ecco un esempio di una semplice funzione Go:
package main import ( "fmt" ) func add(a int, b int) int { return a + b } func main() { result1 := add(5, 7) fmt.Println("La somma è:", result1) }In questo esempio, definiamo una semplice funzione add che prende due parametri interi e restituisce la loro somma. La funzione viene quindi richiamata dalla funzione principale e il risultato viene stampato.
Metodi in Go
I metodi in Go sono simili alle funzioni, ma sono associati a un tipo di ricevitore specifico e vengono richiamati su un'istanza del tipo di ricevitore. Ciò consente di aggiungere comportamenti ai tipi esistenti, in modo simile a come i linguaggi di programmazione orientati agli oggetti definiscono i metodi sulle classi. Ecco un esempio:
package main import ( "fmt" ) type Circle struct { radius float64 } func (c Circle) area() float64 { return 3.14159 * c.radius * c.radius } func main() { myCircle := Circle{radius: 5} circleArea := myCircle.area() fmt.Printf("The area of the circle is: %.2f\n", circleArea) }In questo esempio, definiamo una struttura Circle con un campo radius. Per il tipo Circle viene quindi definito un metodo denominato area. Questo metodo calcola l'area del cerchio utilizzando il raggio e restituisce il risultato come valore float64.
Strutture di controllo in Go
Le strutture di controllo sono alla base di qualsiasi linguaggio di programmazione, in quanto dettano il flusso del programma. Go offre diverse strutture di controllo per la ramificazione condizionale, il looping e i controlli di condizioni multiple o le operazioni di comunicazione.
Dichiarazioni If
In Go, la ramificazione condizionale viene tipicamente eseguita utilizzando gli enunciati if. Queste istruzioni valutano un'espressione booleana e, se vera, eseguono il blocco di codice che segue l'espressione. Ecco un esempio:
package main import ( "fmt" ) func main() { numero := 42 if numero%2 == 0 { fmt.Println("Il numero è pari.") } else { fmt.Println("Il numero è dispari.") } } }In questo esempio, si verifica se un numero è pari o dispari utilizzando l'operatore modulo e un'istruzione if.
Per i cicli
Go ha un solo tipo di ciclo: il ciclo for. Può essere utilizzato per tutti i tipi di loop: iterazioni fisse, loop infiniti e loop "while". Ecco un esempio:
package main import ("fmt" ) func main() { for i := 1; i <= 5; i++ { fmt.Println("Iterazione:", i) } }In questo esempio, si utilizza un ciclo for con un contatore per iterare cinque volte e stampare il numero di iterazione corrente.
Dichiarazioni switch e select
Go fornisce l'istruzione switch per i controlli di condizioni multiple e l'istruzione select per le operazioni di comunicazione. Ecco un esempio di istruzione switch:
package main import ("fmt" ) func main() { voto := "B" switch voto { caso "A": fmt.Println("Eccellente!") caso "B": fmt.Println("Buono") caso "C": fmt.Println("Discreto") caso "D": fmt.Println("Scarso") default: fmt.Println("Voto non valido") } }In questo esempio, utilizziamo un'istruzione switch per controllare il voto in ingresso e stampare il corrispondente commento sulle prestazioni. A differenza di altri linguaggi, Go non richiede un'istruzione break alla fine di ogni blocco case, poiché esce dall'istruzione switch dopo aver eseguito un caso corrispondente.
Concorrenza in Go
Una delle caratteristiche più potenti di Go è il supporto incorporato per la concorrenza tramite goroutine e canali. La concorrenza consente l'esecuzione simultanea di più thread, permettendo di ottenere maggiori prestazioni e reattività nelle applicazioni.
Goroutine
Le goroutine sono esecuzioni di funzioni concomitanti leggere in Go. Per creare una goroutine, è sufficiente aggiungere la parola chiave go a una chiamata di funzione. La funzione inizia a essere eseguita in contemporanea con il resto del programma, condividendo lo stesso spazio degli indirizzi. Ecco un esempio:
package main import ( "fmt" "time" ) func display(message string) { for i := 0; i < 5; i++ { fmt.Println(message) time.Sleep(1 * time.Second) } } func main() { go display("Hello") go display("World") // Lasciamo che le Goroutine finiscano prima di uscire time.Sleep(5 * time.Second) }In questo esempio, creiamo due goroutine che visualizzano messaggi e si fermano per un secondo prima di ripetersi. La funzione principale attende cinque secondi per assicurarsi che le goroutine finiscano prima di uscire dal programma.
Canali
I canali sono il mezzo di comunicazione tra le goroutine. Permettono alle goroutine di inviare e ricevere valori in modo thread-safe. Ecco un esempio:
package main import ( "fmt" ) func producer(numbers chan<- int) { for i := 1; i <= 5; i++ { fmt.Println("Prodotto:", i) numbers <- i } close(numbers) // Chiudere il canale al termine } func consumer(numbers <-chan int) { for number := range numbers { fmt.Println("Consumato:", numero) } } func main() { numbers := make(chan int) go producer(numbers) go consumer(numbers) // Lasciamo che le goroutine finiscano time.Sleep(1 * time.Second) }In questo esempio, creiamo una Goroutine produttore che genera numeri e li invia a un canale e una Goroutine consumatore che elabora i numeri ricevuti dal canale. L'uso dei canali garantisce una comunicazione sicura tra le goroutine.
La concorrenza in Go, utilizzando le goroutine e i canali, semplifica lo sviluppo di applicazioni concorrenti, rendendole più efficienti, affidabili e facili da capire.
Migliori pratiche per la scrittura di codice Go
Scrivere codice Go pulito, manutenibile ed efficiente è essenziale per sviluppare applicazioni potenti e garantire il successo a lungo termine. Ecco alcune buone pratiche da seguire quando si lavora con Go:
Convenzioni di denominazione corrette
Le convenzioni di denominazione svolgono un ruolo cruciale nel rendere il codice Go comprensibile e manutenibile. Seguite queste linee guida per la denominazione in Go:
- Inomi dei pacchetti devono essere minuscoli, brevi e concisi. Evitare l'uso di trattini bassi o di nomi con lettere miste.
- Inomi di variabili, funzioni e metodi devono essere in camelCase, con la prima lettera di ogni parola in maiuscolo, tranne la prima parola.
- Gliidentificatori esportati, come le funzioni, i metodi e le variabili accessibili da altri pacchetti, devono iniziare con la lettera maiuscola.
- Gli identificatorinon esportati, che sono limitati al pacchetto in cui sono definiti, devono iniziare con una lettera minuscola.
Formattazione corretta
Il rispetto di un formato coerente nel codice Go ne facilita la lettura e la comprensione. La comunità di Go ha sviluppato uno strumento chiamato gofmt che formatta automaticamente il codice secondo le linee guida raccomandate. Utilizzate questo strumento per assicurarvi che il vostro codice aderisca a uno stile coerente.
Scrivere funzioni brevi e focalizzate
Assicuratevi che le funzioni e i metodi siano brevi e focalizzati su un unico scopo. Questo migliora la leggibilità, la manutenibilità e semplifica i test. Invece di scrivere una singola funzione con molte responsabilità diverse, suddividetela in funzioni più piccole e specifiche. Questo approccio aiuta anche a riutilizzare il codice in diverse parti dell'applicazione.
Gestione rigorosa degli errori
La gestione degli errori è un aspetto fondamentale della programmazione Go. Go incoraggia a gestire gli errori in modo esplicito, invece di affidarsi alle eccezioni. Quando una funzione restituisce un errore, bisogna sempre controllarlo e gestirlo in modo appropriato. Utilizzate lo schema idiomatico if err != nil per garantire che il vostro programma si comporti correttamente in presenza di errori. Inoltre, fornite un contesto nei messaggi di errore per aiutare voi e gli altri sviluppatori a identificare e diagnosticare più facilmente i problemi.
Scrivere test unitari completi
La scrittura di test unitari è essenziale per garantire la correttezza e l'affidabilità del codice Go. Go ha un supporto integrato per i test attraverso il suo pacchetto di test. Scrivete i test per le singole funzioni, i metodi e i pacchetti per convalidare il loro comportamento e individuare potenziali problemi durante le modifiche al codice. Investite tempo nella scrittura di test manutenibili e approfonditi per prevenire i bug e aumentare la fiducia nel vostro codice.
Usare con saggezza i pacchetti e le librerie di Go
Go ha un forte ecosistema con molte librerie e pacchetti, sia nella libreria standard che nella comunità più ampia. Sebbene l'uso delle librerie possa far risparmiare tempo, bisogna essere cauti nella scelta delle dipendenze esterne. Scegliete sempre librerie affidabili e ben documentate e valutate più opzioni prima di prendere una decisione. Inoltre, mantenete l'elenco delle dipendenze gestibile e monitorate i potenziali problemi di sicurezza e di prestazioni.
Documentare il codice
Scrivete commenti chiari e concisi e documentate il codice usando le convenzioni di Go. Documentare il codice con commenti, spiegazioni ed esempi adeguati è fondamentale per la manutenibilità a lungo termine e il lavoro di squadra.
Casi d'uso e librerie popolari per Go
Go è un linguaggio di programmazione versatile con numerosi casi d'uso. Alcune delle aree di applicazione più popolari per Go includono:
- Programmazione lato server e servizi web
- Reti e sistemi distribuiti
- Architettura a microservizi
- StrumentiDevOps e CLI
Ecco un elenco di alcune librerie e framework popolari nell'ecosistema Go che soddisfano le esigenze di sviluppo più comuni:
Framework e librerie web
- Gin: Un framework web veloce, semplice e leggero con un'API di tipo martiniano.
- Echo: Un framework web ad alte prestazioni, estensibile e minimalista per Go.
- Revel: Un framework web full-stack che non richiede alcuna configurazione o codice boilerplate per iniziare.
Strumenti API e di protocollo
- gRPC: Un framework RPC universale ad alte prestazioni e open-source.
- Gorilla Mux: Un potente router URL e una libreria di dispatcher per la creazione di applicazioni web e API Go.
Driver e helper per database
- GORM: Una fantastica libreria ORM per Go che supporta diversi sistemi di database come PostgreSQL, MySQL, SQLite e altri.
- sqlx: un'estensione del pacchetto standard database/sql che semplifica e migliora le operazioni sui database mantenendo la compatibilità con il pacchetto standard.
Oltre a queste librerie, la libreria standard di Go offre molti pacchetti utili per lavorare con un'ampia gamma di funzionalità, come networking, I/O, strutture dati, algoritmi e altro ancora.
Vale la pena notare che l'apprendimento del linguaggio di programmazione Go e l'utilizzo delle librerie/API più diffuse è solo un aspetto della creazione di un'applicazione di successo. Per accelerare veramente il processo di sviluppo ed eliminare il debito tecnico, potreste prendere in considerazione l'idea di provare AppMaster , una piattaforma no-code che vi permette di costruire applicazioni backend, web e mobili utilizzando un'interfaccia visiva e generando automaticamente il codice sorgente senza alcun debito tecnico. Con la piattaforma AppMaster, le applicazioni Go possono essere sviluppate fino a 10 volte più velocemente e 3 volte più economicamente, coprendo un'ampia gamma di funzionalità e casi d'uso.
