JavaScript插件开发从入门到精通系列---原生JavaScript插件开发

    为什么要做javascript插件开发？

 

    这个应该是一个必然。因为需要跨时间、空间不同开发人员的协作，代码的重用。具体也就不多说了。

 

    js开发小白一般怎么开发程序？我记得我刚入行是这么写的：

    

var a = 1;
var b = 2;

function add(aaa, bbb) {
    var result= aaa + bbb;
    alert("result == " + result);
}

add(a,b);

     add函数很简单，就是计算传入两个数字之和然后alert结果。需求到了后来陆陆续续加上了减法、乘法、除法，我也对应增加了reduce、multiply、divide方法。

 

    所以我的代码变成了以下这个样子：

    

var a = 1;
var b = 2;

// 加法
function add(aaa, bbb) {
    var result= aaa + bbb;
    alert("result == " + result);
}

// 减法
function reduce(aaa, bbb) {
    var result= aaa - bbb;
    alert("result == " + result);
}

// 乘法
function multiply(aaa, bbb) {
    var result= aaa * bbb;
    alert("result == " + result);
}

// 除法
function divide(aaa, bbb) {
    var result = aaa / bbb;
    alert("result == " + result);
}

// 执行加、减、乘、除
add(a, b);
reduce(a, b);
multiply(a, b);
divide(a, b);

 

    突然有一天，小伙伴说哥，你这几个函数我们项目经常用到，可不可以提供出来让我们调用？我说这个简单。于是我把加减乘除的函数单独放置到了一个mathUtil.js文件中，这个文件的内容如下：

    

// 加法  
function add(aaa, bbb) {  
    var result= aaa + bbb;  
    alert("result == " + result);  
}  
  
// 减法  
function reduce(aaa, bbb) {  
    var result= aaa - bbb;  
    alert("result == " + result);  
}  
  
// 乘法  
function multiply(aaa, bbb) {  
    var result= aaa * bbb;  
    alert("result == " + result);  
}  
  
// 除法  
function divide(aaa, bbb) {  
    var result = aaa / bbb;  
    alert("result == " + result);  
}

 

    这个时候其实就是进入了最最原始的插件开发了。因为我写的这份代码被跨时间、跨空间供不同开发人员协作使用，这份代码也做了重用，减少了重复劳动。

 

   接下来就是完善插件的过程了。

 

    优化：方法直接暴露在全局作用域，容易命名冲突且通过作用域查找性能消耗大。没有面向对象编程，纯程式化的函数罗列。解决方案：使用对象封装。

    

    对于JavaScript的面向对象的设计使用，这个也是难点，必须坐下来好好说说。

 

    javascript对象的生成方法有2种：

    

// 字面量定义
var person1 = {
	name: "peter",
	age: 18,
	sayHello: function() {
		alert("hello! I am " + this.name);
	}
};

// 创建Object的一个实例
var person2 = new Object();
person2.name = "william";
person2.age = 19;
person2.sayHello = function() {
	alert("hello! I am " + this.name);
};

 

    以上虽然能创建对象，但是有个缺点。如果要创建多个对象，就需要重复写以上的代码。为了解决这个问题我们可以使用：

 

    工厂模式：

    

// 工厂模式
function createPerson(name, age) {
	var o = new Object();
	o.name = name;
	o.age = age;
	o.sayHello = function() {
		alert("hello! I am " + this.name);
	};
        return o;
}

var person1 = createPerson("peter", 18);
var person2 = createPerson("william", 19);

    

    工厂模式已经可以满足一般我们的开发需要了，但是这个也是有点问题。命名不够直接，实现方面也可以简化。怎么弄？使用构造函数模式：

    

// 构造函数模式
var Person = function(name, age) {
	this.name = name;
	this.age = age;
	this.sayHello = function() {
		alert("hello! I am " + this.name);
	}
};

var person1 = new Person("peter", 18);
var person2 = new Person("william", 19);

 

    从工厂模式跨越到了构造模式，跨度有点大，这里解释一下：

 

    相比较工厂模式，构造函数模式有以下不同：

 

    A.没有显式创建对象

    B.直接将属性、方法赋予了this对象

    C.没有return

 

    这些都是因为在使用new 操作符构造函数模式时经历以下过程：

 

    A.创建一个对象

    B.将构造函数的作用域赋给新对象，所以this就指向了这个新对象

    C.执行构造函数中的代码，例子中就是赋予新对象属性和方法

    D.返回新对象

 

    虽然构造函数模式隐含省略了很多步骤且不怎么好理解。但是使用起来却是简单直接。例如我要创建一个person类，new Person()就得到了（和java的语法简直一模一样啊~32个赞！）。但是要是使用工厂模式，就必须调用createPerson();有时候工厂模式的函数是别的人写的，写成了createHuman，这不逼死强迫症嘛？！

 

    另外一个重要的好处是：使用构造函数模式产生的对象是该函数的实例。怎么讲呢？如果使用工厂模式，得到的person只是Object的实例。而构造函数模式得到的person却是更为具体的Person的实例！当然它同时也是Object的实例。

 

    这个优点在使用instanceof操作符进行实例判断时可以给出我们准确的判断，如果都是工厂模式出来的产品，那么检测结果就是大家都是Object的实例。

 

    在这里，如果不考虑构造函数模式的一些细节问题。这种插件的写法已经可以应用到我们的项目当中了，不知道你们有没有在项目中见到其他人是这么写的？所以我们的mathUtil.js文件就可以写成下面这种样子了：

    

function MathUtil() {
	// 加法    
	this.add = function(aaa, bbb) {    
	    var result= aaa + bbb;    
	    alert("result == " + result);    
	};  
	    
	// 减法    
	this.reduce = function(aaa, bbb) {    
	    var result= aaa - bbb;    
	    alert("result == " + result);    
	};   
	    
	// 乘法    
	this.multiply = function(aaa, bbb) {    
	    var result= aaa * bbb;    
	    alert("result == " + result);    
	};    
	    
	// 除法    
	this.divide = function(aaa, bbb) {    
	    var result = aaa / bbb;    
	    alert("result == " + result);    
	};
}

    

    使用方法：

    

// 引用mathUtil.js文件后使用方式：

var mathUtil1 = new MathUtil();
mathUtil1.add(1, 2);

 

    这样以来插件就实现了面向对象的抽象过程，且将插件需要的各种变量封装了起来。

 

    以上的构造函数模式还是有点小问题的，对于一个对技术精益求精的前端开发，这点也是不能容忍的。问题在于mathUtil函数体重的add等方法都是对象（函数也是特殊对象，定义一个函数就相当于实例化了一个对象了）。当new一个MathUtil的实例时，实例中的方法都是一样的，但是重复了。其实这个是没有必要的。怎么办？

 

    最简单粗暴的方式就是把相关的函数提取出来（为了表述方便加入version变量）：

    

function MathUtil() {

	// 版本号
	var version = "1.0";

	// 加法    
	this.add = add;  
	    
	// 减法    
	this.reduce = reduce;   
	    
	// 乘法    
	this.multiply = multiply;    
	    
	// 除法    
	this.divide = divide;
}

// 加法    
var add = function(aaa, bbb) {    
    var result= aaa + bbb;    
    alert("result == " + result);    
};  
    
// 减法    
var reduce = function(aaa, bbb) {    
    var result= aaa - bbb;    
    alert("result == " + result);    
};   
    
// 乘法    
var multiply = function(aaa, bbb) {    
    var result= aaa * bbb;    
    alert("result == " + result);    
};    
    
// 除法    
var divide = function(aaa, bbb) {    
    var result = aaa / bbb;    
    alert("result == " + result);    
};

 

    以上的改造后，如果new多个MathUtil的实例时，add函数只有一个实例，那就是指向了和MathUtil平级的那个add函数。其他函数相同情况。

 

    但是从实际操作来讲，还不如消耗一点性能，不将插件的函数提取出来。因为这样一来暴露出来的变量急剧增加，很不好控制。

    

    有没有方案解决这种问题呢？即多个实例的共同方法、对象指向一个，复用方法。答案就是原型模式：

    

var MathUtil = function() {};

MathUtil.prototype = {

	// 将构造函数置为MathUtil，这里一定要将constructor重新设置回MathUtil，不然会指向Object的构造函数
    constructor: MathUtil,

	// 版本号
	version: "1.0",

	// 加法
	add: function(aaa, bbb) {    
	    var result= aaa + bbb;    
	    alert("result == " + result);    
	},

	// 减法    
	reduce: function(aaa, bbb) {    
	    var result= aaa - bbb;    
	    alert("result == " + result);    
	},  
    
	// 乘法    
	multiply: function(aaa, bbb) {    
	    var result= aaa * bbb;    
	    alert("result == " + result);    
	},  
    
	// 除法    
	divide: function(aaa, bbb) {    
	    var result = aaa / bbb;    
	    alert("result == " + result);    
	}
};

 

    以上的原型模式看起来已经比较完美了，但是还是有两个比较突出的问题：

 

    A.无初始化变量入口

    B.当属性为Array类型时，会发生属性篡改

 

    对于MathUtil这个函数，无初始化变量入口的意思是在new出一个实例时想直接将version传入，覆盖默认值。但是，以上的设计明显是做不到的。

 

    再说属性篡改问题，为了说明这个问题我们在mathUtil对象中加入一个programmer变量，用来存储开发人员的姓名。

    

var MathUtil = function() {};  
  
MathUtil.prototype = {  

    //省略了其他的代码
    
    //开发人员
    programmer: [] 
};  

    

// 实例化一个MathUtil，并给programmer里增加一个开发人员姓名
var m1 = new MathUtil();
m1.programmer.push("william");


// 实例化一个MathUtil，没有对programmer进行任何操作的情况下，m2的programmer属性无缘无故就多出来一个"william"
var m2 = new MathUtil();
m2.programmer;

    

    这是由于m1、m2共享了同一个原型对象导致的，而Array属于引用类型，所以就造成了m1的programmer其实和m2的programmer是同一个实例的情况。所以呢，我们就人为地对对象的属性做个分类，如果是函数，我们就统一放到prototype属性指向的实例当中，如果只是非引用类型或者Array类型的属性我们放在构造函数里面。而且我们同时改造构造函数接受参数：

    

var MathUtil = function(version, programmer) {
	this.name = name;
	this.programmer = programmer;
};

MathUtil.prototye = {

	// 将构造函数置为MathUtil，这里一定要将constructor重新设置回MathUtil，不然会指向Object的构造函数
	constructor: MathUtil,

	// 加法
	add: function(aaa, bbb) {    
	    var result= aaa + bbb;    
	    alert("result == " + result);    
	},

	// 减法    
	reduce: function(aaa, bbb) {    
	    var result= aaa - bbb;    
	    alert("result == " + result);    
	},  
    
	// 乘法    
	multiply: function(aaa, bbb) {    
	    var result= aaa * bbb;    
	    alert("result == " + result);    
	},  
    
	// 除法    
	divide: function(aaa, bbb) {    
	    var result = aaa / bbb;    
	    alert("result == " + result);    
	}
};

    调用测试的代码：

    

// 引用mathUtil.js文件后使用方式：
var m1 = new MathUtil("william",["william"]);
m1.programmer.push("william2");

var m2 = new MathUtil("peter",["peter"]);
m1.programmer.push("peter2");

   

    这个时候m1,m2各自的programmer对应的就是不同数组了。而且还同时具有初始化参数的能力。

 

    以上的写法已经比较完美了，只是分开两部分来写还是有点那啥。对于强迫症患者来讲，还可以使用动态原型法：

    

var MathUtil = function(version, programmer) {
	this.name = name;
	this.programmer = programmer;

	// 使用必要条件进行检测，然后添加函数。
	if(typeof this.add != "function") {

		// 缓存MathUtil.prototye
		var proto = MathUtil.prototye;

		// 加法
		proto.add = function(aaa, bbb) {    
		    var result = aaa + bbb;    
		    alert("result == " + result);    
		};

		// 减法
		proto.reduce = function(aaa, bbb) {    
		    var result = aaa - bbb;    
		    alert("result == " + result);    
		};

		// 乘法
		proto.multiply = function(aaa, bbb) {    
		    var result= aaa * bbb;    
		    alert("result == " + result);    
		};

		// 除法
		proto.divide = function(aaa, bbb) {    
		    var result= aaa / bbb;    
		    alert("result == " + result);    
		};
	}
};

 

    以上对prototype新增方法的代码在使用new操作符执行时，只会进入判断一次，然后为MathUtil.prototype追加了相应的函数方法。

 

    是否要将prototype放在和构造函数平级还是放在构造函数体内，都没有错，就看个人或者团队喜好，不过最好统一才行。

 

    最后再次强调我们刚才碰到的2个坑：

 

    1.当为MathUtil的prototype追加函数时，如果使用了MathUtil.prototype = {...};那么已经将MathUtil.prototype指向的对象重新定位了，这个时候constructor指向了Object，需要手动指回到MathUtil。最为保险的做法是MathUtil.prototype.add = function() {...};这样的方式来添加，这种方法没有替换MathUtil.prototype指向的实例，所以不会产生不可预料的问题。

 

    2.当MathUtil的属性是数组时，绝对不能将其定义在prototype里面，不然会有属性值覆盖问题。