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!
![featured image - Clean Code: Interfaces in Go - Miért kicsi szép [3. rész]](https://hackernoon.imgix.net/images/ZTiVtl9TF6Mqdq0GSgDuxuALFDX2-d10233z.png?auto=format&fit=max&w=3840)
