基于 javascript 原型(prototype)的面向对象编程风格很有趣,但在很多情况下,您需要能够从类创建对象。
例如,在矢量绘图应用程序中,工作区在绘图开始时通常是空的:我无法从现有的“线”创建新的“线”。更一般地说,动态创建对象的每种情况都需要使用类。
我已经阅读了很多教程和“Javascript:好的部分”一书,但在我看来,没有办法定义尊重 1) 封装和 2) 高效成员方法声明的类(我的意思是:成员定义一次并在每个类实例之间共享的方法)。
为了定义私有(private)变量,使用了闭包:
function ClassA()
{
var value = 1;
this.getValue = function()
{
return value;
}
}
这里的问题是“ClassA”的每个实例都有它自己的成员函数“getValue”的副本,这是效率不高的。
为了有效地定义成员函数,使用原型(prototype):
function ClassB()
{
this.value = 1;
}
ClassB.prototype.getValue = function()
{
return this.value;
}
这里的问题是成员变量“value”是公开的。
我认为这个问题不容易解决,因为需要在对象创建期间定义“私有(private)”变量(以便对象可以访问其创建上下文,而不暴露这些值),而基于原型(prototype)的成员函数定义必须在对象创建之后完成,这样原型(prototype)才有意义(“this.prototype”不存在,我已经检查过)。
或者我错过了什么?
编辑:
首先,感谢您的有趣回答。
我只是想在我的初始消息中添加一点精确度:
我真正想做的是拥有 1)私有(private)变量(封装很好,因为人们只能访问他们需要的东西)和 2)有效的成员方法声明(避免复制)。
似乎简单的私有(private)变量声明实际上只能通过 javascript 中的闭包来实现,这就是我关注基于类的方法的根本原因。如果有一种方法可以使用基于原型(prototype)的方法实现简单的私有(private)变量声明,那对我来说没问题,我不是一个激烈的基于类的方法支持者。
阅读答案后,似乎简单的解决方案是忘记私有(private),并使用特殊的编码约定来阻止其他程序员直接访问“私有(private)”变量......
我同意,我的标题/第一句话对我想在这里讨论的问题具有误导性。
最佳答案
嘘,过来!想听个 secret 吗?
经典继承是一种经过测试和尝试的方法。
经常在 JavaScript 中实现它很有用。类是一个很好的概念,并且拥有在对象之后建模我们的世界的模板很棒。
经典继承只是一种模式。如果您的用例需要这种模式,那么在 JavaScript 中实现经典继承是完全可以的。
原型(prototype)继承侧重于共享功能,这很棒(dinasaur drumstick 很棒),但在某些情况下,您希望共享数据方案而不是功能。这是原型(prototype)继承根本无法解决的问题。
所以,你告诉我类(class)并不像每个人一直告诉我的那样邪恶?
不,他们不是。 JS 社区不赞成的不是类的概念,而是将自己限制在仅用于代码重用的类。就像语言不强制强类型或静态类型一样,它也不强制对象结构的方案。
事实上,语言的幕后巧妙实现can turn你的普通对象类似于经典继承类。
那么,类在 JavaScript 中是如何工作的
好吧,你真的只需要一个构造函数:
function getVehicle(engine){
return { engine : engine };
}
var v = getVehicle("V6");
v.engine;//v6
我们现在有一个车辆类。我们不需要使用特殊关键字显式定义 Vehicle 类。现在,有些人不喜欢以这种方式做事,而是习惯了更经典的方式。为此,JS 通过执行以下操作提供(愚蠢的 imho)语法糖:
function Vehicle(engine){
this.engine = engine;
}
var v = new Vehicle("V6");
v.engine;//v6
大多数情况下,这与上面的示例相同。
那么,我们还缺少什么?
继承和私有(private)成员。
如果我告诉你基本的子类型在 JavaScript 中非常简单怎么办?
JavaScript 的打字概念与我们在其他语言中习惯的不同。成为 JS 中某种类型的子类型是什么意思?
var a = {x:5};
var b = {x:3,y:3};
是
b
的类型a
类型的子类型?假设它是 according to (strong) behavioral subtyping (the LSP):<<<<开始技术部分
还,
所有这些都是再一次,由我们来保持。我们可以随心所欲地保持它们紧密或松散,我们不必这样做,但我们肯定可以。
所以事实上,只要我们在实现继承时遵守上面的这些规则,我们就完全实现了强行为子类型,这是一种非常强大的子类型(见注释*)。
>>>>> 结束技术部分
简单地说,人们还可以看到结构子类型是成立的。
这将如何适用于我们的
Car
例子?function getCar(typeOfCar){
var v = getVehicle("CarEngine");
v.typeOfCar = typeOfCar;
return v;
}
v = getCar("Honda");
v.typeOfCar;//Honda;
v.engine;//CarEngine
不会太难吧?私有(private)成员(member)呢?
function getVehicle(engine){
var secret = "Hello"
return {
engine : engine,
getSecret : function() {
return secret;
}
};
}
见,
secret
是一个闭包变量。它是完全“私有(private)的”,它的工作方式与 Java 等语言中的私有(private)不同,但不可能从外部访问。在函数中使用私有(private)怎么样?
啊!这是一个很好的问题。
如果我们想在原型(prototype)上共享的函数中使用私有(private)变量,我们首先需要了解 JS 闭包和函数是如何工作的。
在 JavaScript 中,函数是一流的。这意味着您可以传递函数。
function getPerson(name){
var greeting = "Hello " + name;
return {
greet : function() {
return greeting;
}
};
}
var a = getPerson("thomasc");
a.greet(); //Hello thomasc
到目前为止一切顺利,但我们可以将绑定(bind)到 a 的函数传递给其他对象!这使您可以进行非常松散的解耦,这非常棒。
var b = a.greet;
b(); //Hello thomasc
等待!
b
是怎么做的知道这个人的名字叫thomasc吗? That's just the magic of closures.很厉害吧?您可能会担心性能。让我告诉你我是如何学会不再担心并开始喜欢优化 JIT 的。
实际上,拥有这样的函数副本并不是什么大问题。 javascript 中的函数都是关于功能的!闭包是一个很棒的概念,一旦你掌握并掌握了它们,你就会发现它是非常值得的,而对性能的影响真的没有那么大的意义。 JS 一天比一天快,不用担心这些性能问题。
如果你觉得它很复杂,下面的也很合理。与其他开发人员的共同契约(Contract)只是简单地说“如果我的变量以
_
开头,请不要碰它,我们都是同意的成年人”。这看起来像:function getPerson(name){
var greeter = {
greet : function() {
return "Hello" +greeter._name;
}
};
greeter._name = name;
return greeter;
}
或者古典风格
function Person(name){
this._name = name;
this.greet = function(){
return "Hello "+this._name;
}
}
或者,如果您想在原型(prototype)上缓存函数而不是实例化副本:
function Person(name){
this._name = name;
}
Person.prototype.greet = function(){
return "Hello "+this._name;
}
所以,总结一下:
*聪明的读者可能会想:嗯?你不是在用历史规则欺骗我吗?我的意思是,属性访问没有被封装。
我说不,我不是。即使您没有明确地将字段封装为私有(private),您也可以简单地以不访问它们的方式定义您的契约(Contract)。经常像 TheifMaster 建议的那样
_
.此外,我认为只要我们不改变属性访问处理父对象属性的方式,历史规则在很多这样的场景中并不是什么大问题。再次,这取决于我们。
关于javascript - 无法在 javascript 中拥有基于类的对象?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/17008086/