我读了一篇关于在类层次结构中保持数据私有(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 干净多了.
最佳答案
简单。
如果我们在 Javascript 中没有原型(prototype)或this
,我们仍然可以愉快地进行 OOP 和继承,就像您描述的那样:
- 每个对象都包含它的方法
- 方法在闭包中有它们的共享状态
甚至没有隐藏状态:
- 每个对象都包含它的方法和状态
- 方法在闭包中引用对象
现在有人可能会说'嘿,我的对象有 2 个状态变量和 10 个方法,每当我想要一个新的对象实例时都需要复制 10 个方法,这不是很浪费吗?'
然后我们可以说“是的,让我们实际上在同一类型的所有对象之间共享函数”。但这会带来两个问题:
- 我们把它们放在哪里? (好吧,让我们创建一个名为“原型(prototype)”的对象,让我们让每个实例都有一个对该原型(prototype)的隐藏引用)
- 该方法如何知道调用它的对象是什么?我们不能再将它放在闭包中了...(让我们将
this
作为隐藏参数传递给每个方法)
...因此我们到达了标准 JS OOP 的当前状态。在此过程中,我们牺牲了在方法闭包中保持私有(private)状态的可能性(因为每个对象只有一种方法)。
因此,您实际上不想去那里,而是停留在每个对象都有自己的方法副本的第一个位置。很好,您可以拥有私有(private)状态!但是为什么你此时甚至需要原型(prototype)呢?他们不能达到最初的目的。一个对象的 bark()
与另一个对象的 bark()
完全无关,它们有不同的闭包,它们不能共享。对于任何继承的方法都是一样的。
在这种情况下,因为您已经复制了所有方法,所以您也可以将它们保留在对象本身中。向每个对象添加(不同的)原型(prototype)并在其中放置父类(super class)方法不会给您带来任何好处,它只是为方法调用增加了一层间接性。
关于javascript - 为什么在构建 Javascript 类层次结构时 Object.setPrototypeOf 不鼓励/效率低下?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/45120928/