Cómo evaluar matemáticamente una cadena como "2-1" para producir "1"?

$operation='2-1';
eval("\$value = \"$operation\";");

O

$value=eval("return ($op);");

Este es uno de los casos en los que eval es útil:

$expression = '2 - 1';
eval( '$result = (' . $expression . ');' );
echo $result;

Puedes usar BC Math arbitrary precision

echo bcsub(5, 4); // 1
echo bcsub(1.234, 5); // 3
echo bcsub(1.234, 5, 4); // -3.7660

Http://www.php.net/manual/en/function.bcsub.php

En este foro alguien lo hizo sin eval. ¿Tal vez puedas intentarlo? Créditos para ellos, acabo de encontrarlo.

function calculate_string( $mathString )    {
    $mathString = trim($mathString);     // trim white spaces
    $mathString = ereg_replace ('[^0-9\+-\*\/\(\) ]', '', $mathString);    // remove any non-numbers chars; exception for math operators

    $compute = create_function("", "return (" . $mathString . ");" );
    return 0 + $compute();
}

$string = " (1 + 1) * (2 + 2)";
echo calculate_string($string);  // outputs 8  

También vea esta respuesta aquí: Evaluando una cadena de expresiones matemáticas simples

Tenga en cuenta que esta solución NO se ajusta a BODMAS, pero puede usar corchetes en su cadena de evaluación para superar esto.

function callback1($m) {
    return string_to_math($m[1]);
}
function callback2($n,$m) {
    $o=$m[0];
    $m[0]=' ';
    return $o=='+' ? $n+$m : ($o=='-' ? $n-$m : ($o=='*' ? $n*$m : $n/$m));
}
function string_to_math($s){ 
    while ($s != ($t = preg_replace_callback('/\(([^()]*)\)/','callback1',$s))) $s=$t;
    preg_match_all('![-+/*].*?[\d.]+!', "+$s", $m);
    return array_reduce($m[0], 'callback2');
}
echo string_to_match('2-1'); //returns 1

Aquí hay un poco detallado de código que rodé para otra pregunta SO. Se ajusta a BO MDAS sin eval(), pero no está equipado para hacer expresiones complejas/de orden superior/entre paréntesis. Este enfoque libre de bibliotecas separa la expresión y reduce sistemáticamente la matriz de componentes hasta que se eliminan todos los operadores. Ciertamente funciona para su expresión de muestra: 2-1 ;)

1. preg_match() comprueba que cada operador tiene un valor numérico subcadena a cada lado.
2. preg_split() divide la cadena en una matriz de números y operadores alternos.
3. array_search() encuentra el índice del operador de destino, mientras que existe en la matriz.
4. array_splice() reemplaza el elemento operador y los elementos a cada lado de él con un nuevo elemento que contiene el resultado matemático de los tres elementos eliminados.

* * actualizado para permitir números negativos * *

Código: ( Demo )

$expression="-11+3*1*4/-6-12";
if(!preg_match('~^-?\d*\.?\d+([*/+-]-?\d*\.?\d+)*$~',$expression)){
    echo "invalid expression";
}else{
    $components=preg_split('~(?<=\d)([*/+-])~',$expression,NULL,PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
    var_export($components);  // ['-11','+','3','*','1','*','4','/','-6','-','12']
    while(($index=array_search('*',$components))!==false){
        array_splice($components,$index-1,3,$components[$index-1]*$components[$index+1]);
        var_export($components);
        // ['-11','+','3','*','4','/','-6','-','12']
        // ['-11','+','12','/','-6','-','12']
    }
    while(($index=array_search('/',$components))!==false){
        array_splice($components,$index-1,3,$components[$index-1]/$components[$index+1]);
        var_export($components);  // [-'11','+','-2','-','12']
    }
    while(($index=array_search('+',$components))!==false){
        array_splice($components,$index-1,3,$components[$index-1]+$components[$index+1]);
        var_export($components);  // ['-13','-','12']
    }
    while(($index=array_search('-',$components))!==false){
        array_splice($components,$index-1,3,$components[$index-1]-$components[$index+1]);
        var_export($components); // [-25]
    }
    echo current($components);  // -25
}

Aquí es una demostración de la B versión OMDAS que usa php pow() cuando ^ se encuentra entre dos números (positivo o negativo).

Creo que nunca me molestaré en escribir una versión que maneje expresiones entre paréntesis ... pero veremos cómo me aburro.