Os operadores variables ​​são possíveis?

Existe uma maneira de fazer algo semelhante a um dos itens a seguir:

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 

Não fora da checkbox. No entanto, é fácil construir manualmente em vários idiomas, incluindo o JS.

 var operators = { '+': function(a, b) { return a + b }, '<': function(a, b) { return a < b }, // ... }; var op = '+'; alert(operators[op](10, 20)); 

Você pode usar nomes baseados em ascii como plus , para evitar passar por strings se não for necessário. No entanto, metade das perguntas semelhantes a esta foram feitas porque alguém tinha strings representando operadores e queria funções deles.

Você pode usar a function eval() , mas isso não é uma boa ideia. Eu acho que a melhor maneira é escrever funções para seus operadores assim:

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

Eu acredito que você quer um operador variável. aqui está um, criado como object. você pode mudar a operação atual mudando:

 [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 

De outra resposta que eu postei recentemente, isso é no V8 e eu acho JavaScriptCore, mas não o Firefox e não é spec. Como você pode interceptar a operação e os comparadores, é possível implementar a sobrecarga nativa do operador na maioria das situações com um pouco de trabalho.

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

Saída:

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

Neste ponto, você tem todas as inputs e a operação para que a parte restante seja o resultado da operação. O receptor da operação receberá um valor primitivo, seja string ou number, e você não poderá evitar isso. Se não for um receptor arbitrário, digamos uma instância da class sobrecarregada pelo operador, você pode manipular várias traps get / set para interceptar o valor de input / evitar a sobrescrita. Você pode armazenar os operandos e a operação em alguma pesquisa central e usar um método simples para rastrear um valor primitivo de volta à operação que o produziu e, em seguida, criar a lógica que quiser para executar sua operação personalizada. Outro método que permitiria que receptores arbitrários, que mais tarde pudessem ser reconstituídos em formas complexas, estivessem codificando os dados no valor primitivo, de modo que ele pudesse ser revertido de volta à sua class complexa. Por exemplo, um valor RGB de 3 números inteiros de 8 bits distintos (255,255,255) poderia ser convertido em um único número na extremidade final e a extremidade receptora poderia ser convertida de volta em seus componentes complexos. Ou, para dados mais complexos, você pode até mesmo retornar uma string serializada JSON.

Ter access aos Proxies Harmony (Firefox6 +, Nodejs with flag) torna todo esse processo imensamente mais fácil, já que você pode criar proxies trapping em praticamente tudo e introspectar todo o processo de ponta a ponta e fazer o que quiser. As instâncias de operando de seus dados / class, o valor de / toString / getters de todos os valores possíveis que o mecanismo interno pode acessar, qualquer object receptor que você tenha pré-reconhecimento e até mesmo interceptar receptores arbitrários no 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"; }

Você não pode sobrecarregar operadores em JavaScript. Você pode usar funções fora do curso para ajudar

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

podemos implementar isso usando o eval, já que estamos usando para verificação do operador.

 var number1 = 30; var number2 = 40; var operator = "==="; function evaluate(param1, param2, operator) { return eval(param1 + operator + param2); } if(evaluate(number1, number2, operator)) { } 

Desta forma, podemos usar a avaliação dinâmica do operador.

Intereting Posts