How to design elegant function API in Golang?

Designing elegant function APIs in Go requires following naming conventions, optimizing parameter types, managing errors, and considering testability. Use naming conventions to clearly distinguish function and method names and identify API categories or purposes. Optimize parameter types, use structures instead of pointers or value types, and define clear input and output parameters. Use an error type to represent the reason why an API call failed and avoid returning an error string or value directly. Write unit-testable functions and avoid using global state or shared mutable data.

Designing elegant function API in Go

The designed function API is both intuitive and easy to use, which is useful for building maintainable and reliable functions. An expanded code base is critical. Here's how to do it in Go:

1. Use naming conventions

• Maintain a consistent naming style, using snake or camel case.
• Clearly distinguish function names and method names.
• Use a prefix to identify the API category or purpose, such as get_, calculate_.

// Get the current user.
func GetCurrentUser() *User { ... }

// Calculate the discount for a given user.
func CalculateDiscountForUser(user *User) float64 { ... }

2. Optimize parameter types

• Consider using structures instead of pointers or value types to improve readability and error handling.
• Define clear input and output parameters and avoid using variable parameter lists.
• Consider using type aliases to simplify complex type definitions.

type User struct {
    ID        int
    Name      string
    IsPremium bool
}

func CreateUser(u *User) error { ... }

3. Manage errors

• Use error types to clearly indicate the reason why the API call failed.
• Avoid returning error strings or values ​​directly, instead use the standard error interface.
• Use errors.Is and errors.As to check for specific error types.

import "errors"

var ErrUserNotFound = errors.New("user not found")

func GetUserByID(id int) (*User, error) { ... }

4. Consider testability

• Write functions for unit testing.
• Avoid using global state or shared mutable data.
• Use interfaces or dependency injection to simulate external dependencies.

import (
    "fmt"
    "io"
)

// Logger接口定义了Write方法。
type Logger interface {
    Write(string)
}

// FileLogger将日志写入文件。
type FileLogger struct {
    File *io.File
}

// Write implements the Logger interface.
func (l *FileLogger) Write(msg string) {
    fmt.Fprintf(l.File, msg)
}

// NewLogger创建新的日志记录器。
func NewLogger(path string) (Logger, error) {
    f, err := os.Create(path)
    if err != nil {
        return nil, err
    }
    return &FileLogger{f}, nil
}

Practical case: a simple hash function API

Consider a function API that generates hashes:

// Hash计算给定字符串的哈希值。
func Hash(s string) string { ... }

We can Improve this API by declaring the input type as a string and separating the hashing and formatting functions:

// ComputeHash计算给定字符串的哈希值。
func ComputeHash(s string) []byte { ... }

// FormatHash格式化哈希值以进行显示或比较。
func FormatHash(hash []byte) string { ... }

This way we can isolate the functionality of the API and make the API easier to extend and test.

The above is the detailed content of How to design elegant function API in Golang?. For more information, please follow other related articles on the PHP Chinese website!