classique héritage vs prototypes héritage en javascript

J'ai googlé tant de liens et ne peut pas obtenir une bonne idée sur la différence entre la classique héritage et prototypes héritage?

J'ai appris certaines choses à partir de ces données, mais je suis toujours confus au sujet de ces concepts.

Classique héritage

//Shape - superclass
function Shape() {
  this.x = 0;
  this.y = 0;
}

//superclass method
Shape.prototype.move = function(x, y) {
    this.x += x;
    this.y += y;
    console.info("Shape moved.");
};

//Rectangle - subclass
function Rectangle() {
  Shape.call(this); //call super constructor.
}

//subclass extends superclass
Rectangle.prototype = Object.create(Shape.prototype);

N'classique héritage utiliser les prototypes de l'héritage à l'intérieur?

http://aaditmshah.github.io/why-prototypal-inheritance-matters/

Partir du lien ci-dessus, j'ai appris nous ne pouvons pas ajouter de nouvelles méthodes au moment de l'exécution dans la classique héritage. Est-ce correct? Mais vous pouvez vérifier le code ci-dessus je peux ajouter "déplacer" la méthode et les méthodes au moment de l'exécution par le biais de prototype. C'est donc un prototype basé classique héritage? Si donc ce qui est réel classique de l'héritage et de l'héritage de prototype? Je suis confus au sujet de qui.

Prototypes héritage.

function Circle(radius) {
    this.radius = radius;
}
Circle.prototype.area = function () {
    var radius = this.radius;
    return Math.PI * radius * radius;
};
Circle.prototype.circumference: function () {
    return 2 * Math.PI * this.radius;
};
var circle = new Circle(5);
var circle2 = new Circle(10);

Est-il semblable à la classique héritage? Je suis totalement confus sur ce qu'est prototypes héritage? Ce qui est classique héritage? Pourquoi est classique héritage mauvais?

Pouvez-vous me donner un exemple simple pour mieux comprendre ces d'une manière simple.

Merci,

Siva

En double, vérifiez ceci: stackoverflow.com/questions/1595611/...
pas sûr de ce que vous êtes ici - le premier bloc de code est l'héritage par prototype, pas classique. Votre deuxième bloc de code n'a pas d'héritage à tous!
Cela peut xplain: blog.stephenwyattbush.com/2012/05/01/...
developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/... ce lien indique que l'on a classique héritage. c'est pourquoi suis confus.
Pour en savoir plus sur pourquoi vous voudrez peut-être éviter classique héritage, voir mon discours, "Classique Héritage est Obsolète: Comment Penser en Prototypes OO" vimeo.com/69255635

InformationsquelleAutor SivaRajini | 2013-10-28

inheritance javascript

228

À la fois les exemples de code dont vous avez fait preuve dans votre question, faire usage de prototypes à l'héritage. En fait, tout le code orienté objet vous écrire en JavaScript est un paradigme de prototypes à l'héritage. JavaScript n'a simplement pas classique héritage. Ceci doit effacer un peu les choses:
```
                                   Inheritance
                                        |
                         +-----------------------------+
                         |                             |
                         v                             v
                    Prototypal                     Classical
                         |
         +------------------------------+
         |                              |
         v                              v
Prototypal Pattern             Constructor Pattern
```
Comme vous pouvez le voir prototypes de l'héritage classique et l'héritage sont deux différents paradigmes de l'héritage. Certaines langues comme l'Auto, Lua et de la prise en charge de JavaScript prototypes héritage. Cependant, la plupart des langages comme C++, Java et C# prise en charge classique héritage.

Un Rapide Aperçu de la Programmation Orientée Objet

Les deux prototypes de l'héritage et de la classique héritage de la programmation orientée objet paradigmes (c'est à dire, ils ont affaire à des objets). Les objets sont simplement des abstractions qui encapsulent les propriétés d'une entité du monde réel (c'est à dire qu'ils représentent mot réel des choses dans le programme). Ceci est connu comme une abstraction.

Abstraction: La représentation des choses du monde réel dans les programmes informatiques.

Théoriquement une abstraction est défini comme "un concept général formé par l'extraction de caractéristiques communes à partir d'exemples précis". Toutefois, pour les fins de cette explication, nous allons utiliser celui-ci de définition de la place.

Maintenant, certains objets ont beaucoup de choses en commun. Par exemple, une boue de vélo et une Harley Davidson ont beaucoup en commun.

Une boue de vélo:

Une Harley Davidson:

Une boue de vélo et une Harley Davidson sont les deux motos. D'où un vélo est une généralisation de tant de boue de vélo et une Harley Davidson.
```
                   Bike
                     |
    +---------------------------------+
    |                                 |
    v                                 v
Mud Bike                       Harley Davidson
```
Dans l'exemple ci-dessus, le vélo, la boue moto et Harley Davidson sont toutes les abstractions. Cependant, le vélo est plus général de l'abstraction de la boue de vélo et la Harley Davidson (c'est à dire à la fois la boue moto et Harley Davidson, certains types de vélos).

Généralisation: une abstraction d'un plus spécifiques à l'abstraction.

Dans la programmation orientée objet nous créer des objets (qui sont des abstractions du monde réel entités) et nous utilisons soit des classes ou des prototypes pour créer des généralisations de ces objets. Les généralisations sont créées par le biais de l'héritage. Un vélo est une généralisation de la boue de vélo. D'où la boue vélos hériter de vélos.

Classique De La Programmation Orientée Objet

Dans la musique classique, la programmation orientée objet, nous avons deux types d'abstractions: les classes et les objets. Un objet, comme mentionné précédemment, est une abstraction d'une entité du monde réel. Une classe sur l'autre main est une abstraction d'un objet ou d'une autre classe (c'est à dire que c'est une généralisation). Par exemple, pensez à:
```
+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | Man            | Class of object johnDoe.              |
| 3                    | Human          | Superclass of class Man.              |
+----------------------+----------------+---------------------------------------+
```
Comme vous pouvez le voir dans la musique classique, langages de programmation orientés objets ne sont que des abstractions (c'est à dire tous les objets ont un niveau d'abstraction de 1) et les classes ne sont que des généralisations (c'est à dire toutes les classes ont un niveau d'abstraction supérieur à 1).

Objets classiques des langages de programmation orientés objet ne peut être créé que par l'instanciation de classes:
```
class Human {
    //...
}

class Man extends Human {
    //...
}

Man johnDoe = new Man();
```
En résumé classiques des langages de programmation orientés objets sont des abstractions du monde réel, les entités et les classes sont des généralisations (c'est à dire des abstractions, soit des objets ou d'autres classes).

Ainsi que le niveau d'abstraction augmente entités deviennent plus général et que le niveau d'abstraction diminue les entités deviennent plus spécifiques. Dans ce sens, le niveau d'abstraction est analogue à une échelle allant du plus spécifiques des entités plus générales des entités.

Prototypes De La Programmation Orientée Objet

Prototypes langages de programmation orientés objet sont beaucoup plus simple que classique langages de programmation orientée objet en raison de prototypes de programmation orientée objet, nous n'avons qu'un seul type d'abstraction (c'est à dire des objets). Par exemple, pensez à:
```
+----------------------+----------------+---------------------------------------+
| Level of Abstraction | Name of Entity |                Comments               |
+----------------------+----------------+---------------------------------------+
| 0                    | John Doe       | Real World Entity.                    |
| 1                    | johnDoe        | Variable holding object.              |
| 2                    | man            | Prototype of object johnDoe.          |
| 3                    | human          | Prototype of object man.              |
+----------------------+----------------+---------------------------------------+
```
Comme vous pouvez le voir dans les prototypes langages de programmation orientés objets sont des abstractions de monde réel entités (dans ce cas, ils sont simplement appelés objets) ou d'autres objets (dans ce cas, ils sont appelés prototypes de ces objets qu'ils abstraite). D'où un prototype est une généralisation.

Objets prototypes langages de programmation orientée objet peut être créé ex-nihilo (c'est à dire à partir de rien) ou d'un autre objet, qui devient le prototype de l'objet nouvellement créé):
```
var human = {};
var man = Object.create(human);
var johnDoe = Object.create(man);
```
À mon humble avis prototypes langages de programmation orientés objet sont plus puissants que les classiques langages de programmation orientée objet, parce que:
1. Il n'y a qu'un seul type d'abstraction.
2. Les généralisations sont simplement des objets.
Maintenant vous devez avoir réalisé la différence entre la musique classique de l'héritage et de prototypes à l'héritage. Classique héritage est limitée à des classes héritant d'autres classes. Cependant prototypes héritage inclut non seulement des prototypes héritant d'autres prototypes, mais aussi des objets héritant de prototypes.

Prototype De La Classe Isomorphisme

Vous devez avoir remarqué que les prototypes et les classes sont très similaires. C'est vrai. Ils sont. En fait, ils sont si semblables que vous pouvez réellement utiliser des prototypes de classes du modèle:
```
function CLASS(base, body) {
    if (arguments.length < 2) body = base, base = Object.prototype;
    var prototype = Object.create(base, {new: {value: create}});
    return body.call(prototype, base), prototype;

    function create() {
        var self = Object.create(prototype);
        return prototype.hasOwnProperty("constructor") &&
            prototype.constructor.apply(self, arguments), self;
    }
}
```
À l'aide de la CLASS fonction, vous pouvez créer des prototypes qui ressemblent à des classes:
```
var Human = CLASS(function () {
    var milliseconds = 1
      , seconds      = 1000 * milliseconds
      , minutes      = 60 * seconds
      , hours        = 60 * minutes
      , days         = 24 * hours
      , years        = 365.2425 * days;

    this.constructor = function (name, sex, dob) {
        this.name = name;
        this.sex = sex;
        this.dob = dob;
    };

    this.age = function () {
        return Math.floor((new Date - this.dob) / years);
    };
});

var Man = CLASS(Human, function (Human) {
    this.constructor = function (name, dob) {
        Human.constructor.call(this, name, "male", dob);
        if (this.age() < 18) throw new Error(name + " is a boy, not a man!");
    };
});

var johnDoe = Man.new("John Doe", new Date(1970, 0, 1));
```
L'inverse n'est pas vrai, cependant (c'est à dire que vous ne pouvez pas utiliser les classes de modèle de prototypes). C'est parce que les prototypes sont des objets mais les classes ne sont pas des objets. Ils sont un type totalement différent de l'abstraction.

Conclusion

En résumé, nous avons appris qu'une abstraction est une "un concept général formé par l'extraction de caractéristiques communes à partir d'exemples précis" et que la généralisation est "une abstraction plus spécifiques à l'abstraction". Nous avons aussi appris les différences entre les prototypes et classique héritage et comment les deux d'entre eux sont les deux faces d'une même pièce.

Pour conclure, je voudrais faire remarquer qu'il existe deux modèles de prototypes d'un héritage: les prototypes de modèle et le constructeur modèle. Les prototypes modèle est le modèle canonique de prototypes de l'héritage alors que le constructeur modèle est utilisé pour fabriquer des prototypes de l'héritage de regarder de plus comme le classique héritage. Personnellement, je préfère les prototypes modèle.

P. S. je suis le gars qui a écrit l'article du blog "Pourquoi Les Prototypes Des Questions D'Héritage" et a répondu à la question:"Les avantages de prototypes héritage de plus classique?". Ma réponse est la réponse.
- merci pour votre excellente réponse. j'ai besoin de comprendre comment les prototypes modèle est mieux comparer de constructeur modèle.un exemple ?
- J'ai écrit un comparatif critique sur les constructeurs vs prototypes dans mon blog: aaditmshah.github.io/pourquoi-prototypes-l'héritage-questions/...
- Donc, serait-il correct de dire que lorsque nous utilisons des fonctions en javascript pour atteindre l'héritage, nous avons quelque peu utiliser le classique modèle d'héritage et lorsque nous utilisons la plaine objets de l'héritage par prototype(à la fois en interne suite à l'héritage par prototype )?
- Pas de. Si vous êtes à l'aide de JavaScript, alors vous êtes en utilisant les prototypes modèle d'héritage. Cependant, JavaScript a deux versions de prototypes héritage: à l'aide de fonctions (c'est à dire le constructeur modèle) et à l'aide d'objets (c'est à dire les prototypes modèle).
- D'accord! Mais alors, constructeur modèle est le " dit "classique" patron de droit?
- Pas de. C'est encore des prototypes. JavaScript n'a pas de "classes" et donc absolument rien en JavaScript classique, dont les constructeurs. C'est toujours prototypes héritage. Juste une étrange forme de prototypes à l'héritage que les gens confondent avec la classique héritage. En bref, programming with classes = classical inheritance, programming with prototypes = prototypal inheritance, programming with constructors = weird form of prototypal inheritance that looks a lot like classical inheritance. L'espoir qui clarifie les choses.
InformationsquelleAutor Aadit M Shah
5

Avant de sauter dans l'héritage, nous allons jeter un oeil à deux primaire modèles pour créer des instances (objets) en javascript:

Modèle classique: Objet est créé à partir d'un plan (de classe)
```
class Person {
  fn() {...}
} //or constructor function say, function Person() {}

//create instance
let person = new Person();
```
Prototypes modèle: Objet est créé directement à partir d'un autre objet.
```
//base object
let Person = { fn(){...} }

//instance
let person = Object.create(Person);
```
Dans les deux cas, l'Héritage* est obtenue en reliant des objets à l'aide de l'objet prototype.

(*méthodes de classe de base sont accessibles via. dérivée de la classe par le biais de l'objet prototype et pas besoin d'être explicitement présent dans la classe dérivée.)

Voici une bonne explication pour mieux comprendre (http://www.objectplayground.com/)

InformationsquelleAutor everlasto

Vous devez vous connecter pour publier un commentaire.

Un Rapide Aperçu de la Programmation Orientée Objet

Classique De La Programmation Orientée Objet

Prototypes De La Programmation Orientée Objet

Prototype De La Classe Isomorphisme

Conclusion