Clean Code

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 잘못된 예시 ❌
d = []  # 무엇을 담는 리스트인지 알 수 없음
u = get_user()  # 사용자 정보의 어떤 부분인지 불명확

def get_them(list1):
    result = []
    for x in list1:
        if x[0] == 4:
            result.append(x)
    return result

# 올바른 예시 ✅
flagged_cells = []  # 플래그된 셀들을 담는 리스트
current_user = get_user()  # 현재 사용자 정보

def get_flagged_cells(game_board):
    """게임 보드에서 플래그된 셀들을 반환"""
    flagged_cells = []
    for cell in game_board:
        if cell[STATUS_VALUE] == FLAGGED:
            flagged_cells.append(cell)
    return flagged_cells

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 잘못된 예시 ❌
def process_user_data(user_id, name, email, age, send_email=True):
    """여러 가지 일을 동시에 수행하는 함수"""
    # 사용자 데이터 검증
    if not email or '@' not in email:
        raise ValueError("Invalid email")
    
    # 데이터베이스에 저장
    user = User(user_id, name, email, age)
    database.save(user)
    
    # 이메일 발송
    if send_email:
        email_service.send_welcome_email(email)
    
    # 로그 기록
    logger.info(f"User {name} created")
    
    return user

# 올바른 예시 ✅
def validate_email(email):
    """이메일 유효성 검증"""
    if not email or '@' not in email:
        raise ValueError("Invalid email")

def create_user(user_data):
    """사용자 생성"""
    validate_email(user_data.email)
    user = User(user_data.id, user_data.name, user_data.email, user_data.age)
    return database.save(user)

def send_welcome_notification(user):
    """환영 알림 발송"""
    email_service.send_welcome_email(user.email)
    logger.info(f"User {user.name} created")

# 사용법
user_data = UserData(id=1, name="John", email="john@example.com", age=30)
new_user = create_user(user_data)
send_welcome_notification(new_user)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# 잘못된 주석 사용 ❌
def calculate_price(items):
    # 총합을 0으로 초기화
    total = 0
    
    # 각 아이템에 대해 반복
    for item in items:
        # 가격에 수량을 곱함
        total += item.price * item.quantity
    
    # 세금 계산 (10%)
    tax = total * 0.1
    
    # 총합에 세금 추가
    return total + tax

# 올바른 주석 사용 ✅
def calculate_price_with_tax(items):
    """
    아이템 목록의 총 가격을 세금 포함하여 계산
    
    Args:
        items: 가격과 수량 정보를 가진 아이템 목록
    
    Returns:
        세금이 포함된 총 가격
    """
    subtotal = sum(item.price * item.quantity for item in items)
    
    # 비즈니스 규칙: 현재 세율은 10%이며, 정부 정책에 따라 변경될 수 있음
    TAX_RATE = 0.1
    tax = subtotal * TAX_RATE
    
    return subtotal + tax

def get_user_discount(user):
    """사용자 할인율 계산"""
    # TODO: 추후 VIP 등급 시스템 도입 시 할인 로직 확장 예정
    if user.is_premium:
        return 0.15  # 프리미엄 사용자 15% 할인
    return 0.0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

# 잘못된 예시 ❌
class UserService:
    def create_admin_user(self, name, email):
        if not email or '@' not in email:
            raise ValueError("Invalid email format")
        if len(name) < 2:
            raise ValueError("Name too short")
        
        user = {
            'id': self.generate_id(),
            'name': name,
            'email': email,
            'role': 'admin',
            'created_at': datetime.now(),
            'is_active': True
        }
        return self.database.save(user)
    
    def create_regular_user(self, name, email):
        if not email or '@' not in email:
            raise ValueError("Invalid email format")
        if len(name) < 2:
            raise ValueError("Name too short")
        
        user = {
            'id': self.generate_id(),
            'name': name,
            'email': email,
            'role': 'user',
            'created_at': datetime.now(),
            'is_active': True
        }
        return self.database.save(user)

# 올바른 예시 ✅
class UserService:
    MIN_NAME_LENGTH = 2
    
    def _validate_user_data(self, name, email):
        """사용자 데이터 유효성 검증"""
        if not email or '@' not in email:
            raise ValueError("Invalid email format")
        if len(name) < self.MIN_NAME_LENGTH:
            raise ValueError(f"Name must be at least {self.MIN_NAME_LENGTH} characters")
    
    def _create_user_dict(self, name, email, role):
        """사용자 딕셔너리 생성"""
        return {
            'id': self.generate_id(),
            'name': name,
            'email': email,
            'role': role,
            'created_at': datetime.now(),
            'is_active': True
        }
    
    def create_user(self, name, email, role='user'):
        """사용자 생성 (역할 지정 가능)"""
        self._validate_user_data(name, email)
        user = self._create_user_dict(name, email, role)
        return self.database.save(user)
    
    def create_admin_user(self, name, email):
        """관리자 사용자 생성"""
        return self.create_user(name, email, 'admin')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

# 잘못된 예시 ❌
def withdraw_money(account_id, amount):
    account = get_account(account_id)
    if account is None:
        return None  # 오류 상황이 명확하지 않음
    
    if account.balance < amount:
        return -1  # 매직 넘버 사용
    
    account.balance -= amount
    return account.balance

# 올바른 예시 ✅
class InsufficientFundsError(Exception):
    """잔액 부족 예외"""
    def __init__(self, requested_amount, available_balance):
        self.requested_amount = requested_amount
        self.available_balance = available_balance
        super().__init__(
            f"Insufficient funds: requested {requested_amount}, "
            f"but only {available_balance} available"
        )

class AccountNotFoundError(Exception):
    """계좌를 찾을 수 없음 예외"""
    def __init__(self, account_id):
        self.account_id = account_id
        super().__init__(f"Account not found: {account_id}")

def withdraw_money(account_id, amount):
    """
    계좌에서 돈을 인출
    
    Args:
        account_id: 계좌 ID
        amount: 인출할 금액
    
    Returns:
        인출 후 잔액
    
    Raises:
        AccountNotFoundError: 계좌를 찾을 수 없는 경우
        InsufficientFundsError: 잔액이 부족한 경우
        ValueError: 인출 금액이 0 이하인 경우
    """
    if amount <= 0:
        raise ValueError("Withdrawal amount must be positive")
    
    account = get_account(account_id)
    if account is None:
        raise AccountNotFoundError(account_id)
    
    if account.balance < amount:
        raise InsufficientFundsError(amount, account.balance)
    
    account.balance -= amount
    save_account(account)
    
    return account.balance

# 사용 예시
try:
    new_balance = withdraw_money("ACC123", 1000)
    print(f"Withdrawal successful. New balance: {new_balance}")
except AccountNotFoundError as e:
    print(f"Error: {e}")
    # 계좌 생성 안내 등…
except InsufficientFundsError as e:
    print(f"Error: {e}")
    # 충전 안내 등…
except ValueError as e:
    print(f"Invalid input: {e}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

# 잘못된 예시 ❌
class User:
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.created_at = datetime.now()
    
    def save_to_database(self):
        # 데이터베이스 저장 로직
        pass
    
    def send_welcome_email(self):
        # 이메일 발송 로직
        pass
    
    def generate_report(self):
        # 리포트 생성 로직
        pass
    
    def validate_email(self):
        # 이메일 검증 로직
        pass

# 올바른 예시 ✅
class User:
    """사용자 도메인 객체"""
    def __init__(self, name, email):
        self.name = name
        self.email = email
        self.created_at = datetime.now()
    
    def get_display_name(self):
        return self.name.title()
    
    def is_recently_created(self, days=7):
        return (datetime.now() - self.created_at).days <= days

class EmailValidator:
    """이메일 검증 전담 클래스"""
    @staticmethod
    def is_valid(email):
        return email and '@' in email and '.' in email.split('@')[1]
    
    @staticmethod
    def validate(email):
        if not EmailValidator.is_valid(email):
            raise ValueError(f"Invalid email format: {email}")

class UserRepository:
    """사용자 데이터 저장/조회 전담 클래스"""
    def __init__(self, database):
        self.database = database
    
    def save(self, user):
        return self.database.insert('users', {
            'name': user.name,
            'email': user.email,
            'created_at': user.created_at
        })
    
    def find_by_email(self, email):
        data = self.database.query('users', {'email': email})
        return User(data['name'], data['email']) if data else None

class NotificationService:
    """알림 발송 전담 클래스"""
    def __init__(self, email_client):
        self.email_client = email_client
    
    def send_welcome_email(self, user):
        subject = f"Welcome, {user.get_display_name()}!"
        body = f"Thank you for joining us, {user.name}!"
        self.email_client.send(user.email, subject, body)

class UserService:
    """사용자 관련 비즈니스 로직 조정"""
    def __init__(self, user_repository, notification_service):
        self.user_repository = user_repository
        self.notification_service = notification_service
    
    def create_user(self, name, email):
        EmailValidator.validate(email)
        
        user = User(name, email)
        saved_user = self.user_repository.save(user)
        
        self.notification_service.send_welcome_email(saved_user)
        
        return saved_user

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

# 잘못된 예시 ❌ - 테스트하기 어려운 코드
import requests
from datetime import datetime

class WeatherService:
    def get_current_temperature(self, city):
        # 외부 API 직접 호출 - 테스트 시 실제 API 요청 발생
        response = requests.get(f"http://api.weather.com/current/{city}")
        data = response.json()
        
        # 현재 시간 직접 사용 - 테스트 시 시간에 따라 결과 달라짐
        current_hour = datetime.now().hour
        
        # 파일에 직접 로그 기록 - 테스트 시 실제 파일 생성
        with open('weather.log', 'a') as f:
            f.write(f"{datetime.now()}: Temperature for {city}: {data['temp']}\n")
        
        return data['temp']

# 올바른 예시 ✅ - 테스트 가능한 코드
from abc import ABC, abstractmethod
from datetime import datetime

class WeatherAPIClient(ABC):
    @abstractmethod
    def get_weather_data(self, city):
        pass

class HttpWeatherAPIClient(WeatherAPIClient):
    def __init__(self, http_client):
        self.http_client = http_client
    
    def get_weather_data(self, city):
        response = self.http_client.get(f"http://api.weather.com/current/{city}")
        return response.json()

class Logger(ABC):
    @abstractmethod
    def log(self, message):
        pass

class FileLogger(Logger):
    def __init__(self, filename):
        self.filename = filename
    
    def log(self, message):
        with open(self.filename, 'a') as f:
            f.write(f"{datetime.now()}: {message}\n")

class TimeProvider(ABC):
    @abstractmethod
    def now(self):
        pass

class SystemTimeProvider(TimeProvider):
    def now(self):
        return datetime.now()

class WeatherService:
    def __init__(self, weather_client, logger, time_provider):
        self.weather_client = weather_client
        self.logger = logger
        self.time_provider = time_provider
    
    def get_current_temperature(self, city):
        weather_data = self.weather_client.get_weather_data(city)
        temperature = weather_data['temp']
        
        current_time = self.time_provider.now()
        self.logger.log(f"Temperature for {city}: {temperature}")
        
        return temperature
    
    def is_good_time_for_outdoor_activity(self, city):
        """야외 활동하기 좋은 시간인지 판단"""
        temperature = self.get_current_temperature(city)
        current_hour = self.time_provider.now().hour
        
        # 비즈니스 로직: 온도 15-25도, 시간 9-18시가 적합
        return 15 <= temperature <= 25 and 9 <= current_hour <= 18

# 테스트 코드 예시
import unittest
from unittest.mock import Mock

class TestWeatherService(unittest.TestCase):
    def setUp(self):
        self.mock_weather_client = Mock(spec=WeatherAPIClient)
        self.mock_logger = Mock(spec=Logger)
        self.mock_time_provider = Mock(spec=TimeProvider)
        
        self.weather_service = WeatherService(
            self.mock_weather_client,
            self.mock_logger,
            self.mock_time_provider
        )
    
    def test_get_current_temperature(self):
        # Given
        self.mock_weather_client.get_weather_data.return_value = {'temp': 20}
        
        # When
        temperature = self.weather_service.get_current_temperature('Seoul')
        
        # Then
        self.assertEqual(temperature, 20)
        self.mock_weather_client.get_weather_data.assert_called_once_with('Seoul')
        self.mock_logger.log.assert_called_once()
    
    def test_is_good_time_for_outdoor_activity_when_conditions_perfect(self):
        # Given
        self.mock_weather_client.get_weather_data.return_value = {'temp': 20}
        mock_time = Mock()
        mock_time.hour = 14  # 오후 2시
        self.mock_time_provider.now.return_value = mock_time
        
        # When
        result = self.weather_service.is_good_time_for_outdoor_activity('Seoul')
        
        # Then
        self.assertTrue(result)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

# 성능과 가독성의 균형 ✅
class UserService:
    def __init__(self):
        self._user_cache = {}  # 간단한 캐싱
    
    def get_user_by_email(self, email):
        """이메일로 사용자 조회 (캐시 활용)"""
        if email in self._user_cache:
            return self._user_cache[email]
        
        user = self._fetch_user_from_database(email)
        if user:
            self._user_cache[email] = user
        
        return user
    
    def get_active_users_by_department(self, department_ids):
        """부서별 활성 사용자 조회 (배치 처리)"""
        # 여러 번의 개별 쿼리 대신 한 번의 배치 쿼리 사용
        query = """
            SELECT * FROM users 
            WHERE department_id IN %s 
            AND is_active = true
            ORDER BY department_id, name
        """
        
        users = self.database.fetch_all(query, (tuple(department_ids),))
        
        # 부서별로 그룹화하여 반환
        from collections import defaultdict
        users_by_dept = defaultdict(list)
        
        for user in users:
            users_by_dept[user['department_id']].append(user)
        
        return dict(users_by_dept)
    
    def process_large_user_list(self, user_data_list):
        """대용량 사용자 데이터 처리 (제너레이터 활용)"""
        def validate_and_transform_users():
            for user_data in user_data_list:
                if self._is_valid_user_data(user_data):
                    yield self._transform_user_data(user_data)
        
        # 메모리 효율적인 배치 처리
        batch_size = 1000
        batch = []
        
        for user in validate_and_transform_users():
            batch.append(user)
            
            if len(batch) >= batch_size:
                self._save_user_batch(batch)
                batch = []
        
        # 마지막 배치 처리
        if batch:
            self._save_user_batch(batch)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// 좋은 예: 적절한 줄 바꿈과 들여쓰기
public class UserService {
    private final UserRepository userRepository;
    private final EmailService emailService;
    
    public UserService(UserRepository userRepository, EmailService emailService) {
        this.userRepository = userRepository;
        this.emailService = emailService;
    }
    
    public User registerUser(String username, String email, String password) {
        validateUserInput(username, email, password);
        User user = new User(username, email, password);
        userRepository.save(user);
        emailService.sendWelcomeEmail(user);
        return user;
    }
    
    private void validateUserInput(String username, String email, String password) {
        // 검증 로직
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 나쁜 예: 서드파티 API 직접 사용
Map<Integer, User> users = new HashMap<>();
users.put(1, new User("John"));
// 코드 전체에서 직접 Map 메서드 사용

// 좋은 예: 래퍼 클래스 사용
public class UserRepository {
    private Map<Integer, User> users = new HashMap<>();
    
    public void addUser(int id, User user) {
        users.put(id, user);
    }
    
    public User findUser(int id) {
        return users.get(id);
    }
    
    // 기타 필요한 메서드들
}