entera - operadores logicos javascript

¿Son posibles los operadores variables?

Question

¿Hay alguna manera de hacer algo similar a cualquiera de los siguientes:

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

- O -

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

Answer 1

Creo que quieres un operador variable. aquí hay uno, creado como objeto. puede cambiar la operación actual cambiando:

[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 2

De otra respuesta que publiqué recientemente, está en V8 y creo que JavaScriptCore, pero no Firefox y no es una especificación. Como puede atrapar la operación y los comparadores, puede implementar la sobrecarga nativa del operador en la mayoría de las situaciones con un poco de trabajo.

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);

Salida:

[ { 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 } ]

En este punto, tiene todas las entradas y la operación, por lo que la parte restante es el resultado de la operación. El receptor de la operación obtendrá un valor primitivo, ya sea cadena o número, y no se puede evitar esto. Si no es un receptor arbitrario, digamos una instancia de la clase que ha sobrecargado el operador, puede manejar varias trampas get / set para interceptar el valor entrante / evitar la sobrescritura. Puede almacenar los operandos y la operación en una búsqueda central y usar un método simple para rastrear un valor primitivo de vuelta a la operación que lo produjo, y luego crear la lógica que desee para realizar su operación personalizada. Otro método que permitiría receptores arbitrarios que luego podrían reconstituirse en formas complejas sería codificar los datos en el valor primitivo para que puedan invertirse en su clase compleja. Por ejemplo, un valor RGB de 3 enteros distintos de 8 bits (255,255,255) podría convertirse en un único número en el extremo final y el extremo receptor podría convertirlo trivialmente en sus componentes complejos. O para datos más complejos, incluso podría devolver una cadena serializada JSON.

Tener acceso a Harmony Proxies (Firefox6 +, Nodejs con flag) hace que todo este proceso sea inmensamente más fácil, ya que puedes crear proxies de captura en prácticamente todo e introspectar todo el proceso de principio a fin y hacer lo que quieras. Las instancias de operando de su data / class, valueOf / toString / getters de cada valor posible al que puede acceder el motor interno, cualquier objeto receptor que tenga preconocimiento, e incluso atrapar receptores arbitrarios en el caso de with(trappingProxy){ "all variable lookup, creation, and setting in here invokes traps on our proxy"; } with(trappingProxy){ "all variable lookup, creation, and setting in here invokes traps on our proxy"; }

Answer 3

No fuera de la caja. Sin embargo, es fácil de construir a mano en muchos idiomas, incluido JS.

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

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

Puede usar nombres basados ​​en Ascii como plus , para evitar pasar por las cadenas si no es necesario. Sin embargo, se formularon la mitad de las preguntas similares a esta porque alguien tenía cadenas que representaban operadores y deseaban funciones de ellas.

Answer 4

No puede sobrecargar operadores en JavaScript. Puedes utilizar funciones para ayudar

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*/ }

Answer 5

Puede usar la función eval() , pero esa no es una buena idea. Creo que la mejor manera es escribir funciones para sus operadores de esta manera:

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 6

podemos implementar esto usando eval, ya que lo estamos usando para la comprobación del operador.

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

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

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

de esta forma podemos usar la evaluación dinámica del operador.