空对象模式（Null Object Pattern）

当存在两个同类的对象时，可以用相同的空对象来代替Null或undefined来做一些检测。

空对象模式的实例

定义基类

  1. class Customer {
  2.    constructor(name) {
  3.       this.name = name;    
  4.    }
  5.    getName() {}
  6.    isNil() {}
  7. }

定义一个真正使用的类和一个空对象类

  1. class RealCustomer extends Customer {
  2.     getName() {
  3.        return this.name;
  4.     }
  5.     isNil() {
  6.        return false;
  7.     }
  8. }
  9. class NullCustomer extends Customer {
  10.     getName() {
  11.        return "Not Available in Customer Database";
  12.     }
  13.     isNil() {
  14.        return true;
  15.     }
  16. }

定义对象工厂方便生产

  1. class CustomerFactory {
  2.     static getCustomer(name){
  3.        for (let i = 0; i < CustomerFactory.names.length; i++) {
  4.           if (CustomerFactory.names[i].toUpperCase()==name.toUpperCase()){
  5.              return new RealCustomer(name);
  6.           }
  7.        }
  8.        return new NullCustomer();
  9.     }
  10. }

在使用的时候空对象可以正常使用，而null却不能调用getName方法。

  1. CustomerFactory.names = ["Rob", "Joe", "Julie"];
  3. const customer1 = CustomerFactory.getCustomer("Rob");
  4. const customer2 = CustomerFactory.getCustomer("Bob");
  5. const customer3 = CustomerFactory.getCustomer("Julie");
  6. const customer4 = CustomerFactory.getCustomer("Laura");
  8. console.log("Customers");
  9. console.log(customer1.getName());
  10. console.log(customer2.getName());
  11. console.log(customer3.getName());
  12. console.log(customer4.getName());
  13. /**
  14.  * output:
  15.  * Customers
  16.  * Rob
  17.  * Not Available in Customer Database
  18.  * Julie
  19.  * Not Available in Customer Database
  20.  */

空对象模式的优势

比如在使用某个类时，需要对这个类来做空判断，在不确定后续这个类的方法是否会被调用时，用一个相同类的空对象来返回，这样可以更加无缝对接空值判断。

上一页(状态模式)

下一页(策略模式)