面向对象的链式调用

1、 对象的链式调用

function Chain(){
　　this.n=0;//属性不一定一开始的时候全部都要初始化
　　this.fn1=function(_obj){//this指向  new Chain()实例化的对象
　　　　alert(this.n++);//注意：alert(this.n++)与this.fn1中的this 不一定指向的对象是一样的
　　　　return this;
　　}
　　this.fn2=function(){//同上
　　　　alert(this.n++);//注意：alert(this.n++)与this.fn1中的this 不一定指向的对象是一样的
　　　　return this;
　　}
}

var _chain1 = new Chain();
var _chain2 = new Chain();
_chain1.fn1().fn2();//依次弹出 0 ， 1
_chain2.fn2().fn1();//依次弹出0 ， 1
_chain1.fn1();//弹出 0
_chain2.fn2().fn1().fn2();//依次弹出 2 ， 3 ， 4（注意：由于前面的_chain2.fn2().fn1()）

2、此代码能解决链式调用，但不能解决顺序执行

function Asynchronous(){
　　var _self=this;

//由于ajax的回调函数（callBack），this的指向指向window对象下，要想this指向new Asychronous()实例化对象，需要用_self=this,指向实例化对象
　　this.visitJson1=function(){
　　　　ajaxRequest("post","json1.json",true,null,function(data){
　　　　　　alert(data);
　　　　});
　　}
　　this.visitJson2=function(){
　　　　ajaxRequest("post","json2.json",true,null,function(data){
　　　　　　alert(data);
　　　　});
　　}
　　this.visitJson3=function(){
　　　　ajaxRequest("post","json3.json",true,null,function(data){
　　　　　　alert(data);
　　　　});
　　}
}
var _async=new Asynchronous();
_async.visitJson1().visitJson2().visitJson3();//弹出的结果也不一定按照json1,json2,json3输出,由于ajax异步,不能同步输出（即顺序输出）

//正确的如下  （封装的ECMAScript 6中的promise函数）

function Asynchronous(fn){

　　this.list = [fn];//把promise当中所有的then内回调函数添加到数组中;之所以用数组，因为ajax是一个不确定什么时候执行完的机制,是异步的,

　　//要想要每个函数同步输出（顺序输出）,需要把函数它们放进一个数组里面,依次执行
　　this.state = 0;//默认为回调函数未完执行成状态
　　this.n = 0;//作用：标记应该执行第几个回调函数
　　/**
　　* then作用：只是把回调函数存到数组当中，然后等待被调用。
　　*/
　　this.then = function(fx){
　　　　this.list.push(fx);
　　　　return this;
　　}
　　/**
　　* 等待被resolve方法按顺序调用，调用后执行数组中的特定的方法
　　*/
　　this.exec = function(n){
　　　　if(this.state == 1){
　　　　　　this.state == 0;//由于以后有出错 的属性 ，故需要state状态
　　　　　　this.fm = this.list[n];//注意：只将function赋值给this.fm,由于this.list[n]数组也是一个对象，this指向数组的某一项,达不到this指向实例化对象
　　　　　　this.fm();
　　　　}
　　}
　　/**
　　* 由回调函数来调用，实例化对象时也自动调用一次;
　　*/
　　this.resolve = function(){//表示执行该回调函数执行完成
　　　　this.state = 1;
　　　　if(this.n < this.list.length){
　　　　　　this.exec(this.n++);
　　　　}
　　}
　　this.resolve();
}

new Asynchronous(function(){
　　var _self = this;
　　ajaxRequest("post","json/json0.json",true,null,function(data){
　　　　alert(data);
　　　　_self.resolve();//由于这是ajax回调函数里面，this的指向的对象是window下，需要改变this的指向，故用_self
　　});

}).then(function(){
　　var _self = this;
　　ajaxRequest("post","json/json1.json",true,null,function(data){
　　　　alert(data);
　　　　_self.resolve();//由于这是ajax回调函数里面，this的指向的对象是window下，需要改变this的指向，故用_self
　　});
}).then(function(){
　　var _self = this;
　　ajaxRequest("post","json/json2.json",true,null,function(data){
　　　　alert(data);
　　　　_self.resolve();//由于这是ajax回调函数里面，this的指向的对象是window下，需要改变this的指向，故用_self
　　});
}).then(function(){

　　var _self = this;
　　ajaxRequest("post","json/json3.json",true,null,function(data){
　　　　alert(data);
　　　　_self.resolve();//由于这是ajax回调函数里面，this的指向的对象是window下，需要改变this的指向，故用_self
　　});
});

3、面向对象的继承

 

function Sign(){
　　this.account="";
　　this.password="";
　　this.sign=function(){
　　　　if(this.account=="abcde" && this.password=="123456"){
　　　　　　alert("登录成功");
　　　　}else{
　　　　　　alert("登录失败");
　　　　}
　　}
}
function Register(){
　　this.abc=0;
　　this.register=function(){
　　　　this.account="abcde";
　　　　this.password="123456";
　　}
}
function Exit(){
　　this.exit=function() {
　　this.account = null;
　　this.password = null;
　　}
}
Register.prototype=new Exit();//Register对象拥有Exit对象的实例属性和方法以及原型属性和方法
Sign.prototype=new Register();//Sign对象拥有Register对象的实例属性和方法以及原型属性和方法
var _user=new Sign();
_user.register();
_user.sign();//输出登录成功
_user.exit();
_user.sign();//输出登录失败

 

function main(){
　　alert(_user.hasOwnProperty("abc"));//输出false 对象.hasOwnProperty("属性名"); (boolean属性,检测"abc"是不是_user这个对象的实例属性
　　alert(Register.prototype.isPrototypeOf(_user));//输出true 对象属性.isPrototypeOf(对象); (boolean属性，检测“Register.prototypeOf”是不是"_user"这个对象的原型属性)
　　if("abc" in _user){//无论“abc”是_user这个对象的实例属性还是原型属性,都输出 true，除非“abc”既不是实例属性也不是原型属性（boolean值）
　　　　if(_user.hasOwnProperty("abc")){
　　　　　　alert("该属性是实例属性");
　　　　}else{
　　　　　　alert("该属性是原型属性");
　　　　}
　　}
}
main();