De outra resposta que postei recentemente, isso está no V8 e acho que JavaScriptCore, mas não no Firefox e não é especificação. Como você pode interceptar a operação e os comparadores, pode 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);
Resultado:
[ { 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 entradas e a operação, então a parte restante é o resultado da operação. O receptor da operação obterá um valor primitivo, string ou número, e você não pode evitar isso. Se não for um receptor arbitrário, digamos uma instância da classe que você sobrecarregou de operador, você pode manipular várias armadilhas get / set para interceptar o valor de entrada / impedir a substituição. 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 qualquer lógica que desejar para fazer sua operação personalizada. Outro método que permitiria receptores arbitrários que mais tarde poderiam ser reconstituídos em formas complexas seria codificar os dados no valor primitivo para que possam ser revertidos de volta em sua classe complexa. Como, digamos, um valor RGB de 3 inteiros de 8 bits distintos (255,255,255) poderia ser convertido em um único número na extremidade de obtenção e a extremidade do receptor poderia facilmente convertê-lo de volta em seus componentes complexos. Ou, para dados mais complexos, você pode até retornar uma string JSON serializada.
Ter acesso aos Harmony Proxies (Firefox6 +, Nodejs com flag) torna todo esse processo imensamente mais fácil, já que você pode criar trapping proxies em basicamente tudo e fazer uma introspecção em todo o processo de ponta a ponta e fazer o que quiser. As instâncias de operando de seus dados / classe, os valueOf / toString / getters de todos os valores possíveis que o mecanismo interno pode acessar, qualquer objeto receptor que você tenha pré-conhecimento e até mesmo interceptar receptores arbitrários no caso dewith(trappingProxy){ "all variable lookup, creation, and setting in here invokes traps on our proxy"; }