Czy dobrą praktyką jest używanie funkcji tylko do centralizacji wspólnego kodu?

Często spotykam się z tym problemem. Na przykład obecnie piszę funkcję odczytu i funkcję zapisu, a oni oboje sprawdzają, czy bufjest wskaźnikiem NULL i czy modezmienna mieści się w określonych granicach.

To jest duplikacja kodu. Można to rozwiązać, przenosząc go do własnej funkcji. Ale powinienem? Będzie to dość anemiczna funkcja (niewiele robi), raczej zlokalizowana (więc nie ma ogólnego zastosowania) i sama nie wytrzymuje dobrze (nie może zrozumieć, do czego jest potrzebna, chyba że zobaczysz, gdzie ona jest) używany). Inną opcją jest użycie makra, ale chcę porozmawiać o funkcjach w tym poście.

Więc czy powinieneś użyć funkcji do czegoś takiego? Jakie są zalety i wady?

To świetne wykorzystanie funkcji.

To będzie dość anemiczna funkcja (niewiele robi) ...

Dobre. Funkcje powinny robić tylko jedną rzecz.

raczej zlokalizowane ...

W języku OO ustaw go jako prywatny.

(więc nie ogólnego przeznaczenia)

Jeśli obsługuje więcej niż jedną skrzynkę, jest to cel ogólny. Co więcej, uogólnienie to nie jedyne użycie funkcji. Są one rzeczywiście po to, aby (1) oszczędzić ci pisania tego samego kodu więcej niż raz, ale także (2), aby podzielić kod na mniejsze części, aby był bardziej czytelny. W tym przypadku osiąga zarówno (1), jak i (2). Jednak nawet jeśli twoja funkcja była wywoływana tylko z jednego miejsca, może to nadal pomóc w (2).

i nie radzi sobie dobrze (nie jest w stanie zrozumieć, do czego jest potrzebny, chyba że zobaczysz, gdzie jest używany).

Wymyśl dla niej dobre imię, a samo w sobie będzie dobrze. „ValidateFileParameters” lub coś takiego. Teraz dobrze sobie radzi.

To całkowicie powinno być funkcją.

if (isBufferValid(buffer)) {
    // ...
}

Znacznie bardziej czytelny i łatwiejszy w utrzymaniu (jeśli logika sprawdzania kiedykolwiek się zmienia, zmieniasz ją tylko w jednym miejscu).

Poza tym takie rzeczy łatwo się wprowadzają, więc nawet nie musisz się martwić o koszty ogólne wywołania funkcji.

Pozwól, że zadam ci lepsze pytanie. Jak nie jest to dobra praktyka?

Robić co należy. :)

IMO, fragmenty kodu warto przenieść do własnych funkcji, ilekroć sprawia to, że kod jest bardziej czytelny , niezależnie od tego, czy funkcja będzie bardzo krótka, czy będzie używana tylko raz.

Są oczywiście granice podyktowane zdrowym rozsądkiem. Na przykład nie chcesz mieć WriteToConsole(text)metody z ciałem po prostu Console.WriteLine(text). Ale błędem w kwestii czytelności jest dobra praktyka.

Zasadniczo dobrym pomysłem jest używanie funkcji do usuwania duplikacji w kodzie.

Jednak może to być brane zbyt daleko. To jest wyrok sądu.

Aby wziąć przykład z zerowego sprawdzania bufora, prawdopodobnie powiedziałbym, że poniższy kod jest wystarczająco jasny i nie powinien być wyodrębniany do oddzielnej funkcji, nawet jeśli ten sam wzorzec jest używany w kilku miejscach.

if (buf==null) throw new BufferException("Null read buffer!");

Jeśli podasz komunikat o błędzie jako parametr do ogólnej funkcji sprawdzania wartości NULL, a także weźmiesz pod uwagę kod wymagany do zdefiniowania funkcji, oznacza to, że nie jest to oszczędność netto LOC, aby zastąpić ją:

checkForNullBuffer(buf, "Null read buffer!");

Ponadto konieczność zanurzenia się w funkcji, aby zobaczyć, co robi podczas debugowania, oznacza, że ​​wywołanie funkcji jest mniej „przezroczyste” dla użytkownika, a zatem może być uważane za mniej czytelne / łatwe do utrzymania.

Centralizacja kodu jest zwykle zawsze dobrym pomysłem. Musimy ponownie wykorzystać kod w jak największym stopniu.

Należy jednak pamiętać, jak to zrobić. Na przykład, jeśli masz kod, który wykonuje compute_prime_number () lub check_if_packet_is_bad (), to dobrze. Są szanse, że algorytm samej funkcjonalności ewoluuje, co przyniesie korzyści.

Jednak żaden fragment kodu, który powtarza się jako proza, nie kwalifikuje się do natychmiastowego scentralizowania. To jest złe. Możesz ukryć dowolne wiersze kodu wewnątrz funkcji, aby ukryć kod, z czasem, gdy zacznie korzystać z wielu części aplikacji, wszystkie muszą pozostać kompatybilne z potrzebami wszystkich wywoływanych funkcji.

Oto kilka pytań, które powinieneś zadać przed zadaniem

1. Czy funkcja, którą tworzysz, ma swoje nieodłączne znaczenie, czy może to tylko wiązka linii?

2. Który inny kontekst będzie wymagał użycia tych samych funkcji? Czy jest prawdopodobne, że przed użyciem tego może być konieczne uogólnienie interfejsu API?

3. Jakich oczekiwań będą dotyczyły (różne części) aplikacje, gdy wprowadzisz wyjątki?

4. Jakie są scenariusze, aby zobaczyć, że funkcje będą ewoluować?

Powinieneś również sprawdzić, czy istnieją już takie rzeczy. Widziałem tak wielu ludzi, którzy zawsze starają się redefiniować swoje makra MIN, MAX zamiast szukać tego, co już istnieje.

Zasadniczo pytanie brzmi: „Czy ta nowa funkcja naprawdę zasługuje na ponowne użycie, czy to tylko kopia-wklej ?” Jeśli jest pierwszy, dobrze jest iść.

Należy unikać powielania kodu. Za każdym razem, gdy się tego spodziewasz, powinieneś unikać duplikacji kodu. Jeśli nie spodziewałeś się tego, zastosuj zasadę 3: refaktoryzuj, zanim ten sam fragment kodu zostanie zduplikowany 3 razy, zanotuj dziwactwo, gdy zostanie zduplikowane 2 razy.

Co to jest duplikat kodu?

• Procedura powtarzana w kilku miejscach w bazie kodu. Ta wycieczka musi być bardziej złożona niż zwykłe wywołanie funkcji (inaczej, nic nie zyskasz przez faktoryzację).
• Bardzo częste zadanie, nawet trywialne (często test). Poprawi to enkapsulację i semantyczność w kodzie.

Rozważ przykład poniżej:

if(user.getPrileges().contains("admin")) {
    // Do something
}

staje się

if(user.isAdmin()) {
    // Do something
}

Poprawiłeś enkapsulację (teraz możesz zmienić warunki, aby być administratorem w sposób transparentny) i semantykę kodu. Jeśli błąd zostanie wykryty w sposób, w jaki sprawdzasz, że użytkownik jest administratorem, nie musisz rzucać całą bazą kodu i naprawiać wszędzie (z ryzykiem zapomnienia o jednym i uzyskania luki w zabezpieczeniach aplikacji).

DRY polega na uproszczeniu manipulacji kodem. Właśnie poruszyłeś kwestię dotyczącą tej zasady: nie chodzi o zminimalizowanie liczby tokenów w kodzie, ale o tworzenie pojedynczych punktów modyfikacji dla semantycznie równoważnego kodu . Wygląda na to, że twoje czeki zawsze mają ten sam semantyczny, więc powinny zostać włączone do funkcji na wypadek, gdybyś musiał je zmodyfikować.

Jeśli widzisz, że jest powielony, powinieneś znaleźć sposób na jego scentralizowanie.

Funkcje są dobrym sposobem (może nie najlepszym, ale to zależy od języka). Nawet jeśli funkcja jest anemiczna, jak mówisz, nie oznacza to, że pozostanie taka.

Co jeśli musisz sprawdzić coś jeszcze?

Czy znajdziesz wszystkie miejsca, w których musisz dodać dodatkową kontrolę lub po prostu zmienić funkcję?

Prawie zawsze dobrze jest spełnić następujące warunki:

• poprawia czytelność
• używane w ograniczonym zakresie

W większym zakresie należy dokładnie wyważyć powielanie z kompromisami zależności. Przykłady technik ograniczających zakres: ukrywanie się w sekcjach prywatnych lub modułach bez ujawniania ich publicznie.