写一个算法，有时候可以用简单的方法就可以写出来，但是只能针对特定的环境，如果要能够适应不同的环境，就需要对算法进行优化，在优化的过程中，你会觉得非常神奇，下面来看一个简单的四则运算的算法编写方式：
1.简单粗暴的实现：直接创建一个对象，在对象上直接挂载加减乘除方法
<script>
var per = {
add: function(n1, n2) {
return n1 + n2;
},
sbb: function(n1, n2) {
return n1 - n2;
},
multi: function(n1, n2) {
return n1 * n2;
},
div: function(n1, n2) {
return n1 / n2;
}, }
console.log(per.add(10, 20));
console.log(per.sbb(10, 20));
console.log(per.multi(10, 20));
console.log(per.div(10, 20));
</script>
运行结果：
2.采用构造函数的方式，把方法加减乘除方法写在构造函数中
<script>
function OPP(n1, n2) {
this.num1 = n1 || 0; // 当传入参数n1时，设置this.num1 = n1,否则设置为0；
this.num2 = n2 || 0; // 当传入参数n2时，设置this.num2 = n2,否则设置为0；
this.setdata = function(n1, n2) {
this.num1 = n1 || 0; // 当传入参数n1时，设置this.num1 = n1,否则设置为0；
this.num2 = n2 || 0; // 当传入参数n2时，设置this.num2 = n2,否则设置为0；
};
// 函数的运行，首先设置相关元素的属性值，然后再进行调用
this.add = function() {
// 当add()函数传入参数时，那么设置参数就使用传入的参数arguments[0]/arguments[1],否则使用原先的构造函数的参数this.num1/this.num2
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 + this.num2;
};
this.sbb = function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 - this.num2;
};
this.multi = function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 * this.num2;
};
this.div = function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 / this.num2;
}
}
console.log(new OPP(10, 20).add()); //
console.log(new OPP().add(10, 20)); //
console.log(new OPP(100, 200).add(10, 20)); //
console.log(new OPP(10, 20).sbb()); //-10
console.log(new OPP().sbb(10, 20)); //-10
console.log(new OPP(100, 200).sbb(10, 20)); //-10
console.log(new OPP(10, 20).multi()); //
console.log(new OPP().multi(10, 20)); //
console.log(new OPP(10, 20).div()); //0.5
console.log(new OPP().div(10, 20)); //0.5
</script>
运行结果：
3. 采用构造函数的原型对象的方式，即将调用函数挂载到了构造函数的原型对象上，当调用函数时，是通过原型链进行调用的，而上一个没有涉及到原型链的问题，这是与上一种方式的本质区别
<script>
function OPP(n1, n2) {
this.num1 = n1 || 0; // 当传入参数n1时，设置this.num1 = n1,否则设置为0；
this.num2 = n2 || 0; // 当传入参数n2时，设置this.num2 = n2,否则设置为0；
}
OPP.prototype = {
constructor: OPP,
setdata: function(n1, n2) {
this.num1 = n1 || 0;
this.num2 = n2 || 0;
},
add: function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 + this.num2;
},
sbb: function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 - this.num2;
},
multi: function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 * this.num2;
},
div: function() {
this.setdata(arguments[0] || this.num1, arguments[1] || this.num2);
return this.num1 / this.num2;
},
}; console.log(new OPP(10, 20).add()); //
console.log(new OPP().add(10, 20)); //
console.log(new OPP(100, 200).add(10, 20)); //
console.log(new OPP(10, 20).sbb()); //-10
console.log(new OPP().sbb(10, 20)); //-10
console.log(new OPP(100, 200).sbb(10, 20)); //-10
console.log(new OPP(10, 20).multi()); //
console.log(new OPP().multi(10, 20)); //
console.log(new OPP(10, 20).div()); //0.5
console.log(new OPP().div(10, 20)); //0.5
</script>
运行结果：
4. 使用继承的方式实现：
<script>
function OPP(n1, n2) {
this.num1 = n1 || 0; // 当传入参数n1时，设置this.num1 = n1,否则设置为0；
this.num2 = n2 || 0; // 当传入参数n2时，设置this.num2 = n2,否则设置为0；
};
OPP.prototype.run = function() {
throw new Error('原型链中没有该方法，请从写该方法才能调用！');
}; function object(o) {
var G = function() {};
G.prototype = o;
return new G();
}; function inheritPrototype(subObj, superObj) {
//调用中间函数:object,实现把子类的原型对象指向中间函数G的实例，而G的实例指向想父类的原型对象，
// 同时把实例的constructor 属性指向子类；相当于在原型链中增加了一个实例，而实例作为子类的原型对象，这样子类就可以通过原型链实现对父类的继承了
var proObj = object(superObj.prototype);
// 调用object()函数的意义，基本上就是实现以下注释的功能
// var G = function() {};
// G.prototype = superObj.prototype;
// var proObj = new G();
proObj.constructor = subObj;
subObj.prototype = proObj;
}; function add(n1, n2) {
OPP.call(this, n1, n2);
};
inheritPrototype(add, OPP);
add.prototype.run = function() {
return this.num1 + this.num2;
}; function sbb(n1, n2) {
OPP.call(this, n1, n2);
};
inheritPrototype(sbb, OPP);
sbb.prototype.run = function() {
return this.num1 - this.num2;
}; function multi(n1, n2) {
OPP.call(this, n1, n2);
};
inheritPrototype(multi, OPP);
multi.prototype.run = function() {
return this.num1 * this.num2;
}; function div(n1, n2) {
OPP.call(this, n1, n2);
};
inheritPrototype(div, OPP);
div.prototype.run = function() {
return this.num1 / this.num2;
}; var huanying2015 = function(n1, n2, oper) {
switch (oper) {
case '+':
return new add(n1, n2).run();
break;
case '-':
return new sbb(n1, n2).run();
break;
case '*':
return new multi(n1, n2).run();
break;
case '/':
return new div(n1, n2).run();
break;
}
} console.log(huanying2015(100, 200, '+'));
console.log(huanying2015(100, 200, '-'));
console.log(huanying2015(100, 200, '*'));
console.log(huanying2015(100, 200, '/'));
</script>
运行结果：