javascript - 为什么在构建 Javascript 类层次结构时 Object.setPrototypeOf 不鼓励/效率低下？

Question

我读了一篇关于在类层次结构中保持数据私有(private)的文章 here .我这样做的方式不同。我将工厂函数与 Object.setPrototypeOf(obj, prototype) 一起使用.

为什么我的做法不被认为是好的做法？

---

这是我的做法:

我不需要公共(public)变量，所以我用工厂函数创建了我的狗对象:

const makeDog = (name) => {
    return { bark: () => { console.log(name) } }
}
const myDog = makeDog("sniffles")
myDog.bark() // "sniffles"

所有动物都可以吃，我希望我的狗继承 Animal:

const makeAnimal = () => {
    let numTimesEat = 0
    return { 
        eat: (food) => {
          numTimesEat += 1 
          console.log( "I eat " + food.toString() )
        },
        get numTimesEat() { return numTimesEat }
    }
}
const myAnimal = makeAnimal()

myDog 将委托(delegate)给 myAnimal 吃东西:

Object.setPrototypeOf(myDog, myAnimal)

现在我可以:

myDog.eat("shoe") // "I eat shoe"
console.log( myDog.numTimesEat ) // 1
myDog.bark() // "sniffles"

请注意，myDog.numTimesEat 应该是指 myDog 进食的次数。

---

附注我知道你可以通过类(class)来做到这一点:

class Animal {
  constructor() {
    this.numTimesEat = 0;
  }

  eat(food) {
    this.numTimesEat += 1;
    console.log( "I eat " + food.toString() );
  }
}

class Dog extends Animal {
  constructor(myName) {
    super();
    this.name = myName;
  }
  bark() {
    console.log( this.name );
  }
}

const dog2 = new Dog("sniffles");
dog2.eat("shoe"); // "I eat shoe"
console.log( dog2.numTimesEat ); // 1
console.log( dog2.name ); // "sniffles"
dog2.bark(); // "sniffles"

但是 class 关键字似乎最终会在我的对象上生成公共(public)变量。如果我尝试使用类似 these 的技术它看起来有点丑(我想下划线语法看起来还不错，但它并不是真正的私有(private))。

---

解决方案:

如果我们创建 10 只狗，它们都使用相同的 Animal 作为其原型(prototype)，则共享“let numTimesEat”。如果一只狗吃一次，您不希望 numTimesEat 为 10。

因此除了设置原型(prototype) 10 次(重复执行的缓慢操作)之外，您还必须为这 10 只狗创建 10 只动物以委托(delegate)给它们。

---

更新:相反，您可以将所有内容放在新创建的对象上

const Dog = function(name) {
    let that = Animal()
    that.bark = () => { console.log(name) }
    return that
}

const Animal = function() {
    let numTimesEat = 0
    return { 
        eat: (food) => {
          numTimesEat += 1 
          console.log( "I eat " + food.toString() )
        },
        get numTimesEat() { return numTimesEat }
    }
}

const lab = new Dog("sniffles")
lab.bark() // sniffles
lab.eat("food") // I eat food
lab.numTimesEat // 1

---

这比 trying to do OOP in Javascript 干净多了.

Answer 1

简单。

如果我们在 Javascript 中没有原型(prototype)或this，我们仍然可以愉快地进行 OOP 和继承，就像您描述的那样:

• 每个对象都包含它的方法
• 方法在闭包中有它们的共享状态

甚至没有隐藏状态:

• 每个对象都包含它的方法和状态
• 方法在闭包中引用对象

---

现在有人可能会说'嘿，我的对象有 2 个状态变量和 10 个方法，每当我想要一个新的对象实例时都需要复制 10 个方法，这不是很浪费吗？'

然后我们可以说“是的，让我们实际上在同一类型的所有对象之间共享函数”。但这会带来两个问题:

• 我们把它们放在哪里？ (好吧，让我们创建一个名为“原型(prototype)”的对象，让我们让每个实例都有一个对该原型(prototype)的隐藏引用)
• 该方法如何知道调用它的对象是什么？我们不能再将它放在闭包中了...(让我们将 this 作为隐藏参数传递给每个方法)

...因此我们到达了标准 JS OOP 的当前状态。在此过程中，我们牺牲了在方法闭包中保持私有(private)状态的可能性(因为每个对象只有一种方法)。

---

因此，您实际上不想去那里，而是停留在每个对象都有自己的方法副本的第一个位置。很好，您可以拥有私有(private)状态!但是为什么你此时甚至需要原型(prototype)呢？他们不能达到最初的目的。一个对象的 bark() 与另一个对象的 bark() 完全无关，它们有不同的闭包，它们不能共享。对于任何继承的方法都是一样的。

在这种情况下，因为您已经复制了所有方法，所以您也可以将它们保留在对象本身中。向每个对象添加(不同的)原型(prototype)并在其中放置父类(super class)方法不会给您带来任何好处，它只是为方法调用增加了一层间接性。