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 · Experten →
Go · ExperteSnippet

Allokationsfreie Konvertierung von String zu Byte-Slice

Standardkonvertierungen kopieren Speicher. Die Verwendung des unsafe-Pakets ermöglicht die Neuinterpretation des zugrunde liegenden Speicher-Headers, um Allokationen zu vermeiden, erfordert jedoch eine sorgfältige Verwaltung der String-Immutabilität.

snippet.go
go
1
2
3
4
5
6
7
func StringToBytes(s string) []byte {
	return unsafe.Slice(unsafe.StringData(s), len(s))
}
 
func BytesToString(b []byte) string {
	return unsafe.String(unsafe.SliceData(b), len(b))
}
PerformanceBest PracticesDatentypen
Go · ExperteSnippet

Optimierung des Speicher-Alignments in Structs

Go richtet Strukturfelder basierend auf ihrer Größe aus. Große Felder sollten zuerst kommen, um Padding-Bytes zu minimieren, die der Compiler hinzufügt, um die Ausrichtung der Speicheradressen zu gewährleisten.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
type Optimized struct {
	A int64 // 8 bytes
	B int32 // 4 bytes
	C bool  // 1 byte
} // Total: 16 bytes (3 bytes padding)
 
type Unoptimized struct {
	C bool  // 1 byte
	A int64 // 8 bytes (7 bytes padding!)
	B int32 // 4 bytes
} // Total: 24 bytes
DatentypenPerformance
Go · ExperteSnippet

Reduzierung des GC-Drucks mit sync.Pool

sync.Pool ermöglicht die Wiederverwendung von Objekten, was die Häufigkeit von Garbage-Collection-Zyklen in Anwendungen mit hohem Durchsatz durch Recycling von zugewiesenem Speicher erheblich reduziert.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
var bufferPool = sync.Pool{
	New: func() any { return new(bytes.Buffer) },
}
 
func Process(data []byte) {
	buf := bufferPool.Get().(*bytes.Buffer)
	defer func() {
		buf.Reset()
		bufferPool.Put(buf)
	}()
	buf.Write(data)
}
PerformanceDesign PatternsAsync & Concurrency
Go · ExperteSnippet

Generische Type-Set-Constraints

Type-Sets in Interfaces ermöglichen es Generics, Typen auf eine bestimmte Vereinigung zu beschränken. Der Tilde-Operator (~) schließt Typen ein, die denselben zugrunde liegenden primitiven Typ teilen.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
type Number interface {
	~int | ~int64 | ~float64
}
 
func Sum[T Number](vals []T) T {
	var total T
	for _, v := range vals {
		total += v
	}
	return total
}
SyntaxDatentypenFunktionen
Go · ExperteSnippet

Request Collapsing mit singleflight

Das singleflight-Paket bietet einen Mechanismus zur Unterdrückung doppelter Funktionsaufrufe. Es stellt sicher, dass für einen bestimmten Schlüssel jeweils nur eine Ausführung einer Funktion aktiv ist. Wenn mehrere Goroutinen gleichzeitig Do mit demselben Schlüssel aufrufen, löst die erste die Funktionsausführung aus, während die anderen warten, um genau dasselbe Ergebnis zu erhalten, sobald es fertig ist. Dies verhindert effektiv 'Thundering Herd'-Probleme bei nachgelagerten Diensten.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
var g singleflight.Group
 
func fetchData(key string) (interface{}, error) {
    v, err, shared := g.Do(key, func() (interface{}, error) {
        return callExpensiveAPI(key)
    })
    if shared {
        log.Printf("Result for %s was shared", key)
    }
    return v, err
}
PerformanceDesign Patterns
Go · ExperteSnippet

Ressourcen-Drosselung mit gewichteten Semaphoren

Gewichtete Semaphoren ermöglichen die Steuerung des Zugriffs auf einen gemeinsamen Ressourcenpool, bei dem verschiedene Aufgaben unterschiedliche Mengen dieser Ressource verbrauchen können. Im Gegensatz zu einer einfachen Kanal-basierten Semaphore, die nur Einheiten zählt, kann die gewichtete Semaphore den Zugriff basierend auf variablen 'Kosten' pro Operation gewähren.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
var sem = semaphore.NewWeighted(100)
 
func handleRequest(ctx context.Context, cost int64) error {
    if err := sem.Acquire(ctx, cost); err != nil {
        return err
    }
    defer sem.Release(cost)
    
    doHeavyWork()
    return nil
}
Async & ConcurrencyDesign Patterns
Go · ExperteSnippet

Profiling spezifischer Logik mit pprof-Labels

Standard-CPU-Profiling in Go zeigt, wo Zeit in Funktionen verbracht wird, unterscheidet aber oft nicht zwischen verschiedenen Kontexten (z. B. welcher Benutzer die Last verursacht hat). pprof.Do ermöglicht es, Key-Value-Labels an den Kontext einer Goroutine zu binden. Bei einem CPU-Profil werden diese Labels aufgezeichnet, sodass das Profil nach spezifischen Kategorien gefiltert werden kann.

snippet.go
go
1
2
3
4
5
6
func processUserRequest(ctx context.Context, userID string) {
    labels := pprof.Labels("worker", "image-processor", "user_id", userID)
    pprof.Do(ctx, labels, func(ctx context.Context) {
        expensiveTransformation(ctx)
    })
}
PerformanceTesting
Go · ExperteSnippet

Hoch-performante Map durch Lock-Striping

Lock-Striping ist ein Entwurfsmuster zur Reduzierung von Ressourcenkonflikten, indem eine geteilte Ressource in mehrere unabhängige 'Shards' mit jeweils eigenem Lock aufgeteilt wird. In Umgebungen mit hoher Parallelität wird ein einzelner globaler Mutex auf einer Map zum Flaschenhals. Durch Hashing des Schlüssels zur Auswahl eines Shards können mehrere Goroutinen gleichzeitig auf verschiedene Teile der Map zugreifen.

snippet.go
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type Shard struct {
    sync.RWMutex
    m map[string]string
}
 
type ShardedMap []*Shard
 
func (s ShardedMap) getShard(key string) *Shard {
    return s[uint32(crc32.ChecksumIEEE([]byte(key)))%uint32(len(s))]
}
 
func (s ShardedMap) Get(key string) string {
    shard := s.getShard(key)
    shard.RLock()
    defer shard.RUnlock()
    return shard.m[key]
}
PerformanceDesign Patterns