12 unersetzbare Go-Pakete und Bibliotheken

German (Deutsch) translation by Tatsiana Bochkareva (you can also view the original English article)

Go ist eine erstaunliche Sprache mit viel Schwung und konzentriert sich auf Einfachheit. Dieser Ansatz zeigt sich in seiner Standardbibliothek, die alle wesentlichen, aber nicht viel mehr enthält.

Glücklicherweise hat Go eine lebendige Community, die viele Bibliotheken von Drittanbietern erstellt und gemeinsam nutzt. In diesem Tutorial stelle ich Ihnen 12 der besten Pakete und Bibliotheken von Go vor. Einige von ihnen haben einen relativ engen Umfang und können zu jedem Projekt hinzugefügt werden, während andere große Projekte sind, die Sie in massive, große verteilte Systeme integrieren können.

Awesome Go

Bevor ich in die Bibliotheken selbst eintauche, möchte ich Ihnen Awesome Go vorstellen, eine sehr aktive und kuratierte Liste von Go-Bibliotheken und anderen Ressourcen. Sie sollten ab und zu besuchen und prüfen, was es Neues gibt.

1. Golang-Set

Go hat Arrays, Slices und Maps, aber keine festgelegte Datenstruktur. Sie können einen Satz mit einer Karte von Bools nachahmen, aber es ist schön, einen tatsächlichen Datentyp mit den richtigen Operationen und der richtigen Semantik zu haben. Hier kommt das Golang-Set ins Spiel. Hier ist ein grundlegendes Beispiel für das Erstellen eines neuen Sets, das Hinzufügen von Elementen und das Testen der Mitgliedschaft:

package main

import (
    "fmt"
	"github.com/deckarep/golang-set"
)


func main() {
	basicColors := mapset.NewSet()
	basicColors.Add("Red")
	basicColors.Add("Blue")
	basicColors.Add("Green")

	if basicColors.Contains("Green") {
		fmt.Println("Yay! 'Green' is a basic color")
	} else {
		fmt.Println("What a disappointment! 'Green' is not a basic color")
	}


	if basicColors.Contains("Yellow") {
		fmt.Println("Yay! 'Yellow' is a basic color")
	} else {
		fmt.Println("What a disappointment! 'Yellow' is not a basic color")
	}
}

Output:

Yay! 'Green' is a basic color
What a disappointment! 'Yellow' is not a basic color

Beachten Sie, dass der Paketname "mapset" lautet. Zusätzlich zu den Grundlagen führen Sie alle festgelegten Operationen wie Vereinigung, Schnittmenge und Differenz aus. Sie können die festgelegten Werte auch durchlaufen:

package main

import (
    "fmt"
	"github.com/deckarep/golang-set"
)


func main() {
	basicColors := mapset.NewSet()
	basicColors.Add("Red")
	basicColors.Add("Blue")
	basicColors.Add("Green")

	otherColors := mapset.NewSetFromSlice([]interface{}{"Orange", "Yellow", "Indigo", "Violet"})
	rainbowColors := basicColors.Union(otherColors)

	for color := range rainbowColors.Iterator().C {
		fmt.Println(color)
	}
}

2. Farbe

Gehen wir mit dem FarbTheme fort. Beim Schreiben von Befehlszeilenprogrammen ist es hilfreich, Farben zu verwenden, um wichtige Meldungen hervorzuheben oder zwischen Fehlern, Erfolgen und Warnungen zu unterscheiden.

Das Farbpaket bietet eine einfache Möglichkeit, Ihren Programmen Farbe hinzuzufügen (Sehen Sie, was ich dort gemacht habe?). Es verwendet ANSII-Escape-Codes und unterstützt auch Windows! Hier ist ein kurzes Beispiel:

package main

import (
    "github.com/fatih/color"
)

func main() {
	color.Red("Roses are red")
	color.Blue("Violets are blue")
}

Das Farbpaket unterstützt das Mischen von Farben mit Hintergrundfarben, Stilen wie Fett oder Kursiv und das Besprühen von Farben mit nicht farbiger Ausgabe.

package main

import (
    "github.com/fatih/color"
	"fmt"
)

func main() {
	minion := color.New(color.FgBlack).Add(color.BgYellow).Add(color.Bold)
	minion.Println("Minion says: banana!!!!!!")

	m := minion.PrintlnFunc()
	m("I want another banana!!!!!")

	slantedRed := color.New(color.FgRed, color.BgWhite, color.Italic).SprintFunc()
	fmt.Println("I've made a huge", slantedRed("mistake"))
}

Das Farbpaket bietet weitere nützliche Funktionen. Gehen Sie voran und erkunden Sie mehr.

3. Now

Now ist ein sehr einfaches Paket, das einen praktischen Wrapper für das Standardzeitpaket bietet und die Arbeit mit verschiedenen Datums- und Zeitkonstrukten zur aktuellen Zeit vereinfacht.

Sie können den Beginn der aktuellen Minute oder das Ende des Sonntags abrufen, der deraktuellen Zeit am nächsten liegt. So verwenden Sie "now":

package main

import (
    "github.com/jinzhu/now"
	"fmt"
)

func main() {

	fmt.Println("All the beginnings...")
	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:

All the beginnings...
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

Sie können auch Zeiten analysieren und sogar Ihre eigenen Formate hinzufügen (für die die bekannten Formate aktualisiert werden müssen). Der Now-Typ bettet time.Time ein, sodass Sie die gesamte time.Time-Methode direkt für Now-Objekte verwenden können.

4. Gen

Das gen-Werkzeug generiert Code für Sie - insbesondere typenbezogenen Code, der versucht, die Lücke zu schließen, in der keine Vorlagen oder Generika in Go vorhanden sind.

Sie kommentieren Ihre Typen mit einem speziellen Kommentar und gen generiert Quelldateien, die Sie in Ihr Projekt aufnehmen. Keine Laufzeitmagie. Sehen wir uns ein Beispiel an. Hier ist ein kommentierter Typ.

// +gen slice:"Where,Count,GroupBy[int]"
type Person struct {
    Name string
	Age int
}

Wenn Sie gen ausführen (stellen Sie sicher, dass es sich in Ihrem Pfad befindet), wird person_slice.go generiert:

// Generated by: gen
// TypeWriter: slice
// Directive: +gen on Person

package main

// PersonSlice is a slice of type Person. Use it where you would use []Person.
type PersonSlice []Person

// Where returns a new PersonSlice whose elements return true for func. See: https://clipperhouse.github.io/gen/#Where
func (rcv PersonSlice) Where(fn func(Person) bool) (result PersonSlice) {
    for _, v := range rcv {
		if fn(v) {
			result = append(result, v)
		}
	}
	return result
}

// Count gives the number elements of PersonSlice that return true for the passed func. See: http://clipperhouse.github.io/gen/#Count
func (rcv PersonSlice) Count(fn func(Person) bool) (result int) {
	for _, v := range rcv {
		if fn(v) {
			result++
		}
	}
	return
}

// GroupByInt groups elements into a map keyed by int. See: http://clipperhouse.github.io/gen/#GroupBy
func (rcv PersonSlice) GroupByInt(fn func(Person) int) map[int]PersonSlice {
	result := make(map[int]PersonSlice)
	for _, v := range rcv {
		key := fn(v)
		result[key] = append(result[key], v)
	}
	return result
}

Der Code bietet LINQ-ähnliche Methoden für die Bearbeitung des PersonSlice-Typs. Es ist einfach zu verstehen und gut dokumentiert.

So verwenden Sie es. In der Hauptfunktion wird eine PersonSlice definiert. Die Funktion age() wählt das Altersfeld aus dem Argument Person aus. Die generierte GroupByInt() -Funktion übernimmt die age() -Funktion und gibt die Personen aus dem Slice zurück, die nach ihrem Alter gruppiert sind (34 ist nur Jim, 23 hat sowohl Jane als auch Kyle).

package main

import (
    "fmt"
)

// +gen slice:"Where,Count,GroupBy[int]"
type Person struct {
	Name string
	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:

map[34:[{Jim 34}] 23:[{Jane 23} {Kyle 23}]]

5. Gorm

Go ist bekannt für seine spartanische Natur. Die Datenbankprogrammierung ist nicht anders. Die beliebtesten DB-Bibliotheken für Go sind ziemlich niedrig. Gorm bringt die Welt der objektrelationalen Zuordnung mit den folgenden Funktionen in Go:

Assoziationen (Has One, Has Many, Belongs To, Many To Many, Polymorphism)
Rückrufe (Before/After Create/Save/Update/Delete/Find)
Vorladen (eifriges Laden)
Transaktionen
Zusammengesetzter Primärschlüssel
SQL Builder
Automatische Migrationen
Logger
Erweiterbare Schreib-Plugins basierend auf GORM-Rückrufen

Aber es deckt nicht alles ab. Wenn Sie aus Python kommen, erwarten Sie keine SQLAlchemy-Magie. Für ausgefallenere Sachen musst du ein niedrigeres Level gehen. Hier ist ein Beispiel für die Verwendung von Gorm mit SQLite. Beachten Sie das eingebettete Modell gorm.Model in der Produktstruktur.

package main

import (
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)

type Product struct {
  gorm.Model
  Code string
  Price uint
}

func main() {
  db, err := gorm.Open("sqlite3", "test.db")
  if err != nil {
    panic("failed to connect database")
  }
  defer db.Close()

  // Migrate the schema
  db.AutoMigrate(&Product{})

  // Create
  db.Create(&Product{Code: "L1212", Price: 1000})

  // Read
  var product Product
  db.First(&product, 1) // find product with id 1
  db.First(&product, "code = ?", "L1212")

  // Update - update product's price to 2000
  db.Model(&product).Update("Price", 2000)

  // Delete - delete product
  db.Delete(&product)

6. Goose

Eine der wichtigsten Aufgaben bei der Arbeit mit relationalen Datenbanken ist die Verwaltung des Schemas. Das Ändern des DB-Schemas wird in einigen Organisationen als "beängstigende" Änderung angesehen. Mit dem goose-Paket können Sie bei Bedarf Schemaänderungen und sogar Datenmigrationen durchführen. Sie können goose up und goose down, um hin und her zu gehen. Achten Sie jedoch auf Ihre Daten und stellen Sie sicher, dass sie nicht verloren gehen oder beschädigt werden.

Goose versioniert Ihr Schema und verwendet Migrationsdateien, die jedem Schema entsprechen. Die Migrationsdateien können SQL-Befehle oder Go-Befehle sein. Hier ist ein Beispiel für eine SQL-Migrationsdatei, die eine neue Tabelle hinzufügt:

-- +goose Up
CREATE TABLE person (
    id int NOT NULL,
    name text,
    age int,
    PRIMARY KEY(id)
);

-- +goose Down
DROP TABLE person;

Die Kommentare -- +goose up und -- +goose down geben goose an, was zu tun ist, um das Schema zu aktualisieren oder herunterzustufen.

7. Glide

Glide ist ein Paketmanager für Go. Unter einem einzigen GOPATH haben Sie möglicherweise viele Programme mit widersprüchlichen Abhängigkeiten. Die Lösung besteht darin, dass jedes Programm sein eigenes Herstellerverzeichnis mit Paketabhängigkeiten verwaltet. Glide hilft bei dieser Aufgabe.

Hier sind die Merkmale des Gleitens:

Unterstützt Versionspakete, einschließlich Semantic Versioning 2.0.0.
Unterstützt Aliasing-Pakete (z. B. zum Arbeiten mit Github-Gabeln).
Entfernen Sie keine Munging-Importanweisungen mehr.
Arbeiten Sie mit allen Go-Werkzeugs.
Unterstützt alle von Go unterstützten VCS-Werkzeugs (git, bzr, hg, svn).
Unterstützt benutzerdefinierte lokale und globale Plugins.
Repository-Caching und Daten-Caching für verbesserte Leistung.
Reduzieren Sie Abhängigkeiten, lösen Sie Versionsunterschiede und vermeiden Sie die mehrfache Aufnahme eines Pakets.
Verwalten und installieren Sie Abhängigkeiten nach Bedarf oder in Ihrem Versionskontrollsystem.

Die Abhängigkeiten werden in glide.yaml gespeichert, und glide bietet verschiedene Befehle zum Verwalten von Abhängigkeiten:

     create, init       Initialize a new project, creating a 
                        glide.yaml file
     config-wizard, cw  Wizard that makes optional suggestions 
                        to improve config in a glide.yaml file.
     get                Install one or more packages into 
                        `vendor/` and add dependency to 
                        glide.yaml.
     remove, rm         Remove a package from the glide.yaml 
                        file, and regenerate the lock file.
     import             Import files from other dependency 
                        management systems.
     name               Print the name of this project.
     novendor, nv       List all non-vendor paths in a 
                        directory.
     rebuild            Rebuild ('go build') the dependencies
     install, i         Install a project's dependencies
     update, up         Update a project's dependencies
     tree               (Deprecated) Tree prints the 
                        dependencies of this project as a tree.
     list               List prints all dependencies that the 
                        present code references.
     info               Info prints information about this 
                        project
     cache-clear, cc    Clears the Glide cache.
     about              Learn about Glide
     mirror             Manage mirrors
     help, h            Shows a list of commands or help for 
                        one command

8. Ginkgo

Ginkgo ist ein BDD-Testframework (Behavior Driven Development). Sie können Ihre Tests in einer Syntax schreiben, die Englisch ähnelt, und weniger technischen Mitarbeitern ermöglichen, Tests (und deren Ausgabe) zu überprüfen und zu überprüfen, ob sie den Geschäftsanforderungen entsprechen.

Einige Entwickler mögen diese Art der Testspezifikation auch. Es lässt sich in das integrierte Testpaket von Go integrieren und wird häufig mit Gomega kombiniert. Hier ist ein Beispiel für einen Ginkgo + Gomega-Test:

1	actual, err := foo()
2	Ω(err).Should(BeNil())
3	Ω(actual).ShouldNot(BeNil())
4	Ω(actual.result).Should(Equal(100))

9. Etcd

Etcd ist ein zuverlässiger verteilter Schlüsselwertspeicher. Der Server ist in Go implementiert und der Go-Client interagiert mit ihm über gRPC.

Es konzentriert sich auf Folgendes:

Einfach: gut definierte, benutzerbezogene API (gRPC).
Sicher: Automatisches TLS mit optionaler Clientzertifizierungsauthentifizierung.
Schnell: Benchmarking von 10.000 Schreibvorgängen/Sek.
Zuverlässig: Mit Raft richtig verteilt.

Hier ist ein Beispiel für das Herstellen einer Verbindung zum Server, das Eingeben und Abrufen eines Werts, einschließlich Zeitüberschreitungen und Bereinigung.

func test_get() {
    cli, err := clientv3.New(clientv3.Config{
		Endpoints:   endpoints,
		DialTimeout: dialTimeout,
	})
	if err != nil {
		log.Fatal(err)
	}
	defer cli.Close()

	_, err = cli.Put(context.TODO(), "foo", "bar")
	if err != nil {
		log.Fatal(err)
	}

	ctx, cancel := context.WithTimeout(context.Background(), 
                                       requestTimeout)
	resp, err := cli.Get(ctx, "foo")
	cancel()
	if err != nil {
		log.Fatal(err)
	}
	for _, ev := range resp.Kvs {
		fmt.Printf("%s : %s\n", ev.Key, ev.Value)
	}
	// Output: foo : bar
}

10. NSQ

NSQ ist eine großartige verteilte Warteschlange. Ich habe es erfolgreich als primären Baustein für verteilte Großsysteme verwendet. Hier sind einige seiner Funktionen:

Unterstützt verteilte Topologien ohne SPOF.
Horizontal skalierbar (keine Broker, fügen Sie dem Cluster nahtlos weitere Knoten hinzu).
Push-basierte Nachrichtenübermittlung mit geringer Latenz (Leistung).
Kombination aus lastausgeglichenem und Multicast-Nachrichtenrouting.
Excel sowohl bei Streaming-Workloads (hoher Durchsatz) als auch bei joborientierten Workloads (niedriger Durchsatz).
Hauptsächlich im Speicher (Nachrichten, die über eine Hochwassermarke hinausgehen, werden transparent auf der Festplatte gespeichert).
Runtime Discovery Service für Verbraucher, um Produzenten zu finden (nsqlookupd).
Transport Layer Security (TLS).
Datenformat agnostisch.
Nur wenige Abhängigkeiten (einfach bereitzustellen) und eine vernünftige, begrenzte Standardkonfiguration.
Einfaches TCP-Protokoll, das Client-Bibliotheken in jeder Sprache unterstützt.
HTTP-Schnittstelle für Statistiken, Administratoraktionen und Produzenten (zum Veröffentlichen ist keine Clientbibliothek erforderlich).
Integriert in statsd für Echtzeitinstrumentierung.
Robuste Cluster-Verwaltungsschnittstelle (nsqadmin).

Wie man eine Nachricht in NSQ veröffentlicht (Fehlerbehandlung entfällt):

package main

import (
  "github.com/bitly/go-nsq"
)

func main() {
  config := nsq.NewConfig()
  p, _ := nsq.NewProducer("127.0.0.1:4150", config)

  p.Publish("topic", []byte("message"))
  p.Stop()
}

Und so konsumieren Sie:

package 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(message *nsq.Message) error {
      fmt.Printf("Got a message: %v", message)
      wg.Done()
      return nil
  })
  q.AddHandler(handler)
  q.ConnectToNSQD("127.0.0.1:4150")
  wg.Wait()
}

11. Docker

Docker ist heute ein bekannter Name (wenn Ihre Familienmitglieder hauptsächlich DevOps-Leute sind). Möglicherweise wissen Sie nicht, dass Docker in Go implementiert ist. Normalerweise verwenden Sie Docker nicht in Ihrem Code, aber es ist ein bedeutendes Projekt und verdient es, als äußerst erfolgreiches und beliebtes Go-Projekt anerkannt zu werden.

12. Kubernetes

Kubernetes ist eine Open-Source-Container-Orchestrierungsplattform für Cloud-native Anwendungen. Es ist ein weiteres in Go implementiertes Monster-Distributed-System. Ich habe kürzlich ein Buch mit dem Titel Mastering Kubernetes geschrieben, in dem ich die fortschrittlichsten Aspekte von Kubernetes ausführlich erläutere. Aus Sicht des Go-Entwicklers ist Kubernetes sehr flexibel und kann über Plugins erweitert und angepasst werden.

Schlussfolgerung

Go ist eine großartige Sprache. Seine Designphilosophie ist es, eine einfache und ansprechbare Sprache zu sein. Die Standardbibliothek ist nicht so umfassend wie einige andere Sprachen wie Python.

Die Go-Community wurde erweitert, und es gibt viele hochwertige Bibliotheken, die Sie in Ihren Programmen verwenden können. In diesem Artikel habe ich 12 Bibliotheken vorgestellt. Ich empfehle Ihnen, nach anderen Bibliotheken zu suchen, bevor Sie alles von Grund auf neu implementieren.