Le modèle prototype est implémenté dans ES5 comme suit :

var Shape = function (id, x, y) {
   this.id = id;
   this.move(x, y);
};
Shape.prototype.move = function (x, y) {
   this.x = x;
   this.y = y;
};

Par contre son équivalent ES6 est défini (dans ici) comme :

class Shape {
  constructor (id, x, y) {
    this.id = id
    this.move(x, y)
  }
  move (x, y) {
    this.x = x
    this.y = y
  }
}

Je suis prêt à utiliser un modèle de prototype afin d'éviter une utilisation excessive de la mémoire et je me demande si les classes ES6 garantissent cela?

0
Detroit 19 mars 2019 à 10:56

2 réponses

Meilleure réponse

La classe et les constructeurs ne sont que du sucre syntaxique. ils sont compilés pour fonctionner et prototyper en interne. vous pouvez donc utiliser les deux mais mieux à utiliser de manière ES6. l'utilisation de la syntaxe de classe rend votre code plus propre et orienté objet. si une personne de java/c++ etc (arrière-plan pur OOP) vient voir le code, elle comprendra ce qui se passe réellement

0
Anshuman Singh 19 mars 2019 à 09:27

Votre code ne sera pas compilé exactement comme modèle de prototype car les convertisseurs ES6 sont fonctionnels, d'où ce qui ressemble à ceci dans ES6

class Shape {
constructor (id, x, y) {
this.id = id
this.move(x, y)
}
move (x, y) {
this.x = x
this.y = y
}
}

Ressemblera à ceci une fois converti, vous avez la méthode générique createclass qui convertit le prototype d'objet à l'aide des méthodes d'objet intégrées

"use strict";

function _instanceof(left, right) {
if (
right != null &&
typeof Symbol !== "undefined" &&
right[Symbol.hasInstance]
) {
return right[Symbol.hasInstance](left);
} else {
return left instanceof right;
}
}

function _classCallCheck(instance, Constructor) {
if (!_instanceof(instance, Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}

function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}

function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}

var Shape =
/*#__PURE__*/
(function() {
 function Shape(id, x, y) {
  _classCallCheck(this, Shape);

  this.id = id;
  this.move(x, y);
}

_createClass(Shape, [
  {
    key: "move",
    value: function move(x, y) {
      this.x = x;
      this.y = y;
    }
  }
]);

return Shape;

}) ();

1
arpit sharma 19 mars 2019 à 08:13