10

一些程序员建议不要在 Javascript 中使用伪经典继承,但建议使用鸭子类型并为每个对象提供一组功能。

有没有一个很好的例子来说明如何做到这一点?我在下面有一个示例,但它一次只分配一个功能。我们能不能给一个对象分配一整组方法,比如我们能不能设置一个OceanAnimal可以“游泳”、“潜水”和“上升”的原型,一个LandAnimal“跑步”、“步行”和“跳跃”的原型",并让一个对象从其中一个或两个继承?(所以 fish 对象可以继承或获得 的能力OceanAnimal,而乌龟可以同时获得 和 的能力OceanAnimalLandAnimal

var yoyo = {
    name: "Yoyo",
    type: "turtle"
}

var simba = {
    name: "Simba",
    type: "lion"
}

var dolphy = {
    name: "Dolphy",
    type: "dolphin"
}

function swim(n) {
    console.log("My name is", this.name, ", I am a", this.type, "and I just swam", n, "feet")
}

function run(n) {
    console.log("My name is", this.name,  ", I am a", this.type, "and I just ran", n, "feet")
}

Object.prototype.respondTo = function(method) {
    return !!(this[method] && (typeof this[method] === "function"));
}

yoyo.swim = swim;
yoyo.swim(10);

dolphy.swim = swim;
dolphy.swim(80);

simba.run = run;
simba.run(200);

yoyo.run = run;
yoyo.run(2);

yoyo.walk = run;
yoyo.walk(1);

console.log(simba.respondTo("swim"));
console.log(simba.respondTo("run"));
console.log(simba.respondTo("walk"));

console.log(yoyo.respondTo("run"));
console.log(yoyo.respondTo("walk"));
console.log(yoyo.respondTo("fly"));

if(dolphy.respondTo("run")) {
    dolphy.run(10);
}

if(dolphy.respondTo("swim")) {
    dolphy.swim(10);
}

输出:

My name is Yoyo , I am a turtle and I just swam 10 feet 
My name is Dolphy , I am a dolphin and I just swam 80 feet 
My name is Simba , I am a lion and I just ran 200 feet 
My name is Yoyo , I am a turtle and I just ran 2 feet 
My name is Yoyo , I am a turtle and I just ran 1 feet 
false 
true 
false 
true 
true 
false 
My name is Dolphy , I am a dolphin and I just swam 10 feet
4

3 回答 3

26

JavaScript 中的函数是通用的。它们可以用作子例程方法构造函数命名空间模块等等。

人们反对在 JavaScript 中使用伪经典继承的原因是因为它隐藏了 JavaScript 的真正威力。如果不比对象更具表现力,函数也同样具有表现力。这已被Alonzo Church证明,他的工作Lambda Calculus图灵完备的。

为了直接回答您的问题,我将使用函数来创建 a Turtle、 aLion和 a Dolphin。然后我将演示乌龟如何是一个OceanAnimal和一个LandAnimal,狮子如何只是一个LandAnimal,海豚如何只是一个OceanAnimal。最后,我将解释什么是鸭式打字。

首先让我们为 an 创建构造函数OceanAnimal

function OceanAnimal() {
    this.swim = function (n) {
        return "I am " + this.name + ", the " + this.type +
               ", and I just swam " + n + " meters.";
    };
}

接下来,我们将为 a 创建构造函数LandAnimal

function LandAnimal() {
    this.walk = function (n) {
        return "I am " + this.name + ", the " + this.type +
               ", and I just walked " + n + " meters.";
    };
}

好吧。所以现在让我们为 a 创建构造函数Turtle

Turtle.prototype.type = "turtle";

function Turtle(name) {
    this.name = name;
    LandAnimal.call(this);
    OceanAnimal.call(this);
}

这里发生了什么事?好的,我们想Turtle从两者继承OceanAnimalLandAnimal。所以我们调用LandAnimal.call(this)and OceanAnimal.call(this)。通过这种方式,我们将OceanAnimalandLandAnimal构造函数用作mixins。因此Turtle继承自两者OceanAnimalLandAnimal但实际上并没有成为OceanAnimalor类型LandAnimal

需要注意的另一件事是,我们将type属性设置在prototypeof 上Turtle而不是内部。这是因为type所有海龟都是一样的。因此它是共享的。name另一方面,每只海龟的 可能会有所不同,因此它被设置在构造函数中。

现在让我们类似地为 a 创建构造函数Lion

Lion.prototype.type = "lion";

function Lion(name) {
    this.name = name;
    LandAnimal.call(this);
}

由于Lion是 aLandAnimal我们只在LandAnimal构造函数中混合。

同样对于 a Dolphin

Dolphin.prototype.type = "dolphin";

function Dolphin(name) {
    this.name = name;
    OceanAnimal.call(this);
}

现在我们已经创建了所有的构造函数,让我们创建一只乌龟、一只狮子和一只海豚:

var yoyo = new Turtle("Yoyo");
var simba = new Lion("Simba");
var dolphy = new Dolphin("Dolphy");

Awww,现在让我们释放它们:

alert(yoyo.walk(10));
alert(yoyo.swim(30));   // turtles are faster in the water
alert(simba.walk(20));
alert(dolphy.swim(20));

哈哈。那很有趣。我个人最喜欢yoyo。

好的,那么鸭子打字是什么?我们知道 yoyo 是 anOceanAnimal和 a LandAnimal。但是,如果我们这样做yoyo instanceof OceanAnimalyoyo instanceof LandAnimal它就会返回false。什么?

  • 你:愚蠢的 JavaScript。ATurtle是一个OceanAnimal和一个LandAnimal
  • JavaScript:不是从我站的地方。我只知道它是一个Turtle.
  • 你:但是如果它会游泳,那么它就是一个OceanAnimal,如果它会走路,那么它就是一个LandAnimal

因此,由于 JavaScript 是个大杂烩,我们必须创建自己的测试来检查对象是否为 anOceanAnimal以及是否为LandAnimal.

让我们从一个开始OceanAnimal

function isOceanAnimal(object) {
    if (typeof object !== "object") return false;
    if (typeof object.swim !== "function") return false;
    return true;
}

同样,对于 a LandAnimal

function isLandAnimal(object) {
    if (typeof object !== "object") return false;
    if (typeof object.walk !== "function") return false;
    return true;
}

所以现在我们可以使用isOceanAnimal(yoyo)代替yoyo instanceof OceanAnimal,和isLandAnimal(yoyo)代替yoyo instanceof LandAnimal; 这两个功能都将返回true给我们心爱的悠悠球。耶!

这是一个在 JavaScript 中进行鸭式输入的简单示例。总结:

当我看到一只像鸭子一样走路、像鸭子一样游泳、像鸭子一样叫的鸟时,我称那只鸟为鸭子。

相似地:

当我看到一种像海洋动物一样游泳的动物时,我称它为海洋动物;当我看到一种像陆地动物一样走路的动物时,我称它为陆地动物。

编辑:你可以在这里看到上面的代码:http: //jsfiddle.net/aaditmshah/X9M4G/

于 2012-10-07T09:07:02.727 回答
10

与其尝试子类化,不如使用鸭子类型倡议来扩展组件和依赖注入?

var Duck = function (flyable, movable, speakable) {

    this.speak = speakable.speak;
    this.fly = flyable.fly;
    this.position = movable.position;

    flyable.subscribe("takeoff", movable.leaveGround);
    flyable.subscribe("land",    movable.hitGround);

}


var duck = new Duck(new BirdFlier(), new BirdWalker(), new Quacker());

var plane = new Duck(new VehicleFlier(), new Drivable(), new Radio());


duck.speak(); // "quack"
plane.speak(); // "Roger"

请注意,plane它愉快地使用与duck.

他们甚至一开始就不需要构造函数。
工厂也可以。

DuckTyping 的重点是对象构造不是使用对象的程序所关心的。

只要它具有相同的方法/属性名称,程序就会使用它们,而不管子/超/静态继承。

编辑: 添加示例组件

这里有几个不同的想法,我将它们结合在一起。所以一次一个点:

一、duck-typing的基本前提:

// the basic nature of duck-typing
var sheriff = {
    gun : {
        aim : function () { /* point gun somewhere */ },
        bullets : 6,
        fire : function () {
            if (this.bullets === 0) { return; }
            this.bullets -= 1;
            /* ... et cetera */
        }
    },
    draw : function () {
        this.gun.aim();
        this.gun.fire();
    }
},

cartoonist = {
    pen : { scribble : function () { /* ... */ } },
    draw : function () { this.pen.scribble(); }
},

graphicsCard = {
    pixels : [ /* ... */ ],
    screen : { /* ... */ },
    draw : function () {
        pixels.forEach(function (pixel) { screen.draw(pixel); });
    }
};


// duck-typing at its finest:
sheriff.draw();
cartoonist.draw();
graphicsCard.draw();

目标是编写不需要检查它是什么类型的对象的函数:

function duckDraw (array) { array.forEach(function (obj) { obj.draw(); }); }
duckDraw([ sheriff, cartoonist, graphicsCard ]);

因此,如果您有海龟、海豚、鲸鱼、潜艇和小鱼,您的程序就不必关心它们游泳方式的差异。它只关心他们都可以.swim();。每个项目都可以担心自己,以及它做它需要做的特殊方式。

鸭子打字

接下来是依赖注入。在某种程度上,依赖注入也使用鸭子类型,但在你的类内部,而不是外部(或者如果你像我在上面那样做,它从内部开始,然后允许鸭子类型在外面也是如此)。

可以这样想:与其让一个人继承某些东西,不如把它交给他们。

如果您有 a soldier、 a sniperaplane和 a tank,则每个都需要 a gun。与其尝试子类化以便他们都能开火……为什么不制造不同种类的枪来满足您的需求,并把他们需要的一切都交给他们呢?

var Rifle = function () {
    this.reload = function () {};
    this.fire = function () { /* ... */ };
},

SniperRifle = function () {
    this.reload = function () {};
    this.fire = function () {};
},

MachineGun = function () {
    this.reload = function () {};
    this.fire = function () {};
},

Cannon = function () {
    this.reload = function () {};
    this.fire = function () {};
};

所以现在我们有了不同种类的枪......你可能会认为因为它们有相同的函数名称,而且它们都处理子弹,所以你可以尝试子类......但你没有不需要 - 这些枪在开火或重装时都不会做同样的事情......所以你最终会用其他语言写overrides一个方法/属性,这将是无用的。abstract virtual

所以现在我们已经有了它们,我们可以看到我们如何“注入”它们,以及这对我们有什么作用:

var Soldier = function (gun) {
    this.currentGun = gun;
    this.inventory = {
        guns : [ gun ]
    };
    this.attack = function () { this.currentGun.fire(); };
};

var Sniper = function (gun) {
    this.currentGun = gun;
    this.inventory = {
        guns : [ gun ]
    };
    this.attack = function () { this.currentGun.fire(); };
};

var Plane = function (gun) {
    this.currentGun = gun;
    this.inventory = {
        guns : [ gun ]
    };
    this.attack = function () { this.currentGun.fire(); };
};

var Tank = function (gun) {
    this.currentGun = gun;
    this.inventory = {
        guns : [ gun ]
    };
    this.attack = function () { this.currentGun.fire(); };
};


var soldier = new Soldier( new Rifle() ),
    sniper  = new Sniper( new SniperRifle() ),
    plane   = new Plane( new MachineGun() ),
    tank    = new Tank( new Cannon() );

所以现在我们有了这些他们称之为枪的课程——他们不在乎什么样的枪,它只是工作,因为枪知道枪是如何工作的,战斗人员知道如何开枪,而且程序知道如何告诉战斗人员开火。

但如果你仔细观察,现在每个战斗员的内部代码都是 100% 相同的。

那么,为什么不拥有一个可以提供特殊组件的“战斗者”呢?

var Combatant = function (gun) {
    this.currentGun = gun;
    this.inventory = {
        guns : [ gun ]
    };
    this.attack = function () { this.currentGun.fire(); };
};

var soldier = new Combatant( new Rifle() );

所以构造函数的内部是鸭式类型gun,如果你有不同的战斗员类,并且每个类都有一个fire方法,那么你也可以在游戏逻辑中对你的单位进行鸭式类型。

最终,构造函数将只保存模块:一个处理射击的模块,一个处理地面移动的模块,一个用于绘图的模块,一个用于玩家控制的模块,等等......构造函数不需要做任何事情,除了让各个部分接触彼此之间,您可以通过赋予它们不同种类的枪、不同种类的运动或不同种类的健康来使单位变得特别,它们在内部运作不同,但具有相同的属性和方法名称以供公众访问。

于 2012-10-06T19:26:13.280 回答
1

所以你有这两个功能:

function make ( props ) {
    var obj = Object.create( {} );
    Object.keys( props ).forEach(function ( key ) {
        obj[ key ] = props[ key ];
    });
    return obj;
};

function addMethods ( obj, methods ) {
    var proto = Object.getPrototypeOf( obj );
    Object.keys( methods ).forEach(function ( key ) {
        proto[ key ] = methods[ key ];
    });        
}

用法:

var simba = make({
    name: "Simba",
    type: "lion"
});

addMethods( simba, {
    swim: function () {},
    run: function () {}
});

addMethods( simba, {
    hunt: function () {},
    kill: function () {}
});

现场演示:http: //jsfiddle.net/UETVc/

于 2012-10-06T18:41:14.363 回答