Go lernen, 2. Auflage

Book description

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

Go hat sich schnell zur bevorzugten Sprache für die Entwicklung von Webdiensten entwickelt. Es gibt viele Tutorials, die Entwicklern mit Erfahrung in anderen Programmiersprachen die Syntax von Go beibringen, aber diese Tutorials reichen nicht aus. Sie vermitteln nicht die Idiome von Go, so dass Entwickler/innen am Ende Muster nachbilden, die im Go-Kontext keinen Sinn ergeben. Dieser praktische Leitfaden liefert das nötige Hintergrundwissen, das du brauchst, um ein klares und idiomatisches Go zu schreiben.

Egal, wie viel Erfahrung du hast, du wirst lernen, wie ein Go-Entwickler zu denken. Der Autor Jon Bodner stellt die Entwurfsmuster vor, die erfahrene Go-Entwickler/innen übernommen haben, und erläutert die Gründe für ihre Verwendung. In dieser aktualisierten Ausgabe erfährst du außerdem, wie sich die Generik-Unterstützung von Go in die Sprache einfügt.

Dieses Buch hilft dir:

  • idiomatischen Code in Go zu schreiben und ein Go-Projekt zu entwerfen
  • die Gründe für die Designentscheidungen von Go zu verstehen
  • Eine Go-Entwicklungsumgebung für einen Einzelentwickler oder ein Team einrichten
  • Lernen, wie und wann Reflexion, unsafe und cgo verwendet werden können
  • Entdecke, wie die Funktionen von Go es ermöglichen, dass die Sprache effizient läuft
  • Welche Go-Funktionen du sparsam oder gar nicht verwenden solltest
  • Nutze die Werkzeuge von Go, um die Leistung zu verbessern, die Speichernutzung zu optimieren und die Garbage Collection zu reduzieren
  • Lerne, wie du die fortschrittlichen Entwicklungswerkzeuge von Go nutzt

Table of contents

  1. Vorwort
    1. Wer sollte dieses Buch lesen?
    2. In diesem Buch verwendete Konventionen
    3. Code-Beispiele verwenden
    4. O'Reilly Online Learning
    5. Wie du uns kontaktierst
    6. Danksagungen für die 2. Auflage
    7. Danksagungen für die 1. Auflage
  2. 1. Einrichten deiner Go-Umgebung
    1. Installieren der Go Tools
      1. Fehlersuche bei deiner Go-Installation
      2. Go Tooling
    2. Dein erstes Go-Programm
      1. Ein Go-Modul herstellen
      2. bauen gehen
      3. fmt gehen
      4. zum Tierarzt gehen
    3. Wähle deine Werkzeuge
      1. Visual Studio Code
      2. GoLand
      3. Der Go-Spielplatz
    4. Makefiles
    5. Das Go-Kompatibilitätsversprechen
    6. Immer auf dem Laufenden bleiben
    7. Übungen
    8. Einpacken
  3. 2. Vordeklarierte Typen und Deklarationen
    1. Die vordeklarierten Typen
      1. Der Nullwert
      2. Literale
      3. Booleans
      4. Numerische Typen
      5. Ein Geschmack von Saiten und Runen
      6. Explizite Typkonvertierung
      7. Literale sind untypisiert
    2. var Versus :=
    3. Mit const
    4. Typisierte und nicht typisierte Konstanten
    5. Ungenutzte Variablen
    6. Benennung von Variablen und Konstanten
    7. Übungen
    8. Einpacken
  4. 3. Zusammengesetzte Typen
    1. Arrays - zu starr für den direkten Einsatz
    2. Slices
      1. len
      2. anhängen.
      3. Kapazität
      4. machen.
      5. Leeren eines Slice
      6. Dein Slice deklarieren
      7. Schneiden von Schnitten
      8. kopieren
      9. Arrays in Slices umwandeln
      10. Slices in Arrays umwandeln
    3. Strings, Runen und Bytes
    4. Karten
      1. Eine Karte lesen und schreiben
      2. Das Komma ok Idiom
      3. Aus Karten löschen
      4. Eine Karte leeren
      5. Karten vergleichen
      6. Karten als Sets verwenden
    5. Strukturen
      1. Anonyme Strukturen
      2. Vergleichen und Konvertieren von Strukturen
    6. Übungen
    7. Einpacken
  5. 4. Blöcke, Schatten und Kontrollstrukturen
    1. Blöcke
    2. Beschattungsvariablen
    3. wenn
    4. für, Vier Wege
      1. Das vollständige Formblatt
      2. Die Bedingung - nur für Aussage
      3. Das Unendliche für Statement
      4. Pause und weiter
      5. Die for-range-Anweisung
      6. Beschriftung deiner For-Aussagen
      7. Das Richtige für die Aussage wählen
    5. switch
      1. Leere Schalter
      2. Die Wahl zwischen if und switch
    6. goto-Ja, goto
    7. Übungen
    8. Einpacken
  6. 5. Funktionen
    1. Deklarieren und Aufrufen von Funktionen
      1. Benannte und optionale Parameter simulieren
      2. Variadische Eingabeparameter und Slices
      3. Mehrere Rückgabewerte
      4. Mehrere Rückgabewerte sind mehrere Werte
      5. Zurückgegebene Werte ignorieren
      6. Benannte Rückgabewerte
      7. Leere Rücksendungen - benutze sie niemals!
    2. Funktionen sind Werte
      1. Funktionstyp-Deklarationen
      2. Anonyme Funktionen
    3. Schließungen
      1. Übergabe von Funktionen als Parameter
      2. Rückgabe von Funktionen aus Funktionen
    4. aufschieben.
    5. Go Is Call by Value
    6. Übungen
    7. Einpacken
  7. 6. Zeiger
    1. Eine schnelle Zeigerfibel
    2. Keine Angst vor den Zeigern
    3. Zeiger zeigen veränderbare Parameter an
    4. Zeiger sind ein letztes Mittel
    5. Leistung der Zeigerübergabe
    6. Der Nullwert versus kein Wert
    7. Der Unterschied zwischen Karten und Slices
    8. Slices als Puffer
    9. Reduzierung der Arbeitslast des Garbage Collectors
    10. Tuning des Garbage Collectors
    11. Übungen
    12. Einpacken
  8. 7. Typen, Methoden und Schnittstellen
    1. Typen in Go
    2. Methoden
      1. Zeigerempfänger und Werteempfänger
      2. Codiere deine Methoden für Null-Instanzen
      3. Methoden sind auch Funktionen
      4. Funktionen vs. Methoden
      5. Typendeklarationen sind keine Vererbung
      6. Typen sind ausführbare Dokumentation
    3. iota ist für Aufzählungen - manchmal
    4. Einbettung für die Komposition verwenden
    5. Einbettung ist keine Vererbung
    6. Eine kurze Lektion über Schnittstellen
    7. Schnittstellen sind typsicher Duck Typing
    8. Einbettung und Schnittstellen
    9. Schnittstellen akzeptieren, Strukturen zurückgeben
    10. Schnittstellen und Null
    11. Schnittstellen sind vergleichbar
    12. Das leere Interface sagt nichts aus
    13. Typ-Assertionen und Typ-Schalter
    14. Type Assertions und Type Switches sparsam verwenden
    15. Funktionstypen sind eine Brücke zu Schnittstellen
    16. Implizite Interfaces machen Dependency Injection einfacher
    17. Draht
    18. Go ist nicht besonders objektorientiert (und das ist gut so)
    19. Übungen
    20. Einpacken
  9. 8. Generika
    1. Generika reduzieren repetitiven Code und erhöhen die Typensicherheit
    2. Einführung von Generika in Go
    3. Generische Funktionen Abstrakte Algorithmen
    4. Generika und Schnittstellen
    5. Typbegriffe zur Angabe von Operatoren verwenden
    6. Typinferenz und Generika
    7. Typ Elemente Grenzkonstanten
    8. Kombinieren von generischen Funktionen mit generischen Datenstrukturen
    9. Mehr über vergleichbare
    10. Dinge, die ausgelassen werden
    11. Idiomatisches Go und Generika
    12. Hinzufügen von Generika zur Standardbibliothek
    13. Zukünftige Funktionen freigeschaltet
    14. Übungen
    15. Einpacken
  10. 9. Fehler
    1. Wie man mit Fehlern umgeht: Die Grundlagen
    2. Strings für einfache Fehler verwenden
    3. Sentinel-Fehler
    4. Fehler sind Werte
    5. Wrapping-Fehler
    6. Mehrere Fehler einpacken
    7. Ist und Als
    8. Wrapping-Fehler mit Aufschub
    9. in Panik geraten und sich erholen
    10. Einen Stack Trace von einem Fehler erhalten
    11. Übungen
    12. Einpacken
  11. 10. Module, Pakete und Importe
    1. Repositories, Module und Pakete
    2. go.mod verwenden
      1. Verwende die go-Direktive, um Go-Build-Versionen zu verwalten
      2. Die geforderte Richtlinie
    3. Gebäudepakete
      1. Importieren und Exportieren
      2. Erstellen und Aufrufen eines Pakets
      3. Pakete benennen
      4. Den Namen eines Pakets überschreiben
      5. Dokumentiere deinen Code mit Go Doc-Kommentaren
      6. Verwendung des internen Pakets
      7. Vermeiden von zirkulären Abhängigkeiten
      8. Organisieren deines Moduls
      9. Anständiges Umbenennen und Reorganisieren deiner API
      10. Wenn möglich, die init-Funktion vermeiden
    4. Arbeiten mit Modulen
      1. Code von Drittanbietern importieren
      2. Mit Versionen arbeiten
      3. Minimale Versionsauswahl
      4. Aktualisieren auf kompatible Versionen
      5. Aktualisieren auf inkompatible Versionen
      6. Vendoring
      7. pkg.go.dev verwenden
    5. Dein Modul veröffentlichen
    6. Versionierung deines Moduls
      1. Abhängigkeiten außer Kraft setzen
      2. Eine Version deines Moduls zurückziehen
      3. Arbeitsbereiche zur gleichzeitigen Änderung von Modulen verwenden
    7. Modul Proxyserver
      1. Festlegen eines Proxy-Servers
      2. Private Repositories verwenden
    8. Zusätzliche Details
    9. Übungen
    10. Einpacken
  12. 11. Go Tooling
    1. Mit go run kleine Programme ausprobieren
    2. Hinzufügen von Tools von Drittanbietern mit go install
    3. Verbessern der Importformatierung mit goimports
    4. Einsatz von Code-Qualitätsscannern
      1. staticcheck
      2. wiederbeleben
      3. golangci-lint
    5. Mit govulncheck nach gefährdeten Abhängigkeiten suchen
    6. Inhalte in dein Programm einbetten
    7. Versteckte Dateien einbetten
    8. Mit go generate
    9. Arbeiten mit go generate und Makefiles
    10. Lesen der Build-Informationen innerhalb einer Go-Binärdatei
    11. Go-Binaries für andere Plattformen erstellen
    12. Verwendung von Build Tags
    13. Testen von Go-Versionen
    14. Mit go help mehr über Go Tooling erfahren
    15. Übungen
    16. Einpacken
  13. 12. Gleichzeitigkeit in Go
    1. Wann sollte man Gleichzeitigkeit nutzen?
    2. Goroutinen
    3. Kanäle
      1. Lesen, Schreiben und Zwischenspeichern
      2. Bereich und Kanäle verwenden
      3. Einen Kanal schließen
      4. Verstehen, wie sich Kanäle verhalten
    4. wähle
    5. Praktiken und Muster der Gleichzeitigkeit
      1. Halte deine APIs frei von Gleichzeitigkeit
      2. Goroutinen, for-Schleifen und variierende Variablen
      3. Räumt eure Goroutinen immer auf
      4. Den Kontext zum Beenden von Goroutinen verwenden
      5. Wissen, wann man gepufferte und ungepufferte Kanäle verwendet
      6. Gegendruck einsetzen
      7. Einen Fall in einer Auswahl ausschalten
      8. Time Out Code
      9. WaitGroups verwenden
      10. Code genau einmal ausführen
      11. Stelle deine gleichzeitigen Werkzeuge zusammen
    6. Wann sollte man Mutexe statt Kanäle verwenden?
    7. Atome - die brauchst du wahrscheinlich nicht
    8. Wo du mehr über Gleichzeitigkeit erfährst
    9. Übungen
    10. Einpacken
  14. 13. Die Standardbibliothek
    1. io und Freunde
    2. Zeit
      1. Monotone Zeit
      2. Timer und Timeouts
    3. Kodierung/json
      1. Mit Struktur-Tags Metadaten hinzufügen
      2. Entschärfen und Einmarschieren
      3. JSON, Leser und Schreiber
      4. Kodierung und Dekodierung von JSON-Streams
      5. Benutzerdefiniertes JSON-Parsing
    4. net/http
      1. Der Kunde
      2. Der Server
      3. ResponseController
    5. Strukturierte Protokollierung
    6. Übungen
    7. Einpacken
  15. 14. Der Kontext
    1. Was ist der Kontext?
    2. Werte
    3. Stornierung
    4. Kontexte mit Fristen
    5. Kontextaufhebung in deinem eigenen Code
    6. Übungen
    7. Einpacken
  16. 15. Schreibtests
    1. Die Grundlagen des Prüfens verstehen
      1. Meldung von Testfehlern
      2. Aufstellen und Abreißen
      3. Testen mit Umgebungsvariablen
      4. Speichern von Probenprüfdaten
      5. Caching Testergebnisse
      6. Testen deiner öffentlichen API
      7. go-cmp zum Vergleich von Testergebnissen verwenden
    2. Tabellen-Tests durchführen
    3. Gleichzeitige Durchführung von Tests
    4. Überprüfe deine Codeabdeckung
    5. Fuzzing
    6. Benchmarks verwenden
    7. Stubs in Go verwenden
    8. httptest verwenden
    9. Integrationstests und Build-Tags verwenden
    10. Gleichzeitigkeitsprobleme mit dem Data Race Detector aufspüren
    11. Übungen
    12. Einpacken
  17. 16. Hier sind die Drachen: Reflect, Unsafe und Cgo
    1. Mit Reflection kannst du mit Typen zur Laufzeit arbeiten
      1. Arten, Gattungen und Werte
      2. Neue Werte schaffen
      3. Mit Reflection prüfen, ob der Wert einer Schnittstelle gleich null ist
      4. Reflection verwenden, um einen Data Marshaler zu schreiben
      5. Funktionen mit Reflection erstellen, um sich wiederholende Aufgaben zu automatisieren
      6. Du kannst Structs mit Reflection bauen, musst es aber nicht
      7. Nachdenken kann keine Methoden machen
      8. Verwende Reflexion nur, wenn sie sich lohnt
    2. Unsicher ist unsicher
      1. Sizeof und Offsetof verwenden
      2. Unsicheres Konvertieren externer Binärdaten verwenden
      3. Zugriff auf nicht exportierte Felder
      4. Unsichere Tools verwenden
    3. Cgo ist für Integration, nicht für Leistung
    4. Übungen
    5. Einpacken
  18. Index
  19. Über den Autor

Product information

  • Title: Go lernen, 2. Auflage
  • Author(s): Jon Bodner
  • Release date: August 2024
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781098180300