Code-Bibliothek — Capypad · Code Zeile für Zeile lesen

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())
}

patternsbestpractices

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))
    }
}

errorhandlingbestpractices

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
    })
}

functionspatterns

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
}

syntaxpatterns

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")
    }
}

asynccontrolflow

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))
}

arraysperformance

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())
	}
}

asyncbestpractices

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")
}

errorhandlingcontrolflow