JavaScript优化if-else复杂判断问题的常用方案

// 优化前
function processOrder(order) {
  if (order) {
    if (order.status === 'pending') {
      if (order.items.length > 0) {
        // 处理逻辑
        return calculateTotal(order);
      } else {
        throw new Error('订单无商品');
      }
    } else {
      throw new Error('订单状态无效');
    }
  } else {
    throw new Error('订单不存在');
  }
}

// 优化后
function processOrder(order) {
  if (!order) throw new Error('订单不存在');
  if (order.status !== 'pending') throw new Error('订单状态无效');
  if (order.items.length === 0) throw new Error('订单无商品');
  
  return calculateTotal(order);
}

// 优化前
function getUserAccess(user) {
  if (user) {
    if (user.active) {
      if (user.role === 'admin') {
        return 'full-access';
      } else if (user.role === 'editor') {
        return 'edit-access';
      } else {
        return 'read-only';
      }
    } else {
      return 'no-access';
    }
  } else {
    return 'guest-access';
  }
}

// 优化后
function getUserAccess(user) {
  if (!user) return 'guest-access';
  if (!user.active) return 'no-access';
  
  const roleMap = {
    'admin': 'full-access',
    'editor': 'edit-access',
    'default': 'read-only'
  };
  
  return roleMap[user.role] || roleMap.default;
}

// 优化前
function calculatePrice(userType, price) {
  if (userType === 'vip') {
    return price * 0.7;
  } else if (userType === 'member') {
    return price * 0.8;
  } else if (userType === 'new') {
    return price * 0.9;
  } else {
    return price;
  }
}

// 优化后
const priceStrategies = {
  vip: (price) => price * 0.7,
  member: (price) => price * 0.8,
  new: (price) => price * 0.9,
  default: (price) => price
};

function calculatePrice(userType, price) {
  const strategy = priceStrategies[userType] || priceStrategies.default;
  return strategy(price);
}

// 更灵活的策略模式
class PriceStrategy {
  static strategies = {
    vip: new VipStrategy(),
    member: new MemberStrategy(),
    new: new NewUserStrategy(),
    default: new DefaultStrategy()
  };
  
  static getStrategy(userType) {
    return this.strategies[userType] || this.strategies.default;
  }
}

// 优化前
function getStatusText(status) {
  if (status === 1) {
    return '待支付';
  } else if (status === 2) {
    return '已支付';
  } else if (status === 3) {
    return '发货中';
  } else if (status === 4) {
    return '已完成';
  } else if (status === 5) {
    return '已取消';
  } else {
    return '未知状态';
  }
}

// 优化后
const STATUS_MAP = {
  1: '待支付',
  2: '已支付',
  3: '发货中',
  4: '已完成',
  5: '已取消'
};

function getStatusText(status) {
  return STATUS_MAP[status] || '未知状态';
}

// 更复杂的数据结构
const STATUS_CONFIG = {
  1: { text: '待支付', color: 'orange', action: 'pay' },
  2: { text: '已支付', color: 'blue', action: 'view' },
  3: { text: '发货中', color: 'green', action: 'track' },
  4: { text: '已完成', color: 'gray', action: 'review' }
};

// 优化前
class Order {
  process() {
    if (this.status === 'pending') {
      // 待处理逻辑
    } else if (this.status === 'paid') {
      // 已支付逻辑
    } else if (this.status === 'shipped') {
      // 已发货逻辑
    }
  }
}

// 优化后
class OrderState {
  process(order) {
    throw new Error('必须实现 process 方法');
  }
}

class PendingState extends OrderState {
  process(order) {
    console.log('处理待支付订单');
    // 具体逻辑
  }
}

class PaidState extends OrderState {
  process(order) {
    console.log('处理已支付订单');
    // 具体逻辑
  }
}

class Order {
  constructor() {
    this.state = new PendingState();
  }
  
  setState(state) {
    this.state = state;
  }
  
  process() {
    return this.state.process(this);
  }
}

// 优化前
function handleRequest(type, data) {
  if (type === 'typeA') {
    return handleTypeA(data);
  } else if (type === 'typeB') {
    return handleTypeB(data);
  } else if (type === 'typeC') {
    return handleTypeC(data);
  } else {
    return handleDefault(data);
  }
}

// 优化后
class Handler {
  constructor() {
    this.nextHandler = null;
  }
  
  setNext(handler) {
    this.nextHandler = handler;
    return handler;
  }
  
  handle(type, data) {
    if (this.nextHandler) {
      return this.nextHandler.handle(type, data);
    }
    return null;
  }
}

class TypeAHandler extends Handler {
  handle(type, data) {
    if (type === 'typeA') {
      return `处理 typeA: ${data}`;
    }
    return super.handle(type, data);
  }
}

// 使用
const handlerChain = new TypeAHandler()
  .setNext(new TypeBHandler())
  .setNext(new TypeCHandler())
  .setNext(new DefaultHandler());
  

// 优化前
function getUserInfo(user) {
  if (user && user.profile && user.profile.contact && user.profile.contact.email) {
    return user.profile.contact.email;
  } else {
    return 'default@email.com';
  }
}

// 优化后
function getUserInfo(user) {
  return user?.profile?.contact?.email ?? 'default@email.com';
}

// 配合默认参数
function processConfig(config = {}) {
  const {
    timeout = 5000,
    retry = 3,
    logLevel = 'info'
  } = config;
  
  // 使用配置
}