标签: prototypal-inheritance

每个人似乎都普遍认为原型继承比类继承更简单,更灵活.我在文献中没有看到的,我读过很多关于原型继承的事情的例子,你不能用经典的东西.所以我提出一个简单的问题:

您可以使用原型继承的一些模式,您不能使用类继承,以及在何时/何时使用它时您将给出的指导是什么？

我试图深入了解原型继承和类创建(我知道,还有其他方法,但为了这个目的,我试图掌握原型.)我的问题是:使用下面的代码示例,是有没有办法内部创建私有变量Tree,并Fruit不会与该函数返回,但仍是原型函数访问genus和bulk？

var Tree = function ( name, size ) { 
    this.name = name;
    this.size = size;
};

Tree.prototype.genus = function(){
    return ((typeof this.name !== 'undefined') ? this.name : 'Hybridicus Maximus');
};
Tree.prototype.bulk = function(){
    return ((typeof this.size !== 'undefined') ? this.size : '8') + ' ft';
};


var Fruit = function( name, size ) { 
    this.name = name;
    this.size = size;
};

Fruit.prototype = new Tree();
// Fruit.prototype = Tree.prototype; -- I …

"JavaScript是世界上最容易被误解的语言"-D.Crockford

我的问题:

1. 构造函数和原型用简单的英语？
2. 使用原型需要什么？使用Prototypes和构造函数的目的是什么？我的意思是他们提供更多的灵活性.我问这个,因为我过去六个月一直在使用这种语言,从来没有使用过原型和构造函数的情况.

我不是在寻找任何语法以及如何进行解释,因为我理解它们的某些部分,只是想以更简单的方式了解这些事情.类比(非技术)或例子会很棒.*

详细说明我问这个问题的原因(如果你愿意,请忽略):

我在过去的六个月里一直在使用JavaScript,当我发现JavaScript是一种基于原型的语言时,我感到非常震惊.

我经历了一些关于如何使用JavaScript并遇到原型和构造函数的Stack Overflow问题.

我学会了它,现在我可以说在构造函数和原型方面我不是一个菜鸟.我熟悉语法.但是我仍然觉得我错过了一些东西而没有深入到这种语言的核心,我有时会感到困惑.

我希望我很清楚.

我正在寻找任何指示是否"超类"内置类型将根据规范工作.也就是说,假设任何假设符合ECMAScript的实现,"内置"的"超类"是否通过影响类构造函数的创建算法来破坏运行时？

"Superclassable",我正在创造的一个术语,指的是一个类,通过构造它来返回它,或者将它作为一个函数调用它,如果适用,将使用相同的内部插槽创建([[Prototype]]除外),无论如何它的直接超类是什么,只要类构造函数的初始[[Prototype]]和类原型在重新分配它们之后仍然在每个相应的继承链中.因此,为了成为"超类",类不得 super()在创建期间调用.

当"超级分类"时Array,我希望它看起来像这样:

// clearly this would break Array if the specification allowed an implementation
// to invoke super() internally in the Array constructor
class Enumerable {
  constructor (iterator = function * () {}) {
    this[Symbol.iterator] = iterator
  }

  asEnumerable() {
    return new Enumerable(this[Symbol.iterator].bind(this))
  }
}

function setSuperclassOf (Class, Superclass) {
  /* These conditions must be satisfied in order to
   * superclass Class with Superclass
   */
  if (
    !(Superclass.prototype instanceof …

function F() {
    return function() {
        return {};
    }
}

var f = new F();
f instanceof F; // returns false

据我所知,如果我想instanceof工作,我需要this从构造函数返回.但我希望构造函数返回一个函数,我无法分配给this.

那么,这真的是不可能的,还是可以以某种方式完成,f = new F()以便返回一个函数并仍然f instanceof F返回true？

有很多文章和帖子解释了JavaScript继承是如何工作的,但为什么JavaScript使用原型继承而不是经典继承来实现？

我喜欢JavaScript,所以我不是说这是件坏事......我只是好奇.

在Douglas Crockford的JavaScript:The Good Parts中,他建议我们使用函数式继承.这是一个例子:

var mammal = function(spec, my) {
    var that = {};
    my = my || {};

    // Protected
    my.clearThroat = function() { 
        return "Ahem";
    };

    that.getName = function() {
        return spec.name;
    };

    that.says = function() {
        return my.clearThroat() + ' ' + spec.saying || '';
    };

    return that;
};

var cat = function(spec, my) {
    var that = {};
    my = my || {};

    spec.saying = spec.saying || 'meow';
    that = mammal(spec, my);

    that.purr = …

C#4.0的ExpandoObject是否支持基于Prototype的继承？如果没有,为什么不(它是否按设计？)以及如何实施？如果是,它是如何工作的,与它在Javascript中的工作方式相比有什么不同？

我已经读过Crockford推动以更明显的原型方式使用JavaScript(克隆对象来创建新的,从不使用"new"关键字).但在野外,我从未见过任何人将这种风格用于大型项目.

我在哪里可以找到使用此样式的大型项目的示例？

我一直在阅读道格拉斯·克罗克福德的"Javascript:The Good Parts" - 虽然它有点极端,但我已经接受了很多他要说的话.

在第3章中,他讨论了对象,并且在某一点上列出了一种模式(也在这里找到),用于简化和避免使用内置"new"关键字时出现的一些混淆/问题.

if (typeof Object.create !== 'function') {
    Object.create = function (o) {
        function F() {}
        F.prototype = o;
        return new F();
    };
}
newObject = Object.create(oldObject);

所以我尝试在我正在处理的项目中使用它,并且在尝试从嵌套的对象继承时发现了一个问题.如果我覆盖使用此模式继承的嵌套对象的值,它将覆盖原型链上的嵌套元素.

Crockford的例子就像flatObj下面的例子一样,效果很好.但是,该行为与嵌套对象不一致:

var flatObj = {
    firstname: "John",
    lastname: "Doe",
    age: 23
}
var person1 = Object.create(flatObj);

var nestObj = {
    sex: "female",
    info: {
        firstname: "Jane",
        lastname: "Dough",
        age: 32  
    }
}
var person2 = Object.create(nestObj);

var nestObj2 = {
    sex: "male",
    info: { …