嘘,过来!想听秘密吗?
经典继承是一种经过考验和尝试的方法。
It is通常用 JavaScript 实现它很有用。类是一个很好的概念,并且拥有用于在对象之后建模我们的世界的模板非常棒。
经典的传承只是一种模式。如果您的用例需要这种模式,那么在 JavaScript 中实现经典继承是完全可以的。
原型继承注重共享功能性那就是awesome (恐龙鼓槌很棒),但在某些情况下您想要共享数据方案而不是功能。这是原型继承根本无法解决的问题。
那么,你是在告诉我,类并不像大家一直告诉我的那样是邪恶的?
不,他们不是。 JS 社区不赞成的不是类的概念,而是将自己限制在代码重用的类中。就像该语言不强制执行强类型或静态类型一样,它也不强制对象结构上的方案。
事实上,在幕后巧妙地实现了该语言can turn您通常会反对类似于经典继承类的东西。
那么,类在 JavaScript 中是如何工作的
好吧,你真的只需要一个构造函数:
function getVehicle(engine){
return { engine : engine };
}
var v = getVehicle("V6");
v.engine;//v6
我们现在有一个车辆类别。我们不需要使用特殊关键字显式定义 Vehicle 类。现在,有些人不喜欢用这种方式做事,而是习惯了更经典的方式。为此 JS 提供了(愚蠢的恕我直言)句法糖通过做:
function Vehicle(engine){
this.engine = engine;
}
var v = new Vehicle("V6");
v.engine;//v6
这在很大程度上与上面的示例相同。
那么,我们还缺少什么呢?
继承和私有成员。
如果我告诉你 JavaScript 中的基本子类型非常简单怎么办?
JavaScript 的类型概念与我们在其他语言中习惯的不同。 JS 中某种类型的子类型是什么意思?
var a = {x:5};
var b = {x:3,y:3};
类型是b
类型的子类型a
?假设是的话根据(强)行为子类型(LSP):
-
逆变子类型中的方法参数 - 完全保留在这种继承中。
-
协方差子类型中的返回类型的数量 - 完全保留在这种继承中。
- 子类型的方法不应引发新的异常,除非这些异常本身是超类型的方法引发的异常的子类型。 ——在这种传承中得到了完整的保存。
Also,
-
前提条件无法在子类型中得到强化。
-
后置条件在子类型中不能被削弱。
-
不变量超类型的属性必须保留在子类型中。
- 历史规律
所有这些又都由我们来保留。我们可以根据需要将它们保持得紧密或松散,我们不是必须这样做,但我们肯定可以。
事实上,只要我们在实现继承时遵守上述规则,我们就完全实现了强行为子类型,这是一种非常强大的子类型形式(参见注释*)。
>>>>>> 技术部分结束
简单地说,我们还可以看到结构子类型成立。
这将如何应用到我们的Car
例子?
function getCar(typeOfCar){
var v = getVehicle("CarEngine");
v.typeOfCar = typeOfCar;
return v;
}
v = getCar("Honda");
v.typeOfCar;//Honda;
v.engine;//CarEngine
不太难,不是吗?那么私人会员呢?
function getVehicle(engine){
var secret = "Hello"
return {
engine : engine,
getSecret : function() {
return secret;
}
};
}
See, secret
is a closure多变的。它是完全“私有”的,它的工作方式与Java等语言中的私有不同,但不可能从外部访问。
在函数中拥有私有变量怎么样?
啊!这是一个很好的问题。
如果我们想在原型上共享的函数中使用私有变量,我们需要首先了解 JS 闭包和函数是如何工作的。
在 JavaScript 中,函数是一流的。这意味着您可以传递函数。
function getPerson(name){
var greeting = "Hello " + name;
return {
greet : function() {
return greeting;
}
};
}
var a = getPerson("thomasc");
a.greet(); //Hello thomasc
到目前为止一切顺利,但是我们可以将绑定到 a around 的函数传递给其他对象!这可以让你做很宽松解耦这太棒了。
var b = a.greet;
b(); //Hello thomasc
等待!如何做b
知道这个人的名字叫 thomasc?这就是闭包的魔力。非常棒吧?
您可能担心性能。让我告诉你我是如何学会停止担忧并开始喜欢优化 JIT 的。
实际上,拥有这样的函数副本并不是什么大问题。 javascript 中的函数都是关于功能!闭包是一个很棒的概念,一旦你掌握并掌握了它们,你就会发现它是非常值得的,而且对性能的影响实际上并没有那么有意义。 JS 每天都在变得越来越快,不用担心这类性能问题。
如果你觉得复杂的话,下面的也很合理。与其他开发人员的共同合同只是说“如果我的变量以_
不要碰它,我们都是同意的成年人”。这看起来像:
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;
}
}
或者,如果您想在原型上缓存函数而不是实例化副本:
function Person(name){
this._name = name;
}
Person.prototype.greet = function(){
return "Hello "+this._name;
}
所以,总结一下:
您可以使用经典的继承模式,它们对于共享数据类型很有用
您还应该使用原型继承,它同样有效,并且在您想要共享功能的情况下更有效。
盗贼大师几乎做到了。私有化实际上并不像人们在 JavaScript 中想象的那样是一件大事,只要你的代码定义了一个清晰的接口,这根本就不应该有问题。我们都是专注于这里的成年人:)
*The clever reader might think: Huh? Weren't you tricking me there with the history rule? I mean, property access isn't encapsulated.
I say no, I was not. Even if you don't explicitly encapsulate the fields as private, you can simply define your contract in a way that does not access them. Often like TheifMaster suggested with _
. Also, I think the history rule is not that big of a deal in a lot of such scenarios as long as we're not changing the way property access treats properties of the parent object. Again, it's up to us.