Chcesz pisać czysty kod?, to ten artykuł jest właśnie dla Ciebie.
Czysty kod to kluczowa kwestia, a umiejętność jego tworzenia odróżnia dobrego programistę od takiego, który stara się być programistą.
W tym wpisie dowiesz się, jak tworzyć czytelny, przejrzysty i zrozumiały kod, który nie tylko ułatwi Ci pracę, ale także sprawi, że inni developerzy będą chcieli chętnie z Tobą współpracować.
Co to jest Czysty Kod?
Zanim zaczniemy, warto zadać sobie pytanie: Czym właściwie jest czysty kod?
Czysty kod to taki, który jest łatwy do czytania, zrozumienia i utrzymania.
Taki kod jest napisany w sposób czytelny, z użyciem dobrych praktyk programistycznych, co sprawia, że jest mniej podatny na błędy i łatwiejszy do dalszego rozwijania i utrzymania.
Czysty kod to nie tylko działający kod, ale także kod, który jest czytelny dla innych programistów.
Oznacza to, że ktoś inny (lub Ty sam za kilka miesięcy) może łatwo zrozumieć, co robi Twój kod i dlaczego został napisany w ten sposób.
To nie jest tak, że Twój kod zawsze będzie idealny.
Często będzie to wynikało z ograniczonego czasu lub Twoich umiejętności. Mój kod również często nie jest idealny a zwłaszcza ten, który pisałem na początku kariery.
Chodzi o to żeby dążyć do ideału i zawsze mieć te zasady w pamięci. Bo nawet jeśli Twój kod nie będzie picco bello, to chociaż będzie zbliżał się do tego stanu
Dlaczego Warto Pisać Czysty Kod?
Możesz się zastanawiać, dlaczego warto poświęcić dodatkowy czas na pisanie czystego kodu.
Oto kilka powodów:
- Łatwiejsze utrzymanie: Czysty kod jest prostszy do modyfikacji i debugowania.
- Współpraca w zespole: Inni programiści łatwiej zrozumieją Twój kod, co przyspiesza pracę zespołową.
- Mniej błędów: Przejrzysty kod zmniejsza ryzyko wprowadzenia błędów podczas zmian.
- Skalowalność: Czysty kod jest łatwiejszy do rozbudowy w przyszłości.
- Profesjonalizm: Pisząc czysty kod, pokazujesz, że jesteś profesjonalistą dbającym o jakość swojej pracy.
Dobre Praktyki Programistyczne
Przejdźmy teraz do konkretnych dobrych praktyk, które pomogą Ci pisać czysty kod.
Nazewnictwo Zmiennych i Funkcji
Nazewnictwo to podstawa czytelności kodu.
Dobre nazwy zmiennych, funkcji i klas powinny być opisowe i zrozumiałe.
Przykład złego kodu:
int a = 5;
int b = 10;
int c = a + b;
Przykład dobrego kodu:
int numbersOfApple = 5;
int numbersOfPeach = 10;
int totalFruitsNumber = numbersOfApple + numbersOfPeach;
Dzięki opisowym nazwom, od razu wiesz, co reprezentuje dana zmienna.
Dobre praktyki nazewnictwa:
- Konsystencja: Używaj spójnego stylu nazewnictwa w całym projekcie.
- Unikaj skrótów: Chyba że są one powszechnie znane.
- Język: Wybierz jeden język (zdecydowanie zalecanym jest angielski) i trzymaj się go w całym kodzie.
- Wielkość liter: Stosuj konwencję camelCase lub snake_case, ale bądź spójny.
Zasada DRY (Don't Repeat Yourself)
Zasada DRY mówi, aby unikać powtarzania tego samego kodu w różnych miejscach.
Powielanie kodu zwiększa ryzyko błędów i utrudnia utrzymanie.
Przykład złego kodu:
public void sendWelcomeEmail(String email) {
// Code to send email
}
public void sendReminderEmail(String email) {
// The same code to send email
}
Przykład dobrego kodu:
public void sendEmail(String email, String subject, String content) {
// Code to send email
}
W ten sposób tworzymy jedną funkcję, która obsługuje różne przypadki.
Zasada KISS (Keep It Simple, Stupid)
Zasada KISS zachęca do utrzymania kodu w jak najprostszej formie.
Unikaj nadmiernej złożoności, która może utrudnić zrozumienie kodu.
Przykład złego kodu:
if (status == true) {
if (user.isActive()) {
if (!user.isBlocked()) {
// Execute operation
}
}
}
Przykład dobrego kodu:
if (status && user.isActive() && !user.isBlocked()) {
// Execute operation
}
Prostszy kod jest łatwiejszy do czytania i utrzymania.
Zasada YAGNI (You Aren't Gonna Need It)
Nie twórz funkcjonalności, której obecnie nie potrzebujesz.
Dodawanie nieużywanego kodu zwiększa złożoność i może wprowadzać dodatkowe błędy.
Przykład:
Jeśli obecnie Twoja aplikacja obsługuje tylko język polski, nie implementuj od razu mechanizmu wielojęzyczności, jeżeli nie jest to konieczne.
Formatowanie i Spójność Kodowania
Formatowanie kodu ma ogromny wpływ na jego czytelność. Używaj odpowiednich wcięć, odstępów i podziałów na linie.
Przykład złego kodu:
public class Example{
public void method(){
System.out.println("Unformatted code");}}
Przykład dobrego kodu:
public class Example {
public void method() {
System.out.println("Formatted code");
}
}
Wskazówki dotyczące formatowania:
- Używaj wcięć: Najczęściej 4 spacje lub tabulator.
- Odstępy: Stosuj spacje wokół operatorów.
- Linie: Nie twórz zbyt długich linii kodu; maksymalnie 80-120 znaków.
Komentowanie Kodu
Komentarze są ważne, ale kod powinien być na tyle czytelny, żeby komentarze nie były potrzebne zbyt często.
Przykład złego kodu:
// Increment the counter
i = i + 1;
Przykład dobrego kodu:
counter++;
Dobre nazewnictwo i czytelny kod eliminują potrzebę nadmiernego komentowania.
Unikanie "Śmierdzącego kodu"
Śmierdzący kod to pierwsze symptomy dalszych problemów.
Mogą to być:
- Duplikacje kodu
- Zbyt długie metody
- Zbyt wiele parametrów
- Nadmierna złożoność
Przykład:
Jeśli masz funkcję z 10 parametrami, warto ją podzielić na mniejsze, bardziej czytelne części.
Refaktoryzacja Kodu
Refaktoryzacja to proces ulepszania kodu bez zmiany jego funkcjonalności.
Regularna refaktoryzacja pomaga utrzymać czystość kodu i poprawia jego czytelność.
Przykład przed refaktoryzacją:
public void processData(String data) {
// Code processing data
// Code validating data
// Code saving data
}
Przykład po refaktoryzacji:
public void processData(String data) {
String processedData = process(data);
if (isValidData(processedData)) {
saveData(processedData);
}
}
private String process(String data) {
// Code processing data
}
private boolean isValidData(String data) {
// Code validating data
}
private void saveData(String data) {
// Code saving data
}
Teraz każda funkcja ma jedno zadanie, co zwiększa czytelność kodu.
Praktyczne Porady dla Początkujących Programistów
Ucz się od osób bardziej doświadczoncych
Jeśli jesteś początkującym programistą, warto korzystać z doświadczenia które masz w zasięgu ręki.
Czytaj ich kod, uczestnicz w code review, zadawaj pytania, rób więcej niż musisz.
Pisz Testy Jednostkowe
Testy jednostkowe pomagają w utrzymaniu jakości kodu i zapewniają, że zmiany nie wprowadzają błędów.
Przykład testu jednostkowego w Pythonie:
import unittest
class TestCalculator(unittest.TestCase):
def test_add(self):
self.assertEqual(add(2, 3), 5)
if __name__ == '__main__':
unittest.main()
Unikaj Hardcodowania Wartości
Nie umieszczaj wartości stałych bezpośrednio w kodzie. Używaj stałych lub plików konfiguracyjnych.
Przykład złego kodu:
public void setLimit() {
int limit = 100; // Hardcoded value
// Code using limit
}
Przykład dobrego kodu:
private static final int USER_LIMIT = 100;
public void setLimit() {
// Code using USER_LIMIT
}
Zasady SOLID
Omówmy teraz na szybko zasady SOLID, które są fundamentem do tworzenia czystego kodu.
S - Single Responsibility Principle
Klasa lub funkcja powinna mieć tylko jedną odpowiedzialność.
Przykład:
Klasa User powinna zarządzać danymi użytkownika, a nie np. połączeniem z bazą danych.
O - Open/Closed Principle
Kod powinien być otwarty na rozszerzenia, ale zamknięty na modyfikacje.
Przykład:
Zamiast modyfikować istniejącą klasę, stwórz klasę dziedziczącą i dodaj nowe funkcjonalności.
L - Liskov Substitution Principle
Obiekty klas pochodnych powinny być wymienialne z obiektami klas bazowych.
I - Interface Segregation Principle
Lepiej mieć wiele specyficznych interfejsów niż jeden ogólny.
D - Dependency Inversion Principle
Moduły wysokiego poziomu nie powinny zależeć od modułów niskiego poziomu.
Podsumowanie
Pamiętaj, że kod piszesz dla ludzi, nie dla maszyn. Pisanie czystego kodu to nie tylko znak profesjonalizmu, ale także inwestycja w przyszłość projektu.
Czystość kodu wpływa na jakość oprogramowania, ułatwia czytanie kodu, jego refaktoryzację i utrzymanie.
Pamiętaj o:
- Dobrym nazewnictwie zmiennych i funkcji.
- Stosowaniu zasad takich jak DRY, KISS, YAGNI.
- Regularnej refaktoryzacji i utrzymaniu spójnego stylu.
- Unikaniu 'śmierdzącego kodu' i nadmiernej złożoności.
- Ciągłym uczeniu się i doskonaleniu swoich umiejętności.
Zacznij już dziś pisać czysty i zrozumiały kod 😉
