【重构笔记03】对象之间搬迁特性

前言

在面向对象设计过程中，“决定把责任放在那儿”即使不是最重要的事，也是最重要的事之一。
这个思想其实对类较重要，在js中，函数应该完成什么职责，也需要分清楚，不要函数做了自己的事情，又做了一部分其它函数的事情。

在js中，往往只有一个类，面向对象的思想其实比较难，没有一定功力不能很好的运用，我也在学习
很多js中其实就只有一个类，一个插件就是一个类，而且这个类还是假的，继承、封装神马的要理解还是不容易的，所以路还长！

搬迁函数

我们的程序中如果有个函数与其所驻类的另一个类有更多的交流（调用后者、或者被后者调用）
那么在该函数最常引用的类中建立一个有着类似行为的新函数，将久函数变成一个单纯的委托函数，或者移除旧函数

搬迁函数是重构理论的支柱，如果一个类有太多行为，或者一个类与另一个类有太多合作而成高度耦合，我们就需要搬迁函数
PS：其实在单页应用中，MVC的结构很可能导致这种情况发现，后面点我们搞点代码出来看看

我们的程序中会有这样的函数，使用另一个对象次数比使用自己的次数还多，搬迁时这就是函数归属的重要依据

来一个例子吧，这里利用一个表示“账户”的Account类来说明

var AccountType = function () {};
AccountType.prototype = {
    isPremium: function () { return true; }
};
var Account = function () {
    this._type = new AccountType();
    this._daysOverdran;
};
Account.prototype = {
    overdraftCharge: function () {
        if (this._type.isPremium()) {
            var result = 10;
            if (this._daysOverdran > 7) result += (this._daysOverdrawn - 7) * 0.85;
            return result;
        } else {
            return this._daysOverdran * 1.75;
        }
    },
    bankCharge: function () {
        var result = 4.5;
        if (this._daysOverdran > 0) result += this.overdraftCharge();
        return result;
    }
};

在这个程序中，加入有几种新账户，每一种都有自己的“透支金额计费规则”，所以overdraftCharge可能需要搬迁到AccountType中去

如何做

首先，我们要观察overdraftCharge使用的每一项特性，考虑那些特性是否可与他一起搬迁

这个程序中，_dayOverdrawn会被留下，因为这个值会随不同账号变化而变化，于是调整后的代码如下：

var AccountType = function () {};
AccountType.prototype = {
    isPremium: function () { return true; },
    overdraftCharge: function (account) {
        if (this.isPremium()) {
            var result = 10;
            if (account.getDaysOverdran() > 7) result += (account.getDaysOverdran() - 7) * 0.85;
            return result;
        } else {
            return account.getDaysOverdran() * 1.75;
        }
    }
};
var Account = function () {
    this._type = new AccountType();
    this._daysOverdran;
};
Account.prototype = {
    bankCharge: function () {
        var result = 4.5;
        if (this._daysOverdran > 0) result += this._type.overdraftCharge(this);
        return result;
    }
};

这里也可以将daysOverdrawn作为参数传入，但是如果后面会传入多个字段，就要改代码，所以直接传入对象吧

搬移字段

搬移字段在再js程序中可能用得会多一点，在我们的程序中，某个字段被自己类之外的类多次使用的话

那么，在目标类新建一个字段，修改源字段的所有用户，让他们使用新字段

为什么这么干？

在类之间移动状态和行为，是重构过程中必不可少的措施，随着系统发展，我们会发现，自己需要新的类，并需要将现有工作责任移动新类中

但是这个星期看似合理正确的设计决策，下个星期可能就错了的情况也不是没有

如果我们发现，一个字段被其它类过多使用，那么我们就该抛弃他了

范例

继续我们上面的例子吧

var Account = function () {
    this._type = new AccountType();
    this._interestRate;
};
Account.prototype = {
    interestForAmount_days: function (amount, days) {
        return this._interestRate * amount * days / 365;
    }
};

我们现在想把表示利率的_interestRate搬移到AccountType类去，目前已经有几个函数引用他了，interestForAmount_days是其中之一

所以我们现在AccountType中建立_interestRate字段与相应函数，以下是重构后的代码

var AccountType = function () {
    this._interestRate;
};
AccountType.prototype = {
    getInterestRate: function () {
        return this._interestRate;
    }
};
var Account = function () {
    this._type = new AccountType();
};
Account.prototype = {
    interestForAmount_days: function (amount, days) {
        return this.type.getInterestRate() * amount * days / 365;
    }
};

提炼类

某个类做了应该两个类做的事，那么就新建一个类，将相关的字段和函数移过去

PS：我们从开始到现在就了解了，重构的一大手段就是消除临时变量，另一个方法就是职责分离了

我们经常听到这句话，一个类应该是一个清除的抽象，处理一些明确的责任，但在实际工作中，类会不断扩张

我们会在这加一些功能，然后在那加一些数据，给某个类添加一项新任务时，你会觉得不值得为这项责任分离出一个单独的类

于是责任不断增加，这个类最后就会越来越复杂，很快这个类就连自己也不想读了

这样的类往往有大量的函数和数据，所以不好理解，这个时候我们需要考虑应该分离哪部分，并将它们写到一个单独的类中

如果这些数据和某些函数总是一起出现，某些数据经常同时变化，那么就分离吧

PS：说了这么多还是虚的，来一段代码吧

var Person = function () {
    this._name;
    this._officeAreaCode;
    this._officeNumber;
};
Person.prototype = {
    getName: function () { return this._name; },
    getTel: function () {
        return '(' + this._officeAreaCode + ')' + this._officeNumberl;
    },
    getOfficeAreaCode: function () {
        return this._officeAreaCode;
    },
    setOfficeAreaCode: function (arg) {
        this._officeAreaCode = arg;
    },
    getOfficeNumber: function () {
        return this._officeNumber;
    },
    setOfficeNumber: function (arg) {
        this._officeNumber = arg;
    }
};

这里，我们可以将电话号码相关行为分离到一个独立的类中，优化后的代码：

var Tel = function () {
    this._number;
    this._areaCode;
};
Tel.prototype = {
    getAreaCode: function () {
        return this._areaCode;
    },
    setAreaCode: function (arg) {
        this._areaCode = arg;
    },
    getNumber: function () {
        return this._number;
    },
    setNumber: function (arg) {
        this._number = arg;
    }
};
var Person = function () {
    this._name;
    this.tel = new Tel();
};
Person.prototype = {
    getName: function () { return this._name; },
    getTel: function () {
        return '(' + this.tel.getAreaCode() + ')' + this.tel.getNumber();
    }
};

想想，Person当然不只Tel这点属性，Tel也可能会有其它动作，如果写在一起，后面代码膨胀是可以预见的

将类内联化

如果某个类没做什么事情，那么将类消除吧，将他完成的特性移动到另一个类中，这个方法与提炼类完全相反

范例就是将上面的代码写回去......

隐藏委托关系

客户通过一个委托来调用另一个对象，在服务器上建立客户的所有函数，用以隐藏委托关系

“封装”即使不是对象最关键的特征，也是最关键的特征之一

封装意味着每个对象都应该尽可能少了解系统其它部分，如此一来，其它地方变化了，就管我屁事了（变化比较容易进行）

范例

本例中，出了人以为，多了一个部门的类啦：

var Department = function (manager) {
    this._chargeCode;
    this._manager = manager;
};
Department.prototype = {
    getManager: function () {
        return this._manager;
    }
};
var Person = function () {
    this._department;
};
Person.prototype = {
    getDepartment: function () {
        return this._department;
    }
};

如果客户想知道某人的经理是谁，他必须先取得Department对象

manager = p.getDepartment().getManager()

这样有一个问题就是，对用户揭露了Department的工作原理，于是客户指定通过Department可以追踪经理信息，如果可以隐藏Department的话，就可以减少耦合

这里就来一个委托：

var Department = function (manager) {
    this._chargeCode;
    this._manager = manager;
};
Department.prototype = {
    getManager: function () {
        return this._manager;
    }
};
var Person = function () {
    this._department;
};
Person.prototype = {
    getDepartment: function () {
        return this._department;
    },
    getManager: function () {
        return this._department.getManager();
    }
};

这样的话，用户就不知道有Department这个东西了

移除中间人

某个类做了过多的简单委托动作，那么就让用户之间调用委托类吧

这个与上面的是反着的，各位对照着看吧

引入外加函数

我们有时需要为提供服务的类增加一个函数，但我们无法修改这个类，那么在客户类中建立一个函数，并以第一参数形式传入一个服务器类实例

var d = new Date(previousEnd.getYear(), previousEnd.getMonth(), previousEnd.getDay() + 1);

var d = nextDay(previousEnd);
function nextDay(arg) {
    return new Date(arg.getYear(), arg.getMonth(), arg.getDay() + 1);
}

这种事情发生的很多，我们正在使用一个类，他提供了很多服务，但是我们突然需要一个新类，这个类却无法提供，那么我们可能会咒骂，完了修改源码

如果源码不能修改，我们就得在客户端补齐函数啦

引入本地扩展

你需要为服务类提供一些额外函数，但你无法修改这个类，建立一个新类，使他包含这些额外的函数，让这个扩展成为源类的子类或者包装类

这个与上面类似，小的要看神都龙王去了，所以暂时到这吧......