Что такое чистый код?

Чистый код (Clean Code)

Чистый код — это хорошо организованный, легко читаемый, понятный и поддерживаемый код, который решает проблему эффективно и безопасно. Это не только о том, что код работает, но и о том, КАК он написан и КАК его поддерживать в будущем.

Принципы чистого кода

1. Понятные имена

Имена переменных, функций и классов должны ясно описывать их назначение:

# Плохо
def calc(d):
    return d * 0.2

# Хорошо
def calculate_discount(price):
    return price * 0.2

# Плохо
x = [1, 2, 3, 4, 5]
for i in x:
    print(i ** 2)

# Хорошо
numbers = [1, 2, 3, 4, 5]
for number in numbers:
    print(number ** 2)

2. Функции должны быть маленькими и иметь одну ответственность

# Плохо — функция делает слишком много
def process_user_data(user_id):
    user = db.query(user_id)
    if not user:
        raise ValueError("User not found")
    user.last_login = datetime.now()
    db.save(user)
    send_email(user.email, "Login notification")
    log_action(user_id, "login")
    update_cache(user_id, user)
    return user

# Хорошо — каждая функция отвечает за одно
def get_user(user_id):
    user = db.query(user_id)
    if not user:
        raise ValueError("User not found")
    return user

def update_last_login(user):
    user.last_login = datetime.now()
    db.save(user)

def notify_login(user):
    send_email(user.email, "Login notification")
    log_action(user.id, "login")

def process_user_login(user_id):
    user = get_user(user_id)
    update_last_login(user)
    notify_login(user)
    update_cache(user_id, user)
    return user

3. Избегай дублирования кода (DRY)

# Плохо — дублирование
def validate_email(email):
    if not email or '@' not in email:
        return False
    return True

def validate_phone(phone):
    if not phone or len(phone) < 10:
        return False
    return True

# Хорошо — реиспользуемая функция
def is_valid(value, validator_func):
    if not value:
        return False
    return validator_func(value)

def has_at_symbol(email):
    return '@' in email

def has_min_length_10(phone):
    return len(phone) >= 10

if is_valid(email, has_at_symbol):
    pass

4. Комментарии должны объяснять ПОЧЕМУ, а не ЧТО

# Плохо
def calc_total(items):
    # Умножаем цену на количество
    total = sum(item.price * item.quantity for item in items)
    # Добавляем налог (20%)
    total = total * 1.2
    return total

# Хорошо
def calculate_total_with_tax(items):
    total = sum(item.price * item.quantity for item in items)
    # Добавляем налог 20% в соответствии с правилами РФ
    tax_rate = 0.2
    return total * (1 + tax_rate)

5. Обработка ошибок

# Плохо
try:
    result = do_something()
except:
    pass  # Игнорируем любые ошибки

# Хорошо
try:
    result = do_something()
except ValueError as e:
    logger.error(f"Invalid input: {e}")
    raise
except ConnectionError as e:
    logger.error(f"Database connection failed: {e}")
    raise

6. Форматирование и структура

# Плохо
def foo(x, y, z, a, b, c):
    d = x * y + z
    e = a + b
    f = d * e
    return f

# Хорошо
def calculate_total_cost(quantity, price, tax_rate, discount_rate):
    subtotal = quantity * price
    tax = subtotal * tax_rate
    discount = subtotal * discount_rate
    total = subtotal + tax - discount
    return total

7. SOLID принципы

# S — Single Responsibility
class UserRepository:
    def get_user(self, user_id):
        pass

class UserEmailNotifier:
    def notify(self, user):
        pass

# O — Open/Closed
class PaymentProcessor:
    def process(self, payment, strategy):
        return strategy.process(payment)

class CreditCardStrategy:
    def process(self, payment):
        pass

class PayPalStrategy:
    def process(self, payment):
        pass

# L — Liskov Substitution
class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof"

# I — Interface Segregation
class Reader:
    def read(self):
        pass

class Writer:
    def write(self, data):
        pass

# D — Dependency Inversion
class UserService:
    def __init__(self, repository):
        self.repository = repository
    
    def get_user(self, user_id):
        return self.repository.get_user(user_id)

8. Тесты

# Чистый код должен быть легко тестируемым
def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

9. Типизация

# Плохо — неясно, какие типы принимает функция
def process(data):
    return data.upper()

# Хорошо — ясно, какие типы и что возвращает
from typing import List, Dict

def process(text: str) -> str:
    return text.upper()

def process_items(items: List[Dict[str, int]]) -> int:
    return sum(item['value'] for item in items)

Признаки нечистого кода

• Длинные функции (более 30 строк)
• Функции с множеством параметров (более 3-4)
• Вложенность более 3 уровней
• Дублирование кода
• Отсутствие типизации
• Плохие имена переменных
• Отсутствие или неправильная обработка ошибок
• Код без тестов
• Magic numbers и string константы
• Побочные эффекты в неожиданных местах

Инструменты для проверки чистоты кода

• pylint — статический анализ
• flake8 — проверка стиля
• black — автоматическое форматирование
• mypy — проверка типов
• pytest — тестирование
• coverage — покрытие тестами

Выводы

Чистый код:

• Легче читать и понимать
• Проще поддерживать и модифицировать
• Содержит меньше ошибок
• Проще тестировать
• Быстрее разрабатывается в долгосрочной перспективе

Книга "Clean Code" Роберта Мартина — обязательное чтение для профессионального разработчика. Чистый код — это не просто красивый код, это уважение к тем, кто будет его поддерживать.