capypad
0 Tage Serie
Neues Quiz
Code-Bibliothek

Code, der lesenswert ist.

Sorgfältig kuratierte Snippets — TypeScript, Python, Rust, Go und mehr. Jedes mit einer Zeile-für-Zeile-Erklärung, damit du Code so liest, wie die Leute ihn geschrieben haben.

3498 Snippets · 10 Sprachen
▶ Lernen starten
Sammlung öffnen: Go · Fortgeschrittene →
Go · MittelSnippet

Implizite Interface-Implementierung

In Go werden Interfaces implizit implementiert. Ein Typ erfüllt ein Interface, indem er einfach dessen Methoden implementiert; es gibt kein Schlüsselwort 'implements'. Dies entkoppelt die Definition des Interfaces von seiner Implementierung.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
 
import "fmt"
 
type Describer interface {
    Describe() string
}
 
type Product struct {
    Name  string
    Price float64
}
 
func (p Product) Describe() string {
    return fmt.Sprintf("%s costs $%.2f", p.Name, p.Price)
}
 
func main() {
    var d Describer = Product{Name: "Keyboard", Price: 49.99}
    fmt.Println(d.Describe())
}
Design PatternsBest Practices
Go · MittelSnippet

Error-Wrapping und Unwrapping

Go 1.13+ führte Error-Wrapping mittels des %w-Verbs in fmt.Errorf ein. Dies erlaubt es, Kontext zu einem Fehler hinzuzufügen, während man weiterhin mit errors.Is auf den ursprünglichen Sentinel-Error prüfen kann.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
 
import (
    "errors"
    "fmt"
)
 
var ErrNotFound = errors.New("not found")
 
func fetchData() error {
    return fmt.Errorf("database error: %w", ErrNotFound)
}
 
func main() {
    err := fetchData()
    if err != nil {
        if errors.Is(err, ErrNotFound) {
            fmt.Println("Resource was not found")
        }
        fmt.Println("Original error:", err)
        fmt.Println("Unwrapped error:", errors.Unwrap(err))
    }
}
FehlerbehandlungBest Practices
Go · MittelSnippet

Benutzerdefinierte Funktionstypen für das Strategy-Pattern

Funktionen sind in Go 'First-Class-Citizens'. Man kann benutzerdefinierte Funktionstypen definieren, was nützlich für Muster wie Strategy oder Middleware ist, da Verhalten als Argument übergeben werden kann.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main
 
import "fmt"
 
type Validator func(string) bool
 
func IsEmail(s string) bool {
    return len(s) > 3 // Simplified logic
}
 
func ValidateInput(input string, v Validator) {
    if v(input) {
        fmt.Println("Input is valid")
    } else {
        fmt.Println("Input is invalid")
    }
}
 
func main() {
    ValidateInput("[email protected]", IsEmail)
    ValidateInput("", func(s string) bool {
        return len(s) > 0
    })
}
FunktionenDesign Patterns
Go · MittelSnippet

Komposition durch Struct-Embedding

Go verwendet Struct-Embedding, um Komposition zu erreichen. Wenn ein Typ ohne Feldnamen eingebettet wird, werden seine Methoden und Felder in das äußere Struct 'befördert', sodass direkt auf sie zugegriffen werden kann.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main
 
import "fmt"
 
type User struct {
    ID   int
    Name string
}
 
func (u User) Greet() {
    fmt.Printf("Hello, I am %s\n", u.Name)
}
 
type Admin struct {
    User  // Embedded field
    Level int
}
 
func main() {
    a := Admin{
        User:  User{ID: 1, Name: "Alice"},
        Level: 10,
    }
    a.Greet() // Promoted method
    fmt.Println("ID:", a.ID) // Promoted field
}
SyntaxDesign Patterns
Go · MittelSnippet

Nicht-blockierende Kanal-Operationen mit Select

Die 'select'-Anweisung lässt eine Goroutine auf mehrere Kommunikationsoperationen warten. Die Verwendung eines 'default'-Falls ermöglicht nicht-blockierendes Senden und Empfangen, das sofort ausgeführt wird, wenn kein Kanal bereit ist.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main
 
import "fmt"
 
func main() {
    messages := make(chan string)
    signals := make(chan bool)
 
    select {
    case msg := <-messages:
        fmt.Println("received message", msg)
    default:
        fmt.Println("no message received")
    }
 
    msg := "hi"
    select {
    case messages <- msg:
        fmt.Println("sent message", msg)
    default:
        fmt.Println("no message sent")
    }
}
Async & ConcurrencyKontrollstrukturen
Go · MittelSnippet

Performance-Optimierung durch Slice-Kapazität

Beim Verwenden von 'append' muss Go das zugrunde liegende Array eventuell neu zuweisen, wenn die Kapazität überschritten wird. Durch die Angabe einer Kapazität in 'make()' reduzieren Sie den CPU-Overhead und die Speicherfragmentierung.

snippet.go
go
1
2
3
4
5
6
7
8
func efficientAppend() {
	// Pre-allocate capacity to avoid multiple reallocations
	data := make([]int, 0, 100)
	for i := 0; i < 100; i++ {
		data = append(data, i)
	}
	fmt.Println(len(data), cap(data))
}
Arrays & ListenPerformance
Go · MittelSnippet

Abbruchsteuerung mit context.WithTimeout

Das Context-Paket ist essenziell für die Steuerung von Lebenszyklen und den Abbruch nebenläufiger Prozesse. WithTimeout erstellt einen abgeleiteten Kontext, der sich nach einer bestimmten Zeit automatisch beendet, um zu verhindern, dass Goroutinen endlos laufen.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
func fetchData(ctx context.Context) {
	ctx, cancel := context.WithTimeout(ctx, 2*time.Second)
	defer cancel()
 
	select {
	case <-time.After(3 * time.Second):
		fmt.Println("Finished task")
	case <-ctx.Done():
		fmt.Println("Cancelled:", ctx.Err())
	}
}
Async & ConcurrencyBest Practices
Go · MittelSnippet

Ressourcensicherheit mit Defer und Panic-Recovery

Die integrierte 'recover'-Funktion ermöglicht es einem Programm, die Kontrolle über eine abstürzende Goroutine zurückzugewinnen. Sie muss immer innerhalb einer 'defer'-Funktion aufgerufen werden, um die Panic abzufangen.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
func protectedFunction() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Recovered from panic:", r)
		}
	}()
 
	panic("something went wrong")
	fmt.Println("This will never run")
}
FehlerbehandlungKontrollstrukturen