Share
Go è un linguaggio straordinario con un sacco di slancio, ed è incentrato sulla semplicità. Questo approccio è evidente nella sua libreria standard, che fornisce tutti gli elementi essenziali, ma non molto di più.
Fortunatamente, Go ha una vivace comunità che crea e condivide molte librerie di terze parti. In questo tutorial, ti presenterò 12 dei migliori pacchetti e librerie di Go. Alcuni di essi hanno uno scopo relativamente ristretto e possono essere aggiunti a qualsiasi progetto, mentre altri sono progetti enormi che è possibile incorporare in sistemi distribuiti di grandi dimensioni e su larga scala.
Prima di immergerti nelle librerie, lascia che ti presenti a Awesome Go, una lista molto attiva e curata di librerie di Go e altre risorse. Dovresti visitare ogni tanto e controllare le novità.
Go ha matrici, sezioni e mappe, ma non ha una struttura dati impostata. Puoi imitare un set con una mappa di bool, ma è bello avere un tipo di dati effettivo con le giuste operazioni e semantica. È qui che entra in gioco golan-set. Ecco un semplice esempio di creazione di un nuovo set, aggiunta di elementi e test per l'appartenenza:
Accentsconagua
pacchetto main import ("fmt" "github.com/deckarep/golang-set") func main () basicColors: = mapset.NewSet () basicColors.Add ("Red") basicColors.Add ("Blue") basicColors. Aggiungi ("Verde") se basicColors.Contains ("Green") fmt.Println ("Yay! 'Green' è un colore di base") else fmt.Println ("Che delusione!" Green "non è un basic color ") if basicColors.Contains (" Yellow ") fmt.Println (" Yay! 'Yellow' è un colore di base ") else fmt.Println (" Che delusione! 'Yellow' non è una base colore ") Uscita: Sì! 'Verde' è un colore di base Che delusione! 'Giallo' non è un colore di baseSi noti che il nome del pacchetto è "mapset". Oltre alle basi, esegui tutte le operazioni impostate come unione, intersezione e differenza. Puoi anche scorrere i valori impostati:
pacchetto main import ("fmt" "github.com/deckarep/golang-set") func main () basicColors: = mapset.NewSet () basicColors.Add ("Red") basicColors.Add ("Blue") basicColors. Aggiungi ("Verde") otherColors: = mapset.NewSetFromSlice ([] interface "Orange", "Yellow", "Indigo", "Violet") rainbowColors: = basicColors.Union (otherColors) per il colore: = range rainbowColors.Iterator (). C fmt.Println (color)Continuiamo con il tema del colore. Durante la scrittura di programmi da riga di comando, è utile utilizzare i colori per evidenziare messaggi importanti o distinguere tra errori, successi e avvisi.
Il pacchetto colori offre un modo semplice per aggiungere un po 'di colore ai tuoi programmi (vedi cosa ho fatto lì?). Usa i codici di escape ANSII e supporta anche Windows! Ecco un rapido esempio:
pacchetto main import ("github.com/fatih/color") func main () color.Red ("Roses are red") color.Blue ("Violets are blue") Il pacchetto di colori supporta la miscelazione di colori con colori di sfondo, stili come grassetto o corsivo e spruzza il colore con output non colorato.
pacchetto main import ("github.com/fatih/color" "fmt") func main () minion: = color.New (color.FgBlack) .Add (color.BgYellow) .Add (color.Bold) minion.Println ("Minion dice: banana !!!!!!") m: = minion.PrintlnFunc () m ("Voglio un'altra banana !!!!!") slantedRed: = color.New (color.FgRed, color.BgWhite , color.Italic) .SprintFunc () fmt.Println ("I've made a huge", slantedRed ("errore")) Il pacchetto colori ha altre utili funzionalità. Vai avanti ed esplora di più.
Ora è un pacchetto molto semplice che fornisce un wrapper di convenienza per il pacchetto orario standard e semplifica il lavoro con vari costrutti di data e ora intorno all'orario corrente.
Ad esempio, è possibile ottenere l'inizio del minuto corrente o la fine della domenica più vicina all'ora corrente. Ecco come usare "now":
pacchetto main import ("github.com/jinzhu/now" "fmt") func main () fmt.Println ("Tutti gli inizi ...") fmt.Println (now.BeginningOfMinute ()) fmt.Println (now.BeginningOfHour ()) fmt.Println (now.BeginningOfDay ()) fmt.Println (now.BeginningOfWeek ()) fmt.Println (now.BeginningOfMonth ()) fmt.Println (now.BeginningOfQuarter ()) fmt.Println (now.BeginningOfYear ()) Output: Tutti gli inizi ... 2017-06-04 16:59:00 -0700 PDT 2017-06-04 16:00:00 -0700 PDT 2017-06-04 00:00:00 -0700 PDT 2017 -06-04 00:00:00 -0700 PDT 2017-06-01 00:00:00 -0700 PDT 2017-04-01 00:00:00 -0700 PDT 2016-12-31 23:00:00 -0800 PST È anche possibile analizzare i tempi e persino aggiungere i propri formati (che richiedono l'aggiornamento dei formati noti). Il Adesso digitare incorpora time.time, quindi puoi usare tutto il time.time metodi direttamente Adesso oggetti.
Lo strumento gen genera codice per te, in particolare, codice sensibile al tipo che tenta di alleviare il vuoto di non avere modelli o generici in Go.
Annoti i tuoi tipi con un commento speciale e gen genera i file sorgente che includi nel tuo progetto. Nessuna magia di runtime. Vediamo un esempio. Ecco un tipo annotato.
// + gen slice: "Where, Count, GroupBy [int]" type Persona struct Name string Age int
In esecuzione gen (assicurati che sia nel tuo percorso) genera person_slice.go:
// Generato da: gen // TypeWriter: slice // Direttiva: + gen on Person package main // PersonSlice è una porzione di tipo Person. Usalo dove useresti [] Person. digita PersonSlice [] Person // Dove restituisce un nuovo PersonSlice i cui elementi restituiscono true per func. Vedi: http://clipperhouse.github.io/gen/#Where func (rcv PersonSlice) Dove (fn func (Person) bool) (risultato PersonSlice) per _, v: = range rcv if fn (v) result = append (result, v) return result // Count fornisce gli elementi numerici di PersonSlice che restituiscono true per la funzione passata. Vedi: http://clipperhouse.github.io/gen/#Count func (rcv PersonSlice) Conteggio (fn func (Persona) bool) (risultato int) per _, v: = intervallo rcv if fn (v) result ++ return // GroupByInt raggruppa elementi in una mappa digitata da int. Vedi: http://clipperhouse.github.io/gen/#GroupBy func (rcv PersonSlice) GroupByInt (fn func (Person) int) map [int] PersonSlice result: = make (map [int] PersonSlice) per _, v: = range rcv key: = fn (v) result [chiave] = append (risultato [chiave], v) risultato restituito
Il codice fornisce metodi simili a LINQ per operare su PersonSlice genere. È semplice da capire e ben documentato.
Ecco come lo usi. Nella funzione principale, a PersonSlice è definito. Il età() la funzione seleziona il campo dell'età dal suo Persona discussione. Il generato GroupByInt () la funzione prende il età() funzione e restituisce le persone dalla fetta raggruppata per la loro età (34 è solo Jim, ma 23 ha sia Jane che Kyle).
pacchetto main import ("fmt") // + gen slice: "Dove, Count, GroupBy [int]" type Persona struct Nome stringa Age int func age (p Person) int return p.Age func main () people: = PersonSlice "Jim", 34, "Jane", 23, "Kyle", 23, groupedByAge: = people.GroupByInt (age) fmt.Println (groupedByAge) Output: mappa [34: [Jim 34] 23: [Jane 23 Kyle 23]]Go è noto per la sua natura spartana. La programmazione del database non è diversa. Le librerie DB più popolari per Go sono piuttosto di basso livello. Gorm porta il mondo della mappatura oggettuale relazionale a Go con le seguenti funzionalità:
Ma non copre tutto. Se vieni da Python, non aspettarti la magia di SQLAlchemy. Per cose più fantasiose, dovrai fare un livello inferiore. Ecco un esempio di come usare Gorm con sqlite. Nota l'incorporato gorm.Model nella struttura del prodotto.
pacchetto main import ("github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/sqlite") tipo Product struct gorm.Model Codice stringa Prezzo uint func main () db, err: = gorm.Open ("sqlite3", "test.db") se err! = nil panico ("impossibile connettere il database") defer db.Close () // Migrazione dello schema db.AutoMigrate (& Prodotto ) / / Crea db.Create (& Product Codice: "L1212", Prezzo: 1000) // Leggi prodotto var Prodotto db.First (& product, 1) // cerca prodotto con id 1 db.First (& product, "code =? "," L1212 ") // Aggiorna - aggiorna il prezzo del prodotto a 2000 db.Model (e prodotto) .Update (" Prezzo ", 2000) // Elimina - elimina prodotto db.Delete (e prodotto)Uno dei compiti più importanti quando si lavora con database relazionali è la gestione dello schema. La modifica dello schema del DB è considerata una modifica "spaventosa" in alcune organizzazioni. Il pacchetto goose consente di eseguire modifiche dello schema e persino migrazioni di dati, se necessario. Puoi d'oca e piuma d'oca andare avanti e indietro. Presta attenzione ai tuoi dati, però, e assicurati che non vada perso o corrotto.
Goose funziona eseguendo il versioning dello schema e utilizzando i file di migrazione corrispondenti a ciascuno schema. I file di migrazione possono essere comandi SQL o comandi Go. Ecco un esempio di un file di migrazione SQL che aggiunge una nuova tabella:
-- +goose Up CREATE TABLE person (id int NOT NULL, nome del testo, age int, PRIMARY KEY (id)); - + piuma d'oca DROP TABLE person;
Il -- +d'oca e -- +piuma d'oca i commenti dicono a cosa fare per aggiornare o downgrade dello schema.
Glide è un gestore di pacchetti per Go. Sotto un singolo GOPATH, potresti avere molti programmi con dipendenze in conflitto. La soluzione è fare in modo che ogni programma gestisca la propria directory del fornitore delle dipendenze del pacchetto. Glide aiuta con questo compito.
Ecco le caratteristiche della planata:
Le dipendenze sono memorizzate in glide.yaml, e glide fornisce diversi comandi per gestire le dipendenze:
create, init Inizializza un nuovo progetto, creando un glide.yaml file config-wizard, cw Wizard che fornisce suggerimenti opzionali per migliorare la configurazione in un file glide.yaml. Installa uno o più pacchetti in "fornitore /" e aggiungi dipendenza a glide.yaml. remove, rm Rimuove un pacchetto dal file glide.yaml e rigenera il file di lock. import Importa file da altri sistemi di gestione delle dipendenze. nome Stampa il nome di questo progetto. novendor, nv Elenca tutti i percorsi non vendor in una directory. Ricostruisci Ricostruisci ('go build') l'installazione delle dipendenze, i Installa l'aggiornamento delle dipendenze di un progetto, in alto Aggiorna l'albero delle dipendenze di un progetto (Deprecato) Albero stampa le dipendenze di questo progetto come una struttura. lista Lista stampa tutte le dipendenze che il codice presente fa riferimento. info Info stampa le informazioni su questo progetto cache-clear, cc Cancella la cache Glide. Informazioni su Glide mirror Gestisci aiuto specchi, h Mostra un elenco di comandi o guida per un comandoGinkgo è un framework di test BDD (Behavior Driven Development). Ti consente di scrivere i tuoi test in una sintassi simile all'inglese e consentire a persone meno tecniche di rivedere i test (e il loro output) e verificare che soddisfino i requisiti aziendali.
Ad alcuni sviluppatori piace anche questo stile di specifica del test. Si integra con il pacchetto di test integrato di Go ed è spesso combinato con Gomega. Ecco un esempio di un test Ginkgo + Gomega:
actual, err: = foo () Ω (err) .Should (BeNil ()) Ω (actual) .ShouldNot (BeNil ()) Ω (actual.result) .Should (Equal (100))
Etcd è un negozio Key-Value distribuito affidabile. Il server è implementato in Go e il client Go interagisce con esso anche se gRPC.
Si concentra su quanto segue:
Ecco un esempio di connessione al server, mettendo un valore e ricevendolo, inclusi timeout e pulizia.
func test_get () cli, err: = clientv3.New (clientv3.Config Endpoint: endpoint, DialTimeout: dialTimeout,) se err! = nil log.Fatal (err) rimanda cli.Close () _, err = cli.Put (context.TODO (), "foo", "bar") se err! = nil log.Fatal (err) ctx, cancel: = context.WithTimeout (context.Background (), requestTimeout) resp , err: = cli.Get (ctx, "foo") cancel () se err! = nil log.Fatal (err) per _, ev: = range resp.Kvs fmt.Printf ("% s:% s \ n ", ev.Key, ev.Value) // Output: foo: barNSQ è una grande coda distribuita. L'ho usato con successo come elemento fondamentale per i sistemi distribuiti su larga scala. Ecco alcune delle sue caratteristiche:
Ecco come pubblicare un messaggio su NSQ (la gestione degli errori viene elisa):
pacchetto main import ("github.com/bitly/go-nsq") func main () config: = nsq.NewConfig () p, _: = nsq.NewProducer ("127.0.0.1:4150", config) p. Pubblica ("argomento", [] byte ("messaggio")) p.Stop ()Ed ecco come consumare:
pacchetto main import ("sync" "fmt" "github.com/bitly/go-nsq") func main () wg: = & sync.WaitGroup wg.Add (1) config: = nsq.NewConfig () q , _: = nsq.NewConsumer ("topic", "channel", config) handler: = nsq.HandlerFunc (func (messaggio * nsq.Message) error fmt.Printf ("Hai un messaggio:% v", messaggio) wg.Done () return nil) q.AddHandler (gestore) q.ConnectToNSQD ("127.0.0.1:4150") wg.Wait ()Docker è un nome familiare ora (se i membri della tua famiglia sono per lo più persone DevOps). Potresti non sapere che Docker è implementato in Go. Solitamente non usi Docker nel tuo codice, ma è un progetto significativo e merita di essere riconosciuto come un progetto Go di enorme successo e popolare.
Kubernetes è una piattaforma di orchestrazione di contenitori open source per applicazioni native cloud. È un altro sistema distribuito di mostri implementato in Go. Recentemente ho scritto un libro intitolato Mastering Kubernetes in cui vado in dettaglio sugli aspetti più avanzati di Kubernetes. Dal punto di vista dello sviluppatore Go, Kubernetes è molto flessibile e puoi estenderlo e personalizzarlo tramite plugin.
Go è una lingua fantastica. La sua filosofia di design è quella di essere un linguaggio semplice e accessibile. La sua libreria standard non è completa come alcuni altri linguaggi come Python.
La community di Go è migliorata e ci sono molte librerie di alta qualità che puoi usare nei tuoi programmi. In questo articolo, ho introdotto 12 librerie. Ti incoraggio a cercare altre librerie prima di saltare e implementare tutto da zero.
