green leafed plant on clear glass vase filled with water

Czysty kod: Klucz do lepszego programowania

Mariusz Jurczenko Mariusz Jurczenko

Co to jest czysty kod?

Czysty kod to termin, który odnosi się do praktyk programistycznych, w których kod źródłowy jest napisany w sposób zrozumiały i łatwy do utrzymania. Kluczowym celem czystego kodu jest jego czytelność, co pozwala innym programistom na łatwe zrozumienie go oraz jego modyfikacje w przyszłości. W prostej definicji, czysty kod powinien być nie tylko funkcjonalny, ale także estetycznie zorganizowany, co znacznie ułatwia pracę zespołową oraz zmniejsza ryzyko wprowadzenia błędów.

Istnieje kilka fundamentalnych cech czystego kodu, które powinny być brane pod uwagę. Po pierwsze, struktura kodu powinna być przejrzysta i logiczna. Kod powinien być podzielony na mniejsze funkcje lub klasy, które realizują dobrze zdefiniowane zadania. Dzięki temu, inni programiści mogą go łatwiej analizować. Po drugie, nazwy zmiennych, funkcji oraz klas powinny być opisowe, co zwiększa ich zrozumiałość. Dobrym przykładem jest unikanie stosowania skrótów, które mogą być mylące dla osób nieznających kontekstu.

Czysty kod ma również istotny wpływ na długofalowy rozwój projektu programistycznego. Główną zaletą takiego podejścia jest ułatwienie współpracy pomiędzy różnymi programistami. W zespołach, gdzie kod jest czysty i zrozumiały, programiści mogą szybciej odnajdywać się w projektach, co przyspiesza proces developmentu i umożliwia skuteczniejsze zarządzanie zmianami. W związku z tym, inwestycja w czysty kod jest nie tylko korzystna, ale wręcz niezbędna dla osiągnięcia sukcesu w długoterminowych projektach programistycznych.

Zasady czystego kodu według Roberta C. Martina

Jednoznaczność jest jedną z fundamentalnych zasad czystego kodu, która polega na tym, że kod powinien być łatwy do zrozumienia dla każdego, kto go czyta. Osiąga się to poprzez stosowanie jasnych nazw zmiennych oraz funkcji, które odzwierciedlają ich przeznaczenie. Dzięki jednoznaczności programiści mogą szybciej analizować i modyfikować kod, minimalizując ryzyko wprowadzenia błędów podczas pracy nad projektem.

Unikanie powtórzeń, znane również jako zasada DRY (Don’t Repeat Yourself), zachęca do redukcji duplikacji w kodzie. Powtarzające się fragmenty kodu mogą prowadzić do trudności w jego utrzymywaniu i testowaniu. Stosując techniki abstrahowania i refaktoryzacji, programiści mogą eliminować powtórzenia, co z kolei zwiększa przejrzystość oraz ułatwia aktualizowanie i rozwijanie aplikacji.

Kolejną zasadą jest pojedyncza odpowiedzialność, która określa, że każda klasa lub funkcja powinny odpowiadać za jeden aspekt działania programu. Takie podejście ułatwia zarządzanie kodem, sprawia, że staje się on bardziej modularny i łatwiejszy do testowania. Dzięki temu możliwe jest szybsze zlokalizowanie oraz naprawa błędów, co przyczynia się do efektywności procesu programowania.

Czytelność kodu to kolejny istotny element czystego kodu. Właściwe formatowanie, stosowanie odpowiednich przerw między fragmentami kodu oraz strukturalne podejście do organizacji kodu poprawia jego czytelność. Ostatecznie, testowanie jest kluczowym aspektem, który zapewnia, że kod działa zgodnie z założeniami. Dzięki regularnemu testowaniu, programiści mogą szybko wychwycić i naprawić ewentualne błędy, co wpływa na jakość oprogramowania.

Korzyści płynące z pisania czystego kodu

Pisanie czystego kodu niesie ze sobą wiele korzyści, które wpływają na efektywność zespołów programistycznych, redukcję kosztów oraz jakość końcowego produktu. Po pierwsze, czysty kod jest znacznie łatwiejszy do zrozumienia, co sprzyja lepszej komunikacji w zespole. Gdy kod jest dobrze zorganizowany i przestrzega zasad programowania, nowe osoby, które dołączają do projektu, mogą znacznie szybciej rozpocząć pracę. W konsekwencji, obniża to czas potrzebny na onboardowanie i ułatwia współpracę między programistami.

Drugą istotną korzyścią jest redukcja kosztów utrzymania. Kod, który jest czysty i dobrze udokumentowany, zwiększa możliwość łatwego wprowadzania zmian i poprawek. W miarę jak projekt się rozwija, istnieje większe prawdopodobieństwo, że nieprzewidziane problemy z kodem zostaną zminimalizowane dzięki jego odpowiedniej strukturyzacji. Ponadto, czysty kod pozwala na szybsze identyfikowanie błędów, co nie tylko zwiększa produktywność, ale również obniża koszty związane z debugowaniem.

Ostatecznie, czysty kod ma bezpośredni wpływ na jakość końcowego produktu. Ułatwienie implementacji nowych funkcji i poprawek w istniejącym projekcie prowadzi do bardziej bezawaryjnych i niezawodnych aplikacji. Przy odpowiedniej dbałości o czystość kodu, można także osiągnąć lepszą wydajność, co z kolei przekłada się na większą satysfakcję użytkowników końcowych. Przykłady z praktyki pokazują, że zespoły stosujące zasady czystego kodu nie tylko osiągają lepsze wyniki, ale również przyspieszają czas realizacji projektów. Praktyki te są niezbędne dla osiągnięcia sukcesu w dzisiejszym dynamicznym środowisku programistycznym.

Jak rozpocząć pisanie czystego kodu?

Pisanie czystego kodu to praktyka, która może znacznie poprawić jakość projektów programistycznych oraz ułatwić ich rozwój i utrzymanie. Aby rozpocząć tę podróż, warto zwrócić uwagę na kilka kluczowych technik oraz narzędzi, które pomogą w wdrożeniu zasad dobrego programowania.

Najważniejszym krokiem jest zrozumienie podstawowych zasad czystego kodu, takich jak zasada jednej odpowiedzialności, które optymalizuje strukturę aplikacji. Dobrym sposobem na wdrożenie tych zasad jest korzystanie z praktyki TDD (Test-Driven Development), która pozwala na pisanie testów przed zaimplementowaniem kodu. W ten sposób zapewniamy, że kod będzie nie tylko czysty, ale również funkcjonalny.

Innym użytecznym narzędziem są linters, które analizują kod pod kątem stylu i potrafią wychwycić nieczytelne fragmenty. Przykłady popularnych linters to ESLint dla JavaScriptu czy Pylint dla Pythona. Korzystanie z tych narzędzi z pewnością podniesie jakość kodu, eliminując błędy i niejednoznaczności. Warto również korzystać z automatyzacji procesu budowania i wdrażania (CI/CD), co znacząco przyspieszy cykl życia aplikacji.

Pisać czysty kod oznacza także stosowanie przejrzystych nazw zmiennych, które odzwierciedlają ich zawartość oraz funkcję. Używanie odpowiednich dokumentacji i komentarzy, ale z umiarem, pozwala innym programistom łatwiej zrozumieć zamierzenia twórcy. Przykłady dobrze napisanych fragmentów kodu, które kładą nacisk na czytelność, mogą znacząco wpłynąć na edukację zespołu oraz poprawić współpracę.

Inwestowanie czasu w naukę i stosowanie tych technik przynosi długofalowe korzyści oraz pozwala na tworzenie bardziej solidnych, łatwiejszych w utrzymaniu i rozszerzanych aplikacji.

Przykład: Prosta aplikacja do zarządzania użytkownikami

Wyobraźmy sobie, że piszemy aplikację do zarządzania użytkownikami w systemie.
Chcemy, aby nasz kod był czytelny, łatwy do rozszerzenia i utrzymania.

Zasady czystego kodu zastosowane w przykładzie:

  1. Jasne nazewnictwo – Nazwy zmiennych, metod i klas są opisowe i mówią, co robią.
  2. Enkapsulacja i separacja odpowiedzialności – Każda klasa i metoda ma jedną, wyraźną odpowiedzialność.
  3. Unikanie kodu “martwego” i powtarzania się – Usunięcie niepotrzebnych linijek kodu i unikanie duplikacji.
  4. Stosowanie wyraźnych zależności – Klasy jasno mówią, jakie mają zależności.

Kod C#: Przykład zarządzania użytkownikami

1. Klasa User – Reprezentacja użytkownika

public class User
{
    public int Id { get; private set; }
    public string Name { get; private set; }
    public string Email { get; private set; }

    public User(int id, string name, string email)
    {
        Id = id;
        Name = name ?? throw new ArgumentNullException(nameof(name), "Name cannot be null");
        Email = email ?? throw new ArgumentNullException(nameof(email), "Email cannot be null");
    }

    public void UpdateEmail(string newEmail)
    {
        if (string.IsNullOrWhiteSpace(newEmail))
            throw new ArgumentException("Email cannot be empty", nameof(newEmail));

        Email = newEmail;
    }
}

Wyjaśnienie:

  • Reprezentuje użytkownika w systemie i zawiera trzy właściwości: Id (unikalny identyfikator), Name (imię i nazwisko) oraz Email.
  • Konstruktor klasy User wymaga podania id, name i email oraz sprawdza, czy name i email nie są puste, aby uniknąć niepoprawnych danych.
  • Metoda UpdateEmail pozwala na zmianę adresu e-mail użytkownika po sprawdzeniu, czy nowy e-mail nie jest pusty lub tylko białymi znakami.

2. Interfejs IUserRepository – Abstrakcja repozytorium dla operacji na użytkownikach

public interface IUserRepository
{
    void AddUser(User user);
    User GetUserById(int id);
    void RemoveUser(int id);
    void UpdateUser(User user);
}

Wyjaśnienie:

  • Interfejs IUserRepository definiuje kontrakt dla operacji na danych użytkowników. Wymusza implementację metod AddUser (dodanie nowego użytkownika), GetUserById (wyszukanie użytkownika po identyfikatorze), RemoveUser (usunięcie użytkownika) oraz UpdateUser (zaktualizowanie danych użytkownika).
  • Interfejs IUserRepository definiuje tylko to, co jest niezbędne do zarządzania użytkownikami, co sprawia, że kod jest bardziej elastyczny i testowalny.

3. Klasa UserRepository – Implementacja repozytorium użytkowników

public class UserRepository : IUserRepository
{
    private readonly List<User> _users = new List<User>();

    public void AddUser(User user)
    {
        if (user == null) throw new ArgumentNullException(nameof(user));
        _users.Add(user);
    }

    public User GetUserById(int id)
    {
        return _users.FirstOrDefault(u => u.Id == id) ?? throw new KeyNotFoundException("User not found");
    }

    public void RemoveUser(int id)
    {
        var user = GetUserById(id);
        _users.Remove(user);
    }

    public void UpdateUser(User user)
    {
        var existingUser = GetUserById(user.Id);
        existingUser.UpdateEmail(user.Email);
    }
}

Wyjaśnienie:

  • Klasa UserRepository implementuje IUserRepository i przechowuje użytkowników w pamięci przy użyciu listy List<User> _users. W rzeczywistych aplikacjach ten kod może być łatwo zastąpiony repozytorium z bazą danych.
  • Każda metoda wykonuje odpowiednie operacje na liście użytkowników:
  • AddUser dodaje użytkownika do listy.
  • GetUserById zwraca użytkownika o określonym id lub wyrzuca wyjątek, jeśli użytkownik nie istnieje.
  • RemoveUser usuwa użytkownika z listy.
  • UpdateUser jest uproszczoną metodą, która pozwala na zapisanie aktualizacji, np. zmiany adresu e-mail, gdy jest taka potrzeba.

4. Interfejs IUserService

public interface IUserService
{
    void RegisterUser(int id, string name, string email);
    void UpdateUserEmail(int id, string newEmail);
}

Interfejs IUserService definiuje logikę aplikacji dla operacji na użytkownikach. Wymaga implementacji metod RegisterUser (dodanie nowego użytkownika) oraz UpdateUserEmail (aktualizacja adresu e-mail).

5. Klasa UserService – Usługa biznesowa do zarządzania użytkownikami

public class UserService
{
    private readonly IUserRepository _userRepository;

    public UserService(IUserRepository userRepository)
    {
        _userRepository = userRepository ?? throw new ArgumentNullException(nameof(userRepository));
    }

    public void RegisterUser(int id, string name, string email)
    {
        var user = new User(id, name, email);
        _userRepository.AddUser(user);
    }

    public void UpdateUserEmail(int id, string newEmail)
    {
        var user = _userRepository.GetUserById(id);
        user.UpdateEmail(newEmail);
        _userRepository.UpdateUser(user);
    }
}

Wyjaśnienie:

Klasa UserService implementuje IUserService i zarządza logiką biznesową:

  • RegisterUser tworzy nowy obiekt User i dodaje go do repozytorium.
  • UpdateUserEmail najpierw pobiera użytkownika z repozytorium, następnie aktualizuje jego adres e-mail i zapisuje zmiany poprzez metodę UpdateUser w repozytorium.

UserService korzysta z repozytorium, więc wymaga jego instancji (IUserRepository). Dzięki interfejsowi IUserService możemy używać różnych implementacji UserService, co ułatwia testowanie oraz ewentualne rozszerzenia aplikacji.

6. Testowanie kodu (np. xUnit)

Testy jednostkowe dla UserService

W testach UserService użyjemy Moq, aby zasymulować IUserRepository.

using Moq;
using Xunit;

public class UserServiceTests
{
    [Fact]
    public void RegisterUser_ShouldAddUserToRepository()
    {
        // Arrange
        var mockRepo = new Mock<IUserRepository>();
        var userService = new UserService(mockRepo.Object);

        // Act
        userService.RegisterUser(1, "Jan Kowalski", "jan.kowalski@example.com");

        // Assert
        mockRepo.Verify(repo => repo.AddUser(It.Is<User>(u => 
            u.Id == 1 && u.Name == "Jan Kowalski" && u.Email == "jan.kowalski@example.com")), Times.Once);
    }

    [Fact]
    public void UpdateUserEmail_ShouldUpdateUserEmailInRepository()
    {
        // Arrange
        var mockRepo = new Mock<IUserRepository>();
        var user = new User(1, "Jan Kowalski", "jan.kowalski@example.com");
        mockRepo.Setup(repo => repo.GetUserById(1)).Returns(user);
        
        var userService = new UserService(mockRepo.Object);

        // Act
        userService.UpdateUserEmail(1, "jan.nowy@example.com");

        // Assert
        Assert.Equal("jan.nowy@example.com", user.Email);
        mockRepo.Verify(repo => repo.UpdateUser(user), Times.Once);
    }

    [Fact]
    public void UpdateUserEmail_ShouldThrowException_WhenUserNotFound()
    {
        // Arrange
        var mockRepo = new Mock<IUserRepository>();
        mockRepo.Setup(repo => repo.GetUserById(1)).Throws(new KeyNotFoundException("User not found"));
        
        var userService = new UserService(mockRepo.Object);

        // Act & Assert
        Assert.Throws<KeyNotFoundException>(() => userService.UpdateUserEmail(1, "jan.nowy@example.com"));
    }
}

Wyjaśnienia

  1. RegisterUser_ShouldAddUserToRepository – Testuje, czy metoda RegisterUser poprawnie dodaje użytkownika do repozytorium.
    • Tworzymy atrapę (mockRepo) dla IUserRepository.
    • Sprawdzamy, czy AddUser zostało wywołane z użytkownikiem o oczekiwanych wartościach.
  2. UpdateUserEmail_ShouldUpdateUserEmailInRepository – Testuje, czy UpdateUserEmail aktualizuje adres e-mail użytkownika.
    • Symulujemy, że metoda GetUserById repozytorium zwraca istniejącego użytkownika.
    • Wywołujemy UpdateUserEmail i sprawdzamy, czy adres e-mail został zmieniony oraz czy UpdateUser w repozytorium został wywołany raz.
  3. UpdateUserEmail_ShouldThrowException_WhenUserNotFound – Testuje, czy metoda UpdateUserEmail rzuca wyjątek, gdy użytkownik nie zostanie znaleziony.
    • Ustawiamy atrapę repozytorium, aby rzuciła wyjątek KeyNotFoundException dla nieistniejącego użytkownika.
    • Sprawdzamy, czy wywołanie UpdateUserEmail rzuca ten sam wyjątek.
Testy jednostkowe dla UserRepository

Poniższe testy dla UserRepository testują operacje na danych przechowywanych w pamięci.

using Xunit;

public class UserRepositoryTests
{
    [Fact]
    public void AddUser_ShouldAddUserToList()
    {
        // Arrange
        var userRepository = new UserRepository();
        var user = new User(1, "Jan Kowalski", "jan.kowalski@example.com");

        // Act
        userRepository.AddUser(user);

        // Assert
        var result = userRepository.GetUserById(1);
        Assert.Equal(user, result);
    }

    [Fact]
    public void GetUserById_ShouldReturnUser_WhenUserExists()
    {
        // Arrange
        var userRepository = new UserRepository();
        var user = new User(1, "Jan Kowalski", "jan.kowalski@example.com");
        userRepository.AddUser(user);

        // Act
        var result = userRepository.GetUserById(1);

        // Assert
        Assert.Equal(user, result);
    }

    [Fact]
    public void GetUserById_ShouldThrowException_WhenUserDoesNotExist()
    {
        // Arrange
        var userRepository = new UserRepository();

        // Act & Assert
        Assert.Throws<KeyNotFoundException>(() => userRepository.GetUserById(1));
    }

    [Fact]
    public void UpdateUser_ShouldUpdateUserInList()
    {
        // Arrange
        var userRepository = new UserRepository();
        var user = new User(1, "Jan Kowalski", "jan.kowalski@example.com");
        userRepository.AddUser(user);

        // Act
        user.UpdateEmail("jan.nowy@example.com");
        userRepository.UpdateUser(user);

        // Assert
        var result = userRepository.GetUserById(1);
        Assert.Equal("jan.nowy@example.com", result.Email);
    }

    [Fact]
    public void RemoveUser_ShouldRemoveUserFromList()
    {
        // Arrange
        var userRepository = new UserRepository();
        var user = new User(1, "Jan Kowalski", "jan.kowalski@example.com");
        userRepository.AddUser(user);

        // Act
        userRepository.RemoveUser(1);

        // Assert
        Assert.Throws<KeyNotFoundException>(() => userRepository.GetUserById(1));
    }
}

Wyjaśnienia do testów UserRepository

  1. AddUser_ShouldAddUserToList – Testuje, czy metoda AddUser poprawnie dodaje użytkownika do listy.
  2. GetUserById_ShouldReturnUser_WhenUserExists – Sprawdza, czy GetUserById zwraca prawidłowego użytkownika, gdy istnieje w repozytorium.
  3. GetUserById_ShouldThrowException_WhenUserDoesNotExist – Sprawdza, czy GetUserById rzuca wyjątek KeyNotFoundException, gdy użytkownik nie istnieje.
  4. UpdateUser_ShouldUpdateUserInList – Testuje, czy UpdateUser prawidłowo aktualizuje dane użytkownika.
  5. RemoveUser_ShouldRemoveUserFromList – Testuje, czy RemoveUser usuwa użytkownika z listy i czy próba uzyskania dostępu do niego generuje wyjątek KeyNotFoundException.

7. Klasa Program.cs (aplikacja konsolowa)

using System;

namespace UserManagementApp
{
    class Program
    {
        static void Main(string[] args)
        {
            // Inicjalizacja repozytorium i serwisu
            IUserRepository userRepository = new UserRepository();
            IUserService userService = new UserService(userRepository);

            // Dodanie użytkownika
            Console.WriteLine("Dodawanie użytkownika...");
            userService.RegisterUser(1, "Jan Kowalski", "jan.kowalski@example.com");

            // Pobranie i wyświetlenie dodanego użytkownika
            var user = userRepository.GetUserById(1);
            Console.WriteLine($"Użytkownik dodany: {user.Name}, Email: {user.Email}");

            // Aktualizacja adresu email
            Console.WriteLine("Aktualizacja adresu email...");
            userService.UpdateUserEmail(1, "jan.nowy@example.com");

            // Pobranie i wyświetlenie zaktualizowanego użytkownika
            user = userRepository.GetUserById(1);
            Console.WriteLine($"Zaktualizowany użytkownik: {user.Name}, Email: {user.Email}");
        }
    }
}

Opis działania

  1. User – klasa reprezentująca użytkownika, zawierająca pola Id, Name i Email, oraz metodę UpdateEmail, która aktualizuje adres e-mail z odpowiednimi walidacjami.
  2. IUserRepository i UserRepository – interfejs i implementacja repozytorium dla zarządzania użytkownikami, przechowywanymi w pamięci aplikacji.
  3. IUserService i UserService – interfejs i implementacja warstwy serwisowej, która zarządza logiką biznesową dla operacji na użytkownikach, w tym rejestracją i aktualizacją adresu e-mail.
  4. Program.cs – kod główny aplikacji konsolowej, który inicjalizuje repozytorium i serwis, a następnie wykonuje dodawanie i aktualizację użytkownika, prezentując wyniki w konsoli.

Przykładowy wynik działania

Dodawanie użytkownika...
Użytkownik dodany: Jan Kowalski, Email: jan.kowalski@example.com
Aktualizacja adresu email...
Zaktualizowany użytkownik: Jan Kowalski, Email: jan.nowy@example.com

Podsumowanie

Ten kod pokazuje, jak stosować zasady czystego kodu:

  • Klarowne nazwy, które pomagają zrozumieć, co robi dana klasa lub metoda.
  • Małe klasy i metody z pojedynczą odpowiedzialnością, co ułatwia zarządzanie kodem.
  • Enkapsulacja logiki biznesowej w serwisach (UserService) oraz zarządzanie danymi w repozytorium (UserRepository).

Mam nadzieję, że ten przykład pomoże w lepszym zrozumieniu zasad czystego kodu w praktyce! Ten kod jest zgodny z zasadami czystego kodu, umożliwia testowanie i łatwość rozbudowy. W przyszłości repozytorium można z łatwością rozszerzyć o funkcję Save dla trwałych magazynów danych, np. baz danych.

Dodaj komentarz

Twój adres e-mail nie zostanie opublikowany. Wymagane pola są oznaczone *