如果我们有很多重复的值且表示一样的含义，但没有明确地说明，那么我们应该将它们转换为常量，以便每个人都知道它们的含义，并且如果需要更改，我们只需更改一个地方就行了。

例如我们可能会这样写代码：

const getWeight = (mass) => mass * 9.81 
const potentialEnergy = (mass, height) => mass * height * 9.81 

对于含义相同的数学我可以用常量表示：

const GRAVITATIONAL_CONSTANT = 9.81; 
const getWeight = (mass) => mass * GRAVITATIONAL_CONSTANT 
const potentialEnergy = (mass, height) => mass * height * GRAVITATIONAL_CONSTANT 

现在我们知道9.81实际上意味着GRAVITATIONAL_CONSTANT，我们不必重复自己。

上面我们用常量 GRAVITATIONAL_CONSTANT 表示 9.81 ，这样别人一看就知道它表示是万有引力常数常量。

我们可以将getter和setter添加到类的字段中，这样就不心直接对类的字段进行操作。

例如我们可能会这样写代码：

class Person { 
  constructor(name) { 
    this.name = name; 
  } 
} 

如果要控制如何设置值，可以这样重构：

class Person { 
  constructor(name) { 
    this._name = name 
  } 
 
  get name() { 
    return this._name 
  } 
 
  set name() { 
    this._name = name 
  } 
} 

这样，我们就可以控制如何设置值，因为我们可以在setter中放入代码来设置名称。我们还可以控制谁能获得名称，因为它是在getter中返回的。

我们可以将字段替换为其自己的数据类，这样在记录数据中会有更强灵活性。

例如我们可能会这样写代码：

class Person { 
  constructor(name, bloodGroup) { 
    this.name = name; 
    this.bloodGroup = bloodGroup; 
  } 
} 
const person = new Person('joe', 'a') 

如果我们想扩充 bloodGroup (血型)的种类，我们可以把 bloodGroup 重构成一个类。

class BloodGroup { 
  constructor(name) { 
    this.bloodGroup = name; 
  } 
} 
class Person { 
  constructor(name, bloodGroup) { 
    this.name = name; 
    this.bloodGroup = bloodGroup; 
  } 
} 
const bloodGroup = new BloodGroup('a'); 
const person = new Person('joe', bloodGroup) 

这样，我们就可以在bloodGroup字段中存储更多种类的数据。

有时，我们可以根据对象的类型创建子类，而不是在类中使用类型字段。这样，我们就可以在它们自己的子类中拥有两个类不共享的更多成员。

例如我们可能会这样写代码：

class Animal { 
  constructor (type) { 
    this.type = type 
  } 
} 
 
const cat = new Animal('cat') 
const dog = new Animal('dog')

我们可以根据 type 类型来重构对应的类：

class Animal { 
  //... 
} 
class Cat extends Animal { 
  //... 
} 
class Dog extends Animal { 
  //... 
} 
const cat = new Cat(); 
const dog = new Dog(); 

在上面的示例中，我们单独编写一个Animal类，而另外添加Cat和Dog类，它们是Animal类的子类。

这样我们可以 Cat 和 Dog 类中共享的属性保存在各自的类的，把共享的放在 Animal 类中。

我们可以将长的条件表达式分解为更小的条件表达式。

例如我们可能会这样写代码：

let ieIEMac = navigator.userAgent.toLowerCase().includes("mac") && navigator.userAgent.toLowerCase().includes("ie") 

我们可以这样重构它：

let userAgent = navigator.userAgent.toLowerCase(); 
let isMac = userAgent.includes("mac"); 
let isIE = userAgent.toLowerCase().includes("ie"); 
let isMacisMacIE = isMac && isIE; 

我们将冗长又难懂的条件表达式分解多个短小表达式，这样会大大滴增加阅读性。

如果我们有很多重复的值且表示一样的含义，但没有明确地说明，那么我们应该将它们转换为常量，以便每个人都知道它们的含义，并且如果需要更改，我们只需更改一个地方就行了。

为了更好控制类的属性，我们可以为它添加getter和setter方法。

如果我们有type字段，则可以用它们自己的子类替换它们。

最后，我们可以将长条件表达式分解为较小的条件表达式，以便于阅读和理解。

原文来自：

本文地址：//gulass.cn/javascript-object-refactoring.html编辑：KSJXAXOAS，审核员：逄增宝

Linux大全：

Linux系统大全：

红帽认证RHCE考试心得：