Les opérateurs sont variables possibles?

Question

Y at-il un moyen de faire quelque chose de semblable à une ou l'autre des éléments suivants:

var1 = 10; var2 = 20;
var operator = "<";
console.log(var1 operator var2); // returns true

- OU -

var1 = 10; var2 = 20;
var operator = "+";
total = var1 operator var2; // total === 30

Answer 1

Pas de la boîte. Cependant, il est facile de construire à la main dans de nombreuses langues, y compris JS.

var operators = {
    '+': function(a, b) { return a + b },
    '<': function(a, b) { return a < b },
     // ...
};

var op = '+';
alert(operators[op](10, 20));

Vous pouvez utiliser des noms en fonction ascii comme plus, pour éviter de passer par les chaînes si vous n'avez pas besoin. Cependant, la moitié des questions similaires à celui-ci ont été demandé parce que quelqu'un avait des chaînes représentant les opérateurs et voulait les fonctions d'eux.

Answer 2

Je crois que vous voulez un opérateur variable. celui de là, créé comme objet. vous pouvez modifier l'opération en cours en changeant:

[yourObjectName].operation = "<" //changes operation to less than


function VarOperator(op) { //you object containing your operator
    this.operation = op;

    this.evaluate = function evaluate(param1, param2) {
        switch(this.operation) {
            case "+":
                return param1 + param2;
            case "-":
                return param1 - param2;
            case "*":
                return param1 * param2;
            case "/":
                return param1 / param2;
            case "<":
                return param1 < param2;
            case ">":
                return param1 > param2;
        }
    }
}

//sample usage:
var vo = new VarOperator("+"); //initial operation: addition
vo.evaluate(21,5); // returns 26
vo.operation = "-" // new operation: subtraction
vo.evaluate(21,5); //returns 16
vo.operation = ">" //new operation: ">"
vo.evaluate(21,5); //returns true

Answer 3

Vous pouvez utiliser la fonction eval(), mais ce n'est pas une bonne idée. Je pense que la meilleure façon est en train d'écrire des fonctions pour vos opérateurs comme ceci:

var addition = function(first, second) {
   return first+second;
};

var subtraction = function(first, second) {
   return first-second;
};

var operator = addition;

alert(operator(12, 13));

var operator = subtraction;

alert(operator(12, 13));

Answer 4

nous pouvons mettre en œuvre ce en utilisant eval, puisque nous utilisons pour le contrôle de l'opérateur.

var number1 = 30;
var number2 = 40;
var operator = "===";

function evaluate(param1, param2, operator) {
     return eval(param1 + operator + param2);
}

if(evaluate(number1, number2, operator)) {
}

De cette façon, nous pouvons utiliser l'évaluation de l'opérateur dynamique.

Answer 5

D'une autre réponse que je récemment, ce V8 est et je pense que JavaScriptCore, mais pas Firefox et ce n'est pas spec. Comme vous pouvez piéger le fonctionnement et les comparateurs, vous pouvez mettre en œuvre la surcharge native de l'opérateur dans la plupart des situations avec un peu de travail.

var actions = [];
var overload = {
  valueOf: function(){
    var caller = arguments.callee.caller;
    actions.push({
      operation: caller.name,
      left: caller.arguments[0] === this ? "unknown" : this,
      right: caller.arguments[0]
    });
    return Object.prototype.toString.call(this);
  }
};
overload.toString = overload.valueOf;
overload == 10;
overload === 10;
overload * 10;
10 / overload;
overload in window;
-overload;
+overload;
overload < 5;
overload > 5;
[][overload];
overload == overload;
console.log(actions);

Sortie:

[ { operation: 'EQUALS',
    left: overload,
    right: 10 },
  { operation: 'MUL',
    left: overload,
    right: 10 },
  { operation: 'DIV',
    left: 'unknown',
    right: overload },
  { operation: 'IN',
    left: overload,
    right: DOMWindow },
  { operation: 'UNARY_MINUS',
    left: overload,
    right: undefined },
  { operation: 'TO_NUMBER',
    left: overload,
    right: undefined },
  { operation: 'COMPARE',
    left: overload,
    right: 5 },
  { operation: 'COMPARE',
    left: 'unknown',
    right: overload },
  { operation: 'ToString',
    left: 'unknown',
    right: overload } ]

À ce stade, vous avez toutes les entrées et l'opération de sorte que la partie restante est le résultat de l'opération. Le récepteur de l'opération aura une valeur primitive, soit chaîne ou un nombre, et vous ne pouvez pas empêcher cela. Si ce n'est pas un arbitraire recepteur, par exemple une instance de la classe que vous opérateur AVONS surchargées, vous pouvez gérer différents pièges get / set pour intercepter la valeur entrante / éviter d'écraser. Vous pouvez stocker les opérandes et le fonctionnement dans une recherche centrale et utiliser une méthode simple pour tracer un retour de valeur primitive à l'opération qui l'a produit, puis de créer toutes la logique que vous voulez faire votre opération personnalisée. Une autre méthode qui permettrait des récepteurs arbitraires qui pourraient ensuite être reconstitués dans des formes complexes seraient à coder les données dans la valeur primitive afin qu'il puisse être de retour dans votre classe inversée complexe. Comme dire une valeur RVB de 3 entiers 8bit distincts (255,255,255) pourrait être converti en un seul numéro à la fin get et la fin de peut convertir trivial nouveau dans ses composants complexes. Ou pour des données plus complexes, vous pouvez même retourner une chaîne sérialisé JSON.

L'accès à l'harmonie proxies (Firefox6 +, NodeJS avec le drapeau) rend ce processus immensément plus facile, comme vous pouvez créer des procurations de piégeage sur tout et essentiellement Introspect l'ensemble du processus de bout en bout et faire ce que vous voulez. Les instances d'opérandes de vos données / classe, les ValueOf / toString / apporteurs de toutes les valeurs possibles du moteur interne peut accéder, tout objet récepteur que vous avez pré-prise de conscience et piéger même les récepteurs arbitraires dans le cas de with(trappingProxy){ "all variable lookup, creation, and setting in here invokes traps on our proxy"; }

Answer 6

Vous ne pouvez pas surcharger les opérateurs en JavaScript. Vous pouvez utiliser les fonctions hors cours à l'aide

var plus = function(a, b) {
    return a + b;
};

var smaller = function(a, b) { 
    return a < b;
};

var operator = plus;
var total = operator(a, b);
operator = smaller;
if(operator(var1, var2)){ /*do something*/ }