Колмогоровская сложность: Приёмы упрощения кода

// До рефакторинга
function processPayment(payment) {
    if (payment) {
        if (payment.isAuthorized) {
            if (payment.amount > 0) {
                // Обработка платежа
            } else {
                throw new Error("Payment amount must be positive");
            }
        } else {
            throw new Error("Payment not authorized");
        }
    } else {
        throw new Error("Payment is required");
    }
}
 
// После рефакторинга с защитными утверждениями
function processPayment(payment) {
    if (!payment) {
        throw new Error("Payment is required");
    }
    
    if (!payment.isAuthorized) {
        throw new Error("Payment not authorized");
    }
    
    if (payment.amount <= 0) {
        throw new Error("Payment amount must be positive");
    }
    
    // Обработка платежа
}

// Без функций высшего порядка
let activeUsers = [];
for (let i = 0; i < users.length; i++) {
  if (users[i].isActive) {
    activeUsers.push(users[i]);
  }
}
 
let userNames = [];
for (let i = 0; i < activeUsers.length; i++) {
  userNames.push(activeUsers[i].name);
}
 
// С функциями высшего порядка
let userNames = users
  .filter(user => user.isActive)
  .map(user => user.name);

function calculateShippingCost(order) {
  if (order) {
    if (order.items) {
      if (order.items.length > 0) {
        if (order.address) {
          if (order.address.country) {
            if (order.address.country === 'USA') {
              return order.items.length * 2;
            } else {
              return order.items.length * 5;
            }
          } else {
            throw new Error('Country is required');
          }
        } else {
          throw new Error('Address is required');
        }
      } else {
        throw new Error('Order must contain items');
      }
    } else {
      throw new Error('Items are required');
    }
  } else {
    throw new Error('Order is required');
  }
}

function calculateShippingCost(order) {
  if (!order) throw new Error('Order is required');
  if (!order.items) throw new Error('Items are required');
  if (order.items.length === 0) throw new Error('Order must contain items');
  if (!order.address) throw new Error('Address is required');
  if (!order.address.country) throw new Error('Country is required');
  
  return order.address.country === 'USA' 
    ? order.items.length * 2 
    : order.items.length * 5;
}

// Императивный подход
function processNumbers(numbers) {
  const result = [];
  for (let i = 0; i < numbers.length; i++) {
    if (numbers[i] % 2 === 0) {
      const doubled = numbers[i] * 2;
      if (doubled > 10) {
        result.push(doubled);
      }
    }
  }
  return result;
}
 
// Функциональный подход
function processNumbers(numbers) {
  return numbers
    .filter(n => n % 2 === 0)
    .map(n => n * 2)
    .filter(n => n > 10);
}

// До рефакторинга
function getDiscountRate(customerType) {
  if (customerType === 'regular') {
    return 0.1;
  } else if (customerType === 'premium') {
    return 0.15;
  } else if (customerType === 'vip') {
    return 0.2;
  } else if (customerType === 'employee') {
    return 0.3;
  } else {
    return 0;
  }
}
 
// После рефакторинга (с использованием объекта как таблицы)
function getDiscountRate(customerType) {
  const discountRates = {
    regular: 0.1,
    premium: 0.15,
    vip: 0.2,
    employee: 0.3
  };
  
  return discountRates[customerType] || 0;
}

function findPairs(numbers, targetSum) {
  const result = [];
  for (let i = 0; i < numbers.length; i++) {
    for (let j = i + 1; j < numbers.length; j++) {
      if (numbers[i] + numbers[j] === targetSum) {
        result.push([numbers[i], numbers[j]]);
      }
    }
  }
  return result;
}

function findPairs(numbers, targetSum) {
  const result = [];
  const seen = new Set();
  
  for (const num of numbers) {
    const complement = targetSum - num;
    if (seen.has(complement)) {
      result.push([complement, num]);
    }
    seen.add(num);
  }
  
  return result;
}

// Трудночитаемая версия
return list && list.length && list.filter(x => !!x).map(item => item.value).reduce((a, b) => a + b, 0);
 
// Более читаемая версия
if (!list || !list.length) {
    return 0;
}
 
const validItems = list.filter(item => item != null);
const values = validItems.map(item => item.value);
const sum = values.reduce((total, value) => total + value, 0);
return sum;