Evaluar una cadena como expresión matemática en JavaScript

Question

¿Cómo analizo y evalúo una expresión matemática en una cadena (por ejemplo, '1+1') sin invocar eval(string) para obtener su valor numérico?

Con ese ejemplo, quiero que la función acepte '1+1' y devuelva 2.

Answer 1

con el tiempo he ido a esta solución, que trabaja para sumar números enteros positivos y negativos (y con un poco de modificación de la expresión regular funcionará para decimales también):

function sum(string) { 
    return (string.match(/^(-?\d+)(\+-?\d+)*$/)) ? string.split('+').stringSum() : NaN; 
} 

Array.prototype.stringSum = function() { 
    var sum = 0; 
    for(var k=0, kl=this.length;k<kl;k++) 
    { 
     sum += +this[k]; 
    } 
    return sum; 
} 

No estoy seguro de si es más rápido que eval(), pero como tengo que llevar a cabo la operación muchas veces me siento mucho más cómodo ejecutando este script que creando muchas instancias del compilador de JavaScript

Answer 2

Alguien tiene que analizar esa cadena. Si no es el intérprete (a través del eval), tendrá que ser usted quien escriba una rutina de análisis para extraer números, operadores y cualquier otra cosa que quiera apoyar en una expresión matemática.

Así que, no, no hay ninguna forma (simple) sin eval. Si le preocupa la seguridad (porque la entrada que está analizando no proviene de una fuente que usted controla), ¿tal vez puede verificar el formato de la entrada (a través de un filtro de expresión regular de la lista blanca) antes de pasarlo al eval?

Answer 3

// Usted puede hacer + o - fácil:

function addbits(s){ 
    var total= 0, s= s.match(/[+\-]*(\.\d+|\d+(\.\d+)?)/g) || []; 
    while(s.length){ 
     total+= parseFloat(s.shift()); 
    } 
    return total; 
} 

var string='1+23+4+5-30'; 
addbits(string) 

más complicado matemáticas hace eval más attractive- y ciertamente más fácil de escribir.

Answer 4

Recientemente lo hice en C# (no Eval() para nosotros ...) mediante la evaluación de la expresión en Notación Polaca Inversa (ese es el bit fácil). La parte difícil es en realidad analizar esta cadena y convertirla en Notación Polaca Inversa. Utilicé el algoritmo de Shunting Yard ya que hay un gran ejemplo en Wikipedia y un pseudocódigo. Me pareció muy fácil de implementar y lo recomendaría si aún no ha encontrado una solución o está buscando alternativas.

Answer 5

Puede utilizar el JavaScript Expression Evaluator library, lo que le permite hacer cosas como:

Parser.evaluate("2^x", { x: 3 }); 

O mathjs, que permite cosas como:

math.eval('sin(45 deg)^2'); 

terminé mathjs la elección de uno de mis proyectos .

Answer 6

Esta es una pequeña función que inventé hace un momento para resolver este problema: construye la expresión analizando la cadena un carácter a la vez (en realidad es bastante rápido). Esto tomará cualquier expresión matemática (limitada a +, -, *,/operadores solamente) y devolverá el resultado. También puede manejar valores negativos y operaciones de números ilimitados.

El único "por hacer" que queda es asegurarse de que calcula * &/before + & -. Agregaré esa funcionalidad más adelante, pero por ahora esto hace lo que necesito ...

/** 
* Evaluate a mathematical expression (as a string) and return the result 
* @param {String} expr A mathematical expression 
* @returns {Decimal} Result of the mathematical expression 
* @example 
* // Returns -81.4600 
* expr("10.04+9.5-1+-100"); 
*/ 
function expr (expr) { 

    var chars = expr.split(""); 
    var n = [], op = [], index = 0, oplast = true; 

    n[index] = ""; 

    // Parse the expression 
    for (var c = 0; c < chars.length; c++) { 

     if (isNaN(parseInt(chars[c])) && chars[c] !== "." && !oplast) { 
      op[index] = chars[c]; 
      index++; 
      n[index] = ""; 
      oplast = true; 
     } else { 
      n[index] += chars[c]; 
      oplast = false; 
     } 
    } 

    // Calculate the expression 
    expr = parseFloat(n[0]); 
    for (var o = 0; o < op.length; o++) { 
     var num = parseFloat(n[o + 1]); 
     switch (op[o]) { 
      case "+": 
       expr = expr + num; 
       break; 
      case "-": 
       expr = expr - num; 
       break; 
      case "*": 
       expr = expr * num; 
       break; 
      case "/": 
       expr = expr/num; 
       break; 
     } 
    } 

    return expr; 
} 

Answer 7

fui en busca de bibliotecas de JavaScript para evaluar expresiones matemáticas, y encontrado los dos candidatos prometedores:

• JavaScript Expression Evaluator: más pequeño y es de esperar más de peso ligero. Permite expresiones algebraicas, sustituciones y un número de funciones de .

• mathjs: Permite números complejos, matrices y unidades también. Creado para ser utilizado tanto por JavaScript dentro del navegador como por Node.js.

Answer 8

Creé BigEval para el mismo propósito.
Al resolver expresiones, realiza exactamente lo mismo que Eval() y admite operadores como%, ^, &, ** (alimentación) y! (factorial). También se le permite usar funciones y constantes (o decir variables) dentro de la expresión. La expresión se resuelve en PEMDAS order, que es común en lenguajes de programación, incluido JavaScript.

var Obj = new BigEval(); 
var result = Obj.exec("5! + 6.6e3 * (PI + E)"); // 38795.17158152233 
var result2 = Obj.exec("sin(45 * deg)**2 + cos(pi/4)**2"); // 1 
var result3 = Obj.exec("0 & -7^-7 - 0%1 + 6%2"); //-7 

También se pueden hacer para utilizar esas bibliotecas gran número de aritmética en caso de que se trata de números con precisión arbitraria.

Answer 9

Trate nerdamer

var result = nerdamer('12+2+PI').evaluate(); 
 
document.getElementById('text').innerHTML = result.text();

<script src="http://nerdamer.com/js/nerdamer.core.js"></script> 
 
<div id="text"></div>

Answer 10

Trate AutoCalculator valor https://github.com/JavscriptLab/autocalculate Calcular entradas y la salida Mediante el uso de expresiones de selector

Sólo añadir un atributo para su entrada una salida como datos-ac = "(# firstinput + # secondinput)"

No es necesario inicializar nada, solo agregue el atributo data-ac. Será averiguar elementos añadidos dinámicamente de forma automática

para 'R' add con salida sólo tiene que añadir el soporte interior rizado datos-ac = "{R} (# firstinput + # secondinput)"

Answer 11

Una alternativa a la excelente responder por @kennebec, utilizando una expresión regular más corto y que permite espacios entre operadores

function addbits(s) { 
    var total = 0; 
    s = s.replace(/\s/g, '').match(/[+\-]?([0-9\.\s]+)/g) || []; 
    while(s.length) total += parseFloat(s.shift()); 
    return total; 
} 

usarlo como

addbits('5 + 30 - 25.1 + 11'); 

actualización

Aquí hay una versión más optimizada

function addbits(s) { 
    return (s.replace(/\s/g, '').match(/[+\-]?([0-9\.]+)/g) || []) 
     .reduce(function(sum, value) { 
      return parseFloat(sum) + parseFloat(value); 
     }); 
} 

Answer 12

Creo que parseInt y ES6 puede ser útil en esta situación

==> de esta manera:

let func = (str) => { 
let arr = str.split(""); 
return `${Number(arr[0]) + parseInt(arr[1] + Number(arr[2]))}`}; 
console.log(func("1+1")); 

Lo principal aquí es que parseInt analiza el número con el operador. El código se puede modificar a las necesidades correspondientes.

Answer 13

Aquí hay una solución algorítmica similar a la de jMichael que recorre la expresión carácter por carácter y rastrea progresivamente hacia la izquierda/operador/derecha. La función acumula el resultado después de cada turno, encuentra un carácter de operador. Esta versión solo es compatible con los operadores '+' y '-', pero está escrita para ser extendida con otros operadores. Nota: establecemos 'currOp' en '+' antes de un bucle porque suponemos que la expresión comienza con un flotante positivo. De hecho, en general estoy asumiendo que la entrada es similar a lo que vendría de una calculadora.

function calculate(exp) { 
    const opMap = { 
    '+': (a, b) => { return parseFloat(a) + parseFloat(b) }, 
    '-': (a, b) => { return parseFloat(a) - parseFloat(b) }, 
    }; 
    const opList = Object.keys(opMap); 

    let acc = 0; 
    let next = ''; 
    let currOp = '+'; 

    for (let char of exp) { 
    if (opList.includes(char)) { 
     acc = opMap[currOp](acc, next); 
     currOp = char; 
     next = ''; 
    } else { 
     next += char; 
    } 
    } 

    return currOp === '+' ? acc + parseFloat(next) : acc - parseFloat(next); 
}