Что такое Stateless операция?

# Stateless операция в программировании

Stateless (без состояния) операция — это функция, вычисление или действие, которое полностью определяется только входными параметрами и не зависит от каких-либо внешних состояний, предыдущих вызовов или побочных эффектов.

Ключевые характеристики Stateless операции

1. Чистая функция — идентичный вход всегда дает идентичный выход
2. Отсутствие побочных эффектов — не изменяет внешние переменные или состояние
3. Независимость — не зависит от глобального состояния приложения
4. Переиспользуемость — можно вызывать в любой момент в любом порядке
5. Предсказуемость — результат всегда одинаков при одних и тех же входных данных

Примеры Stateless операций

Чистые математические функции

# Stateless — всегда вернёт одно и то же для одного входа
def add(a, b):
    return a + b

print(add(2, 3))  # 5
print(add(2, 3))  # 5
print(add(2, 3))  # 5 (идентичный результат)

# Ещё примеры
def calculate_discount(price, discount_percent):
    return price * (1 - discount_percent / 100)

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

Преобразование данных

# Stateless операции для преобразования данных
def format_name(first_name, last_name):
    return f"{first_name.capitalize()} {last_name.capitalize()}"

def parse_csv_line(line):
    return [field.strip() for field in line.split(',')]

def to_uppercase(text):
    return text.upper()

# Все эти функции не зависят от состояния и дают одинаковый результат

Примеры Stateful операций (антипаттерны)

# Stateful — зависит от глобального состояния
counter = 0

def increment():  # Это NOT stateless!
    global counter
    counter += 1
    return counter

print(increment())  # 1
print(increment())  # 2
print(increment())  # 3 (разный результат!)

# Stateful — зависит от предыдущих вызовов
class User:
    def __init__(self, name):
        self.name = name
        self.call_count = 0
    
    def greet(self):  # Not stateless
        self.call_count += 1  # Побочный эффект!
        return f"Hello {self.name}, call #{self.call_count}"

REST API и Statelessness

Stateless операции — основа REST архитектуры:

# Stateless endpoint — не хранит сессию на сервере
from fastapi import FastAPI, HTTPException
from typing import Optional

app = FastAPI()

# Stateless операция
@app.get("/users/{user_id}")
async def get_user(user_id: int):
    # Всю информацию получаем из запроса и БД
    # Не зависим от сессии или состояния сервера
    user = db.get_user(user_id)
    if not user:
        raise HTTPException(status_code=404)
    return user

# Stateless обновление
@app.put("/users/{user_id}")
async def update_user(user_id: int, data: dict):
    # Полная информация в запросе
    # Одна операция не зависит от другой
    user = db.update_user(user_id, data)
    return user

Преимущества для REST API:

• Легко масштабировать (любой сервер может обработать запрос)
• Просто кэшировать (GET запросы можно кэшировать)
• Легко делать load balancing
• Просто тестировать

Stateless vs Stateful обработка

# Stateless обработка заказов
def process_order(order_id, items, customer_id):
    """Все данные передаются в параметрах"""
    total = sum(item['price'] * item['quantity'] for item in items)
    return {
        'order_id': order_id,
        'customer_id': customer_id,
        'total': total,
        'items': items
    }

# Stateful обработка заказов (плохо)
class OrderProcessor:
    def __init__(self):
        self.current_order = None
        self.total = 0
    
    def add_item(self, item):  # Зависит от self.current_order
        self.total += item['price']
    
    def get_total(self):  # Зависит от предыдущих операций
        return self.total

Стателесность в микросервисах

# Microservice должен быть stateless
from fastapi import FastAPI
import jwt

app = FastAPI()

@app.post("/authenticate")
async def authenticate(username: str, password: str):
    # Stateless аутентификация
    if validate_credentials(username, password):
        token = jwt.encode({"user": username}, "secret")
        return {"token": token}
    raise HTTPException(status_code=401)

@app.get("/protected")
async def protected_route(token: str):
    # Не хранимся сессию на сервере
    # Всё необходимое в токене
    user = jwt.decode(token, "secret")
    return {"message": f"Hello {user['user']}", "data": get_data()}

Функциональное программирование

Stateless операции — основа функционального программирования:

# Функциональный стиль (stateless)
from functools import reduce

def map_operation(data, func):
    """Чистая функция для трансформации данных"""
    return [func(item) for item in data]

def filter_operation(data, predicate):
    """Чистая функция для фильтрации"""
    return [item for item in data if predicate(item)]

numbers = [1, 2, 3, 4, 5]
result = filter_operation(
    map_operation(numbers, lambda x: x * 2),
    lambda x: x > 5
)
# result = [6, 8, 10] — воспроизводимый результат

Преимущества Stateless операций

1. Тестируемость — легко писать unit тесты
2. Параллелизм — безопасно выполнять в разных потоках
3. Кэширование — результат можно кэшировать
4. Масштабируемость — просто добавить серверов
5. Отладка — легче найти баги, так как нет скрытых зависимостей

Best Practices

# ✅ Хорошо — stateless функция
def validate_email(email: str) -> bool:
    """Полностью определяется входом"""
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

# ❌ Плохо — stateful функция
validation_count = 0
def validate_email_stateful(email: str) -> bool:
    """Зависит от глобального состояния"""
    global validation_count
    validation_count += 1  # Побочный эффект!
    return '@' in email

Заключение

Stateless операции — это фундамент масштабируемых и надёжных систем. Они позволяют писать код, который легче тестировать, отлаживать и масштабировать. При разработке стремись к stateless операциям, оставляя stateful логику только где действительно необходимо.