空对象模式(Null Object)的默认行为处理

空对象模式(Null Object)的默认行为处理

空对象模式是一种通过提供默认的空对象替代null值，避免条件检查的设计模式。在JavaScript中，当某个对象可能为null或undefined时，使用空对象可以消除大量的if判断，使代码更加简洁健壮。

空对象模式的核心思想

空对象模式的核心在于定义一个不做任何实际操作的"空"对象，这个对象与正常对象实现相同的接口或继承相同的基类。当需要返回null时，改为返回这个空对象。调用者无需检查对象是否为null，可以直接调用对象的方法，空对象会以安全的方式处理这些调用。

// 常规的null检查方式
function getUser(id) {
  if (id === 1) {
    return { name: '张三', hasAccess: () => true };
  }
  return null;
}

const user = getUser(2);
if (user !== null) {
  console.log(user.name);
} else {
  console.log('用户不存在');
}

JavaScript中的空对象实现

在JavaScript中实现空对象模式通常有两种方式：使用默认对象或使用代理。下面是一个用户权限检查的示例：

// 定义空用户对象
const NullUser = {
  name: '访客',
  hasAccess: () => false,
  canEdit: () => false,
  getPermissions: () => []
};

function getUser(id) {
  if (id === 1) {
    return {
      name: '管理员',
      hasAccess: () => true,
      canEdit: () => true,
      getPermissions: () => ['read', 'write', 'delete']
    };
  }
  return NullUser; // 而不是返回null
}

const user = getUser(2);
console.log(user.name); // 直接访问，无需null检查
console.log(user.hasAccess()); // 返回安全的默认值false

空对象模式的应用场景

空对象模式特别适用于以下场景：

1. 数据查询结果：当查询数据库或API可能返回空结果时
2. 配置对象：当配置参数可选时提供默认配置
3. UI组件：当组件可能不存在时提供空渲染
4. 事件监听：当事件处理器未设置时提供空处理器

DOM事件处理的例子：

const NullHandler = {
  handleEvent: () => {} // 空操作
};

function getEventHandler(type) {
  if (type === 'click') {
    return {
      handleEvent: (e) => console.log('点击事件', e)
    };
  }
  return NullHandler;
}

document.addEventListener('click', getEventHandler('click'));
document.addEventListener('mouseover', getEventHandler('mouseover')); // 安全调用

空对象模式的变体实现

除了简单的对象字面量，还可以使用类继承或函数式的方式实现空对象模式：

类继承实现：

class User {
  constructor(name) {
    this.name = name;
  }
  
  hasAccess() {
    return true;
  }
}

class NullUser extends User {
  constructor() {
    super('访客');
  }
  
  hasAccess() {
    return false;
  }
}

function getUser(id) {
  return id === 1 ? new User('管理员') : new NullUser();
}

函数式实现：

function createUser(name, access = false) {
  return {
    name: name || '访客',
    hasAccess: () => access,
    // 其他方法...
  };
}

function getUser(id) {
  return id === 1 ? createUser('管理员', true) : createUser();
}

空对象模式与可选链操作符

ES2020引入的可选链操作符(?.)可以简化null检查，但与空对象模式有本质区别：

// 使用可选链
const user = getUser(2);
console.log(user?.name ?? '访客'); // 仍需提供默认值

// 使用空对象模式
const user = getUser(2);
console.log(user.name); // 空对象已包含默认值

空对象模式将默认行为封装在对象内部，而可选链只是语法糖，仍需外部处理默认值。

空对象模式的优缺点

优点：

1. 消除大量的null检查代码
2. 提供一致的接口调用方式
3. 默认行为集中管理，易于修改
4. 符合开闭原则，新增行为不影响现有代码

缺点：

1. 可能掩盖潜在的错误（如本该有值却返回了空对象）
2. 需要预先设计空对象，增加初期开发成本
3. 对于调试，空对象可能使问题更难发现

实际项目中的综合示例

电商网站的购物车实现：

// 空购物车项
const NullCartItem = {
  getProduct: () => ({ id: 0, name: '已下架商品', price: 0 }),
  getQuantity: () => 0,
  getSubtotal: () => 0,
  increase: () => {},
  decrease: () => {}
};

class Cart {
  constructor() {
    this.items = new Map();
  }
  
  addItem(product, quantity = 1) {
    if (product.available) {
      const item = this.items.get(product.id) || 
        new CartItem(product, 0);
      item.increase(quantity);
      this.items.set(product.id, item);
    }
  }
  
  getItem(productId) {
    return this.items.get(productId) || NullCartItem;
  }
  
  getTotal() {
    return [...this.items.values()].reduce(
      (sum, item) => sum + item.getSubtotal(), 0
    );
  }
}

class CartItem {
  constructor(product, quantity) {
    this.product = product;
    this.quantity = quantity;
  }
  
  getSubtotal() {
    return this.product.price * this.quantity;
  }
  
  increase(amount = 1) {
    this.quantity += amount;
  }
  
  decrease(amount = 1) {
    this.quantity = Math.max(0, this.quantity - amount);
  }
}

// 使用示例
const cart = new Cart();
cart.addItem({ id: 1, name: '手机', price: 3999, available: true }, 2);
console.log(cart.getItem(1).getSubtotal()); // 7998
console.log(cart.getItem(999).getProduct().name); // "已下架商品"

与其他模式的结合

空对象模式常与其他模式配合使用：

1. 与工厂模式结合：通过工厂决定返回真实对象还是空对象
2. 与策略模式结合：空对象作为默认策略
3. 与状态模式结合：空对象作为默认状态

工厂模式示例：

class LoggerFactory {
  static createLogger(type) {
    switch(type) {
      case 'console':
        return new ConsoleLogger();
      case 'file':
        return new FileLogger();
      default:
        return new NullLogger();
    }
  }
}

class NullLogger {
  log() {}
  error() {}
  warn() {}
}

class ConsoleLogger {
  log(msg) { console.log(msg); }
  error(msg) { console.error(msg); }
  warn(msg) { console.warn(msg); }
}

// 使用
const logger = LoggerFactory.createLogger('invalid');
logger.log('这条消息不会被记录'); // 安全调用