Javascript: surcharge d'opérateur

J'ai travaillé avec JavaScript pour quelques jours et j'ai arrivé à un point où j'ai envie de surcharger les opérateurs pour mes objets définis.

Après un passage sur la recherche sur google pour cela, il semble que vous ne pouvez pas officiellement ce faire, pourtant, il y a peu de gens le prétendent certains de longue haleine mode de réalisation de cette action.

Au fond, j'ai fait un Vector2 classe et que vous voulez être en mesure de faire ce qui suit:

var x = new Vector2(10,10);
var y = new Vector2(10,10);

x += y; //This does not result in x being a vector with 20,20 as its x & y values.

Au lieu de cela je vais devoir le faire:

var x = new Vector2(10,10);
var y = new Vector2(10,10);

x = x.add(y); //This results in x being a vector with 20,20 as its x & y values.

Est là une approche que je peut prendre de la surcharge des opérateurs dans mon Vector2 classe? Comme cela semble juste laid.

double possible de la Surcharge des Opérateurs Arithmétiques en JavaScript?
Viens de tomber sur une surcharge d'opérateur de la bibliothèque. N'ai pas essayé et je ne sais pas comment cela fonctionne bien, mais: google.com/...

InformationsquelleAutor Lee Brindley | 2013-10-27

78

Comme vous l'avez constaté, le JavaScript ne supporte pas la surcharge d'opérateur. Le plus proche que vous pouvez venir est de mettre en œuvre toString (qui sera appelée lorsque l'instance doit être forcés à être une chaîne de caractères) et valueOf (qui seront appelés à forcer un certain nombre, par exemple lors de l'utilisation de + de plus, ou dans de nombreux cas, lorsque vous l'utilisez pour la concaténation, car + essaie de faire de plus avant de concaténation), ce qui est assez limité. Ni vous permet de créer un Vector2 objet comme un résultat.

Pour les gens qui arrivent à cette question qui veulent une chaîne ou un nombre comme un résultat (au lieu d'un Vector2), même si, ici, sont des exemples de valueOf et toString. Ces exemples ne pas démontrer la surcharge d'opérateur, tout en prenant avantage de JavaScript intégré dans la manipulation de la conversion de primitives:

valueOf

Cet exemple de doubler la valeur d'un objet val bien, en réponse à des contraintes de primitive, par exemple via +:

JS:
```
function Thing(val) {
    this.val = val;
}
Thing.prototype.valueOf = function() {
    //Here I'm just doubling it; you'd actually do your longAdd thing
    return this.val * 2;
};

var a = new Thing(1);
var b = new Thing(2);
console.log(a + b); //6 (1 * 2 + 2 * 2)
```
Ou avec ES2015 de class:

JS:
```
class Thing {
    constructor(val) {
      this.val = val;
    }
    valueOf() {
      return this.val * 2;
    }
}

const a = new Thing(1);
const b = new Thing(2);
console.log(a + b); //6 (1 * 2 + 2 * 2)
```
Ou tout simplement avec des objets, pas de constructeurs:

JS:
```
var thingPrototype = {
    valueOf: function() {
      return this.val * 2;
    }
};

var a = Object.create(thingPrototype);
a.val = 1;
var b = Object.create(thingPrototype);
b.val = 2;
console.log(a + b); //6 (1 * 2 + 2 * 2)
```
toString

Cet exemple convertit la valeur d'un objet val propriété de majuscules en réponse à des contraintes de primitive, par exemple via +:

JS:
```
function Thing(val) {
    this.val = val;
}
Thing.prototype.toString = function() {
    return this.val.toUpperCase();
};

var a = new Thing("a");
var b = new Thing("b");
console.log(a + b); //AB
```
Ou avec ES2015 de class:

JS:
```
class Thing {
    constructor(val) {
      this.val = val;
    }
    toString() {
      return this.val.toUpperCase();
    }
}

const a = new Thing("a");
const b = new Thing("b");
console.log(a + b); //AB
```
Ou tout simplement avec des objets, pas de constructeurs:

JS:
```
var thingPrototype = {
    toString: function() {
      return this.val.toUpperCase();
    }
};

var a = Object.create(thingPrototype);
a.val = "a";
var b = Object.create(thingPrototype);
b.val = "b";
console.log(a + b); //AB
```
- Alors qu'il n'est pas pris en charge au sein de JS bon, il est assez fréquent de nos jours pour étendre JS avec des fonctionnalités personnalisées et transpile ordinaire, JS, par exemple, SweetJS c'est pour remédier à ce problème.
- Ne les opérateurs de comparaison sur la Date classe de convertir implicitement les dates pour les nombres à l'aide de valueOf? Par exemple, vous pouvez faire date2 > date1 et ce sera vrai si date2 a été créé après date1.
- Oui. >, <, >=, et <= (mais pas ==, ===, !=, ou !==) utiliser le Résumé Relationnel Comparaison l'opération, qui utilise ToPrimitive avec l'indicateur "nombre". Sur un Date objet, que les résultats dans le numéro getTime retourne (le millisecondes depuis L'Époque de valeur).
InformationsquelleAutor T.J. Crowder
19

Comme T. J. a dit, vous ne pouvez pas surcharger les opérateurs en JavaScript. Cependant, vous pouvez profiter de la valueOf fonction pour écrire un hack qui a l'air mieux que d'utiliser des fonctions comme add à chaque fois, mais impose des contraintes sur le vecteur x et y sont entre 0 et MAX_VALUE. Voici le code:
```
var MAX_VALUE = 1000000;

var Vector = function(a, b) {
    var self = this;
    //initialize the vector based on parameters
    if (typeof(b) == "undefined") {
        //if the b value is not passed in, assume a is the hash of a vector
        self.y = a % MAX_VALUE;
        self.x = (a - self.y) / MAX_VALUE;
    } else {
        //if b value is passed in, assume the x and the y coordinates are the constructors
        self.x = a;
        self.y = b;
    }

    //return a hash of the vector
    this.valueOf = function() {
        return self.x * MAX_VALUE + self.y;
    };
};

var V = function(a, b) {
    return new Vector(a, b);
};
```
Vous pouvez alors écrire les équations comme ceci:
```
var a = V(1, 2);            //a -> [1, 2]
var b = V(2, 4);            //b -> [2, 4]
var c = V((2 * a + b) / 2); //c -> [2, 4]
```
- Vous avez juste écrit le code pour l'OP add méthode... quelque Chose qu'ils ne veulent pas le faire.
- this.valueOfquelque chose de nouveau, j'ai appris aujourd'hui, assez cool
- L'OP voulait la surcharge d'un opérateur, ce qui implique clairement qu'il avait l'intention d'écrire une telle fonction. OP préoccupation était d'avoir à appeler "ajouter", ce qui est contre nature; mathématiquement, nous représentons l'addition vectorielle avec un + signe. C'est une très bonne réponse en montrant comment éviter l'appel de manière artificielle le nom de la fonction de quasi-objets numériques.
- La question montre que je suis déjà à l'aide d'une fonction d'ajout. Bien que la fonction ci-dessus n'est pas une mauvaise fonction à tous les il ne traite pas de la question, alors je serais d'accord avec Ian.
- Pour l'instant c'est la seule voie possible. La seule flexibilité que nous avons avec le + opérateur est une possibilité de retourner un Number comme un remplacement pour l'une des opérandes. Par conséquent, toute l'ajout d'une fonctionnalité qui fonctionne Object cas, il doit toujours coder l'objet comme un Number, et éventuellement de les décoder.
InformationsquelleAutor user2259659
6

FYI paper.js résout ce problème en créant PaperScript, autonome, portée javascript avec la surcharge d'opérateur de vecteurs, qui elle, puis traitement en javascript.

Mais la paperscript fichiers doivent être expressément spécifié et traité comme tel.

InformationsquelleAutor Joshua Penman
-1

En fait, il en est une variante de JavaScript qui ne soutien de la surcharge d'opérateur. ExtendScript, le langage de script utilisé par les applications Adobe tels que Photoshop et Illustrator, n'ont surcharge d'opérateur. En elle, vous pouvez écrire:
```
Vector2.prototype["+"] = function( b )
{
  return new Vector2( this.x + b.x, this.y + b.y );
}

var a = new Vector2(1,1);
var b = new Vector2(2,2);
var c = a + b;
```
Ceci est décrit plus en détail dans le "Adobe Extendscript guide des outils JavaScript" (courant lien ici). La syntaxe est apparemment fondée sur une (aujourd'hui abandonnée) le projet de l'ECMAScript standard.

InformationsquelleAutor J. Peterson

Vous devez vous connecter pour publier un commentaire.

Javascript: surcharge d'opérateur

`valueOf`

`toString`