首页
学习
活动
专区
圈层
工具
发布
社区首页 >问答首页 >可以对继承进行建模吗?

问可以对继承进行建模吗?
EN

Stack Overflow用户
提问于 2019-11-06 13:58:58
回答 2查看 109关注 0票数 3

关于这个问题,我的主要信息来源来自James在这个地址的教程:http://www.objectplayground.com/ .在重新看了几次视频之后,我带了足够多的时间来拼凑出一系列的课程,但我仍然不太明白到底是怎么回事。James解释它的方式是:经典模型继承(我假设它指的是使用类来组织数据,而不是一种较旧的处理事物的方式)的工作方式如下:

计算任何函数定义语句时,都会创建两个对象。创建的第一个对象是构造函数(为了这个问题而调用cStruct ),它的成员称为Prototype (根据他和许多其他源指向函数对象原型( Function.prototype )),它可以识别。但是,它变得奇怪了,因为创建的第二个对象是Prototype (或proType),它反过来可以由自己的名为cStruct的构造函数来标识,还有它自己的原型成员,它指向对象对象原型,或者只有Object.prototype。好的,够简单了(ha!),但随后他(和其他源)继续;当一个类扩展另一个类时,我们放弃扩展类(更新/窄)类proType,将它替换为一个新类,它实际上指向扩展(原始/旧/更广)类proType。

好的,通过这个描述,我尝试使用只使用null原型作为构建块的对象来重新创建继承模型,这样我就可以在控制台中检查结果,而不必筛选我还不理解的所有内容。--基本上,我在寻找继承的冒烟之枪;证明它不仅仅是的魔术。这似乎是可能的,但一旦以代码形式建立了逻辑,它就不会如此意外地不能交付继承的属性。你会明白我的意思的。

公共实践-三节课

代码语言:javascript
复制
function ExampleClass_A (  ) {  }
function ExampleClass_B (  ) {  }
function ExampleClass_C (  ) {  }

文字解释

,注意,,这些是字面上模拟的类。它们演示了我所理解的在编写类时在幕后所发生的事情。在这一点上,c变量几乎可以被忽略,直到我们以后开始扩展类。

代码语言:javascript
复制
a = Object.create( null );
b = Object.create( null );
c = Object.create( null );  // this represents the Object Prototype
cStruct_A               = a;
proType_A               = b;
proType_A.prototype     = c;
cStruct_A.prototype     = b;
proType_A.constructor   = a;
delete a; delete b;

a = Object.create( null );
b = Object.create( null );
cStruct_B               = a;
proType_B               = b;
proType_B.prototype     = c;
cStruct_B.prototype     = b;
proType_B.constructor   = a;
delete a; delete b;

a = Object.create( null );
b = Object.create( null );
cStruct_C               = a;
proType_C               = b;
proType_C.prototype     = c;
cStruct_C.prototype     = b;
proType_C.constructor   = a;
delete a; delete b; delete c;

通用实践--线性类扩展

编辑 @Vog,我不知道什么是对象组合,但是如果我不得不猜测,这是类扩展/实例化的另一种模式,而不是我在这个问题中编写的线性扩展/实例化模式,在这个问题中,我必须假设某种形式的继承正在发生。当然,我不准备接受一种模式而不是另一种模式,因为我只是想了解使这些模式可行的机制最初是如何工作的。

代码语言:javascript
复制
ExampleClass_B.prototype = Object.create( ExampleClass_A.prototype );
ExampleClass_C.prototype = Object.create( ExampleClass_B.prototype );

文字解释

注意如果我正确理解了这一点,为了使继承在主类之后的所有子类的proType工作,或者其他子类必须指向其父类的proType。在这里,我们去掉了三个类proType_s中的两个,并将它们替换为指向适当的“假设”位置的类。

代码语言:javascript
复制
a                       = Object.create( null );
a.prototype             = proType_A;
a.constructor           = cStruct_B;
alt_proType_B           = a;
cStruct_B.prototype     = alt_proType_B;
delete proType_B;
delete a;

a                       = Object.create( null );
a.prototype             = alt_proType_B;
a.constructor           = cStruct_C;
alt_proType_C           = a;
cStruct_C.prototype     = alt_proType_C;
delete proType_C;
delete a;

通用实践--实例化

代码语言:javascript
复制
var exampleInstance_W = new ExampleClass_A();   //  
var exampleInstance_R = new ExampleClass_B();   //  randomly chosen names
var exampleInstance_T = new ExampleClass_C();   //  

文字解释

代码语言:javascript
复制
a = Object.create( null );
a.prototype             = proType_A;
nstance_W               = a;
delete a;

a = Object.create( null );
a.prototype             = alt_proType_B;
nstance_R               = a;
delete a;

a = Object.create( null );
a.prototype             = alt_proType_C;
nstance_T               = a;
delete a;

公共实践-作业

代码语言:javascript
复制
ExampleClass_A.prototype.prop_a = "test a,";
ExampleClass_B.prototype.prop_b = "test b,";
ExampleClass_C.prototype.prop_c = "test c";

文字解释

,注意,,在这里,我开始看到可能出了什么问题

代码语言:javascript
复制
cStruct_A.prototype.prop_a = "test a,";
cStruct_B.prototype.prop_b = "test b,";
cStruct_C.prototype.prop_c = "test c";

//  proType_A.prop_a = "test a";    //
//  proType_B.prop_b = "test b";    //  Kind of cool that this works
//  proType_C.prop_c = "test c";    //

测试-通用实践

代码语言:javascript
复制
console.log(
    exampleInstance_T.prop_a,  //  successful log
    exampleInstance_T.prop_b,  //  successful log
    exampleInstance_T.prop_c,  //  successful log
);

测试--文字解释

现在注意到是所有这些努力的顶点。令人困惑的是这些日志产生了不同的结果。

代码语言:javascript
复制
console.log(
    nstance_T.prototype.prop_a,     //  unsuccessful log
    nstance_T.prototype.prop_b,     //  unsuccessful log
    nstance_T.prototype.prop_c,     //  successful log
);

console.log(
    nstance_R.prototype.prop_a,     //  unsuccessful log
    nstance_R.prototype.prop_b,     //  successful log
    nstance_R.prototype.prop_c,     //  unsuccessful log
);

console.log(
    nstance_W.prototype.prop_a,     //  successful log
    nstance_W.prototype.prop_b,     //  unsuccessful log
    nstance_W.prototype.prop_c,     //  unsuccessful log
);

console.log(                        //  Kind of lame that this does't work
    nstance_W.prop_a,               //  
    nstance_R.prop_b,               //  I mean it makes sense when you follow the
    nstance_T.prop_c,               //  established logic, but at the same time
);                                  //  it means that I'm missing something.

换句话说,如果每个文字解释代码块只是在模仿上面的公共实践代码块,那么为什么nstance_t不能访问.prop_a和.prop_b呢?这跟我的配置有关吗?我没抓住重点吗?帮帮我伙计们。提前谢谢。

EN

回答 2

Stack Overflow用户

回答已采纳

发布于 2019-11-07 02:09:35

为什么nstance_t不能访问.prop_a和.prop_b?这跟我的配置有关吗?我没抓住重点吗?

似乎您期望.prototype设置对象的继承链。它没有,它只是一个普通的财产,分配它没有任何魔术。

对象继承的对象(或null)的实际引用是内部的,通常表示为[prototype]。您需要调用Object.getPrototypeOf(…)来访问它。要设置它,可以使用Object.create、Object.setPrototypeOf或new。

我相信这就是你要找的代码:

公共实践- ES6

代码语言:javascript
复制
class A {}
class B extends B {}
const instance = new B

公共实践- ES5

代码语言:javascript
复制
function A() {}
function B() {}
B.prototype = Object.create(A.prototype)
B.prototype.constructor = B
const instance = new B

文字解释(对象关系的解释,忽略构造函数调用)

代码语言:javascript
复制
A_prototype = Object.create(Object.prototype)
A_constructor = new Function(…)
A_prototype.constructor = A_constructor
A_constructor.prototype = A_prototype

B_prototype = Object.create(A_constructor.prototype)
B_constructor = new Function(…)
B_prototype.constructor = B_constructor
B_constructor.prototype = B_prototype

instance = Object.create(B_constructor.prototype)

现在可以在A_prototype/A_constructor.prototype和B_prototype/B_constructor.prototype上分配属性,并在instance上看到它们被继承。

票数 1
EN

Stack Overflow用户

发布于 2019-11-06 14:09:39

虽然我为你建立这样一个东西的好奇心鼓掌,但请注意继承是一种众所周知的反模式。(经典的)面向对象的编程还有更多的方面受到质疑“今天”(在过去的十年里,如果不是更长的话)。然而,继承是几乎每个有经验的程序员都会建议反对的东西。

这里的口号是永远使用对象组合,而不是尽可能地继承(在我看来,这几乎总是如此)。

这与在JavaScript之上建模一个合适的类型系统是不同的。或者,模型解构与结构模式匹配。这些玩具也可能永远不会在生产中使用,但至少你会制造一些你以后真正想要使用的东西。

请注意,继承在任何语言中都没有实现,无论是C++、Python、Ruby、PHP、Smalltalk、Java等等。您甚至可以在GoF书(https://en.wikipedia.org/wiki/Design_Patterns)中找到早期提示,这是大多数OO程序员的一种圣经。在那里,虽然继承没有被直接批评,但是您可以将整个模式总结为“如何用一个维护良好的对象组合结构来替换一个难以维护的继承结构”。

票数 0
EN
页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接:

https://stackoverflow.com/questions/58731842

复制
相关文章

相似问题

领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档