Redéfinition des méthodes en Javascript

Je voudrais savoir quelle est la différence entre les méthodes surchargées avec des prototypes et sans prototypes. Considérer:

Exemple 1:

function Animal() {
    this.sleep = function () {
        alert("animal sleeping");
    };

    this.eat = function () {
        alert("animal eating");
    };
}

function Dog() {
    this.eat = function () {
        alert("Dog eating");
    };
}

Dog.prototype = new Animal;

var dog = new Dog;

dog.eat();

Exemple 2:

function Animal() { }

function Dog() { }

Animal.prototype.sleep = function () {
    alert("animal sleeping");
};

Animal.prototype.eat = function () {
    alert("animal eating");
};

Dog.prototype = new Animal;

Dog.prototype.eat = function () {
    alert("Dog eating");
};

var dog = new Dog;

dog.eat();

Je me sens à la fois des exemples de produire le même effet que le Dog classe est primordial manger de la méthode de la Animal classe. Ou est-il rien de différent de ce qui se passe?

Vous devez utiliser this mot-clé lors de la définition des propriétés d'un objet dans son constructeur.
désolé manqué le mot-clé this. Édité à la question maintenant.
C'est presque toujours une bonne idée de mettre des méthodes sur le prototype, alors qu'ils sont partagés entre toutes les instances. Les mettre dans votre constructeur de copies à travers toutes les instances et cela consomme plus de mémoire.
Donc, en dehors des problèmes de mémoire, est-il un autre problème?
Les fonctions déclarées en tant que propriétés de this à l'intérieur d'un constructeur de prévenir les variables privées du constructeur de déchets collectées, même s'ils ne peuvent pas fermer sur toutes les variables privées elles-mêmes. Cependant, puisque ce peut être classé comme un mémoire préoccupation, je dirais: non, il n'y a pas d'autres questions. C'est juste populaires pratique de codage, de placer des méthodes sur la prototype.

OriginalL'auteur codingsplash | 2013-03-19

10

Dans la première méthode, chaque Animal instance de sa propre mise en œuvre de sleep et eat méthodes.

Alors que dans le second modèle de Toutes les instances partagent la même instance de la sleep et eat méthodes.

Le deuxième modèle est le meilleur, puisque nous pouvons partager les méthodes.

OriginalL'auteur Arun P Johny
6

Comme Arun mentionné dans le premier exemple, vous êtes en train de créer sleep et eat fonctions pour chaque nouvelle instance. Dans le deuxième exemple, il n'y a qu'un sleep et eat fonction qui est partagée par toutes les instances.

Dans ce cas, la seconde méthode est la meilleure, mais c'est bon à savoir quand utiliser la première méthode et lors de l'utilisation de la seconde. Un peu de théorie d'abord:

Remarque: Il existe quatre types de variables en JavaScript - private, public, shared et static.

Variables privées sont inaccessibles en dehors de la fonction dans laquelle elles sont définies. Par exemple:
```
function f() {
    var x; //this is a private variable
}
```
Public les variables sont définies dans le this objet à l'intérieur d'une fonction. Par exemple:
```
function f() {
    this.x; //this is a public variable
}
```
Variables partagées sont partagés sur le prototype de la fonction. Par exemple:
```
function f() {}

f.prototype.x; //this is a shared variable
```
Variables statiques sont des propriétés de la fonction elle-même. Par exemple:
```
function f() {}

f.x; //this is a static variable
```
Le plus souvent, il est préférable de déclarer les méthodes de la fonction constructeur comme des méthodes partagées depuis toutes les instances du constructeur de les partager. Toutefois, si votre méthode a besoin d'accéder à une variable privée alors elle doit être déclarée comme une méthode publique elle-même.

Remarque: C'est ma propre nomenclature. Pas beaucoup de programmeurs JavaScript d'y adhérer. D'autres semblent suivre Douglas Crockford de la nomenclature: http://javascript.crockford.com/private.html

Pour en savoir plus sur les prototypes de l'héritage en JavaScript lire la réponse suivante: https://stackoverflow.com/a/8096017/783743

OriginalL'auteur Aadit M Shah
0

Dans votre premier exemple chaque nouvelle Dog instance aura ses propres eat méthode et dans le deuxième exemple, il n'y aura qu'un seul eat méthode sur Dog.prototype, qui sera partagé entre tous les futurs cas de Dog comme Arun mentionné.

C'est la seule "tricky" différence entre les deux. Mais il est toujours préférable de définir des méthodes sur la prototype pour éviter la forte consommation de la mémoire et des fuites.

OriginalL'auteur happyCoda
0

Les méthodes dans le premier exemple sont définis dans l'instance de l'objet.

De la configuration de la Dog prototype d'un nouveau Animal instance, et donc Dog héritera sleep et eat fonctions de Animal. Alors vous êtes DÉFINITION (PAS PRIMORDIAL) eat méthode dans Dog constructeur comme une méthode d'instance, et ce sera CACHER hérité eat méthode dans Dog instances.

Considérons l'exemple suivant:
```
function LittleDog() { }
LittleDog.prototype = Object.create(Dog.prototype);
(new LittleDog()).eat();
```
Le code ci-dessus va d'alerte animal eating avec votre code dans le premier exemple.

Et d'alerte Dog eating avec le code dans la seconde.

OriginalL'auteur fardjad

Vous devez vous connecter pour publier un commentaire.