Javascript设计模式之原型模式详细

1、原型模式

原型模式用于在创建对象时，通过共享某个对象原型的属性和方法，从而达到提高性能、降低内存占用、代码复用的效果。

示例一

function person(name) {
  this.name = name;

  this.config = {
    a: "1",
    b: "2",
  };

  this.hello = function () {
    console.info("hello");
  };
}

假如需要通过以上代码创建 100 个实例，那么将需要创建 100 个 config、100 个 hello，而这两个东西在每个实例里面是完全一样的。

因此我们可以通过提取公共代码的方式进行油优化。

const config = {
  a: "1",
  b: "2",
};
const hello = function () {
  console.info("hello");
};
function person(name) {
  this.name = name;

  this.config = config;

  this.hello = hello
}

这样的方式使得无论创建多少个person对象都只需要创建一个config、一个hello。 但是仍然污染全局变量、config被误修改、person和其他代码耦合大、不易于代码扩展维护等问题。

因此可以通过原型的方式进行优化。

function person() {}
var p = new person();

该函数创建实例时原型图如下：

示例二

function person(name) {
  this.name = name;

  this.config = {
    a: "1",
    b: "2",
  };

  this.hello = function () {
    console.info("hello");
  };
}

//此方式会重写prototype，造成constructor丢失，变为object()。
//可以使用person.prototype.xx=yy的方式写,或者重新指定person.prototype.constructor=person
person.prototype = {
  version: 1.0,
  say: function (arg) {
    console.info(`${this.name} say ${arg}`);
  },
  constructor: person,
};
var p1 = new person("p1");
var p2 = new person("p2");

console.info(p1.config == p2.config); //false
console.info(p1.hello == p2.hello); //false
console.info(p1.say === p2.say); //true
p1.say("qq");
p2.say("qq");
console.info(p1.version === p2.version); //true
console.info(p1.version);

该函数创建实例时原型图如下：

示例三

function person(name) {
  this.name = name;

  this.config = {
    a: "1",
    b: "2",
  };

  this.hello = function () {
    console.info("hello");
  };
}

//此方式会重写prototype，造成constructor丢失，变为object()
person.prototype = {
  version: 1.0,
  say: function (arg) {
    console.info(`${this.name} say ${arg}`);
  },
};

function persona(name) {
  person.call(this, name);
}
persona.prototype = person.prototype;

function personb(name) {
  person.call(this, name);
}
personb.prototype = person.prototype;
var pa = new persona("pa");
var pb = new personb("pb");

console.info(pa.config == pb.config); //false  内部属性比较
console.info(pa.hello == pb.hello); //false  内部属性比较
console.info(pa.say === pb.say); //true  原型方法共享
pa.say("qq");
pb.say("qq");
console.info(pa.version === pb.version); //true  原型属性共享
console.info(pa.version); //1.0
person.prototype.version = 2.0; //修改原型共享属性
console.info(pb.version); //2.0
console.info(new person().version); //2.0

//修改原型共享方法
personb.prototype.say = function (arg) {
  console.info(`v2--- ${this.name} say ${arg}`);
};
pb.say("qq");
new person("person").say("ww");

总结：

js 在创建对象比较消耗内存、耗时长，可以通过减少内部属性创建的方式降低内存占用。

而原型模式就是使用 javascript 语言的原型特性进行相同属性的共享，从而达到降低内存占用、提高对象创建效率。

2、观察者模式

观察者模式用于模块、组件之间通讯，通过提供统一的模式进行事件订阅、事件发布。从而达到模块、组件之间解耦，提高代码的可维护性。

模块之间、组件之间通讯方式

模块之间、组件之间采用直接引用通讯方式

const modulea = {
  say: function (msg) {
    console.info("a say " + msg);
  },

  letbrun: function () {
    //直接引用了moduleb
    moduleb.run();
  },
};

const moduleb = {
  run: function () {
    console.info("b run ");
  },

  letasay: function () {
    //直接引用了modulea
    modulea.say("hello");
  },
};

modulea.letbrun(); //b run
moduleb.letasay(); //a say hello

模块之间、组件之间采用父组件通讯方式

const modulea = {
  say: function (msg) {
    console.info("a say " + msg);
  },
};

const moduleb = {
  run: function () {
    console.info("b run ");
  },
};

const parentmodule = {
  modulea,
  moduleb,

  letbrun: function () {
    this.moduleb.run();
  },

  letasay: function () {
    this.modulea.say("hello");
  },
};

parentmodule.letbrun(); //b run
parentmodule.letasay(); //a say hello

事件模块实现通讯

function emitter() {
  this.events = {};
  this.res_oldaction = {}
  this.res_action_events = {}
}

//订阅资源
emitter.prototype.subscribe = function (res, action, fn) {
  if(!this.res_oldaction[res.name]){
 this.res_oldaction[res.name] = res[action]
 res[action] = (data) => {
      this.res_oldaction[res.name](data)
   const fns = this.res_action_events[res.name].action;
      for (let i = 0; i < fns.length; i++) {
        fns[i](data);
      }
    }
  }
  
  if(!this.res_action_events[res.name]){
 this.res_action_events[res.name] = {}
  }
  
  if(!this.res_action_events[res.name][action]){
 this.res_action_events[res.name][action] = []
  }
  
  this.res_action_events[res.name].action.push(fn)
}

//取消订阅资源
emitter.prototype.unsubscribe = function (res, action, fn) {
  const fns = this.res_action_events[res.name].action;
  for (let i = 0; i < fns.length; i++) {
 if (fns[i] === fn) {
   fns.splice(i, 1);
   i--;
 }
  }
}

emitter.prototype.on = function (name, fn) {
  if (!this.events[name]) {
    this.events[name] = [];
  }

  this.events[name].push(fn);
};

emitter.prototype.remove = function (name, fn) {
  if (!this.events[name]) {
    return;
  }

  const fns = this.events[name];

  for (let i = 0; i < fns.length; i++) {
    if (fns[i] === fn) {
      fns.splice(i, 1);
      i--;
    }
  }
};

emitter.prototype.fire = function (name, data) {
  if (!this.events[name]) {
    return;
  }

  const fns = this.events[name];

  for (let i = 0; i < fns.length; i++) {
    fns[i](data);
  }
};

const emitter = new emitter();

//模块a中注册事件
const methoda = (data) => {
  console.info("模块a接受到food消息：");
  console.info(data);
};

emitter.on("food", methoda);

//模块b中注册事件
const methodb = (data) => {
  console.info("模块b接受到food消息：");
  console.info(data);
};
emitter.on("food", methodb);

//模块c中触发事件
emitter.fire("food", "饭来了");

//模块b中移除事件
emitter.remove("food", methodb);

//模块c中再次触发事件
emitter.fire("food", "饭又来了");

执行结果如下：

模块 a 接受到 food 消息：

饭来了

模块 b 接受到 food 消息：

饭来了

模块 a 接受到 food 消息：

饭又来了

总结：

js 组件模块的通讯方式一般分为3种（直接通讯、通过父组件通讯、通过事件模块通讯）。观察者模式用于模块、组件之间通讯，通过提供统一的模式进行事件订阅、事件发布，从而达到模块、组件之间解耦，提高代码的可维护性

到此这篇关于javascript设计模式之原型模式详细的文章就介绍到这了,更多相关javascript原型模式内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！