Попробуйте 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>

Я создал BigEval для этой же цели. При решении выражений он выполняет точно такие же, как Eval(), и поддерживает такие операторы, как%, ^, & amp ;, ** (мощность) и! (факториал). Вы также можете использовать функции и константы (или сказать переменные) внутри выражения. Выражение решается в порядке PEMDAS , который является общим для языков программирования, включая 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

Также можно использовать библиотеки Big Number для арифметики, если вы имея дело с числами с произвольной точностью.

Я считаю, что parseInt и ES6 могут быть полезны в этой ситуации

==> следующим образом:

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

Основной Дело в том, что parseInt анализирует число с оператором. Код может быть изменен с учетом соответствующих потребностей.

Кто-то должен разобрать эту строку. Если это не интерпретатор (через eval), то это должен быть вам, написание процедуры разбора для извлечения чисел, операторов и всего, что вы хотите поддержать в математическом выражении.

So , нет, нет (простого) пути без eval. Если вы беспокоитесь о безопасности (потому что ввод, который вы обрабатываете, не из источника, которым вы управляете), возможно, вы можете проверить формат ввода (через белый фильтр регулярных выражений), прежде чем передавать его на eval?

Вот алгоритмическое решение, подобное jMichael, которое циклически перемещает символ выражения по символу и постепенно отслеживает left / operator / right. Функция накапливает результат после каждого поворота, который находит символ оператора. Эта версия поддерживает только операторы «+» и «-», но записывается для расширения с другими операторами. Примечание: перед циклом мы устанавливаем 'currOp' в '+', потому что предположим, что выражение начинается с положительного поплавка. Фактически, в целом, я делаю предположение, что ввод аналогичен тому, что исходит от калькулятора.

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

Я пошел искать библиотеки JavaScript для оценки математических выражений и нашел этих двух перспективных кандидатов:

• JavaScript Expression Evaluator : Меньше и, надеюсь, более легкий. Позволяет алгебраические выражения, подстановки и ряд функций.
• mathjs : Позволяет создавать комплексные числа, матрицы и единицы.

Это небольшая функция, которую я собрал сейчас, чтобы решить эту проблему - она ​​создает выражение, анализируя строку по одному персонажу за раз (на самом деле это довольно быстро). Это займет какое-либо математическое выражение (ограничивается только +, -, *, / операторами) и возвращает результат. Он также может обрабатывать отрицательные значения и операции с неограниченным числом.

Единственное, что нужно сделать, это убедиться, что он вычисляет * & amp; / до + & amp; -. Добавит эту функциональность позже, но пока это делает то, что мне нужно ...

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

Попробуйте AutoCalculator https://github.com/JavscriptLab/autocalculate Вычислить значение входов и вывод с помощью селекторных выражений

Просто добавьте атрибут для ввода вывода, ac = "(# firstinput + # secondinput)"

Нет необходимости в какой-либо инициализации, просто добавьте только атрибут data-ac. Он будет автоматически обнаруживать динамически добавленные элементы

FOr add 'Rs' с выходом только добавить внутри фигурных скобок данных-ac = "{Rs} (# firstinput + # secondinput)"

// Вы можете делать + или - легко:

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)

Более сложная математика делает eval более привлекательной и, конечно, проще писать.

Вы можете использовать библиотеку JavaScript Expression Evaluator , которая позволяет вам делать такие вещи, как:

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

Или mathjs , что позволяет например:

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

Я решил выбрать mathjs для одного из моих проектов.

Я недавно сделал это в C # (без Eval () для нас ...), оценив выражение в Reverse Polish Notation (это легкий бит). Трудная часть на самом деле разбирает строку и превращает ее в обратную польскую нотацию. Я использовал алгоритм Shunting Yard, потому что есть отличный пример в Википедии и псевдокоде. Мне было очень просто реализовать оба варианта, и я бы рекомендовал, если вы еще не нашли решение или смотрите на альтернативы.

const getAddition = (str) => {
  return str.split('+').reduce((total, num) => (total + num * 1), 0);
};

const addition = getAddition('1+1');

сложение равно 2.

Альтернатива отличному ответу @kennebec, используя более короткое регулярное выражение и позволяющее пробелы между операторами

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

Использовать его как

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

Обновить

Вот более оптимизированная версия

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