Ez a harmadik cikk a "Clean Code in Go" sorozatban. Tiszta kód: A funkciók és a hibák kezelése a Go-ban: a káosztól a tisztánlátásig [1. rész] Tiszta kód a folyamatban (2. rész): szerkezetek, módszerek és összetétele az öröklés felett Bevezetés: Interfaces - Go's Secret Weapon Láttam, hogy a csapatok olyan 20 módú interfészeket hoznak létre, amelyeket lehetetlenné teszik a tesztelést, a gúnyolódást vagy a karbantartást. Aztán elgondolkodnak azon, hogy a Go miért érzi magát rosszul. „Elfogadja az interfészeket, adja vissza a struktúrákat” – ha csak egy Go idiomát hallott, akkor valószínűleg ez az. De miért olyan fontos? Gyakori interfész hibák, amelyekkel találkoztam: - 10+ módszerrel rendelkező interfészek: ~45% Enterprise Go kód - Interfészek meghatározása a megvalósítási helyszínen: ~70% a csomagok - Interfészek visszaadása beton típusok helyett: ~55% a funkciók Üres interfész használata mindenhol: ~30% API - nil interface vs nil pointer confusion: ~25% finom hibák 8 évnyi munka után a Go-val, és számtalan interfészrel kapcsolatos probléma elhárítása után elmondhatom: az interfészek megfelelő használata a különbség a nyelv elleni küzdelem és a vízhez hasonlóan áramló kód között. Interfész elégedettség: Duck Typing felnőtteknek A Go-ban egy típus automatikusan kielégíti a felületet, kifejezett nyilatkozat nélkül: // Interface defines a contract
type Writer interface {
    Write([]byte) (int, error)
}

// File satisfies Writer automatically
type File struct {
    path string
}

func (f *File) Write(data []byte) (int, error) {
    // implementation
    return len(data), nil
}

// Buffer also satisfies Writer
type Buffer struct {
    data []byte
}

func (b *Buffer) Write(data []byte) (int, error) {
    b.data = append(b.data, data...)
    return len(data), nil
}

// Function accepts interface
func SaveLog(w Writer, message string) error {
    _, err := w.Write([]byte(message))
    return err
}

// Usage - works with any Writer
file := &File{path: "/var/log/app.log"}
buffer := &Buffer{}

SaveLog(file, "Writing to file")    // OK
SaveLog(buffer, "Writing to buffer") // OK
 Kicsi interfészek: az egyszerűség ereje Az egységes módszer szabályai Nézze meg a Go szabványos könyvtárát: type Reader interface {
    Read([]byte) (int, error)
}

type Writer interface {
    Write([]byte) (int, error)
}

type Closer interface {
    Close() error
}

type Stringer interface {
    String() string
}
 Egy módszer - egy interfész. miért? // BAD: large interface
type Storage interface {
    Save(key string, data []byte) error
    Load(key string) ([]byte, error)
    Delete(key string) error
    List(prefix string) ([]string, error)
    Exists(key string) bool
    Size(key string) (int64, error)
    LastModified(key string) (time.Time, error)
}

// Problem: what if you only need Save/Load?
// You'll have to implement ALL methods!

// GOOD: small interfaces
type Reader interface {
    Read(key string) ([]byte, error)
}

type Writer interface {
    Write(key string, data []byte) error
}

type Deleter interface {
    Delete(key string) error
}

// Interface composition
type ReadWriter interface {
    Reader
    Writer
}

type Storage interface {
    ReadWriter
    Deleter
}

// Now functions can require only what they need
func BackupData(r Reader, keys []string) error {
    for _, key := range keys {
        data, err := r.Read(key)
        if err != nil {
            return fmt.Errorf("read %s: %w", key, err)
        }
        // backup process
    }
    return nil
}

// Function requires minimum - only Reader, not entire Storage
 Az interfész szétválasztásának elve a cselekvésben // Instead of one monstrous interface
type HTTPClient interface {
    Get(url string) (*Response, error)
    Post(url string, body []byte) (*Response, error)
    Put(url string, body []byte) (*Response, error)
    Delete(url string) (*Response, error)
    Head(url string) (*Response, error)
    Options(url string) (*Response, error)
    Patch(url string, body []byte) (*Response, error)
}

// Create focused interfaces
type Getter interface {
    Get(url string) (*Response, error)
}

type Poster interface {
    Post(url string, body []byte) (*Response, error)
}

// Function requires only what it uses
func FetchUser(g Getter, userID string) (*User, error) {
    resp, err := g.Get("/users/" + userID)
    if err != nil {
        return nil, fmt.Errorf("fetch user %s: %w", userID, err)
    }
    // parse response
    return parseUser(resp)
}

// Testing becomes easier
type mockGetter struct {
    response *Response
    err      error
}

func (m mockGetter) Get(url string) (*Response, error) {
    return m.response, m.err
}

// Only need to mock one method, not entire HTTPClient!
 Interfészek elfogadása, visszaküldési struktúrák Miért számít ez // BAD: returning interface
func NewLogger() Logger { // Logger is interface
    return &FileLogger{
        file: os.Stdout,
    }
}

// Problems:
// 1. Hides actual type
// 2. Loses access to type-specific methods
// 3. Complicates debugging

// GOOD: return concrete type
func NewLogger() *FileLogger { // concrete type
    return &FileLogger{
        file: os.Stdout,
    }
}

// But ACCEPT interface
func ProcessData(logger Logger, data []byte) error {
    logger.Log("Processing started")
    // processing
    logger.Log("Processing completed")
    return nil
}
 Gyakorlati példák // Repository returns concrete types
type UserRepository struct {
    db *sql.DB
}

func NewUserRepository(db *sql.DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindByID(id string) (*User, error) {
    // SQL query
    return &User{}, nil
}

func (r *UserRepository) Save(user *User) error {
    // SQL query
    return nil
}

// Service accepts interfaces
type UserFinder interface {
    FindByID(id string) (*User, error)
}

type UserSaver interface {
    Save(user *User) error
}

type UserService struct {
    finder UserFinder
    saver  UserSaver
}

func NewUserService(finder UserFinder, saver UserSaver) *UserService {
    return &UserService{
        finder: finder,
        saver:  saver,
    }
}

// Easy to test - can substitute mocks
type mockFinder struct {
    user *User
    err  error
}

func (m mockFinder) FindByID(id string) (*User, error) {
    return m.user, m.err
}

func TestUserService(t *testing.T) {
    mock := mockFinder{
        user: &User{Name: "Test"},
    }
    
    service := NewUserService(mock, nil)
    // test with mock
}
 Interfész összetétele Beépített interfészek // Base interfaces
type Reader interface {
    Read([]byte) (int, error)
}

type Writer interface {
    Write([]byte) (int, error)
}

type Closer interface {
    Close() error
}

// Composition through embedding
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// Or more explicitly
type ReadWriteCloser interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
}
 Típusú kijelentések és típusú kapcsolók // Type assertion - check concrete type
func ProcessWriter(w io.Writer) {
    // Check if Writer also supports Closer
    if closer, ok := w.(io.Closer); ok {
        defer closer.Close()
    }
    
    // Check for buffering
    if buffered, ok := w.(*bufio.Writer); ok {
        defer buffered.Flush()
    }
    
    w.Write([]byte("data"))
}

// Type switch - handle different types
func Describe(i interface{}) string {
    switch v := i.(type) {
    case string:
        return fmt.Sprintf("String of length %d", len(v))
    case int:
        return fmt.Sprintf("Integer: %d", v)
    case fmt.Stringer:
        return fmt.Sprintf("Stringer: %s", v.String())
    case error:
        return fmt.Sprintf("Error: %v", v)
    default:
        return fmt.Sprintf("Unknown type: %T", v)
    }
}
 Nyitókép: The Gotchas // WARNING: classic mistake
type MyError struct {
    msg string
}

func (e *MyError) Error() string {
    return e.msg
}

func doSomething() error {
    var err *MyError = nil
    // some logic
    return err // RETURNING nil pointer
}

func main() {
    err := doSomething()
    if err != nil { // TRUE! nil pointer != nil interface
        fmt.Println("Got error:", err)
    }
}

// CORRECT: explicitly return nil
func doSomething() error {
    var err *MyError = nil
    // some logic
    if err == nil {
        return nil // return nil interface
    }
    return err
}
 Ellenőrizze a nil // Safe nil check for interface
func IsNil(i interface{}) bool {
    if i == nil {
        return true
    }
    
    // Check if value inside interface is nil
    value := reflect.ValueOf(i)
    switch value.Kind() {
    case reflect.Ptr, reflect.Map, reflect.Slice, reflect.Chan, reflect.Func:
        return value.IsNil()
    }
    return false
}
 Valódi példák a standard könyvtárból io.Reader/Writer – Minden alapja // Copy between any Reader and Writer
func Copy(dst io.Writer, src io.Reader) (int64, error)

// Works with files
file1, _ := os.Open("input.txt")
file2, _ := os.Create("output.txt")
io.Copy(file2, file1)

// Works with network
conn, _ := net.Dial("tcp", "example.com:80")
io.Copy(conn, strings.NewReader("GET / HTTP/1.0\r\n\r\n"))

// Works with buffers
var buf bytes.Buffer
io.Copy(&buf, file1)
 http.Handler — Web Server in One Method type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

// Any type with ServeHTTP method can be a handler
type MyAPI struct {
    db Database
}

func (api MyAPI) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    switch r.URL.Path {
    case "/users":
        api.handleUsers(w, r)
    case "/posts":
        api.handlePosts(w, r)
    default:
        http.NotFound(w, r)
    }
}

// HandlerFunc - adapter for regular functions
type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
    f(w, r) // call the function
}

// Now regular function can be a handler!
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
})
 Patterns és anti-patterns Címke: feltételes interfész // Optional interfaces for extending functionality
type Optimizer interface {
    Optimize() error
}

func ProcessData(w io.Writer, data []byte) error {
    // Basic functionality
    if _, err := w.Write(data); err != nil {
        return err
    }
    
    // Optional optimization
    if optimizer, ok := w.(Optimizer); ok {
        return optimizer.Optimize()
    }
    
    return nil
}
 Anti-Pattern: túl általános interfészek // BAD: interface{} everywhere
func Process(data interface{}) interface{} {
    // type assertions everywhere
    switch v := data.(type) {
    case string:
        return len(v)
    case []byte:
        return len(v)
    default:
        return nil
    }
}

// GOOD: specific interfaces
type Sized interface {
    Size() int
}

func Process(s Sized) int {
    return s.Size()
}
 Gyakorlati tippek 
 
 
 
 
 
 
 
 Határozza meg a felhasználói felületeket, nem a végrehajtást Előnyben részesítik a kis interfészeket a nagyokat A beágyazás használata az interfész összetételéhez Ne adja vissza az interfészeket szükségtelenül Nyelvi interfész vs. Nyelvi mutató Használjon típusú állításokat óvatosan Az interfész az utolsó megoldás, nem az első Interfész ellenőrző lista Az interfész 1-3 módszerrel rendelkezik - Használat közelében definiált interfész A funkciók elfogadják az interfészeket, nem a konkrét típusokat A funkciók konkrét típusokat adnak vissza, nem interfészeket - Nincs fel nem használt módszer az interfészeken - A típusmegállapítások mindkét esetet kezelik (ok/nem ok) - interfész{} csak akkor használható, ha szükséges következtetés Az interfészek azok a ragasztók, amelyek a Go programokat együtt tartják. Rugalmas, tesztelhető és karbantartható kódot biztosítanak komplex öröklési hierarchiák nélkül. Ne feledje: a Go-ban az interfészek implicit, kicsi és komposztálható. A következő cikkben megvitatjuk a csomagokat és a függőségeket: hogyan szervezzük meg a kódot úgy, hogy az import grafikon lapos és a függőségek egyirányúak legyenek. Mit gondolsz az interfésztervezésről? Mennyire kicsi a túl kicsi? Hogyan döntesz úgy, hogy mikor hozzon létre interfészet egy konkrét típushoz képest? Ossza meg tapasztalatait a megjegyzésekben!

Read My Stories

Ez a hanganyag a történet eredeti nyelvén készült!

Clean Code: Interfaces in Go - Miért kicsi szép [3. rész]

About Author

HOZZÁSZÓLÁSOK

HANG TAGOK

EZT A CIKKET BEMUTATTA

Related Stories

Of The First and Last Things: Part 4

HackerNoon Raises $250k at $50M Valuation From Forward Research

From Desk to HackerNoon: Your Ultimate Guide on How to Publish a Story

Of The First and Last Things: Part 1

Of The First and Last Things: Part 4

HackerNoon Raises $250k at $50M Valuation From Forward Research

From Desk to HackerNoon: Your Ultimate Guide on How to Publish a Story

Of The First and Last Things: Part 1

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps