Question

在JavaScript中，有一种实现继承的模式称为＆＃34;功能继承＆＃34;在Crockfords＆＃34; JavaScript的第5章中描述：好的部分＆＃34;。

与使用伪经典模式相比，模式的一个缺点是我们失去了使用instanceof运算符区分类型的能力。

有没有办法实现同样的目标？我们怎么知道两个对象在某种程度上是相关的，因为它们是相同的父/基＃34;类型＆＃34;？

我们怎么能告诉他们即使他们是同一类型的后代，他们自己也是不同的类型？

我不知道如果不能使用instanceof是一个很大的损失，但它看起来并不像。

备注

对于那些不熟悉Crockford解释的人，你可以在JSFiddle上看到一个例子，取自here。

Answer 1

想象一下我们有这些：

mammal { giveBirth }
reptile { layEgg }
cat : mammal { purr, playWithChildren }
dog : mammal { bark }
lion : mammal { purr }

（cat继承mammal并实施purr()等......）

现在想象你有一系列动物。

我认为你问的是我们如何判断animals[0]是cat。

了解animals[0]是cat的愿望来自于我们知道猫可以做某些事情的事实。而不是知道animals[0]是cat我们真正想知道的是animals[0]呜呜声。也许animals[0].purr !== undefined比知道它是cat更准确。这确实意味着我们需要检查每个函数，而不是我们知道实现了几个函数的cat的容器概念，但是它使得实现更加健壮和未来证明（考虑我们是否只关注咕噜声和狮子被添加到以后的动物类型。）

关于继承的问题，我建议我们不需要知道动物是mammal我们需要知道他们giveBirth。这将再次确保我们的实施更具有未来性证明，以便当我们稍后添加marsupial时，我们所有关于分娩而不是产卵的逻辑仍然存在。

Answer 2

instanceof运算符并不特殊。您可以按照Mozilla Developer Network中的说明自行实施。有关详细信息，请参阅以下问题的已接受答案：

JavaScript inheritance and the constructor property

以下是instanceof运算符在JavaScript中的实现方式：

function instanceOf(object, constructor) {
    while (object != null) {
        if (object == constructor.prototype) { //object is instanceof constructor
            return true;
        } else if (typeof object == 'xml') { //workaround for XML objects
            return constructor.prototype == XML.prototype;
        }
        object = object.__proto__; //traverse the prototype chain
    }
    return false; //object is not instanceof constructor
}

想要实现instanceOf功能继承吗？这也很容易做到：

var object = child({ name: "a functional object" });

alert(object.instanceOf(child)); // true
alert(object.instanceOf(base));  // true
alert(object.sayHello());        // Hello, I'm a functional object

function base(spec) {
    var that = {};
    that.name = spec.name;
    that.constructors = [base];
    that.instanceOf = instanceOf;
    return that;
}

function child(spec) {
    var that = base(spec);
    that.sayHello = sayHello;
    that.constructors.push(child);
    return that;

    function sayHello() {
        return "Hello, I'm " + this.name;
    }
}

function instanceOf(constructor) {
     return this.constructors.indexOf(constructor) >= 0;
}

当然，在实际的函数式编程中，根本不需要使用instanceof。

Answer 3

将父对象存储在对象中，然后

if (obj1.parentObject == obj2.parentObject) {//Do your things}

Answer 4

在{34}功能继承＆＃34;（＆＃34; JavaScript：好的部分＆＃34; ）中，inctanceof没有特定的类型和区别。
它是关于匿名函数之间的交换和关系，它们通常通过私有功能生成对象。
这些函数的逻辑层次结构是用条件首选项设置的。
这些功能可以相互呼叫，扩展＆＃34;父母＆＃34;对象方法，扩展其功能例如，在＆＃34;功能继承＆＃34;创建新类型，名为＆＃34; Mammal＆＃34;，看起来像：

var mammal = function (spec) { 
    var that = {}; 
    that.get_.name = function () { 
    return spec.name; 
    }; 
    that.says = function () { 
    return spec.saying || ''; 
    }; 
    return that; 
}; 
var myMammal = mammal({name: 'Herb'});

通过一些有条件协议，我们可以接受它作为父类型（类）现在我们可以创建另一个匿名函数，它将负责＆＃34; Mammal＆＃34;的子类型（子类）。类型（类）。此功能将调用＆＃34; parent＆＃34;函数mammal()来获取具有基本功能的对象：

var cat = function (spec) { 
    spec.saying = spec.saying || 'meow'; 
    var that = mammal(spec); 
    that.purr = function (n) { 
        var i, s = ''; 
        for (i = 9; i < n; i += 1) { 
            if (s) { 
               s += 
            } 
            s += 'r'; 
        } 
        return s; 
    }; 
    that.get_name = function () { 
        return that.says() + ' ' + spec.name + ' ' + that.says(); 
    }; 
    return that; 
}; 
var myCat = cat({name: 'Henrietta'});

使用函数继承时，`instanceof`的等价物是什么？

4 个答案: